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