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