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