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