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