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