1420
840
avoid parallel builds (make -j) in this platform, or get a better
1423
$opt_dry_run || $RM $removelist
1424
844
exit $EXIT_FAILURE
1427
847
# Just move the object if needed
1428
848
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1429
func_show_eval '$MV "$output_obj" "$obj"' \
1430
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1435
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1437
# Unlock the critical section if it was locked
1438
if test "$need_locks" != no; then
1439
removelist=$lockfile
1448
test "$mode" = compile && func_mode_compile ${1+"$@"}
1453
# We need to display help for each of the modes.
1456
# Generic help is extracted from the usage comments
1457
# at the start of this file.
1463
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1465
Remove files from the build directory.
1467
RM is the name of the program to use to delete files associated with each FILE
1468
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1471
If FILE is a libtool library, object or program, all the files associated
1472
with it are deleted. Otherwise, only FILE itself is deleted using RM."
1477
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1479
Compile a source file into a libtool library object.
1481
This mode accepts the following additional options:
1483
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1484
-no-suppress do not suppress compiler output for multiple passes
1485
-prefer-pic try to building PIC objects only
1486
-prefer-non-pic try to building non-PIC objects only
1487
-shared do not build a \`.o' file suitable for static linking
1488
-static only build a \`.o' file suitable for static linking
1490
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1491
from the given SOURCEFILE.
1493
The output file name is determined by removing the directory component from
1494
SOURCEFILE, then substituting the C source code suffix \`.c' with the
1495
library object suffix, \`.lo'."
1500
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1502
Automatically set library path, then run a program.
1504
This mode accepts the following additional options:
1506
-dlopen FILE add the directory containing FILE to the library path
1508
This mode sets the library path environment variable according to \`-dlopen'
1511
If any of the ARGS are libtool executable wrappers, then they are translated
1512
into their corresponding uninstalled binary, and any of their required library
1513
directories are added to the library path.
1515
Then, COMMAND is executed, with ARGS as arguments."
1520
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1522
Complete the installation of libtool libraries.
1524
Each LIBDIR is a directory that contains libtool libraries.
1526
The commands that this mode executes may require superuser privileges. Use
1527
the \`--dry-run' option if you just want to see what would be executed."
1532
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1534
Install executables or libraries.
1536
INSTALL-COMMAND is the installation command. The first component should be
1537
either the \`install' or \`cp' program.
1539
The following components of INSTALL-COMMAND are treated specially:
1541
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1543
The rest of the components are interpreted as arguments to that command (only
1544
BSD-compatible install options are recognized)."
1549
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1551
Link object files or libraries together to form another library, or to
1552
create an executable program.
1554
LINK-COMMAND is a command using the C compiler that you would use to create
1555
a program from several object files.
1557
The following components of LINK-COMMAND are treated specially:
1559
-all-static do not do any dynamic linking at all
1560
-avoid-version do not add a version suffix if possible
1561
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1562
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1563
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1564
-export-symbols SYMFILE
1565
try to export only the symbols listed in SYMFILE
1566
-export-symbols-regex REGEX
1567
try to export only the symbols matching REGEX
1568
-LLIBDIR search LIBDIR for required installed libraries
1569
-lNAME OUTPUT-FILE requires the installed library libNAME
1570
-module build a library that can dlopened
1571
-no-fast-install disable the fast-install mode
1572
-no-install link a not-installable executable
1573
-no-undefined declare that a library does not refer to external symbols
1574
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1575
-objectlist FILE Use a list of object files found in FILE to specify objects
1576
-precious-files-regex REGEX
1577
don't remove output files matching REGEX
1578
-release RELEASE specify package release information
1579
-rpath LIBDIR the created library will eventually be installed in LIBDIR
1580
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1581
-shared only do dynamic linking of libtool libraries
1582
-shrext SUFFIX override the standard shared library file extension
1583
-static do not do any dynamic linking of uninstalled libtool libraries
1584
-static-libtool-libs
1585
do not do any dynamic linking of libtool libraries
1586
-version-info CURRENT[:REVISION[:AGE]]
1587
specify library version info [each variable defaults to 0]
1588
-weak LIBNAME declare that the target provides the LIBNAME interface
1590
All other options (arguments beginning with \`-') are ignored.
1592
Every other argument is treated as a filename. Files ending in \`.la' are
1593
treated as uninstalled libtool libraries, other files are standard or library
1596
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1597
only library objects (\`.lo' files) may be specified, and \`-rpath' is
1598
required, except when creating a convenience library.
1600
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1601
using \`ar' and \`ranlib', or on Windows using \`lib'.
1603
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1604
is created, otherwise an executable program is created."
1609
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1611
Remove libraries from an installation directory.
1613
RM is the name of the program to use to delete files associated with each FILE
1614
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1617
If FILE is a libtool library, all the files associated with it are deleted.
1618
Otherwise, only FILE itself is deleted using RM."
1622
func_fatal_help "invalid operation mode \`$mode'"
1627
$ECHO "Try \`$progname --help' for more information about other modes."
1632
# Now that we've collected a possible --mode arg, show help if necessary
1633
$opt_help && func_mode_help
1636
# func_mode_execute arg...
1637
func_mode_execute ()
1640
# The first argument is the command name.
1643
func_fatal_help "you must specify a COMMAND"
1645
# Handle -dlopen flags immediately.
1646
for file in $execute_dlfiles; do
1648
|| func_fatal_help "\`$file' is not a file"
1653
# Check to see that this really is a libtool archive.
1654
func_lalib_unsafe_p "$file" \
1655
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1657
# Read the libtool library.
1662
# Skip this library if it cannot be dlopened.
1663
if test -z "$dlname"; then
1664
# Warn if it was a shared library.
1665
test -n "$library_names" && \
1666
func_warning "\`$file' was not linked with \`-export-dynamic'"
1670
func_dirname "$file" "" "."
1671
dir="$func_dirname_result"
1673
if test -f "$dir/$objdir/$dlname"; then
1676
if test ! -f "$dir/$dlname"; then
1677
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1683
# Just add the directory containing the .lo file.
1684
func_dirname "$file" "" "."
1685
dir="$func_dirname_result"
1689
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1694
# Get the absolute pathname.
1695
absdir=`cd "$dir" && pwd`
1696
test -n "$absdir" && dir="$absdir"
1698
# Now add the directory to shlibpath_var.
1699
if eval "test -z \"\$$shlibpath_var\""; then
1700
eval "$shlibpath_var=\"\$dir\""
1702
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1706
# This variable tells wrapper scripts just to set shlibpath_var
1707
# rather than running their programs.
1708
libtool_execute_magic="$magic"
1710
# Check if any of the arguments is a wrapper script.
1717
# Do a test to see if this is really a libtool program.
1718
if func_ltwrapper_script_p "$file"; then
1720
# Transform arg to wrapped name.
1721
file="$progdir/$program"
1722
elif func_ltwrapper_executable_p "$file"; then
1723
func_ltwrapper_scriptname "$file"
1724
func_source "$func_ltwrapper_scriptname_result"
1725
# Transform arg to wrapped name.
1726
file="$progdir/$program"
1730
# Quote arguments (to preserve shell metacharacters).
1731
func_quote_for_eval "$file"
1732
args="$args $func_quote_for_eval_result"
1735
if test "X$opt_dry_run" = Xfalse; then
1736
if test -n "$shlibpath_var"; then
1737
# Export the shlibpath_var.
1738
eval "export $shlibpath_var"
1741
# Restore saved environment variables
1742
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1744
eval "if test \"\${save_$lt_var+set}\" = set; then
1745
$lt_var=\$save_$lt_var; export $lt_var
1751
# Now prepare to actually exec the command.
1752
exec_cmd="\$cmd$args"
1754
# Display what would be done.
1755
if test -n "$shlibpath_var"; then
1756
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1757
$ECHO "export $shlibpath_var"
1764
test "$mode" = execute && func_mode_execute ${1+"$@"}
1767
# func_mode_finish arg...
1774
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1777
libdirs="$libdirs $dir"
1780
for libdir in $libdirs; do
1781
if test -n "$finish_cmds"; then
1782
# Do each command in the finish commands.
1783
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1786
if test -n "$finish_eval"; then
1787
# Do the single finish_eval.
1788
eval cmds=\"$finish_eval\"
1789
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
1795
# Exit here if they wanted silent mode.
1796
$opt_silent && exit $EXIT_SUCCESS
1798
$ECHO "X----------------------------------------------------------------------" | $Xsed
1799
$ECHO "Libraries have been installed in:"
1800
for libdir in $libdirs; do
1804
$ECHO "If you ever happen to want to link against installed libraries"
1805
$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1806
$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1807
$ECHO "flag during linking and do at least one of the following:"
1808
if test -n "$shlibpath_var"; then
1809
$ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
1810
$ECHO " during execution"
1812
if test -n "$runpath_var"; then
1813
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1814
$ECHO " during linking"
1816
if test -n "$hardcode_libdir_flag_spec"; then
1818
eval flag=\"$hardcode_libdir_flag_spec\"
1820
$ECHO " - use the \`$flag' linker flag"
1822
if test -n "$admincmds"; then
1823
$ECHO " - have your system administrator run these commands:$admincmds"
1825
if test -f /etc/ld.so.conf; then
1826
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1830
$ECHO "See any operating system documentation about shared libraries for"
1832
solaris2.[6789]|solaris2.1[0-9])
1833
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1837
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1840
$ECHO "X----------------------------------------------------------------------" | $Xsed
1844
test "$mode" = finish && func_mode_finish ${1+"$@"}
1847
# func_mode_install arg...
1848
func_mode_install ()
1851
# There may be an optional sh(1) argument at the beginning of
1852
# install_prog (especially on Windows NT).
1853
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1854
# Allow the use of GNU shtool's install command.
1855
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1856
# Aesthetically quote it.
1857
func_quote_for_eval "$nonopt"
1858
install_prog="$func_quote_for_eval_result "
1866
# The real first argument should be the name of the installation program.
1867
# Aesthetically quote it.
1868
func_quote_for_eval "$arg"
1869
install_prog="$install_prog$func_quote_for_eval_result"
1871
# We need to accept at least all the BSD install flags.
1881
if test -n "$dest"; then
1882
files="$files $dest"
1890
case " $install_prog " in
1905
# If the previous option needed an argument, then skip it.
1906
if test -n "$prev"; then
1915
# Aesthetically quote the argument.
1916
func_quote_for_eval "$arg"
1917
install_prog="$install_prog $func_quote_for_eval_result"
1920
test -z "$install_prog" && \
1921
func_fatal_help "you must specify an install program"
1923
test -n "$prev" && \
1924
func_fatal_help "the \`$prev' option requires an argument"
1926
if test -z "$files"; then
1927
if test -z "$dest"; then
1928
func_fatal_help "no file or destination specified"
1930
func_fatal_help "you must specify a destination"
1934
# Strip any trailing slash from the destination.
1935
func_stripname '' '/' "$dest"
1936
dest=$func_stripname_result
1938
# Check to see that the destination is a directory.
1939
test -d "$dest" && isdir=yes
1940
if test "$isdir" = yes; then
1944
func_dirname_and_basename "$dest" "" "."
1945
destdir="$func_dirname_result"
1946
destname="$func_basename_result"
1948
# Not a directory, so check to see that there is only one file specified.
1949
set dummy $files; shift
1950
test "$#" -gt 1 && \
1951
func_fatal_help "\`$dest' is not a directory"
1954
[\\/]* | [A-Za-z]:[\\/]*) ;;
1956
for file in $files; do
1960
func_fatal_help "\`$destdir' must be an absolute directory name"
1967
# This variable tells wrapper scripts just to set variables rather
1968
# than running their programs.
1969
libtool_install_magic="$magic"
1974
for file in $files; do
1976
# Do each installation.
1979
# Do the static libraries later.
1980
staticlibs="$staticlibs $file"
1984
# Check to see that this really is a libtool archive.
1985
func_lalib_unsafe_p "$file" \
1986
|| func_fatal_help "\`$file' is not a valid libtool archive"
1993
# Add the libdir to current_libdirs if it is the destination.
1994
if test "X$destdir" = "X$libdir"; then
1995
case "$current_libdirs " in
1997
*) current_libdirs="$current_libdirs $libdir" ;;
2000
# Note the libdir as a future libdir.
2001
case "$future_libdirs " in
2003
*) future_libdirs="$future_libdirs $libdir" ;;
2007
func_dirname "$file" "/" ""
2008
dir="$func_dirname_result"
2011
if test -n "$relink_command"; then
2012
# Determine the prefix the user has applied to our future dir.
2013
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2015
# Don't allow the user to place us outside of our expected
2016
# location b/c this prevents finding dependent libraries that
2017
# are installed to the same prefix.
2018
# At present, this check doesn't affect windows .dll's that
2019
# are installed into $libdir/../bin (currently, that works fine)
2020
# but it's something to keep an eye on.
2021
test "$inst_prefix_dir" = "$destdir" && \
2022
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2024
if test -n "$inst_prefix_dir"; then
2025
# Stick the inst_prefix_dir data into the link command.
2026
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2028
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2031
func_warning "relinking \`$file'"
2032
func_show_eval "$relink_command" \
2033
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2036
# See the names of the shared library.
2037
set dummy $library_names; shift
2038
if test -n "$1"; then
2043
test -n "$relink_command" && srcname="$realname"T
2045
# Install the shared library and build the symlinks.
2046
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2050
cygwin* | mingw* | pw32* | cegcc*)
2058
if test -n "$tstripme" && test -n "$striplib"; then
2059
func_show_eval "$striplib $destdir/$realname" 'exit $?'
2062
if test "$#" -gt 0; then
2063
# Delete the old symlinks, and create new ones.
2064
# Try `ln -sf' first, because the `ln' binary might depend on
2065
# the symlink we replace! Solaris /bin/ln does not understand -f,
2066
# so we also need to try rm && ln -s.
2069
test "$linkname" != "$realname" \
2070
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2074
# Do each command in the postinstall commands.
2075
lib="$destdir/$realname"
2076
func_execute_cmds "$postinstall_cmds" 'exit $?'
2079
# Install the pseudo-library for information purposes.
2080
func_basename "$file"
2081
name="$func_basename_result"
2082
instname="$dir/$name"i
2083
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2085
# Maybe install the static library, too.
2086
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2090
# Install (i.e. copy) a libtool object.
2092
# Figure out destination file name, if it wasn't already specified.
2093
if test -n "$destname"; then
2094
destfile="$destdir/$destname"
2096
func_basename "$file"
2097
destfile="$func_basename_result"
2098
destfile="$destdir/$destfile"
2101
# Deduce the name of the destination old-style object file.
2104
func_lo2o "$destfile"
2105
staticdest=$func_lo2o_result
2108
staticdest="$destfile"
2112
func_fatal_help "cannot copy a libtool object to \`$destfile'"
2116
# Install the libtool object if requested.
2117
test -n "$destfile" && \
2118
func_show_eval "$install_prog $file $destfile" 'exit $?'
2120
# Install the old object if enabled.
2121
if test "$build_old_libs" = yes; then
2122
# Deduce the name of the old-style object file.
2124
staticobj=$func_lo2o_result
2125
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2131
# Figure out destination file name, if it wasn't already specified.
2132
if test -n "$destname"; then
2133
destfile="$destdir/$destname"
2135
func_basename "$file"
2136
destfile="$func_basename_result"
2137
destfile="$destdir/$destfile"
2140
# If the file is missing, and there is a .exe on the end, strip it
2141
# because it is most likely a libtool script we actually want to
2146
if test ! -f "$file"; then
2147
func_stripname '' '.exe' "$file"
2148
file=$func_stripname_result
2154
# Do a test to see if this is really a libtool program.
2157
if func_ltwrapper_executable_p "$file"; then
2158
func_ltwrapper_scriptname "$file"
2159
wrapper=$func_ltwrapper_scriptname_result
2161
func_stripname '' '.exe' "$file"
2162
wrapper=$func_stripname_result
2169
if func_ltwrapper_script_p "$wrapper"; then
2173
func_source "$wrapper"
2175
# Check the variables that should have been set.
2176
test -z "$generated_by_libtool_version" && \
2177
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2180
for lib in $notinst_deplibs; do
2181
# Check to see that each library is installed.
2183
if test -f "$lib"; then
2186
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187
if test -n "$libdir" && test ! -f "$libfile"; then
2188
func_warning "\`$lib' has not been installed in \`$libdir'"
2194
func_source "$wrapper"
2197
if test "$fast_install" = no && test -n "$relink_command"; then
2199
if test "$finalize" = yes; then
2200
tmpdir=`func_mktempdir`
2201
func_basename "$file$stripped_ext"
2202
file="$func_basename_result"
2203
outputname="$tmpdir/$file"
2204
# Replace the output file specification.
2205
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2208
func_quote_for_expand "$relink_command"
2209
eval "func_echo $func_quote_for_expand_result"
2211
if eval "$relink_command"; then :
2213
func_error "error: relink \`$file' with the above command before installing it"
2214
$opt_dry_run || ${RM}r "$tmpdir"
2219
func_warning "cannot relink \`$file'"
2223
# Install the binary that we compiled earlier.
2224
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2228
# remove .exe since cygwin /usr/bin/install will append another
2230
case $install_prog,$host in
2231
*/usr/bin/install*,*cygwin*)
2232
case $file:$destfile in
2237
destfile=$destfile.exe
2240
func_stripname '' '.exe' "$destfile"
2241
destfile=$func_stripname_result
2246
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2247
$opt_dry_run || if test -n "$outputname"; then
2254
for file in $staticlibs; do
2255
func_basename "$file"
2256
name="$func_basename_result"
2258
# Set up the ranlib parameters.
2259
oldlib="$destdir/$name"
2261
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2263
if test -n "$stripme" && test -n "$old_striplib"; then
2264
func_show_eval "$old_striplib $oldlib" 'exit $?'
2267
# Do each command in the postinstall commands.
2268
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2271
test -n "$future_libdirs" && \
2272
func_warning "remember to run \`$progname --finish$future_libdirs'"
2274
if test -n "$current_libdirs"; then
2275
# Maybe just do a dry run.
2276
$opt_dry_run && current_libdirs=" -n$current_libdirs"
2277
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2283
test "$mode" = install && func_mode_install ${1+"$@"}
2286
# func_generate_dlsyms outputname originator pic_p
2287
# Extract symbols from dlprefiles and create ${outputname}S.o with
2288
# a dlpreopen symbol table.
2289
func_generate_dlsyms ()
2295
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2298
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2299
if test -n "$NM" && test -n "$global_symbol_pipe"; then
2300
my_dlsyms="${my_outputname}S.c"
2302
func_error "not configured to extract global symbols from dlpreopened files"
2306
if test -n "$my_dlsyms"; then
2310
# Discover the nlist of each of the dlfiles.
2311
nlist="$output_objdir/${my_outputname}.nm"
2313
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2315
# Parse the name list into a source file.
2316
func_verbose "creating $output_objdir/$my_dlsyms"
2318
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2319
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2320
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2326
/* External symbol declarations for the compiler. */\
2329
if test "$dlself" = yes; then
2330
func_verbose "generating symbol list for \`$output'"
2332
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2334
# Add our own program objects to the symbol list.
2335
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2336
for progfile in $progfiles; do
2337
func_verbose "extracting global C symbols from \`$progfile'"
2338
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2341
if test -n "$exclude_expsyms"; then
2343
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2344
eval '$MV "$nlist"T "$nlist"'
2348
if test -n "$export_symbols_regex"; then
2350
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2351
eval '$MV "$nlist"T "$nlist"'
2355
# Prepare the list of exported symbols
2356
if test -z "$export_symbols"; then
2357
export_symbols="$output_objdir/$outputname.exp"
2360
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2362
*cygwin* | *mingw* | *cegcc* )
2363
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2364
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2370
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2371
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372
eval '$MV "$nlist"T "$nlist"'
2374
*cygwin | *mingw* | *cegcc* )
2375
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2383
for dlprefile in $dlprefiles; do
2384
func_verbose "extracting global C symbols from \`$dlprefile'"
2385
func_basename "$dlprefile"
2386
name="$func_basename_result"
2388
eval '$ECHO ": $name " >> "$nlist"'
2389
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2394
# Make sure we have at least an empty file.
2395
test -f "$nlist" || : > "$nlist"
2397
if test -n "$exclude_expsyms"; then
2398
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2399
$MV "$nlist"T "$nlist"
2402
# Try sorting and uniquifying the output.
2403
if $GREP -v "^: " < "$nlist" |
2404
if sort -k 3 </dev/null >/dev/null 2>&1; then
2409
uniq > "$nlist"S; then
2412
$GREP -v "^: " < "$nlist" > "$nlist"S
2415
if test -f "$nlist"S; then
2416
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2418
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2421
$ECHO >> "$output_objdir/$my_dlsyms" "\
2423
/* The mapping between symbol names and symbols. */
2430
*cygwin* | *mingw* | *cegcc* )
2431
$ECHO >> "$output_objdir/$my_dlsyms" "\
2432
/* DATA imports from DLLs on WIN32 con't be const, because
2433
runtime relocations are performed -- see ld's documentation
2434
on pseudo-relocs. */"
2437
echo >> "$output_objdir/$my_dlsyms" "\
2438
/* This system does not cope well with relocations in const data */"
2441
lt_dlsym_const=const ;;
2444
$ECHO >> "$output_objdir/$my_dlsyms" "\
2445
extern $lt_dlsym_const lt_dlsymlist
2446
lt_${my_prefix}_LTX_preloaded_symbols[];
2447
$lt_dlsym_const lt_dlsymlist
2448
lt_${my_prefix}_LTX_preloaded_symbols[] =
2450
{ \"$my_originator\", (void *) 0 },"
2452
case $need_lib_prefix in
2454
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2457
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2460
$ECHO >> "$output_objdir/$my_dlsyms" "\
2464
/* This works around a problem in FreeBSD linker */
2465
#ifdef FREEBSD_WORKAROUND
2466
static const void *lt_preloaded_setup() {
2467
return lt_${my_prefix}_LTX_preloaded_symbols;
2477
pic_flag_for_symtable=
2478
case "$compile_command " in
2482
# compiling the symbol table file with pic_flag works around
2483
# a FreeBSD bug that causes programs to crash when -lm is
2484
# linked before any other PIC object. But we must not use
2485
# pic_flag when linking with -static. The problem exists in
2486
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2487
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2488
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2490
pic_flag_for_symtable=" $pic_flag" ;;
2492
if test "X$my_pic_p" != Xno; then
2493
pic_flag_for_symtable=" $pic_flag"
2500
for arg in $LTCFLAGS; do
2502
-pie | -fpie | -fPIE) ;;
2503
*) symtab_cflags="$symtab_cflags $arg" ;;
2507
# Now compile the dynamic symbol file.
2508
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2510
# Clean up the generated files.
2511
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2513
# Transform the symbol file into the correct name.
2514
symfileobj="$output_objdir/${my_outputname}S.$objext"
2516
*cygwin* | *mingw* | *cegcc* )
2517
if test -f "$output_objdir/$my_outputname.def"; then
2518
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2521
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2526
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2532
func_fatal_error "unknown suffix for \`$my_dlsyms'"
2536
# We keep going just in case the user didn't refer to
2537
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2538
# really was required.
2540
# Nullify the symbol file.
2541
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2546
# func_win32_libid arg
2547
# return the library type of file 'arg'
2549
# Need a lot of goo to handle *both* DLLs and import libs
2550
# Has to be a shell function in order to 'eat' the argument
2551
# that is supplied when $file_magic_command is called.
2555
win32_libid_type="unknown"
2556
win32_fileres=`file -L $1 2>/dev/null`
2557
case $win32_fileres in
2558
*ar\ archive\ import\ library*) # definitely import
2559
win32_libid_type="x86 archive import"
2561
*ar\ archive*) # could be an import, or static
2562
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2563
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564
win32_nmres=`eval $NM -f posix -A $1 |
2573
case $win32_nmres in
2574
import*) win32_libid_type="x86 archive import";;
2575
*) win32_libid_type="x86 archive static";;
2580
win32_libid_type="x86 DLL"
2582
*executable*) # but shell scripts are "executable" too...
2583
case $win32_fileres in
2584
*MS\ Windows\ PE\ Intel*)
2585
win32_libid_type="x86 DLL"
2590
$ECHO "$win32_libid_type"
2595
# func_extract_an_archive dir oldlib
2596
func_extract_an_archive ()
2599
f_ex_an_ar_dir="$1"; shift
2600
f_ex_an_ar_oldlib="$1"
2601
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2602
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2605
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2610
# func_extract_archives gentop oldlib ...
2611
func_extract_archives ()
2614
my_gentop="$1"; shift
2615
my_oldlibs=${1+"$@"}
2621
for my_xlib in $my_oldlibs; do
2622
# Extract the objects.
2624
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2625
*) my_xabs=`pwd`"/$my_xlib" ;;
2627
func_basename "$my_xlib"
2628
my_xlib="$func_basename_result"
2631
case " $extracted_archives " in
2633
func_arith $extracted_serial + 1
2634
extracted_serial=$func_arith_result
2635
my_xlib_u=lt$extracted_serial-$my_xlib ;;
2639
extracted_archives="$extracted_archives $my_xlib_u"
2640
my_xdir="$my_gentop/$my_xlib_u"
2642
func_mkdir_p "$my_xdir"
2646
func_verbose "Extracting $my_xabs"
2647
# Do not bother doing anything if just a dry run
2649
darwin_orig_dir=`pwd`
2650
cd $my_xdir || exit $?
2651
darwin_archive=$my_xabs
2653
darwin_base_archive=`basename "$darwin_archive"`
2654
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2655
if test -n "$darwin_arches"; then
2656
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2658
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2659
for darwin_arch in $darwin_arches ; do
2660
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2661
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2662
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2663
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2665
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2666
done # $darwin_arches
2667
## Okay now we've a bunch of thin objects, gotta fatten them up :)
2668
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2671
for darwin_file in $darwin_filelist; do
2672
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2673
$LIPO -create -output "$darwin_file" $darwin_files
2674
done # $darwin_filelist
2676
cd "$darwin_orig_dir"
2679
func_extract_an_archive "$my_xdir" "$my_xabs"
2684
func_extract_an_archive "$my_xdir" "$my_xabs"
2687
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2690
func_extract_archives_result="$my_oldobjs"
2695
# func_emit_wrapper_part1 [arg=no]
2697
# Emit the first part of a libtool wrapper script on stdout.
2698
# For more information, see the description associated with
2699
# func_emit_wrapper(), below.
2700
func_emit_wrapper_part1 ()
2702
func_emit_wrapper_part1_arg1=no
2703
if test -n "$1" ; then
2704
func_emit_wrapper_part1_arg1=$1
2710
# $output - temporary wrapper script for $objdir/$outputname
2711
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2713
# The $output program cannot be directly executed until all the libtool
2714
# libraries that it depends on are installed.
2716
# This wrapper script should never be moved out of the build directory.
2717
# If it is, it will not operate correctly.
2719
# Sed substitution that helps us do robust quoting. It backslashifies
2720
# metacharacters that are still active within double-quoted strings.
2721
Xsed='${SED} -e 1s/^X//'
2722
sed_quote_subst='$sed_quote_subst'
2724
# Be Bourne compatible
2725
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2728
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2729
# is contrary to our usage. Disable this feature.
2730
alias -g '\${1+\"\$@\"}'='\"\$@\"'
2731
setopt NO_GLOB_SUBST
2733
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2735
BIN_SH=xpg4; export BIN_SH # for Tru64
2736
DUALCASE=1; export DUALCASE # for MKS sh
2738
# The HP-UX ksh and POSIX shell print the target directory to stdout
2740
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2742
relink_command=\"$relink_command\"
2744
# This environment variable determines our operation mode.
2745
if test \"\$libtool_install_magic\" = \"$magic\"; then
2746
# install mode needs the following variables:
2747
generated_by_libtool_version='$macro_version'
2748
notinst_deplibs='$notinst_deplibs'
2750
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2751
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2754
# Make sure echo works.
2755
if test \"X\$1\" = X--no-reexec; then
2756
# Discard the --no-reexec flag, and continue.
2758
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2759
# Yippee, \$ECHO works!
2762
# Restart under the correct shell, and then maybe \$ECHO will work.
2763
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2769
# Find the directory that this script lives in.
2770
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2771
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2773
# Follow symbolic links until we get to the real thisdir.
2774
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2775
while test -n \"\$file\"; do
2776
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2778
# If there was a directory component, then change thisdir.
2779
if test \"x\$destdir\" != \"x\$file\"; then
2780
case \"\$destdir\" in
2781
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2782
*) thisdir=\"\$thisdir/\$destdir\" ;;
2786
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2791
# end: func_emit_wrapper_part1
2793
# func_emit_wrapper_part2 [arg=no]
2795
# Emit the second part of a libtool wrapper script on stdout.
2796
# For more information, see the description associated with
2797
# func_emit_wrapper(), below.
2798
func_emit_wrapper_part2 ()
2800
func_emit_wrapper_part2_arg1=no
2801
if test -n "$1" ; then
2802
func_emit_wrapper_part2_arg1=$1
2807
# Usually 'no', except on cygwin/mingw when embedded into
2809
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2810
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811
# special case for '.'
2812
if test \"\$thisdir\" = \".\"; then
2815
# remove .libs from thisdir
2816
case \"\$thisdir\" in
2817
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818
$objdir ) thisdir=. ;;
2822
# Try to get the absolute directory name.
2823
absdir=\`cd \"\$thisdir\" && pwd\`
2824
test -n \"\$absdir\" && thisdir=\"\$absdir\"
2827
if test "$fast_install" = yes; then
2829
program=lt-'$outputname'$exeext
2830
progdir=\"\$thisdir/$objdir\"
2832
if test ! -f \"\$progdir/\$program\" ||
2833
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2834
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2836
file=\"\$\$-\$program\"
2838
if test ! -d \"\$progdir\"; then
2839
$MKDIR \"\$progdir\"
2841
$RM \"\$progdir/\$file\"
2846
# relink executable if necessary
2847
if test -n \"\$relink_command\"; then
2848
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2850
$ECHO \"\$relink_command_output\" >&2
2851
$RM \"\$progdir/\$file\"
2856
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2857
{ $RM \"\$progdir/\$program\";
2858
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2859
$RM \"\$progdir/\$file\"
2863
program='$outputname'
2864
progdir=\"\$thisdir/$objdir\"
2870
if test -f \"\$progdir/\$program\"; then"
2872
# Export our shlibpath_var if we have one.
2873
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2875
# Add our own library path to $shlibpath_var
2876
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2878
# Some systems cannot cope with colon-terminated $shlibpath_var
2879
# The second colon is a workaround for a bug in BeOS R4 sed
2880
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2882
export $shlibpath_var
2886
# fixup the dll searchpath if we need to.
2887
if test -n "$dllsearchpath"; then
2889
# Add the dll search path components to the executable PATH
2890
PATH=$dllsearchpath:\$PATH
2895
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896
# Run the actual program with our arguments.
2899
# Backslashes separate directories on plain windows
2900
*-*-mingw | *-*-os2* | *-cegcc*)
2902
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2908
exec \"\$progdir/\$program\" \${1+\"\$@\"}
2913
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2917
# The program doesn't exist.
2918
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2926
# end: func_emit_wrapper_part2
2929
# func_emit_wrapper [arg=no]
2931
# Emit a libtool wrapper script on stdout.
2932
# Don't directly open a file because we may want to
2933
# incorporate the script contents within a cygwin/mingw
2934
# wrapper executable. Must ONLY be called from within
2935
# func_mode_link because it depends on a number of variables
2938
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2939
# variable will take. If 'yes', then the emitted script
2940
# will assume that the directory in which it is stored is
2941
# the $objdir directory. This is a cygwin/mingw-specific
2943
func_emit_wrapper ()
2945
func_emit_wrapper_arg1=no
2946
if test -n "$1" ; then
2947
func_emit_wrapper_arg1=$1
2950
# split this up so that func_emit_cwrapperexe_src
2951
# can call each part independently.
2952
func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2953
func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2957
# func_to_host_path arg
2959
# Convert paths to host format when used with build tools.
2960
# Intended for use with "native" mingw (where libtool itself
2961
# is running under the msys shell), or in the following cross-
2962
# build environments:
2964
# mingw (msys) mingw [e.g. native]
2967
# where wine is equipped with the `winepath' executable.
2968
# In the native mingw case, the (msys) shell automatically
2969
# converts paths for any non-msys applications it launches,
2970
# but that facility isn't available from inside the cwrapper.
2971
# Similar accommodations are necessary for $host mingw and
2972
# $build cygwin. Calling this function does no harm for other
2973
# $host/$build combinations not listed above.
2975
# ARG is the path (on $build) that should be converted to
2976
# the proper representation for $host. The result is stored
2977
# in $func_to_host_path_result.
2978
func_to_host_path ()
2980
func_to_host_path_result="$1"
2981
if test -n "$1" ; then
2984
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2986
*mingw* ) # actually, msys
2987
# awkward: cmd appends spaces to result
2988
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2989
func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2990
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2991
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2992
$SED -e "$lt_sed_naive_backslashify"`
2995
func_to_host_path_tmp1=`cygpath -w "$1"`
2996
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2997
$SED -e "$lt_sed_naive_backslashify"`
3000
# Unfortunately, winepath does not exit with a non-zero
3001
# error code, so we are forced to check the contents of
3002
# stdout. On the other hand, if the command is not
3003
# found, the shell will set an exit code of 127 and print
3004
# *an error message* to stdout. So we must check for both
3005
# error code of zero AND non-empty stdout, which explains
3006
# the odd construction:
3007
func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3008
if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3009
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3010
$SED -e "$lt_sed_naive_backslashify"`
3012
# Allow warning below.
3013
func_to_host_path_result=""
3017
if test -z "$func_to_host_path_result" ; then
3018
func_error "Could not determine host path corresponding to"
3020
func_error "Continuing, but uninstalled executables may not work."
3022
func_to_host_path_result="$1"
3028
# end: func_to_host_path
3030
# func_to_host_pathlist arg
3032
# Convert pathlists to host format when used with build tools.
3033
# See func_to_host_path(), above. This function supports the
3034
# following $build/$host combinations (but does no harm for
3035
# combinations not listed here):
3037
# mingw (msys) mingw [e.g. native]
3041
# Path separators are also converted from $build format to
3042
# $host format. If ARG begins or ends with a path separator
3043
# character, it is preserved (but converted to $host format)
3046
# ARG is a pathlist (on $build) that should be converted to
3047
# the proper representation on $host. The result is stored
3048
# in $func_to_host_pathlist_result.
3049
func_to_host_pathlist ()
3051
func_to_host_pathlist_result="$1"
3052
if test -n "$1" ; then
3055
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3056
# Remove leading and trailing path separator characters from
3057
# ARG. msys behavior is inconsistent here, cygpath turns them
3058
# into '.;' and ';.', and winepath ignores them completely.
3059
func_to_host_pathlist_tmp2="$1"
3060
# Once set for this call, this variable should not be
3061
# reassigned. It is used in tha fallback case.
3062
func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3063
$SED -e 's|^:*||' -e 's|:*$||'`
3065
*mingw* ) # Actually, msys.
3066
# Awkward: cmd appends spaces to result.
3067
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3068
func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3069
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3070
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3071
$SED -e "$lt_sed_naive_backslashify"`
3074
func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3075
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3076
$SED -e "$lt_sed_naive_backslashify"`
3079
# unfortunately, winepath doesn't convert pathlists
3080
func_to_host_pathlist_result=""
3081
func_to_host_pathlist_oldIFS=$IFS
3083
for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3084
IFS=$func_to_host_pathlist_oldIFS
3085
if test -n "$func_to_host_pathlist_f" ; then
3086
func_to_host_path "$func_to_host_pathlist_f"
3087
if test -n "$func_to_host_path_result" ; then
3088
if test -z "$func_to_host_pathlist_result" ; then
3089
func_to_host_pathlist_result="$func_to_host_path_result"
3091
func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3097
IFS=$func_to_host_pathlist_oldIFS
3100
if test -z "$func_to_host_pathlist_result" ; then
3101
func_error "Could not determine the host path(s) corresponding to"
3103
func_error "Continuing, but uninstalled executables may not work."
3104
# Fallback. This may break if $1 contains DOS-style drive
3105
# specifications. The fix is not to complicate the expression
3106
# below, but for the user to provide a working wine installation
3107
# with winepath so that path translation in the cross-to-mingw
3108
# case works properly.
3109
lt_replace_pathsep_nix_to_dos="s|:|;|g"
3110
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3111
$SED -e "$lt_replace_pathsep_nix_to_dos"`
3113
# Now, add the leading and trailing path separators back
3115
:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3119
*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3126
# end: func_to_host_pathlist
3128
# func_emit_cwrapperexe_src
3129
# emit the source code for a wrapper executable on stdout
3130
# Must ONLY be called from within func_mode_link because
3131
# it depends on a number of variable set therein.
3132
func_emit_cwrapperexe_src ()
3136
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3137
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3139
The $output program cannot be directly executed until all the libtool
3140
libraries that it depends on are installed.
3142
This wrapper executable should never be moved out of the build directory.
3143
If it is, it will not operate correctly.
3145
Currently, it simply execs the wrapper *script* "$SHELL $output",
3146
but could eventually absorb all of the scripts functionality and
3147
exec $objdir/$outputname directly.
3154
# include <direct.h>
3155
# include <process.h>
3157
# define setmode _setmode
3159
# include <unistd.h>
3160
# include <stdint.h>
3163
# define HAVE_SETENV
3164
# ifdef __STRICT_ANSI__
3165
char *realpath (const char *, char *);
3166
int putenv (char *);
3167
int setenv (const char *, const char *, int);
3178
#include <sys/stat.h>
3180
#if defined(PATH_MAX)
3181
# define LT_PATHMAX PATH_MAX
3182
#elif defined(MAXPATHLEN)
3183
# define LT_PATHMAX MAXPATHLEN
3185
# define LT_PATHMAX 1024
3196
# define S_IXUSR _S_IEXEC
3198
# ifndef _INTPTR_T_DEFINED
3199
# define intptr_t int
3203
#ifndef DIR_SEPARATOR
3204
# define DIR_SEPARATOR '/'
3205
# define PATH_SEPARATOR ':'
3208
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3210
# define HAVE_DOS_BASED_FILE_SYSTEM
3211
# define FOPEN_WB "wb"
3212
# ifndef DIR_SEPARATOR_2
3213
# define DIR_SEPARATOR_2 '\\'
3215
# ifndef PATH_SEPARATOR_2
3216
# define PATH_SEPARATOR_2 ';'
3220
#ifndef DIR_SEPARATOR_2
3221
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3222
#else /* DIR_SEPARATOR_2 */
3223
# define IS_DIR_SEPARATOR(ch) \
3224
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3225
#endif /* DIR_SEPARATOR_2 */
3227
#ifndef PATH_SEPARATOR_2
3228
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3229
#else /* PATH_SEPARATOR_2 */
3230
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231
#endif /* PATH_SEPARATOR_2 */
3234
# define FOPEN_WB "wb"
3238
# define FOPEN_WB "w"
3241
# define _O_BINARY 0
3244
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3245
#define XFREE(stale) do { \
3246
if (stale) { free ((void *) stale); stale = 0; } \
3249
#undef LTWRAPPER_DEBUGPRINTF
3250
#if defined DEBUGWRAPPER
3251
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3253
ltwrapper_debugprintf (const char *fmt, ...)
3256
va_start (args, fmt);
3257
(void) vfprintf (stderr, fmt, args);
3261
# define LTWRAPPER_DEBUGPRINTF(args)
3264
const char *program_name = NULL;
3266
void *xmalloc (size_t num);
3267
char *xstrdup (const char *string);
3268
const char *base_name (const char *name);
3269
char *find_executable (const char *wrapper);
3270
char *chase_symlinks (const char *pathspec);
3271
int make_executable (const char *path);
3272
int check_executable (const char *path);
3273
char *strendzap (char *str, const char *pat);
3274
void lt_fatal (const char *message, ...);
3275
void lt_setenv (const char *name, const char *value);
3276
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3277
void lt_opt_process_env_set (const char *arg);
3278
void lt_opt_process_env_prepend (const char *arg);
3279
void lt_opt_process_env_append (const char *arg);
3280
int lt_split_name_value (const char *arg, char** name, char** value);
3281
void lt_update_exe_path (const char *name, const char *value);
3282
void lt_update_lib_path (const char *name, const char *value);
3284
static const char *script_text_part1 =
3287
func_emit_wrapper_part1 yes |
3288
$SED -e 's/\([\\"]\)/\\\1/g' \
3289
-e 's/^/ "/' -e 's/$/\\n"/'
3293
static const char *script_text_part2 =
3295
func_emit_wrapper_part2 yes |
3296
$SED -e 's/\([\\"]\)/\\\1/g' \
3297
-e 's/^/ "/' -e 's/$/\\n"/'
3301
const char * MAGIC_EXE = "$magic_exe";
3302
const char * LIB_PATH_VARNAME = "$shlibpath_var";
3305
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306
func_to_host_pathlist "$temp_rpath"
3308
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3312
const char * LIB_PATH_VALUE = "";
3316
if test -n "$dllsearchpath"; then
3317
func_to_host_pathlist "$dllsearchpath:"
3319
const char * EXE_PATH_VARNAME = "PATH";
3320
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3324
const char * EXE_PATH_VARNAME = "";
3325
const char * EXE_PATH_VALUE = "";
3329
if test "$fast_install" = yes; then
3331
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3335
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3342
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3343
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3345
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3348
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3350
static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3351
static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";
3352
/* argument is putenv-style "foo=bar", value of foo is set to bar */
3354
static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3355
static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";
3356
/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3358
static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3359
static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";
3360
/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3363
main (int argc, char *argv[])
3368
char *actual_cwrapper_path;
3369
char *actual_cwrapper_name;
3372
intptr_t rval = 127;
3376
program_name = (char *) xstrdup (base_name (argv[0]));
3377
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3378
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3380
/* very simple arg parsing; don't want to rely on getopt */
3381
for (i = 1; i < argc; i++)
3383
if (strcmp (argv[i], dumpscript_opt) == 0)
3387
*mingw* | *cygwin* )
3388
# make stdout use "unix" line endings
3389
echo " setmode(1,_O_BINARY);"
3394
printf ("%s", script_text_part1);
3395
printf ("%s", script_text_part2);
3400
newargz = XMALLOC (char *, argc + 1);
3401
tmp_pathspec = find_executable (argv[0]);
3402
if (tmp_pathspec == NULL)
3403
lt_fatal ("Couldn't find %s", argv[0]);
3404
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3407
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3408
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409
actual_cwrapper_path));
3410
XFREE (tmp_pathspec);
3412
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3413
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3415
/* wrapper name transforms */
3416
strendzap (actual_cwrapper_name, ".exe");
3417
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3418
XFREE (actual_cwrapper_name);
3419
actual_cwrapper_name = tmp_pathspec;
3422
/* target_name transforms -- use actual target program name; might have lt- prefix */
3423
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3424
strendzap (target_name, ".exe");
3425
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3426
XFREE (target_name);
3427
target_name = tmp_pathspec;
3430
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3436
XMALLOC (char, (strlen (actual_cwrapper_path) +
3437
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3438
strcpy (newargz[0], actual_cwrapper_path);
3439
strcat (newargz[0], "$objdir");
3440
strcat (newargz[0], "/");
3444
/* stop here, and copy so we don't have to do this twice */
3445
tmp_pathspec = xstrdup (newargz[0]);
3447
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3448
strcat (newargz[0], actual_cwrapper_name);
3450
/* DO want the lt- prefix here if it exists, so use target_name */
3451
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3452
XFREE (tmp_pathspec);
3453
tmp_pathspec = NULL;
3461
while ((p = strchr (newargz[0], '\\')) != NULL)
3465
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3475
XFREE (target_name);
3476
XFREE (actual_cwrapper_path);
3477
XFREE (actual_cwrapper_name);
3479
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3480
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3481
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3482
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3485
for (i = 1; i < argc; i++)
3487
if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3489
if (argv[i][env_set_opt_len] == '=')
3491
const char *p = argv[i] + env_set_opt_len + 1;
3492
lt_opt_process_env_set (p);
3494
else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3496
lt_opt_process_env_set (argv[++i]); /* don't copy */
3499
lt_fatal ("%s missing required argument", env_set_opt);
3502
if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3504
if (argv[i][env_prepend_opt_len] == '=')
3506
const char *p = argv[i] + env_prepend_opt_len + 1;
3507
lt_opt_process_env_prepend (p);
3509
else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3511
lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3514
lt_fatal ("%s missing required argument", env_prepend_opt);
3517
if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3519
if (argv[i][env_append_opt_len] == '=')
3521
const char *p = argv[i] + env_append_opt_len + 1;
3522
lt_opt_process_env_append (p);
3524
else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3526
lt_opt_process_env_append (argv[++i]); /* don't copy */
3529
lt_fatal ("%s missing required argument", env_append_opt);
3532
if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3534
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3535
namespace, but it is not one of the ones we know about and
3536
have already dealt with, above (inluding dump-script), then
3537
report an error. Otherwise, targets might begin to believe
3538
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3539
namespace. The first time any user complains about this, we'll
3540
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3541
or a configure.ac-settable value.
3543
lt_fatal ("Unrecognized option in %s namespace: '%s'",
3544
ltwrapper_option_prefix, argv[i]);
3547
newargz[++newargc] = xstrdup (argv[i]);
3549
newargz[++newargc] = NULL;
3551
LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3552
for (i = 0; i < newargc; i++)
3554
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3562
/* execv doesn't actually work on mingw as expected on unix */
3563
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3566
/* failed to start process */
3567
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3575
execv (lt_argv_zero, newargz);
3576
return rval; /* =127, but avoids unused variable warning */
3585
xmalloc (size_t num)
3587
void *p = (void *) malloc (num);
3589
lt_fatal ("Memory exhausted");
3595
xstrdup (const char *string)
3597
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3602
base_name (const char *name)
3606
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3607
/* Skip over the disk name in MSDOS pathnames. */
3608
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3612
for (base = name; *name; name++)
3613
if (IS_DIR_SEPARATOR (*name))
3619
check_executable (const char *path)
3623
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3624
path ? (*path ? path : "EMPTY!") : "NULL!"));
3625
if ((!path) || (!*path))
3628
if ((stat (path, &st) >= 0)
3629
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3636
make_executable (const char *path)
3641
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3642
path ? (*path ? path : "EMPTY!") : "NULL!"));
3643
if ((!path) || (!*path))
3646
if (stat (path, &st) >= 0)
3648
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3653
/* Searches for the full path of the wrapper. Returns
3654
newly allocated full path name if found, NULL otherwise
3655
Does not chase symlinks, even on platforms that support them.
3658
find_executable (const char *wrapper)
3663
/* static buffer for getcwd */
3664
char tmp[LT_PATHMAX + 1];
3668
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3669
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3671
if ((wrapper == NULL) || (*wrapper == '\0'))
3674
/* Absolute path? */
3675
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3676
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3678
concat_name = xstrdup (wrapper);
3679
if (check_executable (concat_name))
3681
XFREE (concat_name);
3686
if (IS_DIR_SEPARATOR (wrapper[0]))
3688
concat_name = xstrdup (wrapper);
3689
if (check_executable (concat_name))
3691
XFREE (concat_name);
3693
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3697
for (p = wrapper; *p; p++)
3705
/* no slashes; search PATH */
3706
const char *path = getenv ("PATH");
3709
for (p = path; *p; p = p_next)
3713
for (q = p; *q; q++)
3714
if (IS_PATH_SEPARATOR (*q))
3717
p_next = (*q == '\0' ? q : q + 1);
3720
/* empty path: current directory */
3721
if (getcwd (tmp, LT_PATHMAX) == NULL)
3722
lt_fatal ("getcwd failed");
3723
tmp_len = strlen (tmp);
3725
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3726
memcpy (concat_name, tmp, tmp_len);
3727
concat_name[tmp_len] = '/';
3728
strcpy (concat_name + tmp_len + 1, wrapper);
3733
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3734
memcpy (concat_name, p, p_len);
3735
concat_name[p_len] = '/';
3736
strcpy (concat_name + p_len + 1, wrapper);
3738
if (check_executable (concat_name))
3740
XFREE (concat_name);
3743
/* not found in PATH; assume curdir */
3745
/* Relative path | not found in path: prepend cwd */
3746
if (getcwd (tmp, LT_PATHMAX) == NULL)
3747
lt_fatal ("getcwd failed");
3748
tmp_len = strlen (tmp);
3749
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3750
memcpy (concat_name, tmp, tmp_len);
3751
concat_name[tmp_len] = '/';
3752
strcpy (concat_name + tmp_len + 1, wrapper);
3754
if (check_executable (concat_name))
3756
XFREE (concat_name);
3761
chase_symlinks (const char *pathspec)
3764
return xstrdup (pathspec);
3766
char buf[LT_PATHMAX];
3768
char *tmp_pathspec = xstrdup (pathspec);
3770
int has_symlinks = 0;
3771
while (strlen (tmp_pathspec) && !has_symlinks)
3773
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3775
if (lstat (tmp_pathspec, &s) == 0)
3777
if (S_ISLNK (s.st_mode) != 0)
3783
/* search backwards for last DIR_SEPARATOR */
3784
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3785
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3787
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3789
/* no more DIR_SEPARATORS left */
3796
char *errstr = strerror (errno);
3797
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3800
XFREE (tmp_pathspec);
3804
return xstrdup (pathspec);
3807
tmp_pathspec = realpath (pathspec, buf);
3808
if (tmp_pathspec == 0)
3810
lt_fatal ("Could not follow symlinks for %s", pathspec);
3812
return xstrdup (tmp_pathspec);
3817
strendzap (char *str, const char *pat)
3821
assert (str != NULL);
3822
assert (pat != NULL);
3825
patlen = strlen (pat);
3829
str += len - patlen;
3830
if (strcmp (str, pat) == 0)
3837
lt_error_core (int exit_status, const char *mode,
3838
const char *message, va_list ap)
3840
fprintf (stderr, "%s: %s: ", program_name, mode);
3841
vfprintf (stderr, message, ap);
3842
fprintf (stderr, ".\n");
3844
if (exit_status >= 0)
3849
lt_fatal (const char *message, ...)
3852
va_start (ap, message);
3853
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3858
lt_setenv (const char *name, const char *value)
3860
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861
(name ? name : "<NULL>"),
3862
(value ? value : "<NULL>")));
3865
/* always make a copy, for consistency with !HAVE_SETENV */
3866
char *str = xstrdup (value);
3867
setenv (name, str, 1);
3869
int len = strlen (name) + 1 + strlen (value) + 1;
3870
char *str = XMALLOC (char, len);
3871
sprintf (str, "%s=%s", name, value);
3872
if (putenv (str) != EXIT_SUCCESS)
3881
lt_extend_str (const char *orig_value, const char *add, int to_end)
3884
if (orig_value && *orig_value)
3886
int orig_value_len = strlen (orig_value);
3887
int add_len = strlen (add);
3888
new_value = XMALLOC (char, add_len + orig_value_len + 1);
3891
strcpy (new_value, orig_value);
3892
strcpy (new_value + orig_value_len, add);
3896
strcpy (new_value, add);
3897
strcpy (new_value + add_len, orig_value);
3902
new_value = xstrdup (add);
3908
lt_split_name_value (const char *arg, char** name, char** value)
3915
p = strchr (arg, (int)'=');
3920
*value = xstrdup (++p);
3922
len = strlen (arg) - strlen (*value);
3923
*name = XMALLOC (char, len);
3924
strncpy (*name, arg, len-1);
3925
(*name)[len - 1] = '\0';
3931
lt_opt_process_env_set (const char *arg)
3936
if (lt_split_name_value (arg, &name, &value) != 0)
3940
lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3943
lt_setenv (name, value);
3949
lt_opt_process_env_prepend (const char *arg)
3953
char *new_value = NULL;
3955
if (lt_split_name_value (arg, &name, &value) != 0)
3959
lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3962
new_value = lt_extend_str (getenv (name), value, 0);
3963
lt_setenv (name, new_value);
3970
lt_opt_process_env_append (const char *arg)
3974
char *new_value = NULL;
3976
if (lt_split_name_value (arg, &name, &value) != 0)
3980
lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3983
new_value = lt_extend_str (getenv (name), value, 1);
3984
lt_setenv (name, new_value);
3991
lt_update_exe_path (const char *name, const char *value)
3993
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994
(name ? name : "<NULL>"),
3995
(value ? value : "<NULL>")));
3997
if (name && *name && value && *value)
3999
char *new_value = lt_extend_str (getenv (name), value, 0);
4000
/* some systems can't cope with a ':'-terminated path #' */
4001
int len = strlen (new_value);
4002
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4004
new_value[len-1] = '\0';
4006
lt_setenv (name, new_value);
4012
lt_update_lib_path (const char *name, const char *value)
4014
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015
(name ? name : "<NULL>"),
4016
(value ? value : "<NULL>")));
4018
if (name && *name && value && *value)
4020
char *new_value = lt_extend_str (getenv (name), value, 0);
4021
lt_setenv (name, new_value);
4029
# end: func_emit_cwrapperexe_src
4031
# func_mode_link arg...
4036
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
849
$show "$mv $output_obj $obj"
850
if $run $mv $output_obj $obj; then :
858
# Append the name of the non-PIC object the libtool object file.
859
# Only append if the libtool object file exists.
860
test -z "$run" && cat >> ${libobj}T <<EOF
861
# Name of the non-PIC object.
862
non_pic_object='$objname'
866
# Append the name of the non-PIC object the libtool object file.
867
# Only append if the libtool object file exists.
868
test -z "$run" && cat >> ${libobj}T <<EOF
869
# Name of the non-PIC object.
875
$run $mv "${libobj}T" "${libobj}"
877
# Unlock the critical section if it was locked
878
if test "$need_locks" != no; then
887
modename="$modename: link"
889
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4037
890
# It is impossible to link a dll without this setting, and
4038
891
# we shouldn't force the makefile maintainer to figure out
4039
892
# which system we are compiling for in order to pass an extra
7771
4528
# Replace the output file specification.
7772
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4529
link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7774
4531
# Delete the old output files.
7775
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
4532
$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
7777
func_show_eval "$link_command" 'exit $?'
4534
$show "$link_command"
4535
$run eval "$link_command" || exit $?
7779
4537
# Now create the wrapper script.
7780
func_verbose "creating $output"
4538
$show "creating $output"
7782
4540
# Quote the relink command for shipping.
7783
4541
if test -n "$relink_command"; then
7784
4542
# Preserve any variables that may affect compiler behavior
7785
4543
for var in $variables_saved_for_relink; do
7786
4544
if eval test -z \"\${$var+set}\"; then
7787
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
4545
relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
7788
4546
elif eval var_value=\$$var; test -z "$var_value"; then
7789
4547
relink_command="$var=; export $var; $relink_command"
7791
func_quote_for_eval "$var_value"
7792
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
4549
var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4550
relink_command="$var=\"$var_value\"; export $var; $relink_command"
7795
4553
relink_command="(cd `pwd`; $relink_command)"
7796
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4554
relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7799
# Quote $ECHO for shipping.
7800
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
4557
# Quote $echo for shipping.
4558
if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
7801
4559
case $progpath in
7802
4560
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7803
4561
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7805
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
4563
qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
7807
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
4565
qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
7810
# Only actually do things if not in dry run mode.
4568
# Only actually do things if our run command is non-null.
4569
if test -z "$run"; then
7812
4570
# win32 will think the script is a binary if it has
7813
4571
# a .exe suffix, so we strip it off here.
7814
4572
case $output in
7815
*.exe) func_stripname '' '.exe' "$output"
7816
output=$func_stripname_result ;;
4573
*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
7818
4575
# test for cygwin because mv fails w/o .exe extensions
7822
func_stripname '' '.exe' "$outputname"
7823
outputname=$func_stripname_result ;;
4579
outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
7827
4583
*cygwin* | *mingw* )
7828
func_dirname_and_basename "$output" "" "."
7829
output_name=$func_basename_result
7830
output_path=$func_dirname_result
7831
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7832
cwrapper="$output_path/$output_name.exe"
7833
$RM $cwrappersource $cwrapper
7834
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7836
func_emit_cwrapperexe_src > $cwrappersource
7838
# The wrapper executable is built using the $host compiler,
7839
# because it contains $host paths and files. If cross-
7840
# compiling, it, like the target executable, must be
7841
# executed on the $host or under an emulation environment.
7843
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7847
# Now, create the wrapper script for func_source use:
7848
func_ltwrapper_scriptname $cwrapper
7849
$RM $func_ltwrapper_scriptname_result
7850
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7852
# note: this script will not be executed, so do not chmod.
7853
if test "x$build" = "x$host" ; then
7854
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7856
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7862
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7864
func_emit_wrapper no > $output
4584
cwrappersource=`$echo ${objdir}/lt-${output}.c`
4585
cwrapper=`$echo ${output}.exe`
4586
$rm $cwrappersource $cwrapper
4587
trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4589
cat > $cwrappersource <<EOF
4591
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4592
Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4594
The $output program cannot be directly executed until all the libtool
4595
libraries that it depends on are installed.
4597
This wrapper executable should never be moved out of the build directory.
4598
If it is, it will not operate correctly.
4600
Currently, it simply execs the wrapper *script* "/bin/sh $output",
4601
but could eventually absorb all of the scripts functionality and
4602
exec $objdir/$outputname directly.
4605
cat >> $cwrappersource<<"EOF"
4613
#if defined(PATH_MAX)
4614
# define LT_PATHMAX PATH_MAX
4615
#elif defined(MAXPATHLEN)
4616
# define LT_PATHMAX MAXPATHLEN
4618
# define LT_PATHMAX 1024
4621
#ifndef DIR_SEPARATOR
4622
#define DIR_SEPARATOR '/'
4625
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4627
#define HAVE_DOS_BASED_FILE_SYSTEM
4628
#ifndef DIR_SEPARATOR_2
4629
#define DIR_SEPARATOR_2 '\\'
4633
#ifndef DIR_SEPARATOR_2
4634
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4635
#else /* DIR_SEPARATOR_2 */
4636
# define IS_DIR_SEPARATOR(ch) \
4637
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4638
#endif /* DIR_SEPARATOR_2 */
4640
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4641
#define XFREE(stale) do { \
4642
if (stale) { free ((void *) stale); stale = 0; } \
4645
const char *program_name = NULL;
4647
void * xmalloc (size_t num);
4648
char * xstrdup (const char *string);
4649
char * basename (const char *name);
4650
char * fnqualify(const char *path);
4651
char * strendzap(char *str, const char *pat);
4652
void lt_fatal (const char *message, ...);
4655
main (int argc, char *argv[])
4660
program_name = (char *) xstrdup ((char *) basename (argv[0]));
4661
newargz = XMALLOC(char *, argc+2);
4664
cat >> $cwrappersource <<EOF
4665
newargz[0] = "$SHELL";
4668
cat >> $cwrappersource <<"EOF"
4669
newargz[1] = fnqualify(argv[0]);
4670
/* we know the script has the same name, without the .exe */
4671
/* so make sure newargz[1] doesn't end in .exe */
4672
strendzap(newargz[1],".exe");
4673
for (i = 1; i < argc; i++)
4674
newargz[i+1] = xstrdup(argv[i]);
4675
newargz[argc+1] = NULL;
4678
cat >> $cwrappersource <<EOF
4679
execv("$SHELL",newargz);
4682
cat >> $cwrappersource <<"EOF"
4686
xmalloc (size_t num)
4688
void * p = (void *) malloc (num);
4690
lt_fatal ("Memory exhausted");
4696
xstrdup (const char *string)
4698
return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4703
basename (const char *name)
4707
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4708
/* Skip over the disk name in MSDOS pathnames. */
4709
if (isalpha (name[0]) && name[1] == ':')
4713
for (base = name; *name; name++)
4714
if (IS_DIR_SEPARATOR (*name))
4716
return (char *) base;
4720
fnqualify(const char *path)
4724
char tmp[LT_PATHMAX + 1];
4726
assert(path != NULL);
4728
/* Is it qualified already? */
4729
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4730
if (isalpha (path[0]) && path[1] == ':')
4731
return xstrdup (path);
4733
if (IS_DIR_SEPARATOR (path[0]))
4734
return xstrdup (path);
4736
/* prepend the current directory */
4737
/* doesn't handle '~' */
4738
if (getcwd (tmp, LT_PATHMAX) == NULL)
4739
lt_fatal ("getcwd failed");
4740
size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4741
p = XMALLOC(char, size);
4742
sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4747
strendzap(char *str, const char *pat)
4751
assert(str != NULL);
4752
assert(pat != NULL);
4755
patlen = strlen(pat);
4759
str += len - patlen;
4760
if (strcmp(str, pat) == 0)
4767
lt_error_core (int exit_status, const char * mode,
4768
const char * message, va_list ap)
4770
fprintf (stderr, "%s: %s: ", program_name, mode);
4771
vfprintf (stderr, message, ap);
4772
fprintf (stderr, ".\n");
4774
if (exit_status >= 0)
4779
lt_fatal (const char *message, ...)
4782
va_start (ap, message);
4783
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4787
# we should really use a build-platform specific compiler
4788
# here, but OTOH, the wrappers (shell script and this C one)
4789
# are only useful if you want to execute the "real" binary.
4790
# Since the "real" binary is built for $host, then this
4791
# wrapper might as well be built for $host, too.
4792
$run $LTCC -s -o $cwrapper $cwrappersource
4796
trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4801
# $output - temporary wrapper script for $objdir/$outputname
4802
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4804
# The $output program cannot be directly executed until all the libtool
4805
# libraries that it depends on are installed.
4807
# This wrapper script should never be moved out of the build directory.
4808
# If it is, it will not operate correctly.
4810
# Sed substitution that helps us do robust quoting. It backslashifies
4811
# metacharacters that are still active within double-quoted strings.
4812
Xsed='${SED} -e 1s/^X//'
4813
sed_quote_subst='$sed_quote_subst'
4815
# The HP-UX ksh and POSIX shell print the target directory to stdout
4817
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
4819
relink_command=\"$relink_command\"
4821
# This environment variable determines our operation mode.
4822
if test \"\$libtool_install_magic\" = \"$magic\"; then
4823
# install mode needs the following variable:
4824
notinst_deplibs='$notinst_deplibs'
4826
# When we are sourced in execute mode, \$file and \$echo are already set.
4827
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4830
# Make sure echo works.
4831
if test \"X\$1\" = X--no-reexec; then
4832
# Discard the --no-reexec flag, and continue.
4834
elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4835
# Yippee, \$echo works!
4838
# Restart under the correct shell, and then maybe \$echo will work.
4839
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4845
# Find the directory that this script lives in.
4846
thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4847
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4849
# Follow symbolic links until we get to the real thisdir.
4850
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4851
while test -n \"\$file\"; do
4852
destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4854
# If there was a directory component, then change thisdir.
4855
if test \"x\$destdir\" != \"x\$file\"; then
4856
case \"\$destdir\" in
4857
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4858
*) thisdir=\"\$thisdir/\$destdir\" ;;
4862
file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4863
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4866
# Try to get the absolute directory name.
4867
absdir=\`cd \"\$thisdir\" && pwd\`
4868
test -n \"\$absdir\" && thisdir=\"\$absdir\"
4871
if test "$fast_install" = yes; then
4873
program=lt-'$outputname'$exeext
4874
progdir=\"\$thisdir/$objdir\"
4876
if test ! -f \"\$progdir/\$program\" || \\
4877
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4878
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4880
file=\"\$\$-\$program\"
4882
if test ! -d \"\$progdir\"; then
4883
$mkdir \"\$progdir\"
4885
$rm \"\$progdir/\$file\"
4890
# relink executable if necessary
4891
if test -n \"\$relink_command\"; then
4892
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4894
$echo \"\$relink_command_output\" >&2
4895
$rm \"\$progdir/\$file\"
4900
$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4901
{ $rm \"\$progdir/\$program\";
4902
$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4903
$rm \"\$progdir/\$file\"
4907
program='$outputname'
4908
progdir=\"\$thisdir/$objdir\"
4914
if test -f \"\$progdir/\$program\"; then"
4916
# Export our shlibpath_var if we have one.
4917
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4919
# Add our own library path to $shlibpath_var
4920
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4922
# Some systems cannot cope with colon-terminated $shlibpath_var
4923
# The second colon is a workaround for a bug in BeOS R4 sed
4924
$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4926
export $shlibpath_var
4930
# fixup the dll searchpath if we need to.
4931
if test -n "$dllsearchpath"; then
4933
# Add the dll search path components to the executable PATH
4934
PATH=$dllsearchpath:\$PATH
4939
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4940
# Run the actual program with our arguments.
4943
# Backslashes separate directories on plain windows
4944
*-*-mingw | *-*-os2*)
4946
exec \$progdir\\\\\$program \${1+\"\$@\"}
4952
exec \$progdir/\$program \${1+\"\$@\"}
4957
\$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4961
# The program doesn't exist.
4962
\$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4963
\$echo \"This script is just a wrapper for \$program.\" 1>&2
4964
$echo \"See the $PACKAGE documentation for more information.\" 1>&2
7869
4971
exit $EXIT_SUCCESS
8168
5267
# Directory that this library needs to be installed in:
8169
5268
libdir='$install_libdir'"
8170
5269
if test "$installed" = no && test "$need_relink" = yes; then
8172
5271
relink_command=\"$relink_command\""
8177
5276
# Do a symbolic link so that the libtool archive can be found in
8178
5277
# LD_LIBRARY_PATH before the program is installed.
8179
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8185
{ test "$mode" = link || test "$mode" = relink; } &&
8186
func_mode_link ${1+"$@"}
8189
# func_mode_uninstall arg...
8190
func_mode_uninstall ()
5278
$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5279
$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5285
# libtool install mode
5287
modename="$modename: install"
5289
# There may be an optional sh(1) argument at the beginning of
5290
# install_prog (especially on Windows NT).
5291
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5292
# Allow the use of GNU shtool's install command.
5293
$echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5294
# Aesthetically quote it.
5295
arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5297
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*)
5301
install_prog="$arg "
5309
# The real first argument should be the name of the installation program.
5310
# Aesthetically quote it.
5311
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5313
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*)
5317
install_prog="$install_prog$arg"
5319
# We need to accept at least all the BSD install flags.
5329
if test -n "$dest"; then
5330
files="$files $dest"
5348
# If the previous option needed an argument, then skip it.
5349
if test -n "$prev"; then
5358
# Aesthetically quote the argument.
5359
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5361
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*)
5365
install_prog="$install_prog $arg"
5368
if test -z "$install_prog"; then
5369
$echo "$modename: you must specify an install program" 1>&2
5374
if test -n "$prev"; then
5375
$echo "$modename: the \`$prev' option requires an argument" 1>&2
5380
if test -z "$files"; then
5381
if test -z "$dest"; then
5382
$echo "$modename: no file or destination specified" 1>&2
5384
$echo "$modename: you must specify a destination" 1>&2
5390
# Strip any trailing slash from the destination.
5391
dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5393
# Check to see that the destination is a directory.
5394
test -d "$dest" && isdir=yes
5395
if test "$isdir" = yes; then
5399
destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5400
test "X$destdir" = "X$dest" && destdir=.
5401
destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5403
# Not a directory, so check to see that there is only one file specified.
5405
if test "$#" -gt 2; then
5406
$echo "$modename: \`$dest' is not a directory" 1>&2
5412
[\\/]* | [A-Za-z]:[\\/]*) ;;
5414
for file in $files; do
5418
$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5427
# This variable tells wrapper scripts just to set variables rather
5428
# than running their programs.
5429
libtool_install_magic="$magic"
5434
for file in $files; do
5436
# Do each installation.
5439
# Do the static libraries later.
5440
staticlibs="$staticlibs $file"
5444
# Check to see that this really is a libtool archive.
5445
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5447
$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5455
# If there is no directory component, then add one.
5457
*/* | *\\*) . $file ;;
5461
# Add the libdir to current_libdirs if it is the destination.
5462
if test "X$destdir" = "X$libdir"; then
5463
case "$current_libdirs " in
5465
*) current_libdirs="$current_libdirs $libdir" ;;
5468
# Note the libdir as a future libdir.
5469
case "$future_libdirs " in
5471
*) future_libdirs="$future_libdirs $libdir" ;;
5475
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5476
test "X$dir" = "X$file/" && dir=
5479
if test -n "$relink_command"; then
5480
# Determine the prefix the user has applied to our future dir.
5481
inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5483
# Don't allow the user to place us outside of our expected
5484
# location b/c this prevents finding dependent libraries that
5485
# are installed to the same prefix.
5486
# At present, this check doesn't affect windows .dll's that
5487
# are installed into $libdir/../bin (currently, that works fine)
5488
# but it's something to keep an eye on.
5489
if test "$inst_prefix_dir" = "$destdir"; then
5490
$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5494
if test -n "$inst_prefix_dir"; then
5495
# Stick the inst_prefix_dir data into the link command.
5496
relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5498
relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5501
$echo "$modename: warning: relinking \`$file'" 1>&2
5502
$show "$relink_command"
5503
if $run eval "$relink_command"; then :
5505
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5510
# See the names of the shared library.
5511
set dummy $library_names
5512
if test -n "$2"; then
5518
test -n "$relink_command" && srcname="$realname"T
5520
# Install the shared library and build the symlinks.
5521
$show "$install_prog $dir/$srcname $destdir/$realname"
5522
$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5523
if test -n "$stripme" && test -n "$striplib"; then
5524
$show "$striplib $destdir/$realname"
5525
$run eval "$striplib $destdir/$realname" || exit $?
5528
if test "$#" -gt 0; then
5529
# Delete the old symlinks, and create new ones.
5532
if test "$linkname" != "$realname"; then
5533
$show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5534
$run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5539
# Do each command in the postinstall commands.
5540
lib="$destdir/$realname"
5541
cmds=$postinstall_cmds
5542
save_ifs="$IFS"; IFS='~'
5543
for cmd in $cmds; do
5547
$run eval "$cmd" || exit $?
5552
# Install the pseudo-library for information purposes.
5553
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5554
instname="$dir/$name"i
5555
$show "$install_prog $instname $destdir/$name"
5556
$run eval "$install_prog $instname $destdir/$name" || exit $?
5558
# Maybe install the static library, too.
5559
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5563
# Install (i.e. copy) a libtool object.
5565
# Figure out destination file name, if it wasn't already specified.
5566
if test -n "$destname"; then
5567
destfile="$destdir/$destname"
5569
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5570
destfile="$destdir/$destfile"
5573
# Deduce the name of the destination old-style object file.
5576
staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5579
staticdest="$destfile"
5583
$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5589
# Install the libtool object if requested.
5590
if test -n "$destfile"; then
5591
$show "$install_prog $file $destfile"
5592
$run eval "$install_prog $file $destfile" || exit $?
5595
# Install the old object if enabled.
5596
if test "$build_old_libs" = yes; then
5597
# Deduce the name of the old-style object file.
5598
staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5600
$show "$install_prog $staticobj $staticdest"
5601
$run eval "$install_prog \$staticobj \$staticdest" || exit $?
5607
# Figure out destination file name, if it wasn't already specified.
5608
if test -n "$destname"; then
5609
destfile="$destdir/$destname"
5611
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5612
destfile="$destdir/$destfile"
5615
# If the file is missing, and there is a .exe on the end, strip it
5616
# because it is most likely a libtool script we actually want to
5621
if test ! -f "$file"; then
5622
file=`$echo $file|${SED} 's,.exe$,,'`
5628
# Do a test to see if this is really a libtool program.
5631
wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5637
if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5641
# To insure that "foo" is sourced, and not "foo.exe",
5642
# finese the cygwin/MSYS system by explicitly sourcing "foo."
5643
# which disallows the automatic-append-.exe behavior.
5645
*cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5646
*) wrapperdot=${wrapper} ;;
5648
# If there is no directory component, then add one.
5650
*/* | *\\*) . ${wrapperdot} ;;
5651
*) . ./${wrapperdot} ;;
5654
# Check the variables that should have been set.
5655
if test -z "$notinst_deplibs"; then
5656
$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5661
for lib in $notinst_deplibs; do
5662
# Check to see that each library is installed.
5664
if test -f "$lib"; then
5665
# If there is no directory component, then add one.
5667
*/* | *\\*) . $lib ;;
5671
libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5672
if test -n "$libdir" && test ! -f "$libfile"; then
5673
$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5679
# To insure that "foo" is sourced, and not "foo.exe",
5680
# finese the cygwin/MSYS system by explicitly sourcing "foo."
5681
# which disallows the automatic-append-.exe behavior.
5683
*cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5684
*) wrapperdot=${wrapper} ;;
5686
# If there is no directory component, then add one.
5688
*/* | *\\*) . ${wrapperdot} ;;
5689
*) . ./${wrapperdot} ;;
5693
if test "$fast_install" = no && test -n "$relink_command"; then
5694
if test "$finalize" = yes && test -z "$run"; then
5696
test -n "$TMPDIR" && tmpdir="$TMPDIR"
5697
tmpdir="$tmpdir/libtool-$$"
5700
if $mkdir "$tmpdir"; then
5704
$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5707
file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5708
outputname="$tmpdir/$file"
5709
# Replace the output file specification.
5710
relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5712
$show "$relink_command"
5713
if $run eval "$relink_command"; then :
5715
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5721
$echo "$modename: warning: cannot relink \`$file'" 1>&2
5724
# Install the binary that we compiled earlier.
5725
file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5729
# remove .exe since cygwin /usr/bin/install will append another
5731
case $install_prog,$host in
5732
*/usr/bin/install*,*cygwin*)
5733
case $file:$destfile in
5738
destfile=$destfile.exe
5741
destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5746
$show "$install_prog$stripme $file $destfile"
5747
$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5748
test -n "$outputname" && ${rm}r "$tmpdir"
5753
for file in $staticlibs; do
5754
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5756
# Set up the ranlib parameters.
5757
oldlib="$destdir/$name"
5759
$show "$install_prog $file $oldlib"
5760
$run eval "$install_prog \$file \$oldlib" || exit $?
5762
if test -n "$stripme" && test -n "$old_striplib"; then
5763
$show "$old_striplib $oldlib"
5764
$run eval "$old_striplib $oldlib" || exit $?
5767
# Do each command in the postinstall commands.
5768
cmds=$old_postinstall_cmds
5769
save_ifs="$IFS"; IFS='~'
5770
for cmd in $cmds; do
5774
$run eval "$cmd" || exit $?
5779
if test -n "$future_libdirs"; then
5780
$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5783
if test -n "$current_libdirs"; then
5784
# Maybe just do a dry run.
5785
test -n "$run" && current_libdirs=" -n$current_libdirs"
5786
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
5792
# libtool finish mode
5794
modename="$modename: finish"
5798
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5801
libdirs="$libdirs $dir"
5804
for libdir in $libdirs; do
5805
if test -n "$finish_cmds"; then
5806
# Do each command in the finish commands.
5808
save_ifs="$IFS"; IFS='~'
5809
for cmd in $cmds; do
5813
$run eval "$cmd" || admincmds="$admincmds
5818
if test -n "$finish_eval"; then
5819
# Do the single finish_eval.
5820
eval cmds=\"$finish_eval\"
5821
$run eval "$cmds" || admincmds="$admincmds
5827
# Exit here if they wanted silent mode.
5828
test "$show" = : && exit $EXIT_SUCCESS
5830
$echo "----------------------------------------------------------------------"
5831
$echo "Libraries have been installed in:"
5832
for libdir in $libdirs; do
5836
$echo "If you ever happen to want to link against installed libraries"
5837
$echo "in a given directory, LIBDIR, you must either use libtool, and"
5838
$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5839
$echo "flag during linking and do at least one of the following:"
5840
if test -n "$shlibpath_var"; then
5841
$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
5842
$echo " during execution"
5844
if test -n "$runpath_var"; then
5845
$echo " - add LIBDIR to the \`$runpath_var' environment variable"
5846
$echo " during linking"
5848
if test -n "$hardcode_libdir_flag_spec"; then
5850
eval flag=\"$hardcode_libdir_flag_spec\"
5852
$echo " - use the \`$flag' linker flag"
5854
if test -n "$admincmds"; then
5855
$echo " - have your system administrator run these commands:$admincmds"
5857
if test -f /etc/ld.so.conf; then
5858
$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5861
$echo "See any operating system documentation about shared libraries for"
5862
$echo "more information, such as the ld(1) and ld.so(8) manual pages."
5863
$echo "----------------------------------------------------------------------"
5867
# libtool execute mode
5869
modename="$modename: execute"
5871
# The first argument is the command name.
5873
if test -z "$cmd"; then
5874
$echo "$modename: you must specify a COMMAND" 1>&2
5879
# Handle -dlopen flags immediately.
5880
for file in $execute_dlfiles; do
5881
if test ! -f "$file"; then
5882
$echo "$modename: \`$file' is not a file" 1>&2
5890
# Check to see that this really is a libtool archive.
5891
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5893
$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5898
# Read the libtool library.
5902
# If there is no directory component, then add one.
5904
*/* | *\\*) . $file ;;
5908
# Skip this library if it cannot be dlopened.
5909
if test -z "$dlname"; then
5910
# Warn if it was a shared library.
5911
test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5915
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5916
test "X$dir" = "X$file" && dir=.
5918
if test -f "$dir/$objdir/$dlname"; then
5921
$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5927
# Just add the directory containing the .lo file.
5928
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5929
test "X$dir" = "X$file" && dir=.
5933
$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5938
# Get the absolute pathname.
5939
absdir=`cd "$dir" && pwd`
5940
test -n "$absdir" && dir="$absdir"
5942
# Now add the directory to shlibpath_var.
5943
if eval "test -z \"\$$shlibpath_var\""; then
5944
eval "$shlibpath_var=\"\$dir\""
5946
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5950
# This variable tells wrapper scripts just to set shlibpath_var
5951
# rather than running their programs.
5952
libtool_execute_magic="$magic"
5954
# Check if any of the arguments is a wrapper script.
5961
# Do a test to see if this is really a libtool program.
5962
if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5963
# If there is no directory component, then add one.
5965
*/* | *\\*) . $file ;;
5969
# Transform arg to wrapped name.
5970
file="$progdir/$program"
5974
# Quote arguments (to preserve shell metacharacters).
5975
file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5976
args="$args \"$file\""
5979
if test -z "$run"; then
5980
if test -n "$shlibpath_var"; then
5981
# Export the shlibpath_var.
5982
eval "export $shlibpath_var"
5985
# Restore saved environment variables
5986
if test "${save_LC_ALL+set}" = set; then
5987
LC_ALL="$save_LC_ALL"; export LC_ALL
5989
if test "${save_LANG+set}" = set; then
5990
LANG="$save_LANG"; export LANG
5993
# Now prepare to actually exec the command.
5994
exec_cmd="\$cmd$args"
5996
# Display what would be done.
5997
if test -n "$shlibpath_var"; then
5998
eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
5999
$echo "export $shlibpath_var"
6006
# libtool clean and uninstall mode
6008
modename="$modename: $mode"