embedaddon/libevent/ltmain.sh - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent / ltmain.sh
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Tue Feb 21 23:02:54 2012 UTC (12 years, 3 months ago) by misho
Branches: libevent, MAIN
CVS tags: v1_4_14bp0, v1_4_14b, HEAD

libevent

1: # Generated from ltmain.m4sh. 2: 3: # ltmain.sh (GNU libtool) 2.2.6b 4: # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996 5: 6: # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc. 7: # This is free software; see the source for copying conditions. There is NO 8: # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 9: 10: # GNU Libtool is free software; you can redistribute it and/or modify 11: # it under the terms of the GNU General Public License as published by 12: # the Free Software Foundation; either version 2 of the License, or 13: # (at your option) any later version. 14: # 15: # As a special exception to the GNU General Public License, 16: # if you distribute this file as part of a program or library that 17: # is built using GNU Libtool, you may include this file under the 18: # same distribution terms that you use for the rest of that program. 19: # 20: # GNU Libtool is distributed in the hope that it will be useful, but 21: # WITHOUT ANY WARRANTY; without even the implied warranty of 22: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23: # General Public License for more details. 24: # 25: # You should have received a copy of the GNU General Public License 26: # along with GNU Libtool; see the file COPYING. If not, a copy 27: # can be downloaded from http://www.gnu.org/licenses/gpl.html, 28: # or obtained by writing to the Free Software Foundation, Inc., 29: # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 30: 31: # Usage: $progname [OPTION]... [MODE-ARG]... 32: # 33: # Provide generalized library-building support services. 34: # 35: # --config show all configuration variables 36: # --debug enable verbose shell tracing 37: # -n, --dry-run display commands without modifying any files 38: # --features display basic configuration information and exit 39: # --mode=MODE use operation mode MODE 40: # --preserve-dup-deps don't remove duplicate dependency libraries 41: # --quiet, --silent don't print informational messages 42: # --tag=TAG use configuration variables from tag TAG 43: # -v, --verbose print informational messages (default) 44: # --version print version information 45: # -h, --help print short or long help message 46: # 47: # MODE must be one of the following: 48: # 49: # clean remove files from the build directory 50: # compile compile a source file into a libtool object 51: # execute automatically set library path, then run a program 52: # finish complete the installation of libtool libraries 53: # install install libraries or executables 54: # link create a library or an executable 55: # uninstall remove libraries from an installed directory 56: # 57: # MODE-ARGS vary depending on the MODE. 58: # Try `$progname --help --mode=MODE' for a more detailed description of MODE. 59: # 60: # When reporting a bug, please describe a test case to reproduce it and 61: # include the following information: 62: # 63: # host-triplet: $host 64: # shell: $SHELL 65: # compiler: $LTCC 66: # compiler flags: $LTCFLAGS 67: # linker: $LD (gnu? $with_gnu_ld) 68: # $progname: (GNU libtool) 2.2.6b 69: # automake: $automake_version 70: # autoconf: $autoconf_version 71: # 72: # Report bugs to <bug-libtool@gnu.org>. 73: 74: PROGRAM=ltmain.sh 75: PACKAGE=libtool 76: VERSION=2.2.6b 77: TIMESTAMP="" 78: package_revision=1.3017 79: 80: # Be Bourne compatible 81: if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then 82: emulate sh 83: NULLCMD=: 84: # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which 85: # is contrary to our usage. Disable this feature. 86: alias -g '${1+"$@"}'='"$@"' 87: setopt NO_GLOB_SUBST 88: else 89: case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac 90: fi 91: BIN_SH=xpg4; export BIN_SH # for Tru64 92: DUALCASE=1; export DUALCASE # for MKS sh 93: 94: # NLS nuisances: We save the old values to restore during execute mode. 95: # Only set LANG and LC_ALL to C if already set. 96: # These must not be set unconditionally because not all systems understand 97: # e.g. LANG=C (notably SCO). 98: lt_user_locale= 99: lt_safe_locale= 100: for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES 101: do 102: eval "if test \"\${$lt_var+set}\" = set; then 103: save_$lt_var=\$$lt_var 104: $lt_var=C 105: export $lt_var 106: lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" 107: lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" 108: fi" 109: done 110: 111: $lt_unset CDPATH 112: 113: 114: 115: 116: 117: : ${CP="cp -f"} 118: : ${ECHO="echo"} 119: : ${EGREP="/bin/grep -E"} 120: : ${FGREP="/bin/grep -F"} 121: : ${GREP="/bin/grep"} 122: : ${LN_S="ln -s"} 123: : ${MAKE="make"} 124: : ${MKDIR="mkdir"} 125: : ${MV="mv -f"} 126: : ${RM="rm -f"} 127: : ${SED="/bin/sed"} 128: : ${SHELL="${CONFIG_SHELL-/bin/sh}"} 129: : ${Xsed="$SED -e 1s/^X//"} 130: 131: # Global variables: 132: EXIT_SUCCESS=0 133: EXIT_FAILURE=1 134: EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. 135: EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. 136: 137: exit_status=$EXIT_SUCCESS 138: 139: # Make sure IFS has a sensible default 140: lt_nl=' 141: ' 142: IFS=" $lt_nl" 143: 144: dirname="s,/[^/]*$,," 145: basename="s,^.*/,," 146: 147: # func_dirname_and_basename file append nondir_replacement 148: # perform func_basename and func_dirname in a single function 149: # call: 150: # dirname: Compute the dirname of FILE. If nonempty, 151: # add APPEND to the result, otherwise set result 152: # to NONDIR_REPLACEMENT. 153: # value returned in "$func_dirname_result" 154: # basename: Compute filename of FILE. 155: # value retuned in "$func_basename_result" 156: # Implementation must be kept synchronized with func_dirname 157: # and func_basename. For efficiency, we do not delegate to 158: # those functions but instead duplicate the functionality here. 159: func_dirname_and_basename () 160: { 161: # Extract subdirectory from the argument. 162: func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"` 163: if test "X$func_dirname_result" = "X${1}"; then 164: func_dirname_result="${3}" 165: else 166: func_dirname_result="$func_dirname_result${2}" 167: fi 168: func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"` 169: } 170: 171: # Generated shell functions inserted here. 172: 173: # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh 174: # is ksh but when the shell is invoked as "sh" and the current value of 175: # the _XPG environment variable is not equal to 1 (one), the special 176: # positional parameter $0, within a function call, is the name of the 177: # function. 178: progpath="$0" 179: 180: # The name of this program: 181: # In the unlikely event $progname began with a '-', it would play havoc with 182: # func_echo (imagine progname=-n), so we prepend ./ in that case: 183: func_dirname_and_basename "$progpath" 184: progname=$func_basename_result 185: case $progname in 186: -*) progname=./$progname ;; 187: esac 188: 189: # Make sure we have an absolute path for reexecution: 190: case $progpath in 191: [\\/]*|[A-Za-z]:\\*) ;; 192: *[\\/]*) 193: progdir=$func_dirname_result 194: progdir=`cd "$progdir" && pwd` 195: progpath="$progdir/$progname" 196: ;; 197: *) 198: save_IFS="$IFS" 199: IFS=: 200: for progdir in $PATH; do 201: IFS="$save_IFS" 202: test -x "$progdir/$progname" && break 203: done 204: IFS="$save_IFS" 205: test -n "$progdir" || progdir=`pwd` 206: progpath="$progdir/$progname" 207: ;; 208: esac 209: 210: # Sed substitution that helps us do robust quoting. It backslashifies 211: # metacharacters that are still active within double-quoted strings. 212: Xsed="${SED}"' -e 1s/^X//' 213: sed_quote_subst='s/$[`"$\\]$/\\\1/g' 214: 215: # Same as above, but do not quote variable references. 216: double_quote_subst='s/$["`\\]$/\\\1/g' 217: 218: # Re-`\' parameter expansions in output of double_quote_subst that were 219: # `\'-ed in input to the same. If an odd number of `\' preceded a '$' 220: # in input to double_quote_subst, that '$' was protected from expansion. 221: # Since each input `\' is now two `\'s, look for any number of runs of 222: # four `\'s followed by two `\'s and then a '$'. `\' that '$'. 223: bs='\\' 224: bs2='\\\\' 225: bs4='\\\\\\\\' 226: dollar='\$' 227: sed_double_backslash="\ 228: s/$bs4/&\\ 229: /g 230: s/^$bs2$dollar/$bs&/ 231: s/\$[^$bs]\$$bs2$dollar/\\1$bs2$bs$dollar/g 232: s/\n//g" 233: 234: # Standard options: 235: opt_dry_run=false 236: opt_help=false 237: opt_quiet=false 238: opt_verbose=false 239: opt_warning=: 240: 241: # func_echo arg... 242: # Echo program name prefixed message, along with the current mode 243: # name if it has been set yet. 244: func_echo () 245: { 246: $ECHO "$progname${mode+: }$mode: $*" 247: } 248: 249: # func_verbose arg... 250: # Echo program name prefixed message in verbose mode only. 251: func_verbose () 252: { 253: $opt_verbose && func_echo ${1+"$@"} 254: 255: # A bug in bash halts the script if the last line of a function 256: # fails when set -e is in force, so we need another command to 257: # work around that: 258: : 259: } 260: 261: # func_error arg... 262: # Echo program name prefixed message to standard error. 263: func_error () 264: { 265: $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2 266: } 267: 268: # func_warning arg... 269: # Echo program name prefixed warning message to standard error. 270: func_warning () 271: { 272: $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2 273: 274: # bash bug again: 275: : 276: } 277: 278: # func_fatal_error arg... 279: # Echo program name prefixed message to standard error, and exit. 280: func_fatal_error () 281: { 282: func_error ${1+"$@"} 283: exit $EXIT_FAILURE 284: } 285: 286: # func_fatal_help arg... 287: # Echo program name prefixed message to standard error, followed by 288: # a help hint, and exit. 289: func_fatal_help () 290: { 291: func_error ${1+"$@"} 292: func_fatal_error "$help" 293: } 294: help="Try \`$progname --help' for more information." ## default 295: 296: 297: # func_grep expression filename 298: # Check whether EXPRESSION matches any line of FILENAME, without output. 299: func_grep () 300: { 301: $GREP "$1" "$2" >/dev/null 2>&1 302: } 303: 304: 305: # func_mkdir_p directory-path 306: # Make sure the entire path to DIRECTORY-PATH is available. 307: func_mkdir_p () 308: { 309: my_directory_path="$1" 310: my_dir_list= 311: 312: if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then 313: 314: # Protect directory names starting with `-' 315: case $my_directory_path in 316: -*) my_directory_path="./$my_directory_path" ;; 317: esac 318: 319: # While some portion of DIR does not yet exist... 320: while test ! -d "$my_directory_path"; do 321: # ...make a list in topmost first order. Use a colon delimited 322: # list incase some portion of path contains whitespace. 323: my_dir_list="$my_directory_path:$my_dir_list" 324: 325: # If the last portion added has no slash in it, the list is done 326: case $my_directory_path in */*) ;; *) break ;; esac 327: 328: # ...otherwise throw away the child directory and loop 329: my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"` 330: done 331: my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'` 332: 333: save_mkdir_p_IFS="$IFS"; IFS=':' 334: for my_dir in $my_dir_list; do 335: IFS="$save_mkdir_p_IFS" 336: # mkdir can fail with a `File exist' error if two processes 337: # try to create one of the directories concurrently. Don't 338: # stop in that case! 339: $MKDIR "$my_dir" 2>/dev/null || : 340: done 341: IFS="$save_mkdir_p_IFS" 342: 343: # Bail out if we (or some other process) failed to create a directory. 344: test -d "$my_directory_path" || \ 345: func_fatal_error "Failed to create \`$1'" 346: fi 347: } 348: 349: 350: # func_mktempdir [string] 351: # Make a temporary directory that won't clash with other running 352: # libtool processes, and avoids race conditions if possible. If 353: # given, STRING is the basename for that directory. 354: func_mktempdir () 355: { 356: my_template="${TMPDIR-/tmp}/${1-$progname}" 357: 358: if test "$opt_dry_run" = ":"; then 359: # Return a directory name, but don't create it in dry-run mode 360: my_tmpdir="${my_template}-$$" 361: else 362: 363: # If mktemp works, use that first and foremost 364: my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null` 365: 366: if test ! -d "$my_tmpdir"; then 367: # Failing that, at least try and use $RANDOM to avoid a race 368: my_tmpdir="${my_template}-${RANDOM-0}$$" 369: 370: save_mktempdir_umask=`umask` 371: umask 0077 372: $MKDIR "$my_tmpdir" 373: umask $save_mktempdir_umask 374: fi 375: 376: # If we're not in dry-run mode, bomb out on failure 377: test -d "$my_tmpdir" || \ 378: func_fatal_error "cannot create temporary directory \`$my_tmpdir'" 379: fi 380: 381: $ECHO "X$my_tmpdir" | $Xsed 382: } 383: 384: 385: # func_quote_for_eval arg 386: # Aesthetically quote ARG to be evaled later. 387: # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT 388: # is double-quoted, suitable for a subsequent eval, whereas 389: # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters 390: # which are still active within double quotes backslashified. 391: func_quote_for_eval () 392: { 393: case $1 in 394: *[\\\`\"\$]*) 395: func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;; 396: *) 397: func_quote_for_eval_unquoted_result="$1" ;; 398: esac 399: 400: case $func_quote_for_eval_unquoted_result in 401: # Double-quote args containing shell metacharacters to delay 402: # word splitting, command substitution and and variable 403: # expansion for a subsequent eval. 404: # Many Bourne shells cannot handle close brackets correctly 405: # in scan sets, so we specify it separately. 406: *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") 407: func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\"" 408: ;; 409: *) 410: func_quote_for_eval_result="$func_quote_for_eval_unquoted_result" 411: esac 412: } 413: 414: 415: # func_quote_for_expand arg 416: # Aesthetically quote ARG to be evaled later; same as above, 417: # but do not quote variable references. 418: func_quote_for_expand () 419: { 420: case $1 in 421: *[\\\`\"]*) 422: my_arg=`$ECHO "X$1" | $Xsed \ 423: -e "$double_quote_subst" -e "$sed_double_backslash"` ;; 424: *) 425: my_arg="$1" ;; 426: esac 427: 428: case $my_arg in 429: # Double-quote args containing shell metacharacters to delay 430: # word splitting and command substitution for a subsequent eval. 431: # Many Bourne shells cannot handle close brackets correctly 432: # in scan sets, so we specify it separately. 433: *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") 434: my_arg="\"$my_arg\"" 435: ;; 436: esac 437: 438: func_quote_for_expand_result="$my_arg" 439: } 440: 441: 442: # func_show_eval cmd [fail_exp] 443: # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is 444: # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP 445: # is given, then evaluate it. 446: func_show_eval () 447: { 448: my_cmd="$1" 449: my_fail_exp="${2-:}" 450: 451: ${opt_silent-false} || { 452: func_quote_for_expand "$my_cmd" 453: eval "func_echo $func_quote_for_expand_result" 454: } 455: 456: if ${opt_dry_run-false}; then :; else 457: eval "$my_cmd" 458: my_status=$? 459: if test "$my_status" -eq 0; then :; else 460: eval "(exit $my_status); $my_fail_exp" 461: fi 462: fi 463: } 464: 465: 466: # func_show_eval_locale cmd [fail_exp] 467: # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is 468: # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP 469: # is given, then evaluate it. Use the saved locale for evaluation. 470: func_show_eval_locale () 471: { 472: my_cmd="$1" 473: my_fail_exp="${2-:}" 474: 475: ${opt_silent-false} || { 476: func_quote_for_expand "$my_cmd" 477: eval "func_echo $func_quote_for_expand_result" 478: } 479: 480: if ${opt_dry_run-false}; then :; else 481: eval "$lt_user_locale 482: $my_cmd" 483: my_status=$? 484: eval "$lt_safe_locale" 485: if test "$my_status" -eq 0; then :; else 486: eval "(exit $my_status); $my_fail_exp" 487: fi 488: fi 489: } 490: 491: 492: 493: 494: 495: # func_version 496: # Echo version message to standard output and exit. 497: func_version () 498: { 499: $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / { 500: s/^# // 501: s/^# *$// 502: s/$(C)$[ 0-9,-]*$ [1-9][0-9]*$/\1\2/ 503: p 504: }' < "$progpath" 505: exit $? 506: } 507: 508: # func_usage 509: # Echo short help message to standard output and exit. 510: func_usage () 511: { 512: $SED -n '/^# Usage:/,/# -h/ { 513: s/^# // 514: s/^# *$// 515: s/\$progname/'$progname'/ 516: p 517: }' < "$progpath" 518: $ECHO 519: $ECHO "run \`$progname --help | more' for full usage" 520: exit $? 521: } 522: 523: # func_help 524: # Echo long help message to standard output and exit. 525: func_help () 526: { 527: $SED -n '/^# Usage:/,/# Report bugs to/ { 528: s/^# // 529: s/^# *$// 530: s*\$progname*'$progname'* 531: s*\$host*'"$host"'* 532: s*\$SHELL*'"$SHELL"'* 533: s*\$LTCC*'"$LTCC"'* 534: s*\$LTCFLAGS*'"$LTCFLAGS"'* 535: s*\$LD*'"$LD"'* 536: s/\$with_gnu_ld/'"$with_gnu_ld"'/ 537: s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/ 538: s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/ 539: p 540: }' < "$progpath" 541: exit $? 542: } 543: 544: # func_missing_arg argname 545: # Echo program name prefixed message to standard error and set global 546: # exit_cmd. 547: func_missing_arg () 548: { 549: func_error "missing argument for $1" 550: exit_cmd=exit 551: } 552: 553: exit_cmd=: 554: 555: 556: 557: 558: 559: # Check that we have a working $ECHO. 560: if test "X$1" = X--no-reexec; then 561: # Discard the --no-reexec flag, and continue. 562: shift 563: elif test "X$1" = X--fallback-echo; then 564: # Avoid inline document here, it may be left over 565: : 566: elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then 567: # Yippee, $ECHO works! 568: : 569: else 570: # Restart under the correct shell, and then maybe $ECHO will work. 571: exec $SHELL "$progpath" --no-reexec ${1+"$@"} 572: fi 573: 574: if test "X$1" = X--fallback-echo; then 575: # used as fallback echo 576: shift 577: cat <<EOF 578: $* 579: EOF 580: exit $EXIT_SUCCESS 581: fi 582: 583: magic="%%%MAGIC variable%%%" 584: magic_exe="%%%MAGIC EXE variable%%%" 585: 586: # Global variables. 587: # $mode is unset 588: nonopt= 589: execute_dlfiles= 590: preserve_args= 591: lo2o="s/\\.lo\$/.${objext}/" 592: o2lo="s/\\.${objext}\$/.lo/" 593: extracted_archives= 594: extracted_serial=0 595: 596: opt_dry_run=false 597: opt_duplicate_deps=false 598: opt_silent=false 599: opt_debug=: 600: 601: # If this variable is set in any of the actions, the command in it 602: # will be execed at the end. This prevents here-documents from being 603: # left over by shells. 604: exec_cmd= 605: 606: # func_fatal_configuration arg... 607: # Echo program name prefixed message to standard error, followed by 608: # a configuration failure hint, and exit. 609: func_fatal_configuration () 610: { 611: func_error ${1+"$@"} 612: func_error "See the $PACKAGE documentation for more information." 613: func_fatal_error "Fatal configuration error." 614: } 615: 616: 617: # func_config 618: # Display the configuration for all the tags in this script. 619: func_config () 620: { 621: re_begincf='^# ### BEGIN LIBTOOL' 622: re_endcf='^# ### END LIBTOOL' 623: 624: # Default configuration. 625: $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" 626: 627: # Now print the configurations for the tags. 628: for tagname in $taglist; do 629: $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" 630: done 631: 632: exit $? 633: } 634: 635: # func_features 636: # Display the features supported by this script. 637: func_features () 638: { 639: $ECHO "host: $host" 640: if test "$build_libtool_libs" = yes; then 641: $ECHO "enable shared libraries" 642: else 643: $ECHO "disable shared libraries" 644: fi 645: if test "$build_old_libs" = yes; then 646: $ECHO "enable static libraries" 647: else 648: $ECHO "disable static libraries" 649: fi 650: 651: exit $? 652: } 653: 654: # func_enable_tag tagname 655: # Verify that TAGNAME is valid, and either flag an error and exit, or 656: # enable the TAGNAME tag. We also add TAGNAME to the global $taglist 657: # variable here. 658: func_enable_tag () 659: { 660: # Global variable: 661: tagname="$1" 662: 663: re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" 664: re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" 665: sed_extractcf="/$re_begincf/,/$re_endcf/p" 666: 667: # Validate tagname. 668: case $tagname in 669: *[!-_A-Za-z0-9,/]*) 670: func_fatal_error "invalid tag name: $tagname" 671: ;; 672: esac 673: 674: # Don't test for the "default" C tag, as we know it's 675: # there but not specially marked. 676: case $tagname in 677: CC) ;; 678: *) 679: if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then 680: taglist="$taglist $tagname" 681: 682: # Evaluate the configuration. Be careful to quote the path 683: # and the sed script, to avoid splitting on whitespace, but 684: # also don't use non-portable quotes within backquotes within 685: # quotes we have to do it in 2 steps: 686: extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` 687: eval "$extractedcf" 688: else 689: func_error "ignoring unknown tag $tagname" 690: fi 691: ;; 692: esac 693: } 694: 695: # Parse options once, thoroughly. This comes as soon as possible in 696: # the script to make things like `libtool --version' happen quickly. 697: { 698: 699: # Shorthand for --mode=foo, only valid as the first argument 700: case $1 in 701: clean|clea|cle|cl) 702: shift; set dummy --mode clean ${1+"$@"}; shift 703: ;; 704: compile|compil|compi|comp|com|co|c) 705: shift; set dummy --mode compile ${1+"$@"}; shift 706: ;; 707: execute|execut|execu|exec|exe|ex|e) 708: shift; set dummy --mode execute ${1+"$@"}; shift 709: ;; 710: finish|finis|fini|fin|fi|f) 711: shift; set dummy --mode finish ${1+"$@"}; shift 712: ;; 713: install|instal|insta|inst|ins|in|i) 714: shift; set dummy --mode install ${1+"$@"}; shift 715: ;; 716: link|lin|li|l) 717: shift; set dummy --mode link ${1+"$@"}; shift 718: ;; 719: uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) 720: shift; set dummy --mode uninstall ${1+"$@"}; shift 721: ;; 722: esac 723: 724: # Parse non-mode specific arguments: 725: while test "$#" -gt 0; do 726: opt="$1" 727: shift 728: 729: case $opt in 730: --config) func_config ;; 731: 732: --debug) preserve_args="$preserve_args $opt" 733: func_echo "enabling shell trace mode" 734: opt_debug='set -x' 735: $opt_debug 736: ;; 737: 738: -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break 739: execute_dlfiles="$execute_dlfiles $1" 740: shift 741: ;; 742: 743: --dry-run | -n) opt_dry_run=: ;; 744: --features) func_features ;; 745: --finish) mode="finish" ;; 746: 747: --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break 748: case $1 in 749: # Valid mode arguments: 750: clean) ;; 751: compile) ;; 752: execute) ;; 753: finish) ;; 754: install) ;; 755: link) ;; 756: relink) ;; 757: uninstall) ;; 758: 759: # Catch anything else as an error 760: *) func_error "invalid argument for $opt" 761: exit_cmd=exit 762: break 763: ;; 764: esac 765: 766: mode="$1" 767: shift 768: ;; 769: 770: --preserve-dup-deps) 771: opt_duplicate_deps=: ;; 772: 773: --quiet|--silent) preserve_args="$preserve_args $opt" 774: opt_silent=: 775: ;; 776: 777: --verbose| -v) preserve_args="$preserve_args $opt" 778: opt_silent=false 779: ;; 780: 781: --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break 782: preserve_args="$preserve_args $opt $1" 783: func_enable_tag "$1" # tagname is set here 784: shift 785: ;; 786: 787: # Separate optargs to long options: 788: -dlopen=*|--mode=*|--tag=*) 789: func_opt_split "$opt" 790: set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"} 791: shift 792: ;; 793: 794: -\?|-h) func_usage ;; 795: --help) opt_help=: ;; 796: --version) func_version ;; 797: 798: -*) func_fatal_help "unrecognized option \`$opt'" ;; 799: 800: *) nonopt="$opt" 801: break 802: ;; 803: esac 804: done 805: 806: 807: case $host in 808: *cygwin* | *mingw* | *pw32* | *cegcc*) 809: # don't eliminate duplications in $postdeps and $predeps 810: opt_duplicate_compiler_generated_deps=: 811: ;; 812: *) 813: opt_duplicate_compiler_generated_deps=$opt_duplicate_deps 814: ;; 815: esac 816: 817: # Having warned about all mis-specified options, bail out if 818: # anything was wrong. 819: $exit_cmd $EXIT_FAILURE 820: } 821: 822: # func_check_version_match 823: # Ensure that we are using m4 macros, and libtool script from the same 824: # release of libtool. 825: func_check_version_match () 826: { 827: if test "$package_revision" != "$macro_revision"; then 828: if test "$VERSION" != "$macro_version"; then 829: if test -z "$macro_version"; then 830: cat >&2 <<_LT_EOF 831: $progname: Version mismatch error. This is $PACKAGE $VERSION, but the 832: $progname: definition of this LT_INIT comes from an older release. 833: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION 834: $progname: and run autoconf again. 835: _LT_EOF 836: else 837: cat >&2 <<_LT_EOF 838: $progname: Version mismatch error. This is $PACKAGE $VERSION, but the 839: $progname: definition of this LT_INIT comes from $PACKAGE $macro_version. 840: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION 841: $progname: and run autoconf again. 842: _LT_EOF 843: fi 844: else 845: cat >&2 <<_LT_EOF 846: $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, 847: $progname: but the definition of this LT_INIT comes from revision $macro_revision. 848: $progname: You should recreate aclocal.m4 with macros from revision $package_revision 849: $progname: of $PACKAGE $VERSION and run autoconf again. 850: _LT_EOF 851: fi 852: 853: exit $EXIT_MISMATCH 854: fi 855: } 856: 857: 858: ## ----------- ## 859: ## Main. ## 860: ## ----------- ## 861: 862: $opt_help || { 863: # Sanity checks first: 864: func_check_version_match 865: 866: if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then 867: func_fatal_configuration "not configured to build any kind of library" 868: fi 869: 870: test -z "$mode" && func_fatal_error "error: you must specify a MODE." 871: 872: 873: # Darwin sucks 874: eval std_shrext=\"$shrext_cmds\" 875: 876: 877: # Only execute mode is allowed to have -dlopen flags. 878: if test -n "$execute_dlfiles" && test "$mode" != execute; then 879: func_error "unrecognized option \`-dlopen'" 880: $ECHO "$help" 1>&2 881: exit $EXIT_FAILURE 882: fi 883: 884: # Change the help message to a mode-specific one. 885: generic_help="$help" 886: help="Try \`$progname --help --mode=$mode' for more information." 887: } 888: 889: 890: # func_lalib_p file 891: # True iff FILE is a libtool `.la' library or `.lo' object file. 892: # This function is only a basic sanity check; it will hardly flush out 893: # determined imposters. 894: func_lalib_p () 895: { 896: test -f "$1" && 897: $SED -e 4q "$1" 2>/dev/null \ 898: | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 899: } 900: 901: # func_lalib_unsafe_p file 902: # True iff FILE is a libtool `.la' library or `.lo' object file. 903: # This function implements the same check as func_lalib_p without 904: # resorting to external programs. To this end, it redirects stdin and 905: # closes it afterwards, without saving the original file descriptor. 906: # As a safety measure, use it only where a negative result would be 907: # fatal anyway. Works if `file' does not exist. 908: func_lalib_unsafe_p () 909: { 910: lalib_p=no 911: if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then 912: for lalib_p_l in 1 2 3 4 913: do 914: read lalib_p_line 915: case "$lalib_p_line" in 916: \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; 917: esac 918: done 919: exec 0<&5 5<&- 920: fi 921: test "$lalib_p" = yes 922: } 923: 924: # func_ltwrapper_script_p file 925: # True iff FILE is a libtool wrapper script 926: # This function is only a basic sanity check; it will hardly flush out 927: # determined imposters. 928: func_ltwrapper_script_p () 929: { 930: func_lalib_p "$1" 931: } 932: 933: # func_ltwrapper_executable_p file 934: # True iff FILE is a libtool wrapper executable 935: # This function is only a basic sanity check; it will hardly flush out 936: # determined imposters. 937: func_ltwrapper_executable_p () 938: { 939: func_ltwrapper_exec_suffix= 940: case $1 in 941: *.exe) ;; 942: *) func_ltwrapper_exec_suffix=.exe ;; 943: esac 944: $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 945: } 946: 947: # func_ltwrapper_scriptname file 948: # Assumes file is an ltwrapper_executable 949: # uses $file to determine the appropriate filename for a 950: # temporary ltwrapper_script. 951: func_ltwrapper_scriptname () 952: { 953: func_ltwrapper_scriptname_result="" 954: if func_ltwrapper_executable_p "$1"; then 955: func_dirname_and_basename "$1" "" "." 956: func_stripname '' '.exe' "$func_basename_result" 957: func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper" 958: fi 959: } 960: 961: # func_ltwrapper_p file 962: # True iff FILE is a libtool wrapper script or wrapper executable 963: # This function is only a basic sanity check; it will hardly flush out 964: # determined imposters. 965: func_ltwrapper_p () 966: { 967: func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" 968: } 969: 970: 971: # func_execute_cmds commands fail_cmd 972: # Execute tilde-delimited COMMANDS. 973: # If FAIL_CMD is given, eval that upon failure. 974: # FAIL_CMD may read-access the current command in variable CMD! 975: func_execute_cmds () 976: { 977: $opt_debug 978: save_ifs=$IFS; IFS='~' 979: for cmd in $1; do 980: IFS=$save_ifs 981: eval cmd=\"$cmd\" 982: func_show_eval "$cmd" "${2-:}" 983: done 984: IFS=$save_ifs 985: } 986: 987: 988: # func_source file 989: # Source FILE, adding directory component if necessary. 990: # Note that it is not necessary on cygwin/mingw to append a dot to 991: # FILE even if both FILE and FILE.exe exist: automatic-append-.exe 992: # behavior happens only for exec(3), not for open(2)! Also, sourcing 993: # `FILE.' does not work on cygwin managed mounts. 994: func_source () 995: { 996: $opt_debug 997: case $1 in 998: */* | *\\*) . "$1" ;; 999: *) . "./$1" ;; 1000: esac 1001: } 1002: 1003: 1004: # func_infer_tag arg 1005: # Infer tagged configuration to use if any are available and 1006: # if one wasn't chosen via the "--tag" command line option. 1007: # Only attempt this if the compiler in the base compile 1008: # command doesn't match the default compiler. 1009: # arg is usually of the form 'gcc ...' 1010: func_infer_tag () 1011: { 1012: $opt_debug 1013: if test -n "$available_tags" && test -z "$tagname"; then 1014: CC_quoted= 1015: for arg in $CC; do 1016: func_quote_for_eval "$arg" 1017: CC_quoted="$CC_quoted $func_quote_for_eval_result" 1018: done 1019: case $@ in 1020: # Blanks in the command may have been stripped by the calling shell, 1021: # but not from the CC environment variable when configure was run. 1022: " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;; 1023: # Blanks at the start of $base_compile will cause this to fail 1024: # if we don't check for them as well. 1025: *) 1026: for z in $available_tags; do 1027: if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then 1028: # Evaluate the configuration. 1029: eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" 1030: CC_quoted= 1031: for arg in $CC; do 1032: # Double-quote args containing other shell metacharacters. 1033: func_quote_for_eval "$arg" 1034: CC_quoted="$CC_quoted $func_quote_for_eval_result" 1035: done 1036: case "$@ " in 1037: " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) 1038: # The compiler in the base compile command matches 1039: # the one in the tagged configuration. 1040: # Assume this is the tagged configuration we want. 1041: tagname=$z 1042: break 1043: ;; 1044: esac 1045: fi 1046: done 1047: # If $tagname still isn't set, then no tagged configuration 1048: # was found and let the user know that the "--tag" command 1049: # line option must be used. 1050: if test -z "$tagname"; then 1051: func_echo "unable to infer tagged configuration" 1052: func_fatal_error "specify a tag with \`--tag'" 1053: # else 1054: # func_verbose "using $tagname tagged configuration" 1055: fi 1056: ;; 1057: esac 1058: fi 1059: } 1060: 1061: 1062: 1063: # func_write_libtool_object output_name pic_name nonpic_name 1064: # Create a libtool object file (analogous to a ".la" file), 1065: # but don't create it if we're doing a dry run. 1066: func_write_libtool_object () 1067: { 1068: write_libobj=${1} 1069: if test "$build_libtool_libs" = yes; then 1070: write_lobj=\'${2}\' 1071: else 1072: write_lobj=none 1073: fi 1074: 1075: if test "$build_old_libs" = yes; then 1076: write_oldobj=\'${3}\' 1077: else 1078: write_oldobj=none 1079: fi 1080: 1081: $opt_dry_run || { 1082: cat >${write_libobj}T <<EOF 1083: # $write_libobj - a libtool object file 1084: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 1085: # 1086: # Please DO NOT delete this file! 1087: # It is necessary for linking the library. 1088: 1089: # Name of the PIC object. 1090: pic_object=$write_lobj 1091: 1092: # Name of the non-PIC object 1093: non_pic_object=$write_oldobj 1094: 1095: EOF 1096: $MV "${write_libobj}T" "${write_libobj}" 1097: } 1098: } 1099: 1100: # func_mode_compile arg... 1101: func_mode_compile () 1102: { 1103: $opt_debug 1104: # Get the compilation command and the source file. 1105: base_compile= 1106: srcfile="$nonopt" # always keep a non-empty value in "srcfile" 1107: suppress_opt=yes 1108: suppress_output= 1109: arg_mode=normal 1110: libobj= 1111: later= 1112: pie_flag= 1113: 1114: for arg 1115: do 1116: case $arg_mode in 1117: arg ) 1118: # do not "continue". Instead, add this to base_compile 1119: lastarg="$arg" 1120: arg_mode=normal 1121: ;; 1122: 1123: target ) 1124: libobj="$arg" 1125: arg_mode=normal 1126: continue 1127: ;; 1128: 1129: normal ) 1130: # Accept any command-line options. 1131: case $arg in 1132: -o) 1133: test -n "$libobj" && \ 1134: func_fatal_error "you cannot specify \`-o' more than once" 1135: arg_mode=target 1136: continue 1137: ;; 1138: 1139: -pie | -fpie | -fPIE) 1140: pie_flag="$pie_flag $arg" 1141: continue 1142: ;; 1143: 1144: -shared | -static | -prefer-pic | -prefer-non-pic) 1145: later="$later $arg" 1146: continue 1147: ;; 1148: 1149: -no-suppress) 1150: suppress_opt=no 1151: continue 1152: ;; 1153: 1154: -Xcompiler) 1155: arg_mode=arg # the next one goes into the "base_compile" arg list 1156: continue # The current "srcfile" will either be retained or 1157: ;; # replaced later. I would guess that would be a bug. 1158: 1159: -Wc,*) 1160: func_stripname '-Wc,' '' "$arg" 1161: args=$func_stripname_result 1162: lastarg= 1163: save_ifs="$IFS"; IFS=',' 1164: for arg in $args; do 1165: IFS="$save_ifs" 1166: func_quote_for_eval "$arg" 1167: lastarg="$lastarg $func_quote_for_eval_result" 1168: done 1169: IFS="$save_ifs" 1170: func_stripname ' ' '' "$lastarg" 1171: lastarg=$func_stripname_result 1172: 1173: # Add the arguments to base_compile. 1174: base_compile="$base_compile $lastarg" 1175: continue 1176: ;; 1177: 1178: *) 1179: # Accept the current argument as the source file. 1180: # The previous "srcfile" becomes the current argument. 1181: # 1182: lastarg="$srcfile" 1183: srcfile="$arg" 1184: ;; 1185: esac # case $arg 1186: ;; 1187: esac # case $arg_mode 1188: 1189: # Aesthetically quote the previous argument. 1190: func_quote_for_eval "$lastarg" 1191: base_compile="$base_compile $func_quote_for_eval_result" 1192: done # for arg 1193: 1194: case $arg_mode in 1195: arg) 1196: func_fatal_error "you must specify an argument for -Xcompile" 1197: ;; 1198: target) 1199: func_fatal_error "you must specify a target with \`-o'" 1200: ;; 1201: *) 1202: # Get the name of the library object. 1203: test -z "$libobj" && { 1204: func_basename "$srcfile" 1205: libobj="$func_basename_result" 1206: } 1207: ;; 1208: esac 1209: 1210: # Recognize several different file suffixes. 1211: # If the user specifies -o file.o, it is replaced with file.lo 1212: case $libobj in 1213: *.[cCFSifmso] | \ 1214: *.ada | *.adb | *.ads | *.asm | \ 1215: *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ 1216: *.[fF][09]? | *.for | *.java | *.obj | *.sx) 1217: func_xform "$libobj" 1218: libobj=$func_xform_result 1219: ;; 1220: esac 1221: 1222: case $libobj in 1223: *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; 1224: *) 1225: func_fatal_error "cannot determine name of library object from \`$libobj'" 1226: ;; 1227: esac 1228: 1229: func_infer_tag $base_compile 1230: 1231: for arg in $later; do 1232: case $arg in 1233: -shared) 1234: test "$build_libtool_libs" != yes && \ 1235: func_fatal_configuration "can not build a shared library" 1236: build_old_libs=no 1237: continue 1238: ;; 1239: 1240: -static) 1241: build_libtool_libs=no 1242: build_old_libs=yes 1243: continue 1244: ;; 1245: 1246: -prefer-pic) 1247: pic_mode=yes 1248: continue 1249: ;; 1250: 1251: -prefer-non-pic) 1252: pic_mode=no 1253: continue 1254: ;; 1255: esac 1256: done 1257: 1258: func_quote_for_eval "$libobj" 1259: test "X$libobj" != "X$func_quote_for_eval_result" \ 1260: && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ 1261: && func_warning "libobj name \`$libobj' may not contain shell special characters." 1262: func_dirname_and_basename "$obj" "/" "" 1263: objname="$func_basename_result" 1264: xdir="$func_dirname_result" 1265: lobj=${xdir}$objdir/$objname 1266: 1267: test -z "$base_compile" && \ 1268: func_fatal_help "you must specify a compilation command" 1269: 1270: # Delete any leftover library objects. 1271: if test "$build_old_libs" = yes; then 1272: removelist="$obj $lobj $libobj ${libobj}T" 1273: else 1274: removelist="$lobj $libobj ${libobj}T" 1275: fi 1276: 1277: # On Cygwin there's no "real" PIC flag so we must build both object types 1278: case $host_os in 1279: cygwin* | mingw* | pw32* | os2* | cegcc*) 1280: pic_mode=default 1281: ;; 1282: esac 1283: if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then 1284: # non-PIC code in shared libraries is not supported 1285: pic_mode=default 1286: fi 1287: 1288: # Calculate the filename of the output object if compiler does 1289: # not support -o with -c 1290: if test "$compiler_c_o" = no; then 1291: output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext} 1292: lockfile="$output_obj.lock" 1293: else 1294: output_obj= 1295: need_locks=no 1296: lockfile= 1297: fi 1298: 1299: # Lock this critical section if it is needed 1300: # We use this script file to make the link, it avoids creating a new file 1301: if test "$need_locks" = yes; then 1302: until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do 1303: func_echo "Waiting for $lockfile to be removed" 1304: sleep 2 1305: done 1306: elif test "$need_locks" = warn; then 1307: if test -f "$lockfile"; then 1308: $ECHO "\ 1309: *** ERROR, $lockfile exists and contains: 1310: `cat $lockfile 2>/dev/null` 1311: 1312: This indicates that another process is trying to use the same 1313: temporary object file, and libtool could not work around it because 1314: your compiler does not support \`-c' and \`-o' together. If you 1315: repeat this compilation, it may succeed, by chance, but you had better 1316: avoid parallel builds (make -j) in this platform, or get a better 1317: compiler." 1318: 1319: $opt_dry_run || $RM $removelist 1320: exit $EXIT_FAILURE 1321: fi 1322: removelist="$removelist $output_obj" 1323: $ECHO "$srcfile" > "$lockfile" 1324: fi 1325: 1326: $opt_dry_run || $RM $removelist 1327: removelist="$removelist $lockfile" 1328: trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 1329: 1330: if test -n "$fix_srcfile_path"; then 1331: eval srcfile=\"$fix_srcfile_path\" 1332: fi 1333: func_quote_for_eval "$srcfile" 1334: qsrcfile=$func_quote_for_eval_result 1335: 1336: # Only build a PIC object if we are building libtool libraries. 1337: if test "$build_libtool_libs" = yes; then 1338: # Without this assignment, base_compile gets emptied. 1339: fbsd_hideous_sh_bug=$base_compile 1340: 1341: if test "$pic_mode" != no; then 1342: command="$base_compile $qsrcfile $pic_flag" 1343: else 1344: # Don't build PIC code 1345: command="$base_compile $qsrcfile" 1346: fi 1347: 1348: func_mkdir_p "$xdir$objdir" 1349: 1350: if test -z "$output_obj"; then 1351: # Place PIC objects in $objdir 1352: command="$command -o $lobj" 1353: fi 1354: 1355: func_show_eval_locale "$command" \ 1356: 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' 1357: 1358: if test "$need_locks" = warn && 1359: test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then 1360: $ECHO "\ 1361: *** ERROR, $lockfile contains: 1362: `cat $lockfile 2>/dev/null` 1363: 1364: but it should contain: 1365: $srcfile 1366: 1367: This indicates that another process is trying to use the same 1368: temporary object file, and libtool could not work around it because 1369: your compiler does not support \`-c' and \`-o' together. If you 1370: repeat this compilation, it may succeed, by chance, but you had better 1371: avoid parallel builds (make -j) in this platform, or get a better 1372: compiler." 1373: 1374: $opt_dry_run || $RM $removelist 1375: exit $EXIT_FAILURE 1376: fi 1377: 1378: # Just move the object if needed, then go on to compile the next one 1379: if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then 1380: func_show_eval '$MV "$output_obj" "$lobj"' \ 1381: 'error=$?; $opt_dry_run || $RM $removelist; exit $error' 1382: fi 1383: 1384: # Allow error messages only from the first compilation. 1385: if test "$suppress_opt" = yes; then 1386: suppress_output=' >/dev/null 2>&1' 1387: fi 1388: fi 1389: 1390: # Only build a position-dependent object if we build old libraries. 1391: if test "$build_old_libs" = yes; then 1392: if test "$pic_mode" != yes; then 1393: # Don't build PIC code 1394: command="$base_compile $qsrcfile$pie_flag" 1395: else 1396: command="$base_compile $qsrcfile $pic_flag" 1397: fi 1398: if test "$compiler_c_o" = yes; then 1399: command="$command -o $obj" 1400: fi 1401: 1402: # Suppress compiler output if we already did a PIC compilation. 1403: command="$command$suppress_output" 1404: func_show_eval_locale "$command" \ 1405: '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1406: 1407: if test "$need_locks" = warn && 1408: test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then 1409: $ECHO "\ 1410: *** ERROR, $lockfile contains: 1411: `cat $lockfile 2>/dev/null` 1412: 1413: but it should contain: 1414: $srcfile 1415: 1416: This indicates that another process is trying to use the same 1417: temporary object file, and libtool could not work around it because 1418: your compiler does not support \`-c' and \`-o' together. If you 1419: repeat this compilation, it may succeed, by chance, but you had better 1420: avoid parallel builds (make -j) in this platform, or get a better 1421: compiler." 1422: 1423: $opt_dry_run || $RM $removelist 1424: exit $EXIT_FAILURE 1425: fi 1426: 1427: # Just move the object if needed 1428: if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then 1429: func_show_eval '$MV "$output_obj" "$obj"' \ 1430: 'error=$?; $opt_dry_run || $RM $removelist; exit $error' 1431: fi 1432: fi 1433: 1434: $opt_dry_run || { 1435: func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" 1436: 1437: # Unlock the critical section if it was locked 1438: if test "$need_locks" != no; then 1439: removelist=$lockfile 1440: $RM "$lockfile" 1441: fi 1442: } 1443: 1444: exit $EXIT_SUCCESS 1445: } 1446: 1447: $opt_help || { 1448: test "$mode" = compile && func_mode_compile ${1+"$@"} 1449: } 1450: 1451: func_mode_help () 1452: { 1453: # We need to display help for each of the modes. 1454: case $mode in 1455: "") 1456: # Generic help is extracted from the usage comments 1457: # at the start of this file. 1458: func_help 1459: ;; 1460: 1461: clean) 1462: $ECHO \ 1463: "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... 1464: 1465: Remove files from the build directory. 1466: 1467: RM is the name of the program to use to delete files associated with each FILE 1468: (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed 1469: to RM. 1470: 1471: If FILE is a libtool library, object or program, all the files associated 1472: with it are deleted. Otherwise, only FILE itself is deleted using RM." 1473: ;; 1474: 1475: compile) 1476: $ECHO \ 1477: "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE 1478: 1479: Compile a source file into a libtool library object. 1480: 1481: This mode accepts the following additional options: 1482: 1483: -o OUTPUT-FILE set the output file name to OUTPUT-FILE 1484: -no-suppress do not suppress compiler output for multiple passes 1485: -prefer-pic try to building PIC objects only 1486: -prefer-non-pic try to building non-PIC objects only 1487: -shared do not build a \`.o' file suitable for static linking 1488: -static only build a \`.o' file suitable for static linking 1489: 1490: COMPILE-COMMAND is a command to be used in creating a \`standard' object file 1491: from the given SOURCEFILE. 1492: 1493: The output file name is determined by removing the directory component from 1494: SOURCEFILE, then substituting the C source code suffix \`.c' with the 1495: library object suffix, \`.lo'." 1496: ;; 1497: 1498: execute) 1499: $ECHO \ 1500: "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... 1501: 1502: Automatically set library path, then run a program. 1503: 1504: This mode accepts the following additional options: 1505: 1506: -dlopen FILE add the directory containing FILE to the library path 1507: 1508: This mode sets the library path environment variable according to \`-dlopen' 1509: flags. 1510: 1511: If any of the ARGS are libtool executable wrappers, then they are translated 1512: into their corresponding uninstalled binary, and any of their required library 1513: directories are added to the library path. 1514: 1515: Then, COMMAND is executed, with ARGS as arguments." 1516: ;; 1517: 1518: finish) 1519: $ECHO \ 1520: "Usage: $progname [OPTION]... --mode=finish [LIBDIR]... 1521: 1522: Complete the installation of libtool libraries. 1523: 1524: Each LIBDIR is a directory that contains libtool libraries. 1525: 1526: The commands that this mode executes may require superuser privileges. Use 1527: the \`--dry-run' option if you just want to see what would be executed." 1528: ;; 1529: 1530: install) 1531: $ECHO \ 1532: "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... 1533: 1534: Install executables or libraries. 1535: 1536: INSTALL-COMMAND is the installation command. The first component should be 1537: either the \`install' or \`cp' program. 1538: 1539: The following components of INSTALL-COMMAND are treated specially: 1540: 1541: -inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation 1542: 1543: The rest of the components are interpreted as arguments to that command (only 1544: BSD-compatible install options are recognized)." 1545: ;; 1546: 1547: link) 1548: $ECHO \ 1549: "Usage: $progname [OPTION]... --mode=link LINK-COMMAND... 1550: 1551: Link object files or libraries together to form another library, or to 1552: create an executable program. 1553: 1554: LINK-COMMAND is a command using the C compiler that you would use to create 1555: a program from several object files. 1556: 1557: The following components of LINK-COMMAND are treated specially: 1558: 1559: -all-static do not do any dynamic linking at all 1560: -avoid-version do not add a version suffix if possible 1561: -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime 1562: -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols 1563: -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) 1564: -export-symbols SYMFILE 1565: try to export only the symbols listed in SYMFILE 1566: -export-symbols-regex REGEX 1567: try to export only the symbols matching REGEX 1568: -LLIBDIR search LIBDIR for required installed libraries 1569: -lNAME OUTPUT-FILE requires the installed library libNAME 1570: -module build a library that can dlopened 1571: -no-fast-install disable the fast-install mode 1572: -no-install link a not-installable executable 1573: -no-undefined declare that a library does not refer to external symbols 1574: -o OUTPUT-FILE create OUTPUT-FILE from the specified objects 1575: -objectlist FILE Use a list of object files found in FILE to specify objects 1576: -precious-files-regex REGEX 1577: don't remove output files matching REGEX 1578: -release RELEASE specify package release information 1579: -rpath LIBDIR the created library will eventually be installed in LIBDIR 1580: -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries 1581: -shared only do dynamic linking of libtool libraries 1582: -shrext SUFFIX override the standard shared library file extension 1583: -static do not do any dynamic linking of uninstalled libtool libraries 1584: -static-libtool-libs 1585: do not do any dynamic linking of libtool libraries 1586: -version-info CURRENT[:REVISION[:AGE]] 1587: specify library version info [each variable defaults to 0] 1588: -weak LIBNAME declare that the target provides the LIBNAME interface 1589: 1590: All other options (arguments beginning with \`-') are ignored. 1591: 1592: Every other argument is treated as a filename. Files ending in \`.la' are 1593: treated as uninstalled libtool libraries, other files are standard or library 1594: object files. 1595: 1596: If the OUTPUT-FILE ends in \`.la', then a libtool library is created, 1597: only library objects (\`.lo' files) may be specified, and \`-rpath' is 1598: required, except when creating a convenience library. 1599: 1600: If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created 1601: using \`ar' and \`ranlib', or on Windows using \`lib'. 1602: 1603: If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file 1604: is created, otherwise an executable program is created." 1605: ;; 1606: 1607: uninstall) 1608: $ECHO \ 1609: "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... 1610: 1611: Remove libraries from an installation directory. 1612: 1613: RM is the name of the program to use to delete files associated with each FILE 1614: (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed 1615: to RM. 1616: 1617: If FILE is a libtool library, all the files associated with it are deleted. 1618: Otherwise, only FILE itself is deleted using RM." 1619: ;; 1620: 1621: *) 1622: func_fatal_help "invalid operation mode \`$mode'" 1623: ;; 1624: esac 1625: 1626: $ECHO 1627: $ECHO "Try \`$progname --help' for more information about other modes." 1628: 1629: exit $? 1630: } 1631: 1632: # Now that we've collected a possible --mode arg, show help if necessary 1633: $opt_help && func_mode_help 1634: 1635: 1636: # func_mode_execute arg... 1637: func_mode_execute () 1638: { 1639: $opt_debug 1640: # The first argument is the command name. 1641: cmd="$nonopt" 1642: test -z "$cmd" && \ 1643: func_fatal_help "you must specify a COMMAND" 1644: 1645: # Handle -dlopen flags immediately. 1646: for file in $execute_dlfiles; do 1647: test -f "$file" \ 1648: || func_fatal_help "\`$file' is not a file" 1649: 1650: dir= 1651: case $file in 1652: *.la) 1653: # Check to see that this really is a libtool archive. 1654: func_lalib_unsafe_p "$file" \ 1655: || func_fatal_help "\`$lib' is not a valid libtool archive" 1656: 1657: # Read the libtool library. 1658: dlname= 1659: library_names= 1660: func_source "$file" 1661: 1662: # Skip this library if it cannot be dlopened. 1663: if test -z "$dlname"; then 1664: # Warn if it was a shared library. 1665: test -n "$library_names" && \ 1666: func_warning "\`$file' was not linked with \`-export-dynamic'" 1667: continue 1668: fi 1669: 1670: func_dirname "$file" "" "." 1671: dir="$func_dirname_result" 1672: 1673: if test -f "$dir/$objdir/$dlname"; then 1674: dir="$dir/$objdir" 1675: else 1676: if test ! -f "$dir/$dlname"; then 1677: func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1678: fi 1679: fi 1680: ;; 1681: 1682: *.lo) 1683: # Just add the directory containing the .lo file. 1684: func_dirname "$file" "" "." 1685: dir="$func_dirname_result" 1686: ;; 1687: 1688: *) 1689: func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" 1690: continue 1691: ;; 1692: esac 1693: 1694: # Get the absolute pathname. 1695: absdir=`cd "$dir" && pwd` 1696: test -n "$absdir" && dir="$absdir" 1697: 1698: # Now add the directory to shlibpath_var. 1699: if eval "test -z \"\$$shlibpath_var\""; then 1700: eval "$shlibpath_var=\"\$dir\"" 1701: else 1702: eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" 1703: fi 1704: done 1705: 1706: # This variable tells wrapper scripts just to set shlibpath_var 1707: # rather than running their programs. 1708: libtool_execute_magic="$magic" 1709: 1710: # Check if any of the arguments is a wrapper script. 1711: args= 1712: for file 1713: do 1714: case $file in 1715: -*) ;; 1716: *) 1717: # Do a test to see if this is really a libtool program. 1718: if func_ltwrapper_script_p "$file"; then 1719: func_source "$file" 1720: # Transform arg to wrapped name. 1721: file="$progdir/$program" 1722: elif func_ltwrapper_executable_p "$file"; then 1723: func_ltwrapper_scriptname "$file" 1724: func_source "$func_ltwrapper_scriptname_result" 1725: # Transform arg to wrapped name. 1726: file="$progdir/$program" 1727: fi 1728: ;; 1729: esac 1730: # Quote arguments (to preserve shell metacharacters). 1731: func_quote_for_eval "$file" 1732: args="$args $func_quote_for_eval_result" 1733: done 1734: 1735: if test "X$opt_dry_run" = Xfalse; then 1736: if test -n "$shlibpath_var"; then 1737: # Export the shlibpath_var. 1738: eval "export $shlibpath_var" 1739: fi 1740: 1741: # Restore saved environment variables 1742: for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES 1743: do 1744: eval "if test \"\${save_$lt_var+set}\" = set; then 1745: $lt_var=\$save_$lt_var; export $lt_var 1746: else 1747: $lt_unset $lt_var 1748: fi" 1749: done 1750: 1751: # Now prepare to actually exec the command. 1752: exec_cmd="\$cmd$args" 1753: else 1754: # Display what would be done. 1755: if test -n "$shlibpath_var"; then 1756: eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" 1757: $ECHO "export $shlibpath_var" 1758: fi 1759: $ECHO "$cmd$args" 1760: exit $EXIT_SUCCESS 1761: fi 1762: } 1763: 1764: test "$mode" = execute && func_mode_execute ${1+"$@"} 1765: 1766: 1767: # func_mode_finish arg... 1768: func_mode_finish () 1769: { 1770: $opt_debug 1771: libdirs="$nonopt" 1772: admincmds= 1773: 1774: if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then 1775: for dir 1776: do 1777: libdirs="$libdirs $dir" 1778: done 1779: 1780: for libdir in $libdirs; do 1781: if test -n "$finish_cmds"; then 1782: # Do each command in the finish commands. 1783: func_execute_cmds "$finish_cmds" 'admincmds="$admincmds 1784: '"$cmd"'"' 1785: fi 1786: if test -n "$finish_eval"; then 1787: # Do the single finish_eval. 1788: eval cmds=\"$finish_eval\" 1789: $opt_dry_run || eval "$cmds" || admincmds="$admincmds 1790: $cmds" 1791: fi 1792: done 1793: fi 1794: 1795: # Exit here if they wanted silent mode. 1796: $opt_silent && exit $EXIT_SUCCESS 1797: 1798: $ECHO "X----------------------------------------------------------------------" | $Xsed 1799: $ECHO "Libraries have been installed in:" 1800: for libdir in $libdirs; do 1801: $ECHO " $libdir" 1802: done 1803: $ECHO 1804: $ECHO "If you ever happen to want to link against installed libraries" 1805: $ECHO "in a given directory, LIBDIR, you must either use libtool, and" 1806: $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'" 1807: $ECHO "flag during linking and do at least one of the following:" 1808: if test -n "$shlibpath_var"; then 1809: $ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable" 1810: $ECHO " during execution" 1811: fi 1812: if test -n "$runpath_var"; then 1813: $ECHO " - add LIBDIR to the \`$runpath_var' environment variable" 1814: $ECHO " during linking" 1815: fi 1816: if test -n "$hardcode_libdir_flag_spec"; then 1817: libdir=LIBDIR 1818: eval flag=\"$hardcode_libdir_flag_spec\" 1819: 1820: $ECHO " - use the \`$flag' linker flag" 1821: fi 1822: if test -n "$admincmds"; then 1823: $ECHO " - have your system administrator run these commands:$admincmds" 1824: fi 1825: if test -f /etc/ld.so.conf; then 1826: $ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" 1827: fi 1828: $ECHO 1829: 1830: $ECHO "See any operating system documentation about shared libraries for" 1831: case $host in 1832: solaris2.[6789]|solaris2.1[0-9]) 1833: $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual" 1834: $ECHO "pages." 1835: ;; 1836: *) 1837: $ECHO "more information, such as the ld(1) and ld.so(8) manual pages." 1838: ;; 1839: esac 1840: $ECHO "X----------------------------------------------------------------------" | $Xsed 1841: exit $EXIT_SUCCESS 1842: } 1843: 1844: test "$mode" = finish && func_mode_finish ${1+"$@"} 1845: 1846: 1847: # func_mode_install arg... 1848: func_mode_install () 1849: { 1850: $opt_debug 1851: # There may be an optional sh(1) argument at the beginning of 1852: # install_prog (especially on Windows NT). 1853: if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || 1854: # Allow the use of GNU shtool's install command. 1855: $ECHO "X$nonopt" | $GREP shtool >/dev/null; then 1856: # Aesthetically quote it. 1857: func_quote_for_eval "$nonopt" 1858: install_prog="$func_quote_for_eval_result " 1859: arg=$1 1860: shift 1861: else 1862: install_prog= 1863: arg=$nonopt 1864: fi 1865: 1866: # The real first argument should be the name of the installation program. 1867: # Aesthetically quote it. 1868: func_quote_for_eval "$arg" 1869: install_prog="$install_prog$func_quote_for_eval_result" 1870: 1871: # We need to accept at least all the BSD install flags. 1872: dest= 1873: files= 1874: opts= 1875: prev= 1876: install_type= 1877: isdir=no 1878: stripme= 1879: for arg 1880: do 1881: if test -n "$dest"; then 1882: files="$files $dest" 1883: dest=$arg 1884: continue 1885: fi 1886: 1887: case $arg in 1888: -d) isdir=yes ;; 1889: -f) 1890: case " $install_prog " in 1891: *[\\\ /]cp\ *) ;; 1892: *) prev=$arg ;; 1893: esac 1894: ;; 1895: -g | -m | -o) 1896: prev=$arg 1897: ;; 1898: -s) 1899: stripme=" -s" 1900: continue 1901: ;; 1902: -*) 1903: ;; 1904: *) 1905: # If the previous option needed an argument, then skip it. 1906: if test -n "$prev"; then 1907: prev= 1908: else 1909: dest=$arg 1910: continue 1911: fi 1912: ;; 1913: esac 1914: 1915: # Aesthetically quote the argument. 1916: func_quote_for_eval "$arg" 1917: install_prog="$install_prog $func_quote_for_eval_result" 1918: done 1919: 1920: test -z "$install_prog" && \ 1921: func_fatal_help "you must specify an install program" 1922: 1923: test -n "$prev" && \ 1924: func_fatal_help "the \`$prev' option requires an argument" 1925: 1926: if test -z "$files"; then 1927: if test -z "$dest"; then 1928: func_fatal_help "no file or destination specified" 1929: else 1930: func_fatal_help "you must specify a destination" 1931: fi 1932: fi 1933: 1934: # Strip any trailing slash from the destination. 1935: func_stripname '' '/' "$dest" 1936: dest=$func_stripname_result 1937: 1938: # Check to see that the destination is a directory. 1939: test -d "$dest" && isdir=yes 1940: if test "$isdir" = yes; then 1941: destdir="$dest" 1942: destname= 1943: else 1944: func_dirname_and_basename "$dest" "" "." 1945: destdir="$func_dirname_result" 1946: destname="$func_basename_result" 1947: 1948: # Not a directory, so check to see that there is only one file specified. 1949: set dummy $files; shift 1950: test "$#" -gt 1 && \ 1951: func_fatal_help "\`$dest' is not a directory" 1952: fi 1953: case $destdir in 1954: [\\/]* | [A-Za-z]:[\\/]*) ;; 1955: *) 1956: for file in $files; do 1957: case $file in 1958: *.lo) ;; 1959: *) 1960: func_fatal_help "\`$destdir' must be an absolute directory name" 1961: ;; 1962: esac 1963: done 1964: ;; 1965: esac 1966: 1967: # This variable tells wrapper scripts just to set variables rather 1968: # than running their programs. 1969: libtool_install_magic="$magic" 1970: 1971: staticlibs= 1972: future_libdirs= 1973: current_libdirs= 1974: for file in $files; do 1975: 1976: # Do each installation. 1977: case $file in 1978: *.$libext) 1979: # Do the static libraries later. 1980: staticlibs="$staticlibs $file" 1981: ;; 1982: 1983: *.la) 1984: # Check to see that this really is a libtool archive. 1985: func_lalib_unsafe_p "$file" \ 1986: || func_fatal_help "\`$file' is not a valid libtool archive" 1987: 1988: library_names= 1989: old_library= 1990: relink_command= 1991: func_source "$file" 1992: 1993: # Add the libdir to current_libdirs if it is the destination. 1994: if test "X$destdir" = "X$libdir"; then 1995: case "$current_libdirs " in 1996: *" $libdir "*) ;; 1997: *) current_libdirs="$current_libdirs $libdir" ;; 1998: esac 1999: else 2000: # Note the libdir as a future libdir. 2001: case "$future_libdirs " in 2002: *" $libdir "*) ;; 2003: *) future_libdirs="$future_libdirs $libdir" ;; 2004: esac 2005: fi 2006: 2007: func_dirname "$file" "/" "" 2008: dir="$func_dirname_result" 2009: dir="$dir$objdir" 2010: 2011: if test -n "$relink_command"; then 2012: # Determine the prefix the user has applied to our future dir. 2013: inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"` 2014: 2015: # Don't allow the user to place us outside of our expected 2016: # location b/c this prevents finding dependent libraries that 2017: # are installed to the same prefix. 2018: # At present, this check doesn't affect windows .dll's that 2019: # are installed into $libdir/../bin (currently, that works fine) 2020: # but it's something to keep an eye on. 2021: test "$inst_prefix_dir" = "$destdir" && \ 2022: func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" 2023: 2024: if test -n "$inst_prefix_dir"; then 2025: # Stick the inst_prefix_dir data into the link command. 2026: relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` 2027: else 2028: relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"` 2029: fi 2030: 2031: func_warning "relinking \`$file'" 2032: func_show_eval "$relink_command" \ 2033: 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' 2034: fi 2035: 2036: # See the names of the shared library. 2037: set dummy $library_names; shift 2038: if test -n "$1"; then 2039: realname="$1" 2040: shift 2041: 2042: srcname="$realname" 2043: test -n "$relink_command" && srcname="$realname"T 2044: 2045: # Install the shared library and build the symlinks. 2046: func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \ 2047: 'exit $?' 2048: tstripme="$stripme" 2049: case $host_os in 2050: cygwin* | mingw* | pw32* | cegcc*) 2051: case $realname in 2052: *.dll.a) 2053: tstripme="" 2054: ;; 2055: esac 2056: ;; 2057: esac 2058: if test -n "$tstripme" && test -n "$striplib"; then 2059: func_show_eval "$striplib $destdir/$realname" 'exit $?' 2060: fi 2061: 2062: if test "$#" -gt 0; then 2063: # Delete the old symlinks, and create new ones. 2064: # Try `ln -sf' first, because the `ln' binary might depend on 2065: # the symlink we replace! Solaris /bin/ln does not understand -f, 2066: # so we also need to try rm && ln -s. 2067: for linkname 2068: do 2069: test "$linkname" != "$realname" \ 2070: && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" 2071: done 2072: fi 2073: 2074: # Do each command in the postinstall commands. 2075: lib="$destdir/$realname" 2076: func_execute_cmds "$postinstall_cmds" 'exit $?' 2077: fi 2078: 2079: # Install the pseudo-library for information purposes. 2080: func_basename "$file" 2081: name="$func_basename_result" 2082: instname="$dir/$name"i 2083: func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' 2084: 2085: # Maybe install the static library, too. 2086: test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library" 2087: ;; 2088: 2089: *.lo) 2090: # Install (i.e. copy) a libtool object. 2091: 2092: # Figure out destination file name, if it wasn't already specified. 2093: if test -n "$destname"; then 2094: destfile="$destdir/$destname" 2095: else 2096: func_basename "$file" 2097: destfile="$func_basename_result" 2098: destfile="$destdir/$destfile" 2099: fi 2100: 2101: # Deduce the name of the destination old-style object file. 2102: case $destfile in 2103: *.lo) 2104: func_lo2o "$destfile" 2105: staticdest=$func_lo2o_result 2106: ;; 2107: *.$objext) 2108: staticdest="$destfile" 2109: destfile= 2110: ;; 2111: *) 2112: func_fatal_help "cannot copy a libtool object to \`$destfile'" 2113: ;; 2114: esac 2115: 2116: # Install the libtool object if requested. 2117: test -n "$destfile" && \ 2118: func_show_eval "$install_prog $file $destfile" 'exit $?' 2119: 2120: # Install the old object if enabled. 2121: if test "$build_old_libs" = yes; then 2122: # Deduce the name of the old-style object file. 2123: func_lo2o "$file" 2124: staticobj=$func_lo2o_result 2125: func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' 2126: fi 2127: exit $EXIT_SUCCESS 2128: ;; 2129: 2130: *) 2131: # Figure out destination file name, if it wasn't already specified. 2132: if test -n "$destname"; then 2133: destfile="$destdir/$destname" 2134: else 2135: func_basename "$file" 2136: destfile="$func_basename_result" 2137: destfile="$destdir/$destfile" 2138: fi 2139: 2140: # If the file is missing, and there is a .exe on the end, strip it 2141: # because it is most likely a libtool script we actually want to 2142: # install 2143: stripped_ext="" 2144: case $file in 2145: *.exe) 2146: if test ! -f "$file"; then 2147: func_stripname '' '.exe' "$file" 2148: file=$func_stripname_result 2149: stripped_ext=".exe" 2150: fi 2151: ;; 2152: esac 2153: 2154: # Do a test to see if this is really a libtool program. 2155: case $host in 2156: *cygwin* | *mingw*) 2157: if func_ltwrapper_executable_p "$file"; then 2158: func_ltwrapper_scriptname "$file" 2159: wrapper=$func_ltwrapper_scriptname_result 2160: else 2161: func_stripname '' '.exe' "$file" 2162: wrapper=$func_stripname_result 2163: fi 2164: ;; 2165: *) 2166: wrapper=$file 2167: ;; 2168: esac 2169: if func_ltwrapper_script_p "$wrapper"; then 2170: notinst_deplibs= 2171: relink_command= 2172: 2173: func_source "$wrapper" 2174: 2175: # Check the variables that should have been set. 2176: test -z "$generated_by_libtool_version" && \ 2177: func_fatal_error "invalid libtool wrapper script \`$wrapper'" 2178: 2179: finalize=yes 2180: for lib in $notinst_deplibs; do 2181: # Check to see that each library is installed. 2182: libdir= 2183: if test -f "$lib"; then 2184: func_source "$lib" 2185: fi 2186: libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test 2187: if test -n "$libdir" && test ! -f "$libfile"; then 2188: func_warning "\`$lib' has not been installed in \`$libdir'" 2189: finalize=no 2190: fi 2191: done 2192: 2193: relink_command= 2194: func_source "$wrapper" 2195: 2196: outputname= 2197: if test "$fast_install" = no && test -n "$relink_command"; then 2198: $opt_dry_run || { 2199: if test "$finalize" = yes; then 2200: tmpdir=`func_mktempdir` 2201: func_basename "$file$stripped_ext" 2202: file="$func_basename_result" 2203: outputname="$tmpdir/$file" 2204: # Replace the output file specification. 2205: relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'` 2206: 2207: $opt_silent || { 2208: func_quote_for_expand "$relink_command" 2209: eval "func_echo $func_quote_for_expand_result" 2210: } 2211: if eval "$relink_command"; then : 2212: else 2213: func_error "error: relink \`$file' with the above command before installing it" 2214: $opt_dry_run || ${RM}r "$tmpdir" 2215: continue 2216: fi 2217: file="$outputname" 2218: else 2219: func_warning "cannot relink \`$file'" 2220: fi 2221: } 2222: else 2223: # Install the binary that we compiled earlier. 2224: file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%$[^/]*$$%$objdir/\1%"` 2225: fi 2226: fi 2227: 2228: # remove .exe since cygwin /usr/bin/install will append another 2229: # one anyway 2230: case $install_prog,$host in 2231: */usr/bin/install*,*cygwin*) 2232: case $file:$destfile in 2233: *.exe:*.exe) 2234: # this is ok 2235: ;; 2236: *.exe:*) 2237: destfile=$destfile.exe 2238: ;; 2239: *:*.exe) 2240: func_stripname '' '.exe' "$destfile" 2241: destfile=$func_stripname_result 2242: ;; 2243: esac 2244: ;; 2245: esac 2246: func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' 2247: $opt_dry_run || if test -n "$outputname"; then 2248: ${RM}r "$tmpdir" 2249: fi 2250: ;; 2251: esac 2252: done 2253: 2254: for file in $staticlibs; do 2255: func_basename "$file" 2256: name="$func_basename_result" 2257: 2258: # Set up the ranlib parameters. 2259: oldlib="$destdir/$name" 2260: 2261: func_show_eval "$install_prog \$file \$oldlib" 'exit $?' 2262: 2263: if test -n "$stripme" && test -n "$old_striplib"; then 2264: func_show_eval "$old_striplib $oldlib" 'exit $?' 2265: fi 2266: 2267: # Do each command in the postinstall commands. 2268: func_execute_cmds "$old_postinstall_cmds" 'exit $?' 2269: done 2270: 2271: test -n "$future_libdirs" && \ 2272: func_warning "remember to run \`$progname --finish$future_libdirs'" 2273: 2274: if test -n "$current_libdirs"; then 2275: # Maybe just do a dry run. 2276: $opt_dry_run && current_libdirs=" -n$current_libdirs" 2277: exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' 2278: else 2279: exit $EXIT_SUCCESS 2280: fi 2281: } 2282: 2283: test "$mode" = install && func_mode_install ${1+"$@"} 2284: 2285: 2286: # func_generate_dlsyms outputname originator pic_p 2287: # Extract symbols from dlprefiles and create ${outputname}S.o with 2288: # a dlpreopen symbol table. 2289: func_generate_dlsyms () 2290: { 2291: $opt_debug 2292: my_outputname="$1" 2293: my_originator="$2" 2294: my_pic_p="${3-no}" 2295: my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` 2296: my_dlsyms= 2297: 2298: if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 2299: if test -n "$NM" && test -n "$global_symbol_pipe"; then 2300: my_dlsyms="${my_outputname}S.c" 2301: else 2302: func_error "not configured to extract global symbols from dlpreopened files" 2303: fi 2304: fi 2305: 2306: if test -n "$my_dlsyms"; then 2307: case $my_dlsyms in 2308: "") ;; 2309: *.c) 2310: # Discover the nlist of each of the dlfiles. 2311: nlist="$output_objdir/${my_outputname}.nm" 2312: 2313: func_show_eval "$RM $nlist ${nlist}S ${nlist}T" 2314: 2315: # Parse the name list into a source file. 2316: func_verbose "creating $output_objdir/$my_dlsyms" 2317: 2318: $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ 2319: /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ 2320: /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ 2321: 2322: #ifdef __cplusplus 2323: extern \"C\" { 2324: #endif 2325: 2326: /* External symbol declarations for the compiler. */\ 2327: " 2328: 2329: if test "$dlself" = yes; then 2330: func_verbose "generating symbol list for \`$output'" 2331: 2332: $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" 2333: 2334: # Add our own program objects to the symbol list. 2335: progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 2336: for progfile in $progfiles; do 2337: func_verbose "extracting global C symbols from \`$progfile'" 2338: $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'" 2339: done 2340: 2341: if test -n "$exclude_expsyms"; then 2342: $opt_dry_run || { 2343: eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' 2344: eval '$MV "$nlist"T "$nlist"' 2345: } 2346: fi 2347: 2348: if test -n "$export_symbols_regex"; then 2349: $opt_dry_run || { 2350: eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' 2351: eval '$MV "$nlist"T "$nlist"' 2352: } 2353: fi 2354: 2355: # Prepare the list of exported symbols 2356: if test -z "$export_symbols"; then 2357: export_symbols="$output_objdir/$outputname.exp" 2358: $opt_dry_run || { 2359: $RM $export_symbols 2360: eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"' 2361: case $host in 2362: *cygwin* | *mingw* | *cegcc* ) 2363: eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' 2364: eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' 2365: ;; 2366: esac 2367: } 2368: else 2369: $opt_dry_run || { 2370: eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' 2371: eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' 2372: eval '$MV "$nlist"T "$nlist"' 2373: case $host in 2374: *cygwin | *mingw* | *cegcc* ) 2375: eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' 2376: eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' 2377: ;; 2378: esac 2379: } 2380: fi 2381: fi 2382: 2383: for dlprefile in $dlprefiles; do 2384: func_verbose "extracting global C symbols from \`$dlprefile'" 2385: func_basename "$dlprefile" 2386: name="$func_basename_result" 2387: $opt_dry_run || { 2388: eval '$ECHO ": $name " >> "$nlist"' 2389: eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'" 2390: } 2391: done 2392: 2393: $opt_dry_run || { 2394: # Make sure we have at least an empty file. 2395: test -f "$nlist" || : > "$nlist" 2396: 2397: if test -n "$exclude_expsyms"; then 2398: $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T 2399: $MV "$nlist"T "$nlist" 2400: fi 2401: 2402: # Try sorting and uniquifying the output. 2403: if $GREP -v "^: " < "$nlist" | 2404: if sort -k 3 </dev/null >/dev/null 2>&1; then 2405: sort -k 3 2406: else 2407: sort +2 2408: fi | 2409: uniq > "$nlist"S; then 2410: : 2411: else 2412: $GREP -v "^: " < "$nlist" > "$nlist"S 2413: fi 2414: 2415: if test -f "$nlist"S; then 2416: eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' 2417: else 2418: $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms" 2419: fi 2420: 2421: $ECHO >> "$output_objdir/$my_dlsyms" "\ 2422: 2423: /* The mapping between symbol names and symbols. */ 2424: typedef struct { 2425: const char *name; 2426: void *address; 2427: } lt_dlsymlist; 2428: " 2429: case $host in 2430: *cygwin* | *mingw* | *cegcc* ) 2431: $ECHO >> "$output_objdir/$my_dlsyms" "\ 2432: /* DATA imports from DLLs on WIN32 con't be const, because 2433: runtime relocations are performed -- see ld's documentation 2434: on pseudo-relocs. */" 2435: lt_dlsym_const= ;; 2436: *osf5*) 2437: echo >> "$output_objdir/$my_dlsyms" "\ 2438: /* This system does not cope well with relocations in const data */" 2439: lt_dlsym_const= ;; 2440: *) 2441: lt_dlsym_const=const ;; 2442: esac 2443: 2444: $ECHO >> "$output_objdir/$my_dlsyms" "\ 2445: extern $lt_dlsym_const lt_dlsymlist 2446: lt_${my_prefix}_LTX_preloaded_symbols[]; 2447: $lt_dlsym_const lt_dlsymlist 2448: lt_${my_prefix}_LTX_preloaded_symbols[] = 2449: {\ 2450: { \"$my_originator\", (void *) 0 }," 2451: 2452: case $need_lib_prefix in 2453: no) 2454: eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" 2455: ;; 2456: *) 2457: eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" 2458: ;; 2459: esac 2460: $ECHO >> "$output_objdir/$my_dlsyms" "\ 2461: {0, (void *) 0} 2462: }; 2463: 2464: /* This works around a problem in FreeBSD linker */ 2465: #ifdef FREEBSD_WORKAROUND 2466: static const void *lt_preloaded_setup() { 2467: return lt_${my_prefix}_LTX_preloaded_symbols; 2468: } 2469: #endif 2470: 2471: #ifdef __cplusplus 2472: } 2473: #endif\ 2474: " 2475: } # !$opt_dry_run 2476: 2477: pic_flag_for_symtable= 2478: case "$compile_command " in 2479: *" -static "*) ;; 2480: *) 2481: case $host in 2482: # compiling the symbol table file with pic_flag works around 2483: # a FreeBSD bug that causes programs to crash when -lm is 2484: # linked before any other PIC object. But we must not use 2485: # pic_flag when linking with -static. The problem exists in 2486: # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. 2487: *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) 2488: pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; 2489: *-*-hpux*) 2490: pic_flag_for_symtable=" $pic_flag" ;; 2491: *) 2492: if test "X$my_pic_p" != Xno; then 2493: pic_flag_for_symtable=" $pic_flag" 2494: fi 2495: ;; 2496: esac 2497: ;; 2498: esac 2499: symtab_cflags= 2500: for arg in $LTCFLAGS; do 2501: case $arg in 2502: -pie | -fpie | -fPIE) ;; 2503: *) symtab_cflags="$symtab_cflags $arg" ;; 2504: esac 2505: done 2506: 2507: # Now compile the dynamic symbol file. 2508: func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' 2509: 2510: # Clean up the generated files. 2511: func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' 2512: 2513: # Transform the symbol file into the correct name. 2514: symfileobj="$output_objdir/${my_outputname}S.$objext" 2515: case $host in 2516: *cygwin* | *mingw* | *cegcc* ) 2517: if test -f "$output_objdir/$my_outputname.def"; then 2518: compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` 2519: finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` 2520: else 2521: compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"` 2522: finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"` 2523: fi 2524: ;; 2525: *) 2526: compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"` 2527: finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"` 2528: ;; 2529: esac 2530: ;; 2531: *) 2532: func_fatal_error "unknown suffix for \`$my_dlsyms'" 2533: ;; 2534: esac 2535: else 2536: # We keep going just in case the user didn't refer to 2537: # lt_preloaded_symbols. The linker will fail if global_symbol_pipe 2538: # really was required. 2539: 2540: # Nullify the symbol file. 2541: compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` 2542: finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` 2543: fi 2544: } 2545: 2546: # func_win32_libid arg 2547: # return the library type of file 'arg' 2548: # 2549: # Need a lot of goo to handle *both* DLLs and import libs 2550: # Has to be a shell function in order to 'eat' the argument 2551: # that is supplied when $file_magic_command is called. 2552: func_win32_libid () 2553: { 2554: $opt_debug 2555: win32_libid_type="unknown" 2556: win32_fileres=`file -L $1 2>/dev/null` 2557: case $win32_fileres in 2558: *ar\ archive\ import\ library*) # definitely import 2559: win32_libid_type="x86 archive import" 2560: ;; 2561: *ar\ archive*) # could be an import, or static 2562: if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | 2563: $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then 2564: win32_nmres=`eval $NM -f posix -A $1 | 2565: $SED -n -e ' 2566: 1,100{ 2567: / I /{ 2568: s,.*,import, 2569: p 2570: q 2571: } 2572: }'` 2573: case $win32_nmres in 2574: import*) win32_libid_type="x86 archive import";; 2575: *) win32_libid_type="x86 archive static";; 2576: esac 2577: fi 2578: ;; 2579: *DLL*) 2580: win32_libid_type="x86 DLL" 2581: ;; 2582: *executable*) # but shell scripts are "executable" too... 2583: case $win32_fileres in 2584: *MS\ Windows\ PE\ Intel*) 2585: win32_libid_type="x86 DLL" 2586: ;; 2587: esac 2588: ;; 2589: esac 2590: $ECHO "$win32_libid_type" 2591: } 2592: 2593: 2594: 2595: # func_extract_an_archive dir oldlib 2596: func_extract_an_archive () 2597: { 2598: $opt_debug 2599: f_ex_an_ar_dir="$1"; shift 2600: f_ex_an_ar_oldlib="$1" 2601: func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?' 2602: if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then 2603: : 2604: else 2605: func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 2606: fi 2607: } 2608: 2609: 2610: # func_extract_archives gentop oldlib ... 2611: func_extract_archives () 2612: { 2613: $opt_debug 2614: my_gentop="$1"; shift 2615: my_oldlibs=${1+"$@"} 2616: my_oldobjs="" 2617: my_xlib="" 2618: my_xabs="" 2619: my_xdir="" 2620: 2621: for my_xlib in $my_oldlibs; do 2622: # Extract the objects. 2623: case $my_xlib in 2624: [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; 2625: *) my_xabs=`pwd`"/$my_xlib" ;; 2626: esac 2627: func_basename "$my_xlib" 2628: my_xlib="$func_basename_result" 2629: my_xlib_u=$my_xlib 2630: while :; do 2631: case " $extracted_archives " in 2632: *" $my_xlib_u "*) 2633: func_arith $extracted_serial + 1 2634: extracted_serial=$func_arith_result 2635: my_xlib_u=lt$extracted_serial-$my_xlib ;; 2636: *) break ;; 2637: esac 2638: done 2639: extracted_archives="$extracted_archives $my_xlib_u" 2640: my_xdir="$my_gentop/$my_xlib_u" 2641: 2642: func_mkdir_p "$my_xdir" 2643: 2644: case $host in 2645: *-darwin*) 2646: func_verbose "Extracting $my_xabs" 2647: # Do not bother doing anything if just a dry run 2648: $opt_dry_run || { 2649: darwin_orig_dir=`pwd` 2650: cd $my_xdir || exit $? 2651: darwin_archive=$my_xabs 2652: darwin_curdir=`pwd` 2653: darwin_base_archive=`basename "$darwin_archive"` 2654: darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` 2655: if test -n "$darwin_arches"; then 2656: darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` 2657: darwin_arch= 2658: func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" 2659: for darwin_arch in $darwin_arches ; do 2660: func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" 2661: $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" 2662: cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" 2663: func_extract_an_archive "`pwd`" "${darwin_base_archive}" 2664: cd "$darwin_curdir" 2665: $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" 2666: done # $darwin_arches 2667: ## Okay now we've a bunch of thin objects, gotta fatten them up :) 2668: darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` 2669: darwin_file= 2670: darwin_files= 2671: for darwin_file in $darwin_filelist; do 2672: darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP` 2673: $LIPO -create -output "$darwin_file" $darwin_files 2674: done # $darwin_filelist 2675: $RM -rf unfat-$$ 2676: cd "$darwin_orig_dir" 2677: else 2678: cd $darwin_orig_dir 2679: func_extract_an_archive "$my_xdir" "$my_xabs" 2680: fi # $darwin_arches 2681: } # !$opt_dry_run 2682: ;; 2683: *) 2684: func_extract_an_archive "$my_xdir" "$my_xabs" 2685: ;; 2686: esac 2687: my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP` 2688: done 2689: 2690: func_extract_archives_result="$my_oldobjs" 2691: } 2692: 2693: 2694: 2695: # func_emit_wrapper_part1 [arg=no] 2696: # 2697: # Emit the first part of a libtool wrapper script on stdout. 2698: # For more information, see the description associated with 2699: # func_emit_wrapper(), below. 2700: func_emit_wrapper_part1 () 2701: { 2702: func_emit_wrapper_part1_arg1=no 2703: if test -n "$1" ; then 2704: func_emit_wrapper_part1_arg1=$1 2705: fi 2706: 2707: $ECHO "\ 2708: #! $SHELL 2709: 2710: # $output - temporary wrapper script for $objdir/$outputname 2711: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 2712: # 2713: # The $output program cannot be directly executed until all the libtool 2714: # libraries that it depends on are installed. 2715: # 2716: # This wrapper script should never be moved out of the build directory. 2717: # If it is, it will not operate correctly. 2718: 2719: # Sed substitution that helps us do robust quoting. It backslashifies 2720: # metacharacters that are still active within double-quoted strings. 2721: Xsed='${SED} -e 1s/^X//' 2722: sed_quote_subst='$sed_quote_subst' 2723: 2724: # Be Bourne compatible 2725: if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then 2726: emulate sh 2727: NULLCMD=: 2728: # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which 2729: # is contrary to our usage. Disable this feature. 2730: alias -g '\${1+\"\$@\"}'='\"\$@\"' 2731: setopt NO_GLOB_SUBST 2732: else 2733: case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac 2734: fi 2735: BIN_SH=xpg4; export BIN_SH # for Tru64 2736: DUALCASE=1; export DUALCASE # for MKS sh 2737: 2738: # The HP-UX ksh and POSIX shell print the target directory to stdout 2739: # if CDPATH is set. 2740: (unset CDPATH) >/dev/null 2>&1 && unset CDPATH 2741: 2742: relink_command=\"$relink_command\" 2743: 2744: # This environment variable determines our operation mode. 2745: if test \"\$libtool_install_magic\" = \"$magic\"; then 2746: # install mode needs the following variables: 2747: generated_by_libtool_version='$macro_version' 2748: notinst_deplibs='$notinst_deplibs' 2749: else 2750: # When we are sourced in execute mode, \$file and \$ECHO are already set. 2751: if test \"\$libtool_execute_magic\" != \"$magic\"; then 2752: ECHO=\"$qecho\" 2753: file=\"\$0\" 2754: # Make sure echo works. 2755: if test \"X\$1\" = X--no-reexec; then 2756: # Discard the --no-reexec flag, and continue. 2757: shift 2758: elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then 2759: # Yippee, \$ECHO works! 2760: : 2761: else 2762: # Restart under the correct shell, and then maybe \$ECHO will work. 2763: exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"} 2764: fi 2765: fi\ 2766: " 2767: $ECHO "\ 2768: 2769: # Find the directory that this script lives in. 2770: thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\` 2771: test \"x\$thisdir\" = \"x\$file\" && thisdir=. 2772: 2773: # Follow symbolic links until we get to the real thisdir. 2774: file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\` 2775: while test -n \"\$file\"; do 2776: destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\` 2777: 2778: # If there was a directory component, then change thisdir. 2779: if test \"x\$destdir\" != \"x\$file\"; then 2780: case \"\$destdir\" in 2781: [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; 2782: *) thisdir=\"\$thisdir/\$destdir\" ;; 2783: esac 2784: fi 2785: 2786: file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\` 2787: file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\` 2788: done 2789: " 2790: } 2791: # end: func_emit_wrapper_part1 2792: 2793: # func_emit_wrapper_part2 [arg=no] 2794: # 2795: # Emit the second part of a libtool wrapper script on stdout. 2796: # For more information, see the description associated with 2797: # func_emit_wrapper(), below. 2798: func_emit_wrapper_part2 () 2799: { 2800: func_emit_wrapper_part2_arg1=no 2801: if test -n "$1" ; then 2802: func_emit_wrapper_part2_arg1=$1 2803: fi 2804: 2805: $ECHO "\ 2806: 2807: # Usually 'no', except on cygwin/mingw when embedded into 2808: # the cwrapper. 2809: WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1 2810: if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then 2811: # special case for '.' 2812: if test \"\$thisdir\" = \".\"; then 2813: thisdir=\`pwd\` 2814: fi 2815: # remove .libs from thisdir 2816: case \"\$thisdir\" in 2817: *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;; 2818: $objdir ) thisdir=. ;; 2819: esac 2820: fi 2821: 2822: # Try to get the absolute directory name. 2823: absdir=\`cd \"\$thisdir\" && pwd\` 2824: test -n \"\$absdir\" && thisdir=\"\$absdir\" 2825: " 2826: 2827: if test "$fast_install" = yes; then 2828: $ECHO "\ 2829: program=lt-'$outputname'$exeext 2830: progdir=\"\$thisdir/$objdir\" 2831: 2832: if test ! -f \"\$progdir/\$program\" || 2833: { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ 2834: test \"X\$file\" != \"X\$progdir/\$program\"; }; then 2835: 2836: file=\"\$\$-\$program\" 2837: 2838: if test ! -d \"\$progdir\"; then 2839: $MKDIR \"\$progdir\" 2840: else 2841: $RM \"\$progdir/\$file\" 2842: fi" 2843: 2844: $ECHO "\ 2845: 2846: # relink executable if necessary 2847: if test -n \"\$relink_command\"; then 2848: if relink_command_output=\`eval \$relink_command 2>&1\`; then : 2849: else 2850: $ECHO \"\$relink_command_output\" >&2 2851: $RM \"\$progdir/\$file\" 2852: exit 1 2853: fi 2854: fi 2855: 2856: $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || 2857: { $RM \"\$progdir/\$program\"; 2858: $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } 2859: $RM \"\$progdir/\$file\" 2860: fi" 2861: else 2862: $ECHO "\ 2863: program='$outputname' 2864: progdir=\"\$thisdir/$objdir\" 2865: " 2866: fi 2867: 2868: $ECHO "\ 2869: 2870: if test -f \"\$progdir/\$program\"; then" 2871: 2872: # Export our shlibpath_var if we have one. 2873: if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then 2874: $ECHO "\ 2875: # Add our own library path to $shlibpath_var 2876: $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" 2877: 2878: # Some systems cannot cope with colon-terminated $shlibpath_var 2879: # The second colon is a workaround for a bug in BeOS R4 sed 2880: $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\` 2881: 2882: export $shlibpath_var 2883: " 2884: fi 2885: 2886: # fixup the dll searchpath if we need to. 2887: if test -n "$dllsearchpath"; then 2888: $ECHO "\ 2889: # Add the dll search path components to the executable PATH 2890: PATH=$dllsearchpath:\$PATH 2891: " 2892: fi 2893: 2894: $ECHO "\ 2895: if test \"\$libtool_execute_magic\" != \"$magic\"; then 2896: # Run the actual program with our arguments. 2897: " 2898: case $host in 2899: # Backslashes separate directories on plain windows 2900: *-*-mingw | *-*-os2* | *-cegcc*) 2901: $ECHO "\ 2902: exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} 2903: " 2904: ;; 2905: 2906: *) 2907: $ECHO "\ 2908: exec \"\$progdir/\$program\" \${1+\"\$@\"} 2909: " 2910: ;; 2911: esac 2912: $ECHO "\ 2913: \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 2914: exit 1 2915: fi 2916: else 2917: # The program doesn't exist. 2918: \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 2919: \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 2920: $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 2921: exit 1 2922: fi 2923: fi\ 2924: " 2925: } 2926: # end: func_emit_wrapper_part2 2927: 2928: 2929: # func_emit_wrapper [arg=no] 2930: # 2931: # Emit a libtool wrapper script on stdout. 2932: # Don't directly open a file because we may want to 2933: # incorporate the script contents within a cygwin/mingw 2934: # wrapper executable. Must ONLY be called from within 2935: # func_mode_link because it depends on a number of variables 2936: # set therein. 2937: # 2938: # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR 2939: # variable will take. If 'yes', then the emitted script 2940: # will assume that the directory in which it is stored is 2941: # the $objdir directory. This is a cygwin/mingw-specific 2942: # behavior. 2943: func_emit_wrapper () 2944: { 2945: func_emit_wrapper_arg1=no 2946: if test -n "$1" ; then 2947: func_emit_wrapper_arg1=$1 2948: fi 2949: 2950: # split this up so that func_emit_cwrapperexe_src 2951: # can call each part independently. 2952: func_emit_wrapper_part1 "${func_emit_wrapper_arg1}" 2953: func_emit_wrapper_part2 "${func_emit_wrapper_arg1}" 2954: } 2955: 2956: 2957: # func_to_host_path arg 2958: # 2959: # Convert paths to host format when used with build tools. 2960: # Intended for use with "native" mingw (where libtool itself 2961: # is running under the msys shell), or in the following cross- 2962: # build environments: 2963: # $build $host 2964: # mingw (msys) mingw [e.g. native] 2965: # cygwin mingw 2966: # *nix + wine mingw 2967: # where wine is equipped with the `winepath' executable. 2968: # In the native mingw case, the (msys) shell automatically 2969: # converts paths for any non-msys applications it launches, 2970: # but that facility isn't available from inside the cwrapper. 2971: # Similar accommodations are necessary for $host mingw and 2972: # $build cygwin. Calling this function does no harm for other 2973: # $host/$build combinations not listed above. 2974: # 2975: # ARG is the path (on $build) that should be converted to 2976: # the proper representation for $host. The result is stored 2977: # in $func_to_host_path_result. 2978: func_to_host_path () 2979: { 2980: func_to_host_path_result="$1" 2981: if test -n "$1" ; then 2982: case $host in 2983: *mingw* ) 2984: lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' 2985: case $build in 2986: *mingw* ) # actually, msys 2987: # awkward: cmd appends spaces to result 2988: lt_sed_strip_trailing_spaces="s/[ ]*\$//" 2989: func_to_host_path_tmp1=`( cmd //c echo "$1" |\ 2990: $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""` 2991: func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\ 2992: $SED -e "$lt_sed_naive_backslashify"` 2993: ;; 2994: *cygwin* ) 2995: func_to_host_path_tmp1=`cygpath -w "$1"` 2996: func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\ 2997: $SED -e "$lt_sed_naive_backslashify"` 2998: ;; 2999: * ) 3000: # Unfortunately, winepath does not exit with a non-zero 3001: # error code, so we are forced to check the contents of 3002: # stdout. On the other hand, if the command is not 3003: # found, the shell will set an exit code of 127 and print 3004: # *an error message* to stdout. So we must check for both 3005: # error code of zero AND non-empty stdout, which explains 3006: # the odd construction: 3007: func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null` 3008: if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then 3009: func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\ 3010: $SED -e "$lt_sed_naive_backslashify"` 3011: else 3012: # Allow warning below. 3013: func_to_host_path_result="" 3014: fi 3015: ;; 3016: esac 3017: if test -z "$func_to_host_path_result" ; then 3018: func_error "Could not determine host path corresponding to" 3019: func_error " '$1'" 3020: func_error "Continuing, but uninstalled executables may not work." 3021: # Fallback: 3022: func_to_host_path_result="$1" 3023: fi 3024: ;; 3025: esac 3026: fi 3027: } 3028: # end: func_to_host_path 3029: 3030: # func_to_host_pathlist arg 3031: # 3032: # Convert pathlists to host format when used with build tools. 3033: # See func_to_host_path(), above. This function supports the 3034: # following $build/$host combinations (but does no harm for 3035: # combinations not listed here): 3036: # $build $host 3037: # mingw (msys) mingw [e.g. native] 3038: # cygwin mingw 3039: # *nix + wine mingw 3040: # 3041: # Path separators are also converted from $build format to 3042: # $host format. If ARG begins or ends with a path separator 3043: # character, it is preserved (but converted to $host format) 3044: # on output. 3045: # 3046: # ARG is a pathlist (on $build) that should be converted to 3047: # the proper representation on $host. The result is stored 3048: # in $func_to_host_pathlist_result. 3049: func_to_host_pathlist () 3050: { 3051: func_to_host_pathlist_result="$1" 3052: if test -n "$1" ; then 3053: case $host in 3054: *mingw* ) 3055: lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' 3056: # Remove leading and trailing path separator characters from 3057: # ARG. msys behavior is inconsistent here, cygpath turns them 3058: # into '.;' and ';.', and winepath ignores them completely. 3059: func_to_host_pathlist_tmp2="$1" 3060: # Once set for this call, this variable should not be 3061: # reassigned. It is used in tha fallback case. 3062: func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\ 3063: $SED -e 's|^:*||' -e 's|:*$||'` 3064: case $build in 3065: *mingw* ) # Actually, msys. 3066: # Awkward: cmd appends spaces to result. 3067: lt_sed_strip_trailing_spaces="s/[ ]*\$//" 3068: func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\ 3069: $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""` 3070: func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\ 3071: $SED -e "$lt_sed_naive_backslashify"` 3072: ;; 3073: *cygwin* ) 3074: func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"` 3075: func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\ 3076: $SED -e "$lt_sed_naive_backslashify"` 3077: ;; 3078: * ) 3079: # unfortunately, winepath doesn't convert pathlists 3080: func_to_host_pathlist_result="" 3081: func_to_host_pathlist_oldIFS=$IFS 3082: IFS=: 3083: for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do 3084: IFS=$func_to_host_pathlist_oldIFS 3085: if test -n "$func_to_host_pathlist_f" ; then 3086: func_to_host_path "$func_to_host_pathlist_f" 3087: if test -n "$func_to_host_path_result" ; then 3088: if test -z "$func_to_host_pathlist_result" ; then 3089: func_to_host_pathlist_result="$func_to_host_path_result" 3090: else 3091: func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result" 3092: fi 3093: fi 3094: fi 3095: IFS=: 3096: done 3097: IFS=$func_to_host_pathlist_oldIFS 3098: ;; 3099: esac 3100: if test -z "$func_to_host_pathlist_result" ; then 3101: func_error "Could not determine the host path(s) corresponding to" 3102: func_error " '$1'" 3103: func_error "Continuing, but uninstalled executables may not work." 3104: # Fallback. This may break if $1 contains DOS-style drive 3105: # specifications. The fix is not to complicate the expression 3106: # below, but for the user to provide a working wine installation 3107: # with winepath so that path translation in the cross-to-mingw 3108: # case works properly. 3109: lt_replace_pathsep_nix_to_dos="s|:|;|g" 3110: func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\ 3111: $SED -e "$lt_replace_pathsep_nix_to_dos"` 3112: fi 3113: # Now, add the leading and trailing path separators back 3114: case "$1" in 3115: :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result" 3116: ;; 3117: esac 3118: case "$1" in 3119: *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;" 3120: ;; 3121: esac 3122: ;; 3123: esac 3124: fi 3125: } 3126: # end: func_to_host_pathlist 3127: 3128: # func_emit_cwrapperexe_src 3129: # emit the source code for a wrapper executable on stdout 3130: # Must ONLY be called from within func_mode_link because 3131: # it depends on a number of variable set therein. 3132: func_emit_cwrapperexe_src () 3133: { 3134: cat <<EOF 3135: 3136: /* $cwrappersource - temporary wrapper executable for $objdir/$outputname 3137: Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 3138: 3139: The $output program cannot be directly executed until all the libtool 3140: libraries that it depends on are installed. 3141: 3142: This wrapper executable should never be moved out of the build directory. 3143: If it is, it will not operate correctly. 3144: 3145: Currently, it simply execs the wrapper *script* "$SHELL $output", 3146: but could eventually absorb all of the scripts functionality and 3147: exec $objdir/$outputname directly. 3148: */ 3149: EOF 3150: cat <<"EOF" 3151: #include <stdio.h> 3152: #include <stdlib.h> 3153: #ifdef _MSC_VER 3154: # include <direct.h> 3155: # include <process.h> 3156: # include <io.h> 3157: # define setmode _setmode 3158: #else 3159: # include <unistd.h> 3160: # include <stdint.h> 3161: # ifdef __CYGWIN__ 3162: # include <io.h> 3163: # define HAVE_SETENV 3164: # ifdef __STRICT_ANSI__ 3165: char *realpath (const char *, char *); 3166: int putenv (char *); 3167: int setenv (const char *, const char *, int); 3168: # endif 3169: # endif 3170: #endif 3171: #include <malloc.h> 3172: #include <stdarg.h> 3173: #include <assert.h> 3174: #include <string.h> 3175: #include <ctype.h> 3176: #include <errno.h> 3177: #include <fcntl.h> 3178: #include <sys/stat.h> 3179: 3180: #if defined(PATH_MAX) 3181: # define LT_PATHMAX PATH_MAX 3182: #elif defined(MAXPATHLEN) 3183: # define LT_PATHMAX MAXPATHLEN 3184: #else 3185: # define LT_PATHMAX 1024 3186: #endif 3187: 3188: #ifndef S_IXOTH 3189: # define S_IXOTH 0 3190: #endif 3191: #ifndef S_IXGRP 3192: # define S_IXGRP 0 3193: #endif 3194: 3195: #ifdef _MSC_VER 3196: # define S_IXUSR _S_IEXEC 3197: # define stat _stat 3198: # ifndef _INTPTR_T_DEFINED 3199: # define intptr_t int 3200: # endif 3201: #endif 3202: 3203: #ifndef DIR_SEPARATOR 3204: # define DIR_SEPARATOR '/' 3205: # define PATH_SEPARATOR ':' 3206: #endif 3207: 3208: #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ 3209: defined (__OS2__) 3210: # define HAVE_DOS_BASED_FILE_SYSTEM 3211: # define FOPEN_WB "wb" 3212: # ifndef DIR_SEPARATOR_2 3213: # define DIR_SEPARATOR_2 '\\' 3214: # endif 3215: # ifndef PATH_SEPARATOR_2 3216: # define PATH_SEPARATOR_2 ';' 3217: # endif 3218: #endif 3219: 3220: #ifndef DIR_SEPARATOR_2 3221: # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) 3222: #else /* DIR_SEPARATOR_2 */ 3223: # define IS_DIR_SEPARATOR(ch) \ 3224: (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) 3225: #endif /* DIR_SEPARATOR_2 */ 3226: 3227: #ifndef PATH_SEPARATOR_2 3228: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) 3229: #else /* PATH_SEPARATOR_2 */ 3230: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) 3231: #endif /* PATH_SEPARATOR_2 */ 3232: 3233: #ifdef __CYGWIN__ 3234: # define FOPEN_WB "wb" 3235: #endif 3236: 3237: #ifndef FOPEN_WB 3238: # define FOPEN_WB "w" 3239: #endif 3240: #ifndef _O_BINARY 3241: # define _O_BINARY 0 3242: #endif 3243: 3244: #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) 3245: #define XFREE(stale) do { \ 3246: if (stale) { free ((void *) stale); stale = 0; } \ 3247: } while (0) 3248: 3249: #undef LTWRAPPER_DEBUGPRINTF 3250: #if defined DEBUGWRAPPER 3251: # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args 3252: static void 3253: ltwrapper_debugprintf (const char *fmt, ...) 3254: { 3255: va_list args; 3256: va_start (args, fmt); 3257: (void) vfprintf (stderr, fmt, args); 3258: va_end (args); 3259: } 3260: #else 3261: # define LTWRAPPER_DEBUGPRINTF(args) 3262: #endif 3263: 3264: const char *program_name = NULL; 3265: 3266: void *xmalloc (size_t num); 3267: char *xstrdup (const char *string); 3268: const char *base_name (const char *name); 3269: char *find_executable (const char *wrapper); 3270: char *chase_symlinks (const char *pathspec); 3271: int make_executable (const char *path); 3272: int check_executable (const char *path); 3273: char *strendzap (char *str, const char *pat); 3274: void lt_fatal (const char *message, ...); 3275: void lt_setenv (const char *name, const char *value); 3276: char *lt_extend_str (const char *orig_value, const char *add, int to_end); 3277: void lt_opt_process_env_set (const char *arg); 3278: void lt_opt_process_env_prepend (const char *arg); 3279: void lt_opt_process_env_append (const char *arg); 3280: int lt_split_name_value (const char *arg, char** name, char** value); 3281: void lt_update_exe_path (const char *name, const char *value); 3282: void lt_update_lib_path (const char *name, const char *value); 3283: 3284: static const char *script_text_part1 = 3285: EOF 3286: 3287: func_emit_wrapper_part1 yes | 3288: $SED -e 's/$[\\"]$/\\\1/g' \ 3289: -e 's/^/ "/' -e 's/$/\\n"/' 3290: echo ";" 3291: cat <<EOF 3292: 3293: static const char *script_text_part2 = 3294: EOF 3295: func_emit_wrapper_part2 yes | 3296: $SED -e 's/$[\\"]$/\\\1/g' \ 3297: -e 's/^/ "/' -e 's/$/\\n"/' 3298: echo ";" 3299: 3300: cat <<EOF 3301: const char * MAGIC_EXE = "$magic_exe"; 3302: const char * LIB_PATH_VARNAME = "$shlibpath_var"; 3303: EOF 3304: 3305: if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then 3306: func_to_host_pathlist "$temp_rpath" 3307: cat <<EOF 3308: const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result"; 3309: EOF 3310: else 3311: cat <<"EOF" 3312: const char * LIB_PATH_VALUE = ""; 3313: EOF 3314: fi 3315: 3316: if test -n "$dllsearchpath"; then 3317: func_to_host_pathlist "$dllsearchpath:" 3318: cat <<EOF 3319: const char * EXE_PATH_VARNAME = "PATH"; 3320: const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result"; 3321: EOF 3322: else 3323: cat <<"EOF" 3324: const char * EXE_PATH_VARNAME = ""; 3325: const char * EXE_PATH_VALUE = ""; 3326: EOF 3327: fi 3328: 3329: if test "$fast_install" = yes; then 3330: cat <<EOF 3331: const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */ 3332: EOF 3333: else 3334: cat <<EOF 3335: const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */ 3336: EOF 3337: fi 3338: 3339: 3340: cat <<"EOF" 3341: 3342: #define LTWRAPPER_OPTION_PREFIX "--lt-" 3343: #define LTWRAPPER_OPTION_PREFIX_LENGTH 5 3344: 3345: static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH; 3346: static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX; 3347: 3348: static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script"; 3349: 3350: static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7; 3351: static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set"; 3352: /* argument is putenv-style "foo=bar", value of foo is set to bar */ 3353: 3354: static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11; 3355: static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend"; 3356: /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */ 3357: 3358: static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10; 3359: static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append"; 3360: /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */ 3361: 3362: int 3363: main (int argc, char *argv[]) 3364: { 3365: char **newargz; 3366: int newargc; 3367: char *tmp_pathspec; 3368: char *actual_cwrapper_path; 3369: char *actual_cwrapper_name; 3370: char *target_name; 3371: char *lt_argv_zero; 3372: intptr_t rval = 127; 3373: 3374: int i; 3375: 3376: program_name = (char *) xstrdup (base_name (argv[0])); 3377: LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0])); 3378: LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name)); 3379: 3380: /* very simple arg parsing; don't want to rely on getopt */ 3381: for (i = 1; i < argc; i++) 3382: { 3383: if (strcmp (argv[i], dumpscript_opt) == 0) 3384: { 3385: EOF 3386: case "$host" in 3387: *mingw* | *cygwin* ) 3388: # make stdout use "unix" line endings 3389: echo " setmode(1,_O_BINARY);" 3390: ;; 3391: esac 3392: 3393: cat <<"EOF" 3394: printf ("%s", script_text_part1); 3395: printf ("%s", script_text_part2); 3396: return 0; 3397: } 3398: } 3399: 3400: newargz = XMALLOC (char *, argc + 1); 3401: tmp_pathspec = find_executable (argv[0]); 3402: if (tmp_pathspec == NULL) 3403: lt_fatal ("Couldn't find %s", argv[0]); 3404: LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n", 3405: tmp_pathspec)); 3406: 3407: actual_cwrapper_path = chase_symlinks (tmp_pathspec); 3408: LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n", 3409: actual_cwrapper_path)); 3410: XFREE (tmp_pathspec); 3411: 3412: actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path)); 3413: strendzap (actual_cwrapper_path, actual_cwrapper_name); 3414: 3415: /* wrapper name transforms */ 3416: strendzap (actual_cwrapper_name, ".exe"); 3417: tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1); 3418: XFREE (actual_cwrapper_name); 3419: actual_cwrapper_name = tmp_pathspec; 3420: tmp_pathspec = 0; 3421: 3422: /* target_name transforms -- use actual target program name; might have lt- prefix */ 3423: target_name = xstrdup (base_name (TARGET_PROGRAM_NAME)); 3424: strendzap (target_name, ".exe"); 3425: tmp_pathspec = lt_extend_str (target_name, ".exe", 1); 3426: XFREE (target_name); 3427: target_name = tmp_pathspec; 3428: tmp_pathspec = 0; 3429: 3430: LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n", 3431: target_name)); 3432: EOF 3433: 3434: cat <<EOF 3435: newargz[0] = 3436: XMALLOC (char, (strlen (actual_cwrapper_path) + 3437: strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1)); 3438: strcpy (newargz[0], actual_cwrapper_path); 3439: strcat (newargz[0], "$objdir"); 3440: strcat (newargz[0], "/"); 3441: EOF 3442: 3443: cat <<"EOF" 3444: /* stop here, and copy so we don't have to do this twice */ 3445: tmp_pathspec = xstrdup (newargz[0]); 3446: 3447: /* do NOT want the lt- prefix here, so use actual_cwrapper_name */ 3448: strcat (newargz[0], actual_cwrapper_name); 3449: 3450: /* DO want the lt- prefix here if it exists, so use target_name */ 3451: lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1); 3452: XFREE (tmp_pathspec); 3453: tmp_pathspec = NULL; 3454: EOF 3455: 3456: case $host_os in 3457: mingw*) 3458: cat <<"EOF" 3459: { 3460: char* p; 3461: while ((p = strchr (newargz[0], '\\')) != NULL) 3462: { 3463: *p = '/'; 3464: } 3465: while ((p = strchr (lt_argv_zero, '\\')) != NULL) 3466: { 3467: *p = '/'; 3468: } 3469: } 3470: EOF 3471: ;; 3472: esac 3473: 3474: cat <<"EOF" 3475: XFREE (target_name); 3476: XFREE (actual_cwrapper_path); 3477: XFREE (actual_cwrapper_name); 3478: 3479: lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */ 3480: lt_setenv ("DUALCASE", "1"); /* for MSK sh */ 3481: lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE); 3482: lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE); 3483: 3484: newargc=0; 3485: for (i = 1; i < argc; i++) 3486: { 3487: if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0) 3488: { 3489: if (argv[i][env_set_opt_len] == '=') 3490: { 3491: const char *p = argv[i] + env_set_opt_len + 1; 3492: lt_opt_process_env_set (p); 3493: } 3494: else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc) 3495: { 3496: lt_opt_process_env_set (argv[++i]); /* don't copy */ 3497: } 3498: else 3499: lt_fatal ("%s missing required argument", env_set_opt); 3500: continue; 3501: } 3502: if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0) 3503: { 3504: if (argv[i][env_prepend_opt_len] == '=') 3505: { 3506: const char *p = argv[i] + env_prepend_opt_len + 1; 3507: lt_opt_process_env_prepend (p); 3508: } 3509: else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc) 3510: { 3511: lt_opt_process_env_prepend (argv[++i]); /* don't copy */ 3512: } 3513: else 3514: lt_fatal ("%s missing required argument", env_prepend_opt); 3515: continue; 3516: } 3517: if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0) 3518: { 3519: if (argv[i][env_append_opt_len] == '=') 3520: { 3521: const char *p = argv[i] + env_append_opt_len + 1; 3522: lt_opt_process_env_append (p); 3523: } 3524: else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc) 3525: { 3526: lt_opt_process_env_append (argv[++i]); /* don't copy */ 3527: } 3528: else 3529: lt_fatal ("%s missing required argument", env_append_opt); 3530: continue; 3531: } 3532: if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0) 3533: { 3534: /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX 3535: namespace, but it is not one of the ones we know about and 3536: have already dealt with, above (inluding dump-script), then 3537: report an error. Otherwise, targets might begin to believe 3538: they are allowed to use options in the LTWRAPPER_OPTION_PREFIX 3539: namespace. The first time any user complains about this, we'll 3540: need to make LTWRAPPER_OPTION_PREFIX a configure-time option 3541: or a configure.ac-settable value. 3542: */ 3543: lt_fatal ("Unrecognized option in %s namespace: '%s'", 3544: ltwrapper_option_prefix, argv[i]); 3545: } 3546: /* otherwise ... */ 3547: newargz[++newargc] = xstrdup (argv[i]); 3548: } 3549: newargz[++newargc] = NULL; 3550: 3551: LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>"))); 3552: for (i = 0; i < newargc; i++) 3553: { 3554: LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>"))); 3555: } 3556: 3557: EOF 3558: 3559: case $host_os in 3560: mingw*) 3561: cat <<"EOF" 3562: /* execv doesn't actually work on mingw as expected on unix */ 3563: rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz); 3564: if (rval == -1) 3565: { 3566: /* failed to start process */ 3567: LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno)); 3568: return 127; 3569: } 3570: return rval; 3571: EOF 3572: ;; 3573: *) 3574: cat <<"EOF" 3575: execv (lt_argv_zero, newargz); 3576: return rval; /* =127, but avoids unused variable warning */ 3577: EOF 3578: ;; 3579: esac 3580: 3581: cat <<"EOF" 3582: } 3583: 3584: void * 3585: xmalloc (size_t num) 3586: { 3587: void *p = (void *) malloc (num); 3588: if (!p) 3589: lt_fatal ("Memory exhausted"); 3590: 3591: return p; 3592: } 3593: 3594: char * 3595: xstrdup (const char *string) 3596: { 3597: return string ? strcpy ((char *) xmalloc (strlen (string) + 1), 3598: string) : NULL; 3599: } 3600: 3601: const char * 3602: base_name (const char *name) 3603: { 3604: const char *base; 3605: 3606: #if defined (HAVE_DOS_BASED_FILE_SYSTEM) 3607: /* Skip over the disk name in MSDOS pathnames. */ 3608: if (isalpha ((unsigned char) name[0]) && name[1] == ':') 3609: name += 2; 3610: #endif 3611: 3612: for (base = name; *name; name++) 3613: if (IS_DIR_SEPARATOR (*name)) 3614: base = name + 1; 3615: return base; 3616: } 3617: 3618: int 3619: check_executable (const char *path) 3620: { 3621: struct stat st; 3622: 3623: LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n", 3624: path ? (*path ? path : "EMPTY!") : "NULL!")); 3625: if ((!path) || (!*path)) 3626: return 0; 3627: 3628: if ((stat (path, &st) >= 0) 3629: && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) 3630: return 1; 3631: else 3632: return 0; 3633: } 3634: 3635: int 3636: make_executable (const char *path) 3637: { 3638: int rval = 0; 3639: struct stat st; 3640: 3641: LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n", 3642: path ? (*path ? path : "EMPTY!") : "NULL!")); 3643: if ((!path) || (!*path)) 3644: return 0; 3645: 3646: if (stat (path, &st) >= 0) 3647: { 3648: rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); 3649: } 3650: return rval; 3651: } 3652: 3653: /* Searches for the full path of the wrapper. Returns 3654: newly allocated full path name if found, NULL otherwise 3655: Does not chase symlinks, even on platforms that support them. 3656: */ 3657: char * 3658: find_executable (const char *wrapper) 3659: { 3660: int has_slash = 0; 3661: const char *p; 3662: const char *p_next; 3663: /* static buffer for getcwd */ 3664: char tmp[LT_PATHMAX + 1]; 3665: int tmp_len; 3666: char *concat_name; 3667: 3668: LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n", 3669: wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!")); 3670: 3671: if ((wrapper == NULL) || (*wrapper == '\0')) 3672: return NULL; 3673: 3674: /* Absolute path? */ 3675: #if defined (HAVE_DOS_BASED_FILE_SYSTEM) 3676: if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') 3677: { 3678: concat_name = xstrdup (wrapper); 3679: if (check_executable (concat_name)) 3680: return concat_name; 3681: XFREE (concat_name); 3682: } 3683: else 3684: { 3685: #endif 3686: if (IS_DIR_SEPARATOR (wrapper[0])) 3687: { 3688: concat_name = xstrdup (wrapper); 3689: if (check_executable (concat_name)) 3690: return concat_name; 3691: XFREE (concat_name); 3692: } 3693: #if defined (HAVE_DOS_BASED_FILE_SYSTEM) 3694: } 3695: #endif 3696: 3697: for (p = wrapper; *p; p++) 3698: if (*p == '/') 3699: { 3700: has_slash = 1; 3701: break; 3702: } 3703: if (!has_slash) 3704: { 3705: /* no slashes; search PATH */ 3706: const char *path = getenv ("PATH"); 3707: if (path != NULL) 3708: { 3709: for (p = path; *p; p = p_next) 3710: { 3711: const char *q; 3712: size_t p_len; 3713: for (q = p; *q; q++) 3714: if (IS_PATH_SEPARATOR (*q)) 3715: break; 3716: p_len = q - p; 3717: p_next = (*q == '\0' ? q : q + 1); 3718: if (p_len == 0) 3719: { 3720: /* empty path: current directory */ 3721: if (getcwd (tmp, LT_PATHMAX) == NULL) 3722: lt_fatal ("getcwd failed"); 3723: tmp_len = strlen (tmp); 3724: concat_name = 3725: XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); 3726: memcpy (concat_name, tmp, tmp_len); 3727: concat_name[tmp_len] = '/'; 3728: strcpy (concat_name + tmp_len + 1, wrapper); 3729: } 3730: else 3731: { 3732: concat_name = 3733: XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); 3734: memcpy (concat_name, p, p_len); 3735: concat_name[p_len] = '/'; 3736: strcpy (concat_name + p_len + 1, wrapper); 3737: } 3738: if (check_executable (concat_name)) 3739: return concat_name; 3740: XFREE (concat_name); 3741: } 3742: } 3743: /* not found in PATH; assume curdir */ 3744: } 3745: /* Relative path | not found in path: prepend cwd */ 3746: if (getcwd (tmp, LT_PATHMAX) == NULL) 3747: lt_fatal ("getcwd failed"); 3748: tmp_len = strlen (tmp); 3749: concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); 3750: memcpy (concat_name, tmp, tmp_len); 3751: concat_name[tmp_len] = '/'; 3752: strcpy (concat_name + tmp_len + 1, wrapper); 3753: 3754: if (check_executable (concat_name)) 3755: return concat_name; 3756: XFREE (concat_name); 3757: return NULL; 3758: } 3759: 3760: char * 3761: chase_symlinks (const char *pathspec) 3762: { 3763: #ifndef S_ISLNK 3764: return xstrdup (pathspec); 3765: #else 3766: char buf[LT_PATHMAX]; 3767: struct stat s; 3768: char *tmp_pathspec = xstrdup (pathspec); 3769: char *p; 3770: int has_symlinks = 0; 3771: while (strlen (tmp_pathspec) && !has_symlinks) 3772: { 3773: LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n", 3774: tmp_pathspec)); 3775: if (lstat (tmp_pathspec, &s) == 0) 3776: { 3777: if (S_ISLNK (s.st_mode) != 0) 3778: { 3779: has_symlinks = 1; 3780: break; 3781: } 3782: 3783: /* search backwards for last DIR_SEPARATOR */ 3784: p = tmp_pathspec + strlen (tmp_pathspec) - 1; 3785: while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) 3786: p--; 3787: if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) 3788: { 3789: /* no more DIR_SEPARATORS left */ 3790: break; 3791: } 3792: *p = '\0'; 3793: } 3794: else 3795: { 3796: char *errstr = strerror (errno); 3797: lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr); 3798: } 3799: } 3800: XFREE (tmp_pathspec); 3801: 3802: if (!has_symlinks) 3803: { 3804: return xstrdup (pathspec); 3805: } 3806: 3807: tmp_pathspec = realpath (pathspec, buf); 3808: if (tmp_pathspec == 0) 3809: { 3810: lt_fatal ("Could not follow symlinks for %s", pathspec); 3811: } 3812: return xstrdup (tmp_pathspec); 3813: #endif 3814: } 3815: 3816: char * 3817: strendzap (char *str, const char *pat) 3818: { 3819: size_t len, patlen; 3820: 3821: assert (str != NULL); 3822: assert (pat != NULL); 3823: 3824: len = strlen (str); 3825: patlen = strlen (pat); 3826: 3827: if (patlen <= len) 3828: { 3829: str += len - patlen; 3830: if (strcmp (str, pat) == 0) 3831: *str = '\0'; 3832: } 3833: return str; 3834: } 3835: 3836: static void 3837: lt_error_core (int exit_status, const char *mode, 3838: const char *message, va_list ap) 3839: { 3840: fprintf (stderr, "%s: %s: ", program_name, mode); 3841: vfprintf (stderr, message, ap); 3842: fprintf (stderr, ".\n"); 3843: 3844: if (exit_status >= 0) 3845: exit (exit_status); 3846: } 3847: 3848: void 3849: lt_fatal (const char *message, ...) 3850: { 3851: va_list ap; 3852: va_start (ap, message); 3853: lt_error_core (EXIT_FAILURE, "FATAL", message, ap); 3854: va_end (ap); 3855: } 3856: 3857: void 3858: lt_setenv (const char *name, const char *value) 3859: { 3860: LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n", 3861: (name ? name : "<NULL>"), 3862: (value ? value : "<NULL>"))); 3863: { 3864: #ifdef HAVE_SETENV 3865: /* always make a copy, for consistency with !HAVE_SETENV */ 3866: char *str = xstrdup (value); 3867: setenv (name, str, 1); 3868: #else 3869: int len = strlen (name) + 1 + strlen (value) + 1; 3870: char *str = XMALLOC (char, len); 3871: sprintf (str, "%s=%s", name, value); 3872: if (putenv (str) != EXIT_SUCCESS) 3873: { 3874: XFREE (str); 3875: } 3876: #endif 3877: } 3878: } 3879: 3880: char * 3881: lt_extend_str (const char *orig_value, const char *add, int to_end) 3882: { 3883: char *new_value; 3884: if (orig_value && *orig_value) 3885: { 3886: int orig_value_len = strlen (orig_value); 3887: int add_len = strlen (add); 3888: new_value = XMALLOC (char, add_len + orig_value_len + 1); 3889: if (to_end) 3890: { 3891: strcpy (new_value, orig_value); 3892: strcpy (new_value + orig_value_len, add); 3893: } 3894: else 3895: { 3896: strcpy (new_value, add); 3897: strcpy (new_value + add_len, orig_value); 3898: } 3899: } 3900: else 3901: { 3902: new_value = xstrdup (add); 3903: } 3904: return new_value; 3905: } 3906: 3907: int 3908: lt_split_name_value (const char *arg, char** name, char** value) 3909: { 3910: const char *p; 3911: int len; 3912: if (!arg || !*arg) 3913: return 1; 3914: 3915: p = strchr (arg, (int)'='); 3916: 3917: if (!p) 3918: return 1; 3919: 3920: *value = xstrdup (++p); 3921: 3922: len = strlen (arg) - strlen (*value); 3923: *name = XMALLOC (char, len); 3924: strncpy (*name, arg, len-1); 3925: (*name)[len - 1] = '\0'; 3926: 3927: return 0; 3928: } 3929: 3930: void 3931: lt_opt_process_env_set (const char *arg) 3932: { 3933: char *name = NULL; 3934: char *value = NULL; 3935: 3936: if (lt_split_name_value (arg, &name, &value) != 0) 3937: { 3938: XFREE (name); 3939: XFREE (value); 3940: lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg); 3941: } 3942: 3943: lt_setenv (name, value); 3944: XFREE (name); 3945: XFREE (value); 3946: } 3947: 3948: void 3949: lt_opt_process_env_prepend (const char *arg) 3950: { 3951: char *name = NULL; 3952: char *value = NULL; 3953: char *new_value = NULL; 3954: 3955: if (lt_split_name_value (arg, &name, &value) != 0) 3956: { 3957: XFREE (name); 3958: XFREE (value); 3959: lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg); 3960: } 3961: 3962: new_value = lt_extend_str (getenv (name), value, 0); 3963: lt_setenv (name, new_value); 3964: XFREE (new_value); 3965: XFREE (name); 3966: XFREE (value); 3967: } 3968: 3969: void 3970: lt_opt_process_env_append (const char *arg) 3971: { 3972: char *name = NULL; 3973: char *value = NULL; 3974: char *new_value = NULL; 3975: 3976: if (lt_split_name_value (arg, &name, &value) != 0) 3977: { 3978: XFREE (name); 3979: XFREE (value); 3980: lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg); 3981: } 3982: 3983: new_value = lt_extend_str (getenv (name), value, 1); 3984: lt_setenv (name, new_value); 3985: XFREE (new_value); 3986: XFREE (name); 3987: XFREE (value); 3988: } 3989: 3990: void 3991: lt_update_exe_path (const char *name, const char *value) 3992: { 3993: LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n", 3994: (name ? name : "<NULL>"), 3995: (value ? value : "<NULL>"))); 3996: 3997: if (name && *name && value && *value) 3998: { 3999: char *new_value = lt_extend_str (getenv (name), value, 0); 4000: /* some systems can't cope with a ':'-terminated path #' */ 4001: int len = strlen (new_value); 4002: while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) 4003: { 4004: new_value[len-1] = '\0'; 4005: } 4006: lt_setenv (name, new_value); 4007: XFREE (new_value); 4008: } 4009: } 4010: 4011: void 4012: lt_update_lib_path (const char *name, const char *value) 4013: { 4014: LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n", 4015: (name ? name : "<NULL>"), 4016: (value ? value : "<NULL>"))); 4017: 4018: if (name && *name && value && *value) 4019: { 4020: char *new_value = lt_extend_str (getenv (name), value, 0); 4021: lt_setenv (name, new_value); 4022: XFREE (new_value); 4023: } 4024: } 4025: 4026: 4027: EOF 4028: } 4029: # end: func_emit_cwrapperexe_src 4030: 4031: # func_mode_link arg... 4032: func_mode_link () 4033: { 4034: $opt_debug 4035: case $host in 4036: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 4037: # It is impossible to link a dll without this setting, and 4038: # we shouldn't force the makefile maintainer to figure out 4039: # which system we are compiling for in order to pass an extra 4040: # flag for every libtool invocation. 4041: # allow_undefined=no 4042: 4043: # FIXME: Unfortunately, there are problems with the above when trying 4044: # to make a dll which has undefined symbols, in which case not 4045: # even a static library is built. For now, we need to specify 4046: # -no-undefined on the libtool link line when we can be certain 4047: # that all symbols are satisfied, otherwise we get a static library. 4048: allow_undefined=yes 4049: ;; 4050: *) 4051: allow_undefined=yes 4052: ;; 4053: esac 4054: libtool_args=$nonopt 4055: base_compile="$nonopt $@" 4056: compile_command=$nonopt 4057: finalize_command=$nonopt 4058: 4059: compile_rpath= 4060: finalize_rpath= 4061: compile_shlibpath= 4062: finalize_shlibpath= 4063: convenience= 4064: old_convenience= 4065: deplibs= 4066: old_deplibs= 4067: compiler_flags= 4068: linker_flags= 4069: dllsearchpath= 4070: lib_search_path=`pwd` 4071: inst_prefix_dir= 4072: new_inherited_linker_flags= 4073: 4074: avoid_version=no 4075: dlfiles= 4076: dlprefiles= 4077: dlself=no 4078: export_dynamic=no 4079: export_symbols= 4080: export_symbols_regex= 4081: generated= 4082: libobjs= 4083: ltlibs= 4084: module=no 4085: no_install=no 4086: objs= 4087: non_pic_objects= 4088: precious_files_regex= 4089: prefer_static_libs=no 4090: preload=no 4091: prev= 4092: prevarg= 4093: release= 4094: rpath= 4095: xrpath= 4096: perm_rpath= 4097: temp_rpath= 4098: thread_safe=no 4099: vinfo= 4100: vinfo_number=no 4101: weak_libs= 4102: single_module="${wl}-single_module" 4103: func_infer_tag $base_compile 4104: 4105: # We need to know -static, to get the right output filenames. 4106: for arg 4107: do 4108: case $arg in 4109: -shared) 4110: test "$build_libtool_libs" != yes && \ 4111: func_fatal_configuration "can not build a shared library" 4112: build_old_libs=no 4113: break 4114: ;; 4115: -all-static | -static | -static-libtool-libs) 4116: case $arg in 4117: -all-static) 4118: if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then 4119: func_warning "complete static linking is impossible in this configuration" 4120: fi 4121: if test -n "$link_static_flag"; then 4122: dlopen_self=$dlopen_self_static 4123: fi 4124: prefer_static_libs=yes 4125: ;; 4126: -static) 4127: if test -z "$pic_flag" && test -n "$link_static_flag"; then 4128: dlopen_self=$dlopen_self_static 4129: fi 4130: prefer_static_libs=built 4131: ;; 4132: -static-libtool-libs) 4133: if test -z "$pic_flag" && test -n "$link_static_flag"; then 4134: dlopen_self=$dlopen_self_static 4135: fi 4136: prefer_static_libs=yes 4137: ;; 4138: esac 4139: build_libtool_libs=no 4140: build_old_libs=yes 4141: break 4142: ;; 4143: esac 4144: done 4145: 4146: # See if our shared archives depend on static archives. 4147: test -n "$old_archive_from_new_cmds" && build_old_libs=yes 4148: 4149: # Go through the arguments, transforming them on the way. 4150: while test "$#" -gt 0; do 4151: arg="$1" 4152: shift 4153: func_quote_for_eval "$arg" 4154: qarg=$func_quote_for_eval_unquoted_result 4155: func_append libtool_args " $func_quote_for_eval_result" 4156: 4157: # If the previous option needs an argument, assign it. 4158: if test -n "$prev"; then 4159: case $prev in 4160: output) 4161: func_append compile_command " @OUTPUT@" 4162: func_append finalize_command " @OUTPUT@" 4163: ;; 4164: esac 4165: 4166: case $prev in 4167: dlfiles|dlprefiles) 4168: if test "$preload" = no; then 4169: # Add the symbol object into the linking commands. 4170: func_append compile_command " @SYMFILE@" 4171: func_append finalize_command " @SYMFILE@" 4172: preload=yes 4173: fi 4174: case $arg in 4175: *.la | *.lo) ;; # We handle these cases below. 4176: force) 4177: if test "$dlself" = no; then 4178: dlself=needless 4179: export_dynamic=yes 4180: fi 4181: prev= 4182: continue 4183: ;; 4184: self) 4185: if test "$prev" = dlprefiles; then 4186: dlself=yes 4187: elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then 4188: dlself=yes 4189: else 4190: dlself=needless 4191: export_dynamic=yes 4192: fi 4193: prev= 4194: continue 4195: ;; 4196: *) 4197: if test "$prev" = dlfiles; then 4198: dlfiles="$dlfiles $arg" 4199: else 4200: dlprefiles="$dlprefiles $arg" 4201: fi 4202: prev= 4203: continue 4204: ;; 4205: esac 4206: ;; 4207: expsyms) 4208: export_symbols="$arg" 4209: test -f "$arg" \ 4210: || func_fatal_error "symbol file \`$arg' does not exist" 4211: prev= 4212: continue 4213: ;; 4214: expsyms_regex) 4215: export_symbols_regex="$arg" 4216: prev= 4217: continue 4218: ;; 4219: framework) 4220: case $host in 4221: *-*-darwin*) 4222: case "$deplibs " in 4223: *" $qarg.ltframework "*) ;; 4224: *) deplibs="$deplibs $qarg.ltframework" # this is fixed later 4225: ;; 4226: esac 4227: ;; 4228: esac 4229: prev= 4230: continue 4231: ;; 4232: inst_prefix) 4233: inst_prefix_dir="$arg" 4234: prev= 4235: continue 4236: ;; 4237: objectlist) 4238: if test -f "$arg"; then 4239: save_arg=$arg 4240: moreargs= 4241: for fil in `cat "$save_arg"` 4242: do 4243: # moreargs="$moreargs $fil" 4244: arg=$fil 4245: # A libtool-controlled object. 4246: 4247: # Check to see that this really is a libtool object. 4248: if func_lalib_unsafe_p "$arg"; then 4249: pic_object= 4250: non_pic_object= 4251: 4252: # Read the .lo file 4253: func_source "$arg" 4254: 4255: if test -z "$pic_object" || 4256: test -z "$non_pic_object" || 4257: test "$pic_object" = none && 4258: test "$non_pic_object" = none; then 4259: func_fatal_error "cannot find name of object for \`$arg'" 4260: fi 4261: 4262: # Extract subdirectory from the argument. 4263: func_dirname "$arg" "/" "" 4264: xdir="$func_dirname_result" 4265: 4266: if test "$pic_object" != none; then 4267: # Prepend the subdirectory the object is found in. 4268: pic_object="$xdir$pic_object" 4269: 4270: if test "$prev" = dlfiles; then 4271: if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then 4272: dlfiles="$dlfiles $pic_object" 4273: prev= 4274: continue 4275: else 4276: # If libtool objects are unsupported, then we need to preload. 4277: prev=dlprefiles 4278: fi 4279: fi 4280: 4281: # CHECK ME: I think I busted this. -Ossama 4282: if test "$prev" = dlprefiles; then 4283: # Preload the old-style object. 4284: dlprefiles="$dlprefiles $pic_object" 4285: prev= 4286: fi 4287: 4288: # A PIC object. 4289: func_append libobjs " $pic_object" 4290: arg="$pic_object" 4291: fi 4292: 4293: # Non-PIC object. 4294: if test "$non_pic_object" != none; then 4295: # Prepend the subdirectory the object is found in. 4296: non_pic_object="$xdir$non_pic_object" 4297: 4298: # A standard non-PIC object 4299: func_append non_pic_objects " $non_pic_object" 4300: if test -z "$pic_object" || test "$pic_object" = none ; then 4301: arg="$non_pic_object" 4302: fi 4303: else 4304: # If the PIC object exists, use it instead. 4305: # $xdir was prepended to $pic_object above. 4306: non_pic_object="$pic_object" 4307: func_append non_pic_objects " $non_pic_object" 4308: fi 4309: else 4310: # Only an error if not doing a dry-run. 4311: if $opt_dry_run; then 4312: # Extract subdirectory from the argument. 4313: func_dirname "$arg" "/" "" 4314: xdir="$func_dirname_result" 4315: 4316: func_lo2o "$arg" 4317: pic_object=$xdir$objdir/$func_lo2o_result 4318: non_pic_object=$xdir$func_lo2o_result 4319: func_append libobjs " $pic_object" 4320: func_append non_pic_objects " $non_pic_object" 4321: else 4322: func_fatal_error "\`$arg' is not a valid libtool object" 4323: fi 4324: fi 4325: done 4326: else 4327: func_fatal_error "link input file \`$arg' does not exist" 4328: fi 4329: arg=$save_arg 4330: prev= 4331: continue 4332: ;; 4333: precious_regex) 4334: precious_files_regex="$arg" 4335: prev= 4336: continue 4337: ;; 4338: release) 4339: release="-$arg" 4340: prev= 4341: continue 4342: ;; 4343: rpath | xrpath) 4344: # We need an absolute path. 4345: case $arg in 4346: [\\/]* | [A-Za-z]:[\\/]*) ;; 4347: *) 4348: func_fatal_error "only absolute run-paths are allowed" 4349: ;; 4350: esac 4351: if test "$prev" = rpath; then 4352: case "$rpath " in 4353: *" $arg "*) ;; 4354: *) rpath="$rpath $arg" ;; 4355: esac 4356: else 4357: case "$xrpath " in 4358: *" $arg "*) ;; 4359: *) xrpath="$xrpath $arg" ;; 4360: esac 4361: fi 4362: prev= 4363: continue 4364: ;; 4365: shrext) 4366: shrext_cmds="$arg" 4367: prev= 4368: continue 4369: ;; 4370: weak) 4371: weak_libs="$weak_libs $arg" 4372: prev= 4373: continue 4374: ;; 4375: xcclinker) 4376: linker_flags="$linker_flags $qarg" 4377: compiler_flags="$compiler_flags $qarg" 4378: prev= 4379: func_append compile_command " $qarg" 4380: func_append finalize_command " $qarg" 4381: continue 4382: ;; 4383: xcompiler) 4384: compiler_flags="$compiler_flags $qarg" 4385: prev= 4386: func_append compile_command " $qarg" 4387: func_append finalize_command " $qarg" 4388: continue 4389: ;; 4390: xlinker) 4391: linker_flags="$linker_flags $qarg" 4392: compiler_flags="$compiler_flags $wl$qarg" 4393: prev= 4394: func_append compile_command " $wl$qarg" 4395: func_append finalize_command " $wl$qarg" 4396: continue 4397: ;; 4398: *) 4399: eval "$prev=\"\$arg\"" 4400: prev= 4401: continue 4402: ;; 4403: esac 4404: fi # test -n "$prev" 4405: 4406: prevarg="$arg" 4407: 4408: case $arg in 4409: -all-static) 4410: if test -n "$link_static_flag"; then 4411: # See comment for -static flag below, for more details. 4412: func_append compile_command " $link_static_flag" 4413: func_append finalize_command " $link_static_flag" 4414: fi 4415: continue 4416: ;; 4417: 4418: -allow-undefined) 4419: # FIXME: remove this flag sometime in the future. 4420: func_fatal_error "\`-allow-undefined' must not be used because it is the default" 4421: ;; 4422: 4423: -avoid-version) 4424: avoid_version=yes 4425: continue 4426: ;; 4427: 4428: -dlopen) 4429: prev=dlfiles 4430: continue 4431: ;; 4432: 4433: -dlpreopen) 4434: prev=dlprefiles 4435: continue 4436: ;; 4437: 4438: -export-dynamic) 4439: export_dynamic=yes 4440: continue 4441: ;; 4442: 4443: -export-symbols | -export-symbols-regex) 4444: if test -n "$export_symbols" || test -n "$export_symbols_regex"; then 4445: func_fatal_error "more than one -exported-symbols argument is not allowed" 4446: fi 4447: if test "X$arg" = "X-export-symbols"; then 4448: prev=expsyms 4449: else 4450: prev=expsyms_regex 4451: fi 4452: continue 4453: ;; 4454: 4455: -framework) 4456: prev=framework 4457: continue 4458: ;; 4459: 4460: -inst-prefix-dir) 4461: prev=inst_prefix 4462: continue 4463: ;; 4464: 4465: # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* 4466: # so, if we see these flags be careful not to treat them like -L 4467: -L[A-Z][A-Z]*:*) 4468: case $with_gcc/$host in 4469: no/*-*-irix* | /*-*-irix*) 4470: func_append compile_command " $arg" 4471: func_append finalize_command " $arg" 4472: ;; 4473: esac 4474: continue 4475: ;; 4476: 4477: -L*) 4478: func_stripname '-L' '' "$arg" 4479: dir=$func_stripname_result 4480: if test -z "$dir"; then 4481: if test "$#" -gt 0; then 4482: func_fatal_error "require no space between \`-L' and \`$1'" 4483: else 4484: func_fatal_error "need path for \`-L' option" 4485: fi 4486: fi 4487: # We need an absolute path. 4488: case $dir in 4489: [\\/]* | [A-Za-z]:[\\/]*) ;; 4490: *) 4491: absdir=`cd "$dir" && pwd` 4492: test -z "$absdir" && \ 4493: func_fatal_error "cannot determine absolute directory name of \`$dir'" 4494: dir="$absdir" 4495: ;; 4496: esac 4497: case "$deplibs " in 4498: *" -L$dir "*) ;; 4499: *) 4500: deplibs="$deplibs -L$dir" 4501: lib_search_path="$lib_search_path $dir" 4502: ;; 4503: esac 4504: case $host in 4505: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 4506: testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'` 4507: case :$dllsearchpath: in 4508: *":$dir:"*) ;; 4509: ::) dllsearchpath=$dir;; 4510: *) dllsearchpath="$dllsearchpath:$dir";; 4511: esac 4512: case :$dllsearchpath: in 4513: *":$testbindir:"*) ;; 4514: ::) dllsearchpath=$testbindir;; 4515: *) dllsearchpath="$dllsearchpath:$testbindir";; 4516: esac 4517: ;; 4518: esac 4519: continue 4520: ;; 4521: 4522: -l*) 4523: if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then 4524: case $host in 4525: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*) 4526: # These systems don't actually have a C or math library (as such) 4527: continue 4528: ;; 4529: *-*-os2*) 4530: # These systems don't actually have a C library (as such) 4531: test "X$arg" = "X-lc" && continue 4532: ;; 4533: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 4534: # Do not include libc due to us having libc/libc_r. 4535: test "X$arg" = "X-lc" && continue 4536: ;; 4537: *-*-rhapsody* | *-*-darwin1.[012]) 4538: # Rhapsody C and math libraries are in the System framework 4539: deplibs="$deplibs System.ltframework" 4540: continue 4541: ;; 4542: *-*-sco3.2v5* | *-*-sco5v6*) 4543: # Causes problems with __ctype 4544: test "X$arg" = "X-lc" && continue 4545: ;; 4546: *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) 4547: # Compiler inserts libc in the correct place for threads to work 4548: test "X$arg" = "X-lc" && continue 4549: ;; 4550: esac 4551: elif test "X$arg" = "X-lc_r"; then 4552: case $host in 4553: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 4554: # Do not include libc_r directly, use -pthread flag. 4555: continue 4556: ;; 4557: esac 4558: fi 4559: deplibs="$deplibs $arg" 4560: continue 4561: ;; 4562: 4563: -module) 4564: module=yes 4565: continue 4566: ;; 4567: 4568: # Tru64 UNIX uses -model [arg] to determine the layout of C++ 4569: # classes, name mangling, and exception handling. 4570: # Darwin uses the -arch flag to determine output architecture. 4571: -model|-arch|-isysroot) 4572: compiler_flags="$compiler_flags $arg" 4573: func_append compile_command " $arg" 4574: func_append finalize_command " $arg" 4575: prev=xcompiler 4576: continue 4577: ;; 4578: 4579: -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads) 4580: compiler_flags="$compiler_flags $arg" 4581: func_append compile_command " $arg" 4582: func_append finalize_command " $arg" 4583: case "$new_inherited_linker_flags " in 4584: *" $arg "*) ;; 4585: * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;; 4586: esac 4587: continue 4588: ;; 4589: 4590: -multi_module) 4591: single_module="${wl}-multi_module" 4592: continue 4593: ;; 4594: 4595: -no-fast-install) 4596: fast_install=no 4597: continue 4598: ;; 4599: 4600: -no-install) 4601: case $host in 4602: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) 4603: # The PATH hackery in wrapper scripts is required on Windows 4604: # and Darwin in order for the loader to find any dlls it needs. 4605: func_warning "\`-no-install' is ignored for $host" 4606: func_warning "assuming \`-no-fast-install' instead" 4607: fast_install=no 4608: ;; 4609: *) no_install=yes ;; 4610: esac 4611: continue 4612: ;; 4613: 4614: -no-undefined) 4615: allow_undefined=no 4616: continue 4617: ;; 4618: 4619: -objectlist) 4620: prev=objectlist 4621: continue 4622: ;; 4623: 4624: -o) prev=output ;; 4625: 4626: -precious-files-regex) 4627: prev=precious_regex 4628: continue 4629: ;; 4630: 4631: -release) 4632: prev=release 4633: continue 4634: ;; 4635: 4636: -rpath) 4637: prev=rpath 4638: continue 4639: ;; 4640: 4641: -R) 4642: prev=xrpath 4643: continue 4644: ;; 4645: 4646: -R*) 4647: func_stripname '-R' '' "$arg" 4648: dir=$func_stripname_result 4649: # We need an absolute path. 4650: case $dir in 4651: [\\/]* | [A-Za-z]:[\\/]*) ;; 4652: *) 4653: func_fatal_error "only absolute run-paths are allowed" 4654: ;; 4655: esac 4656: case "$xrpath " in 4657: *" $dir "*) ;; 4658: *) xrpath="$xrpath $dir" ;; 4659: esac 4660: continue 4661: ;; 4662: 4663: -shared) 4664: # The effects of -shared are defined in a previous loop. 4665: continue 4666: ;; 4667: 4668: -shrext) 4669: prev=shrext 4670: continue 4671: ;; 4672: 4673: -static | -static-libtool-libs) 4674: # The effects of -static are defined in a previous loop. 4675: # We used to do the same as -all-static on platforms that 4676: # didn't have a PIC flag, but the assumption that the effects 4677: # would be equivalent was wrong. It would break on at least 4678: # Digital Unix and AIX. 4679: continue 4680: ;; 4681: 4682: -thread-safe) 4683: thread_safe=yes 4684: continue 4685: ;; 4686: 4687: -version-info) 4688: prev=vinfo 4689: continue 4690: ;; 4691: 4692: -version-number) 4693: prev=vinfo 4694: vinfo_number=yes 4695: continue 4696: ;; 4697: 4698: -weak) 4699: prev=weak 4700: continue 4701: ;; 4702: 4703: -Wc,*) 4704: func_stripname '-Wc,' '' "$arg" 4705: args=$func_stripname_result 4706: arg= 4707: save_ifs="$IFS"; IFS=',' 4708: for flag in $args; do 4709: IFS="$save_ifs" 4710: func_quote_for_eval "$flag" 4711: arg="$arg $wl$func_quote_for_eval_result" 4712: compiler_flags="$compiler_flags $func_quote_for_eval_result" 4713: done 4714: IFS="$save_ifs" 4715: func_stripname ' ' '' "$arg" 4716: arg=$func_stripname_result 4717: ;; 4718: 4719: -Wl,*) 4720: func_stripname '-Wl,' '' "$arg" 4721: args=$func_stripname_result 4722: arg= 4723: save_ifs="$IFS"; IFS=',' 4724: for flag in $args; do 4725: IFS="$save_ifs" 4726: func_quote_for_eval "$flag" 4727: arg="$arg $wl$func_quote_for_eval_result" 4728: compiler_flags="$compiler_flags $wl$func_quote_for_eval_result" 4729: linker_flags="$linker_flags $func_quote_for_eval_result" 4730: done 4731: IFS="$save_ifs" 4732: func_stripname ' ' '' "$arg" 4733: arg=$func_stripname_result 4734: ;; 4735: 4736: -Xcompiler) 4737: prev=xcompiler 4738: continue 4739: ;; 4740: 4741: -Xlinker) 4742: prev=xlinker 4743: continue 4744: ;; 4745: 4746: -XCClinker) 4747: prev=xcclinker 4748: continue 4749: ;; 4750: 4751: # -msg_* for osf cc 4752: -msg_*) 4753: func_quote_for_eval "$arg" 4754: arg="$func_quote_for_eval_result" 4755: ;; 4756: 4757: # -64, -mips[0-9] enable 64-bit mode on the SGI compiler 4758: # -r[0-9][0-9]* specifies the processor on the SGI compiler 4759: # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler 4760: # +DA*, +DD* enable 64-bit mode on the HP compiler 4761: # -q* pass through compiler args for the IBM compiler 4762: # -m*, -t[45]*, -txscale* pass through architecture-specific 4763: # compiler args for GCC 4764: # -F/path gives path to uninstalled frameworks, gcc on darwin 4765: # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC 4766: # @file GCC response files 4767: -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ 4768: -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*) 4769: func_quote_for_eval "$arg" 4770: arg="$func_quote_for_eval_result" 4771: func_append compile_command " $arg" 4772: func_append finalize_command " $arg" 4773: compiler_flags="$compiler_flags $arg" 4774: continue 4775: ;; 4776: 4777: # Some other compiler flag. 4778: -* | +*) 4779: func_quote_for_eval "$arg" 4780: arg="$func_quote_for_eval_result" 4781: ;; 4782: 4783: *.$objext) 4784: # A standard object. 4785: objs="$objs $arg" 4786: ;; 4787: 4788: *.lo) 4789: # A libtool-controlled object. 4790: 4791: # Check to see that this really is a libtool object. 4792: if func_lalib_unsafe_p "$arg"; then 4793: pic_object= 4794: non_pic_object= 4795: 4796: # Read the .lo file 4797: func_source "$arg" 4798: 4799: if test -z "$pic_object" || 4800: test -z "$non_pic_object" || 4801: test "$pic_object" = none && 4802: test "$non_pic_object" = none; then 4803: func_fatal_error "cannot find name of object for \`$arg'" 4804: fi 4805: 4806: # Extract subdirectory from the argument. 4807: func_dirname "$arg" "/" "" 4808: xdir="$func_dirname_result" 4809: 4810: if test "$pic_object" != none; then 4811: # Prepend the subdirectory the object is found in. 4812: pic_object="$xdir$pic_object" 4813: 4814: if test "$prev" = dlfiles; then 4815: if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then 4816: dlfiles="$dlfiles $pic_object" 4817: prev= 4818: continue 4819: else 4820: # If libtool objects are unsupported, then we need to preload. 4821: prev=dlprefiles 4822: fi 4823: fi 4824: 4825: # CHECK ME: I think I busted this. -Ossama 4826: if test "$prev" = dlprefiles; then 4827: # Preload the old-style object. 4828: dlprefiles="$dlprefiles $pic_object" 4829: prev= 4830: fi 4831: 4832: # A PIC object. 4833: func_append libobjs " $pic_object" 4834: arg="$pic_object" 4835: fi 4836: 4837: # Non-PIC object. 4838: if test "$non_pic_object" != none; then 4839: # Prepend the subdirectory the object is found in. 4840: non_pic_object="$xdir$non_pic_object" 4841: 4842: # A standard non-PIC object 4843: func_append non_pic_objects " $non_pic_object" 4844: if test -z "$pic_object" || test "$pic_object" = none ; then 4845: arg="$non_pic_object" 4846: fi 4847: else 4848: # If the PIC object exists, use it instead. 4849: # $xdir was prepended to $pic_object above. 4850: non_pic_object="$pic_object" 4851: func_append non_pic_objects " $non_pic_object" 4852: fi 4853: else 4854: # Only an error if not doing a dry-run. 4855: if $opt_dry_run; then 4856: # Extract subdirectory from the argument. 4857: func_dirname "$arg" "/" "" 4858: xdir="$func_dirname_result" 4859: 4860: func_lo2o "$arg" 4861: pic_object=$xdir$objdir/$func_lo2o_result 4862: non_pic_object=$xdir$func_lo2o_result 4863: func_append libobjs " $pic_object" 4864: func_append non_pic_objects " $non_pic_object" 4865: else 4866: func_fatal_error "\`$arg' is not a valid libtool object" 4867: fi 4868: fi 4869: ;; 4870: 4871: *.$libext) 4872: # An archive. 4873: deplibs="$deplibs $arg" 4874: old_deplibs="$old_deplibs $arg" 4875: continue 4876: ;; 4877: 4878: *.la) 4879: # A libtool-controlled library. 4880: 4881: if test "$prev" = dlfiles; then 4882: # This library was specified with -dlopen. 4883: dlfiles="$dlfiles $arg" 4884: prev= 4885: elif test "$prev" = dlprefiles; then 4886: # The library was specified with -dlpreopen. 4887: dlprefiles="$dlprefiles $arg" 4888: prev= 4889: else 4890: deplibs="$deplibs $arg" 4891: fi 4892: continue 4893: ;; 4894: 4895: # Some other compiler argument. 4896: *) 4897: # Unknown arguments in both finalize_command and compile_command need 4898: # to be aesthetically quoted because they are evaled later. 4899: func_quote_for_eval "$arg" 4900: arg="$func_quote_for_eval_result" 4901: ;; 4902: esac # arg 4903: 4904: # Now actually substitute the argument into the commands. 4905: if test -n "$arg"; then 4906: func_append compile_command " $arg" 4907: func_append finalize_command " $arg" 4908: fi 4909: done # argument parsing loop 4910: 4911: test -n "$prev" && \ 4912: func_fatal_help "the \`$prevarg' option requires an argument" 4913: 4914: if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then 4915: eval arg=\"$export_dynamic_flag_spec\" 4916: func_append compile_command " $arg" 4917: func_append finalize_command " $arg" 4918: fi 4919: 4920: oldlibs= 4921: # calculate the name of the file, without its directory 4922: func_basename "$output" 4923: outputname="$func_basename_result" 4924: libobjs_save="$libobjs" 4925: 4926: if test -n "$shlibpath_var"; then 4927: # get the directories listed in $shlibpath_var 4928: eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\` 4929: else 4930: shlib_search_path= 4931: fi 4932: eval sys_lib_search_path=\"$sys_lib_search_path_spec\" 4933: eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" 4934: 4935: func_dirname "$output" "/" "" 4936: output_objdir="$func_dirname_result$objdir" 4937: # Create the object directory. 4938: func_mkdir_p "$output_objdir" 4939: 4940: # Determine the type of output 4941: case $output in 4942: "") 4943: func_fatal_help "you must specify an output file" 4944: ;; 4945: *.$libext) linkmode=oldlib ;; 4946: *.lo | *.$objext) linkmode=obj ;; 4947: *.la) linkmode=lib ;; 4948: *) linkmode=prog ;; # Anything else should be a program. 4949: esac 4950: 4951: specialdeplibs= 4952: 4953: libs= 4954: # Find all interdependent deplibs by searching for libraries 4955: # that are linked more than once (e.g. -la -lb -la) 4956: for deplib in $deplibs; do 4957: if $opt_duplicate_deps ; then 4958: case "$libs " in 4959: *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 4960: esac 4961: fi 4962: libs="$libs $deplib" 4963: done 4964: 4965: if test "$linkmode" = lib; then 4966: libs="$predeps $libs $compiler_lib_search_path $postdeps" 4967: 4968: # Compute libraries that are listed more than once in $predeps 4969: # $postdeps and mark them as special (i.e., whose duplicates are 4970: # not to be eliminated). 4971: pre_post_deps= 4972: if $opt_duplicate_compiler_generated_deps; then 4973: for pre_post_dep in $predeps $postdeps; do 4974: case "$pre_post_deps " in 4975: *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;; 4976: esac 4977: pre_post_deps="$pre_post_deps $pre_post_dep" 4978: done 4979: fi 4980: pre_post_deps= 4981: fi 4982: 4983: deplibs= 4984: newdependency_libs= 4985: newlib_search_path= 4986: need_relink=no # whether we're linking any uninstalled libtool libraries 4987: notinst_deplibs= # not-installed libtool libraries 4988: notinst_path= # paths that contain not-installed libtool libraries 4989: 4990: case $linkmode in 4991: lib) 4992: passes="conv dlpreopen link" 4993: for file in $dlfiles $dlprefiles; do 4994: case $file in 4995: *.la) ;; 4996: *) 4997: func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" 4998: ;; 4999: esac 5000: done 5001: ;; 5002: prog) 5003: compile_deplibs= 5004: finalize_deplibs= 5005: alldeplibs=no 5006: newdlfiles= 5007: newdlprefiles= 5008: passes="conv scan dlopen dlpreopen link" 5009: ;; 5010: *) passes="conv" 5011: ;; 5012: esac 5013: 5014: for pass in $passes; do 5015: # The preopen pass in lib mode reverses $deplibs; put it back here 5016: # so that -L comes before libs that need it for instance... 5017: if test "$linkmode,$pass" = "lib,link"; then 5018: ## FIXME: Find the place where the list is rebuilt in the wrong 5019: ## order, and fix it there properly 5020: tmp_deplibs= 5021: for deplib in $deplibs; do 5022: tmp_deplibs="$deplib $tmp_deplibs" 5023: done 5024: deplibs="$tmp_deplibs" 5025: fi 5026: 5027: if test "$linkmode,$pass" = "lib,link" || 5028: test "$linkmode,$pass" = "prog,scan"; then 5029: libs="$deplibs" 5030: deplibs= 5031: fi 5032: if test "$linkmode" = prog; then 5033: case $pass in 5034: dlopen) libs="$dlfiles" ;; 5035: dlpreopen) libs="$dlprefiles" ;; 5036: link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; 5037: esac 5038: fi 5039: if test "$linkmode,$pass" = "lib,dlpreopen"; then 5040: # Collect and forward deplibs of preopened libtool libs 5041: for lib in $dlprefiles; do 5042: # Ignore non-libtool-libs 5043: dependency_libs= 5044: case $lib in 5045: *.la) func_source "$lib" ;; 5046: esac 5047: 5048: # Collect preopened libtool deplibs, except any this library 5049: # has declared as weak libs 5050: for deplib in $dependency_libs; do 5051: deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"` 5052: case " $weak_libs " in 5053: *" $deplib_base "*) ;; 5054: *) deplibs="$deplibs $deplib" ;; 5055: esac 5056: done 5057: done 5058: libs="$dlprefiles" 5059: fi 5060: if test "$pass" = dlopen; then 5061: # Collect dlpreopened libraries 5062: save_deplibs="$deplibs" 5063: deplibs= 5064: fi 5065: 5066: for deplib in $libs; do 5067: lib= 5068: found=no 5069: case $deplib in 5070: -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads) 5071: if test "$linkmode,$pass" = "prog,link"; then 5072: compile_deplibs="$deplib $compile_deplibs" 5073: finalize_deplibs="$deplib $finalize_deplibs" 5074: else 5075: compiler_flags="$compiler_flags $deplib" 5076: if test "$linkmode" = lib ; then 5077: case "$new_inherited_linker_flags " in 5078: *" $deplib "*) ;; 5079: * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;; 5080: esac 5081: fi 5082: fi 5083: continue 5084: ;; 5085: -l*) 5086: if test "$linkmode" != lib && test "$linkmode" != prog; then 5087: func_warning "\`-l' is ignored for archives/objects" 5088: continue 5089: fi 5090: func_stripname '-l' '' "$deplib" 5091: name=$func_stripname_result 5092: if test "$linkmode" = lib; then 5093: searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" 5094: else 5095: searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" 5096: fi 5097: for searchdir in $searchdirs; do 5098: for search_ext in .la $std_shrext .so .a; do 5099: # Search the libtool library 5100: lib="$searchdir/lib${name}${search_ext}" 5101: if test -f "$lib"; then 5102: if test "$search_ext" = ".la"; then 5103: found=yes 5104: else 5105: found=no 5106: fi 5107: break 2 5108: fi 5109: done 5110: done 5111: if test "$found" != yes; then 5112: # deplib doesn't seem to be a libtool library 5113: if test "$linkmode,$pass" = "prog,link"; then 5114: compile_deplibs="$deplib $compile_deplibs" 5115: finalize_deplibs="$deplib $finalize_deplibs" 5116: else 5117: deplibs="$deplib $deplibs" 5118: test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 5119: fi 5120: continue 5121: else # deplib is a libtool library 5122: # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, 5123: # We need to do some special things here, and not later. 5124: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 5125: case " $predeps $postdeps " in 5126: *" $deplib "*) 5127: if func_lalib_p "$lib"; then 5128: library_names= 5129: old_library= 5130: func_source "$lib" 5131: for l in $old_library $library_names; do 5132: ll="$l" 5133: done 5134: if test "X$ll" = "X$old_library" ; then # only static version available 5135: found=no 5136: func_dirname "$lib" "" "." 5137: ladir="$func_dirname_result" 5138: lib=$ladir/$old_library 5139: if test "$linkmode,$pass" = "prog,link"; then 5140: compile_deplibs="$deplib $compile_deplibs" 5141: finalize_deplibs="$deplib $finalize_deplibs" 5142: else 5143: deplibs="$deplib $deplibs" 5144: test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" 5145: fi 5146: continue 5147: fi 5148: fi 5149: ;; 5150: *) ;; 5151: esac 5152: fi 5153: fi 5154: ;; # -l 5155: *.ltframework) 5156: if test "$linkmode,$pass" = "prog,link"; then 5157: compile_deplibs="$deplib $compile_deplibs" 5158: finalize_deplibs="$deplib $finalize_deplibs" 5159: else 5160: deplibs="$deplib $deplibs" 5161: if test "$linkmode" = lib ; then 5162: case "$new_inherited_linker_flags " in 5163: *" $deplib "*) ;; 5164: * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;; 5165: esac 5166: fi 5167: fi 5168: continue 5169: ;; 5170: -L*) 5171: case $linkmode in 5172: lib) 5173: deplibs="$deplib $deplibs" 5174: test "$pass" = conv && continue 5175: newdependency_libs="$deplib $newdependency_libs" 5176: func_stripname '-L' '' "$deplib" 5177: newlib_search_path="$newlib_search_path $func_stripname_result" 5178: ;; 5179: prog) 5180: if test "$pass" = conv; then 5181: deplibs="$deplib $deplibs" 5182: continue 5183: fi 5184: if test "$pass" = scan; then 5185: deplibs="$deplib $deplibs" 5186: else 5187: compile_deplibs="$deplib $compile_deplibs" 5188: finalize_deplibs="$deplib $finalize_deplibs" 5189: fi 5190: func_stripname '-L' '' "$deplib" 5191: newlib_search_path="$newlib_search_path $func_stripname_result" 5192: ;; 5193: *) 5194: func_warning "\`-L' is ignored for archives/objects" 5195: ;; 5196: esac # linkmode 5197: continue 5198: ;; # -L 5199: -R*) 5200: if test "$pass" = link; then 5201: func_stripname '-R' '' "$deplib" 5202: dir=$func_stripname_result 5203: # Make sure the xrpath contains only unique directories. 5204: case "$xrpath " in 5205: *" $dir "*) ;; 5206: *) xrpath="$xrpath $dir" ;; 5207: esac 5208: fi 5209: deplibs="$deplib $deplibs" 5210: continue 5211: ;; 5212: *.la) lib="$deplib" ;; 5213: *.$libext) 5214: if test "$pass" = conv; then 5215: deplibs="$deplib $deplibs" 5216: continue 5217: fi 5218: case $linkmode in 5219: lib) 5220: # Linking convenience modules into shared libraries is allowed, 5221: # but linking other static libraries is non-portable. 5222: case " $dlpreconveniencelibs " in 5223: *" $deplib "*) ;; 5224: *) 5225: valid_a_lib=no 5226: case $deplibs_check_method in 5227: match_pattern*) 5228: set dummy $deplibs_check_method; shift 5229: match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"` 5230: if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \ 5231: | $EGREP "$match_pattern_regex" > /dev/null; then 5232: valid_a_lib=yes 5233: fi 5234: ;; 5235: pass_all) 5236: valid_a_lib=yes 5237: ;; 5238: esac 5239: if test "$valid_a_lib" != yes; then 5240: $ECHO 5241: $ECHO "*** Warning: Trying to link with static lib archive $deplib." 5242: $ECHO "*** I have the capability to make that library automatically link in when" 5243: $ECHO "*** you link to this library. But I can only do this if you have a" 5244: $ECHO "*** shared version of the library, which you do not appear to have" 5245: $ECHO "*** because the file extensions .$libext of this argument makes me believe" 5246: $ECHO "*** that it is just a static archive that I should not use here." 5247: else 5248: $ECHO 5249: $ECHO "*** Warning: Linking the shared library $output against the" 5250: $ECHO "*** static library $deplib is not portable!" 5251: deplibs="$deplib $deplibs" 5252: fi 5253: ;; 5254: esac 5255: continue 5256: ;; 5257: prog) 5258: if test "$pass" != link; then 5259: deplibs="$deplib $deplibs" 5260: else 5261: compile_deplibs="$deplib $compile_deplibs" 5262: finalize_deplibs="$deplib $finalize_deplibs" 5263: fi 5264: continue 5265: ;; 5266: esac # linkmode 5267: ;; # *.$libext 5268: *.lo | *.$objext) 5269: if test "$pass" = conv; then 5270: deplibs="$deplib $deplibs" 5271: elif test "$linkmode" = prog; then 5272: if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then 5273: # If there is no dlopen support or we're linking statically, 5274: # we need to preload. 5275: newdlprefiles="$newdlprefiles $deplib" 5276: compile_deplibs="$deplib $compile_deplibs" 5277: finalize_deplibs="$deplib $finalize_deplibs" 5278: else 5279: newdlfiles="$newdlfiles $deplib" 5280: fi 5281: fi 5282: continue 5283: ;; 5284: %DEPLIBS%) 5285: alldeplibs=yes 5286: continue 5287: ;; 5288: esac # case $deplib 5289: 5290: if test "$found" = yes || test -f "$lib"; then : 5291: else 5292: func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" 5293: fi 5294: 5295: # Check to see that this really is a libtool archive. 5296: func_lalib_unsafe_p "$lib" \ 5297: || func_fatal_error "\`$lib' is not a valid libtool archive" 5298: 5299: func_dirname "$lib" "" "." 5300: ladir="$func_dirname_result" 5301: 5302: dlname= 5303: dlopen= 5304: dlpreopen= 5305: libdir= 5306: library_names= 5307: old_library= 5308: inherited_linker_flags= 5309: # If the library was installed with an old release of libtool, 5310: # it will not redefine variables installed, or shouldnotlink 5311: installed=yes 5312: shouldnotlink=no 5313: avoidtemprpath= 5314: 5315: 5316: # Read the .la file 5317: func_source "$lib" 5318: 5319: # Convert "-framework foo" to "foo.ltframework" 5320: if test -n "$inherited_linker_flags"; then 5321: tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework $[^ $]*$/\1.ltframework/g'` 5322: for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do 5323: case " $new_inherited_linker_flags " in 5324: *" $tmp_inherited_linker_flag "*) ;; 5325: *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";; 5326: esac 5327: done 5328: fi 5329: dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 5330: if test "$linkmode,$pass" = "lib,link" || 5331: test "$linkmode,$pass" = "prog,scan" || 5332: { test "$linkmode" != prog && test "$linkmode" != lib; }; then 5333: test -n "$dlopen" && dlfiles="$dlfiles $dlopen" 5334: test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen" 5335: fi 5336: 5337: if test "$pass" = conv; then 5338: # Only check for convenience libraries 5339: deplibs="$lib $deplibs" 5340: if test -z "$libdir"; then 5341: if test -z "$old_library"; then 5342: func_fatal_error "cannot find name of link library for \`$lib'" 5343: fi 5344: # It is a libtool convenience library, so add in its objects. 5345: convenience="$convenience $ladir/$objdir/$old_library" 5346: old_convenience="$old_convenience $ladir/$objdir/$old_library" 5347: elif test "$linkmode" != prog && test "$linkmode" != lib; then 5348: func_fatal_error "\`$lib' is not a convenience library" 5349: fi 5350: tmp_libs= 5351: for deplib in $dependency_libs; do 5352: deplibs="$deplib $deplibs" 5353: if $opt_duplicate_deps ; then 5354: case "$tmp_libs " in 5355: *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 5356: esac 5357: fi 5358: tmp_libs="$tmp_libs $deplib" 5359: done 5360: continue 5361: fi # $pass = conv 5362: 5363: 5364: # Get the name of the library we link against. 5365: linklib= 5366: for l in $old_library $library_names; do 5367: linklib="$l" 5368: done 5369: if test -z "$linklib"; then 5370: func_fatal_error "cannot find name of link library for \`$lib'" 5371: fi 5372: 5373: # This library was specified with -dlopen. 5374: if test "$pass" = dlopen; then 5375: if test -z "$libdir"; then 5376: func_fatal_error "cannot -dlopen a convenience library: \`$lib'" 5377: fi 5378: if test -z "$dlname" || 5379: test "$dlopen_support" != yes || 5380: test "$build_libtool_libs" = no; then 5381: # If there is no dlname, no dlopen support or we're linking 5382: # statically, we need to preload. We also need to preload any 5383: # dependent libraries so libltdl's deplib preloader doesn't 5384: # bomb out in the load deplibs phase. 5385: dlprefiles="$dlprefiles $lib $dependency_libs" 5386: else 5387: newdlfiles="$newdlfiles $lib" 5388: fi 5389: continue 5390: fi # $pass = dlopen 5391: 5392: # We need an absolute path. 5393: case $ladir in 5394: [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; 5395: *) 5396: abs_ladir=`cd "$ladir" && pwd` 5397: if test -z "$abs_ladir"; then 5398: func_warning "cannot determine absolute directory name of \`$ladir'" 5399: func_warning "passing it literally to the linker, although it might fail" 5400: abs_ladir="$ladir" 5401: fi 5402: ;; 5403: esac 5404: func_basename "$lib" 5405: laname="$func_basename_result" 5406: 5407: # Find the relevant object directory and library name. 5408: if test "X$installed" = Xyes; then 5409: if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then 5410: func_warning "library \`$lib' was moved." 5411: dir="$ladir" 5412: absdir="$abs_ladir" 5413: libdir="$abs_ladir" 5414: else 5415: dir="$libdir" 5416: absdir="$libdir" 5417: fi 5418: test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes 5419: else 5420: if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then 5421: dir="$ladir" 5422: absdir="$abs_ladir" 5423: # Remove this search path later 5424: notinst_path="$notinst_path $abs_ladir" 5425: else 5426: dir="$ladir/$objdir" 5427: absdir="$abs_ladir/$objdir" 5428: # Remove this search path later 5429: notinst_path="$notinst_path $abs_ladir" 5430: fi 5431: fi # $installed = yes 5432: func_stripname 'lib' '.la' "$laname" 5433: name=$func_stripname_result 5434: 5435: # This library was specified with -dlpreopen. 5436: if test "$pass" = dlpreopen; then 5437: if test -z "$libdir" && test "$linkmode" = prog; then 5438: func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" 5439: fi 5440: # Prefer using a static library (so that no silly _DYNAMIC symbols 5441: # are required to link). 5442: if test -n "$old_library"; then 5443: newdlprefiles="$newdlprefiles $dir/$old_library" 5444: # Keep a list of preopened convenience libraries to check 5445: # that they are being used correctly in the link pass. 5446: test -z "$libdir" && \ 5447: dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library" 5448: # Otherwise, use the dlname, so that lt_dlopen finds it. 5449: elif test -n "$dlname"; then 5450: newdlprefiles="$newdlprefiles $dir/$dlname" 5451: else 5452: newdlprefiles="$newdlprefiles $dir/$linklib" 5453: fi 5454: fi # $pass = dlpreopen 5455: 5456: if test -z "$libdir"; then 5457: # Link the convenience library 5458: if test "$linkmode" = lib; then 5459: deplibs="$dir/$old_library $deplibs" 5460: elif test "$linkmode,$pass" = "prog,link"; then 5461: compile_deplibs="$dir/$old_library $compile_deplibs" 5462: finalize_deplibs="$dir/$old_library $finalize_deplibs" 5463: else 5464: deplibs="$lib $deplibs" # used for prog,scan pass 5465: fi 5466: continue 5467: fi 5468: 5469: 5470: if test "$linkmode" = prog && test "$pass" != link; then 5471: newlib_search_path="$newlib_search_path $ladir" 5472: deplibs="$lib $deplibs" 5473: 5474: linkalldeplibs=no 5475: if test "$link_all_deplibs" != no || test -z "$library_names" || 5476: test "$build_libtool_libs" = no; then 5477: linkalldeplibs=yes 5478: fi 5479: 5480: tmp_libs= 5481: for deplib in $dependency_libs; do 5482: case $deplib in 5483: -L*) func_stripname '-L' '' "$deplib" 5484: newlib_search_path="$newlib_search_path $func_stripname_result" 5485: ;; 5486: esac 5487: # Need to link against all dependency_libs? 5488: if test "$linkalldeplibs" = yes; then 5489: deplibs="$deplib $deplibs" 5490: else 5491: # Need to hardcode shared library paths 5492: # or/and link against static libraries 5493: newdependency_libs="$deplib $newdependency_libs" 5494: fi 5495: if $opt_duplicate_deps ; then 5496: case "$tmp_libs " in 5497: *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 5498: esac 5499: fi 5500: tmp_libs="$tmp_libs $deplib" 5501: done # for deplib 5502: continue 5503: fi # $linkmode = prog... 5504: 5505: if test "$linkmode,$pass" = "prog,link"; then 5506: if test -n "$library_names" && 5507: { { test "$prefer_static_libs" = no || 5508: test "$prefer_static_libs,$installed" = "built,yes"; } || 5509: test -z "$old_library"; }; then 5510: # We need to hardcode the library path 5511: if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then 5512: # Make sure the rpath contains only unique directories. 5513: case "$temp_rpath:" in 5514: *"$absdir:"*) ;; 5515: *) temp_rpath="$temp_rpath$absdir:" ;; 5516: esac 5517: fi 5518: 5519: # Hardcode the library path. 5520: # Skip directories that are in the system default run-time 5521: # search path. 5522: case " $sys_lib_dlsearch_path " in 5523: *" $absdir "*) ;; 5524: *) 5525: case "$compile_rpath " in 5526: *" $absdir "*) ;; 5527: *) compile_rpath="$compile_rpath $absdir" 5528: esac 5529: ;; 5530: esac 5531: case " $sys_lib_dlsearch_path " in 5532: *" $libdir "*) ;; 5533: *) 5534: case "$finalize_rpath " in 5535: *" $libdir "*) ;; 5536: *) finalize_rpath="$finalize_rpath $libdir" 5537: esac 5538: ;; 5539: esac 5540: fi # $linkmode,$pass = prog,link... 5541: 5542: if test "$alldeplibs" = yes && 5543: { test "$deplibs_check_method" = pass_all || 5544: { test "$build_libtool_libs" = yes && 5545: test -n "$library_names"; }; }; then 5546: # We only need to search for static libraries 5547: continue 5548: fi 5549: fi 5550: 5551: link_static=no # Whether the deplib will be linked statically 5552: use_static_libs=$prefer_static_libs 5553: if test "$use_static_libs" = built && test "$installed" = yes; then 5554: use_static_libs=no 5555: fi 5556: if test -n "$library_names" && 5557: { test "$use_static_libs" = no || test -z "$old_library"; }; then 5558: case $host in 5559: *cygwin* | *mingw* | *cegcc*) 5560: # No point in relinking DLLs because paths are not encoded 5561: notinst_deplibs="$notinst_deplibs $lib" 5562: need_relink=no 5563: ;; 5564: *) 5565: if test "$installed" = no; then 5566: notinst_deplibs="$notinst_deplibs $lib" 5567: need_relink=yes 5568: fi 5569: ;; 5570: esac 5571: # This is a shared library 5572: 5573: # Warn about portability, can't link against -module's on some 5574: # systems (darwin). Don't bleat about dlopened modules though! 5575: dlopenmodule="" 5576: for dlpremoduletest in $dlprefiles; do 5577: if test "X$dlpremoduletest" = "X$lib"; then 5578: dlopenmodule="$dlpremoduletest" 5579: break 5580: fi 5581: done 5582: if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then 5583: $ECHO 5584: if test "$linkmode" = prog; then 5585: $ECHO "*** Warning: Linking the executable $output against the loadable module" 5586: else 5587: $ECHO "*** Warning: Linking the shared library $output against the loadable module" 5588: fi 5589: $ECHO "*** $linklib is not portable!" 5590: fi 5591: if test "$linkmode" = lib && 5592: test "$hardcode_into_libs" = yes; then 5593: # Hardcode the library path. 5594: # Skip directories that are in the system default run-time 5595: # search path. 5596: case " $sys_lib_dlsearch_path " in 5597: *" $absdir "*) ;; 5598: *) 5599: case "$compile_rpath " in 5600: *" $absdir "*) ;; 5601: *) compile_rpath="$compile_rpath $absdir" 5602: esac 5603: ;; 5604: esac 5605: case " $sys_lib_dlsearch_path " in 5606: *" $libdir "*) ;; 5607: *) 5608: case "$finalize_rpath " in 5609: *" $libdir "*) ;; 5610: *) finalize_rpath="$finalize_rpath $libdir" 5611: esac 5612: ;; 5613: esac 5614: fi 5615: 5616: if test -n "$old_archive_from_expsyms_cmds"; then 5617: # figure out the soname 5618: set dummy $library_names 5619: shift 5620: realname="$1" 5621: shift 5622: libname=`eval "\\$ECHO \"$libname_spec\""` 5623: # use dlname if we got it. it's perfectly good, no? 5624: if test -n "$dlname"; then 5625: soname="$dlname" 5626: elif test -n "$soname_spec"; then 5627: # bleh windows 5628: case $host in 5629: *cygwin* | mingw* | *cegcc*) 5630: func_arith $current - $age 5631: major=$func_arith_result 5632: versuffix="-$major" 5633: ;; 5634: esac 5635: eval soname=\"$soname_spec\" 5636: else 5637: soname="$realname" 5638: fi 5639: 5640: # Make a new name for the extract_expsyms_cmds to use 5641: soroot="$soname" 5642: func_basename "$soroot" 5643: soname="$func_basename_result" 5644: func_stripname 'lib' '.dll' "$soname" 5645: newlib=libimp-$func_stripname_result.a 5646: 5647: # If the library has no export list, then create one now 5648: if test -f "$output_objdir/$soname-def"; then : 5649: else 5650: func_verbose "extracting exported symbol list from \`$soname'" 5651: func_execute_cmds "$extract_expsyms_cmds" 'exit $?' 5652: fi 5653: 5654: # Create $newlib 5655: if test -f "$output_objdir/$newlib"; then :; else 5656: func_verbose "generating import library for \`$soname'" 5657: func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' 5658: fi 5659: # make sure the library variables are pointing to the new library 5660: dir=$output_objdir 5661: linklib=$newlib 5662: fi # test -n "$old_archive_from_expsyms_cmds" 5663: 5664: if test "$linkmode" = prog || test "$mode" != relink; then 5665: add_shlibpath= 5666: add_dir= 5667: add= 5668: lib_linked=yes 5669: case $hardcode_action in 5670: immediate | unsupported) 5671: if test "$hardcode_direct" = no; then 5672: add="$dir/$linklib" 5673: case $host in 5674: *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; 5675: *-*-sysv4*uw2*) add_dir="-L$dir" ;; 5676: *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ 5677: *-*-unixware7*) add_dir="-L$dir" ;; 5678: *-*-darwin* ) 5679: # if the lib is a (non-dlopened) module then we can not 5680: # link against it, someone is ignoring the earlier warnings 5681: if /usr/bin/file -L $add 2> /dev/null | 5682: $GREP ": [^:]* bundle" >/dev/null ; then 5683: if test "X$dlopenmodule" != "X$lib"; then 5684: $ECHO "*** Warning: lib $linklib is a module, not a shared library" 5685: if test -z "$old_library" ; then 5686: $ECHO 5687: $ECHO "*** And there doesn't seem to be a static archive available" 5688: $ECHO "*** The link will probably fail, sorry" 5689: else 5690: add="$dir/$old_library" 5691: fi 5692: elif test -n "$old_library"; then 5693: add="$dir/$old_library" 5694: fi 5695: fi 5696: esac 5697: elif test "$hardcode_minus_L" = no; then 5698: case $host in 5699: *-*-sunos*) add_shlibpath="$dir" ;; 5700: esac 5701: add_dir="-L$dir" 5702: add="-l$name" 5703: elif test "$hardcode_shlibpath_var" = no; then 5704: add_shlibpath="$dir" 5705: add="-l$name" 5706: else 5707: lib_linked=no 5708: fi 5709: ;; 5710: relink) 5711: if test "$hardcode_direct" = yes && 5712: test "$hardcode_direct_absolute" = no; then 5713: add="$dir/$linklib" 5714: elif test "$hardcode_minus_L" = yes; then 5715: add_dir="-L$dir" 5716: # Try looking first in the location we're being installed to. 5717: if test -n "$inst_prefix_dir"; then 5718: case $libdir in 5719: [\\/]*) 5720: add_dir="$add_dir -L$inst_prefix_dir$libdir" 5721: ;; 5722: esac 5723: fi 5724: add="-l$name" 5725: elif test "$hardcode_shlibpath_var" = yes; then 5726: add_shlibpath="$dir" 5727: add="-l$name" 5728: else 5729: lib_linked=no 5730: fi 5731: ;; 5732: *) lib_linked=no ;; 5733: esac 5734: 5735: if test "$lib_linked" != yes; then 5736: func_fatal_configuration "unsupported hardcode properties" 5737: fi 5738: 5739: if test -n "$add_shlibpath"; then 5740: case :$compile_shlibpath: in 5741: *":$add_shlibpath:"*) ;; 5742: *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;; 5743: esac 5744: fi 5745: if test "$linkmode" = prog; then 5746: test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" 5747: test -n "$add" && compile_deplibs="$add $compile_deplibs" 5748: else 5749: test -n "$add_dir" && deplibs="$add_dir $deplibs" 5750: test -n "$add" && deplibs="$add $deplibs" 5751: if test "$hardcode_direct" != yes && 5752: test "$hardcode_minus_L" != yes && 5753: test "$hardcode_shlibpath_var" = yes; then 5754: case :$finalize_shlibpath: in 5755: *":$libdir:"*) ;; 5756: *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; 5757: esac 5758: fi 5759: fi 5760: fi 5761: 5762: if test "$linkmode" = prog || test "$mode" = relink; then 5763: add_shlibpath= 5764: add_dir= 5765: add= 5766: # Finalize command for both is simple: just hardcode it. 5767: if test "$hardcode_direct" = yes && 5768: test "$hardcode_direct_absolute" = no; then 5769: add="$libdir/$linklib" 5770: elif test "$hardcode_minus_L" = yes; then 5771: add_dir="-L$libdir" 5772: add="-l$name" 5773: elif test "$hardcode_shlibpath_var" = yes; then 5774: case :$finalize_shlibpath: in 5775: *":$libdir:"*) ;; 5776: *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; 5777: esac 5778: add="-l$name" 5779: elif test "$hardcode_automatic" = yes; then 5780: if test -n "$inst_prefix_dir" && 5781: test -f "$inst_prefix_dir$libdir/$linklib" ; then 5782: add="$inst_prefix_dir$libdir/$linklib" 5783: else 5784: add="$libdir/$linklib" 5785: fi 5786: else 5787: # We cannot seem to hardcode it, guess we'll fake it. 5788: add_dir="-L$libdir" 5789: # Try looking first in the location we're being installed to. 5790: if test -n "$inst_prefix_dir"; then 5791: case $libdir in 5792: [\\/]*) 5793: add_dir="$add_dir -L$inst_prefix_dir$libdir" 5794: ;; 5795: esac 5796: fi 5797: add="-l$name" 5798: fi 5799: 5800: if test "$linkmode" = prog; then 5801: test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" 5802: test -n "$add" && finalize_deplibs="$add $finalize_deplibs" 5803: else 5804: test -n "$add_dir" && deplibs="$add_dir $deplibs" 5805: test -n "$add" && deplibs="$add $deplibs" 5806: fi 5807: fi 5808: elif test "$linkmode" = prog; then 5809: # Here we assume that one of hardcode_direct or hardcode_minus_L 5810: # is not unsupported. This is valid on all known static and 5811: # shared platforms. 5812: if test "$hardcode_direct" != unsupported; then 5813: test -n "$old_library" && linklib="$old_library" 5814: compile_deplibs="$dir/$linklib $compile_deplibs" 5815: finalize_deplibs="$dir/$linklib $finalize_deplibs" 5816: else 5817: compile_deplibs="-l$name -L$dir $compile_deplibs" 5818: finalize_deplibs="-l$name -L$dir $finalize_deplibs" 5819: fi 5820: elif test "$build_libtool_libs" = yes; then 5821: # Not a shared library 5822: if test "$deplibs_check_method" != pass_all; then 5823: # We're trying link a shared library against a static one 5824: # but the system doesn't support it. 5825: 5826: # Just print a warning and add the library to dependency_libs so 5827: # that the program can be linked against the static library. 5828: $ECHO 5829: $ECHO "*** Warning: This system can not link to static lib archive $lib." 5830: $ECHO "*** I have the capability to make that library automatically link in when" 5831: $ECHO "*** you link to this library. But I can only do this if you have a" 5832: $ECHO "*** shared version of the library, which you do not appear to have." 5833: if test "$module" = yes; then 5834: $ECHO "*** But as you try to build a module library, libtool will still create " 5835: $ECHO "*** a static module, that should work as long as the dlopening application" 5836: $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime." 5837: if test -z "$global_symbol_pipe"; then 5838: $ECHO 5839: $ECHO "*** However, this would only work if libtool was able to extract symbol" 5840: $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could" 5841: $ECHO "*** not find such a program. So, this module is probably useless." 5842: $ECHO "*** \`nm' from GNU binutils and a full rebuild may help." 5843: fi 5844: if test "$build_old_libs" = no; then 5845: build_libtool_libs=module 5846: build_old_libs=yes 5847: else 5848: build_libtool_libs=no 5849: fi 5850: fi 5851: else 5852: deplibs="$dir/$old_library $deplibs" 5853: link_static=yes 5854: fi 5855: fi # link shared/static library? 5856: 5857: if test "$linkmode" = lib; then 5858: if test -n "$dependency_libs" && 5859: { test "$hardcode_into_libs" != yes || 5860: test "$build_old_libs" = yes || 5861: test "$link_static" = yes; }; then 5862: # Extract -R from dependency_libs 5863: temp_deplibs= 5864: for libdir in $dependency_libs; do 5865: case $libdir in 5866: -R*) func_stripname '-R' '' "$libdir" 5867: temp_xrpath=$func_stripname_result 5868: case " $xrpath " in 5869: *" $temp_xrpath "*) ;; 5870: *) xrpath="$xrpath $temp_xrpath";; 5871: esac;; 5872: *) temp_deplibs="$temp_deplibs $libdir";; 5873: esac 5874: done 5875: dependency_libs="$temp_deplibs" 5876: fi 5877: 5878: newlib_search_path="$newlib_search_path $absdir" 5879: # Link against this library 5880: test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" 5881: # ... and its dependency_libs 5882: tmp_libs= 5883: for deplib in $dependency_libs; do 5884: newdependency_libs="$deplib $newdependency_libs" 5885: if $opt_duplicate_deps ; then 5886: case "$tmp_libs " in 5887: *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; 5888: esac 5889: fi 5890: tmp_libs="$tmp_libs $deplib" 5891: done 5892: 5893: if test "$link_all_deplibs" != no; then 5894: # Add the search paths of all dependency libraries 5895: for deplib in $dependency_libs; do 5896: case $deplib in 5897: -L*) path="$deplib" ;; 5898: *.la) 5899: func_dirname "$deplib" "" "." 5900: dir="$func_dirname_result" 5901: # We need an absolute path. 5902: case $dir in 5903: [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; 5904: *) 5905: absdir=`cd "$dir" && pwd` 5906: if test -z "$absdir"; then 5907: func_warning "cannot determine absolute directory name of \`$dir'" 5908: absdir="$dir" 5909: fi 5910: ;; 5911: esac 5912: if $GREP "^installed=no" $deplib > /dev/null; then 5913: case $host in 5914: *-*-darwin*) 5915: depdepl= 5916: eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib` 5917: if test -n "$deplibrary_names" ; then 5918: for tmp in $deplibrary_names ; do 5919: depdepl=$tmp 5920: done 5921: if test -f "$absdir/$objdir/$depdepl" ; then 5922: depdepl="$absdir/$objdir/$depdepl" 5923: darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 5924: if test -z "$darwin_install_name"; then 5925: darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` 5926: fi 5927: compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" 5928: linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}" 5929: path= 5930: fi 5931: fi 5932: ;; 5933: *) 5934: path="-L$absdir/$objdir" 5935: ;; 5936: esac 5937: else 5938: eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib` 5939: test -z "$libdir" && \ 5940: func_fatal_error "\`$deplib' is not a valid libtool archive" 5941: test "$absdir" != "$libdir" && \ 5942: func_warning "\`$deplib' seems to be moved" 5943: 5944: path="-L$absdir" 5945: fi 5946: ;; 5947: esac 5948: case " $deplibs " in 5949: *" $path "*) ;; 5950: *) deplibs="$path $deplibs" ;; 5951: esac 5952: done 5953: fi # link_all_deplibs != no 5954: fi # linkmode = lib 5955: done # for deplib in $libs 5956: if test "$pass" = link; then 5957: if test "$linkmode" = "prog"; then 5958: compile_deplibs="$new_inherited_linker_flags $compile_deplibs" 5959: finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" 5960: else 5961: compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 5962: fi 5963: fi 5964: dependency_libs="$newdependency_libs" 5965: if test "$pass" = dlpreopen; then 5966: # Link the dlpreopened libraries before other libraries 5967: for deplib in $save_deplibs; do 5968: deplibs="$deplib $deplibs" 5969: done 5970: fi 5971: if test "$pass" != dlopen; then 5972: if test "$pass" != conv; then 5973: # Make sure lib_search_path contains only unique directories. 5974: lib_search_path= 5975: for dir in $newlib_search_path; do 5976: case "$lib_search_path " in 5977: *" $dir "*) ;; 5978: *) lib_search_path="$lib_search_path $dir" ;; 5979: esac 5980: done 5981: newlib_search_path= 5982: fi 5983: 5984: if test "$linkmode,$pass" != "prog,link"; then 5985: vars="deplibs" 5986: else 5987: vars="compile_deplibs finalize_deplibs" 5988: fi 5989: for var in $vars dependency_libs; do 5990: # Add libraries to $var in reverse order 5991: eval tmp_libs=\"\$$var\" 5992: new_libs= 5993: for deplib in $tmp_libs; do 5994: # FIXME: Pedantically, this is the right thing to do, so 5995: # that some nasty dependency loop isn't accidentally 5996: # broken: 5997: #new_libs="$deplib $new_libs" 5998: # Pragmatically, this seems to cause very few problems in 5999: # practice: 6000: case $deplib in 6001: -L*) new_libs="$deplib $new_libs" ;; 6002: -R*) ;; 6003: *) 6004: # And here is the reason: when a library appears more 6005: # than once as an explicit dependence of a library, or 6006: # is implicitly linked in more than once by the 6007: # compiler, it is considered special, and multiple 6008: # occurrences thereof are not removed. Compare this 6009: # with having the same library being listed as a 6010: # dependency of multiple other libraries: in this case, 6011: # we know (pedantically, we assume) the library does not 6012: # need to be listed more than once, so we keep only the 6013: # last copy. This is not always right, but it is rare 6014: # enough that we require users that really mean to play 6015: # such unportable linking tricks to link the library 6016: # using -Wl,-lname, so that libtool does not consider it 6017: # for duplicate removal. 6018: case " $specialdeplibs " in 6019: *" $deplib "*) new_libs="$deplib $new_libs" ;; 6020: *) 6021: case " $new_libs " in 6022: *" $deplib "*) ;; 6023: *) new_libs="$deplib $new_libs" ;; 6024: esac 6025: ;; 6026: esac 6027: ;; 6028: esac 6029: done 6030: tmp_libs= 6031: for deplib in $new_libs; do 6032: case $deplib in 6033: -L*) 6034: case " $tmp_libs " in 6035: *" $deplib "*) ;; 6036: *) tmp_libs="$tmp_libs $deplib" ;; 6037: esac 6038: ;; 6039: *) tmp_libs="$tmp_libs $deplib" ;; 6040: esac 6041: done 6042: eval $var=\"$tmp_libs\" 6043: done # for var 6044: fi 6045: # Last step: remove runtime libs from dependency_libs 6046: # (they stay in deplibs) 6047: tmp_libs= 6048: for i in $dependency_libs ; do 6049: case " $predeps $postdeps $compiler_lib_search_path " in 6050: *" $i "*) 6051: i="" 6052: ;; 6053: esac 6054: if test -n "$i" ; then 6055: tmp_libs="$tmp_libs $i" 6056: fi 6057: done 6058: dependency_libs=$tmp_libs 6059: done # for pass 6060: if test "$linkmode" = prog; then 6061: dlfiles="$newdlfiles" 6062: fi 6063: if test "$linkmode" = prog || test "$linkmode" = lib; then 6064: dlprefiles="$newdlprefiles" 6065: fi 6066: 6067: case $linkmode in 6068: oldlib) 6069: if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 6070: func_warning "\`-dlopen' is ignored for archives" 6071: fi 6072: 6073: case " $deplibs" in 6074: *\ -l* | *\ -L*) 6075: func_warning "\`-l' and \`-L' are ignored for archives" ;; 6076: esac 6077: 6078: test -n "$rpath" && \ 6079: func_warning "\`-rpath' is ignored for archives" 6080: 6081: test -n "$xrpath" && \ 6082: func_warning "\`-R' is ignored for archives" 6083: 6084: test -n "$vinfo" && \ 6085: func_warning "\`-version-info/-version-number' is ignored for archives" 6086: 6087: test -n "$release" && \ 6088: func_warning "\`-release' is ignored for archives" 6089: 6090: test -n "$export_symbols$export_symbols_regex" && \ 6091: func_warning "\`-export-symbols' is ignored for archives" 6092: 6093: # Now set the variables for building old libraries. 6094: build_libtool_libs=no 6095: oldlibs="$output" 6096: objs="$objs$old_deplibs" 6097: ;; 6098: 6099: lib) 6100: # Make sure we only generate libraries of the form `libNAME.la'. 6101: case $outputname in 6102: lib*) 6103: func_stripname 'lib' '.la' "$outputname" 6104: name=$func_stripname_result 6105: eval shared_ext=\"$shrext_cmds\" 6106: eval libname=\"$libname_spec\" 6107: ;; 6108: *) 6109: test "$module" = no && \ 6110: func_fatal_help "libtool library \`$output' must begin with \`lib'" 6111: 6112: if test "$need_lib_prefix" != no; then 6113: # Add the "lib" prefix for modules if required 6114: func_stripname '' '.la' "$outputname" 6115: name=$func_stripname_result 6116: eval shared_ext=\"$shrext_cmds\" 6117: eval libname=\"$libname_spec\" 6118: else 6119: func_stripname '' '.la' "$outputname" 6120: libname=$func_stripname_result 6121: fi 6122: ;; 6123: esac 6124: 6125: if test -n "$objs"; then 6126: if test "$deplibs_check_method" != pass_all; then 6127: func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 6128: else 6129: $ECHO 6130: $ECHO "*** Warning: Linking the shared library $output against the non-libtool" 6131: $ECHO "*** objects $objs is not portable!" 6132: libobjs="$libobjs $objs" 6133: fi 6134: fi 6135: 6136: test "$dlself" != no && \ 6137: func_warning "\`-dlopen self' is ignored for libtool libraries" 6138: 6139: set dummy $rpath 6140: shift 6141: test "$#" -gt 1 && \ 6142: func_warning "ignoring multiple \`-rpath's for a libtool library" 6143: 6144: install_libdir="$1" 6145: 6146: oldlibs= 6147: if test -z "$rpath"; then 6148: if test "$build_libtool_libs" = yes; then 6149: # Building a libtool convenience library. 6150: # Some compilers have problems with a `.al' extension so 6151: # convenience libraries should have the same extension an 6152: # archive normally would. 6153: oldlibs="$output_objdir/$libname.$libext $oldlibs" 6154: build_libtool_libs=convenience 6155: build_old_libs=yes 6156: fi 6157: 6158: test -n "$vinfo" && \ 6159: func_warning "\`-version-info/-version-number' is ignored for convenience libraries" 6160: 6161: test -n "$release" && \ 6162: func_warning "\`-release' is ignored for convenience libraries" 6163: else 6164: 6165: # Parse the version information argument. 6166: save_ifs="$IFS"; IFS=':' 6167: set dummy $vinfo 0 0 0 6168: shift 6169: IFS="$save_ifs" 6170: 6171: test -n "$7" && \ 6172: func_fatal_help "too many parameters to \`-version-info'" 6173: 6174: # convert absolute version numbers to libtool ages 6175: # this retains compatibility with .la files and attempts 6176: # to make the code below a bit more comprehensible 6177: 6178: case $vinfo_number in 6179: yes) 6180: number_major="$1" 6181: number_minor="$2" 6182: number_revision="$3" 6183: # 6184: # There are really only two kinds -- those that 6185: # use the current revision as the major version 6186: # and those that subtract age and use age as 6187: # a minor version. But, then there is irix 6188: # which has an extra 1 added just for fun 6189: # 6190: case $version_type in 6191: darwin|linux|osf|windows|none) 6192: func_arith $number_major + $number_minor 6193: current=$func_arith_result 6194: age="$number_minor" 6195: revision="$number_revision" 6196: ;; 6197: freebsd-aout|freebsd-elf|sunos) 6198: current="$number_major" 6199: revision="$number_minor" 6200: age="0" 6201: ;; 6202: irix|nonstopux) 6203: func_arith $number_major + $number_minor 6204: current=$func_arith_result 6205: age="$number_minor" 6206: revision="$number_minor" 6207: lt_irix_increment=no 6208: ;; 6209: esac 6210: ;; 6211: no) 6212: current="$1" 6213: revision="$2" 6214: age="$3" 6215: ;; 6216: esac 6217: 6218: # Check that each of the things are valid numbers. 6219: case $current in 6220: 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]) ;; 6221: *) 6222: func_error "CURRENT \`$current' must be a nonnegative integer" 6223: func_fatal_error "\`$vinfo' is not valid version information" 6224: ;; 6225: esac 6226: 6227: case $revision in 6228: 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]) ;; 6229: *) 6230: func_error "REVISION \`$revision' must be a nonnegative integer" 6231: func_fatal_error "\`$vinfo' is not valid version information" 6232: ;; 6233: esac 6234: 6235: case $age in 6236: 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]) ;; 6237: *) 6238: func_error "AGE \`$age' must be a nonnegative integer" 6239: func_fatal_error "\`$vinfo' is not valid version information" 6240: ;; 6241: esac 6242: 6243: if test "$age" -gt "$current"; then 6244: func_error "AGE \`$age' is greater than the current interface number \`$current'" 6245: func_fatal_error "\`$vinfo' is not valid version information" 6246: fi 6247: 6248: # Calculate the version variables. 6249: major= 6250: versuffix= 6251: verstring= 6252: case $version_type in 6253: none) ;; 6254: 6255: darwin) 6256: # Like Linux, but with the current version available in 6257: # verstring for coding it into the library header 6258: func_arith $current - $age 6259: major=.$func_arith_result 6260: versuffix="$major.$age.$revision" 6261: # Darwin ld doesn't like 0 for these options... 6262: func_arith $current + 1 6263: minor_current=$func_arith_result 6264: xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" 6265: verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" 6266: ;; 6267: 6268: freebsd-aout) 6269: major=".$current" 6270: versuffix=".$current.$revision"; 6271: ;; 6272: 6273: freebsd-elf) 6274: major=".$current" 6275: versuffix=".$current" 6276: ;; 6277: 6278: irix | nonstopux) 6279: if test "X$lt_irix_increment" = "Xno"; then 6280: func_arith $current - $age 6281: else 6282: func_arith $current - $age + 1 6283: fi 6284: major=$func_arith_result 6285: 6286: case $version_type in 6287: nonstopux) verstring_prefix=nonstopux ;; 6288: *) verstring_prefix=sgi ;; 6289: esac 6290: verstring="$verstring_prefix$major.$revision" 6291: 6292: # Add in all the interfaces that we are compatible with. 6293: loop=$revision 6294: while test "$loop" -ne 0; do 6295: func_arith $revision - $loop 6296: iface=$func_arith_result 6297: func_arith $loop - 1 6298: loop=$func_arith_result 6299: verstring="$verstring_prefix$major.$iface:$verstring" 6300: done 6301: 6302: # Before this point, $major must not contain `.'. 6303: major=.$major 6304: versuffix="$major.$revision" 6305: ;; 6306: 6307: linux) 6308: func_arith $current - $age 6309: major=.$func_arith_result 6310: versuffix="$major.$age.$revision" 6311: ;; 6312: 6313: osf) 6314: func_arith $current - $age 6315: major=.$func_arith_result 6316: versuffix=".$current.$age.$revision" 6317: verstring="$current.$age.$revision" 6318: 6319: # Add in all the interfaces that we are compatible with. 6320: loop=$age 6321: while test "$loop" -ne 0; do 6322: func_arith $current - $loop 6323: iface=$func_arith_result 6324: func_arith $loop - 1 6325: loop=$func_arith_result 6326: verstring="$verstring:${iface}.0" 6327: done 6328: 6329: # Make executables depend on our current version. 6330: verstring="$verstring:${current}.0" 6331: ;; 6332: 6333: qnx) 6334: major=".$current" 6335: versuffix=".$current" 6336: ;; 6337: 6338: sunos) 6339: major=".$current" 6340: versuffix=".$current.$revision" 6341: ;; 6342: 6343: windows) 6344: # Use '-' rather than '.', since we only want one 6345: # extension on DOS 8.3 filesystems. 6346: func_arith $current - $age 6347: major=$func_arith_result 6348: versuffix="-$major" 6349: ;; 6350: 6351: *) 6352: func_fatal_configuration "unknown library version type \`$version_type'" 6353: ;; 6354: esac 6355: 6356: # Clear the version info if we defaulted, and they specified a release. 6357: if test -z "$vinfo" && test -n "$release"; then 6358: major= 6359: case $version_type in 6360: darwin) 6361: # we can't check for "0.0" in archive_cmds due to quoting 6362: # problems, so we reset it completely 6363: verstring= 6364: ;; 6365: *) 6366: verstring="0.0" 6367: ;; 6368: esac 6369: if test "$need_version" = no; then 6370: versuffix= 6371: else 6372: versuffix=".0.0" 6373: fi 6374: fi 6375: 6376: # Remove version info from name if versioning should be avoided 6377: if test "$avoid_version" = yes && test "$need_version" = no; then 6378: major= 6379: versuffix= 6380: verstring="" 6381: fi 6382: 6383: # Check to see if the archive will have undefined symbols. 6384: if test "$allow_undefined" = yes; then 6385: if test "$allow_undefined_flag" = unsupported; then 6386: func_warning "undefined symbols not allowed in $host shared libraries" 6387: build_libtool_libs=no 6388: build_old_libs=yes 6389: fi 6390: else 6391: # Don't allow undefined symbols. 6392: allow_undefined_flag="$no_undefined_flag" 6393: fi 6394: 6395: fi 6396: 6397: func_generate_dlsyms "$libname" "$libname" "yes" 6398: libobjs="$libobjs $symfileobj" 6399: test "X$libobjs" = "X " && libobjs= 6400: 6401: if test "$mode" != relink; then 6402: # Remove our outputs, but don't remove object files since they 6403: # may have been created when compiling PIC objects. 6404: removelist= 6405: tempremovelist=`$ECHO "$output_objdir/*"` 6406: for p in $tempremovelist; do 6407: case $p in 6408: *.$objext | *.gcno) 6409: ;; 6410: $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) 6411: if test "X$precious_files_regex" != "X"; then 6412: if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 6413: then 6414: continue 6415: fi 6416: fi 6417: removelist="$removelist $p" 6418: ;; 6419: *) ;; 6420: esac 6421: done 6422: test -n "$removelist" && \ 6423: func_show_eval "${RM}r \$removelist" 6424: fi 6425: 6426: # Now set the variables for building old libraries. 6427: if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then 6428: oldlibs="$oldlibs $output_objdir/$libname.$libext" 6429: 6430: # Transform .lo files to .o files. 6431: oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP` 6432: fi 6433: 6434: # Eliminate all temporary directories. 6435: #for path in $notinst_path; do 6436: # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"` 6437: # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"` 6438: # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"` 6439: #done 6440: 6441: if test -n "$xrpath"; then 6442: # If the user specified any rpath flags, then add them. 6443: temp_xrpath= 6444: for libdir in $xrpath; do 6445: temp_xrpath="$temp_xrpath -R$libdir" 6446: case "$finalize_rpath " in 6447: *" $libdir "*) ;; 6448: *) finalize_rpath="$finalize_rpath $libdir" ;; 6449: esac 6450: done 6451: if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then 6452: dependency_libs="$temp_xrpath $dependency_libs" 6453: fi 6454: fi 6455: 6456: # Make sure dlfiles contains only unique files that won't be dlpreopened 6457: old_dlfiles="$dlfiles" 6458: dlfiles= 6459: for lib in $old_dlfiles; do 6460: case " $dlprefiles $dlfiles " in 6461: *" $lib "*) ;; 6462: *) dlfiles="$dlfiles $lib" ;; 6463: esac 6464: done 6465: 6466: # Make sure dlprefiles contains only unique files 6467: old_dlprefiles="$dlprefiles" 6468: dlprefiles= 6469: for lib in $old_dlprefiles; do 6470: case "$dlprefiles " in 6471: *" $lib "*) ;; 6472: *) dlprefiles="$dlprefiles $lib" ;; 6473: esac 6474: done 6475: 6476: if test "$build_libtool_libs" = yes; then 6477: if test -n "$rpath"; then 6478: case $host in 6479: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*) 6480: # these systems don't actually have a c library (as such)! 6481: ;; 6482: *-*-rhapsody* | *-*-darwin1.[012]) 6483: # Rhapsody C library is in the System framework 6484: deplibs="$deplibs System.ltframework" 6485: ;; 6486: *-*-netbsd*) 6487: # Don't link with libc until the a.out ld.so is fixed. 6488: ;; 6489: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) 6490: # Do not include libc due to us having libc/libc_r. 6491: ;; 6492: *-*-sco3.2v5* | *-*-sco5v6*) 6493: # Causes problems with __ctype 6494: ;; 6495: *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) 6496: # Compiler inserts libc in the correct place for threads to work 6497: ;; 6498: *) 6499: # Add libc to deplibs on all other systems if necessary. 6500: if test "$build_libtool_need_lc" = "yes"; then 6501: deplibs="$deplibs -lc" 6502: fi 6503: ;; 6504: esac 6505: fi 6506: 6507: # Transform deplibs into only deplibs that can be linked in shared. 6508: name_save=$name 6509: libname_save=$libname 6510: release_save=$release 6511: versuffix_save=$versuffix 6512: major_save=$major 6513: # I'm not sure if I'm treating the release correctly. I think 6514: # release should show up in the -l (ie -lgmp5) so we don't want to 6515: # add it in twice. Is that correct? 6516: release="" 6517: versuffix="" 6518: major="" 6519: newdeplibs= 6520: droppeddeps=no 6521: case $deplibs_check_method in 6522: pass_all) 6523: # Don't check for shared/static. Everything works. 6524: # This might be a little naive. We might want to check 6525: # whether the library exists or not. But this is on 6526: # osf3 & osf4 and I'm not really sure... Just 6527: # implementing what was already the behavior. 6528: newdeplibs=$deplibs 6529: ;; 6530: test_compile) 6531: # This code stresses the "libraries are programs" paradigm to its 6532: # limits. Maybe even breaks it. We compile a program, linking it 6533: # against the deplibs as a proxy for the library. Then we can check 6534: # whether they linked in statically or dynamically with ldd. 6535: $opt_dry_run || $RM conftest.c 6536: cat > conftest.c <<EOF 6537: int main() { return 0; } 6538: EOF 6539: $opt_dry_run || $RM conftest 6540: if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then 6541: ldd_output=`ldd conftest` 6542: for i in $deplibs; do 6543: case $i in 6544: -l*) 6545: func_stripname -l '' "$i" 6546: name=$func_stripname_result 6547: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6548: case " $predeps $postdeps " in 6549: *" $i "*) 6550: newdeplibs="$newdeplibs $i" 6551: i="" 6552: ;; 6553: esac 6554: fi 6555: if test -n "$i" ; then 6556: libname=`eval "\\$ECHO \"$libname_spec\""` 6557: deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 6558: set dummy $deplib_matches; shift 6559: deplib_match=$1 6560: if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 6561: newdeplibs="$newdeplibs $i" 6562: else 6563: droppeddeps=yes 6564: $ECHO 6565: $ECHO "*** Warning: dynamic linker does not accept needed library $i." 6566: $ECHO "*** I have the capability to make that library automatically link in when" 6567: $ECHO "*** you link to this library. But I can only do this if you have a" 6568: $ECHO "*** shared version of the library, which I believe you do not have" 6569: $ECHO "*** because a test_compile did reveal that the linker did not use it for" 6570: $ECHO "*** its dynamic dependency list that programs get resolved with at runtime." 6571: fi 6572: fi 6573: ;; 6574: *) 6575: newdeplibs="$newdeplibs $i" 6576: ;; 6577: esac 6578: done 6579: else 6580: # Error occurred in the first compile. Let's try to salvage 6581: # the situation: Compile a separate program for each library. 6582: for i in $deplibs; do 6583: case $i in 6584: -l*) 6585: func_stripname -l '' "$i" 6586: name=$func_stripname_result 6587: $opt_dry_run || $RM conftest 6588: if $LTCC $LTCFLAGS -o conftest conftest.c $i; then 6589: ldd_output=`ldd conftest` 6590: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6591: case " $predeps $postdeps " in 6592: *" $i "*) 6593: newdeplibs="$newdeplibs $i" 6594: i="" 6595: ;; 6596: esac 6597: fi 6598: if test -n "$i" ; then 6599: libname=`eval "\\$ECHO \"$libname_spec\""` 6600: deplib_matches=`eval "\\$ECHO \"$library_names_spec\""` 6601: set dummy $deplib_matches; shift 6602: deplib_match=$1 6603: if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then 6604: newdeplibs="$newdeplibs $i" 6605: else 6606: droppeddeps=yes 6607: $ECHO 6608: $ECHO "*** Warning: dynamic linker does not accept needed library $i." 6609: $ECHO "*** I have the capability to make that library automatically link in when" 6610: $ECHO "*** you link to this library. But I can only do this if you have a" 6611: $ECHO "*** shared version of the library, which you do not appear to have" 6612: $ECHO "*** because a test_compile did reveal that the linker did not use this one" 6613: $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime." 6614: fi 6615: fi 6616: else 6617: droppeddeps=yes 6618: $ECHO 6619: $ECHO "*** Warning! Library $i is needed by this library but I was not able to" 6620: $ECHO "*** make it link in! You will probably need to install it or some" 6621: $ECHO "*** library that it depends on before this library will be fully" 6622: $ECHO "*** functional. Installing it before continuing would be even better." 6623: fi 6624: ;; 6625: *) 6626: newdeplibs="$newdeplibs $i" 6627: ;; 6628: esac 6629: done 6630: fi 6631: ;; 6632: file_magic*) 6633: set dummy $deplibs_check_method; shift 6634: file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"` 6635: for a_deplib in $deplibs; do 6636: case $a_deplib in 6637: -l*) 6638: func_stripname -l '' "$a_deplib" 6639: name=$func_stripname_result 6640: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6641: case " $predeps $postdeps " in 6642: *" $a_deplib "*) 6643: newdeplibs="$newdeplibs $a_deplib" 6644: a_deplib="" 6645: ;; 6646: esac 6647: fi 6648: if test -n "$a_deplib" ; then 6649: libname=`eval "\\$ECHO \"$libname_spec\""` 6650: for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 6651: potential_libs=`ls $i/$libname[.-]* 2>/dev/null` 6652: for potent_lib in $potential_libs; do 6653: # Follow soft links. 6654: if ls -lLd "$potent_lib" 2>/dev/null | 6655: $GREP " -> " >/dev/null; then 6656: continue 6657: fi 6658: # The statement above tries to avoid entering an 6659: # endless loop below, in case of cyclic links. 6660: # We might still enter an endless loop, since a link 6661: # loop can be closed while we follow links, 6662: # but so what? 6663: potlib="$potent_lib" 6664: while test -h "$potlib" 2>/dev/null; do 6665: potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` 6666: case $potliblink in 6667: [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; 6668: *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";; 6669: esac 6670: done 6671: if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | 6672: $SED -e 10q | 6673: $EGREP "$file_magic_regex" > /dev/null; then 6674: newdeplibs="$newdeplibs $a_deplib" 6675: a_deplib="" 6676: break 2 6677: fi 6678: done 6679: done 6680: fi 6681: if test -n "$a_deplib" ; then 6682: droppeddeps=yes 6683: $ECHO 6684: $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 6685: $ECHO "*** I have the capability to make that library automatically link in when" 6686: $ECHO "*** you link to this library. But I can only do this if you have a" 6687: $ECHO "*** shared version of the library, which you do not appear to have" 6688: $ECHO "*** because I did check the linker path looking for a file starting" 6689: if test -z "$potlib" ; then 6690: $ECHO "*** with $libname but no candidates were found. (...for file magic test)" 6691: else 6692: $ECHO "*** with $libname and none of the candidates passed a file format test" 6693: $ECHO "*** using a file magic. Last file checked: $potlib" 6694: fi 6695: fi 6696: ;; 6697: *) 6698: # Add a -L argument. 6699: newdeplibs="$newdeplibs $a_deplib" 6700: ;; 6701: esac 6702: done # Gone through all deplibs. 6703: ;; 6704: match_pattern*) 6705: set dummy $deplibs_check_method; shift 6706: match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"` 6707: for a_deplib in $deplibs; do 6708: case $a_deplib in 6709: -l*) 6710: func_stripname -l '' "$a_deplib" 6711: name=$func_stripname_result 6712: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6713: case " $predeps $postdeps " in 6714: *" $a_deplib "*) 6715: newdeplibs="$newdeplibs $a_deplib" 6716: a_deplib="" 6717: ;; 6718: esac 6719: fi 6720: if test -n "$a_deplib" ; then 6721: libname=`eval "\\$ECHO \"$libname_spec\""` 6722: for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do 6723: potential_libs=`ls $i/$libname[.-]* 2>/dev/null` 6724: for potent_lib in $potential_libs; do 6725: potlib="$potent_lib" # see symlink-check above in file_magic test 6726: if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \ 6727: $EGREP "$match_pattern_regex" > /dev/null; then 6728: newdeplibs="$newdeplibs $a_deplib" 6729: a_deplib="" 6730: break 2 6731: fi 6732: done 6733: done 6734: fi 6735: if test -n "$a_deplib" ; then 6736: droppeddeps=yes 6737: $ECHO 6738: $ECHO "*** Warning: linker path does not have real file for library $a_deplib." 6739: $ECHO "*** I have the capability to make that library automatically link in when" 6740: $ECHO "*** you link to this library. But I can only do this if you have a" 6741: $ECHO "*** shared version of the library, which you do not appear to have" 6742: $ECHO "*** because I did check the linker path looking for a file starting" 6743: if test -z "$potlib" ; then 6744: $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" 6745: else 6746: $ECHO "*** with $libname and none of the candidates passed a file format test" 6747: $ECHO "*** using a regex pattern. Last file checked: $potlib" 6748: fi 6749: fi 6750: ;; 6751: *) 6752: # Add a -L argument. 6753: newdeplibs="$newdeplibs $a_deplib" 6754: ;; 6755: esac 6756: done # Gone through all deplibs. 6757: ;; 6758: none | unknown | *) 6759: newdeplibs="" 6760: tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \ 6761: -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'` 6762: if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then 6763: for i in $predeps $postdeps ; do 6764: # can't use Xsed below, because $i might contain '/' 6765: tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"` 6766: done 6767: fi 6768: if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' | 6769: $GREP . >/dev/null; then 6770: $ECHO 6771: if test "X$deplibs_check_method" = "Xnone"; then 6772: $ECHO "*** Warning: inter-library dependencies are not supported in this platform." 6773: else 6774: $ECHO "*** Warning: inter-library dependencies are not known to be supported." 6775: fi 6776: $ECHO "*** All declared inter-library dependencies are being dropped." 6777: droppeddeps=yes 6778: fi 6779: ;; 6780: esac 6781: versuffix=$versuffix_save 6782: major=$major_save 6783: release=$release_save 6784: libname=$libname_save 6785: name=$name_save 6786: 6787: case $host in 6788: *-*-rhapsody* | *-*-darwin1.[012]) 6789: # On Rhapsody replace the C library with the System framework 6790: newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 6791: ;; 6792: esac 6793: 6794: if test "$droppeddeps" = yes; then 6795: if test "$module" = yes; then 6796: $ECHO 6797: $ECHO "*** Warning: libtool could not satisfy all declared inter-library" 6798: $ECHO "*** dependencies of module $libname. Therefore, libtool will create" 6799: $ECHO "*** a static module, that should work as long as the dlopening" 6800: $ECHO "*** application is linked with the -dlopen flag." 6801: if test -z "$global_symbol_pipe"; then 6802: $ECHO 6803: $ECHO "*** However, this would only work if libtool was able to extract symbol" 6804: $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could" 6805: $ECHO "*** not find such a program. So, this module is probably useless." 6806: $ECHO "*** \`nm' from GNU binutils and a full rebuild may help." 6807: fi 6808: if test "$build_old_libs" = no; then 6809: oldlibs="$output_objdir/$libname.$libext" 6810: build_libtool_libs=module 6811: build_old_libs=yes 6812: else 6813: build_libtool_libs=no 6814: fi 6815: else 6816: $ECHO "*** The inter-library dependencies that have been dropped here will be" 6817: $ECHO "*** automatically added whenever a program is linked with this library" 6818: $ECHO "*** or is declared to -dlopen it." 6819: 6820: if test "$allow_undefined" = no; then 6821: $ECHO 6822: $ECHO "*** Since this library must not contain undefined symbols," 6823: $ECHO "*** because either the platform does not support them or" 6824: $ECHO "*** it was explicitly requested with -no-undefined," 6825: $ECHO "*** libtool will only create a static version of it." 6826: if test "$build_old_libs" = no; then 6827: oldlibs="$output_objdir/$libname.$libext" 6828: build_libtool_libs=module 6829: build_old_libs=yes 6830: else 6831: build_libtool_libs=no 6832: fi 6833: fi 6834: fi 6835: fi 6836: # Done checking deplibs! 6837: deplibs=$newdeplibs 6838: fi 6839: # Time to change all our "foo.ltframework" stuff back to "-framework foo" 6840: case $host in 6841: *-*-darwin*) 6842: newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 6843: new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 6844: deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 6845: ;; 6846: esac 6847: 6848: # move library search paths that coincide with paths to not yet 6849: # installed libraries to the beginning of the library search list 6850: new_libs= 6851: for path in $notinst_path; do 6852: case " $new_libs " in 6853: *" -L$path/$objdir "*) ;; 6854: *) 6855: case " $deplibs " in 6856: *" -L$path/$objdir "*) 6857: new_libs="$new_libs -L$path/$objdir" ;; 6858: esac 6859: ;; 6860: esac 6861: done 6862: for deplib in $deplibs; do 6863: case $deplib in 6864: -L*) 6865: case " $new_libs " in 6866: *" $deplib "*) ;; 6867: *) new_libs="$new_libs $deplib" ;; 6868: esac 6869: ;; 6870: *) new_libs="$new_libs $deplib" ;; 6871: esac 6872: done 6873: deplibs="$new_libs" 6874: 6875: # All the library-specific variables (install_libdir is set above). 6876: library_names= 6877: old_library= 6878: dlname= 6879: 6880: # Test again, we may have decided not to build it any more 6881: if test "$build_libtool_libs" = yes; then 6882: if test "$hardcode_into_libs" = yes; then 6883: # Hardcode the library paths 6884: hardcode_libdirs= 6885: dep_rpath= 6886: rpath="$finalize_rpath" 6887: test "$mode" != relink && rpath="$compile_rpath$rpath" 6888: for libdir in $rpath; do 6889: if test -n "$hardcode_libdir_flag_spec"; then 6890: if test -n "$hardcode_libdir_separator"; then 6891: if test -z "$hardcode_libdirs"; then 6892: hardcode_libdirs="$libdir" 6893: else 6894: # Just accumulate the unique libdirs. 6895: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 6896: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 6897: ;; 6898: *) 6899: hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 6900: ;; 6901: esac 6902: fi 6903: else 6904: eval flag=\"$hardcode_libdir_flag_spec\" 6905: dep_rpath="$dep_rpath $flag" 6906: fi 6907: elif test -n "$runpath_var"; then 6908: case "$perm_rpath " in 6909: *" $libdir "*) ;; 6910: *) perm_rpath="$perm_rpath $libdir" ;; 6911: esac 6912: fi 6913: done 6914: # Substitute the hardcoded libdirs into the rpath. 6915: if test -n "$hardcode_libdir_separator" && 6916: test -n "$hardcode_libdirs"; then 6917: libdir="$hardcode_libdirs" 6918: if test -n "$hardcode_libdir_flag_spec_ld"; then 6919: eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" 6920: else 6921: eval dep_rpath=\"$hardcode_libdir_flag_spec\" 6922: fi 6923: fi 6924: if test -n "$runpath_var" && test -n "$perm_rpath"; then 6925: # We should set the runpath_var. 6926: rpath= 6927: for dir in $perm_rpath; do 6928: rpath="$rpath$dir:" 6929: done 6930: eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" 6931: fi 6932: test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" 6933: fi 6934: 6935: shlibpath="$finalize_shlibpath" 6936: test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath" 6937: if test -n "$shlibpath"; then 6938: eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" 6939: fi 6940: 6941: # Get the real and link names of the library. 6942: eval shared_ext=\"$shrext_cmds\" 6943: eval library_names=\"$library_names_spec\" 6944: set dummy $library_names 6945: shift 6946: realname="$1" 6947: shift 6948: 6949: if test -n "$soname_spec"; then 6950: eval soname=\"$soname_spec\" 6951: else 6952: soname="$realname" 6953: fi 6954: if test -z "$dlname"; then 6955: dlname=$soname 6956: fi 6957: 6958: lib="$output_objdir/$realname" 6959: linknames= 6960: for link 6961: do 6962: linknames="$linknames $link" 6963: done 6964: 6965: # Use standard objects if they are pic 6966: test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 6967: test "X$libobjs" = "X " && libobjs= 6968: 6969: delfiles= 6970: if test -n "$export_symbols" && test -n "$include_expsyms"; then 6971: $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" 6972: export_symbols="$output_objdir/$libname.uexp" 6973: delfiles="$delfiles $export_symbols" 6974: fi 6975: 6976: orig_export_symbols= 6977: case $host_os in 6978: cygwin* | mingw* | cegcc*) 6979: if test -n "$export_symbols" && test -z "$export_symbols_regex"; then 6980: # exporting using user supplied symfile 6981: if test "x`$SED 1q $export_symbols`" != xEXPORTS; then 6982: # and it's NOT already a .def file. Must figure out 6983: # which of the given symbols are data symbols and tag 6984: # them as such. So, trigger use of export_symbols_cmds. 6985: # export_symbols gets reassigned inside the "prepare 6986: # the list of exported symbols" if statement, so the 6987: # include_expsyms logic still works. 6988: orig_export_symbols="$export_symbols" 6989: export_symbols= 6990: always_export_symbols=yes 6991: fi 6992: fi 6993: ;; 6994: esac 6995: 6996: # Prepare the list of exported symbols 6997: if test -z "$export_symbols"; then 6998: if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then 6999: func_verbose "generating symbol list for \`$libname.la'" 7000: export_symbols="$output_objdir/$libname.exp" 7001: $opt_dry_run || $RM $export_symbols 7002: cmds=$export_symbols_cmds 7003: save_ifs="$IFS"; IFS='~' 7004: for cmd in $cmds; do 7005: IFS="$save_ifs" 7006: eval cmd=\"$cmd\" 7007: func_len " $cmd" 7008: len=$func_len_result 7009: if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 7010: func_show_eval "$cmd" 'exit $?' 7011: skipped_export=false 7012: else 7013: # The command line is too long to execute in one step. 7014: func_verbose "using reloadable object file for export list..." 7015: skipped_export=: 7016: # Break out early, otherwise skipped_export may be 7017: # set to false by a later but shorter cmd. 7018: break 7019: fi 7020: done 7021: IFS="$save_ifs" 7022: if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then 7023: func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 7024: func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 7025: fi 7026: fi 7027: fi 7028: 7029: if test -n "$export_symbols" && test -n "$include_expsyms"; then 7030: tmp_export_symbols="$export_symbols" 7031: test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 7032: $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"' 7033: fi 7034: 7035: if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then 7036: # The given exports_symbols file has to be filtered, so filter it. 7037: func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 7038: # FIXME: $output_objdir/$libname.filter potentially contains lots of 7039: # 's' commands which not all seds can handle. GNU sed should be fine 7040: # though. Also, the filter scales superlinearly with the number of 7041: # global variables. join(1) would be nice here, but unfortunately 7042: # isn't a blessed tool. 7043: $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 7044: delfiles="$delfiles $export_symbols $output_objdir/$libname.filter" 7045: export_symbols=$output_objdir/$libname.def 7046: $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 7047: fi 7048: 7049: tmp_deplibs= 7050: for test_deplib in $deplibs; do 7051: case " $convenience " in 7052: *" $test_deplib "*) ;; 7053: *) 7054: tmp_deplibs="$tmp_deplibs $test_deplib" 7055: ;; 7056: esac 7057: done 7058: deplibs="$tmp_deplibs" 7059: 7060: if test -n "$convenience"; then 7061: if test -n "$whole_archive_flag_spec" && 7062: test "$compiler_needs_object" = yes && 7063: test -z "$libobjs"; then 7064: # extract the archives, so we have objects to list. 7065: # TODO: could optimize this to just extract one archive. 7066: whole_archive_flag_spec= 7067: fi 7068: if test -n "$whole_archive_flag_spec"; then 7069: save_libobjs=$libobjs 7070: eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 7071: test "X$libobjs" = "X " && libobjs= 7072: else 7073: gentop="$output_objdir/${outputname}x" 7074: generated="$generated $gentop" 7075: 7076: func_extract_archives $gentop $convenience 7077: libobjs="$libobjs $func_extract_archives_result" 7078: test "X$libobjs" = "X " && libobjs= 7079: fi 7080: fi 7081: 7082: if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then 7083: eval flag=\"$thread_safe_flag_spec\" 7084: linker_flags="$linker_flags $flag" 7085: fi 7086: 7087: # Make a backup of the uninstalled library when relinking 7088: if test "$mode" = relink; then 7089: $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? 7090: fi 7091: 7092: # Do each of the archive commands. 7093: if test "$module" = yes && test -n "$module_cmds" ; then 7094: if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 7095: eval test_cmds=\"$module_expsym_cmds\" 7096: cmds=$module_expsym_cmds 7097: else 7098: eval test_cmds=\"$module_cmds\" 7099: cmds=$module_cmds 7100: fi 7101: else 7102: if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 7103: eval test_cmds=\"$archive_expsym_cmds\" 7104: cmds=$archive_expsym_cmds 7105: else 7106: eval test_cmds=\"$archive_cmds\" 7107: cmds=$archive_cmds 7108: fi 7109: fi 7110: 7111: if test "X$skipped_export" != "X:" && 7112: func_len " $test_cmds" && 7113: len=$func_len_result && 7114: test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 7115: : 7116: else 7117: # The command line is too long to link in one step, link piecewise 7118: # or, if using GNU ld and skipped_export is not :, use a linker 7119: # script. 7120: 7121: # Save the value of $output and $libobjs because we want to 7122: # use them later. If we have whole_archive_flag_spec, we 7123: # want to use save_libobjs as it was before 7124: # whole_archive_flag_spec was expanded, because we can't 7125: # assume the linker understands whole_archive_flag_spec. 7126: # This may have to be revisited, in case too many 7127: # convenience libraries get linked in and end up exceeding 7128: # the spec. 7129: if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then 7130: save_libobjs=$libobjs 7131: fi 7132: save_output=$output 7133: output_la=`$ECHO "X$output" | $Xsed -e "$basename"` 7134: 7135: # Clear the reloadable object creation command queue and 7136: # initialize k to one. 7137: test_cmds= 7138: concat_cmds= 7139: objlist= 7140: last_robj= 7141: k=1 7142: 7143: if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then 7144: output=${output_objdir}/${output_la}.lnkscript 7145: func_verbose "creating GNU ld script: $output" 7146: $ECHO 'INPUT (' > $output 7147: for obj in $save_libobjs 7148: do 7149: $ECHO "$obj" >> $output 7150: done 7151: $ECHO ')' >> $output 7152: delfiles="$delfiles $output" 7153: elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then 7154: output=${output_objdir}/${output_la}.lnk 7155: func_verbose "creating linker input file list: $output" 7156: : > $output 7157: set x $save_libobjs 7158: shift 7159: firstobj= 7160: if test "$compiler_needs_object" = yes; then 7161: firstobj="$1 " 7162: shift 7163: fi 7164: for obj 7165: do 7166: $ECHO "$obj" >> $output 7167: done 7168: delfiles="$delfiles $output" 7169: output=$firstobj\"$file_list_spec$output\" 7170: else 7171: if test -n "$save_libobjs"; then 7172: func_verbose "creating reloadable object files..." 7173: output=$output_objdir/$output_la-${k}.$objext 7174: eval test_cmds=\"$reload_cmds\" 7175: func_len " $test_cmds" 7176: len0=$func_len_result 7177: len=$len0 7178: 7179: # Loop over the list of objects to be linked. 7180: for obj in $save_libobjs 7181: do 7182: func_len " $obj" 7183: func_arith $len + $func_len_result 7184: len=$func_arith_result 7185: if test "X$objlist" = X || 7186: test "$len" -lt "$max_cmd_len"; then 7187: func_append objlist " $obj" 7188: else 7189: # The command $test_cmds is almost too long, add a 7190: # command to the queue. 7191: if test "$k" -eq 1 ; then 7192: # The first file doesn't have a previous command to add. 7193: eval concat_cmds=\"$reload_cmds $objlist $last_robj\" 7194: else 7195: # All subsequent reloadable object files will link in 7196: # the last one created. 7197: eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\" 7198: fi 7199: last_robj=$output_objdir/$output_la-${k}.$objext 7200: func_arith $k + 1 7201: k=$func_arith_result 7202: output=$output_objdir/$output_la-${k}.$objext 7203: objlist=$obj 7204: func_len " $last_robj" 7205: func_arith $len0 + $func_len_result 7206: len=$func_arith_result 7207: fi 7208: done 7209: # Handle the remaining objects by creating one last 7210: # reloadable object file. All subsequent reloadable object 7211: # files will link in the last one created. 7212: test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 7213: eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\" 7214: if test -n "$last_robj"; then 7215: eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" 7216: fi 7217: delfiles="$delfiles $output" 7218: 7219: else 7220: output= 7221: fi 7222: 7223: if ${skipped_export-false}; then 7224: func_verbose "generating symbol list for \`$libname.la'" 7225: export_symbols="$output_objdir/$libname.exp" 7226: $opt_dry_run || $RM $export_symbols 7227: libobjs=$output 7228: # Append the command to create the export file. 7229: test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 7230: eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" 7231: if test -n "$last_robj"; then 7232: eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" 7233: fi 7234: fi 7235: 7236: test -n "$save_libobjs" && 7237: func_verbose "creating a temporary reloadable object file: $output" 7238: 7239: # Loop through the commands generated above and execute them. 7240: save_ifs="$IFS"; IFS='~' 7241: for cmd in $concat_cmds; do 7242: IFS="$save_ifs" 7243: $opt_silent || { 7244: func_quote_for_expand "$cmd" 7245: eval "func_echo $func_quote_for_expand_result" 7246: } 7247: $opt_dry_run || eval "$cmd" || { 7248: lt_exit=$? 7249: 7250: # Restore the uninstalled library and exit 7251: if test "$mode" = relink; then 7252: ( cd "$output_objdir" && \ 7253: $RM "${realname}T" && \ 7254: $MV "${realname}U" "$realname" ) 7255: fi 7256: 7257: exit $lt_exit 7258: } 7259: done 7260: IFS="$save_ifs" 7261: 7262: if test -n "$export_symbols_regex" && ${skipped_export-false}; then 7263: func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' 7264: func_show_eval '$MV "${export_symbols}T" "$export_symbols"' 7265: fi 7266: fi 7267: 7268: if ${skipped_export-false}; then 7269: if test -n "$export_symbols" && test -n "$include_expsyms"; then 7270: tmp_export_symbols="$export_symbols" 7271: test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" 7272: $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"' 7273: fi 7274: 7275: if test -n "$orig_export_symbols"; then 7276: # The given exports_symbols file has to be filtered, so filter it. 7277: func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" 7278: # FIXME: $output_objdir/$libname.filter potentially contains lots of 7279: # 's' commands which not all seds can handle. GNU sed should be fine 7280: # though. Also, the filter scales superlinearly with the number of 7281: # global variables. join(1) would be nice here, but unfortunately 7282: # isn't a blessed tool. 7283: $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter 7284: delfiles="$delfiles $export_symbols $output_objdir/$libname.filter" 7285: export_symbols=$output_objdir/$libname.def 7286: $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols 7287: fi 7288: fi 7289: 7290: libobjs=$output 7291: # Restore the value of output. 7292: output=$save_output 7293: 7294: if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then 7295: eval libobjs=\"\$libobjs $whole_archive_flag_spec\" 7296: test "X$libobjs" = "X " && libobjs= 7297: fi 7298: # Expand the library linking commands again to reset the 7299: # value of $libobjs for piecewise linking. 7300: 7301: # Do each of the archive commands. 7302: if test "$module" = yes && test -n "$module_cmds" ; then 7303: if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then 7304: cmds=$module_expsym_cmds 7305: else 7306: cmds=$module_cmds 7307: fi 7308: else 7309: if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then 7310: cmds=$archive_expsym_cmds 7311: else 7312: cmds=$archive_cmds 7313: fi 7314: fi 7315: fi 7316: 7317: if test -n "$delfiles"; then 7318: # Append the command to remove temporary files to $cmds. 7319: eval cmds=\"\$cmds~\$RM $delfiles\" 7320: fi 7321: 7322: # Add any objects from preloaded convenience libraries 7323: if test -n "$dlprefiles"; then 7324: gentop="$output_objdir/${outputname}x" 7325: generated="$generated $gentop" 7326: 7327: func_extract_archives $gentop $dlprefiles 7328: libobjs="$libobjs $func_extract_archives_result" 7329: test "X$libobjs" = "X " && libobjs= 7330: fi 7331: 7332: save_ifs="$IFS"; IFS='~' 7333: for cmd in $cmds; do 7334: IFS="$save_ifs" 7335: eval cmd=\"$cmd\" 7336: $opt_silent || { 7337: func_quote_for_expand "$cmd" 7338: eval "func_echo $func_quote_for_expand_result" 7339: } 7340: $opt_dry_run || eval "$cmd" || { 7341: lt_exit=$? 7342: 7343: # Restore the uninstalled library and exit 7344: if test "$mode" = relink; then 7345: ( cd "$output_objdir" && \ 7346: $RM "${realname}T" && \ 7347: $MV "${realname}U" "$realname" ) 7348: fi 7349: 7350: exit $lt_exit 7351: } 7352: done 7353: IFS="$save_ifs" 7354: 7355: # Restore the uninstalled library and exit 7356: if test "$mode" = relink; then 7357: $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? 7358: 7359: if test -n "$convenience"; then 7360: if test -z "$whole_archive_flag_spec"; then 7361: func_show_eval '${RM}r "$gentop"' 7362: fi 7363: fi 7364: 7365: exit $EXIT_SUCCESS 7366: fi 7367: 7368: # Create links to the real library. 7369: for linkname in $linknames; do 7370: if test "$realname" != "$linkname"; then 7371: func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' 7372: fi 7373: done 7374: 7375: # If -module or -export-dynamic was specified, set the dlname. 7376: if test "$module" = yes || test "$export_dynamic" = yes; then 7377: # On all known operating systems, these are identical. 7378: dlname="$soname" 7379: fi 7380: fi 7381: ;; 7382: 7383: obj) 7384: if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then 7385: func_warning "\`-dlopen' is ignored for objects" 7386: fi 7387: 7388: case " $deplibs" in 7389: *\ -l* | *\ -L*) 7390: func_warning "\`-l' and \`-L' are ignored for objects" ;; 7391: esac 7392: 7393: test -n "$rpath" && \ 7394: func_warning "\`-rpath' is ignored for objects" 7395: 7396: test -n "$xrpath" && \ 7397: func_warning "\`-R' is ignored for objects" 7398: 7399: test -n "$vinfo" && \ 7400: func_warning "\`-version-info' is ignored for objects" 7401: 7402: test -n "$release" && \ 7403: func_warning "\`-release' is ignored for objects" 7404: 7405: case $output in 7406: *.lo) 7407: test -n "$objs$old_deplibs" && \ 7408: func_fatal_error "cannot build library object \`$output' from non-libtool objects" 7409: 7410: libobj=$output 7411: func_lo2o "$libobj" 7412: obj=$func_lo2o_result 7413: ;; 7414: *) 7415: libobj= 7416: obj="$output" 7417: ;; 7418: esac 7419: 7420: # Delete the old objects. 7421: $opt_dry_run || $RM $obj $libobj 7422: 7423: # Objects from convenience libraries. This assumes 7424: # single-version convenience libraries. Whenever we create 7425: # different ones for PIC/non-PIC, this we'll have to duplicate 7426: # the extraction. 7427: reload_conv_objs= 7428: gentop= 7429: # reload_cmds runs $LD directly, so let us get rid of 7430: # -Wl from whole_archive_flag_spec and hope we can get by with 7431: # turning comma into space.. 7432: wl= 7433: 7434: if test -n "$convenience"; then 7435: if test -n "$whole_archive_flag_spec"; then 7436: eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" 7437: reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'` 7438: else 7439: gentop="$output_objdir/${obj}x" 7440: generated="$generated $gentop" 7441: 7442: func_extract_archives $gentop $convenience 7443: reload_conv_objs="$reload_objs $func_extract_archives_result" 7444: fi 7445: fi 7446: 7447: # Create the old-style object. 7448: reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test 7449: 7450: output="$obj" 7451: func_execute_cmds "$reload_cmds" 'exit $?' 7452: 7453: # Exit if we aren't doing a library object file. 7454: if test -z "$libobj"; then 7455: if test -n "$gentop"; then 7456: func_show_eval '${RM}r "$gentop"' 7457: fi 7458: 7459: exit $EXIT_SUCCESS 7460: fi 7461: 7462: if test "$build_libtool_libs" != yes; then 7463: if test -n "$gentop"; then 7464: func_show_eval '${RM}r "$gentop"' 7465: fi 7466: 7467: # Create an invalid libtool object if no PIC, so that we don't 7468: # accidentally link it into a program. 7469: # $show "echo timestamp > $libobj" 7470: # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? 7471: exit $EXIT_SUCCESS 7472: fi 7473: 7474: if test -n "$pic_flag" || test "$pic_mode" != default; then 7475: # Only do commands if we really have different PIC objects. 7476: reload_objs="$libobjs $reload_conv_objs" 7477: output="$libobj" 7478: func_execute_cmds "$reload_cmds" 'exit $?' 7479: fi 7480: 7481: if test -n "$gentop"; then 7482: func_show_eval '${RM}r "$gentop"' 7483: fi 7484: 7485: exit $EXIT_SUCCESS 7486: ;; 7487: 7488: prog) 7489: case $host in 7490: *cygwin*) func_stripname '' '.exe' "$output" 7491: output=$func_stripname_result.exe;; 7492: esac 7493: test -n "$vinfo" && \ 7494: func_warning "\`-version-info' is ignored for programs" 7495: 7496: test -n "$release" && \ 7497: func_warning "\`-release' is ignored for programs" 7498: 7499: test "$preload" = yes \ 7500: && test "$dlopen_support" = unknown \ 7501: && test "$dlopen_self" = unknown \ 7502: && test "$dlopen_self_static" = unknown && \ 7503: func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." 7504: 7505: case $host in 7506: *-*-rhapsody* | *-*-darwin1.[012]) 7507: # On Rhapsody replace the C library is the System framework 7508: compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 7509: finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'` 7510: ;; 7511: esac 7512: 7513: case $host in 7514: *-*-darwin*) 7515: # Don't allow lazy linking, it breaks C++ global constructors 7516: # But is supposedly fixed on 10.4 or later (yay!). 7517: if test "$tagname" = CXX ; then 7518: case ${MACOSX_DEPLOYMENT_TARGET-10.0} in 7519: 10.[0123]) 7520: compile_command="$compile_command ${wl}-bind_at_load" 7521: finalize_command="$finalize_command ${wl}-bind_at_load" 7522: ;; 7523: esac 7524: fi 7525: # Time to change all our "foo.ltframework" stuff back to "-framework foo" 7526: compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 7527: finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'` 7528: ;; 7529: esac 7530: 7531: 7532: # move library search paths that coincide with paths to not yet 7533: # installed libraries to the beginning of the library search list 7534: new_libs= 7535: for path in $notinst_path; do 7536: case " $new_libs " in 7537: *" -L$path/$objdir "*) ;; 7538: *) 7539: case " $compile_deplibs " in 7540: *" -L$path/$objdir "*) 7541: new_libs="$new_libs -L$path/$objdir" ;; 7542: esac 7543: ;; 7544: esac 7545: done 7546: for deplib in $compile_deplibs; do 7547: case $deplib in 7548: -L*) 7549: case " $new_libs " in 7550: *" $deplib "*) ;; 7551: *) new_libs="$new_libs $deplib" ;; 7552: esac 7553: ;; 7554: *) new_libs="$new_libs $deplib" ;; 7555: esac 7556: done 7557: compile_deplibs="$new_libs" 7558: 7559: 7560: compile_command="$compile_command $compile_deplibs" 7561: finalize_command="$finalize_command $finalize_deplibs" 7562: 7563: if test -n "$rpath$xrpath"; then 7564: # If the user specified any rpath flags, then add them. 7565: for libdir in $rpath $xrpath; do 7566: # This is the magic to use -rpath. 7567: case "$finalize_rpath " in 7568: *" $libdir "*) ;; 7569: *) finalize_rpath="$finalize_rpath $libdir" ;; 7570: esac 7571: done 7572: fi 7573: 7574: # Now hardcode the library paths 7575: rpath= 7576: hardcode_libdirs= 7577: for libdir in $compile_rpath $finalize_rpath; do 7578: if test -n "$hardcode_libdir_flag_spec"; then 7579: if test -n "$hardcode_libdir_separator"; then 7580: if test -z "$hardcode_libdirs"; then 7581: hardcode_libdirs="$libdir" 7582: else 7583: # Just accumulate the unique libdirs. 7584: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 7585: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 7586: ;; 7587: *) 7588: hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 7589: ;; 7590: esac 7591: fi 7592: else 7593: eval flag=\"$hardcode_libdir_flag_spec\" 7594: rpath="$rpath $flag" 7595: fi 7596: elif test -n "$runpath_var"; then 7597: case "$perm_rpath " in 7598: *" $libdir "*) ;; 7599: *) perm_rpath="$perm_rpath $libdir" ;; 7600: esac 7601: fi 7602: case $host in 7603: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) 7604: testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` 7605: case :$dllsearchpath: in 7606: *":$libdir:"*) ;; 7607: ::) dllsearchpath=$libdir;; 7608: *) dllsearchpath="$dllsearchpath:$libdir";; 7609: esac 7610: case :$dllsearchpath: in 7611: *":$testbindir:"*) ;; 7612: ::) dllsearchpath=$testbindir;; 7613: *) dllsearchpath="$dllsearchpath:$testbindir";; 7614: esac 7615: ;; 7616: esac 7617: done 7618: # Substitute the hardcoded libdirs into the rpath. 7619: if test -n "$hardcode_libdir_separator" && 7620: test -n "$hardcode_libdirs"; then 7621: libdir="$hardcode_libdirs" 7622: eval rpath=\" $hardcode_libdir_flag_spec\" 7623: fi 7624: compile_rpath="$rpath" 7625: 7626: rpath= 7627: hardcode_libdirs= 7628: for libdir in $finalize_rpath; do 7629: if test -n "$hardcode_libdir_flag_spec"; then 7630: if test -n "$hardcode_libdir_separator"; then 7631: if test -z "$hardcode_libdirs"; then 7632: hardcode_libdirs="$libdir" 7633: else 7634: # Just accumulate the unique libdirs. 7635: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in 7636: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) 7637: ;; 7638: *) 7639: hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" 7640: ;; 7641: esac 7642: fi 7643: else 7644: eval flag=\"$hardcode_libdir_flag_spec\" 7645: rpath="$rpath $flag" 7646: fi 7647: elif test -n "$runpath_var"; then 7648: case "$finalize_perm_rpath " in 7649: *" $libdir "*) ;; 7650: *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;; 7651: esac 7652: fi 7653: done 7654: # Substitute the hardcoded libdirs into the rpath. 7655: if test -n "$hardcode_libdir_separator" && 7656: test -n "$hardcode_libdirs"; then 7657: libdir="$hardcode_libdirs" 7658: eval rpath=\" $hardcode_libdir_flag_spec\" 7659: fi 7660: finalize_rpath="$rpath" 7661: 7662: if test -n "$libobjs" && test "$build_old_libs" = yes; then 7663: # Transform all the library objects into standard objects. 7664: compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 7665: finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` 7666: fi 7667: 7668: func_generate_dlsyms "$outputname" "@PROGRAM@" "no" 7669: 7670: # template prelinking step 7671: if test -n "$prelink_cmds"; then 7672: func_execute_cmds "$prelink_cmds" 'exit $?' 7673: fi 7674: 7675: wrappers_required=yes 7676: case $host in 7677: *cygwin* | *mingw* ) 7678: if test "$build_libtool_libs" != yes; then 7679: wrappers_required=no 7680: fi 7681: ;; 7682: *cegcc) 7683: # Disable wrappers for cegcc, we are cross compiling anyway. 7684: wrappers_required=no 7685: ;; 7686: *) 7687: if test "$need_relink" = no || test "$build_libtool_libs" != yes; then 7688: wrappers_required=no 7689: fi 7690: ;; 7691: esac 7692: if test "$wrappers_required" = no; then 7693: # Replace the output file specification. 7694: compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` 7695: link_command="$compile_command$compile_rpath" 7696: 7697: # We have no uninstalled library dependencies, so finalize right now. 7698: exit_status=0 7699: func_show_eval "$link_command" 'exit_status=$?' 7700: 7701: # Delete the generated files. 7702: if test -f "$output_objdir/${outputname}S.${objext}"; then 7703: func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' 7704: fi 7705: 7706: exit $exit_status 7707: fi 7708: 7709: if test -n "$compile_shlibpath$finalize_shlibpath"; then 7710: compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" 7711: fi 7712: if test -n "$finalize_shlibpath"; then 7713: finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" 7714: fi 7715: 7716: compile_var= 7717: finalize_var= 7718: if test -n "$runpath_var"; then 7719: if test -n "$perm_rpath"; then 7720: # We should set the runpath_var. 7721: rpath= 7722: for dir in $perm_rpath; do 7723: rpath="$rpath$dir:" 7724: done 7725: compile_var="$runpath_var=\"$rpath\$$runpath_var\" " 7726: fi 7727: if test -n "$finalize_perm_rpath"; then 7728: # We should set the runpath_var. 7729: rpath= 7730: for dir in $finalize_perm_rpath; do 7731: rpath="$rpath$dir:" 7732: done 7733: finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " 7734: fi 7735: fi 7736: 7737: if test "$no_install" = yes; then 7738: # We don't need to create a wrapper script. 7739: link_command="$compile_var$compile_command$compile_rpath" 7740: # Replace the output file specification. 7741: link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` 7742: # Delete the old output file. 7743: $opt_dry_run || $RM $output 7744: # Link the executable and exit 7745: func_show_eval "$link_command" 'exit $?' 7746: exit $EXIT_SUCCESS 7747: fi 7748: 7749: if test "$hardcode_action" = relink; then 7750: # Fast installation is not supported 7751: link_command="$compile_var$compile_command$compile_rpath" 7752: relink_command="$finalize_var$finalize_command$finalize_rpath" 7753: 7754: func_warning "this platform does not like uninstalled shared libraries" 7755: func_warning "\`$output' will be relinked during installation" 7756: else 7757: if test "$fast_install" != no; then 7758: link_command="$finalize_var$compile_command$finalize_rpath" 7759: if test "$fast_install" = yes; then 7760: relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'` 7761: else 7762: # fast_install is set to needless 7763: relink_command= 7764: fi 7765: else 7766: link_command="$compile_var$compile_command$compile_rpath" 7767: relink_command="$finalize_var$finalize_command$finalize_rpath" 7768: fi 7769: fi 7770: 7771: # Replace the output file specification. 7772: link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` 7773: 7774: # Delete the old output files. 7775: $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname 7776: 7777: func_show_eval "$link_command" 'exit $?' 7778: 7779: # Now create the wrapper script. 7780: func_verbose "creating $output" 7781: 7782: # Quote the relink command for shipping. 7783: if test -n "$relink_command"; then 7784: # Preserve any variables that may affect compiler behavior 7785: for var in $variables_saved_for_relink; do 7786: if eval test -z \"\${$var+set}\"; then 7787: relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 7788: elif eval var_value=\$$var; test -z "$var_value"; then 7789: relink_command="$var=; export $var; $relink_command" 7790: else 7791: func_quote_for_eval "$var_value" 7792: relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 7793: fi 7794: done 7795: relink_command="(cd `pwd`; $relink_command)" 7796: relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"` 7797: fi 7798: 7799: # Quote $ECHO for shipping. 7800: if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then 7801: case $progpath in 7802: [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";; 7803: *) qecho="$SHELL `pwd`/$progpath --fallback-echo";; 7804: esac 7805: qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"` 7806: else 7807: qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"` 7808: fi 7809: 7810: # Only actually do things if not in dry run mode. 7811: $opt_dry_run || { 7812: # win32 will think the script is a binary if it has 7813: # a .exe suffix, so we strip it off here. 7814: case $output in 7815: *.exe) func_stripname '' '.exe' "$output" 7816: output=$func_stripname_result ;; 7817: esac 7818: # test for cygwin because mv fails w/o .exe extensions 7819: case $host in 7820: *cygwin*) 7821: exeext=.exe 7822: func_stripname '' '.exe' "$outputname" 7823: outputname=$func_stripname_result ;; 7824: *) exeext= ;; 7825: esac 7826: case $host in 7827: *cygwin* | *mingw* ) 7828: func_dirname_and_basename "$output" "" "." 7829: output_name=$func_basename_result 7830: output_path=$func_dirname_result 7831: cwrappersource="$output_path/$objdir/lt-$output_name.c" 7832: cwrapper="$output_path/$output_name.exe" 7833: $RM $cwrappersource $cwrapper 7834: trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 7835: 7836: func_emit_cwrapperexe_src > $cwrappersource 7837: 7838: # The wrapper executable is built using the $host compiler, 7839: # because it contains $host paths and files. If cross- 7840: # compiling, it, like the target executable, must be 7841: # executed on the $host or under an emulation environment. 7842: $opt_dry_run || { 7843: $LTCC $LTCFLAGS -o $cwrapper $cwrappersource 7844: $STRIP $cwrapper 7845: } 7846: 7847: # Now, create the wrapper script for func_source use: 7848: func_ltwrapper_scriptname $cwrapper 7849: $RM $func_ltwrapper_scriptname_result 7850: trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 7851: $opt_dry_run || { 7852: # note: this script will not be executed, so do not chmod. 7853: if test "x$build" = "x$host" ; then 7854: $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result 7855: else 7856: func_emit_wrapper no > $func_ltwrapper_scriptname_result 7857: fi 7858: } 7859: ;; 7860: * ) 7861: $RM $output 7862: trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 7863: 7864: func_emit_wrapper no > $output 7865: chmod +x $output 7866: ;; 7867: esac 7868: } 7869: exit $EXIT_SUCCESS 7870: ;; 7871: esac 7872: 7873: # See if we need to build an old-fashioned archive. 7874: for oldlib in $oldlibs; do 7875: 7876: if test "$build_libtool_libs" = convenience; then 7877: oldobjs="$libobjs_save $symfileobj" 7878: addlibs="$convenience" 7879: build_libtool_libs=no 7880: else 7881: if test "$build_libtool_libs" = module; then 7882: oldobjs="$libobjs_save" 7883: build_libtool_libs=no 7884: else 7885: oldobjs="$old_deplibs $non_pic_objects" 7886: if test "$preload" = yes && test -f "$symfileobj"; then 7887: oldobjs="$oldobjs $symfileobj" 7888: fi 7889: fi 7890: addlibs="$old_convenience" 7891: fi 7892: 7893: if test -n "$addlibs"; then 7894: gentop="$output_objdir/${outputname}x" 7895: generated="$generated $gentop" 7896: 7897: func_extract_archives $gentop $addlibs 7898: oldobjs="$oldobjs $func_extract_archives_result" 7899: fi 7900: 7901: # Do each command in the archive commands. 7902: if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then 7903: cmds=$old_archive_from_new_cmds 7904: else 7905: 7906: # Add any objects from preloaded convenience libraries 7907: if test -n "$dlprefiles"; then 7908: gentop="$output_objdir/${outputname}x" 7909: generated="$generated $gentop" 7910: 7911: func_extract_archives $gentop $dlprefiles 7912: oldobjs="$oldobjs $func_extract_archives_result" 7913: fi 7914: 7915: # POSIX demands no paths to be encoded in archives. We have 7916: # to avoid creating archives with duplicate basenames if we 7917: # might have to extract them afterwards, e.g., when creating a 7918: # static archive out of a convenience library, or when linking 7919: # the entirety of a libtool archive into another (currently 7920: # not supported by libtool). 7921: if (for obj in $oldobjs 7922: do 7923: func_basename "$obj" 7924: $ECHO "$func_basename_result" 7925: done | sort | sort -uc >/dev/null 2>&1); then 7926: : 7927: else 7928: $ECHO "copying selected object files to avoid basename conflicts..." 7929: gentop="$output_objdir/${outputname}x" 7930: generated="$generated $gentop" 7931: func_mkdir_p "$gentop" 7932: save_oldobjs=$oldobjs 7933: oldobjs= 7934: counter=1 7935: for obj in $save_oldobjs 7936: do 7937: func_basename "$obj" 7938: objbase="$func_basename_result" 7939: case " $oldobjs " in 7940: " ") oldobjs=$obj ;; 7941: *[\ /]"$objbase "*) 7942: while :; do 7943: # Make sure we don't pick an alternate name that also 7944: # overlaps. 7945: newobj=lt$counter-$objbase 7946: func_arith $counter + 1 7947: counter=$func_arith_result 7948: case " $oldobjs " in 7949: *[\ /]"$newobj "*) ;; 7950: *) if test ! -f "$gentop/$newobj"; then break; fi ;; 7951: esac 7952: done 7953: func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" 7954: oldobjs="$oldobjs $gentop/$newobj" 7955: ;; 7956: *) oldobjs="$oldobjs $obj" ;; 7957: esac 7958: done 7959: fi 7960: eval cmds=\"$old_archive_cmds\" 7961: 7962: func_len " $cmds" 7963: len=$func_len_result 7964: if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then 7965: cmds=$old_archive_cmds 7966: else 7967: # the command line is too long to link in one step, link in parts 7968: func_verbose "using piecewise archive linking..." 7969: save_RANLIB=$RANLIB 7970: RANLIB=: 7971: objlist= 7972: concat_cmds= 7973: save_oldobjs=$oldobjs 7974: oldobjs= 7975: # Is there a better way of finding the last object in the list? 7976: for obj in $save_oldobjs 7977: do 7978: last_oldobj=$obj 7979: done 7980: eval test_cmds=\"$old_archive_cmds\" 7981: func_len " $test_cmds" 7982: len0=$func_len_result 7983: len=$len0 7984: for obj in $save_oldobjs 7985: do 7986: func_len " $obj" 7987: func_arith $len + $func_len_result 7988: len=$func_arith_result 7989: func_append objlist " $obj" 7990: if test "$len" -lt "$max_cmd_len"; then 7991: : 7992: else 7993: # the above command should be used before it gets too long 7994: oldobjs=$objlist 7995: if test "$obj" = "$last_oldobj" ; then 7996: RANLIB=$save_RANLIB 7997: fi 7998: test -z "$concat_cmds" || concat_cmds=$concat_cmds~ 7999: eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" 8000: objlist= 8001: len=$len0 8002: fi 8003: done 8004: RANLIB=$save_RANLIB 8005: oldobjs=$objlist 8006: if test "X$oldobjs" = "X" ; then 8007: eval cmds=\"\$concat_cmds\" 8008: else 8009: eval cmds=\"\$concat_cmds~\$old_archive_cmds\" 8010: fi 8011: fi 8012: fi 8013: func_execute_cmds "$cmds" 'exit $?' 8014: done 8015: 8016: test -n "$generated" && \ 8017: func_show_eval "${RM}r$generated" 8018: 8019: # Now create the libtool archive. 8020: case $output in 8021: *.la) 8022: old_library= 8023: test "$build_old_libs" = yes && old_library="$libname.$libext" 8024: func_verbose "creating $output" 8025: 8026: # Preserve any variables that may affect compiler behavior 8027: for var in $variables_saved_for_relink; do 8028: if eval test -z \"\${$var+set}\"; then 8029: relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" 8030: elif eval var_value=\$$var; test -z "$var_value"; then 8031: relink_command="$var=; export $var; $relink_command" 8032: else 8033: func_quote_for_eval "$var_value" 8034: relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" 8035: fi 8036: done 8037: # Quote the link command for shipping. 8038: relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" 8039: relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"` 8040: if test "$hardcode_automatic" = yes ; then 8041: relink_command= 8042: fi 8043: 8044: # Only create the output if not a dry run. 8045: $opt_dry_run || { 8046: for installed in no yes; do 8047: if test "$installed" = yes; then 8048: if test -z "$install_libdir"; then 8049: break 8050: fi 8051: output="$output_objdir/$outputname"i 8052: # Replace all uninstalled libtool libraries with the installed ones 8053: newdependency_libs= 8054: for deplib in $dependency_libs; do 8055: case $deplib in 8056: *.la) 8057: func_basename "$deplib" 8058: name="$func_basename_result" 8059: eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib` 8060: test -z "$libdir" && \ 8061: func_fatal_error "\`$deplib' is not a valid libtool archive" 8062: newdependency_libs="$newdependency_libs $libdir/$name" 8063: ;; 8064: *) newdependency_libs="$newdependency_libs $deplib" ;; 8065: esac 8066: done 8067: dependency_libs="$newdependency_libs" 8068: newdlfiles= 8069: 8070: for lib in $dlfiles; do 8071: case $lib in 8072: *.la) 8073: func_basename "$lib" 8074: name="$func_basename_result" 8075: eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib` 8076: test -z "$libdir" && \ 8077: func_fatal_error "\`$lib' is not a valid libtool archive" 8078: newdlfiles="$newdlfiles $libdir/$name" 8079: ;; 8080: *) newdlfiles="$newdlfiles $lib" ;; 8081: esac 8082: done 8083: dlfiles="$newdlfiles" 8084: newdlprefiles= 8085: for lib in $dlprefiles; do 8086: case $lib in 8087: *.la) 8088: # Only pass preopened files to the pseudo-archive (for 8089: # eventual linking with the app. that links it) if we 8090: # didn't already link the preopened objects directly into 8091: # the library: 8092: func_basename "$lib" 8093: name="$func_basename_result" 8094: eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib` 8095: test -z "$libdir" && \ 8096: func_fatal_error "\`$lib' is not a valid libtool archive" 8097: newdlprefiles="$newdlprefiles $libdir/$name" 8098: ;; 8099: esac 8100: done 8101: dlprefiles="$newdlprefiles" 8102: else 8103: newdlfiles= 8104: for lib in $dlfiles; do 8105: case $lib in 8106: [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 8107: *) abs=`pwd`"/$lib" ;; 8108: esac 8109: newdlfiles="$newdlfiles $abs" 8110: done 8111: dlfiles="$newdlfiles" 8112: newdlprefiles= 8113: for lib in $dlprefiles; do 8114: case $lib in 8115: [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; 8116: *) abs=`pwd`"/$lib" ;; 8117: esac 8118: newdlprefiles="$newdlprefiles $abs" 8119: done 8120: dlprefiles="$newdlprefiles" 8121: fi 8122: $RM $output 8123: # place dlname in correct position for cygwin 8124: tdlname=$dlname 8125: case $host,$output,$installed,$module,$dlname in 8126: *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;; 8127: esac 8128: $ECHO > $output "\ 8129: # $outputname - a libtool library file 8130: # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION 8131: # 8132: # Please DO NOT delete this file! 8133: # It is necessary for linking the library. 8134: 8135: # The name that we can dlopen(3). 8136: dlname='$tdlname' 8137: 8138: # Names of this library. 8139: library_names='$library_names' 8140: 8141: # The name of the static archive. 8142: old_library='$old_library' 8143: 8144: # Linker flags that can not go in dependency_libs. 8145: inherited_linker_flags='$new_inherited_linker_flags' 8146: 8147: # Libraries that this one depends upon. 8148: dependency_libs='$dependency_libs' 8149: 8150: # Names of additional weak libraries provided by this library 8151: weak_library_names='$weak_libs' 8152: 8153: # Version information for $libname. 8154: current=$current 8155: age=$age 8156: revision=$revision 8157: 8158: # Is this an already installed library? 8159: installed=$installed 8160: 8161: # Should we warn about portability when linking against -modules? 8162: shouldnotlink=$module 8163: 8164: # Files to dlopen/dlpreopen 8165: dlopen='$dlfiles' 8166: dlpreopen='$dlprefiles' 8167: 8168: # Directory that this library needs to be installed in: 8169: libdir='$install_libdir'" 8170: if test "$installed" = no && test "$need_relink" = yes; then 8171: $ECHO >> $output "\ 8172: relink_command=\"$relink_command\"" 8173: fi 8174: done 8175: } 8176: 8177: # Do a symbolic link so that the libtool archive can be found in 8178: # LD_LIBRARY_PATH before the program is installed. 8179: func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' 8180: ;; 8181: esac 8182: exit $EXIT_SUCCESS 8183: } 8184: 8185: { test "$mode" = link || test "$mode" = relink; } && 8186: func_mode_link ${1+"$@"} 8187: 8188: 8189: # func_mode_uninstall arg... 8190: func_mode_uninstall () 8191: { 8192: $opt_debug 8193: RM="$nonopt" 8194: files= 8195: rmforce= 8196: exit_status=0 8197: 8198: # This variable tells wrapper scripts just to set variables rather 8199: # than running their programs. 8200: libtool_install_magic="$magic" 8201: 8202: for arg 8203: do 8204: case $arg in 8205: -f) RM="$RM $arg"; rmforce=yes ;; 8206: -*) RM="$RM $arg" ;; 8207: *) files="$files $arg" ;; 8208: esac 8209: done 8210: 8211: test -z "$RM" && \ 8212: func_fatal_help "you must specify an RM program" 8213: 8214: rmdirs= 8215: 8216: origobjdir="$objdir" 8217: for file in $files; do 8218: func_dirname "$file" "" "." 8219: dir="$func_dirname_result" 8220: if test "X$dir" = X.; then 8221: objdir="$origobjdir" 8222: else 8223: objdir="$dir/$origobjdir" 8224: fi 8225: func_basename "$file" 8226: name="$func_basename_result" 8227: test "$mode" = uninstall && objdir="$dir" 8228: 8229: # Remember objdir for removal later, being careful to avoid duplicates 8230: if test "$mode" = clean; then 8231: case " $rmdirs " in 8232: *" $objdir "*) ;; 8233: *) rmdirs="$rmdirs $objdir" ;; 8234: esac 8235: fi 8236: 8237: # Don't error if the file doesn't exist and rm -f was used. 8238: if { test -L "$file"; } >/dev/null 2>&1 || 8239: { test -h "$file"; } >/dev/null 2>&1 || 8240: test -f "$file"; then 8241: : 8242: elif test -d "$file"; then 8243: exit_status=1 8244: continue 8245: elif test "$rmforce" = yes; then 8246: continue 8247: fi 8248: 8249: rmfiles="$file" 8250: 8251: case $name in 8252: *.la) 8253: # Possibly a libtool archive, so verify it. 8254: if func_lalib_p "$file"; then 8255: func_source $dir/$name 8256: 8257: # Delete the libtool libraries and symlinks. 8258: for n in $library_names; do 8259: rmfiles="$rmfiles $objdir/$n" 8260: done 8261: test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library" 8262: 8263: case "$mode" in 8264: clean) 8265: case " $library_names " in 8266: # " " in the beginning catches empty $dlname 8267: *" $dlname "*) ;; 8268: *) rmfiles="$rmfiles $objdir/$dlname" ;; 8269: esac 8270: test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i" 8271: ;; 8272: uninstall) 8273: if test -n "$library_names"; then 8274: # Do each command in the postuninstall commands. 8275: func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 8276: fi 8277: 8278: if test -n "$old_library"; then 8279: # Do each command in the old_postuninstall commands. 8280: func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' 8281: fi 8282: # FIXME: should reinstall the best remaining shared library. 8283: ;; 8284: esac 8285: fi 8286: ;; 8287: 8288: *.lo) 8289: # Possibly a libtool object, so verify it. 8290: if func_lalib_p "$file"; then 8291: 8292: # Read the .lo file 8293: func_source $dir/$name 8294: 8295: # Add PIC object to the list of files to remove. 8296: if test -n "$pic_object" && 8297: test "$pic_object" != none; then 8298: rmfiles="$rmfiles $dir/$pic_object" 8299: fi 8300: 8301: # Add non-PIC object to the list of files to remove. 8302: if test -n "$non_pic_object" && 8303: test "$non_pic_object" != none; then 8304: rmfiles="$rmfiles $dir/$non_pic_object" 8305: fi 8306: fi 8307: ;; 8308: 8309: *) 8310: if test "$mode" = clean ; then 8311: noexename=$name 8312: case $file in 8313: *.exe) 8314: func_stripname '' '.exe' "$file" 8315: file=$func_stripname_result 8316: func_stripname '' '.exe' "$name" 8317: noexename=$func_stripname_result 8318: # $file with .exe has already been added to rmfiles, 8319: # add $file without .exe 8320: rmfiles="$rmfiles $file" 8321: ;; 8322: esac 8323: # Do a test to see if this is a libtool program. 8324: if func_ltwrapper_p "$file"; then 8325: if func_ltwrapper_executable_p "$file"; then 8326: func_ltwrapper_scriptname "$file" 8327: relink_command= 8328: func_source $func_ltwrapper_scriptname_result 8329: rmfiles="$rmfiles $func_ltwrapper_scriptname_result" 8330: else 8331: relink_command= 8332: func_source $dir/$noexename 8333: fi 8334: 8335: # note $name still contains .exe if it was in $file originally 8336: # as does the version of $file that was added into $rmfiles 8337: rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}" 8338: if test "$fast_install" = yes && test -n "$relink_command"; then 8339: rmfiles="$rmfiles $objdir/lt-$name" 8340: fi 8341: if test "X$noexename" != "X$name" ; then 8342: rmfiles="$rmfiles $objdir/lt-${noexename}.c" 8343: fi 8344: fi 8345: fi 8346: ;; 8347: esac 8348: func_show_eval "$RM $rmfiles" 'exit_status=1' 8349: done 8350: objdir="$origobjdir" 8351: 8352: # Try to remove the ${objdir}s in the directories where we deleted files 8353: for dir in $rmdirs; do 8354: if test -d "$dir"; then 8355: func_show_eval "rmdir $dir >/dev/null 2>&1" 8356: fi 8357: done 8358: 8359: exit $exit_status 8360: } 8361: 8362: { test "$mode" = uninstall || test "$mode" = clean; } && 8363: func_mode_uninstall ${1+"$@"} 8364: 8365: test -z "$mode" && { 8366: help="$generic_help" 8367: func_fatal_help "you must specify a MODE" 8368: } 8369: 8370: test -z "$exec_cmd" && \ 8371: func_fatal_help "invalid operation mode \`$mode'" 8372: 8373: if test -n "$exec_cmd"; then 8374: eval exec "$exec_cmd" 8375: exit $EXIT_FAILURE 8376: fi 8377: 8378: exit $exit_status 8379: 8380: 8381: # The TAGs below are defined such that we never get into a situation 8382: # in which we disable both kinds of libraries. Given conflicting 8383: # choices, we go for a static library, that is the most portable, 8384: # since we can't tell whether shared libraries were disabled because 8385: # the user asked for that or because the platform doesn't support 8386: # them. This is particularly important on AIX, because we don't 8387: # support having both static and shared libraries enabled at the same 8388: # time on that platform, so we default to a shared-only configuration. 8389: # If a disable-shared tag is given, we'll fallback to a static-only 8390: # configuration. But we'll never go from static-only to shared-only. 8391: 8392: # ### BEGIN LIBTOOL TAG CONFIG: disable-shared 8393: build_libtool_libs=no 8394: build_old_libs=yes 8395: # ### END LIBTOOL TAG CONFIG: disable-shared 8396: 8397: # ### BEGIN LIBTOOL TAG CONFIG: disable-static 8398: build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` 8399: # ### END LIBTOOL TAG CONFIG: disable-static 8400: 8401: # Local Variables: 8402: # mode:shell-script 8403: # sh-indentation:2 8404: # End: 8405: # vi:sw=2 8406: