embedaddon/iperf/config/ltmain.sh - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / iperf / config / ltmain.sh
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Wed Sep 27 11:14:54 2023 UTC (10 months, 2 weeks ago) by misho
Branches: iperf, MAIN
CVS tags: v3_15, HEAD

Version 3.15

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