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 exit $EXIT_SUCCESS 2718} 2719 2720test "$opt_mode" = finish && func_mode_finish ${1+"$@"} 2721 2722 2723# func_mode_install arg... 2724func_mode_install () 2725{ 2726 $opt_debug 2727 # There may be an optional sh(1) argument at the beginning of 2728 # install_prog (especially on Windows NT). 2729 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || 2730 # Allow the use of GNU shtool's install command. 2731 case $nonopt in *shtool*) :;; *) false;; esac; then 2732 # Aesthetically quote it. 2733 func_quote_for_eval "$nonopt" 2734 install_prog="$func_quote_for_eval_result " 2735 arg=$1 2736 shift 2737 else 2738 install_prog= 2739 arg=$nonopt 2740 fi 2741 2742 # The real first argument should be the name of the installation program. 2743 # Aesthetically quote it. 2744 func_quote_for_eval "$arg" 2745 func_append install_prog "$func_quote_for_eval_result" 2746 install_shared_prog=$install_prog 2747 case " $install_prog " in 2748 *[\\\ /]cp\ *) install_cp=: ;; 2749 *) install_cp=false ;; 2750 esac 2751 2752 # We need to accept at least all the BSD install flags. 2753 dest= 2754 files= 2755 opts= 2756 prev= 2757 install_type= 2758 isdir=no 2759 stripme= 2760 no_mode=: 2761 for arg 2762 do 2763 arg2= 2764 if test -n "$dest"; then 2765 func_append files " $dest" 2766 dest=$arg 2767 continue 2768 fi 2769 2770 case $arg in 2771 -d) isdir=yes ;; 2772 -f) 2773 if $install_cp; then :; else 2774 prev=$arg 2775 fi 2776 ;; 2777 -g | -m | -o) 2778 prev=$arg 2779 ;; 2780 -s) 2781 stripme=" -s" 2782 continue 2783 ;; 2784 -*) 2785 ;; 2786 *) 2787 # If the previous option needed an argument, then skip it. 2788 if test -n "$prev"; then 2789 if test "x$prev" = x-m && test -n "$install_override_mode"; then 2790 arg2=$install_override_mode 2791 no_mode=false 2792 fi 2793 prev= 2794 else 2795 dest=$arg 2796 continue 2797 fi 2798 ;; 2799 esac 2800 2801 # Aesthetically quote the argument. 2802 func_quote_for_eval "$arg" 2803 func_append install_prog " $func_quote_for_eval_result" 2804 if test -n "$arg2"; then 2805 func_quote_for_eval "$arg2" 2806 fi 2807 func_append install_shared_prog " $func_quote_for_eval_result" 2808 done 2809 case " $install_prog " in 2810 *[\\\ /]cp\ *) extra_mode=;; 2811 *) extra_mode='-m 644';; 2812 esac 2813 2814 test -z "$install_prog" && \ 2815 func_fatal_help "you must specify an install program" 2816 2817 test -n "$prev" && \ 2818 func_fatal_help "the \`$prev' option requires an argument" 2819 2820 if test -n "$install_override_mode" && $no_mode; then 2821 if $install_cp; then :; else 2822 func_quote_for_eval "$install_override_mode" 2823 func_append install_shared_prog " -m $func_quote_for_eval_result" 2824 fi 2825 fi 2826 2827 if test -z "$files"; then 2828 if test -z "$dest"; then 2829 func_fatal_help "no file or destination specified" 2830 else 2831 func_fatal_help "you must specify a destination" 2832 fi 2833 fi 2834 2835 # Strip any trailing slash from the destination. 2836 func_stripname '' '/' "$dest" 2837 dest=$func_stripname_result 2838 2839 # Check to see that the destination is a directory. 2840 test -d "$dest" && isdir=yes 2841 if test "$isdir" = yes; then 2842 destdir="$dest" 2843 destname= 2844 else 2845 func_dirname_and_basename "$dest" "" "." 2846 destdir="$func_dirname_result" 2847 destname="$func_basename_result" 2848 2849 # Not a directory, so check to see that there is only one file specified. 2850 set dummy $files; shift 2851 test "$#" -gt 1 && \ 2852 func_fatal_help "\`$dest' is not a directory" 2853 fi 2854 case $destdir in 2855 [\\/]* | [A-Za-z]:[\\/]*) ;; 2856 *) 2857 for file in $files; do 2858 case $file in 2859 *.lo) ;; 2860 *) 2861 func_fatal_help "\`$destdir' must be an absolute directory name" 2862 ;; 2863 esac 2864 done 2865 ;; 2866 esac 2867 2868 # This variable tells wrapper scripts just to set variables rather 2869 # than running their programs. 2870 libtool_install_magic="$magic" 2871 2872 staticlibs= 2873 future_libdirs= 2874 current_libdirs= 2875 for file in $files; do 2876 2877 # Do each installation. 2878 case $file in 2879 *.$libext) 2880 # Do the static libraries later. 2881 func_append staticlibs " $file" 2882 ;; 2883 2884 *.la) 2885 func_resolve_sysroot "$file" 2886 file=$func_resolve_sysroot_result 2887 2888 # Check to see that this really is a libtool archive. 2889 func_lalib_unsafe_p "$file" \ 2890 || func_fatal_help "\`$file' is not a valid libtool archive" 2891 2892 library_names= 2893 old_library= 2894 relink_command= 2895 func_source "$file" 2896 2897 # Add the libdir to current_libdirs if it is the destination. 2898 if test "X$destdir" = "X$libdir"; then 2899 case "$current_libdirs " in 2900 *" $libdir "*) ;; 2901 *) func_append current_libdirs " $libdir" ;; 2902 esac 2903 else 2904 # Note the libdir as a future libdir. 2905 case "$future_libdirs " in 2906 *" $libdir "*) ;; 2907 *) func_append future_libdirs " $libdir" ;; 2908 esac 2909 fi 2910 2911 func_dirname "$file" "/" "" 2912 dir="$func_dirname_result" 2913 func_append dir "$objdir" 2914 2915 if test -n "$relink_command"; then 2916 # Determine the prefix the user has applied to our future dir. 2917 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` 2918 2919 # Don't allow the user to place us outside of our expected 2920 # location b/c this prevents finding dependent libraries that 2921 # are installed to the same prefix. 2922 # At present, this check doesn't affect windows .dll's that 2923 # are installed into $libdir/../bin (currently, that works fine) 2924 # but it's something to keep an eye on. 2925 test "$inst_prefix_dir" = "$destdir" && \ 2926 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" 2927 2928 if test -n "$inst_prefix_dir"; then 2929 # Stick the inst_prefix_dir data into the link command. 2930 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` 2931 else 2932 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` 2933 fi 2934 2935 func_warning "relinking \`$file'" 2936 func_show_eval "$relink_command" \ 2937 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' 2938 fi 2939 2940 # See the names of the shared library. 2941 set dummy $library_names; shift 2942 if test -n "$1"; then 2943 realname="$1" 2944 shift 2945 2946 srcname="$realname" 2947 test -n "$relink_command" && srcname="$realname"T 2948 2949 # Install the shared library and build the symlinks. 2950 func_show_eval "$install_shared_prog $extra_mode $dir/$srcname $destdir/$realname" \ 2951 'exit $?' 2952 tstripme="$stripme" 2953 case $host_os in 2954 cygwin* | mingw* | pw32* | cegcc*) 2955 case $realname in 2956 *.dll.a) 2957 tstripme="" 2958 ;; 2959 esac 2960 ;; 2961 esac 2962 if test -n "$tstripme" && test -n "$striplib"; then 2963 func_show_eval "$striplib $destdir/$realname" 'exit $?' 2964 fi 2965 2966 if test "$#" -gt 0; then 2967 # Delete the old symlinks, and create new ones. 2968 # Try `ln -sf' first, because the `ln' binary might depend on 2969 # the symlink we replace! Solaris /bin/ln does not understand -f, 2970 # so we also need to try rm && ln -s. 2971 for linkname 2972 do 2973 test "$linkname" != "$realname" \ 2974 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" 2975 done 2976 fi 2977 2978 # Do each command in the postinstall commands. 2979 lib="$destdir/$realname" 2980 func_execute_cmds "$postinstall_cmds" 'exit $?' 2981 fi 2982 2983 # Install the pseudo-library for information purposes. 2984 func_basename "$file" 2985 name="$func_basename_result" 2986 instname="$dir/$name"i 2987 func_show_eval "$install_prog $extra_mode $instname $destdir/$name" 'exit $?' 2988 2989 # Maybe install the static library, too. 2990 test -n "$old_library" && func_append staticlibs " $dir/$old_library" 2991 ;; 2992 2993 *.lo) 2994 # Install (i.e. copy) a libtool object. 2995 2996 # Figure out destination file name, if it wasn't already specified. 2997 if test -n "$destname"; then 2998 destfile="$destdir/$destname" 2999 else 3000 func_basename "$file" 3001 destfile="$func_basename_result" 3002 destfile="$destdir/$destfile" 3003 fi 3004 3005 # Deduce the name of the destination old-style object file. 3006 case $destfile in 3007 *.lo) 3008 func_lo2o "$destfile" 3009 staticdest=$func_lo2o_result 3010 ;; 3011 *.$objext) 3012 staticdest="$destfile" 3013 destfile= 3014 ;; 3015 *) 3016 func_fatal_help "cannot copy a libtool object to \`$destfile'" 3017 ;; 3018 esac 3019 3020 # Install the libtool object if requested. 3021 test -n "$destfile" && \ 3022 func_show_eval "$install_prog $extra_mode $file $destfile" 'exit $?' 3023 3024 # Install the old object if enabled. 3025 if test "$build_old_libs" = yes; then 3026 # Deduce the name of the old-style object file. 3027 func_lo2o "$file" 3028 staticobj=$func_lo2o_result 3029 func_show_eval "$install_prog $extra_mode \$staticobj \$staticdest" 'exit $?' 3030 fi 3031 exit $EXIT_SUCCESS 3032 ;; 3033 3034 *) 3035 # Figure out destination file name, if it wasn't already specified. 3036 if test -n "$destname"; then 3037 destfile="$destdir/$destname" 3038 else 3039 func_basename "$file" 3040 destfile="$func_basename_result" 3041 destfile="$destdir/$destfile" 3042 fi 3043 3044 # If the file is missing, and there is a .exe on the end, strip it 3045 # because it is most likely a libtool script we actually want to 3046 # install 3047 stripped_ext="" 3048 case $file in 3049 *.exe) 3050 if test ! -f "$file"; then 3051 func_stripname '' '.exe' "$file" 3052 file=$func_stripname_result 3053 stripped_ext=".exe" 3054 fi 3055 ;; 3056 esac 3057 3058 # Do a test to see if this is really a libtool program. 3059 case $host in 3060 *cygwin* | *mingw*) 3061 if func_ltwrapper_executable_p "$file"; then 3062 func_ltwrapper_scriptname "$file" 3063 wrapper=$func_ltwrapper_scriptname_result 3064 else 3065 func_stripname '' '.exe' "$file" 3066 wrapper=$func_stripname_result 3067 fi 3068 ;; 3069 *) 3070 wrapper=$file 3071 ;; 3072 esac 3073 if func_ltwrapper_script_p "$wrapper"; then 3074 notinst_deplibs= 3075 relink_command= 3076 3077 func_source "$wrapper" 3078 3079 # Check the variables that should have been set. 3080 test -z "$generated_by_libtool_version" && \ 3081 func_fatal_error "invalid libtool wrapper script \`$wrapper'" 3082 3083 finalize=yes 3084 for lib in $notinst_deplibs; do 3085 # Check to see that each library is installed. 3086 libdir= 3087 if test -f "$lib"; then 3088 func_source "$lib" 3089 fi 3090 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test 3091 if test -n "$libdir" && test ! -f "$libfile"; then 3092 func_warning "\`$lib' has not been installed in \`$libdir'" 3093 finalize=no 3094 fi 3095 done 3096 3097 relink_command= 3098 func_source "$wrapper" 3099 3100 outputname= 3101 if test "$fast_install" = no && test -n "$relink_command"; then 3102 $opt_dry_run || { 3103 if test "$finalize" = yes; then 3104 tmpdir=`func_mktempdir` 3105 func_basename "$file$stripped_ext" 3106 file="$func_basename_result" 3107 outputname="$tmpdir/$file" 3108 # Replace the output file specification. 3109 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` 3110 3111 $opt_silent || { 3112 func_quote_for_expand "$relink_command" 3113 eval "func_echo $func_quote_for_expand_result" 3114 } 3115 if eval "$relink_command"; then : 3116 else 3117 func_error "error: relink \`$file' with the above command before installing it" 3118 $opt_dry_run || ${RM}r "$tmpdir" 3119 continue 3120 fi 3121 file="$outputname" 3122 else 3123 func_warning "cannot relink \`$file'" 3124 fi 3125 } 3126 else 3127 # Install the binary that we compiled earlier. 3128 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` 3129 fi 3130 fi 3131 3132 # remove .exe since cygwin /usr/bin/install will append another 3133 # one anyway 3134 case $install_prog,$host in 3135 */usr/bin/install*,*cygwin*) 3136 case $file:$destfile in 3137 *.exe:*.exe) 3138 # this is ok 3139 ;; 3140 *.exe:*) 3141 destfile=$destfile.exe 3142 ;; 3143 *:*.exe) 3144 func_stripname '' '.exe' "$destfile" 3145 destfile=$func_stripname_result 3146 ;; 3147 esac 3148 ;; 3149 esac 3150 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' 3151 $opt_dry_run || if test -n "$outputname"; then 3152 ${RM}r "$tmpdir" 3153 fi 3154 ;; 3155 esac 3156 done 3157 3158 for file in $staticlibs; do 3159 func_basename "$file" 3160 name="$func_basename_result" 3161 3162 # Set up the ranlib parameters. 3163 oldlib="$destdir/$name" 3164 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 3165 tool_oldlib=$func_to_tool_file_result 3166 3167 func_show_eval "$install_prog \$file \$oldlib" 'exit $?' 3168 3169 if test -n "$stripme" && test -n "$old_striplib"; then 3170 func_show_eval "$old_striplib $tool_oldlib" 'exit $?' 3171 fi 3172 3173 # Do each command in the postinstall commands. 3174 func_execute_cmds "$old_postinstall_cmds" 'exit $?' 3175 done 3176 3177 test -n "$future_libdirs" && \ 3178 func_warning "remember to run \`$progname --finish$future_libdirs'" 3179 3180 if test -n "$current_libdirs"; then 3181 # Maybe just do a dry run. 3182 $opt_dry_run && current_libdirs=" -n$current_libdirs" 3183 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' 3184 else 3185 exit $EXIT_SUCCESS 3186 fi 3187} 3188 3189test "$opt_mode" = install && func_mode_install ${1+"$@"} 3190 3191 3192# func_generate_dlsyms outputname originator pic_p 3193# Extract symbols from dlprefiles and create ${outputname}S.o with 3194# a dlpreopen symbol table. 3195func_generate_dlsyms () 3196{ 3197 $opt_debug 3198 my_outputname="$1" 3199 my_originator="$2" 3200 my_pic_p="${3-no}" 3201 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` 3202 my_dlsyms= 3203 3204 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 3205 if test -n "$NM" && test -n "$global_symbol_pipe"; then 3206 my_dlsyms="${my_outputname}S.c" 3207 else 3208 func_error "not configured to extract global symbols from dlpreopened files" 3209 fi 3210 fi 3211 3212 if test -n "$my_dlsyms"; then 3213 case $my_dlsyms in 3214 "") ;; 3215 *.c) 3216 # Discover the nlist of each of the dlfiles. 3217 nlist="$output_objdir/${my_outputname}.nm" 3218 3219 func_show_eval "$RM $nlist ${nlist}S ${nlist}T" 3220 3221 # Parse the name list into a source file. 3222 func_verbose "creating $output_objdir/$my_dlsyms" 3223 3224 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ 3225/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ 3226/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ 3227 3228#ifdef __cplusplus 3229extern \"C\" { 3230#endif 3231 3232#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) 3233#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" 3234#endif 3235 3236/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ 3237#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) 3238/* DATA imports from DLLs on WIN32 con't be const, because runtime 3239 relocations are performed -- see ld's documentation on pseudo-relocs. */ 3240# define LT_DLSYM_CONST 3241#elif defined(__osf__) 3242/* This system does not cope well with relocations in const data. */ 3243# define LT_DLSYM_CONST 3244#else 3245# define LT_DLSYM_CONST const 3246#endif 3247 3248/* External symbol declarations for the compiler. */\ 3249" 3250 3251 if test "$dlself" = yes; then 3252 func_verbose "generating symbol list for \`$output'" 3253 3254 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" 3255 3256 # Add our own program objects to the symbol list. 3257 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` 3258 for progfile in $progfiles; do 3259 func_to_tool_file "$progfile" func_convert_file_msys_to_w32 3260 func_verbose "extracting global C symbols from \`$func_to_tool_file_result'" 3261 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" 3262 done 3263 3264 if test -n "$exclude_expsyms"; then 3265 $opt_dry_run || { 3266 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' 3267 eval '$MV "$nlist"T "$nlist"' 3268 } 3269 fi 3270 3271 if test -n "$export_symbols_regex"; then 3272 $opt_dry_run || { 3273 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' 3274 eval '$MV "$nlist"T "$nlist"' 3275 } 3276 fi 3277 3278 # Prepare the list of exported symbols 3279 if test -z "$export_symbols"; then 3280 export_symbols="$output_objdir/$outputname.exp" 3281 $opt_dry_run || { 3282 $RM $export_symbols 3283 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' 3284 case $host in 3285 *cygwin* | *mingw* | *cegcc* ) 3286 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' 3287 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' 3288 ;; 3289 esac 3290 } 3291 else 3292 $opt_dry_run || { 3293 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' 3294 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' 3295 eval '$MV "$nlist"T "$nlist"' 3296 case $host in 3297 *cygwin* | *mingw* | *cegcc* ) 3298 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' 3299 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' 3300 ;; 3301 esac 3302 } 3303 fi 3304 fi 3305 3306 for dlprefile in $dlprefiles; do 3307 func_verbose "extracting global C symbols from \`$dlprefile'" 3308 func_basename "$dlprefile" 3309 name="$func_basename_result" 3310 case $host in 3311 *cygwin* | *mingw* | *cegcc* ) 3312 # if an import library, we need to obtain dlname 3313 if func_win32_import_lib_p "$dlprefile"; then 3314 func_tr_sh "$dlprefile" 3315 eval "curr_lafile=\$libfile_$func_tr_sh_result" 3316 dlprefile_dlbasename="" 3317 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then 3318 # Use subshell, to avoid clobbering current variable values 3319 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` 3320 if test -n "$dlprefile_dlname" ; then 3321 func_basename "$dlprefile_dlname" 3322 dlprefile_dlbasename="$func_basename_result" 3323 else 3324 # no lafile. user explicitly requested -dlpreopen <import library>. 3325 $sharedlib_from_linklib_cmd "$dlprefile" 3326 dlprefile_dlbasename=$sharedlib_from_linklib_result 3327 fi 3328 fi 3329 $opt_dry_run || { 3330 if test -n "$dlprefile_dlbasename" ; then 3331 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' 3332 else 3333 func_warning "Could not compute DLL name from $name" 3334 eval '$ECHO ": $name " >> "$nlist"' 3335 fi 3336 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 3337 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | 3338 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" 3339 } 3340 else # not an import lib 3341 $opt_dry_run || { 3342 eval '$ECHO ": $name " >> "$nlist"' 3343 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 3344 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" 3345 } 3346 fi 3347 ;; 3348 *) 3349 $opt_dry_run || { 3350 eval '$ECHO ": $name " >> "$nlist"' 3351 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 3352 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" 3353 } 3354 ;; 3355 esac 3356 done 3357 3358 $opt_dry_run || { 3359 # Make sure we have at least an empty file. 3360 test -f "$nlist" || : > "$nlist" 3361 3362 if test -n "$exclude_expsyms"; then 3363 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T 3364 $MV "$nlist"T "$nlist" 3365 fi 3366 3367 # Try sorting and uniquifying the output. 3368 if $GREP -v "^: " < "$nlist" | 3369 if sort -k 3 </dev/null >/dev/null 2>&1; then 3370 sort -k 3 3371 else 3372 sort +2 3373 fi | 3374 uniq > "$nlist"S; then 3375 : 3376 else 3377 $GREP -v "^: " < "$nlist" > "$nlist"S 3378 fi 3379 3380 if test -f "$nlist"S; then 3381 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' 3382 else 3383 echo '/* NONE */' >> "$output_objdir/$my_dlsyms" 3384 fi 3385 3386 echo >> "$output_objdir/$my_dlsyms" "\ 3387 3388/* The mapping between symbol names and symbols. */ 3389typedef struct { 3390 const char *name; 3391 void *address; 3392} lt_dlsymlist; 3393extern LT_DLSYM_CONST lt_dlsymlist 3394lt_${my_prefix}_LTX_preloaded_symbols[]; 3395LT_DLSYM_CONST lt_dlsymlist 3396lt_${my_prefix}_LTX_preloaded_symbols[] = 3397{\ 3398 { \"$my_originator\", (void *) 0 }," 3399 3400 case $need_lib_prefix in 3401 no) 3402 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" 3403 ;; 3404 *) 3405 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" 3406 ;; 3407 esac 3408 echo >> "$output_objdir/$my_dlsyms" "\ 3409 {0, (void *) 0} 3410}; 3411 3412/* This works around a problem in FreeBSD linker */ 3413#ifdef FREEBSD_WORKAROUND 3414static const void *lt_preloaded_setup() { 3415 return lt_${my_prefix}_LTX_preloaded_symbols; 3416} 3417#endif 3418 3419#ifdef __cplusplus 3420} 3421#endif\ 3422" 3423 } # !$opt_dry_run 3424 3425 pic_flag_for_symtable= 3426 case "$compile_command " in 3427 *" -static "*) ;; 3428 *) 3429 case $host in 3430 # compiling the symbol table file with pic_flag works around 3431 # a FreeBSD bug that causes programs to crash when -lm is 3432 # linked before any other PIC object. But we must not use 3433 # pic_flag when linking with -static. The problem exists in 3434 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. 3435 *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) 3436 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; 3437 *-*-hpux*) 3438 pic_flag_for_symtable=" $pic_flag" ;; 3439 *) 3440 if test "X$my_pic_p" != Xno; then 3441 pic_flag_for_symtable=" $pic_flag" 3442 fi 3443 ;; 3444 esac 3445 ;; 3446 esac 3447 symtab_cflags= 3448 for arg in $LTCFLAGS; do 3449 case $arg in 3450 -pie | -fpie | -fPIE) ;; 3451 *) func_append symtab_cflags " $arg" ;; 3452 esac 3453 done 3454 3455 # Now compile the dynamic symbol file. 3456 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' 3457 3458 # Clean up the generated files. 3459 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' 3460 3461 # Transform the symbol file into the correct name. 3462 symfileobj="$output_objdir/${my_outputname}S.$objext" 3463 case $host in 3464 *cygwin* | *mingw* | *cegcc* ) 3465 if test -f "$output_objdir/$my_outputname.def"; then 3466 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` 3467 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` 3468 else 3469 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` 3470 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` 3471 fi 3472 ;; 3473 *) 3474 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` 3475 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` 3476 ;; 3477 esac 3478 ;; 3479 *) 3480 func_fatal_error "unknown suffix for \`$my_dlsyms'" 3481 ;; 3482 esac 3483 else 3484 # We keep going just in case the user didn't refer to 3485 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe 3486 # really was required. 3487 3488 # Nullify the symbol file. 3489 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` 3490 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` 3491 fi 3492} 3493 3494# func_win32_libid arg 3495# return the library type of file 'arg' 3496# 3497# Need a lot of goo to handle *both* DLLs and import libs 3498# Has to be a shell function in order to 'eat' the argument 3499# that is supplied when $file_magic_command is called. 3500# Despite the name, also deal with 64 bit binaries. 3501func_win32_libid () 3502{ 3503 $opt_debug 3504 win32_libid_type="unknown" 3505 win32_fileres=`file -L $1 2>/dev/null` 3506 case $win32_fileres in 3507 *ar\ archive\ import\ library*) # definitely import 3508 win32_libid_type="x86 archive import" 3509 ;; 3510 *ar\ archive*) # could be an import, or static 3511 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. 3512 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | 3513 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then 3514 func_to_tool_file "$1" func_convert_file_msys_to_w32 3515 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | 3516 $SED -n -e ' 3517 1,100{ 3518 / I /{ 3519 s,.*,import, 3520 p 3521 q 3522 } 3523 }'` 3524 case $win32_nmres in 3525 import*) win32_libid_type="x86 archive import";; 3526 *) win32_libid_type="x86 archive static";; 3527 esac 3528 fi 3529 ;; 3530 *DLL*) 3531 win32_libid_type="x86 DLL" 3532 ;; 3533 *executable*) # but shell scripts are "executable" too... 3534 case $win32_fileres in 3535 *MS\ Windows\ PE\ Intel*) 3536 win32_libid_type="x86 DLL" 3537 ;; 3538 esac 3539 ;; 3540 esac 3541 $ECHO "$win32_libid_type" 3542} 3543 3544# func_cygming_dll_for_implib ARG 3545# 3546# Platform-specific function to extract the 3547# name of the DLL associated with the specified 3548# import library ARG. 3549# Invoked by eval'ing the libtool variable 3550# $sharedlib_from_linklib_cmd 3551# Result is available in the variable 3552# $sharedlib_from_linklib_result 3553func_cygming_dll_for_implib () 3554{ 3555 $opt_debug 3556 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` 3557} 3558 3559# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs 3560# 3561# The is the core of a fallback implementation of a 3562# platform-specific function to extract the name of the 3563# DLL associated with the specified import library LIBNAME. 3564# 3565# SECTION_NAME is either .idata$6 or .idata$7, depending 3566# on the platform and compiler that created the implib. 3567# 3568# Echos the name of the DLL associated with the 3569# specified import library. 3570func_cygming_dll_for_implib_fallback_core () 3571{ 3572 $opt_debug 3573 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` 3574 $OBJDUMP -s --section "$1" "$2" 2>/dev/null | 3575 $SED '/^Contents of section '"$match_literal"':/{ 3576 # Place marker at beginning of archive member dllname section 3577 s/.*/====MARK====/ 3578 p 3579 d 3580 } 3581 # These lines can sometimes be longer than 43 characters, but 3582 # are always uninteresting 3583 /:[ ]*file format pe[i]\{,1\}-/d 3584 /^In archive [^:]*:/d 3585 # Ensure marker is printed 3586 /^====MARK====/p 3587 # Remove all lines with less than 43 characters 3588 /^.\{43\}/!d 3589 # From remaining lines, remove first 43 characters 3590 s/^.\{43\}//' | 3591 $SED -n ' 3592 # Join marker and all lines until next marker into a single line 3593 /^====MARK====/ b para 3594 H 3595 $ b para 3596 b 3597 :para 3598 x 3599 s/\n//g 3600 # Remove the marker 3601 s/^====MARK====// 3602 # Remove trailing dots and whitespace 3603 s/[\. \t]*$// 3604 # Print 3605 /./p' | 3606 # we now have a list, one entry per line, of the stringified 3607 # contents of the appropriate section of all members of the 3608 # archive which possess that section. Heuristic: eliminate 3609 # all those which have a first or second character that is 3610 # a '.' (that is, objdump's representation of an unprintable 3611 # character.) This should work for all archives with less than 3612 # 0x302f exports -- but will fail for DLLs whose name actually 3613 # begins with a literal '.' or a single character followed by 3614 # a '.'. 3615 # 3616 # Of those that remain, print the first one. 3617 $SED -e '/^\./d;/^.\./d;q' 3618} 3619 3620# func_cygming_gnu_implib_p ARG 3621# This predicate returns with zero status (TRUE) if 3622# ARG is a GNU/binutils-style import library. Returns 3623# with nonzero status (FALSE) otherwise. 3624func_cygming_gnu_implib_p () 3625{ 3626 $opt_debug 3627 func_to_tool_file "$1" func_convert_file_msys_to_w32 3628 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)$'` 3629 test -n "$func_cygming_gnu_implib_tmp" 3630} 3631 3632# func_cygming_ms_implib_p ARG 3633# This predicate returns with zero status (TRUE) if 3634# ARG is an MS-style import library. Returns 3635# with nonzero status (FALSE) otherwise. 3636func_cygming_ms_implib_p () 3637{ 3638 $opt_debug 3639 func_to_tool_file "$1" func_convert_file_msys_to_w32 3640 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` 3641 test -n "$func_cygming_ms_implib_tmp" 3642} 3643 3644# func_cygming_dll_for_implib_fallback ARG 3645# Platform-specific function to extract the 3646# name of the DLL associated with the specified 3647# import library ARG. 3648# 3649# This fallback implementation is for use when $DLLTOOL 3650# does not support the --identify-strict option. 3651# Invoked by eval'ing the libtool variable 3652# $sharedlib_from_linklib_cmd 3653# Result is available in the variable 3654# $sharedlib_from_linklib_result 3655func_cygming_dll_for_implib_fallback () 3656{ 3657 $opt_debug 3658 if func_cygming_gnu_implib_p "$1" ; then 3659 # binutils import library 3660 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` 3661 elif func_cygming_ms_implib_p "$1" ; then 3662 # ms-generated import library 3663 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` 3664 else 3665 # unknown 3666 sharedlib_from_linklib_result="" 3667 fi 3668} 3669 3670 3671# func_extract_an_archive dir oldlib 3672func_extract_an_archive () 3673{ 3674 $opt_debug 3675 f_ex_an_ar_dir="$1"; shift 3676 f_ex_an_ar_oldlib="$1" 3677 if test "$lock_old_archive_extraction" = yes; then 3678 lockfile=$f_ex_an_ar_oldlib.lock 3679 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do 3680 func_echo "Waiting for $lockfile to be removed" 3681 sleep 2 3682 done 3683 fi 3684 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ 3685 'stat=$?; rm -f "$lockfile"; exit $stat' 3686 if test "$lock_old_archive_extraction" = yes; then 3687 $opt_dry_run || rm -f "$lockfile" 3688 fi 3689 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then 3690 : 3691 else 3692 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 3693 fi 3694} 3695 3696 3697# func_extract_archives gentop oldlib ... 3698func_extract_archives () 3699{ 3700 $opt_debug 3701 my_gentop="$1"; shift 3702 my_oldlibs=${1+"$@"} 3703 my_oldobjs="" 3704 my_xlib="" 3705 my_xabs="" 3706 my_xdir="" 3707 3708 for my_xlib in $my_oldlibs; do 3709 # Extract the objects. 3710 case $my_xlib in 3711 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; 3712 *) my_xabs=`pwd`"/$my_xlib" ;; 3713 esac 3714 func_basename "$my_xlib" 3715 my_xlib="$func_basename_result" 3716 my_xlib_u=$my_xlib 3717 while :; do 3718 case " $extracted_archives " in 3719 *" $my_xlib_u "*) 3720 func_arith $extracted_serial + 1 3721 extracted_serial=$func_arith_result 3722 my_xlib_u=lt$extracted_serial-$my_xlib ;; 3723 *) break ;; 3724 esac 3725 done 3726 extracted_archives="$extracted_archives $my_xlib_u" 3727 my_xdir="$my_gentop/$my_xlib_u" 3728 3729 func_mkdir_p "$my_xdir" 3730 3731 case $host in 3732 *-darwin*) 3733 func_verbose "Extracting $my_xabs" 3734 # Do not bother doing anything if just a dry run 3735 $opt_dry_run || { 3736 darwin_orig_dir=`pwd` 3737 cd $my_xdir || exit $? 3738 darwin_archive=$my_xabs 3739 darwin_curdir=`pwd` 3740 darwin_base_archive=`basename "$darwin_archive"` 3741 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` 3742 if test -n "$darwin_arches"; then 3743 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` 3744 darwin_arch= 3745 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" 3746 for darwin_arch in $darwin_arches ; do 3747 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" 3748 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" 3749 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" 3750 func_extract_an_archive "`pwd`" "${darwin_base_archive}" 3751 cd "$darwin_curdir" 3752 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" 3753 done # $darwin_arches 3754 ## Okay now we've a bunch of thin objects, gotta fatten them up :) 3755 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` 3756 darwin_file= 3757 darwin_files= 3758 for darwin_file in $darwin_filelist; do 3759 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` 3760 $LIPO -create -output "$darwin_file" $darwin_files 3761 done # $darwin_filelist 3762 $RM -rf unfat-$$ 3763 cd "$darwin_orig_dir" 3764 else 3765 cd $darwin_orig_dir 3766 func_extract_an_archive "$my_xdir" "$my_xabs" 3767 fi # $darwin_arches 3768 } # !$opt_dry_run 3769 ;; 3770 *) 3771 func_extract_an_archive "$my_xdir" "$my_xabs" 3772 ;; 3773 esac 3774 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` 3775 done 3776 3777 func_extract_archives_result="$my_oldobjs" 3778} 3779 3780 3781# func_emit_wrapper [arg=no] 3782# 3783# Emit a libtool wrapper script on stdout. 3784# Don't directly open a file because we may want to 3785# incorporate the script contents within a cygwin/mingw 3786# wrapper executable. Must ONLY be called from within 3787# func_mode_link because it depends on a number of variables 3788# set therein. 3789# 3790# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR 3791# variable will take. If 'yes', then the emitted script 3792# will assume that the directory in which it is stored is 3793# the $objdir directory. This is a cygwin/mingw-specific 3794# behavior. 3795func_emit_wrapper () 3796{ 3797 func_emit_wrapper_arg1=${1-no} 3798 3799 $ECHO "\ 3800#! $SHELL 3801 3802# $output - temporary wrapper script for $objdir/$outputname 3803# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 3804# 3805# The $output program cannot be directly executed until all the libtool 3806# libraries that it depends on are installed. 3807# 3808# This wrapper script should never be moved out of the build directory. 3809# If it is, it will not operate correctly. 3810 3811# Sed substitution that helps us do robust quoting. It backslashifies 3812# metacharacters that are still active within double-quoted strings. 3813sed_quote_subst='$sed_quote_subst' 3814 3815# Be Bourne compatible 3816if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then 3817 emulate sh 3818 NULLCMD=: 3819 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which 3820 # is contrary to our usage. Disable this feature. 3821 alias -g '\${1+\"\$@\"}'='\"\$@\"' 3822 setopt NO_GLOB_SUBST 3823else 3824 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac 3825fi 3826BIN_SH=xpg4; export BIN_SH # for Tru64 3827DUALCASE=1; export DUALCASE # for MKS sh 3828 3829# The HP-UX ksh and POSIX shell print the target directory to stdout 3830# if CDPATH is set. 3831(unset CDPATH) >/dev/null 2>&1 && unset CDPATH 3832 3833relink_command=\"$relink_command\" 3834 3835# This environment variable determines our operation mode. 3836if test \"\$libtool_install_magic\" = \"$magic\"; then 3837 # install mode needs the following variables: 3838 generated_by_libtool_version='$macro_version' 3839 notinst_deplibs='$notinst_deplibs' 3840else 3841 # When we are sourced in execute mode, \$file and \$ECHO are already set. 3842 if test \"\$libtool_execute_magic\" != \"$magic\"; then 3843 file=\"\$0\"" 3844 3845 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` 3846 $ECHO "\ 3847 3848# A function that is used when there is no print builtin or printf. 3849func_fallback_echo () 3850{ 3851 eval 'cat <<_LTECHO_EOF 3852\$1 3853_LTECHO_EOF' 3854} 3855 ECHO=\"$qECHO\" 3856 fi 3857 3858# Very basic option parsing. These options are (a) specific to 3859# the libtool wrapper, (b) are identical between the wrapper 3860# /script/ and the wrapper /executable/ which is used only on 3861# windows platforms, and (c) all begin with the string "--lt-" 3862# (application programs are unlikely to have options which match 3863# this pattern). 3864# 3865# There are only two supported options: --lt-debug and 3866# --lt-dump-script. There is, deliberately, no --lt-help. 3867# 3868# The first argument to this parsing function should be the 3869# script's $0 value, followed by "$@". 3870lt_option_debug= 3871func_parse_lt_options () 3872{ 3873 lt_script_arg0=\$0 3874 shift 3875 for lt_opt 3876 do 3877 case \"\$lt_opt\" in 3878 --lt-debug) lt_option_debug=1 ;; 3879 --lt-dump-script) 3880 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` 3881 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. 3882 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` 3883 cat \"\$lt_dump_D/\$lt_dump_F\" 3884 exit 0 3885 ;; 3886 --lt-*) 3887 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 3888 exit 1 3889 ;; 3890 esac 3891 done 3892 3893 # Print the debug banner immediately: 3894 if test -n \"\$lt_option_debug\"; then 3895 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2 3896 fi 3897} 3898 3899# Used when --lt-debug. Prints its arguments to stdout 3900# (redirection is the responsibility of the caller) 3901func_lt_dump_args () 3902{ 3903 lt_dump_args_N=1; 3904 for lt_arg 3905 do 3906 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\" 3907 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` 3908 done 3909} 3910 3911# Core function for launching the target application 3912func_exec_program_core () 3913{ 3914" 3915 case $host in 3916 # Backslashes separate directories on plain windows 3917 *-*-mingw | *-*-os2* | *-cegcc*) 3918 $ECHO "\ 3919 if test -n \"\$lt_option_debug\"; then 3920 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2 3921 func_lt_dump_args \${1+\"\$@\"} 1>&2 3922 fi 3923 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} 3924" 3925 ;; 3926 3927 *) 3928 $ECHO "\ 3929 if test -n \"\$lt_option_debug\"; then 3930 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2 3931 func_lt_dump_args \${1+\"\$@\"} 1>&2 3932 fi 3933 exec \"\$progdir/\$program\" \${1+\"\$@\"} 3934" 3935 ;; 3936 esac 3937 $ECHO "\ 3938 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 3939 exit 1 3940} 3941 3942# A function to encapsulate launching the target application 3943# Strips options in the --lt-* namespace from \$@ and 3944# launches target application with the remaining arguments. 3945func_exec_program () 3946{ 3947 case \" \$* \" in 3948 *\\ --lt-*) 3949 for lt_wr_arg 3950 do 3951 case \$lt_wr_arg in 3952 --lt-*) ;; 3953 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; 3954 esac 3955 shift 3956 done ;; 3957 esac 3958 func_exec_program_core \${1+\"\$@\"} 3959} 3960 3961 # Parse options 3962 func_parse_lt_options \"\$0\" \${1+\"\$@\"} 3963 3964 # Find the directory that this script lives in. 3965 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` 3966 test \"x\$thisdir\" = \"x\$file\" && thisdir=. 3967 3968 # Follow symbolic links until we get to the real thisdir. 3969 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` 3970 while test -n \"\$file\"; do 3971 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` 3972 3973 # If there was a directory component, then change thisdir. 3974 if test \"x\$destdir\" != \"x\$file\"; then 3975 case \"\$destdir\" in 3976 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; 3977 *) thisdir=\"\$thisdir/\$destdir\" ;; 3978 esac 3979 fi 3980 3981 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` 3982 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` 3983 done 3984 3985 # Usually 'no', except on cygwin/mingw when embedded into 3986 # the cwrapper. 3987 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 3988 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then 3989 # special case for '.' 3990 if test \"\$thisdir\" = \".\"; then 3991 thisdir=\`pwd\` 3992 fi 3993 # remove .libs from thisdir 3994 case \"\$thisdir\" in 3995 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; 3996 $objdir ) thisdir=. ;; 3997 esac 3998 fi 3999 4000 # Try to get the absolute directory name. 4001 absdir=\`cd \"\$thisdir\" && pwd\` 4002 test -n \"\$absdir\" && thisdir=\"\$absdir\" 4003" 4004 4005 if test "$fast_install" = yes; then 4006 $ECHO "\ 4007 program=lt-'$outputname'$exeext 4008 progdir=\"\$thisdir/$objdir\" 4009 4010 if test ! -f \"\$progdir/\$program\" || 4011 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ 4012 test \"X\$file\" != \"X\$progdir/\$program\"; }; then 4013 4014 file=\"\$\$-\$program\" 4015 4016 if test ! -d \"\$progdir\"; then 4017 $MKDIR \"\$progdir\" 4018 else 4019 $RM \"\$progdir/\$file\" 4020 fi" 4021 4022 $ECHO "\ 4023 4024 # relink executable if necessary 4025 if test -n \"\$relink_command\"; then 4026 if relink_command_output=\`eval \$relink_command 2>&1\`; then : 4027 else 4028 $ECHO \"\$relink_command_output\" >&2 4029 $RM \"\$progdir/\$file\" 4030 exit 1 4031 fi 4032 fi 4033 4034 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || 4035 { $RM \"\$progdir/\$program\"; 4036 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } 4037 $RM \"\$progdir/\$file\" 4038 fi" 4039 else 4040 $ECHO "\ 4041 program='$outputname' 4042 progdir=\"\$thisdir/$objdir\" 4043" 4044 fi 4045 4046 $ECHO "\ 4047 4048 if test -f \"\$progdir/\$program\"; then" 4049 4050 # fixup the dll searchpath if we need to. 4051 # 4052 # Fix the DLL searchpath if we need to. Do this before prepending 4053 # to shlibpath, because on Windows, both are PATH and uninstalled 4054 # libraries must come first. 4055 if test -n "$dllsearchpath"; then 4056 $ECHO "\ 4057 # Add the dll search path components to the executable PATH 4058 PATH=$dllsearchpath:\$PATH 4059" 4060 fi 4061 4062 # Export our shlibpath_var if we have one. 4063 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then 4064 $ECHO "\ 4065 # Add our own library path to $shlibpath_var 4066 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" 4067 4068 # Some systems cannot cope with colon-terminated $shlibpath_var 4069 # The second colon is a workaround for a bug in BeOS R4 sed 4070 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` 4071 4072 export $shlibpath_var 4073" 4074 fi 4075 4076 $ECHO "\ 4077 if test \"\$libtool_execute_magic\" != \"$magic\"; then 4078 # Run the actual program with our arguments. 4079 func_exec_program \${1+\"\$@\"} 4080 fi 4081 else 4082 # The program doesn't exist. 4083 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 4084 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 4085 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 4086 exit 1 4087 fi 4088fi\ 4089" 4090} 4091 4092 4093# func_emit_cwrapperexe_src 4094# emit the source code for a wrapper executable on stdout 4095# Must ONLY be called from within func_mode_link because 4096# it depends on a number of variable set therein. 4097func_emit_cwrapperexe_src () 4098{ 4099 cat <<EOF 4100 4101/* $cwrappersource - temporary wrapper executable for $objdir/$outputname 4102 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 4103 4104 The $output program cannot be directly executed until all the libtool 4105 libraries that it depends on are installed. 4106 4107 This wrapper executable should never be moved out of the build directory. 4108 If it is, it will not operate correctly. 4109*/ 4110EOF 4111 cat <<"EOF" 4112#ifdef _MSC_VER 4113# define _CRT_SECURE_NO_DEPRECATE 1 4114#endif 4115#include <stdio.h> 4116#include <stdlib.h> 4117#ifdef _MSC_VER 4118# include <direct.h> 4119# include <process.h> 4120# include <io.h> 4121#else 4122# include <unistd.h> 4123# include <stdint.h> 4124# ifdef __CYGWIN__ 4125# include <io.h> 4126# endif 4127#endif 4128#include <malloc.h> 4129#include <stdarg.h> 4130#include <assert.h> 4131#include <string.h> 4132#include <ctype.h> 4133#include <errno.h> 4134#include <fcntl.h> 4135#include <sys/stat.h> 4136 4137/* declarations of non-ANSI functions */ 4138#if defined(__MINGW32__) 4139# ifdef __STRICT_ANSI__ 4140int _putenv (const char *); 4141# endif 4142#elif defined(__CYGWIN__) 4143# ifdef __STRICT_ANSI__ 4144char *realpath (const char *, char *); 4145int putenv (char *); 4146int setenv (const char *, const char *, int); 4147# endif 4148/* #elif defined (other platforms) ... */ 4149#endif 4150 4151/* portability defines, excluding path handling macros */ 4152#if defined(_MSC_VER) 4153# define setmode _setmode 4154# define stat _stat 4155# define chmod _chmod 4156# define getcwd _getcwd 4157# define putenv _putenv 4158# define S_IXUSR _S_IEXEC 4159# ifndef _INTPTR_T_DEFINED 4160# define _INTPTR_T_DEFINED 4161# define intptr_t int 4162# endif 4163#elif defined(__MINGW32__) 4164# define setmode _setmode 4165# define stat _stat 4166# define chmod _chmod 4167# define getcwd _getcwd 4168# define putenv _putenv 4169#elif defined(__CYGWIN__) 4170# define HAVE_SETENV 4171# define FOPEN_WB "wb" 4172/* #elif defined (other platforms) ... */ 4173#endif 4174 4175#if defined(PATH_MAX) 4176# define LT_PATHMAX PATH_MAX 4177#elif defined(MAXPATHLEN) 4178# define LT_PATHMAX MAXPATHLEN 4179#else 4180# define LT_PATHMAX 1024 4181#endif 4182 4183#ifndef S_IXOTH 4184# define S_IXOTH 0 4185#endif 4186#ifndef S_IXGRP 4187# define S_IXGRP 0 4188#endif 4189 4190/* path handling portability macros */ 4191#ifndef DIR_SEPARATOR 4192# define DIR_SEPARATOR '/' 4193# define PATH_SEPARATOR ':' 4194#endif 4195 4196#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ 4197 defined (__OS2__) 4198# define HAVE_DOS_BASED_FILE_SYSTEM 4199# define FOPEN_WB "wb" 4200# ifndef DIR_SEPARATOR_2 4201# define DIR_SEPARATOR_2 '\\' 4202# endif 4203# ifndef PATH_SEPARATOR_2 4204# define PATH_SEPARATOR_2 ';' 4205# endif 4206#endif 4207 4208#ifndef DIR_SEPARATOR_2 4209# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) 4210#else /* DIR_SEPARATOR_2 */ 4211# define IS_DIR_SEPARATOR(ch) \ 4212 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) 4213#endif /* DIR_SEPARATOR_2 */ 4214 4215#ifndef PATH_SEPARATOR_2 4216# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) 4217#else /* PATH_SEPARATOR_2 */ 4218# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) 4219#endif /* PATH_SEPARATOR_2 */ 4220 4221#ifndef FOPEN_WB 4222# define FOPEN_WB "w" 4223#endif 4224#ifndef _O_BINARY 4225# define _O_BINARY 0 4226#endif 4227 4228#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) 4229#define XFREE(stale) do { \ 4230 if (stale) { free ((void *) stale); stale = 0; } \ 4231} while (0) 4232 4233#if defined(LT_DEBUGWRAPPER) 4234static int lt_debug = 1; 4235#else 4236static int lt_debug = 0; 4237#endif 4238 4239const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ 4240 4241void *xmalloc (size_t num); 4242char *xstrdup (const char *string); 4243const char *base_name (const char *name); 4244char *find_executable (const char *wrapper); 4245char *chase_symlinks (const char *pathspec); 4246int make_executable (const char *path); 4247int check_executable (const char *path); 4248char *strendzap (char *str, const char *pat); 4249void lt_debugprintf (const char *file, int line, const char *fmt, ...); 4250void lt_fatal (const char *file, int line, const char *message, ...); 4251static const char *nonnull (const char *s); 4252static const char *nonempty (const char *s); 4253void lt_setenv (const char *name, const char *value); 4254char *lt_extend_str (const char *orig_value, const char *add, int to_end); 4255void lt_update_exe_path (const char *name, const char *value); 4256void lt_update_lib_path (const char *name, const char *value); 4257char **prepare_spawn (char **argv); 4258void lt_dump_script (FILE *f); 4259EOF 4260 4261 cat <<EOF 4262volatile const char * MAGIC_EXE = "$magic_exe"; 4263const char * LIB_PATH_VARNAME = "$shlibpath_var"; 4264EOF 4265 4266 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then 4267 func_to_host_path "$temp_rpath" 4268 cat <<EOF 4269const char * LIB_PATH_VALUE = "$func_to_host_path_result"; 4270EOF 4271 else 4272 cat <<"EOF" 4273const char * LIB_PATH_VALUE = ""; 4274EOF 4275 fi 4276 4277 if test -n "$dllsearchpath"; then 4278 func_to_host_path "$dllsearchpath:" 4279 cat <<EOF 4280const char * EXE_PATH_VARNAME = "PATH"; 4281const char * EXE_PATH_VALUE = "$func_to_host_path_result"; 4282EOF 4283 else 4284 cat <<"EOF" 4285const char * EXE_PATH_VARNAME = ""; 4286const char * EXE_PATH_VALUE = ""; 4287EOF 4288 fi 4289 4290 if test "$fast_install" = yes; then 4291 cat <<EOF 4292const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */ 4293EOF 4294 else 4295 cat <<EOF 4296const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */ 4297EOF 4298 fi 4299 4300 4301 cat <<"EOF" 4302 4303#define LTWRAPPER_OPTION_PREFIX "--lt-" 4304 4305static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX; 4306static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script"; 4307static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug"; 4308 4309int 4310main (int argc, char *argv[]) 4311{ 4312 char **newargz; 4313 int newargc; 4314 char *tmp_pathspec; 4315 char *actual_cwrapper_path; 4316 char *actual_cwrapper_name; 4317 char *target_name; 4318 char *lt_argv_zero; 4319 intptr_t rval = 127; 4320 4321 int i; 4322 4323 program_name = (char *) xstrdup (base_name (argv[0])); 4324 newargz = XMALLOC (char *, argc + 1); 4325 4326 /* very simple arg parsing; don't want to rely on getopt 4327 * also, copy all non cwrapper options to newargz, except 4328 * argz[0], which is handled differently 4329 */ 4330 newargc=0; 4331 for (i = 1; i < argc; i++) 4332 { 4333 if (strcmp (argv[i], dumpscript_opt) == 0) 4334 { 4335EOF 4336 case "$host" in 4337 *mingw* | *cygwin* ) 4338 # make stdout use "unix" line endings 4339 echo " setmode(1,_O_BINARY);" 4340 ;; 4341 esac 4342 4343 cat <<"EOF" 4344 lt_dump_script (stdout); 4345 return 0; 4346 } 4347 if (strcmp (argv[i], debug_opt) == 0) 4348 { 4349 lt_debug = 1; 4350 continue; 4351 } 4352 if (strcmp (argv[i], ltwrapper_option_prefix) == 0) 4353 { 4354 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX 4355 namespace, but it is not one of the ones we know about and 4356 have already dealt with, above (inluding dump-script), then 4357 report an error. Otherwise, targets might begin to believe 4358 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX 4359 namespace. The first time any user complains about this, we'll 4360 need to make LTWRAPPER_OPTION_PREFIX a configure-time option 4361 or a configure.ac-settable value. 4362 */ 4363 lt_fatal (__FILE__, __LINE__, 4364 "unrecognized %s option: '%s'", 4365 ltwrapper_option_prefix, argv[i]); 4366 } 4367 /* otherwise ... */ 4368 newargz[++newargc] = xstrdup (argv[i]); 4369 } 4370 newargz[++newargc] = NULL; 4371 4372EOF 4373 cat <<EOF 4374 /* The GNU banner must be the first non-error debug message */ 4375 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n"); 4376EOF 4377 cat <<"EOF" 4378 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]); 4379 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name); 4380 4381 tmp_pathspec = find_executable (argv[0]); 4382 if (tmp_pathspec == NULL) 4383 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]); 4384 lt_debugprintf (__FILE__, __LINE__, 4385 "(main) found exe (before symlink chase) at: %s\n", 4386 tmp_pathspec); 4387 4388 actual_cwrapper_path = chase_symlinks (tmp_pathspec); 4389 lt_debugprintf (__FILE__, __LINE__, 4390 "(main) found exe (after symlink chase) at: %s\n", 4391 actual_cwrapper_path); 4392 XFREE (tmp_pathspec); 4393 4394 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path)); 4395 strendzap (actual_cwrapper_path, actual_cwrapper_name); 4396 4397 /* wrapper name transforms */ 4398 strendzap (actual_cwrapper_name, ".exe"); 4399 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1); 4400 XFREE (actual_cwrapper_name); 4401 actual_cwrapper_name = tmp_pathspec; 4402 tmp_pathspec = 0; 4403 4404 /* target_name transforms -- use actual target program name; might have lt- prefix */ 4405 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME)); 4406 strendzap (target_name, ".exe"); 4407 tmp_pathspec = lt_extend_str (target_name, ".exe", 1); 4408 XFREE (target_name); 4409 target_name = tmp_pathspec; 4410 tmp_pathspec = 0; 4411 4412 lt_debugprintf (__FILE__, __LINE__, 4413 "(main) libtool target name: %s\n", 4414 target_name); 4415EOF 4416 4417 cat <<EOF 4418 newargz[0] = 4419 XMALLOC (char, (strlen (actual_cwrapper_path) + 4420 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1)); 4421 strcpy (newargz[0], actual_cwrapper_path); 4422 strcat (newargz[0], "$objdir"); 4423 strcat (newargz[0], "/"); 4424EOF 4425 4426 cat <<"EOF" 4427 /* stop here, and copy so we don't have to do this twice */ 4428 tmp_pathspec = xstrdup (newargz[0]); 4429 4430 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */ 4431 strcat (newargz[0], actual_cwrapper_name); 4432 4433 /* DO want the lt- prefix here if it exists, so use target_name */ 4434 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1); 4435 XFREE (tmp_pathspec); 4436 tmp_pathspec = NULL; 4437EOF 4438 4439 case $host_os in 4440 mingw*) 4441 cat <<"EOF" 4442 { 4443 char* p; 4444 while ((p = strchr (newargz[0], '\\')) != NULL) 4445 { 4446 *p = '/'; 4447 } 4448 while ((p = strchr (lt_argv_zero, '\\')) != NULL) 4449 { 4450 *p = '/'; 4451 } 4452 } 4453EOF 4454 ;; 4455 esac 4456 4457 cat <<"EOF" 4458 XFREE (target_name); 4459 XFREE (actual_cwrapper_path); 4460 XFREE (actual_cwrapper_name); 4461 4462 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */ 4463 lt_setenv ("DUALCASE", "1"); /* for MSK sh */ 4464 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must 4465 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath) 4466 because on Windows, both *_VARNAMEs are PATH but uninstalled 4467 libraries must come first. */ 4468 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE); 4469 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE); 4470 4471 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n", 4472 nonnull (lt_argv_zero)); 4473 for (i = 0; i < newargc; i++) 4474 { 4475 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n", 4476 i, nonnull (newargz[i])); 4477 } 4478 4479EOF 4480 4481 case $host_os in 4482 mingw*) 4483 cat <<"EOF" 4484 /* execv doesn't actually work on mingw as expected on unix */ 4485 newargz = prepare_spawn (newargz); 4486 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz); 4487 if (rval == -1) 4488 { 4489 /* failed to start process */ 4490 lt_debugprintf (__FILE__, __LINE__, 4491 "(main) failed to launch target \"%s\": %s\n", 4492 lt_argv_zero, nonnull (strerror (errno))); 4493 return 127; 4494 } 4495 return rval; 4496EOF 4497 ;; 4498 *) 4499 cat <<"EOF" 4500 execv (lt_argv_zero, newargz); 4501 return rval; /* =127, but avoids unused variable warning */ 4502EOF 4503 ;; 4504 esac 4505 4506 cat <<"EOF" 4507} 4508 4509void * 4510xmalloc (size_t num) 4511{ 4512 void *p = (void *) malloc (num); 4513 if (!p) 4514 lt_fatal (__FILE__, __LINE__, "memory exhausted"); 4515 4516 return p; 4517} 4518 4519char * 4520xstrdup (const char *string) 4521{ 4522 return string ? strcpy ((char *) xmalloc (strlen (string) + 1), 4523 string) : NULL; 4524} 4525 4526const char * 4527base_name (const char *name) 4528{ 4529 const char *base; 4530 4531#if defined (HAVE_DOS_BASED_FILE_SYSTEM) 4532 /* Skip over the disk name in MSDOS pathnames. */ 4533 if (isalpha ((unsigned char) name[0]) && name[1] == ':') 4534 name += 2; 4535#endif 4536 4537 for (base = name; *name; name++) 4538 if (IS_DIR_SEPARATOR (*name)) 4539 base = name + 1; 4540 return base; 4541} 4542 4543int 4544check_executable (const char *path) 4545{ 4546 struct stat st; 4547 4548 lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n", 4549 nonempty (path)); 4550 if ((!path) || (!*path)) 4551 return 0; 4552 4553 if ((stat (path, &st) >= 0) 4554 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) 4555 return 1; 4556 else 4557 return 0; 4558} 4559 4560int 4561make_executable (const char *path) 4562{ 4563 int rval = 0; 4564 struct stat st; 4565 4566 lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", 4567 nonempty (path)); 4568 if ((!path) || (!*path)) 4569 return 0; 4570 4571 if (stat (path, &st) >= 0) 4572 { 4573 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); 4574 } 4575 return rval; 4576} 4577 4578/* Searches for the full path of the wrapper. Returns 4579 newly allocated full path name if found, NULL otherwise 4580 Does not chase symlinks, even on platforms that support them. 4581*/ 4582char * 4583find_executable (const char *wrapper) 4584{ 4585 int has_slash = 0; 4586 const char *p; 4587 const char *p_next; 4588 /* static buffer for getcwd */ 4589 char tmp[LT_PATHMAX + 1]; 4590 int tmp_len; 4591 char *concat_name; 4592 4593 lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", 4594 nonempty (wrapper)); 4595 4596 if ((wrapper == NULL) || (*wrapper == '\0')) 4597 return NULL; 4598 4599 /* Absolute path? */ 4600#if defined (HAVE_DOS_BASED_FILE_SYSTEM) 4601 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') 4602 { 4603 concat_name = xstrdup (wrapper); 4604 if (check_executable (concat_name)) 4605 return concat_name; 4606 XFREE (concat_name); 4607 } 4608 else 4609 { 4610#endif 4611 if (IS_DIR_SEPARATOR (wrapper[0])) 4612 { 4613 concat_name = xstrdup (wrapper); 4614 if (check_executable (concat_name)) 4615 return concat_name; 4616 XFREE (concat_name); 4617 } 4618#if defined (HAVE_DOS_BASED_FILE_SYSTEM) 4619 } 4620#endif 4621 4622 for (p = wrapper; *p; p++) 4623 if (*p == '/') 4624 { 4625 has_slash = 1; 4626 break; 4627 } 4628 if (!has_slash) 4629 { 4630 /* no slashes; search PATH */ 4631 const char *path = getenv ("PATH"); 4632 if (path != NULL) 4633 { 4634 for (p = path; *p; p = p_next) 4635 { 4636 const char *q; 4637 size_t p_len; 4638 for (q = p; *q; q++) 4639 if (IS_PATH_SEPARATOR (*q)) 4640 break; 4641 p_len = q - p; 4642 p_next = (*q == '\0' ? q : q + 1); 4643 if (p_len == 0) 4644 { 4645 /* empty path: current directory */ 4646 if (getcwd (tmp, LT_PATHMAX) == NULL) 4647 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", 4648 nonnull (strerror (errno))); 4649 tmp_len = strlen (tmp); 4650 concat_name = 4651 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); 4652 memcpy (concat_name, tmp, tmp_len); 4653 concat_name[tmp_len] = '/'; 4654 strcpy (concat_name + tmp_len + 1, wrapper); 4655 } 4656 else 4657 { 4658 concat_name = 4659 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); 4660 memcpy (concat_name, p, p_len); 4661 concat_name[p_len] = '/'; 4662 strcpy (concat_name + p_len + 1, wrapper); 4663 } 4664 if (check_executable (concat_name)) 4665 return concat_name; 4666 XFREE (concat_name); 4667 } 4668 } 4669 /* not found in PATH; assume curdir */ 4670 } 4671 /* Relative path | not found in path: prepend cwd */ 4672 if (getcwd (tmp, LT_PATHMAX) == NULL) 4673 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", 4674 nonnull (strerror (errno))); 4675 tmp_len = strlen (tmp); 4676 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); 4677 memcpy (concat_name, tmp, tmp_len); 4678 concat_name[tmp_len] = '/'; 4679 strcpy (concat_name + tmp_len + 1, wrapper); 4680 4681 if (check_executable (concat_name)) 4682 return concat_name; 4683 XFREE (concat_name); 4684 return NULL; 4685} 4686 4687char * 4688chase_symlinks (const char *pathspec) 4689{ 4690#ifndef S_ISLNK 4691 return xstrdup (pathspec); 4692#else 4693 char buf[LT_PATHMAX]; 4694 struct stat s; 4695 char *tmp_pathspec = xstrdup (pathspec); 4696 char *p; 4697 int has_symlinks = 0; 4698 while (strlen (tmp_pathspec) && !has_symlinks) 4699 { 4700 lt_debugprintf (__FILE__, __LINE__, 4701 "checking path component for symlinks: %s\n", 4702 tmp_pathspec); 4703 if (lstat (tmp_pathspec, &s) == 0) 4704 { 4705 if (S_ISLNK (s.st_mode) != 0) 4706 { 4707 has_symlinks = 1; 4708 break; 4709 } 4710 4711 /* search backwards for last DIR_SEPARATOR */ 4712 p = tmp_pathspec + strlen (tmp_pathspec) - 1; 4713 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) 4714 p--; 4715 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) 4716 { 4717 /* no more DIR_SEPARATORS left */ 4718 break; 4719 } 4720 *p = '\0'; 4721 } 4722 else 4723 { 4724 lt_fatal (__FILE__, __LINE__, 4725 "error accessing file \"%s\": %s", 4726 tmp_pathspec, nonnull (strerror (errno))); 4727 } 4728 } 4729 XFREE (tmp_pathspec); 4730 4731 if (!has_symlinks) 4732 { 4733 return xstrdup (pathspec); 4734 } 4735 4736 tmp_pathspec = realpath (pathspec, buf); 4737 if (tmp_pathspec == 0) 4738 { 4739 lt_fatal (__FILE__, __LINE__, 4740 "could not follow symlinks for %s", pathspec); 4741 } 4742 return xstrdup (tmp_pathspec); 4743#endif 4744} 4745 4746char * 4747strendzap (char *str, const char *pat) 4748{ 4749 size_t len, patlen; 4750 4751 assert (str != NULL); 4752 assert (pat != NULL); 4753 4754 len = strlen (str); 4755 patlen = strlen (pat); 4756 4757 if (patlen <= len) 4758 { 4759 str += len - patlen; 4760 if (strcmp (str, pat) == 0) 4761 *str = '\0'; 4762 } 4763 return str; 4764} 4765 4766void 4767lt_debugprintf (const char *file, int line, const char *fmt, ...) 4768{ 4769 va_list args; 4770 if (lt_debug) 4771 { 4772 (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); 4773 va_start (args, fmt); 4774 (void) vfprintf (stderr, fmt, args); 4775 va_end (args); 4776 } 4777} 4778 4779static void 4780lt_error_core (int exit_status, const char *file, 4781 int line, const char *mode, 4782 const char *message, va_list ap) 4783{ 4784 fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); 4785 vfprintf (stderr, message, ap); 4786 fprintf (stderr, ".\n"); 4787 4788 if (exit_status >= 0) 4789 exit (exit_status); 4790} 4791 4792void 4793lt_fatal (const char *file, int line, const char *message, ...) 4794{ 4795 va_list ap; 4796 va_start (ap, message); 4797 lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); 4798 va_end (ap); 4799} 4800 4801static const char * 4802nonnull (const char *s) 4803{ 4804 return s ? s : "(null)"; 4805} 4806 4807static const char * 4808nonempty (const char *s) 4809{ 4810 return (s && !*s) ? "(empty)" : nonnull (s); 4811} 4812 4813void 4814lt_setenv (const char *name, const char *value) 4815{ 4816 lt_debugprintf (__FILE__, __LINE__, 4817 "(lt_setenv) setting '%s' to '%s'\n", 4818 nonnull (name), nonnull (value)); 4819 { 4820#ifdef HAVE_SETENV 4821 /* always make a copy, for consistency with !HAVE_SETENV */ 4822 char *str = xstrdup (value); 4823 setenv (name, str, 1); 4824#else 4825 int len = strlen (name) + 1 + strlen (value) + 1; 4826 char *str = XMALLOC (char, len); 4827 sprintf (str, "%s=%s", name, value); 4828 if (putenv (str) != EXIT_SUCCESS) 4829 { 4830 XFREE (str); 4831 } 4832#endif 4833 } 4834} 4835 4836char * 4837lt_extend_str (const char *orig_value, const char *add, int to_end) 4838{ 4839 char *new_value; 4840 if (orig_value && *orig_value) 4841 { 4842 int orig_value_len = strlen (orig_value); 4843 int add_len = strlen (add); 4844 new_value = XMALLOC (char, add_len + orig_value_len + 1); 4845 if (to_end) 4846 { 4847 strcpy (new_value, orig_value); 4848 strcpy (new_value + orig_value_len, add); 4849 } 4850 else 4851 { 4852 strcpy (new_value, add); 4853 strcpy (new_value + add_len, orig_value); 4854 } 4855 } 4856 else 4857 { 4858 new_value = xstrdup (add); 4859 } 4860 return new_value; 4861} 4862 4863void 4864lt_update_exe_path (const char *name, const char *value) 4865{ 4866 lt_debugprintf (__FILE__, __LINE__, 4867 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", 4868 nonnull (name), nonnull (value)); 4869 4870 if (name && *name && value && *value) 4871 { 4872 char *new_value = lt_extend_str (getenv (name), value, 0); 4873 /* some systems can't cope with a ':'-terminated path #' */ 4874 int len = strlen (new_value); 4875 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) 4876 { 4877 new_value[len-1] = '\0'; 4878 } 4879 lt_setenv (name, new_value); 4880 XFREE (new_value); 4881 } 4882} 4883 4884void 4885lt_update_lib_path (const char *name, const char *value) 4886{ 4887 lt_debugprintf (__FILE__, __LINE__, 4888 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", 4889 nonnull (name), nonnull (value)); 4890 4891 if (name && *name && value && *value) 4892 { 4893 char *new_value = lt_extend_str (getenv (name), value, 0); 4894 lt_setenv (name, new_value); 4895 XFREE (new_value); 4896 } 4897} 4898 4899EOF 4900 case $host_os in 4901 mingw*) 4902 cat <<"EOF" 4903 4904/* Prepares an argument vector before calling spawn(). 4905 Note that spawn() does not by itself call the command interpreter 4906 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : 4907 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); 4908 GetVersionEx(&v); 4909 v.dwPlatformId == VER_PLATFORM_WIN32_NT; 4910 }) ? "cmd.exe" : "command.com"). 4911 Instead it simply concatenates the arguments, separated by ' ', and calls 4912 CreateProcess(). We must quote the arguments since Win32 CreateProcess() 4913 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a 4914 special way: 4915 - Space and tab are interpreted as delimiters. They are not treated as 4916 delimiters if they are surrounded by double quotes: "...". 4917 - Unescaped double quotes are removed from the input. Their only effect is 4918 that within double quotes, space and tab are treated like normal 4919 characters. 4920 - Backslashes not followed by double quotes are not special. 4921 - But 2*n+1 backslashes followed by a double quote become 4922 n backslashes followed by a double quote (n >= 0): 4923 \" -> " 4924 \\\" -> \" 4925 \\\\\" -> \\" 4926 */ 4927#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" 4928#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" 4929char ** 4930prepare_spawn (char **argv) 4931{ 4932 size_t argc; 4933 char **new_argv; 4934 size_t i; 4935 4936 /* Count number of arguments. */ 4937 for (argc = 0; argv[argc] != NULL; argc++) 4938 ; 4939 4940 /* Allocate new argument vector. */ 4941 new_argv = XMALLOC (char *, argc + 1); 4942 4943 /* Put quoted arguments into the new argument vector. */ 4944 for (i = 0; i < argc; i++) 4945 { 4946 const char *string = argv[i]; 4947 4948 if (string[0] == '\0') 4949 new_argv[i] = xstrdup ("\"\""); 4950 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) 4951 { 4952 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); 4953 size_t length; 4954 unsigned int backslashes; 4955 const char *s; 4956 char *quoted_string; 4957 char *p; 4958 4959 length = 0; 4960 backslashes = 0; 4961 if (quote_around) 4962 length++; 4963 for (s = string; *s != '\0'; s++) 4964 { 4965 char c = *s; 4966 if (c == '"') 4967 length += backslashes + 1; 4968 length++; 4969 if (c == '\\') 4970 backslashes++; 4971 else 4972 backslashes = 0; 4973 } 4974 if (quote_around) 4975 length += backslashes + 1; 4976 4977 quoted_string = XMALLOC (char, length + 1); 4978 4979 p = quoted_string; 4980 backslashes = 0; 4981 if (quote_around) 4982 *p++ = '"'; 4983 for (s = string; *s != '\0'; s++) 4984 { 4985 char c = *s; 4986 if (c == '"') 4987 { 4988 unsigned int j; 4989 for (j = backslashes + 1; j > 0; j--) 4990 *p++ = '\\'; 4991 } 4992 *p++ = c; 4993 if (c == '\\') 4994 backslashes++; 4995 else 4996 backslashes = 0; 4997 } 4998 if (quote_around) 4999 { 5000 unsigned int j; 5001 for (j = backslashes; j > 0; j--) 5002 *p++ = '\\'; 5003 *p++ = '"'; 5004 } 5005 *p = '\0'; 5006 5007 new_argv[i] = quoted_string; 5008 } 5009 else 5010 new_argv[i] = (char *) string; 5011 } 5012 new_argv[argc] = NULL; 5013 5014 return new_argv; 5015} 5016EOF 5017 ;; 5018 esac 5019 5020 cat <<"EOF" 5021void lt_dump_script (FILE* f) 5022{ 5023EOF 5024 func_emit_wrapper yes | 5025 $SED -n -e ' 5026s/^\(.\{79\}\)\(..*\)/\1\ 5027\2/ 5028h 5029s/\([\\"]\)/\\\1/g 5030s/$/\\n/ 5031s/\([^\n]*\).*/ fputs ("\1", f);/p 5032g 5033D' 5034 cat <<"EOF" 5035} 5036EOF 5037} 5038# end: func_emit_cwrapperexe_src 5039 5040# func_win32_import_lib_p ARG 5041# True if ARG is an import lib, as indicated by $file_magic_cmd 5042func_win32_import_lib_p () 5043{ 5044 $opt_debug 5045 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in 5046 *import*) : ;; 5047 *) false ;; 5048 esac 5049} 5050 5051# func_mode_link arg... 5052func_mode_link () 5053{ 5054 $opt_debug 5055 case $host in 5056 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 5057 # It is impossible to link a dll without this setting, and 5058 # we shouldn't force the makefile maintainer to figure out 5059 # which system we are compiling for in order to pass an extra 5060 # flag for every libtool invocation. 5061 # allow_undefined=no 5062 5063 # FIXME: Unfortunately, there are problems with the above when trying 5064 # to make a dll which has undefined symbols, in which case not 5065 # even a static library is built. For now, we need to specify 5066 # -no-undefined on the libtool link line when we can be certain 5067 # that all symbols are satisfied, otherwise we get a static library. 5068 allow_undefined=yes 5069 ;; 5070 *) 5071 allow_undefined=yes 5072 ;; 5073 esac 5074 libtool_args=$nonopt 5075 base_compile="$nonopt $@" 5076 compile_command=$nonopt 5077 finalize_command=$nonopt 5078 5079 compile_rpath= 5080 finalize_rpath= 5081 compile_shlibpath= 5082 finalize_shlibpath= 5083 convenience= 5084 old_convenience= 5085 deplibs= 5086 old_deplibs= 5087 compiler_flags= 5088 linker_flags= 5089 dllsearchpath= 5090 lib_search_path=`pwd` 5091 inst_prefix_dir= 5092 new_inherited_linker_flags= 5093 5094 avoid_version=no 5095 bindir= 5096 dlfiles= 5097 dlprefiles= 5098 dlself=no 5099 export_dynamic=no 5100 export_symbols= 5101 export_symbols_regex= 5102 generated= 5103 libobjs= 5104 ltlibs= 5105 module=no 5106 no_install=no 5107 objs= 5108 non_pic_objects= 5109 precious_files_regex= 5110 prefer_static_libs=no 5111 preload=no 5112 prev= 5113 prevarg= 5114 release= 5115 rpath= 5116 xrpath= 5117 perm_rpath= 5118 temp_rpath= 5119 thread_safe=no 5120 vinfo= 5121 vinfo_number=no 5122 weak_libs= 5123 single_module="${wl}-single_module" 5124 func_infer_tag $base_compile 5125 5126 # We need to know -static, to get the right output filenames. 5127 for arg 5128 do 5129 case $arg in 5130 -shared) 5131 test "$build_libtool_libs" != yes && \ 5132 func_fatal_configuration "can not build a shared library" 5133 build_old_libs=no 5134 break 5135 ;; 5136 -all-static | -static | -static-libtool-libs) 5137 case $arg in 5138 -all-static) 5139 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then 5140 func_warning "complete static linking is impossible in this configuration" 5141 fi 5142 if test -n "$link_static_flag"; then 5143 dlopen_self=$dlopen_self_static 5144 fi 5145 prefer_static_libs=yes 5146 ;; 5147 -static) 5148 if test -z "$pic_flag" && test -n "$link_static_flag"; then 5149 dlopen_self=$dlopen_self_static 5150 fi 5151 prefer_static_libs=built 5152 ;; 5153 -static-libtool-libs) 5154 if test -z "$pic_flag" && test -n "$link_static_flag"; then 5155 dlopen_self=$dlopen_self_static 5156 fi 5157 prefer_static_libs=yes 5158 ;; 5159 esac 5160 build_libtool_libs=no 5161 build_old_libs=yes 5162 break 5163 ;; 5164 esac 5165 done 5166 5167 # See if our shared archives depend on static archives. 5168 test -n "$old_archive_from_new_cmds" && build_old_libs=yes 5169 5170 # Go through the arguments, transforming them on the way. 5171 while test "$#" -gt 0; do 5172 arg="$1" 5173 shift 5174 func_quote_for_eval "$arg" 5175 qarg=$func_quote_for_eval_unquoted_result 5176 func_append libtool_args " $func_quote_for_eval_result" 5177 5178 # If the previous option needs an argument, assign it. 5179 if test -n "$prev"; then 5180 case $prev in 5181 output) 5182 func_append compile_command " @OUTPUT@" 5183 func_append finalize_command " @OUTPUT@" 5184 ;; 5185 esac 5186 5187 case $prev in 5188 bindir) 5189 bindir="$arg" 5190 prev= 5191 continue 5192 ;; 5193 dlfiles|dlprefiles) 5194 if test "$preload" = no; then 5195 # Add the symbol object into the linking commands. 5196 func_append compile_command " @SYMFILE@" 5197 func_append finalize_command " @SYMFILE@" 5198 preload=yes 5199 fi 5200 case $arg in 5201 *.la | *.lo) ;; # We handle these cases below. 5202 force) 5203 if test "$dlself" = no; then 5204 dlself=needless 5205 export_dynamic=yes 5206 fi 5207 prev= 5208 continue 5209 ;; 5210 self) 5211 if test "$prev" = dlprefiles; then 5212 dlself=yes 5213 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then 5214 dlself=yes 5215 else 5216 dlself=needless 5217 export_dynamic=yes 5218 fi 5219 prev= 5220 continue 5221 ;; 5222 *) 5223 if test "$prev" = dlfiles; then 5224 func_append dlfiles " $arg" 5225 else 5226 func_append dlprefiles " $arg" 5227 fi 5228 prev= 5229 continue 5230 ;; 5231 esac 5232 ;; 5233 expsyms) 5234 export_symbols="$arg" 5235 test -f "$arg" \ 5236 || func_fatal_error "symbol file \`$arg' does not exist" 5237 prev= 5238 continue 5239 ;; 5240 expsyms_regex) 5241 export_symbols_regex="$arg" 5242 prev= 5243 continue 5244 ;; 5245 framework) 5246 case $host in 5247 *-*-darwin*) 5248 case "$deplibs " in 5249 *" $qarg.ltframework "*) ;; 5250 *) func_append deplibs " $qarg.ltframework" # this is fixed later 5251 ;; 5252 esac 5253 ;; 5254 esac 5255 prev= 5256 continue 5257 ;; 5258 inst_prefix) 5259 inst_prefix_dir="$arg" 5260 prev= 5261 continue 5262 ;; 5263 objectlist) 5264 if test -f "$arg"; then 5265 save_arg=$arg 5266 moreargs= 5267 for fil in `cat "$save_arg"` 5268 do 5269# func_append moreargs " $fil" 5270 arg=$fil 5271 # A libtool-controlled object. 5272 5273 # Check to see that this really is a libtool object. 5274 if func_lalib_unsafe_p "$arg"; then 5275 pic_object= 5276 non_pic_object= 5277 5278 # Read the .lo file 5279 func_source "$arg" 5280 5281 if test -z "$pic_object" || 5282 test -z "$non_pic_object" || 5283 test "$pic_object" = none && 5284 test "$non_pic_object" = none; then 5285 func_fatal_error "cannot find name of object for \`$arg'" 5286 fi 5287 5288 # Extract subdirectory from the argument. 5289 func_dirname "$arg" "/" "" 5290 xdir="$func_dirname_result" 5291 5292 if test "$pic_object" != none; then 5293 # Prepend the subdirectory the object is found in. 5294 pic_object="$xdir$pic_object" 5295 5296 if test "$prev" = dlfiles; then 5297 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then 5298 func_append dlfiles " $pic_object" 5299 prev= 5300 continue 5301 else 5302 # If libtool objects are unsupported, then we need to preload. 5303 prev=dlprefiles 5304 fi 5305 fi 5306 5307 # CHECK ME: I think I busted this. -Ossama 5308 if test "$prev" = dlprefiles; then 5309 # Preload the old-style object. 5310 func_append dlprefiles " $pic_object" 5311 prev= 5312 fi 5313 5314 # A PIC object. 5315 func_append libobjs " $pic_object" 5316 arg="$pic_object" 5317 fi 5318 5319 # Non-PIC object. 5320 if test "$non_pic_object" != none; then 5321 # Prepend the subdirectory the object is found in. 5322 non_pic_object="$xdir$non_pic_object" 5323 5324 # A standard non-PIC object 5325 func_append non_pic_objects " $non_pic_object" 5326 if test -z "$pic_object" || test "$pic_object" = none ; then 5327 arg="$non_pic_object" 5328 fi 5329 else 5330 # If the PIC object exists, use it instead. 5331 # $xdir was prepended to $pic_object above. 5332 non_pic_object="$pic_object" 5333 func_append non_pic_objects " $non_pic_object" 5334 fi 5335 else 5336 # Only an error if not doing a dry-run. 5337 if $opt_dry_run; then 5338 # Extract subdirectory from the argument. 5339 func_dirname "$arg" "/" "" 5340 xdir="$func_dirname_result" 5341 5342 func_lo2o "$arg" 5343 pic_object=$xdir$objdir/$func_lo2o_result 5344 non_pic_object=$xdir$func_lo2o_result 5345 func_append libobjs " $pic_object" 5346 func_append non_pic_objects " $non_pic_object" 5347 else 5348 func_fatal_error "\`$arg' is not a valid libtool object" 5349 fi 5350 fi 5351 done 5352 else 5353 func_fatal_error "link input file \`$arg' does not exist" 5354 fi 5355 arg=$save_arg 5356 prev= 5357 continue 5358 ;; 5359 precious_regex) 5360 precious_files_regex="$arg" 5361 prev= 5362 continue 5363 ;; 5364 release) 5365 release="-$arg" 5366 prev= 5367 continue 5368 ;; 5369 rpath | xrpath) 5370 # We need an absolute path. 5371 case $arg in 5372 [\\/]* | [A-Za-z]:[\\/]*) ;; 5373 *) 5374 func_fatal_error "only absolute run-paths are allowed" 5375 ;; 5376 esac 5377 if test "$prev" = rpath; then 5378 case "$rpath " in 5379 *" $arg "*) ;; 5380 *) func_append rpath " $arg" ;; 5381 esac 5382 else 5383 case "$xrpath " in 5384 *" $arg "*) ;; 5385 *) func_append xrpath " $arg" ;; 5386 esac 5387 fi 5388 prev= 5389 continue 5390 ;; 5391 shrext) 5392 shrext_cmds="$arg" 5393 prev= 5394 continue 5395 ;; 5396 weak) 5397 func_append weak_libs " $arg" 5398 prev= 5399 continue 5400 ;; 5401 xcclinker) 5402 func_append linker_flags " $qarg" 5403 func_append compiler_flags " $qarg" 5404 prev= 5405 func_append compile_command " $qarg" 5406 func_append finalize_command " $qarg" 5407 continue 5408 ;; 5409 xcompiler) 5410 func_append compiler_flags " $qarg" 5411 prev= 5412 func_append compile_command " $qarg" 5413 func_append finalize_command " $qarg" 5414 continue 5415 ;; 5416 xlinker) 5417 func_append linker_flags " $qarg" 5418 func_append compiler_flags " $wl$qarg" 5419 prev= 5420 func_append compile_command " $wl$qarg" 5421 func_append finalize_command " $wl$qarg" 5422 continue 5423 ;; 5424 *) 5425 eval "$prev=\"\$arg\"" 5426 prev= 5427 continue 5428 ;; 5429 esac 5430 fi # test -n "$prev" 5431 5432 prevarg="$arg" 5433 5434 case $arg in 5435 -all-static) 5436 if test -n "$link_static_flag"; then 5437 # See comment for -static flag below, for more details. 5438 func_append compile_command " $link_static_flag" 5439 func_append finalize_command " $link_static_flag" 5440 fi 5441 continue 5442 ;; 5443 5444 -allow-undefined) 5445 # FIXME: remove this flag sometime in the future. 5446 func_fatal_error "\`-allow-undefined' must not be used because it is the default" 5447 ;; 5448 5449 -avoid-version) 5450 avoid_version=yes 5451 continue 5452 ;; 5453 5454 -bindir) 5455 prev=bindir 5456 continue 5457 ;; 5458 5459 -dlopen) 5460 prev=dlfiles 5461 continue 5462 ;; 5463 5464 -dlpreopen) 5465 prev=dlprefiles 5466 continue 5467 ;; 5468 5469 -export-dynamic) 5470 export_dynamic=yes 5471 continue 5472 ;; 5473 5474 -export-symbols | -export-symbols-regex) 5475 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then 5476 func_fatal_error "more than one -exported-symbols argument is not allowed" 5477 fi 5478 if test "X$arg" = "X-export-symbols"; then 5479 prev=expsyms 5480 else 5481 prev=expsyms_regex 5482 fi 5483 continue 5484 ;; 5485 5486 -framework) 5487 prev=framework 5488 continue 5489 ;; 5490 5491 -inst-prefix-dir) 5492 prev=inst_prefix 5493 continue 5494 ;; 5495 5496 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* 5497 # so, if we see these flags be careful not to treat them like -L 5498 -L[A-Z][A-Z]*:*) 5499 case $with_gcc/$host in 5500 no/*-*-irix* | /*-*-irix*) 5501 func_append compile_command " $arg" 5502 func_append finalize_command " $arg" 5503 ;; 5504 esac 5505 continue 5506 ;; 5507 5508 -L*) 5509 func_stripname "-L" '' "$arg" 5510 if test -z "$func_stripname_result"; then 5511 if test "$#" -gt 0; then 5512 func_fatal_error "require no space between \`-L' and \`$1'" 5513 else 5514 func_fatal_error "need path for \`-L' option" 5515 fi 5516 fi 5517 func_resolve_sysroot "$func_stripname_result" 5518 dir=$func_resolve_sysroot_result 5519 # We need an absolute path. 5520 case $dir in 5521 [\\/]* | [A-Za-z]:[\\/]*) ;; 5522 *) 5523 absdir=`cd "$dir" && pwd` 5524 test -z "$absdir" && \ 5525 func_fatal_error "cannot determine absolute directory name of \`$dir'" 5526 dir="$absdir" 5527 ;; 5528 esac 5529 case "$deplibs " in 5530 *" -L$dir "* | *" $arg "*) 5531 # Will only happen for absolute or sysroot arguments 5532 ;; 5533 *) 5534 # Preserve sysroot, but never include relative directories 5535 case $dir in 5536 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; 5537 *) func_append deplibs " -L$dir" ;; 5538 esac 5539 func_append lib_search_path " $dir" 5540 ;; 5541 esac 5542 case $host in 5543 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 5544 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` 5545 case :$dllsearchpath: in 5546 *":$dir:"*) ;; 5547 ::) dllsearchpath=$dir;; 5548 *) func_append dllsearchpath ":$dir";; 5549 esac 5550 case :$dllsearchpath: in 5551 *":$testbindir:"*) ;; 5552 ::) dllsearchpath=$testbindir;; 5553 *) func_append dllsearchpath ":$testbindir";; 5554 esac 5555 ;; 5556 esac 5557 continue 5558 ;; 5559 5560 -l*) 5561 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then 5562 case $host in 5563 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) 5564 # These systems don't actually have a C or math library (as such) 5565 continue 5566 ;; 5567 *-*-os2*) 5568 # These systems don't actually have a C library (as such) 5569 test "X$arg" = "X-lc" && continue 5570 ;; 5571 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 5572 # Do not include libc due to us having libc/libc_r. 5573 test "X$arg" = "X-lc" && continue 5574 ;; 5575 *-*-rhapsody* | *-*-darwin1.[012]) 5576 # Rhapsody C and math libraries are in the System framework 5577 func_append deplibs " System.ltframework" 5578 continue 5579 ;; 5580 *-*-sco3.2v5* | *-*-sco5v6*) 5581 # Causes problems with __ctype 5582 test "X$arg" = "X-lc" && continue 5583 ;; 5584 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) 5585 # Compiler inserts libc in the correct place for threads to work 5586 test "X$arg" = "X-lc" && continue 5587 ;; 5588 esac 5589 elif test "X$arg" = "X-lc_r"; then 5590 case $host in 5591 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 5592 # Do not include libc_r directly, use -pthread flag. 5593 continue 5594 ;; 5595 esac 5596 fi 5597 func_append deplibs " $arg" 5598 continue 5599 ;; 5600 5601 -module) 5602 module=yes 5603 continue 5604 ;; 5605 5606 # Tru64 UNIX uses -model [arg] to determine the layout of C++ 5607 # classes, name mangling, and exception handling. 5608 # Darwin uses the -arch flag to determine output architecture. 5609 -model|-arch|-isysroot|--sysroot) 5610 func_append compiler_flags " $arg" 5611 func_append compile_command " $arg" 5612 func_append finalize_command " $arg" 5613 prev=xcompiler 5614 continue 5615 ;; 5616 5617 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ 5618 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) 5619 func_append compiler_flags " $arg" 5620 func_append compile_command " $arg" 5621 func_append finalize_command " $arg" 5622 func_append deplibs " $arg" 5623 case "$new_inherited_linker_flags " in 5624 *" $arg "*) ;; 5625 * ) func_append new_inherited_linker_flags " $arg" ;; 5626 esac 5627 continue 5628 ;; 5629 5630 -multi_module) 5631 single_module="${wl}-multi_module" 5632 continue 5633 ;; 5634 5635 -no-fast-install) 5636 fast_install=no 5637 continue 5638 ;; 5639 5640 -no-install) 5641 case $host in 5642 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) 5643 # The PATH hackery in wrapper scripts is required on Windows 5644 # and Darwin in order for the loader to find any dlls it needs. 5645 func_warning "\`-no-install' is ignored for $host" 5646 func_warning "assuming \`-no-fast-install' instead" 5647 fast_install=no 5648 ;; 5649 *) no_install=yes ;; 5650 esac 5651 continue 5652 ;; 5653 5654 -no-undefined) 5655 allow_undefined=no 5656 continue 5657 ;; 5658 5659 -objectlist) 5660 prev=objectlist 5661 continue 5662 ;; 5663 5664 -o) prev=output ;; 5665 5666 -precious-files-regex) 5667 prev=precious_regex 5668 continue 5669 ;; 5670 5671 -release) 5672 prev=release 5673 continue 5674 ;; 5675 5676 -rpath) 5677 prev=rpath 5678 continue 5679 ;; 5680 5681 -R) 5682 prev=xrpath 5683 continue 5684 ;; 5685 5686 -R*) 5687 func_stripname '-R' '' "$arg" 5688 dir=$func_stripname_result 5689 # We need an absolute path. 5690 case $dir in 5691 [\\/]* | [A-Za-z]:[\\/]*) ;; 5692 =*) 5693 func_stripname '=' '' "$dir" 5694 dir=$lt_sysroot$func_stripname_result 5695 ;; 5696 *) 5697 func_fatal_error "only absolute run-paths are allowed" 5698 ;; 5699 esac 5700 case "$xrpath " in 5701 *" $dir "*) ;; 5702 *) func_append xrpath " $dir" ;; 5703 esac 5704 continue 5705 ;; 5706 5707 -shared) 5708 # The effects of -shared are defined in a previous loop. 5709 continue 5710 ;; 5711 5712 -shrext) 5713 prev=shrext 5714 continue 5715 ;; 5716 5717 -static | -static-libtool-libs) 5718 # The effects of -static are defined in a previous loop. 5719 # We used to do the same as -all-static on platforms that 5720 # didn't have a PIC flag, but the assumption that the effects 5721 # would be equivalent was wrong. It would break on at least 5722 # Digital Unix and AIX. 5723 continue 5724 ;; 5725 5726 -thread-safe) 5727 thread_safe=yes 5728 continue 5729 ;; 5730 5731 -version-info) 5732 prev=vinfo 5733 continue 5734 ;; 5735 5736 -version-number) 5737 prev=vinfo 5738 vinfo_number=yes 5739 continue 5740 ;; 5741 5742 -weak) 5743 prev=weak 5744 continue 5745 ;; 5746 5747 -Wc,*) 5748 func_stripname '-Wc,' '' "$arg" 5749 args=$func_stripname_result 5750 arg= 5751 save_ifs="$IFS"; IFS=',' 5752 for flag in $args; do 5753 IFS="$save_ifs" 5754 func_quote_for_eval "$flag" 5755 func_append arg " $func_quote_for_eval_result" 5756 func_append compiler_flags " $func_quote_for_eval_result" 5757 done 5758 IFS="$save_ifs" 5759 func_stripname ' ' '' "$arg" 5760 arg=$func_stripname_result 5761 ;; 5762 5763 -Wl,*) 5764 func_stripname '-Wl,' '' "$arg" 5765 args=$func_stripname_result 5766 arg= 5767 save_ifs="$IFS"; IFS=',' 5768 for flag in $args; do 5769 IFS="$save_ifs" 5770 func_quote_for_eval "$flag" 5771 func_append arg " $wl$func_quote_for_eval_result" 5772 func_append compiler_flags " $wl$func_quote_for_eval_result" 5773 func_append linker_flags " $func_quote_for_eval_result" 5774 done 5775 IFS="$save_ifs" 5776 func_stripname ' ' '' "$arg" 5777 arg=$func_stripname_result 5778 ;; 5779 5780 -Xcompiler) 5781 prev=xcompiler 5782 continue 5783 ;; 5784 5785 -Xlinker) 5786 prev=xlinker 5787 continue 5788 ;; 5789 5790 -XCClinker) 5791 prev=xcclinker 5792 continue 5793 ;; 5794 5795 # -msg_* for osf cc 5796 -msg_*) 5797 func_quote_for_eval "$arg" 5798 arg="$func_quote_for_eval_result" 5799 ;; 5800 5801 # Flags to be passed through unchanged, with rationale: 5802 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler 5803 # -r[0-9][0-9]* specify processor for the SGI compiler 5804 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler 5805 # +DA*, +DD* enable 64-bit mode for the HP compiler 5806 # -q* compiler args for the IBM compiler 5807 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC 5808 # -F/path path to uninstalled frameworks, gcc on darwin 5809 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC 5810 # @file GCC response files 5811 # -tp=* Portland pgcc target processor selection 5812 # --sysroot=* for sysroot support 5813 # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization 5814 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ 5815 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ 5816 -O*|-flto*|-fwhopr*|-fuse-linker-plugin) 5817 func_quote_for_eval "$arg" 5818 arg="$func_quote_for_eval_result" 5819 func_append compile_command " $arg" 5820 func_append finalize_command " $arg" 5821 func_append compiler_flags " $arg" 5822 continue 5823 ;; 5824 5825 # Some other compiler flag. 5826 -* | +*) 5827 func_quote_for_eval "$arg" 5828 arg="$func_quote_for_eval_result" 5829 ;; 5830 5831 *.$objext) 5832 # A standard object. 5833 func_append objs " $arg" 5834 ;; 5835 5836 *.lo) 5837 # A libtool-controlled object. 5838 5839 # Check to see that this really is a libtool object. 5840 if func_lalib_unsafe_p "$arg"; then 5841 pic_object= 5842 non_pic_object= 5843 5844 # Read the .lo file 5845 func_source "$arg" 5846 5847 if test -z "$pic_object" || 5848 test -z "$non_pic_object" || 5849 test "$pic_object" = none && 5850 test "$non_pic_object" = none; then 5851 func_fatal_error "cannot find name of object for \`$arg'" 5852 fi 5853 5854 # Extract subdirectory from the argument. 5855 func_dirname "$arg" "/" "" 5856 xdir="$func_dirname_result" 5857 5858 if test "$pic_object" != none; then 5859 # Prepend the subdirectory the object is found in. 5860 pic_object="$xdir$pic_object" 5861 5862 if test "$prev" = dlfiles; then 5863 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then 5864 func_append dlfiles " $pic_object" 5865 prev= 5866 continue 5867 else 5868 # If libtool objects are unsupported, then we need to preload. 5869 prev=dlprefiles 5870 fi 5871 fi 5872 5873 # CHECK ME: I think I busted this. -Ossama 5874 if test "$prev" = dlprefiles; then 5875 # Preload the old-style object. 5876 func_append dlprefiles " $pic_object" 5877 prev= 5878 fi 5879 5880 # A PIC object. 5881 func_append libobjs " $pic_object" 5882 arg="$pic_object" 5883 fi 5884 5885 # Non-PIC object. 5886 if test "$non_pic_object" != none; then 5887 # Prepend the subdirectory the object is found in. 5888 non_pic_object="$xdir$non_pic_object" 5889 5890 # A standard non-PIC object 5891 func_append non_pic_objects " $non_pic_object" 5892 if test -z "$pic_object" || test "$pic_object" = none ; then 5893 arg="$non_pic_object" 5894 fi 5895 else 5896 # If the PIC object exists, use it instead. 5897 # $xdir was prepended to $pic_object above. 5898 non_pic_object="$pic_object" 5899 func_append non_pic_objects " $non_pic_object" 5900 fi 5901 else 5902 # Only an error if not doing a dry-run. 5903 if $opt_dry_run; then 5904 # Extract subdirectory from the argument. 5905 func_dirname "$arg" "/" "" 5906 xdir="$func_dirname_result" 5907 5908 func_lo2o "$arg" 5909 pic_object=$xdir$objdir/$func_lo2o_result 5910 non_pic_object=$xdir$func_lo2o_result 5911 func_append libobjs " $pic_object" 5912 func_append non_pic_objects " $non_pic_object" 5913 else 5914 func_fatal_error "\`$arg' is not a valid libtool object" 5915 fi 5916 fi 5917 ;; 5918 5919 *.$libext) 5920 # An archive. 5921 func_append deplibs " $arg" 5922 func_append old_deplibs " $arg" 5923 continue 5924 ;; 5925 5926 *.la) 5927 # A libtool-controlled library. 5928 5929 func_resolve_sysroot "$arg" 5930 if test "$prev" = dlfiles; then 5931 # This library was specified with -dlopen. 5932 func_append dlfiles " $func_resolve_sysroot_result" 5933 prev= 5934 elif test "$prev" = dlprefiles; then 5935 # The library was specified with -dlpreopen. 5936 func_append dlprefiles " $func_resolve_sysroot_result" 5937 prev= 5938 else 5939 func_append deplibs " $func_resolve_sysroot_result" 5940 fi 5941 continue 5942 ;; 5943 5944 # Some other compiler argument. 5945 *) 5946 # Unknown arguments in both finalize_command and compile_command need 5947 # to be aesthetically quoted because they are evaled later. 5948 func_quote_for_eval "$arg" 5949 arg="$func_quote_for_eval_result" 5950 ;; 5951 esac # arg 5952 5953 # Now actually substitute the argument into the commands. 5954 if test -n "$arg"; then 5955 func_append compile_command " $arg" 5956 func_append finalize_command " $arg" 5957 fi 5958 done # argument parsing loop 5959 5960 test -n "$prev" && \ 5961 func_fatal_help "the \`$prevarg' option requires an argument" 5962 5963 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then 5964 eval arg=\"$export_dynamic_flag_spec\" 5965 func_append compile_command " $arg" 5966 func_append finalize_command " $arg" 5967 fi 5968 5969 oldlibs= 5970 # calculate the name of the file, without its directory 5971 func_basename "$output" 5972 outputname="$func_basename_result" 5973 libobjs_save="$libobjs" 5974 5975 if test -n "$shlibpath_var"; then 5976 # get the directories listed in $shlibpath_var 5977 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\` 5978 else 5979 shlib_search_path= 5980 fi 5981 eval sys_lib_search_path=\"$sys_lib_search_path_spec\" 5982 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" 5983 5984 func_dirname "$output" "/" "" 5985 output_objdir="$func_dirname_result$objdir" 5986 func_to_tool_file "$output_objdir/" 5987 tool_output_objdir=$func_to_tool_file_result 5988 # Create the object directory. 5989 func_mkdir_p "$output_objdir" 5990 5991 # Determine the type of output 5992 case $output in 5993 "") 5994 func_fatal_help "you must specify an output file" 5995 ;; 5996 *.$libext) linkmode=oldlib ;; 5997 *.lo | *.$objext) linkmode=obj ;; 5998 *.la) linkmode=lib ;; 5999 *) linkmode=prog ;; # Anything else should be a program. 6000 esac 6001 6002 specialdeplibs= 6003 6004 libs= 6005 # Find all interdependent deplibs by searching for libraries 6006 # that are linked more than once (e.g. -la -lb -la) 6007 for deplib in $deplibs; do 6008 if $opt_preserve_dup_deps ; then 6009 case "$libs " in 6010 *" $deplib "*) func_append specialdeplibs " $deplib" ;; 6011 esac 6012 fi 6013 func_append libs " $deplib" 6014 done 6015 6016 if test "$linkmode" = lib; then 6017 libs="$predeps $libs $compiler_lib_search_path $postdeps" 6018 6019 # Compute libraries that are listed more than once in $predeps 6020 # $postdeps and mark them as special (i.e., whose duplicates are 6021 # not to be eliminated). 6022 pre_post_deps= 6023 if $opt_duplicate_compiler_generated_deps; then 6024 for pre_post_dep in $predeps $postdeps; do 6025 case "$pre_post_deps " in 6026 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; 6027 esac 6028 func_append pre_post_deps " $pre_post_dep" 6029 done 6030 fi 6031 pre_post_deps= 6032 fi 6033 6034 deplibs= 6035 newdependency_libs= 6036 newlib_search_path= 6037 need_relink=no # whether we're linking any uninstalled libtool libraries 6038 notinst_deplibs= # not-installed libtool libraries 6039 notinst_path= # paths that contain not-installed libtool libraries 6040 6041 case $linkmode in 6042 lib) 6043 passes="conv dlpreopen link" 6044 for file in $dlfiles $dlprefiles; do 6045 case $file in 6046 *.la) ;; 6047 *) 6048 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" 6049 ;; 6050 esac 6051 done 6052 ;; 6053 prog) 6054 compile_deplibs= 6055 finalize_deplibs= 6056 alldeplibs=no 6057 newdlfiles= 6058 newdlprefiles= 6059 passes="conv scan dlopen dlpreopen link" 6060 ;; 6061 *) passes="conv" 6062 ;; 6063 esac 6064 6065 for pass in $passes; do 6066 # The preopen pass in lib mode reverses $deplibs; put it back here 6067 # so that -L comes before libs that need it for instance... 6068 if test "$linkmode,$pass" = "lib,link"; then 6069 ## FIXME: Find the place where the list is rebuilt in the wrong 6070 ## order, and fix it there properly 6071 tmp_deplibs= 6072 for deplib in $deplibs; do 6073 tmp_deplibs="$deplib $tmp_deplibs" 6074 done 6075 deplibs="$tmp_deplibs" 6076 fi 6077 6078 if test "$linkmode,$pass" = "lib,link" || 6079 test "$linkmode,$pass" = "prog,scan"; then 6080 libs="$deplibs" 6081 deplibs= 6082 fi 6083 if test "$linkmode" = prog; then 6084 case $pass in 6085 dlopen) libs="$dlfiles" ;; 6086 dlpreopen) libs="$dlprefiles" ;; 6087 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; 6088 esac 6089 fi 6090 if test "$linkmode,$pass" = "lib,dlpreopen"; then 6091 # Collect and forward deplibs of preopened libtool libs 6092 for lib in $dlprefiles; do 6093 # Ignore non-libtool-libs 6094 dependency_libs= 6095 func_resolve_sysroot "$lib" 6096 case $lib in 6097 *.la) func_source "$func_resolve_sysroot_result" ;; 6098 esac 6099 6100 # Collect preopened libtool deplibs, except any this library 6101 # has declared as weak libs 6102 for deplib in $dependency_libs; do 6103 func_basename "$deplib" 6104 deplib_base=$func_basename_result 6105 case " $weak_libs " in 6106 *" $deplib_base "*) ;; 6107 *) func_append deplibs " $deplib" ;; 6108 esac 6109 done 6110 done 6111 libs="$dlprefiles" 6112 fi 6113 if test "$pass" = dlopen; then 6114 # Collect dlpreopened libraries 6115 save_deplibs="$deplibs" 6116 deplibs= 6117 fi 6118 6119 for deplib in $libs; do 6120 lib= 6121 found=no 6122 case $deplib in 6123 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ 6124 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) 6125 if test "$linkmode,$pass" = "prog,link"; then 6126 compile_deplibs="$deplib $compile_deplibs" 6127 finalize_deplibs="$deplib $finalize_deplibs" 6128 else 6129 func_append compiler_flags " $deplib" 6130 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 6131 if test "$linkmode" = lib ; then 6132 case "$new_inherited_linker_flags " in 6133 *" $deplib "*) ;; 6134 * ) func_append new_inherited_linker_flags " $deplib" ;; 6135 esac 6136 fi 6137 fi 6138 continue 6139 ;; 6140 -l*) 6141 if test "$linkmode" != lib && test "$linkmode" != prog; then 6142 func_warning "\`-l' is ignored for archives/objects" 6143 continue 6144 fi 6145 func_stripname '-l' '' "$deplib" 6146 name=$func_stripname_result 6147 if test "$linkmode" = lib; then 6148 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" 6149 else 6150 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" 6151 fi 6152 for searchdir in $searchdirs; do 6153 for search_ext in .la $std_shrext .so .a; do 6154 # Search the libtool library 6155 lib="$searchdir/lib${name}${search_ext}" 6156 if test -f "$lib"; then 6157 if test "$search_ext" = ".la"; then 6158 found=yes 6159 else 6160 found=no 6161 fi 6162 break 2 6163 fi 6164 done 6165 done 6166 if test "$found" != yes; then 6167 # deplib doesn't seem to be a libtool library 6168 if test "$linkmode,$pass" = "prog,link"; then 6169 compile_deplibs="$deplib $compile_deplibs" 6170 finalize_deplibs="$deplib $finalize_deplibs" 6171 else 6172 deplibs="$deplib $deplibs" 6173 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 6174 fi 6175 continue 6176 else # deplib is a libtool library 6177 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, 6178 # We need to do some special things here, and not later. 6179 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6180 case " $predeps $postdeps " in 6181 *" $deplib "*) 6182 if func_lalib_p "$lib"; then 6183 library_names= 6184 old_library= 6185 func_source "$lib" 6186 for l in $old_library $library_names; do 6187 ll="$l" 6188 done 6189 if test "X$ll" = "X$old_library" ; then # only static version available 6190 found=no 6191 func_dirname "$lib" "" "." 6192 ladir="$func_dirname_result" 6193 lib=$ladir/$old_library 6194 if test "$linkmode,$pass" = "prog,link"; then 6195 compile_deplibs="$deplib $compile_deplibs" 6196 finalize_deplibs="$deplib $finalize_deplibs" 6197 else 6198 deplibs="$deplib $deplibs" 6199 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 6200 fi 6201 continue 6202 fi 6203 fi 6204 ;; 6205 *) ;; 6206 esac 6207 fi 6208 fi 6209 ;; # -l 6210 *.ltframework) 6211 if test "$linkmode,$pass" = "prog,link"; then 6212 compile_deplibs="$deplib $compile_deplibs" 6213 finalize_deplibs="$deplib $finalize_deplibs" 6214 else 6215 deplibs="$deplib $deplibs" 6216 if test "$linkmode" = lib ; then 6217 case "$new_inherited_linker_flags " in 6218 *" $deplib "*) ;; 6219 * ) func_append new_inherited_linker_flags " $deplib" ;; 6220 esac 6221 fi 6222 fi 6223 continue 6224 ;; 6225 -L*) 6226 case $linkmode in 6227 lib) 6228 deplibs="$deplib $deplibs" 6229 test "$pass" = conv && continue 6230 newdependency_libs="$deplib $newdependency_libs" 6231 func_stripname '-L' '' "$deplib" 6232 func_resolve_sysroot "$func_stripname_result" 6233 func_append newlib_search_path " $func_resolve_sysroot_result" 6234 ;; 6235 prog) 6236 if test "$pass" = conv; then 6237 deplibs="$deplib $deplibs" 6238 continue 6239 fi 6240 if test "$pass" = scan; then 6241 deplibs="$deplib $deplibs" 6242 else 6243 compile_deplibs="$deplib $compile_deplibs" 6244 finalize_deplibs="$deplib $finalize_deplibs" 6245 fi 6246 func_stripname '-L' '' "$deplib" 6247 func_resolve_sysroot "$func_stripname_result" 6248 func_append newlib_search_path " $func_resolve_sysroot_result" 6249 ;; 6250 *) 6251 func_warning "\`-L' is ignored for archives/objects" 6252 ;; 6253 esac # linkmode 6254 continue 6255 ;; # -L 6256 -R*) 6257 if test "$pass" = link; then 6258 func_stripname '-R' '' "$deplib" 6259 func_resolve_sysroot "$func_stripname_result" 6260 dir=$func_resolve_sysroot_result 6261 # Make sure the xrpath contains only unique directories. 6262 case "$xrpath " in 6263 *" $dir "*) ;; 6264 *) func_append xrpath " $dir" ;; 6265 esac 6266 fi 6267 deplibs="$deplib $deplibs" 6268 continue 6269 ;; 6270 *.la) 6271 func_resolve_sysroot "$deplib" 6272 lib=$func_resolve_sysroot_result 6273 ;; 6274 *.$libext) 6275 if test "$pass" = conv; then 6276 deplibs="$deplib $deplibs" 6277 continue 6278 fi 6279 case $linkmode in 6280 lib) 6281 # Linking convenience modules into shared libraries is allowed, 6282 # but linking other static libraries is non-portable. 6283 case " $dlpreconveniencelibs " in 6284 *" $deplib "*) ;; 6285 *) 6286 valid_a_lib=no 6287 case $deplibs_check_method in 6288 match_pattern*) 6289 set dummy $deplibs_check_method; shift 6290 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 6291 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ 6292 | $EGREP "$match_pattern_regex" > /dev/null; then 6293 valid_a_lib=yes 6294 fi 6295 ;; 6296 pass_all) 6297 valid_a_lib=yes 6298 ;; 6299 esac 6300 if test "$valid_a_lib" != yes; then 6301 echo 6302 $ECHO "*** Warning: Trying to link with static lib archive $deplib." 6303 echo "*** I have the capability to make that library automatically link in when" 6304 echo "*** you link to this library. But I can only do this if you have a" 6305 echo "*** shared version of the library, which you do not appear to have" 6306 echo "*** because the file extensions .$libext of this argument makes me believe" 6307 echo "*** that it is just a static archive that I should not use here." 6308 else 6309 echo 6310 $ECHO "*** Warning: Linking the shared library $output against the" 6311 $ECHO "*** static library $deplib is not portable!" 6312 deplibs="$deplib $deplibs" 6313 fi 6314 ;; 6315 esac 6316 continue 6317 ;; 6318 prog) 6319 if test "$pass" != link; then 6320 deplibs="$deplib $deplibs" 6321 else 6322 compile_deplibs="$deplib $compile_deplibs" 6323 finalize_deplibs="$deplib $finalize_deplibs" 6324 fi 6325 continue 6326 ;; 6327 esac # linkmode 6328 ;; # *.$libext 6329 *.lo | *.$objext) 6330 if test "$pass" = conv; then 6331 deplibs="$deplib $deplibs" 6332 elif test "$linkmode" = prog; then 6333 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then 6334 # If there is no dlopen support or we're linking statically, 6335 # we need to preload. 6336 func_append newdlprefiles " $deplib" 6337 compile_deplibs="$deplib $compile_deplibs" 6338 finalize_deplibs="$deplib $finalize_deplibs" 6339 else 6340 func_append newdlfiles " $deplib" 6341 fi 6342 fi 6343 continue 6344 ;; 6345 %DEPLIBS%) 6346 alldeplibs=yes 6347 continue 6348 ;; 6349 esac # case $deplib 6350 6351 if test "$found" = yes || test -f "$lib"; then : 6352 else 6353 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" 6354 fi 6355 6356 # Check to see that this really is a libtool archive. 6357 func_lalib_unsafe_p "$lib" \ 6358 || func_fatal_error "\`$lib' is not a valid libtool archive" 6359 6360 func_dirname "$lib" "" "." 6361 ladir="$func_dirname_result" 6362 6363 dlname= 6364 dlopen= 6365 dlpreopen= 6366 libdir= 6367 library_names= 6368 old_library= 6369 inherited_linker_flags= 6370 # If the library was installed with an old release of libtool, 6371 # it will not redefine variables installed, or shouldnotlink 6372 installed=yes 6373 shouldnotlink=no 6374 avoidtemprpath= 6375 6376 6377 # Read the .la file 6378 func_source "$lib" 6379 6380 # Convert "-framework foo" to "foo.ltframework" 6381 if test -n "$inherited_linker_flags"; then 6382 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` 6383 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do 6384 case " $new_inherited_linker_flags " in 6385 *" $tmp_inherited_linker_flag "*) ;; 6386 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; 6387 esac 6388 done 6389 fi 6390 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 6391 if test "$linkmode,$pass" = "lib,link" || 6392 test "$linkmode,$pass" = "prog,scan" || 6393 { test "$linkmode" != prog && test "$linkmode" != lib; }; then 6394 test -n "$dlopen" && func_append dlfiles " $dlopen" 6395 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" 6396 fi 6397 6398 if test "$pass" = conv; then 6399 # Only check for convenience libraries 6400 deplibs="$lib $deplibs" 6401 if test -z "$libdir"; then 6402 if test -z "$old_library"; then 6403 func_fatal_error "cannot find name of link library for \`$lib'" 6404 fi 6405 # It is a libtool convenience library, so add in its objects. 6406 func_append convenience " $ladir/$objdir/$old_library" 6407 func_append old_convenience " $ladir/$objdir/$old_library" 6408 elif test "$linkmode" != prog && test "$linkmode" != lib; then 6409 func_fatal_error "\`$lib' is not a convenience library" 6410 fi 6411 tmp_libs= 6412 for deplib in $dependency_libs; do 6413 deplibs="$deplib $deplibs" 6414 if $opt_preserve_dup_deps ; then 6415 case "$tmp_libs " in 6416 *" $deplib "*) func_append specialdeplibs " $deplib" ;; 6417 esac 6418 fi 6419 func_append tmp_libs " $deplib" 6420 done 6421 continue 6422 fi # $pass = conv 6423 6424 6425 # Get the name of the library we link against. 6426 linklib= 6427 if test -n "$old_library" && 6428 { test "$prefer_static_libs" = yes || 6429 test "$prefer_static_libs,$installed" = "built,no"; }; then 6430 linklib=$old_library 6431 else 6432 for l in $old_library $library_names; do 6433 linklib="$l" 6434 done 6435 fi 6436 if test -z "$linklib"; then 6437 func_fatal_error "cannot find name of link library for \`$lib'" 6438 fi 6439 6440 # This library was specified with -dlopen. 6441 if test "$pass" = dlopen; then 6442 if test -z "$libdir"; then 6443 func_fatal_error "cannot -dlopen a convenience library: \`$lib'" 6444 fi 6445 if test -z "$dlname" || 6446 test "$dlopen_support" != yes || 6447 test "$build_libtool_libs" = no; then 6448 # If there is no dlname, no dlopen support or we're linking 6449 # statically, we need to preload. We also need to preload any 6450 # dependent libraries so libltdl's deplib preloader doesn't 6451 # bomb out in the load deplibs phase. 6452 func_append dlprefiles " $lib $dependency_libs" 6453 else 6454 func_append newdlfiles " $lib" 6455 fi 6456 continue 6457 fi # $pass = dlopen 6458 6459 # We need an absolute path. 6460 case $ladir in 6461 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; 6462 *) 6463 abs_ladir=`cd "$ladir" && pwd` 6464 if test -z "$abs_ladir"; then 6465 func_warning "cannot determine absolute directory name of \`$ladir'" 6466 func_warning "passing it literally to the linker, although it might fail" 6467 abs_ladir="$ladir" 6468 fi 6469 ;; 6470 esac 6471 func_basename "$lib" 6472 laname="$func_basename_result" 6473 6474 # Find the relevant object directory and library name. 6475 if test "X$installed" = Xyes; then 6476 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then 6477 func_warning "library \`$lib' was moved." 6478 dir="$ladir" 6479 absdir="$abs_ladir" 6480 libdir="$abs_ladir" 6481 else 6482 dir="$lt_sysroot$libdir" 6483 absdir="$lt_sysroot$libdir" 6484 fi 6485 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes 6486 else 6487 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then 6488 dir="$ladir" 6489 absdir="$abs_ladir" 6490 # Remove this search path later 6491 func_append notinst_path " $abs_ladir" 6492 else 6493 dir="$ladir/$objdir" 6494 absdir="$abs_ladir/$objdir" 6495 # Remove this search path later 6496 func_append notinst_path " $abs_ladir" 6497 fi 6498 fi # $installed = yes 6499 func_stripname 'lib' '.la' "$laname" 6500 name=$func_stripname_result 6501 6502 # This library was specified with -dlpreopen. 6503 if test "$pass" = dlpreopen; then 6504 if test -z "$libdir" && test "$linkmode" = prog; then 6505 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" 6506 fi 6507 case "$host" in 6508 # special handling for platforms with PE-DLLs. 6509 *cygwin* | *mingw* | *cegcc* ) 6510 # Linker will automatically link against shared library if both 6511 # static and shared are present. Therefore, ensure we extract 6512 # symbols from the import library if a shared library is present 6513 # (otherwise, the dlopen module name will be incorrect). We do 6514 # this by putting the import library name into $newdlprefiles. 6515 # We recover the dlopen module name by 'saving' the la file 6516 # name in a special purpose variable, and (later) extracting the 6517 # dlname from the la file. 6518 if test -n "$dlname"; then 6519 func_tr_sh "$dir/$linklib" 6520 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" 6521 func_append newdlprefiles " $dir/$linklib" 6522 else 6523 func_append newdlprefiles " $dir/$old_library" 6524 # Keep a list of preopened convenience libraries to check 6525 # that they are being used correctly in the link pass. 6526 test -z "$libdir" && \ 6527 func_append dlpreconveniencelibs " $dir/$old_library" 6528 fi 6529 ;; 6530 * ) 6531 # Prefer using a static library (so that no silly _DYNAMIC symbols 6532 # are required to link). 6533 if test -n "$old_library"; then 6534 func_append newdlprefiles " $dir/$old_library" 6535 # Keep a list of preopened convenience libraries to check 6536 # that they are being used correctly in the link pass. 6537 test -z "$libdir" && \ 6538 func_append dlpreconveniencelibs " $dir/$old_library" 6539 # Otherwise, use the dlname, so that lt_dlopen finds it. 6540 elif test -n "$dlname"; then 6541 func_append newdlprefiles " $dir/$dlname" 6542 else 6543 func_append newdlprefiles " $dir/$linklib" 6544 fi 6545 ;; 6546 esac 6547 fi # $pass = dlpreopen 6548 6549 if test -z "$libdir"; then 6550 # Link the convenience library 6551 if test "$linkmode" = lib; then 6552 deplibs="$dir/$old_library $deplibs" 6553 elif test "$linkmode,$pass" = "prog,link"; then 6554 compile_deplibs="$dir/$old_library $compile_deplibs" 6555 finalize_deplibs="$dir/$old_library $finalize_deplibs" 6556 else 6557 deplibs="$lib $deplibs" # used for prog,scan pass 6558 fi 6559 continue 6560 fi 6561 6562 6563 if test "$linkmode" = prog && test "$pass" != link; then 6564 func_append newlib_search_path " $ladir" 6565 deplibs="$lib $deplibs" 6566 6567 linkalldeplibs=no 6568 if test "$link_all_deplibs" != no || test -z "$library_names" || 6569 test "$build_libtool_libs" = no; then 6570 linkalldeplibs=yes 6571 fi 6572 6573 tmp_libs= 6574 for deplib in $dependency_libs; do 6575 case $deplib in 6576 -L*) func_stripname '-L' '' "$deplib" 6577 func_resolve_sysroot "$func_stripname_result" 6578 func_append newlib_search_path " $func_resolve_sysroot_result" 6579 ;; 6580 esac 6581 # Need to link against all dependency_libs? 6582 if test "$linkalldeplibs" = yes; then 6583 deplibs="$deplib $deplibs" 6584 else 6585 # Need to hardcode shared library paths 6586 # or/and link against static libraries 6587 newdependency_libs="$deplib $newdependency_libs" 6588 fi 6589 if $opt_preserve_dup_deps ; then 6590 case "$tmp_libs " in 6591 *" $deplib "*) func_append specialdeplibs " $deplib" ;; 6592 esac 6593 fi 6594 func_append tmp_libs " $deplib" 6595 done # for deplib 6596 continue 6597 fi # $linkmode = prog... 6598 6599 if test "$linkmode,$pass" = "prog,link"; then 6600 if test -n "$library_names" && 6601 { { test "$prefer_static_libs" = no || 6602 test "$prefer_static_libs,$installed" = "built,yes"; } || 6603 test -z "$old_library"; }; then 6604 # We need to hardcode the library path 6605 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then 6606 # Make sure the rpath contains only unique directories. 6607 case "$temp_rpath:" in 6608 *"$absdir:"*) ;; 6609 *) func_append temp_rpath "$absdir:" ;; 6610 esac 6611 fi 6612 6613 # Hardcode the library path. 6614 # Skip directories that are in the system default run-time 6615 # search path. 6616 case " $sys_lib_dlsearch_path " in 6617 *" $absdir "*) ;; 6618 *) 6619 case "$compile_rpath " in 6620 *" $absdir "*) ;; 6621 *) func_append compile_rpath " $absdir" ;; 6622 esac 6623 ;; 6624 esac 6625 case " $sys_lib_dlsearch_path " in 6626 *" $libdir "*) ;; 6627 *) 6628 case "$finalize_rpath " in 6629 *" $libdir "*) ;; 6630 *) func_append finalize_rpath " $libdir" ;; 6631 esac 6632 ;; 6633 esac 6634 fi # $linkmode,$pass = prog,link... 6635 6636 if test "$alldeplibs" = yes && 6637 { test "$deplibs_check_method" = pass_all || 6638 { test "$build_libtool_libs" = yes && 6639 test -n "$library_names"; }; }; then 6640 # We only need to search for static libraries 6641 continue 6642 fi 6643 fi 6644 6645 link_static=no # Whether the deplib will be linked statically 6646 use_static_libs=$prefer_static_libs 6647 if test "$use_static_libs" = built && test "$installed" = yes; then 6648 use_static_libs=no 6649 fi 6650 if test -n "$library_names" && 6651 { test "$use_static_libs" = no || test -z "$old_library"; }; then 6652 case $host in 6653 *cygwin* | *mingw* | *cegcc*) 6654 # No point in relinking DLLs because paths are not encoded 6655 func_append notinst_deplibs " $lib" 6656 need_relink=no 6657 ;; 6658 *) 6659 if test "$installed" = no; then 6660 func_append notinst_deplibs " $lib" 6661 test -z "$DESTDIR" && need_relink=yes 6662 fi 6663 ;; 6664 esac 6665 # This is a shared library 6666 6667 # Warn about portability, can't link against -module's on some 6668 # systems (darwin). Don't bleat about dlopened modules though! 6669 dlopenmodule="" 6670 for dlpremoduletest in $dlprefiles; do 6671 if test "X$dlpremoduletest" = "X$lib"; then 6672 dlopenmodule="$dlpremoduletest" 6673 break 6674 fi 6675 done 6676 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then 6677 echo 6678 if test "$linkmode" = prog; then 6679 $ECHO "*** Warning: Linking the executable $output against the loadable module" 6680 else 6681 $ECHO "*** Warning: Linking the shared library $output against the loadable module" 6682 fi 6683 $ECHO "*** $linklib is not portable!" 6684 fi 6685 if test "$linkmode" = lib && 6686 test "$hardcode_into_libs" = yes; then 6687 # Hardcode the library path. 6688 # Skip directories that are in the system default run-time 6689 # search path. 6690 case " $sys_lib_dlsearch_path " in 6691 *" $absdir "*) ;; 6692 *) 6693 case "$compile_rpath " in 6694 *" $absdir "*) ;; 6695 *) func_append compile_rpath " $absdir" ;; 6696 esac 6697 ;; 6698 esac 6699 case " $sys_lib_dlsearch_path " in 6700 *" $libdir "*) ;; 6701 *) 6702 case "$finalize_rpath " in 6703 *" $libdir "*) ;; 6704 *) func_append finalize_rpath " $libdir" ;; 6705 esac 6706 ;; 6707 esac 6708 fi 6709 6710 if test -n "$old_archive_from_expsyms_cmds"; then 6711 # figure out the soname 6712 set dummy $library_names 6713 shift 6714 realname="$1" 6715 shift 6716 libname=`eval "\\$ECHO \"$libname_spec\""` 6717 # use dlname if we got it. it's perfectly good, no? 6718 if test -n "$dlname"; then 6719 soname="$dlname" 6720 elif test -n "$soname_spec"; then 6721 # bleh windows 6722 case $host in 6723 *cygwin* | mingw* | *cegcc*) 6724 func_arith $current - $age 6725 major=$func_arith_result 6726 versuffix="-$major" 6727 ;; 6728 esac 6729 eval soname=\"$soname_spec\" 6730 else 6731 soname="$realname" 6732 fi 6733 6734 # Make a new name for the extract_expsyms_cmds to use 6735 soroot="$soname" 6736 func_basename "$soroot" 6737 soname="$func_basename_result" 6738 func_stripname 'lib' '.dll' "$soname" 6739 newlib=libimp-$func_stripname_result.a 6740 6741 # If the library has no export list, then create one now 6742 if test -f "$output_objdir/$soname-def"; then : 6743 else 6744 func_verbose "extracting exported symbol list from \`$soname'" 6745 func_execute_cmds "$extract_expsyms_cmds" 'exit $?' 6746 fi 6747 6748 # Create $newlib 6749 if test -f "$output_objdir/$newlib"; then :; else 6750 func_verbose "generating import library for \`$soname'" 6751 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' 6752 fi 6753 # make sure the library variables are pointing to the new library 6754 dir=$output_objdir 6755 linklib=$newlib 6756 fi # test -n "$old_archive_from_expsyms_cmds" 6757 6758 if test "$linkmode" = prog || test "$opt_mode" != relink; then 6759 add_shlibpath= 6760 add_dir= 6761 add= 6762 lib_linked=yes 6763 case $hardcode_action in 6764 immediate | unsupported) 6765 if test "$hardcode_direct" = no; then 6766 add="$dir/$linklib" 6767 case $host in 6768 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; 6769 *-*-sysv4*uw2*) add_dir="-L$dir" ;; 6770 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ 6771 *-*-unixware7*) add_dir="-L$dir" ;; 6772 *-*-darwin* ) 6773 # if the lib is a (non-dlopened) module then we can not 6774 # link against it, someone is ignoring the earlier warnings 6775 if /usr/bin/file -L $add 2> /dev/null | 6776 $GREP ": [^:]* bundle" >/dev/null ; then 6777 if test "X$dlopenmodule" != "X$lib"; then 6778 $ECHO "*** Warning: lib $linklib is a module, not a shared library" 6779 if test -z "$old_library" ; then 6780 echo 6781 echo "*** And there doesn't seem to be a static archive available" 6782 echo "*** The link will probably fail, sorry" 6783 else 6784 add="$dir/$old_library" 6785 fi 6786 elif test -n "$old_library"; then 6787 add="$dir/$old_library" 6788 fi 6789 fi 6790 esac 6791 elif test "$hardcode_minus_L" = no; then 6792 case $host in 6793 *-*-sunos*) add_shlibpath="$dir" ;; 6794 esac 6795 add_dir="-L$dir" 6796 add="-l$name" 6797 elif test "$hardcode_shlibpath_var" = no; then 6798 add_shlibpath="$dir" 6799 add="-l$name" 6800 else 6801 lib_linked=no 6802 fi 6803 ;; 6804 relink) 6805 if test "$hardcode_direct" = yes && 6806 test "$hardcode_direct_absolute" = no; then 6807 add="$dir/$linklib" 6808 elif test "$hardcode_minus_L" = yes; then 6809 add_dir="-L$absdir" 6810 # Try looking first in the location we're being installed to. 6811 if test -n "$inst_prefix_dir"; then 6812 case $libdir in 6813 [\\/]*) 6814 func_append add_dir " -L$inst_prefix_dir$libdir" 6815 ;; 6816 esac 6817 fi 6818 add="-l$name" 6819 elif test "$hardcode_shlibpath_var" = yes; then 6820 add_shlibpath="$dir" 6821 add="-l$name" 6822 else 6823 lib_linked=no 6824 fi 6825 ;; 6826 *) lib_linked=no ;; 6827 esac 6828 6829 if test "$lib_linked" != yes; then 6830 func_fatal_configuration "unsupported hardcode properties" 6831 fi 6832 6833 if test -n "$add_shlibpath"; then 6834 case :$compile_shlibpath: in 6835 *":$add_shlibpath:"*) ;; 6836 *) func_append compile_shlibpath "$add_shlibpath:" ;; 6837 esac 6838 fi 6839 if test "$linkmode" = prog; then 6840 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" 6841 test -n "$add" && compile_deplibs="$add $compile_deplibs" 6842 else 6843 test -n "$add_dir" && deplibs="$add_dir $deplibs" 6844 test -n "$add" && deplibs="$add $deplibs" 6845 if test "$hardcode_direct" != yes && 6846 test "$hardcode_minus_L" != yes && 6847 test "$hardcode_shlibpath_var" = yes; then 6848 case :$finalize_shlibpath: in 6849 *":$libdir:"*) ;; 6850 *) func_append finalize_shlibpath "$libdir:" ;; 6851 esac 6852 fi 6853 fi 6854 fi 6855 6856 if test "$linkmode" = prog || test "$opt_mode" = relink; then 6857 add_shlibpath= 6858 add_dir= 6859 add= 6860 # Finalize command for both is simple: just hardcode it. 6861 if test "$hardcode_direct" = yes && 6862 test "$hardcode_direct_absolute" = no; then 6863 add="$libdir/$linklib" 6864 elif test "$hardcode_minus_L" = yes; then 6865 add_dir="-L$libdir" 6866 add="-l$name" 6867 elif test "$hardcode_shlibpath_var" = yes; then 6868 case :$finalize_shlibpath: in 6869 *":$libdir:"*) ;; 6870 *) func_append finalize_shlibpath "$libdir:" ;; 6871 esac 6872 add="-l$name" 6873 elif test "$hardcode_automatic" = yes; then 6874 if test -n "$inst_prefix_dir" && 6875 test -f "$inst_prefix_dir$libdir/$linklib" ; then 6876 add="$inst_prefix_dir$libdir/$linklib" 6877 else 6878 add="$libdir/$linklib" 6879 fi 6880 else 6881 # We cannot seem to hardcode it, guess we'll fake it. 6882 add_dir="-L$libdir" 6883 # Try looking first in the location we're being installed to. 6884 if test -n "$inst_prefix_dir"; then 6885 case $libdir in 6886 [\\/]*) 6887 func_append add_dir " -L$inst_prefix_dir$libdir" 6888 ;; 6889 esac 6890 fi 6891 add="-l$name" 6892 fi 6893 6894 if test "$linkmode" = prog; then 6895 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" 6896 test -n "$add" && finalize_deplibs="$add $finalize_deplibs" 6897 else 6898 test -n "$add_dir" && deplibs="$add_dir $deplibs" 6899 test -n "$add" && deplibs="$add $deplibs" 6900 fi 6901 fi 6902 elif test "$linkmode" = prog; then 6903 # Here we assume that one of hardcode_direct or hardcode_minus_L 6904 # is not unsupported. This is valid on all known static and 6905 # shared platforms. 6906 if test "$hardcode_direct" != unsupported; then 6907 test -n "$old_library" && linklib="$old_library" 6908 compile_deplibs="$dir/$linklib $compile_deplibs" 6909 finalize_deplibs="$dir/$linklib $finalize_deplibs" 6910 else 6911 compile_deplibs="-l$name -L$dir $compile_deplibs" 6912 finalize_deplibs="-l$name -L$dir $finalize_deplibs" 6913 fi 6914 elif test "$build_libtool_libs" = yes; then 6915 # Not a shared library 6916 if test "$deplibs_check_method" != pass_all; then 6917 # We're trying link a shared library against a static one 6918 # but the system doesn't support it. 6919 6920 # Just print a warning and add the library to dependency_libs so 6921 # that the program can be linked against the static library. 6922 echo 6923 $ECHO "*** Warning: This system can not link to static lib archive $lib." 6924 echo "*** I have the capability to make that library automatically link in when" 6925 echo "*** you link to this library. But I can only do this if you have a" 6926 echo "*** shared version of the library, which you do not appear to have." 6927 if test "$module" = yes; then 6928 echo "*** But as you try to build a module library, libtool will still create " 6929 echo "*** a static module, that should work as long as the dlopening application" 6930 echo "*** is linked with the -dlopen flag to resolve symbols at runtime." 6931 if test -z "$global_symbol_pipe"; then 6932 echo 6933 echo "*** However, this would only work if libtool was able to extract symbol" 6934 echo "*** lists from a program, using \`nm' or equivalent, but libtool could" 6935 echo "*** not find such a program. So, this module is probably useless." 6936 echo "*** \`nm' from GNU binutils and a full rebuild may help." 6937 fi 6938 if test "$build_old_libs" = no; then 6939 build_libtool_libs=module 6940 build_old_libs=yes 6941 else 6942 build_libtool_libs=no 6943 fi 6944 fi 6945 else 6946 deplibs="$dir/$old_library $deplibs" 6947 link_static=yes 6948 fi 6949 fi # link shared/static library? 6950 6951 if test "$linkmode" = lib; then 6952 if test -n "$dependency_libs" && 6953 { test "$hardcode_into_libs" != yes || 6954 test "$build_old_libs" = yes || 6955 test "$link_static" = yes; }; then 6956 # Extract -R from dependency_libs 6957 temp_deplibs= 6958 for libdir in $dependency_libs; do 6959 case $libdir in 6960 -R*) func_stripname '-R' '' "$libdir" 6961 temp_xrpath=$func_stripname_result 6962 case " $xrpath " in 6963 *" $temp_xrpath "*) ;; 6964 *) func_append xrpath " $temp_xrpath";; 6965 esac;; 6966 *) func_append temp_deplibs " $libdir";; 6967 esac 6968 done 6969 dependency_libs="$temp_deplibs" 6970 fi 6971 6972 func_append newlib_search_path " $absdir" 6973 # Link against this library 6974 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" 6975 # ... and its dependency_libs 6976 tmp_libs= 6977 for deplib in $dependency_libs; do 6978 newdependency_libs="$deplib $newdependency_libs" 6979 case $deplib in 6980 -L*) func_stripname '-L' '' "$deplib" 6981 func_resolve_sysroot "$func_stripname_result";; 6982 *) func_resolve_sysroot "$deplib" ;; 6983 esac 6984 if $opt_preserve_dup_deps ; then 6985 case "$tmp_libs " in 6986 *" $func_resolve_sysroot_result "*) 6987 func_append specialdeplibs " $func_resolve_sysroot_result" ;; 6988 esac 6989 fi 6990 func_append tmp_libs " $func_resolve_sysroot_result" 6991 done 6992 6993 if test "$link_all_deplibs" != no; then 6994 # Add the search paths of all dependency libraries 6995 for deplib in $dependency_libs; do 6996 path= 6997 case $deplib in 6998 -L*) path="$deplib" ;; 6999 *.la) 7000 func_resolve_sysroot "$deplib" 7001 deplib=$func_resolve_sysroot_result 7002 func_dirname "$deplib" "" "." 7003 dir=$func_dirname_result 7004 # We need an absolute path. 7005 case $dir in 7006 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; 7007 *) 7008 absdir=`cd "$dir" && pwd` 7009 if test -z "$absdir"; then 7010 func_warning "cannot determine absolute directory name of \`$dir'" 7011 absdir="$dir" 7012 fi 7013 ;; 7014 esac 7015 if $GREP "^installed=no" $deplib > /dev/null; then 7016 case $host in 7017 *-*-darwin*) 7018 depdepl= 7019 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` 7020 if test -n "$deplibrary_names" ; then 7021 for tmp in $deplibrary_names ; do 7022 depdepl=$tmp 7023 done 7024 if test -f "$absdir/$objdir/$depdepl" ; then 7025 depdepl="$absdir/$objdir/$depdepl" 7026 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 7027 if test -z "$darwin_install_name"; then 7028 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 7029 fi 7030 func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" 7031 func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}" 7032 path= 7033 fi 7034 fi 7035 ;; 7036 *) 7037 path="-L$absdir/$objdir" 7038 ;; 7039 esac 7040 else 7041 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` 7042 test -z "$libdir" && \ 7043 func_fatal_error "\`$deplib' is not a valid libtool archive" 7044 test "$absdir" != "$libdir" && \ 7045 func_warning "\`$deplib' seems to be moved" 7046 7047 path="-L$absdir" 7048 fi 7049 ;; 7050 esac 7051 case " $deplibs " in 7052 *" $path "*) ;; 7053 *) deplibs="$path $deplibs" ;; 7054 esac 7055 done 7056 fi # link_all_deplibs != no 7057 fi # linkmode = lib 7058 done # for deplib in $libs 7059 if test "$pass" = link; then 7060 if test "$linkmode" = "prog"; then 7061 compile_deplibs="$new_inherited_linker_flags $compile_deplibs" 7062 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" 7063 else 7064 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 7065 fi 7066 fi 7067 dependency_libs="$newdependency_libs" 7068 if test "$pass" = dlpreopen; then 7069 # Link the dlpreopened libraries before other libraries 7070 for deplib in $save_deplibs; do 7071 deplibs="$deplib $deplibs" 7072 done 7073 fi 7074 if test "$pass" != dlopen; then 7075 if test "$pass" != conv; then 7076 # Make sure lib_search_path contains only unique directories. 7077 lib_search_path= 7078 for dir in $newlib_search_path; do 7079 case "$lib_search_path " in 7080 *" $dir "*) ;; 7081 *) func_append lib_search_path " $dir" ;; 7082 esac 7083 done 7084 newlib_search_path= 7085 fi 7086 7087 if test "$linkmode,$pass" != "prog,link"; then 7088 vars="deplibs" 7089 else 7090 vars="compile_deplibs finalize_deplibs" 7091 fi 7092 for var in $vars dependency_libs; do 7093 # Add libraries to $var in reverse order 7094 eval tmp_libs=\"\$$var\" 7095 new_libs= 7096 for deplib in $tmp_libs; do 7097 # FIXME: Pedantically, this is the right thing to do, so 7098 # that some nasty dependency loop isn't accidentally 7099 # broken: 7100 #new_libs="$deplib $new_libs" 7101 # Pragmatically, this seems to cause very few problems in 7102 # practice: 7103 case $deplib in 7104 -L*) new_libs="$deplib $new_libs" ;; 7105 -R*) ;; 7106 *) 7107 # And here is the reason: when a library appears more 7108 # than once as an explicit dependence of a library, or 7109 # is implicitly linked in more than once by the 7110 # compiler, it is considered special, and multiple 7111 # occurrences thereof are not removed. Compare this 7112 # with having the same library being listed as a 7113 # dependency of multiple other libraries: in this case, 7114 # we know (pedantically, we assume) the library does not 7115 # need to be listed more than once, so we keep only the 7116 # last copy. This is not always right, but it is rare 7117 # enough that we require users that really mean to play 7118 # such unportable linking tricks to link the library 7119 # using -Wl,-lname, so that libtool does not consider it 7120 # for duplicate removal. 7121 case " $specialdeplibs " in 7122 *" $deplib "*) new_libs="$deplib $new_libs" ;; 7123 *) 7124 case " $new_libs " in 7125 *" $deplib "*) ;; 7126 *) new_libs="$deplib $new_libs" ;; 7127 esac 7128 ;; 7129 esac 7130 ;; 7131 esac 7132 done 7133 tmp_libs= 7134 for deplib in $new_libs; do 7135 case $deplib in 7136 -L*) 7137 case " $tmp_libs " in 7138 *" $deplib "*) ;; 7139 *) func_append tmp_libs " $deplib" ;; 7140 esac 7141 ;; 7142 *) func_append tmp_libs " $deplib" ;; 7143 esac 7144 done 7145 eval $var=\"$tmp_libs\" 7146 done # for var 7147 fi 7148 # Last step: remove runtime libs from dependency_libs 7149 # (they stay in deplibs) 7150 tmp_libs= 7151 for i in $dependency_libs ; do 7152 case " $predeps $postdeps $compiler_lib_search_path " in 7153 *" $i "*) 7154 i="" 7155 ;; 7156 esac 7157 if test -n "$i" ; then 7158 func_append tmp_libs " $i" 7159 fi 7160 done 7161 dependency_libs=$tmp_libs 7162 done # for pass 7163 if test "$linkmode" = prog; then 7164 dlfiles="$newdlfiles" 7165 fi 7166 if test "$linkmode" = prog || test "$linkmode" = lib; then 7167 dlprefiles="$newdlprefiles" 7168 fi 7169 7170 case $linkmode in 7171 oldlib) 7172 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 7173 func_warning "\`-dlopen' is ignored for archives" 7174 fi 7175 7176 case " $deplibs" in 7177 *\ -l* | *\ -L*) 7178 func_warning "\`-l' and \`-L' are ignored for archives" ;; 7179 esac 7180 7181 test -n "$rpath" && \ 7182 func_warning "\`-rpath' is ignored for archives" 7183 7184 test -n "$xrpath" && \ 7185 func_warning "\`-R' is ignored for archives" 7186 7187 test -n "$vinfo" && \ 7188 func_warning "\`-version-info/-version-number' is ignored for archives" 7189 7190 test -n "$release" && \ 7191 func_warning "\`-release' is ignored for archives" 7192 7193 test -n "$export_symbols$export_symbols_regex" && \ 7194 func_warning "\`-export-symbols' is ignored for archives" 7195 7196 # Now set the variables for building old libraries. 7197 build_libtool_libs=no 7198 oldlibs="$output" 7199 func_append objs "$old_deplibs" 7200 ;; 7201 7202 lib) 7203 # Make sure we only generate libraries of the form `libNAME.la'. 7204 case $outputname in 7205 lib*) 7206 func_stripname 'lib' '.la' "$outputname" 7207 name=$func_stripname_result 7208 eval shared_ext=\"$shrext_cmds\" 7209 eval libname=\"$libname_spec\" 7210 ;; 7211 *) 7212 test "$module" = no && \ 7213 func_fatal_help "libtool library \`$output' must begin with \`lib'" 7214 7215 if test "$need_lib_prefix" != no; then 7216 # Add the "lib" prefix for modules if required 7217 func_stripname '' '.la' "$outputname" 7218 name=$func_stripname_result 7219 eval shared_ext=\"$shrext_cmds\" 7220 eval libname=\"$libname_spec\" 7221 else 7222 func_stripname '' '.la' "$outputname" 7223 libname=$func_stripname_result 7224 fi 7225 ;; 7226 esac 7227 7228 if test -n "$objs"; then 7229 if test "$deplibs_check_method" != pass_all; then 7230 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 7231 else 7232 echo 7233 $ECHO "*** Warning: Linking the shared library $output against the non-libtool" 7234 $ECHO "*** objects $objs is not portable!" 7235 func_append libobjs " $objs" 7236 fi 7237 fi 7238 7239 test "$dlself" != no && \ 7240 func_warning "\`-dlopen self' is ignored for libtool libraries" 7241 7242 set dummy $rpath 7243 shift 7244 test "$#" -gt 1 && \ 7245 func_warning "ignoring multiple \`-rpath's for a libtool library" 7246 7247 install_libdir="$1" 7248 7249 oldlibs= 7250 if test -z "$rpath"; then 7251 if test "$build_libtool_libs" = yes; then 7252 # Building a libtool convenience library. 7253 # Some compilers have problems with a `.al' extension so 7254 # convenience libraries should have the same extension an 7255 # archive normally would. 7256 oldlibs="$output_objdir/$libname.$libext $oldlibs" 7257 build_libtool_libs=convenience 7258 build_old_libs=yes 7259 fi 7260 7261 test -n "$vinfo" && \ 7262 func_warning "\`-version-info/-version-number' is ignored for convenience libraries" 7263 7264 test -n "$release" && \ 7265 func_warning "\`-release' is ignored for convenience libraries" 7266 else 7267 7268 # Parse the version information argument. 7269 save_ifs="$IFS"; IFS=':' 7270 set dummy $vinfo 0 0 0 7271 shift 7272 IFS="$save_ifs" 7273 7274 test -n "$7" && \ 7275 func_fatal_help "too many parameters to \`-version-info'" 7276 7277 # convert absolute version numbers to libtool ages 7278 # this retains compatibility with .la files and attempts 7279 # to make the code below a bit more comprehensible 7280 7281 case $vinfo_number in 7282 yes) 7283 number_major="$1" 7284 number_minor="$2" 7285 number_revision="$3" 7286 # 7287 # There are really only two kinds -- those that 7288 # use the current revision as the major version 7289 # and those that subtract age and use age as 7290 # a minor version. But, then there is irix 7291 # which has an extra 1 added just for fun 7292 # 7293 case $version_type in 7294 # correct linux to gnu/linux during the next big refactor 7295 darwin|linux|osf|windows|none) 7296 func_arith $number_major + $number_minor 7297 current=$func_arith_result 7298 age="$number_minor" 7299 revision="$number_revision" 7300 ;; 7301 freebsd-aout|freebsd-elf|qnx|sunos) 7302 current="$number_major" 7303 revision="$number_minor" 7304 age="0" 7305 ;; 7306 irix|nonstopux) 7307 func_arith $number_major + $number_minor 7308 current=$func_arith_result 7309 age="$number_minor" 7310 revision="$number_minor" 7311 lt_irix_increment=no 7312 ;; 7313 esac 7314 ;; 7315 no) 7316 current="$1" 7317 revision="$2" 7318 age="$3" 7319 ;; 7320 esac 7321 7322 # Check that each of the things are valid numbers. 7323 case $current in 7324 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]) ;; 7325 *) 7326 func_error "CURRENT \`$current' must be a nonnegative integer" 7327 func_fatal_error "\`$vinfo' is not valid version information" 7328 ;; 7329 esac 7330 7331 case $revision in 7332 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]) ;; 7333 *) 7334 func_error "REVISION \`$revision' must be a nonnegative integer" 7335 func_fatal_error "\`$vinfo' is not valid version information" 7336 ;; 7337 esac 7338 7339 case $age in 7340 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]) ;; 7341 *) 7342 func_error "AGE \`$age' must be a nonnegative integer" 7343 func_fatal_error "\`$vinfo' is not valid version information" 7344 ;; 7345 esac 7346 7347 if test "$age" -gt "$current"; then 7348 func_error "AGE \`$age' is greater than the current interface number \`$current'" 7349 func_fatal_error "\`$vinfo' is not valid version information" 7350 fi 7351 7352 # Calculate the version variables. 7353 major= 7354 versuffix= 7355 verstring= 7356 case $version_type in 7357 none) ;; 7358 7359 darwin) 7360 # Like Linux, but with the current version available in 7361 # verstring for coding it into the library header 7362 func_arith $current - $age 7363 major=.$func_arith_result 7364 versuffix="$major.$age.$revision" 7365 # Darwin ld doesn't like 0 for these options... 7366 func_arith $current + 1 7367 minor_current=$func_arith_result 7368 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" 7369 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" 7370 ;; 7371 7372 freebsd-aout) 7373 major=".$current" 7374 versuffix=".$current.$revision"; 7375 ;; 7376 7377 freebsd-elf) 7378 major=".$current" 7379 versuffix=".$current" 7380 ;; 7381 7382 irix | nonstopux) 7383 if test "X$lt_irix_increment" = "Xno"; then 7384 func_arith $current - $age 7385 else 7386 func_arith $current - $age + 1 7387 fi 7388 major=$func_arith_result 7389 7390 case $version_type in 7391 nonstopux) verstring_prefix=nonstopux ;; 7392 *) verstring_prefix=sgi ;; 7393 esac 7394 verstring="$verstring_prefix$major.$revision" 7395 7396 # Add in all the interfaces that we are compatible with. 7397 loop=$revision 7398 while test "$loop" -ne 0; do 7399 func_arith $revision - $loop 7400 iface=$func_arith_result 7401 func_arith $loop - 1 7402 loop=$func_arith_result 7403 verstring="$verstring_prefix$major.$iface:$verstring" 7404 done 7405 7406 # Before this point, $major must not contain `.'. 7407 major=.$major 7408 versuffix="$major.$revision" 7409 ;; 7410 7411 linux) # correct to gnu/linux during the next big refactor 7412 func_arith $current - $age 7413 major=.$func_arith_result 7414 versuffix="$major.$age.$revision" 7415 ;; 7416 7417 osf) 7418 func_arith $current - $age 7419 major=.$func_arith_result 7420 versuffix=".$current.$age.$revision" 7421 verstring="$current.$age.$revision" 7422 7423 # Add in all the interfaces that we are compatible with. 7424 loop=$age 7425 while test "$loop" -ne 0; do 7426 func_arith $current - $loop 7427 iface=$func_arith_result 7428 func_arith $loop - 1 7429 loop=$func_arith_result 7430 verstring="$verstring:${iface}.0" 7431 done 7432 7433 # Make executables depend on our current version. 7434 func_append verstring ":${current}.0" 7435 ;; 7436 7437 qnx) 7438 major=".$current" 7439 versuffix=".$current" 7440 ;; 7441 7442 sunos) 7443 major=".$current" 7444 versuffix=".$current.$revision" 7445 ;; 7446 7447 windows) 7448 # Use '-' rather than '.', since we only want one 7449 # extension on DOS 8.3 filesystems. 7450 func_arith $current - $age 7451 major=$func_arith_result 7452 versuffix="-$major" 7453 ;; 7454 7455 *) 7456 func_fatal_configuration "unknown library version type \`$version_type'" 7457 ;; 7458 esac 7459 7460 # Clear the version info if we defaulted, and they specified a release. 7461 if test -z "$vinfo" && test -n "$release"; then 7462 major= 7463 case $version_type in 7464 darwin) 7465 # we can't check for "0.0" in archive_cmds due to quoting 7466 # problems, so we reset it completely 7467 verstring= 7468 ;; 7469 *) 7470 verstring="0.0" 7471 ;; 7472 esac 7473 if test "$need_version" = no; then 7474 versuffix= 7475 else 7476 versuffix=".0.0" 7477 fi 7478 fi 7479 7480 # Remove version info from name if versioning should be avoided 7481 if test "$avoid_version" = yes && test "$need_version" = no; then 7482 major= 7483 versuffix= 7484 verstring="" 7485 else 7486 # XXX 7487 tmp=`echo $libname|sed -e 's,+,_,g' -e 's,-,_,g' -e 's,\.,_,g'` 7488 eval tmp2=\$${tmp}_ltversion 7489 if ! test -z "${SHARED_LIBS_LOG}"; then 7490 if ! test -f ${SHARED_LIBS_LOG}; then 7491 echo "# SHARED_LIBS+= <libname> <obsd version> # <orig version>" >${SHARED_LIBS_LOG} 7492 fi 7493 tmp4=`echo $libname|sed -e 's/^lib//'` 7494 printf "SHARED_LIBS +=\t%-20s %-8s # %s\n" "$tmp4" "$tmp2" "$versuffix" >>${SHARED_LIBS_LOG} 7495 fi 7496 if test -n "$versuffix" && test -n "$tmp2"; then 7497 versuffix=".$tmp2" 7498 fi 7499 fi 7500 7501 # Check to see if the archive will have undefined symbols. 7502 if test "$allow_undefined" = yes; then 7503 if test "$allow_undefined_flag" = unsupported; then 7504 func_warning "undefined symbols not allowed in $host shared libraries" 7505 build_libtool_libs=no 7506 build_old_libs=yes 7507 fi 7508 else 7509 # Don't allow undefined symbols. 7510 allow_undefined_flag="$no_undefined_flag" 7511 fi 7512 7513 fi 7514 7515 func_generate_dlsyms "$libname" "$libname" "yes" 7516 func_append libobjs " $symfileobj" 7517 test "X$libobjs" = "X " && libobjs= 7518 7519 if test "$opt_mode" != relink; then 7520 # Remove our outputs, but don't remove object files since they 7521 # may have been created when compiling PIC objects. 7522 removelist= 7523 tempremovelist=`$ECHO "$output_objdir/*"` 7524 for p in $tempremovelist; do 7525 case $p in 7526 *.$objext | *.gcno) 7527 ;; 7528 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) 7529 if test "X$precious_files_regex" != "X"; then 7530 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 7531 then 7532 continue 7533 fi 7534 fi 7535 func_append removelist " $p" 7536 ;; 7537 *) ;; 7538 esac 7539 done 7540 test -n "$removelist" && \ 7541 func_show_eval "${RM}r \$removelist" 7542 fi 7543 7544 # Now set the variables for building old libraries. 7545 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then 7546 func_append oldlibs " $output_objdir/$libname.$libext" 7547 7548 # Transform .lo files to .o files. 7549 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP` 7550 fi 7551 7552 # Eliminate all temporary directories. 7553 #for path in $notinst_path; do 7554 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` 7555 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` 7556 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` 7557 #done 7558 7559 if test -n "$xrpath"; then 7560 # If the user specified any rpath flags, then add them. 7561 temp_xrpath= 7562 for libdir in $xrpath; do 7563 func_replace_sysroot "$libdir" 7564 func_append temp_xrpath " -R$func_replace_sysroot_result" 7565 case "$finalize_rpath " in 7566 *" $libdir "*) ;; 7567 *) func_append finalize_rpath " $libdir" ;; 7568 esac 7569 done 7570 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then 7571 dependency_libs="$temp_xrpath $dependency_libs" 7572 fi 7573 fi 7574 7575 # Make sure dlfiles contains only unique files that won't be dlpreopened 7576 old_dlfiles="$dlfiles" 7577 dlfiles= 7578 for lib in $old_dlfiles; do 7579 case " $dlprefiles $dlfiles " in 7580 *" $lib "*) ;; 7581 *) func_append dlfiles " $lib" ;; 7582 esac 7583 done 7584 7585 # Make sure dlprefiles contains only unique files 7586 old_dlprefiles="$dlprefiles" 7587 dlprefiles= 7588 for lib in $old_dlprefiles; do 7589 case "$dlprefiles " in 7590 *" $lib "*) ;; 7591 *) func_append dlprefiles " $lib" ;; 7592 esac 7593 done 7594 7595 if test "$build_libtool_libs" = yes; then 7596 if test -n "$rpath"; then 7597 case $host in 7598 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) 7599 # these systems don't actually have a c library (as such)! 7600 ;; 7601 *-*-rhapsody* | *-*-darwin1.[012]) 7602 # Rhapsody C library is in the System framework 7603 func_append deplibs " System.ltframework" 7604 ;; 7605 *-*-netbsd*) 7606 # Don't link with libc until the a.out ld.so is fixed. 7607 ;; 7608 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 7609 # Do not include libc due to us having libc/libc_r. 7610 ;; 7611 *-*-sco3.2v5* | *-*-sco5v6*) 7612 # Causes problems with __ctype 7613 ;; 7614 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) 7615 # Compiler inserts libc in the correct place for threads to work 7616 ;; 7617 *) 7618 # Add libc to deplibs on all other systems if necessary. 7619 if test "$build_libtool_need_lc" = "yes"; then 7620 func_append deplibs " -lc" 7621 fi 7622 ;; 7623 esac 7624 fi 7625 7626 # Transform deplibs into only deplibs that can be linked in shared. 7627 name_save=$name 7628 libname_save=$libname 7629 release_save=$release 7630 versuffix_save=$versuffix 7631 major_save=$major 7632 # I'm not sure if I'm treating the release correctly. I think 7633 # release should show up in the -l (ie -lgmp5) so we don't want to 7634 # add it in twice. Is that correct? 7635 release="" 7636 versuffix="" 7637 major="" 7638 newdeplibs= 7639 droppeddeps=no 7640 case $deplibs_check_method in 7641 pass_all) 7642 # Don't check for shared/static. Everything works. 7643 # This might be a little naive. We might want to check 7644 # whether the library exists or not. But this is on 7645 # osf3 & osf4 and I'm not really sure... Just 7646 # implementing what was already the behavior. 7647 newdeplibs=$deplibs 7648 ;; 7649 test_compile) 7650 # This code stresses the "libraries are programs" paradigm to its 7651 # limits. Maybe even breaks it. We compile a program, linking it 7652 # against the deplibs as a proxy for the library. Then we can check 7653 # whether they linked in statically or dynamically with ldd. 7654 $opt_dry_run || $RM conftest.c 7655 cat > conftest.c <<EOF 7656 int main() { return 0; } 7657EOF 7658 $opt_dry_run || $RM conftest 7659 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then 7660 ldd_output=`ldd conftest` 7661 for i in $deplibs; do 7662 case $i in 7663 -l*) 7664 func_stripname -l '' "$i" 7665 name=$func_stripname_result 7666 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 7667 case " $predeps $postdeps " in 7668 *" $i "*) 7669 func_append newdeplibs " $i" 7670 i="" 7671 ;; 7672 esac 7673 fi 7674 if test -n "$i" ; then 7675 libname=`eval "\\$ECHO \"$libname_spec\""` 7676 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 7677 set dummy $deplib_matches; shift 7678 deplib_match=$1 7679 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 7680 func_append newdeplibs " $i" 7681 else 7682 droppeddeps=yes 7683 echo 7684 $ECHO "*** Warning: dynamic linker does not accept needed library $i." 7685 echo "*** I have the capability to make that library automatically link in when" 7686 echo "*** you link to this library. But I can only do this if you have a" 7687 echo "*** shared version of the library, which I believe you do not have" 7688 echo "*** because a test_compile did reveal that the linker did not use it for" 7689 echo "*** its dynamic dependency list that programs get resolved with at runtime." 7690 fi 7691 fi 7692 ;; 7693 *) 7694 func_append newdeplibs " $i" 7695 ;; 7696 esac 7697 done 7698 else 7699 # Error occurred in the first compile. Let's try to salvage 7700 # the situation: Compile a separate program for each library. 7701 for i in $deplibs; do 7702 case $i in 7703 -l*) 7704 func_stripname -l '' "$i" 7705 name=$func_stripname_result 7706 $opt_dry_run || $RM conftest 7707 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then 7708 ldd_output=`ldd conftest` 7709 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 7710 case " $predeps $postdeps " in 7711 *" $i "*) 7712 func_append newdeplibs " $i" 7713 i="" 7714 ;; 7715 esac 7716 fi 7717 if test -n "$i" ; then 7718 libname=`eval "\\$ECHO \"$libname_spec\""` 7719 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 7720 set dummy $deplib_matches; shift 7721 deplib_match=$1 7722 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 7723 func_append newdeplibs " $i" 7724 else 7725 droppeddeps=yes 7726 echo 7727 $ECHO "*** Warning: dynamic linker does not accept needed library $i." 7728 echo "*** I have the capability to make that library automatically link in when" 7729 echo "*** you link to this library. But I can only do this if you have a" 7730 echo "*** shared version of the library, which you do not appear to have" 7731 echo "*** because a test_compile did reveal that the linker did not use this one" 7732 echo "*** as a dynamic dependency that programs can get resolved with at runtime." 7733 fi 7734 fi 7735 else 7736 droppeddeps=yes 7737 echo 7738 $ECHO "*** Warning! Library $i is needed by this library but I was not able to" 7739 echo "*** make it link in! You will probably need to install it or some" 7740 echo "*** library that it depends on before this library will be fully" 7741 echo "*** functional. Installing it before continuing would be even better." 7742 fi 7743 ;; 7744 *) 7745 func_append newdeplibs " $i" 7746 ;; 7747 esac 7748 done 7749 fi 7750 ;; 7751 file_magic*) 7752 set dummy $deplibs_check_method; shift 7753 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 7754 for a_deplib in $deplibs; do 7755 case $a_deplib in 7756 -l*) 7757 func_stripname -l '' "$a_deplib" 7758 name=$func_stripname_result 7759 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 7760 case " $predeps $postdeps " in 7761 *" $a_deplib "*) 7762 func_append newdeplibs " $a_deplib" 7763 a_deplib="" 7764 ;; 7765 esac 7766 fi 7767 if test -n "$a_deplib" ; then 7768 libname=`eval "\\$ECHO \"$libname_spec\""` 7769 if test -n "$file_magic_glob"; then 7770 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob` 7771 else 7772 libnameglob=$libname 7773 fi 7774 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob` 7775 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 7776 if test "$want_nocaseglob" = yes; then 7777 shopt -s nocaseglob 7778 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` 7779 $nocaseglob 7780 else 7781 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` 7782 fi 7783 for potent_lib in $potential_libs; do 7784 # Follow soft links. 7785 if ls -lLd "$potent_lib" 2>/dev/null | 7786 $GREP " -> " >/dev/null; then 7787 continue 7788 fi 7789 # The statement above tries to avoid entering an 7790 # endless loop below, in case of cyclic links. 7791 # We might still enter an endless loop, since a link 7792 # loop can be closed while we follow links, 7793 # but so what? 7794 potlib="$potent_lib" 7795 while test -h "$potlib" 2>/dev/null; do 7796 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` 7797 case $potliblink in 7798 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; 7799 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";; 7800 esac 7801 done 7802 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | 7803 $SED -e 10q | 7804 $EGREP "$file_magic_regex" > /dev/null; then 7805 func_append newdeplibs " $a_deplib" 7806 a_deplib="" 7807 break 2 7808 fi 7809 done 7810 done 7811 fi 7812 if test -n "$a_deplib" ; then 7813 droppeddeps=yes 7814 echo 7815 $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 7816 echo "*** I have the capability to make that library automatically link in when" 7817 echo "*** you link to this library. But I can only do this if you have a" 7818 echo "*** shared version of the library, which you do not appear to have" 7819 echo "*** because I did check the linker path looking for a file starting" 7820 if test -z "$potlib" ; then 7821 $ECHO "*** with $libname but no candidates were found. (...for file magic test)" 7822 else 7823 $ECHO "*** with $libname and none of the candidates passed a file format test" 7824 $ECHO "*** using a file magic. Last file checked: $potlib" 7825 fi 7826 fi 7827 ;; 7828 *) 7829 # Add a -L argument. 7830 func_append newdeplibs " $a_deplib" 7831 ;; 7832 esac 7833 done # Gone through all deplibs. 7834 ;; 7835 match_pattern*) 7836 set dummy $deplibs_check_method; shift 7837 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` 7838 for a_deplib in $deplibs; do 7839 case $a_deplib in 7840 -l*) 7841 func_stripname -l '' "$a_deplib" 7842 name=$func_stripname_result 7843 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 7844 case " $predeps $postdeps " in 7845 *" $a_deplib "*) 7846 func_append newdeplibs " $a_deplib" 7847 a_deplib="" 7848 ;; 7849 esac 7850 fi 7851 if test -n "$a_deplib" ; then 7852 libname=`eval "\\$ECHO \"$libname_spec\""` 7853 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 7854 potential_libs=`ls $i/$libname[.-]* 2>/dev/null` 7855 for potent_lib in $potential_libs; do 7856 potlib="$potent_lib" # see symlink-check above in file_magic test 7857 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ 7858 $EGREP "$match_pattern_regex" > /dev/null; then 7859 func_append newdeplibs " $a_deplib" 7860 a_deplib="" 7861 break 2 7862 fi 7863 done 7864 done 7865 fi 7866 if test -n "$a_deplib" ; then 7867 droppeddeps=yes 7868 echo 7869 $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 7870 echo "*** I have the capability to make that library automatically link in when" 7871 echo "*** you link to this library. But I can only do this if you have a" 7872 echo "*** shared version of the library, which you do not appear to have" 7873 echo "*** because I did check the linker path looking for a file starting" 7874 if test -z "$potlib" ; then 7875 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" 7876 else 7877 $ECHO "*** with $libname and none of the candidates passed a file format test" 7878 $ECHO "*** using a regex pattern. Last file checked: $potlib" 7879 fi 7880 fi 7881 ;; 7882 *) 7883 # Add a -L argument. 7884 func_append newdeplibs " $a_deplib" 7885 ;; 7886 esac 7887 done # Gone through all deplibs. 7888 ;; 7889 none | unknown | *) 7890 newdeplibs="" 7891 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` 7892 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 7893 for i in $predeps $postdeps ; do 7894 # can't use Xsed below, because $i might contain '/' 7895 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"` 7896 done 7897 fi 7898 case $tmp_deplibs in 7899 *[!\ \ ]*) 7900 echo 7901 if test "X$deplibs_check_method" = "Xnone"; then 7902 echo "*** Warning: inter-library dependencies are not supported in this platform." 7903 else 7904 echo "*** Warning: inter-library dependencies are not known to be supported." 7905 fi 7906 echo "*** All declared inter-library dependencies are being dropped." 7907 droppeddeps=yes 7908 ;; 7909 esac 7910 ;; 7911 esac 7912 versuffix=$versuffix_save 7913 major=$major_save 7914 release=$release_save 7915 libname=$libname_save 7916 name=$name_save 7917 7918 case $host in 7919 *-*-rhapsody* | *-*-darwin1.[012]) 7920 # On Rhapsody replace the C library with the System framework 7921 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` 7922 ;; 7923 esac 7924 7925 if test "$droppeddeps" = yes; then 7926 if test "$module" = yes; then 7927 echo 7928 echo "*** Warning: libtool could not satisfy all declared inter-library" 7929 $ECHO "*** dependencies of module $libname. Therefore, libtool will create" 7930 echo "*** a static module, that should work as long as the dlopening" 7931 echo "*** application is linked with the -dlopen flag." 7932 if test -z "$global_symbol_pipe"; then 7933 echo 7934 echo "*** However, this would only work if libtool was able to extract symbol" 7935 echo "*** lists from a program, using \`nm' or equivalent, but libtool could" 7936 echo "*** not find such a program. So, this module is probably useless." 7937 echo "*** \`nm' from GNU binutils and a full rebuild may help." 7938 fi 7939 if test "$build_old_libs" = no; then 7940 oldlibs="$output_objdir/$libname.$libext" 7941 build_libtool_libs=module 7942 build_old_libs=yes 7943 else 7944 build_libtool_libs=no 7945 fi 7946 else 7947 echo "*** The inter-library dependencies that have been dropped here will be" 7948 echo "*** automatically added whenever a program is linked with this library" 7949 echo "*** or is declared to -dlopen it." 7950 7951 if test "$allow_undefined" = no; then 7952 echo 7953 echo "*** Since this library must not contain undefined symbols," 7954 echo "*** because either the platform does not support them or" 7955 echo "*** it was explicitly requested with -no-undefined," 7956 echo "*** libtool will only create a static version of it." 7957 if test "$build_old_libs" = no; then 7958 oldlibs="$output_objdir/$libname.$libext" 7959 build_libtool_libs=module 7960 build_old_libs=yes 7961 else 7962 build_libtool_libs=no 7963 fi 7964 fi 7965 fi 7966 fi 7967 # Done checking deplibs! 7968 deplibs=$newdeplibs 7969 fi 7970 # Time to change all our "foo.ltframework" stuff back to "-framework foo" 7971 case $host in 7972 *-*-darwin*) 7973 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 7974 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 7975 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 7976 ;; 7977 esac 7978 7979 # move library search paths that coincide with paths to not yet 7980 # installed libraries to the beginning of the library search list 7981 new_libs= 7982 for path in $notinst_path; do 7983 case " $new_libs " in 7984 *" -L$path/$objdir "*) ;; 7985 *) 7986 case " $deplibs " in 7987 *" -L$path/$objdir "*) 7988 func_append new_libs " -L$path/$objdir" ;; 7989 esac 7990 ;; 7991 esac 7992 done 7993 for deplib in $deplibs; do 7994 case $deplib in 7995 -L*) 7996 case " $new_libs " in 7997 *" $deplib "*) ;; 7998 *) func_append new_libs " $deplib" ;; 7999 esac 8000 ;; 8001 *) func_append new_libs " $deplib" ;; 8002 esac 8003 done 8004 deplibs="$new_libs" 8005 8006 # All the library-specific variables (install_libdir is set above). 8007 library_names= 8008 old_library= 8009 dlname= 8010 8011 # Test again, we may have decided not to build it any more 8012 if test "$build_libtool_libs" = yes; then 8013 # Remove ${wl} instances when linking with ld. 8014 # FIXME: should test the right _cmds variable. 8015 case $archive_cmds in 8016 *\$LD\ *) wl= ;; 8017 esac 8018 if test "$hardcode_into_libs" = yes; then 8019 # Hardcode the library paths 8020 hardcode_libdirs= 8021 dep_rpath= 8022 rpath="$finalize_rpath" 8023 test "$opt_mode" != relink && rpath="$compile_rpath$rpath" 8024 for libdir in $rpath; do 8025 if test -n "$hardcode_libdir_flag_spec"; then 8026 if test -n "$hardcode_libdir_separator"; then 8027 func_replace_sysroot "$libdir" 8028 libdir=$func_replace_sysroot_result 8029 if test -z "$hardcode_libdirs"; then 8030 hardcode_libdirs="$libdir" 8031 else 8032 # Just accumulate the unique libdirs. 8033 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 8034 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 8035 ;; 8036 *) 8037 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" 8038 ;; 8039 esac 8040 fi 8041 else 8042 eval flag=\"$hardcode_libdir_flag_spec\" 8043 func_append dep_rpath " $flag" 8044 fi 8045 elif test -n "$runpath_var"; then 8046 case "$perm_rpath " in 8047 *" $libdir "*) ;; 8048 *) func_append perm_rpath " $libdir" ;; 8049 esac 8050 fi 8051 done 8052 # Substitute the hardcoded libdirs into the rpath. 8053 if test -n "$hardcode_libdir_separator" && 8054 test -n "$hardcode_libdirs"; then 8055 libdir="$hardcode_libdirs" 8056 eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" 8057 fi 8058 if test -n "$runpath_var" && test -n "$perm_rpath"; then 8059 # We should set the runpath_var. 8060 rpath= 8061 for dir in $perm_rpath; do 8062 func_append rpath "$dir:" 8063 done 8064 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" 8065 fi 8066 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" 8067 fi 8068 8069 shlibpath="$finalize_shlibpath" 8070 test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath" 8071 if test -n "$shlibpath"; then 8072 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" 8073 fi 8074 8075 # Get the real and link names of the library. 8076 eval shared_ext=\"$shrext_cmds\" 8077 eval library_names=\"$library_names_spec\" 8078 set dummy $library_names 8079 shift 8080 realname="$1" 8081 shift 8082 8083 if test -n "$soname_spec"; then 8084 eval soname=\"$soname_spec\" 8085 else 8086 soname="$realname" 8087 fi 8088 if test -z "$dlname"; then 8089 dlname=$soname 8090 fi 8091 8092 lib="$output_objdir/$realname" 8093 linknames= 8094 for link 8095 do 8096 func_append linknames " $link" 8097 done 8098 8099 # Use standard objects if they are pic 8100 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` 8101 test "X$libobjs" = "X " && libobjs= 8102 8103 delfiles= 8104 if test -n "$export_symbols" && test -n "$include_expsyms"; then 8105 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" 8106 export_symbols="$output_objdir/$libname.uexp" 8107 func_append delfiles " $export_symbols" 8108 fi 8109 8110 orig_export_symbols= 8111 case $host_os in 8112 cygwin* | mingw* | cegcc*) 8113 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then 8114 # exporting using user supplied symfile 8115 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then 8116 # and it's NOT already a .def file. Must figure out 8117 # which of the given symbols are data symbols and tag 8118 # them as such. So, trigger use of export_symbols_cmds. 8119 # export_symbols gets reassigned inside the "prepare 8120 # the list of exported symbols" if statement, so the 8121 # include_expsyms logic still works. 8122 orig_export_symbols="$export_symbols" 8123 export_symbols= 8124 always_export_symbols=yes 8125 fi 8126 fi 8127 ;; 8128 esac 8129 8130 # Prepare the list of exported symbols 8131 if test -z "$export_symbols"; then 8132 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then 8133 func_verbose "generating symbol list for \`$libname.la'" 8134 export_symbols="$output_objdir/$libname.exp" 8135 $opt_dry_run || $RM $export_symbols 8136 cmds=$export_symbols_cmds 8137 save_ifs="$IFS"; IFS='~' 8138 for cmd1 in $cmds; do 8139 IFS="$save_ifs" 8140 # Take the normal branch if the nm_file_list_spec branch 8141 # doesn't work or if tool conversion is not needed. 8142 case $nm_file_list_spec~$to_tool_file_cmd in 8143 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) 8144 try_normal_branch=yes 8145 eval cmd=\"$cmd1\" 8146 func_len " $cmd" 8147 len=$func_len_result 8148 ;; 8149 *) 8150 try_normal_branch=no 8151 ;; 8152 esac 8153 if test "$try_normal_branch" = yes \ 8154 && { test "$len" -lt "$max_cmd_len" \ 8155 || test "$max_cmd_len" -le -1; } 8156 then 8157 func_show_eval "$cmd" 'exit $?' 8158 skipped_export=false 8159 elif test -n "$nm_file_list_spec"; then 8160 func_basename "$output" 8161 output_la=$func_basename_result 8162 save_libobjs=$libobjs 8163 save_output=$output 8164 output=${output_objdir}/${output_la}.nm 8165 func_to_tool_file "$output" 8166 libobjs=$nm_file_list_spec$func_to_tool_file_result 8167 func_append delfiles " $output" 8168 func_verbose "creating $NM input file list: $output" 8169 for obj in $save_libobjs; do 8170 func_to_tool_file "$obj" 8171 $ECHO "$func_to_tool_file_result" 8172 done > "$output" 8173 eval cmd=\"$cmd1\" 8174 func_show_eval "$cmd" 'exit $?' 8175 output=$save_output 8176 libobjs=$save_libobjs 8177 skipped_export=false 8178 else 8179 # The command line is too long to execute in one step. 8180 func_verbose "using reloadable object file for export list..." 8181 skipped_export=: 8182 # Break out early, otherwise skipped_export may be 8183 # set to false by a later but shorter cmd. 8184 break 8185 fi 8186 done 8187 IFS="$save_ifs" 8188 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then 8189 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 8190 func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 8191 fi 8192 fi 8193 fi 8194 8195 if test -n "$export_symbols" && test -n "$include_expsyms"; then 8196 tmp_export_symbols="$export_symbols" 8197 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 8198 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' 8199 fi 8200 8201 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then 8202 # The given exports_symbols file has to be filtered, so filter it. 8203 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 8204 # FIXME: $output_objdir/$libname.filter potentially contains lots of 8205 # 's' commands which not all seds can handle. GNU sed should be fine 8206 # though. Also, the filter scales superlinearly with the number of 8207 # global variables. join(1) would be nice here, but unfortunately 8208 # isn't a blessed tool. 8209 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 8210 func_append delfiles " $export_symbols $output_objdir/$libname.filter" 8211 export_symbols=$output_objdir/$libname.def 8212 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 8213 fi 8214 8215 tmp_deplibs= 8216 for test_deplib in $deplibs; do 8217 case " $convenience " in 8218 *" $test_deplib "*) ;; 8219 *) 8220 func_append tmp_deplibs " $test_deplib" 8221 ;; 8222 esac 8223 done 8224 deplibs="$tmp_deplibs" 8225 8226 if test -n "$convenience"; then 8227 if test -n "$whole_archive_flag_spec" && 8228 test "$compiler_needs_object" = yes && 8229 test -z "$libobjs"; then 8230 # extract the archives, so we have objects to list. 8231 # TODO: could optimize this to just extract one archive. 8232 whole_archive_flag_spec= 8233 fi 8234 if test -n "$whole_archive_flag_spec"; then 8235 save_libobjs=$libobjs 8236 eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 8237 test "X$libobjs" = "X " && libobjs= 8238 else 8239 gentop="$output_objdir/${outputname}x" 8240 func_append generated " $gentop" 8241 8242 func_extract_archives $gentop $convenience 8243 func_append libobjs " $func_extract_archives_result" 8244 test "X$libobjs" = "X " && libobjs= 8245 fi 8246 fi 8247 8248 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then 8249 eval flag=\"$thread_safe_flag_spec\" 8250 func_append linker_flags " $flag" 8251 fi 8252 8253 # Make a backup of the uninstalled library when relinking 8254 if test "$opt_mode" = relink; then 8255 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? 8256 fi 8257 8258 # Do each of the archive commands. 8259 if test "$module" = yes && test -n "$module_cmds" ; then 8260 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 8261 eval test_cmds=\"$module_expsym_cmds\" 8262 cmds=$module_expsym_cmds 8263 else 8264 eval test_cmds=\"$module_cmds\" 8265 cmds=$module_cmds 8266 fi 8267 else 8268 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 8269 eval test_cmds=\"$archive_expsym_cmds\" 8270 cmds=$archive_expsym_cmds 8271 else 8272 eval test_cmds=\"$archive_cmds\" 8273 cmds=$archive_cmds 8274 fi 8275 fi 8276 8277 if test "X$skipped_export" != "X:" && 8278 func_len " $test_cmds" && 8279 len=$func_len_result && 8280 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 8281 : 8282 else 8283 # The command line is too long to link in one step, link piecewise 8284 # or, if using GNU ld and skipped_export is not :, use a linker 8285 # script. 8286 8287 # Save the value of $output and $libobjs because we want to 8288 # use them later. If we have whole_archive_flag_spec, we 8289 # want to use save_libobjs as it was before 8290 # whole_archive_flag_spec was expanded, because we can't 8291 # assume the linker understands whole_archive_flag_spec. 8292 # This may have to be revisited, in case too many 8293 # convenience libraries get linked in and end up exceeding 8294 # the spec. 8295 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then 8296 save_libobjs=$libobjs 8297 fi 8298 save_output=$output 8299 func_basename "$output" 8300 output_la=$func_basename_result 8301 8302 # Clear the reloadable object creation command queue and 8303 # initialize k to one. 8304 test_cmds= 8305 concat_cmds= 8306 objlist= 8307 last_robj= 8308 k=1 8309 8310 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then 8311 output=${output_objdir}/${output_la}.lnkscript 8312 func_verbose "creating GNU ld script: $output" 8313 echo 'INPUT (' > $output 8314 for obj in $save_libobjs 8315 do 8316 func_to_tool_file "$obj" 8317 $ECHO "$func_to_tool_file_result" >> $output 8318 done 8319 echo ')' >> $output 8320 func_append delfiles " $output" 8321 func_to_tool_file "$output" 8322 output=$func_to_tool_file_result 8323 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then 8324 output=${output_objdir}/${output_la}.lnk 8325 func_verbose "creating linker input file list: $output" 8326 : > $output 8327 set x $save_libobjs 8328 shift 8329 firstobj= 8330 if test "$compiler_needs_object" = yes; then 8331 firstobj="$1 " 8332 shift 8333 fi 8334 for obj 8335 do 8336 func_to_tool_file "$obj" 8337 $ECHO "$func_to_tool_file_result" >> $output 8338 done 8339 func_append delfiles " $output" 8340 func_to_tool_file "$output" 8341 output=$firstobj\"$file_list_spec$func_to_tool_file_result\" 8342 else 8343 if test -n "$save_libobjs"; then 8344 func_verbose "creating reloadable object files..." 8345 output=$output_objdir/$output_la-${k}.$objext 8346 eval test_cmds=\"$reload_cmds\" 8347 func_len " $test_cmds" 8348 len0=$func_len_result 8349 len=$len0 8350 8351 # Loop over the list of objects to be linked. 8352 for obj in $save_libobjs 8353 do 8354 func_len " $obj" 8355 func_arith $len + $func_len_result 8356 len=$func_arith_result 8357 if test "X$objlist" = X || 8358 test "$len" -lt "$max_cmd_len"; then 8359 func_append objlist " $obj" 8360 else 8361 # The command $test_cmds is almost too long, add a 8362 # command to the queue. 8363 if test "$k" -eq 1 ; then 8364 # The first file doesn't have a previous command to add. 8365 reload_objs=$objlist 8366 eval concat_cmds=\"$reload_cmds\" 8367 else 8368 # All subsequent reloadable object files will link in 8369 # the last one created. 8370 reload_objs="$objlist $last_robj" 8371 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" 8372 fi 8373 last_robj=$output_objdir/$output_la-${k}.$objext 8374 func_arith $k + 1 8375 k=$func_arith_result 8376 output=$output_objdir/$output_la-${k}.$objext 8377 objlist=" $obj" 8378 func_len " $last_robj" 8379 func_arith $len0 + $func_len_result 8380 len=$func_arith_result 8381 fi 8382 done 8383 # Handle the remaining objects by creating one last 8384 # reloadable object file. All subsequent reloadable object 8385 # files will link in the last one created. 8386 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 8387 reload_objs="$objlist $last_robj" 8388 eval concat_cmds=\"\${concat_cmds}$reload_cmds\" 8389 if test -n "$last_robj"; then 8390 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" 8391 fi 8392 func_append delfiles " $output" 8393 8394 else 8395 output= 8396 fi 8397 8398 if ${skipped_export-false}; then 8399 func_verbose "generating symbol list for \`$libname.la'" 8400 export_symbols="$output_objdir/$libname.exp" 8401 $opt_dry_run || $RM $export_symbols 8402 libobjs=$output 8403 # Append the command to create the export file. 8404 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 8405 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" 8406 if test -n "$last_robj"; then 8407 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" 8408 fi 8409 fi 8410 8411 test -n "$save_libobjs" && 8412 func_verbose "creating a temporary reloadable object file: $output" 8413 8414 # Loop through the commands generated above and execute them. 8415 save_ifs="$IFS"; IFS='~' 8416 for cmd in $concat_cmds; do 8417 IFS="$save_ifs" 8418 $opt_silent || { 8419 func_quote_for_expand "$cmd" 8420 eval "func_echo $func_quote_for_expand_result" 8421 } 8422 $opt_dry_run || eval "$cmd" || { 8423 lt_exit=$? 8424 8425 # Restore the uninstalled library and exit 8426 if test "$opt_mode" = relink; then 8427 ( cd "$output_objdir" && \ 8428 $RM "${realname}T" && \ 8429 $MV "${realname}U" "$realname" ) 8430 fi 8431 8432 exit $lt_exit 8433 } 8434 done 8435 IFS="$save_ifs" 8436 8437 if test -n "$export_symbols_regex" && ${skipped_export-false}; then 8438 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 8439 func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 8440 fi 8441 fi 8442 8443 if ${skipped_export-false}; then 8444 if test -n "$export_symbols" && test -n "$include_expsyms"; then 8445 tmp_export_symbols="$export_symbols" 8446 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 8447 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' 8448 fi 8449 8450 if test -n "$orig_export_symbols"; then 8451 # The given exports_symbols file has to be filtered, so filter it. 8452 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 8453 # FIXME: $output_objdir/$libname.filter potentially contains lots of 8454 # 's' commands which not all seds can handle. GNU sed should be fine 8455 # though. Also, the filter scales superlinearly with the number of 8456 # global variables. join(1) would be nice here, but unfortunately 8457 # isn't a blessed tool. 8458 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 8459 func_append delfiles " $export_symbols $output_objdir/$libname.filter" 8460 export_symbols=$output_objdir/$libname.def 8461 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 8462 fi 8463 fi 8464 8465 libobjs=$output 8466 # Restore the value of output. 8467 output=$save_output 8468 8469 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then 8470 eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 8471 test "X$libobjs" = "X " && libobjs= 8472 fi 8473 # Expand the library linking commands again to reset the 8474 # value of $libobjs for piecewise linking. 8475 8476 # Do each of the archive commands. 8477 if test "$module" = yes && test -n "$module_cmds" ; then 8478 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 8479 cmds=$module_expsym_cmds 8480 else 8481 cmds=$module_cmds 8482 fi 8483 else 8484 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 8485 cmds=$archive_expsym_cmds 8486 else 8487 cmds=$archive_cmds 8488 fi 8489 fi 8490 fi 8491 8492 if test -n "$delfiles"; then 8493 # Append the command to remove temporary files to $cmds. 8494 eval cmds=\"\$cmds~\$RM $delfiles\" 8495 fi 8496 8497 # Add any objects from preloaded convenience libraries 8498 if test -n "$dlprefiles"; then 8499 gentop="$output_objdir/${outputname}x" 8500 func_append generated " $gentop" 8501 8502 func_extract_archives $gentop $dlprefiles 8503 func_append libobjs " $func_extract_archives_result" 8504 test "X$libobjs" = "X " && libobjs= 8505 fi 8506 8507 save_ifs="$IFS"; IFS='~' 8508 for cmd in $cmds; do 8509 IFS="$save_ifs" 8510 eval cmd=\"$cmd\" 8511 $opt_silent || { 8512 func_quote_for_expand "$cmd" 8513 eval "func_echo $func_quote_for_expand_result" 8514 } 8515 $opt_dry_run || eval "$cmd" || { 8516 lt_exit=$? 8517 8518 # Restore the uninstalled library and exit 8519 if test "$opt_mode" = relink; then 8520 ( cd "$output_objdir" && \ 8521 $RM "${realname}T" && \ 8522 $MV "${realname}U" "$realname" ) 8523 fi 8524 8525 exit $lt_exit 8526 } 8527 done 8528 IFS="$save_ifs" 8529 8530 # Restore the uninstalled library and exit 8531 if test "$opt_mode" = relink; then 8532 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? 8533 8534 if test -n "$convenience"; then 8535 if test -z "$whole_archive_flag_spec"; then 8536 func_show_eval '${RM}r "$gentop"' 8537 fi 8538 fi 8539 8540 exit $EXIT_SUCCESS 8541 fi 8542 8543 # Create links to the real library. 8544 for linkname in $linknames; do 8545 if test "$realname" != "$linkname"; then 8546 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' 8547 fi 8548 done 8549 8550 # If -module or -export-dynamic was specified, set the dlname. 8551 if test "$module" = yes || test "$export_dynamic" = yes; then 8552 # On all known operating systems, these are identical. 8553 dlname="$soname" 8554 fi 8555 fi 8556 ;; 8557 8558 obj) 8559 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 8560 func_warning "\`-dlopen' is ignored for objects" 8561 fi 8562 8563 case " $deplibs" in 8564 *\ -l* | *\ -L*) 8565 func_warning "\`-l' and \`-L' are ignored for objects" ;; 8566 esac 8567 8568 test -n "$rpath" && \ 8569 func_warning "\`-rpath' is ignored for objects" 8570 8571 test -n "$xrpath" && \ 8572 func_warning "\`-R' is ignored for objects" 8573 8574 test -n "$vinfo" && \ 8575 func_warning "\`-version-info' is ignored for objects" 8576 8577 test -n "$release" && \ 8578 func_warning "\`-release' is ignored for objects" 8579 8580 case $output in 8581 *.lo) 8582 test -n "$objs$old_deplibs" && \ 8583 func_fatal_error "cannot build library object \`$output' from non-libtool objects" 8584 8585 libobj=$output 8586 func_lo2o "$libobj" 8587 obj=$func_lo2o_result 8588 ;; 8589 *) 8590 libobj= 8591 obj="$output" 8592 ;; 8593 esac 8594 8595 # Delete the old objects. 8596 $opt_dry_run || $RM $obj $libobj 8597 8598 # Objects from convenience libraries. This assumes 8599 # single-version convenience libraries. Whenever we create 8600 # different ones for PIC/non-PIC, this we'll have to duplicate 8601 # the extraction. 8602 reload_conv_objs= 8603 gentop= 8604 # reload_cmds runs $LD directly, so let us get rid of 8605 # -Wl from whole_archive_flag_spec and hope we can get by with 8606 # turning comma into space.. 8607 wl= 8608 8609 if test -n "$convenience"; then 8610 if test -n "$whole_archive_flag_spec"; then 8611 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" 8612 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` 8613 else 8614 gentop="$output_objdir/${obj}x" 8615 func_append generated " $gentop" 8616 8617 func_extract_archives $gentop $convenience 8618 reload_conv_objs="$reload_objs $func_extract_archives_result" 8619 fi 8620 fi 8621 8622 # If we're not building shared, we need to use non_pic_objs 8623 test "$build_libtool_libs" != yes && libobjs="$non_pic_objects" 8624 8625 # Create the old-style object. 8626 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test 8627 8628 output="$obj" 8629 func_execute_cmds "$reload_cmds" 'exit $?' 8630 8631 # Exit if we aren't doing a library object file. 8632 if test -z "$libobj"; then 8633 if test -n "$gentop"; then 8634 func_show_eval '${RM}r "$gentop"' 8635 fi 8636 8637 exit $EXIT_SUCCESS 8638 fi 8639 8640 if test "$build_libtool_libs" != yes; then 8641 if test -n "$gentop"; then 8642 func_show_eval '${RM}r "$gentop"' 8643 fi 8644 8645 # Create an invalid libtool object if no PIC, so that we don't 8646 # accidentally link it into a program. 8647 # $show "echo timestamp > $libobj" 8648 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? 8649 exit $EXIT_SUCCESS 8650 fi 8651 8652 if test -n "$pic_flag" || test "$pic_mode" != default; then 8653 # Only do commands if we really have different PIC objects. 8654 reload_objs="$libobjs $reload_conv_objs" 8655 output="$libobj" 8656 func_execute_cmds "$reload_cmds" 'exit $?' 8657 fi 8658 8659 if test -n "$gentop"; then 8660 func_show_eval '${RM}r "$gentop"' 8661 fi 8662 8663 exit $EXIT_SUCCESS 8664 ;; 8665 8666 prog) 8667 case $host in 8668 *cygwin*) func_stripname '' '.exe' "$output" 8669 output=$func_stripname_result.exe;; 8670 esac 8671 test -n "$vinfo" && \ 8672 func_warning "\`-version-info' is ignored for programs" 8673 8674 test -n "$release" && \ 8675 func_warning "\`-release' is ignored for programs" 8676 8677 test "$preload" = yes \ 8678 && test "$dlopen_support" = unknown \ 8679 && test "$dlopen_self" = unknown \ 8680 && test "$dlopen_self_static" = unknown && \ 8681 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." 8682 8683 case $host in 8684 *-*-rhapsody* | *-*-darwin1.[012]) 8685 # On Rhapsody replace the C library is the System framework 8686 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` 8687 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` 8688 ;; 8689 esac 8690 8691 case $host in 8692 *-*-darwin*) 8693 # Don't allow lazy linking, it breaks C++ global constructors 8694 # But is supposedly fixed on 10.4 or later (yay!). 8695 if test "$tagname" = CXX ; then 8696 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in 8697 10.[0123]) 8698 func_append compile_command " ${wl}-bind_at_load" 8699 func_append finalize_command " ${wl}-bind_at_load" 8700 ;; 8701 esac 8702 fi 8703 # Time to change all our "foo.ltframework" stuff back to "-framework foo" 8704 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 8705 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` 8706 ;; 8707 esac 8708 8709 8710 # move library search paths that coincide with paths to not yet 8711 # installed libraries to the beginning of the library search list 8712 new_libs= 8713 for path in $notinst_path; do 8714 case " $new_libs " in 8715 *" -L$path/$objdir "*) ;; 8716 *) 8717 case " $compile_deplibs " in 8718 *" -L$path/$objdir "*) 8719 func_append new_libs " -L$path/$objdir" ;; 8720 esac 8721 ;; 8722 esac 8723 done 8724 for deplib in $compile_deplibs; do 8725 case $deplib in 8726 -L*) 8727 case " $new_libs " in 8728 *" $deplib "*) ;; 8729 *) func_append new_libs " $deplib" ;; 8730 esac 8731 ;; 8732 *) func_append new_libs " $deplib" ;; 8733 esac 8734 done 8735 compile_deplibs="$new_libs" 8736 8737 8738 func_append compile_command " $compile_deplibs" 8739 func_append finalize_command " $finalize_deplibs" 8740 8741 if test -n "$rpath$xrpath"; then 8742 # If the user specified any rpath flags, then add them. 8743 for libdir in $rpath $xrpath; do 8744 # This is the magic to use -rpath. 8745 case "$finalize_rpath " in 8746 *" $libdir "*) ;; 8747 *) func_append finalize_rpath " $libdir" ;; 8748 esac 8749 done 8750 fi 8751 8752 # Now hardcode the library paths 8753 rpath= 8754 hardcode_libdirs= 8755 for libdir in $compile_rpath $finalize_rpath; do 8756 if test -n "$hardcode_libdir_flag_spec"; then 8757 if test -n "$hardcode_libdir_separator"; then 8758 if test -z "$hardcode_libdirs"; then 8759 hardcode_libdirs="$libdir" 8760 else 8761 # Just accumulate the unique libdirs. 8762 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 8763 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 8764 ;; 8765 *) 8766 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" 8767 ;; 8768 esac 8769 fi 8770 else 8771 eval flag=\"$hardcode_libdir_flag_spec\" 8772 func_append rpath " $flag" 8773 fi 8774 elif test -n "$runpath_var"; then 8775 case "$perm_rpath " in 8776 *" $libdir "*) ;; 8777 *) func_append perm_rpath " $libdir" ;; 8778 esac 8779 fi 8780 case $host in 8781 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 8782 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` 8783 case :$dllsearchpath: in 8784 *":$libdir:"*) ;; 8785 ::) dllsearchpath=$libdir;; 8786 *) func_append dllsearchpath ":$libdir";; 8787 esac 8788 case :$dllsearchpath: in 8789 *":$testbindir:"*) ;; 8790 ::) dllsearchpath=$testbindir;; 8791 *) func_append dllsearchpath ":$testbindir";; 8792 esac 8793 ;; 8794 esac 8795 done 8796 # Substitute the hardcoded libdirs into the rpath. 8797 if test -n "$hardcode_libdir_separator" && 8798 test -n "$hardcode_libdirs"; then 8799 libdir="$hardcode_libdirs" 8800 eval rpath=\" $hardcode_libdir_flag_spec\" 8801 fi 8802 compile_rpath="$rpath" 8803 8804 rpath= 8805 hardcode_libdirs= 8806 for libdir in $finalize_rpath; do 8807 if test -n "$hardcode_libdir_flag_spec"; then 8808 if test -n "$hardcode_libdir_separator"; then 8809 if test -z "$hardcode_libdirs"; then 8810 hardcode_libdirs="$libdir" 8811 else 8812 # Just accumulate the unique libdirs. 8813 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 8814 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 8815 ;; 8816 *) 8817 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" 8818 ;; 8819 esac 8820 fi 8821 else 8822 eval flag=\"$hardcode_libdir_flag_spec\" 8823 func_append rpath " $flag" 8824 fi 8825 elif test -n "$runpath_var"; then 8826 case "$finalize_perm_rpath " in 8827 *" $libdir "*) ;; 8828 *) func_append finalize_perm_rpath " $libdir" ;; 8829 esac 8830 fi 8831 done 8832 # Substitute the hardcoded libdirs into the rpath. 8833 if test -n "$hardcode_libdir_separator" && 8834 test -n "$hardcode_libdirs"; then 8835 libdir="$hardcode_libdirs" 8836 eval rpath=\" $hardcode_libdir_flag_spec\" 8837 fi 8838 finalize_rpath="$rpath" 8839 8840 if test -n "$libobjs" && test "$build_old_libs" = yes; then 8841 # Transform all the library objects into standard objects. 8842 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` 8843 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` 8844 fi 8845 8846 func_generate_dlsyms "$outputname" "@PROGRAM@" "no" 8847 8848 # template prelinking step 8849 if test -n "$prelink_cmds"; then 8850 func_execute_cmds "$prelink_cmds" 'exit $?' 8851 fi 8852 8853 wrappers_required=yes 8854 case $host in 8855 *cegcc* | *mingw32ce*) 8856 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. 8857 wrappers_required=no 8858 ;; 8859 *cygwin* | *mingw* ) 8860 if test "$build_libtool_libs" != yes; then 8861 wrappers_required=no 8862 fi 8863 ;; 8864 *) 8865 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then 8866 wrappers_required=no 8867 fi 8868 ;; 8869 esac 8870 if test "$wrappers_required" = no; then 8871 # Replace the output file specification. 8872 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` 8873 link_command="$compile_command$compile_rpath" 8874 8875 # We have no uninstalled library dependencies, so finalize right now. 8876 exit_status=0 8877 func_show_eval "$link_command" 'exit_status=$?' 8878 8879 if test -n "$postlink_cmds"; then 8880 func_to_tool_file "$output" 8881 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` 8882 func_execute_cmds "$postlink_cmds" 'exit $?' 8883 fi 8884 8885 # Delete the generated files. 8886 if test -f "$output_objdir/${outputname}S.${objext}"; then 8887 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' 8888 fi 8889 8890 exit $exit_status 8891 fi 8892 8893 if test -n "$compile_shlibpath$finalize_shlibpath"; then 8894 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" 8895 fi 8896 if test -n "$finalize_shlibpath"; then 8897 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" 8898 fi 8899 8900 compile_var= 8901 finalize_var= 8902 if test -n "$runpath_var"; then 8903 if test -n "$perm_rpath"; then 8904 # We should set the runpath_var. 8905 rpath= 8906 for dir in $perm_rpath; do 8907 func_append rpath "$dir:" 8908 done 8909 compile_var="$runpath_var=\"$rpath\$$runpath_var\" " 8910 fi 8911 if test -n "$finalize_perm_rpath"; then 8912 # We should set the runpath_var. 8913 rpath= 8914 for dir in $finalize_perm_rpath; do 8915 func_append rpath "$dir:" 8916 done 8917 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " 8918 fi 8919 fi 8920 8921 if test "$no_install" = yes; then 8922 # We don't need to create a wrapper script. 8923 link_command="$compile_var$compile_command$compile_rpath" 8924 # Replace the output file specification. 8925 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` 8926 # Delete the old output file. 8927 $opt_dry_run || $RM $output 8928 # Link the executable and exit 8929 func_show_eval "$link_command" 'exit $?' 8930 8931 if test -n "$postlink_cmds"; then 8932 func_to_tool_file "$output" 8933 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` 8934 func_execute_cmds "$postlink_cmds" 'exit $?' 8935 fi 8936 8937 exit $EXIT_SUCCESS 8938 fi 8939 8940 if test "$hardcode_action" = relink; then 8941 # Fast installation is not supported 8942 link_command="$compile_var$compile_command$compile_rpath" 8943 relink_command="$finalize_var$finalize_command$finalize_rpath" 8944 8945 func_warning "this platform does not like uninstalled shared libraries" 8946 func_warning "\`$output' will be relinked during installation" 8947 else 8948 if test "$fast_install" != no; then 8949 link_command="$finalize_var$compile_command$finalize_rpath" 8950 if test "$fast_install" = yes; then 8951 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` 8952 else 8953 # fast_install is set to needless 8954 relink_command= 8955 fi 8956 else 8957 link_command="$compile_var$compile_command$compile_rpath" 8958 relink_command="$finalize_var$finalize_command$finalize_rpath" 8959 fi 8960 fi 8961 8962 # Replace the output file specification. 8963 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` 8964 8965 # Delete the old output files. 8966 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname 8967 8968 func_show_eval "$link_command" 'exit $?' 8969 8970 if test -n "$postlink_cmds"; then 8971 func_to_tool_file "$output_objdir/$outputname" 8972 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'` 8973 func_execute_cmds "$postlink_cmds" 'exit $?' 8974 fi 8975 8976 # Now create the wrapper script. 8977 func_verbose "creating $output" 8978 8979 # Quote the relink command for shipping. 8980 if test -n "$relink_command"; then 8981 # Preserve any variables that may affect compiler behavior 8982 for var in $variables_saved_for_relink; do 8983 if eval test -z \"\${$var+set}\"; then 8984 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 8985 elif eval var_value=\$$var; test -z "$var_value"; then 8986 relink_command="$var=; export $var; $relink_command" 8987 else 8988 func_quote_for_eval "$var_value" 8989 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 8990 fi 8991 done 8992 relink_command="(cd `pwd`; $relink_command)" 8993 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` 8994 fi 8995 8996 # Only actually do things if not in dry run mode. 8997 $opt_dry_run || { 8998 # win32 will think the script is a binary if it has 8999 # a .exe suffix, so we strip it off here. 9000 case $output in 9001 *.exe) func_stripname '' '.exe' "$output" 9002 output=$func_stripname_result ;; 9003 esac 9004 # test for cygwin because mv fails w/o .exe extensions 9005 case $host in 9006 *cygwin*) 9007 exeext=.exe 9008 func_stripname '' '.exe' "$outputname" 9009 outputname=$func_stripname_result ;; 9010 *) exeext= ;; 9011 esac 9012 case $host in 9013 *cygwin* | *mingw* ) 9014 func_dirname_and_basename "$output" "" "." 9015 output_name=$func_basename_result 9016 output_path=$func_dirname_result 9017 cwrappersource="$output_path/$objdir/lt-$output_name.c" 9018 cwrapper="$output_path/$output_name.exe" 9019 $RM $cwrappersource $cwrapper 9020 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 9021 9022 func_emit_cwrapperexe_src > $cwrappersource 9023 9024 # The wrapper executable is built using the $host compiler, 9025 # because it contains $host paths and files. If cross- 9026 # compiling, it, like the target executable, must be 9027 # executed on the $host or under an emulation environment. 9028 $opt_dry_run || { 9029 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource 9030 $STRIP $cwrapper 9031 } 9032 9033 # Now, create the wrapper script for func_source use: 9034 func_ltwrapper_scriptname $cwrapper 9035 $RM $func_ltwrapper_scriptname_result 9036 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 9037 $opt_dry_run || { 9038 # note: this script will not be executed, so do not chmod. 9039 if test "x$build" = "x$host" ; then 9040 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result 9041 else 9042 func_emit_wrapper no > $func_ltwrapper_scriptname_result 9043 fi 9044 } 9045 ;; 9046 * ) 9047 $RM $output 9048 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 9049 9050 func_emit_wrapper no > $output 9051 chmod +x $output 9052 ;; 9053 esac 9054 } 9055 exit $EXIT_SUCCESS 9056 ;; 9057 esac 9058 9059 # See if we need to build an old-fashioned archive. 9060 for oldlib in $oldlibs; do 9061 9062 if test "$build_libtool_libs" = convenience; then 9063 oldobjs="$libobjs_save $symfileobj" 9064 addlibs="$convenience" 9065 build_libtool_libs=no 9066 else 9067 if test "$build_libtool_libs" = module; then 9068 oldobjs="$libobjs_save" 9069 build_libtool_libs=no 9070 else 9071 oldobjs="$old_deplibs $non_pic_objects" 9072 if test "$preload" = yes && test -f "$symfileobj"; then 9073 func_append oldobjs " $symfileobj" 9074 fi 9075 fi 9076 addlibs="$old_convenience" 9077 fi 9078 9079 if test -n "$addlibs"; then 9080 gentop="$output_objdir/${outputname}x" 9081 func_append generated " $gentop" 9082 9083 func_extract_archives $gentop $addlibs 9084 func_append oldobjs " $func_extract_archives_result" 9085 fi 9086 9087 # Do each command in the archive commands. 9088 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then 9089 cmds=$old_archive_from_new_cmds 9090 else 9091 9092 # Add any objects from preloaded convenience libraries 9093 if test -n "$dlprefiles"; then 9094 gentop="$output_objdir/${outputname}x" 9095 func_append generated " $gentop" 9096 9097 func_extract_archives $gentop $dlprefiles 9098 func_append oldobjs " $func_extract_archives_result" 9099 fi 9100 9101 # POSIX demands no paths to be encoded in archives. We have 9102 # to avoid creating archives with duplicate basenames if we 9103 # might have to extract them afterwards, e.g., when creating a 9104 # static archive out of a convenience library, or when linking 9105 # the entirety of a libtool archive into another (currently 9106 # not supported by libtool). 9107 if (for obj in $oldobjs 9108 do 9109 func_basename "$obj" 9110 $ECHO "$func_basename_result" 9111 done | sort | sort -uc >/dev/null 2>&1); then 9112 : 9113 else 9114 echo "copying selected object files to avoid basename conflicts..." 9115 gentop="$output_objdir/${outputname}x" 9116 func_append generated " $gentop" 9117 func_mkdir_p "$gentop" 9118 save_oldobjs=$oldobjs 9119 oldobjs= 9120 counter=1 9121 for obj in $save_oldobjs 9122 do 9123 func_basename "$obj" 9124 objbase="$func_basename_result" 9125 case " $oldobjs " in 9126 " ") oldobjs=$obj ;; 9127 *[\ /]"$objbase "*) 9128 while :; do 9129 # Make sure we don't pick an alternate name that also 9130 # overlaps. 9131 newobj=lt$counter-$objbase 9132 func_arith $counter + 1 9133 counter=$func_arith_result 9134 case " $oldobjs " in 9135 *[\ /]"$newobj "*) ;; 9136 *) if test ! -f "$gentop/$newobj"; then break; fi ;; 9137 esac 9138 done 9139 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" 9140 func_append oldobjs " $gentop/$newobj" 9141 ;; 9142 *) func_append oldobjs " $obj" ;; 9143 esac 9144 done 9145 fi 9146 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 9147 tool_oldlib=$func_to_tool_file_result 9148 eval cmds=\"$old_archive_cmds\" 9149 9150 func_len " $cmds" 9151 len=$func_len_result 9152 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 9153 cmds=$old_archive_cmds 9154 elif test -n "$archiver_list_spec"; then 9155 func_verbose "using command file archive linking..." 9156 for obj in $oldobjs 9157 do 9158 func_to_tool_file "$obj" 9159 $ECHO "$func_to_tool_file_result" 9160 done > $output_objdir/$libname.libcmd 9161 func_to_tool_file "$output_objdir/$libname.libcmd" 9162 oldobjs=" $archiver_list_spec$func_to_tool_file_result" 9163 cmds=$old_archive_cmds 9164 else 9165 # the command line is too long to link in one step, link in parts 9166 func_verbose "using piecewise archive linking..." 9167 save_RANLIB=$RANLIB 9168 RANLIB=: 9169 objlist= 9170 concat_cmds= 9171 save_oldobjs=$oldobjs 9172 oldobjs= 9173 # Is there a better way of finding the last object in the list? 9174 for obj in $save_oldobjs 9175 do 9176 last_oldobj=$obj 9177 done 9178 eval test_cmds=\"$old_archive_cmds\" 9179 func_len " $test_cmds" 9180 len0=$func_len_result 9181 len=$len0 9182 for obj in $save_oldobjs 9183 do 9184 func_len " $obj" 9185 func_arith $len + $func_len_result 9186 len=$func_arith_result 9187 func_append objlist " $obj" 9188 if test "$len" -lt "$max_cmd_len"; then 9189 : 9190 else 9191 # the above command should be used before it gets too long 9192 oldobjs=$objlist 9193 if test "$obj" = "$last_oldobj" ; then 9194 RANLIB=$save_RANLIB 9195 fi 9196 test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 9197 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" 9198 objlist= 9199 len=$len0 9200 fi 9201 done 9202 RANLIB=$save_RANLIB 9203 oldobjs=$objlist 9204 if test "X$oldobjs" = "X" ; then 9205 eval cmds=\"\$concat_cmds\" 9206 else 9207 eval cmds=\"\$concat_cmds~\$old_archive_cmds\" 9208 fi 9209 fi 9210 fi 9211 func_execute_cmds "$cmds" 'exit $?' 9212 done 9213 9214 test -n "$generated" && \ 9215 func_show_eval "${RM}r$generated" 9216 9217 # Now create the libtool archive. 9218 case $output in 9219 *.la) 9220 old_library= 9221 test "$build_old_libs" = yes && old_library="$libname.$libext" 9222 func_verbose "creating $output" 9223 9224 # Preserve any variables that may affect compiler behavior 9225 for var in $variables_saved_for_relink; do 9226 if eval test -z \"\${$var+set}\"; then 9227 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 9228 elif eval var_value=\$$var; test -z "$var_value"; then 9229 relink_command="$var=; export $var; $relink_command" 9230 else 9231 func_quote_for_eval "$var_value" 9232 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 9233 fi 9234 done 9235 # Quote the link command for shipping. 9236 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" 9237 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` 9238 if test "$hardcode_automatic" = yes ; then 9239 relink_command= 9240 fi 9241 9242 # Only create the output if not a dry run. 9243 $opt_dry_run || { 9244 for installed in no yes; do 9245 if test "$installed" = yes; then 9246 if test -z "$install_libdir"; then 9247 break 9248 fi 9249 output="$output_objdir/$outputname"i 9250 # Replace all uninstalled libtool libraries with the installed ones 9251 newdependency_libs= 9252 for deplib in $dependency_libs; do 9253 case $deplib in 9254 *.la) 9255 func_basename "$deplib" 9256 name="$func_basename_result" 9257 func_resolve_sysroot "$deplib" 9258 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` 9259 test -z "$libdir" && \ 9260 func_fatal_error "\`$deplib' is not a valid libtool archive" 9261 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" 9262 ;; 9263 -L*) 9264 func_stripname -L '' "$deplib" 9265 func_replace_sysroot "$func_stripname_result" 9266 func_append newdependency_libs " -L$func_replace_sysroot_result" 9267 ;; 9268 -R*) 9269 func_stripname -R '' "$deplib" 9270 func_replace_sysroot "$func_stripname_result" 9271 func_append newdependency_libs " -R$func_replace_sysroot_result" 9272 ;; 9273 *) func_append newdependency_libs " $deplib" ;; 9274 esac 9275 done 9276 dependency_libs="$newdependency_libs" 9277 newdlfiles= 9278 9279 for lib in $dlfiles; do 9280 case $lib in 9281 *.la) 9282 func_basename "$lib" 9283 name="$func_basename_result" 9284 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` 9285 test -z "$libdir" && \ 9286 func_fatal_error "\`$lib' is not a valid libtool archive" 9287 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" 9288 ;; 9289 *) func_append newdlfiles " $lib" ;; 9290 esac 9291 done 9292 dlfiles="$newdlfiles" 9293 newdlprefiles= 9294 for lib in $dlprefiles; do 9295 case $lib in 9296 *.la) 9297 # Only pass preopened files to the pseudo-archive (for 9298 # eventual linking with the app. that links it) if we 9299 # didn't already link the preopened objects directly into 9300 # the library: 9301 func_basename "$lib" 9302 name="$func_basename_result" 9303 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` 9304 test -z "$libdir" && \ 9305 func_fatal_error "\`$lib' is not a valid libtool archive" 9306 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" 9307 ;; 9308 esac 9309 done 9310 dlprefiles="$newdlprefiles" 9311 else 9312 newdlfiles= 9313 for lib in $dlfiles; do 9314 case $lib in 9315 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 9316 *) abs=`pwd`"/$lib" ;; 9317 esac 9318 func_append newdlfiles " $abs" 9319 done 9320 dlfiles="$newdlfiles" 9321 newdlprefiles= 9322 for lib in $dlprefiles; do 9323 case $lib in 9324 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 9325 *) abs=`pwd`"/$lib" ;; 9326 esac 9327 func_append newdlprefiles " $abs" 9328 done 9329 dlprefiles="$newdlprefiles" 9330 fi 9331 $RM $output 9332 # place dlname in correct position for cygwin 9333 # In fact, it would be nice if we could use this code for all target 9334 # systems that can't hard-code library paths into their executables 9335 # and that have no shared library path variable independent of PATH, 9336 # but it turns out we can't easily determine that from inspecting 9337 # libtool variables, so we have to hard-code the OSs to which it 9338 # applies here; at the moment, that means platforms that use the PE 9339 # object format with DLL files. See the long comment at the top of 9340 # tests/bindir.at for full details. 9341 tdlname=$dlname 9342 case $host,$output,$installed,$module,$dlname in 9343 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) 9344 # If a -bindir argument was supplied, place the dll there. 9345 if test "x$bindir" != x ; 9346 then 9347 func_relative_path "$install_libdir" "$bindir" 9348 tdlname=$func_relative_path_result$dlname 9349 else 9350 # Otherwise fall back on heuristic. 9351 tdlname=../bin/$dlname 9352 fi 9353 ;; 9354 esac 9355 $ECHO > $output "\ 9356# $outputname - a libtool library file 9357# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 9358# 9359# Please DO NOT delete this file! 9360# It is necessary for linking the library. 9361 9362# The name that we can dlopen(3). 9363dlname='$tdlname' 9364 9365# Names of this library. 9366library_names='$library_names' 9367 9368# The name of the static archive. 9369old_library='$old_library' 9370 9371# Linker flags that can not go in dependency_libs. 9372inherited_linker_flags='$new_inherited_linker_flags' 9373 9374# Libraries that this one depends upon. 9375dependency_libs='$dependency_libs' 9376 9377# Names of additional weak libraries provided by this library 9378weak_library_names='$weak_libs' 9379 9380# Version information for $libname. 9381current=$current 9382age=$age 9383revision=$revision 9384 9385# Is this an already installed library? 9386installed=$installed 9387 9388# Should we warn about portability when linking against -modules? 9389shouldnotlink=$module 9390 9391# Files to dlopen/dlpreopen 9392dlopen='$dlfiles' 9393dlpreopen='$dlprefiles' 9394 9395# Directory that this library needs to be installed in: 9396libdir='$install_libdir'" 9397 if test "$installed" = no && test "$need_relink" = yes; then 9398 $ECHO >> $output "\ 9399relink_command=\"$relink_command\"" 9400 fi 9401 done 9402 } 9403 9404 # Do a symbolic link so that the libtool archive can be found in 9405 # LD_LIBRARY_PATH before the program is installed. 9406 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' 9407 ;; 9408 esac 9409 exit $EXIT_SUCCESS 9410} 9411 9412{ test "$opt_mode" = link || test "$opt_mode" = relink; } && 9413 func_mode_link ${1+"$@"} 9414 9415 9416# func_mode_uninstall arg... 9417func_mode_uninstall () 9418{ 9419 $opt_debug 9420 RM="$nonopt" 9421 files= 9422 rmforce= 9423 exit_status=0 9424 9425 # This variable tells wrapper scripts just to set variables rather 9426 # than running their programs. 9427 libtool_install_magic="$magic" 9428 9429 for arg 9430 do 9431 case $arg in 9432 -f) func_append RM " $arg"; rmforce=yes ;; 9433 -*) func_append RM " $arg" ;; 9434 *) func_append files " $arg" ;; 9435 esac 9436 done 9437 9438 test -z "$RM" && \ 9439 func_fatal_help "you must specify an RM program" 9440 9441 rmdirs= 9442 9443 for file in $files; do 9444 func_dirname "$file" "" "." 9445 dir="$func_dirname_result" 9446 if test "X$dir" = X.; then 9447 odir="$objdir" 9448 else 9449 odir="$dir/$objdir" 9450 fi 9451 func_basename "$file" 9452 name="$func_basename_result" 9453 test "$opt_mode" = uninstall && odir="$dir" 9454 9455 # Remember odir for removal later, being careful to avoid duplicates 9456 if test "$opt_mode" = clean; then 9457 case " $rmdirs " in 9458 *" $odir "*) ;; 9459 *) func_append rmdirs " $odir" ;; 9460 esac 9461 fi 9462 9463 # Don't error if the file doesn't exist and rm -f was used. 9464 if { test -L "$file"; } >/dev/null 2>&1 || 9465 { test -h "$file"; } >/dev/null 2>&1 || 9466 test -f "$file"; then 9467 : 9468 elif test -d "$file"; then 9469 exit_status=1 9470 continue 9471 elif test "$rmforce" = yes; then 9472 continue 9473 fi 9474 9475 rmfiles="$file" 9476 9477 case $name in 9478 *.la) 9479 # Possibly a libtool archive, so verify it. 9480 if func_lalib_p "$file"; then 9481 func_source $dir/$name 9482 9483 # Delete the libtool libraries and symlinks. 9484 for n in $library_names; do 9485 func_append rmfiles " $odir/$n" 9486 done 9487 test -n "$old_library" && func_append rmfiles " $odir/$old_library" 9488 9489 case "$opt_mode" in 9490 clean) 9491 case " $library_names " in 9492 *" $dlname "*) ;; 9493 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; 9494 esac 9495 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" 9496 ;; 9497 uninstall) 9498 if test -n "$library_names"; then 9499 # Do each command in the postuninstall commands. 9500 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 9501 fi 9502 9503 if test -n "$old_library"; then 9504 # Do each command in the old_postuninstall commands. 9505 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 9506 fi 9507 # FIXME: should reinstall the best remaining shared library. 9508 ;; 9509 esac 9510 fi 9511 ;; 9512 9513 *.lo) 9514 # Possibly a libtool object, so verify it. 9515 if func_lalib_p "$file"; then 9516 9517 # Read the .lo file 9518 func_source $dir/$name 9519 9520 # Add PIC object to the list of files to remove. 9521 if test -n "$pic_object" && 9522 test "$pic_object" != none; then 9523 func_append rmfiles " $dir/$pic_object" 9524 fi 9525 9526 # Add non-PIC object to the list of files to remove. 9527 if test -n "$non_pic_object" && 9528 test "$non_pic_object" != none; then 9529 func_append rmfiles " $dir/$non_pic_object" 9530 fi 9531 fi 9532 ;; 9533 9534 *) 9535 if test "$opt_mode" = clean ; then 9536 noexename=$name 9537 case $file in 9538 *.exe) 9539 func_stripname '' '.exe' "$file" 9540 file=$func_stripname_result 9541 func_stripname '' '.exe' "$name" 9542 noexename=$func_stripname_result 9543 # $file with .exe has already been added to rmfiles, 9544 # add $file without .exe 9545 func_append rmfiles " $file" 9546 ;; 9547 esac 9548 # Do a test to see if this is a libtool program. 9549 if func_ltwrapper_p "$file"; then 9550 if func_ltwrapper_executable_p "$file"; then 9551 func_ltwrapper_scriptname "$file" 9552 relink_command= 9553 func_source $func_ltwrapper_scriptname_result 9554 func_append rmfiles " $func_ltwrapper_scriptname_result" 9555 else 9556 relink_command= 9557 func_source $dir/$noexename 9558 fi 9559 9560 # note $name still contains .exe if it was in $file originally 9561 # as does the version of $file that was added into $rmfiles 9562 func_append rmfiles " $odir/$name $odir/${name}S.${objext}" 9563 if test "$fast_install" = yes && test -n "$relink_command"; then 9564 func_append rmfiles " $odir/lt-$name" 9565 fi 9566 if test "X$noexename" != "X$name" ; then 9567 func_append rmfiles " $odir/lt-${noexename}.c" 9568 fi 9569 fi 9570 fi 9571 ;; 9572 esac 9573 func_show_eval "$RM $rmfiles" 'exit_status=1' 9574 done 9575 9576 # Try to remove the ${objdir}s in the directories where we deleted files 9577 for dir in $rmdirs; do 9578 if test -d "$dir"; then 9579 func_show_eval "rmdir $dir >/dev/null 2>&1" 9580 fi 9581 done 9582 9583 exit $exit_status 9584} 9585 9586{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } && 9587 func_mode_uninstall ${1+"$@"} 9588 9589test -z "$opt_mode" && { 9590 help="$generic_help" 9591 func_fatal_help "you must specify a MODE" 9592} 9593 9594test -z "$exec_cmd" && \ 9595 func_fatal_help "invalid operation mode \`$opt_mode'" 9596 9597if test -n "$exec_cmd"; then 9598 eval exec "$exec_cmd" 9599 exit $EXIT_FAILURE 9600fi 9601 9602exit $exit_status 9603 9604 9605# The TAGs below are defined such that we never get into a situation 9606# in which we disable both kinds of libraries. Given conflicting 9607# choices, we go for a static library, that is the most portable, 9608# since we can't tell whether shared libraries were disabled because 9609# the user asked for that or because the platform doesn't support 9610# them. This is particularly important on AIX, because we don't 9611# support having both static and shared libraries enabled at the same 9612# time on that platform, so we default to a shared-only configuration. 9613# If a disable-shared tag is given, we'll fallback to a static-only 9614# configuration. But we'll never go from static-only to shared-only. 9615 9616# ### BEGIN LIBTOOL TAG CONFIG: disable-shared 9617build_libtool_libs=no 9618build_old_libs=yes 9619# ### END LIBTOOL TAG CONFIG: disable-shared 9620 9621# ### BEGIN LIBTOOL TAG CONFIG: disable-static 9622build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` 9623# ### END LIBTOOL TAG CONFIG: disable-static 9624 9625# Local Variables: 9626# mode:shell-script 9627# sh-indentation:2 9628# End: 9629# vi:sw=2 9630 9631