embedaddon/sudo/ltmain.sh - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / ltmain.sh
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Sun Jun 15 16:12:53 2014 UTC (10 years ago) by misho
Branches: sudo, MAIN
CVS tags: v1_8_10p3_0, v1_8_10p3, HEAD

sudo v 1.8.10p3

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