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