1020
1420
avoid parallel builds (make -j) in this platform, or get a better
1023
$run $rm $removelist
1423
$opt_dry_run || $RM $removelist
1024
1424
exit $EXIT_FAILURE
1027
1427
# Just move the object if needed
1028
1428
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1029
$show "$mv $output_obj $obj"
1030
if $run $mv $output_obj $obj; then :
1033
$run $rm $removelist
1038
# Append the name of the non-PIC object the libtool object file.
1039
# Only append if the libtool object file exists.
1040
test -z "$run" && cat >> ${libobj}T <<EOF
1041
# Name of the non-PIC object.
1042
non_pic_object='$objname'
1046
# Append the name of the non-PIC object the libtool object file.
1047
# Only append if the libtool object file exists.
1048
test -z "$run" && cat >> ${libobj}T <<EOF
1049
# Name of the non-PIC object.
1055
$run $mv "${libobj}T" "${libobj}"
1057
# Unlock the critical section if it was locked
1058
if test "$need_locks" != no; then
1059
$run $rm "$lockfile"
1067
modename="$modename: link"
1069
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
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*)
1070
4037
# It is impossible to link a dll without this setting, and
1071
4038
# we shouldn't force the makefile maintainer to figure out
1072
4039
# which system we are compiling for in order to pass an extra
4823
7778
# Replace the output file specification.
4824
link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7779
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4826
7781
# Delete the old output files.
4827
$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
7782
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
4829
$show "$link_command"
4830
$run eval "$link_command" || exit $?
7784
func_show_eval "$link_command" 'exit $?'
4832
7786
# Now create the wrapper script.
4833
$show "creating $output"
7787
func_verbose "creating $output"
4835
7789
# Quote the relink command for shipping.
4836
7790
if test -n "$relink_command"; then
4837
7791
# Preserve any variables that may affect compiler behavior
4838
7792
for var in $variables_saved_for_relink; do
4839
7793
if eval test -z \"\${$var+set}\"; then
4840
relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
7794
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
4841
7795
elif eval var_value=\$$var; test -z "$var_value"; then
4842
7796
relink_command="$var=; export $var; $relink_command"
4844
var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4845
relink_command="$var=\"$var_value\"; export $var; $relink_command"
7798
func_quote_for_eval "$var_value"
7799
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
4848
7802
relink_command="(cd `pwd`; $relink_command)"
4849
relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7803
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4852
# Quote $echo for shipping.
4853
if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
7806
# Quote $ECHO for shipping.
7807
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
4854
7808
case $progpath in
4855
7809
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4856
7810
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4858
qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
7812
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
4860
qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
7814
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
4863
# Only actually do things if our run command is non-null.
4864
if test -z "$run"; then
7817
# Only actually do things if not in dry run mode.
4865
7819
# win32 will think the script is a binary if it has
4866
7820
# a .exe suffix, so we strip it off here.
4867
7821
case $output in
4868
*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
7822
*.exe) func_stripname '' '.exe' "$output"
7823
output=$func_stripname_result ;;
4870
7825
# test for cygwin because mv fails w/o .exe extensions
4874
outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
7829
func_stripname '' '.exe' "$outputname"
7830
outputname=$func_stripname_result ;;
4878
7834
*cygwin* | *mingw* )
4879
output_name=`basename $output`
4880
output_path=`dirname $output`
4881
cwrappersource="$output_path/$objdir/lt-$output_name.c"
4882
cwrapper="$output_path/$output_name.exe"
4883
$rm $cwrappersource $cwrapper
4884
trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4886
cat > $cwrappersource <<EOF
4888
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4889
Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4891
The $output program cannot be directly executed until all the libtool
4892
libraries that it depends on are installed.
4894
This wrapper executable should never be moved out of the build directory.
4895
If it is, it will not operate correctly.
4897
Currently, it simply execs the wrapper *script* "/bin/sh $output",
4898
but could eventually absorb all of the scripts functionality and
4899
exec $objdir/$outputname directly.
4902
cat >> $cwrappersource<<"EOF"
4911
#include <sys/stat.h>
4913
#if defined(PATH_MAX)
4914
# define LT_PATHMAX PATH_MAX
4915
#elif defined(MAXPATHLEN)
4916
# define LT_PATHMAX MAXPATHLEN
4918
# define LT_PATHMAX 1024
4921
#ifndef DIR_SEPARATOR
4922
# define DIR_SEPARATOR '/'
4923
# define PATH_SEPARATOR ':'
4926
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4928
# define HAVE_DOS_BASED_FILE_SYSTEM
4929
# ifndef DIR_SEPARATOR_2
4930
# define DIR_SEPARATOR_2 '\\'
4932
# ifndef PATH_SEPARATOR_2
4933
# define PATH_SEPARATOR_2 ';'
4937
#ifndef DIR_SEPARATOR_2
4938
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4939
#else /* DIR_SEPARATOR_2 */
4940
# define IS_DIR_SEPARATOR(ch) \
4941
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4942
#endif /* DIR_SEPARATOR_2 */
4944
#ifndef PATH_SEPARATOR_2
4945
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4946
#else /* PATH_SEPARATOR_2 */
4947
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4948
#endif /* PATH_SEPARATOR_2 */
4950
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4951
#define XFREE(stale) do { \
4952
if (stale) { free ((void *) stale); stale = 0; } \
4955
/* -DDEBUG is fairly common in CFLAGS. */
4957
#if defined DEBUGWRAPPER
4958
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
4960
# define DEBUG(format, ...)
4963
const char *program_name = NULL;
4965
void * xmalloc (size_t num);
4966
char * xstrdup (const char *string);
4967
const char * base_name (const char *name);
4968
char * find_executable(const char *wrapper);
4969
int check_executable(const char *path);
4970
char * strendzap(char *str, const char *pat);
4971
void lt_fatal (const char *message, ...);
4974
main (int argc, char *argv[])
4979
program_name = (char *) xstrdup (base_name (argv[0]));
4980
DEBUG("(main) argv[0] : %s\n",argv[0]);
4981
DEBUG("(main) program_name : %s\n",program_name);
4982
newargz = XMALLOC(char *, argc+2);
4985
cat >> $cwrappersource <<EOF
4986
newargz[0] = (char *) xstrdup("$SHELL");
4989
cat >> $cwrappersource <<"EOF"
4990
newargz[1] = find_executable(argv[0]);
4991
if (newargz[1] == NULL)
4992
lt_fatal("Couldn't find %s", argv[0]);
4993
DEBUG("(main) found exe at : %s\n",newargz[1]);
4994
/* we know the script has the same name, without the .exe */
4995
/* so make sure newargz[1] doesn't end in .exe */
4996
strendzap(newargz[1],".exe");
4997
for (i = 1; i < argc; i++)
4998
newargz[i+1] = xstrdup(argv[i]);
4999
newargz[argc+1] = NULL;
5001
for (i=0; i<argc+1; i++)
5003
DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
5011
cat >> $cwrappersource <<EOF
5012
execv("$SHELL",(char const **)newargz);
5016
cat >> $cwrappersource <<EOF
5017
execv("$SHELL",newargz);
5022
cat >> $cwrappersource <<"EOF"
5027
xmalloc (size_t num)
5029
void * p = (void *) malloc (num);
5031
lt_fatal ("Memory exhausted");
5037
xstrdup (const char *string)
5039
return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5044
base_name (const char *name)
5048
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5049
/* Skip over the disk name in MSDOS pathnames. */
5050
if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5054
for (base = name; *name; name++)
5055
if (IS_DIR_SEPARATOR (*name))
5061
check_executable(const char * path)
5065
DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5066
if ((!path) || (!*path))
5069
if ((stat (path, &st) >= 0) &&
5071
/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5072
#if defined (S_IXOTH)
5073
((st.st_mode & S_IXOTH) == S_IXOTH) ||
5075
#if defined (S_IXGRP)
5076
((st.st_mode & S_IXGRP) == S_IXGRP) ||
5078
((st.st_mode & S_IXUSR) == S_IXUSR))
5085
/* Searches for the full path of the wrapper. Returns
5086
newly allocated full path name if found, NULL otherwise */
5088
find_executable (const char* wrapper)
5093
/* static buffer for getcwd */
5094
char tmp[LT_PATHMAX + 1];
5098
DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5100
if ((wrapper == NULL) || (*wrapper == '\0'))
5103
/* Absolute path? */
5104
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5105
if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5107
concat_name = xstrdup (wrapper);
5108
if (check_executable(concat_name))
5115
if (IS_DIR_SEPARATOR (wrapper[0]))
5117
concat_name = xstrdup (wrapper);
5118
if (check_executable(concat_name))
5122
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5126
for (p = wrapper; *p; p++)
5134
/* no slashes; search PATH */
5135
const char* path = getenv ("PATH");
5138
for (p = path; *p; p = p_next)
5142
for (q = p; *q; q++)
5143
if (IS_PATH_SEPARATOR(*q))
5146
p_next = (*q == '\0' ? q : q + 1);
5149
/* empty path: current directory */
5150
if (getcwd (tmp, LT_PATHMAX) == NULL)
5151
lt_fatal ("getcwd failed");
5152
tmp_len = strlen(tmp);
5153
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5154
memcpy (concat_name, tmp, tmp_len);
5155
concat_name[tmp_len] = '/';
5156
strcpy (concat_name + tmp_len + 1, wrapper);
5160
concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5161
memcpy (concat_name, p, p_len);
5162
concat_name[p_len] = '/';
5163
strcpy (concat_name + p_len + 1, wrapper);
5165
if (check_executable(concat_name))
7835
func_dirname_and_basename "$output" "" "."
7836
output_name=$func_basename_result
7837
output_path=$func_dirname_result
7838
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7839
cwrapper="$output_path/$output_name.exe"
7840
$RM $cwrappersource $cwrapper
7841
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7843
func_emit_cwrapperexe_src > $cwrappersource
7845
# The wrapper executable is built using the $host compiler,
7846
# because it contains $host paths and files. If cross-
7847
# compiling, it, like the target executable, must be
7848
# executed on the $host or under an emulation environment.
7850
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7854
# Now, create the wrapper script for func_source use:
7855
func_ltwrapper_scriptname $cwrapper
7856
$RM $func_ltwrapper_scriptname_result
7857
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7859
# note: this script will not be executed, so do not chmod.
7860
if test "x$build" = "x$host" ; then
7861
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7863
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7869
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7871
func_emit_wrapper no > $output
5170
/* not found in PATH; assume curdir */
5172
/* Relative path | not found in path: prepend cwd */
5173
if (getcwd (tmp, LT_PATHMAX) == NULL)
5174
lt_fatal ("getcwd failed");
5175
tmp_len = strlen(tmp);
5176
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5177
memcpy (concat_name, tmp, tmp_len);
5178
concat_name[tmp_len] = '/';
5179
strcpy (concat_name + tmp_len + 1, wrapper);
5181
if (check_executable(concat_name))
5188
strendzap(char *str, const char *pat)
5192
assert(str != NULL);
5193
assert(pat != NULL);
5196
patlen = strlen(pat);
5200
str += len - patlen;
5201
if (strcmp(str, pat) == 0)
5208
lt_error_core (int exit_status, const char * mode,
5209
const char * message, va_list ap)
5211
fprintf (stderr, "%s: %s: ", program_name, mode);
5212
vfprintf (stderr, message, ap);
5213
fprintf (stderr, ".\n");
5215
if (exit_status >= 0)
5220
lt_fatal (const char *message, ...)
5223
va_start (ap, message);
5224
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5228
# we should really use a build-platform specific compiler
5229
# here, but OTOH, the wrappers (shell script and this C one)
5230
# are only useful if you want to execute the "real" binary.
5231
# Since the "real" binary is built for $host, then this
5232
# wrapper might as well be built for $host, too.
5233
$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5237
trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5242
# $output - temporary wrapper script for $objdir/$outputname
5243
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5245
# The $output program cannot be directly executed until all the libtool
5246
# libraries that it depends on are installed.
5248
# This wrapper script should never be moved out of the build directory.
5249
# If it is, it will not operate correctly.
5251
# Sed substitution that helps us do robust quoting. It backslashifies
5252
# metacharacters that are still active within double-quoted strings.
5253
Xsed='${SED} -e 1s/^X//'
5254
sed_quote_subst='$sed_quote_subst'
5256
# The HP-UX ksh and POSIX shell print the target directory to stdout
5258
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5260
relink_command=\"$relink_command\"
5262
# This environment variable determines our operation mode.
5263
if test \"\$libtool_install_magic\" = \"$magic\"; then
5264
# install mode needs the following variable:
5265
notinst_deplibs='$notinst_deplibs'
5267
# When we are sourced in execute mode, \$file and \$echo are already set.
5268
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5271
# Make sure echo works.
5272
if test \"X\$1\" = X--no-reexec; then
5273
# Discard the --no-reexec flag, and continue.
5275
elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5276
# Yippee, \$echo works!
5279
# Restart under the correct shell, and then maybe \$echo will work.
5280
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5286
# Find the directory that this script lives in.
5287
thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5288
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5290
# Follow symbolic links until we get to the real thisdir.
5291
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5292
while test -n \"\$file\"; do
5293
destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5295
# If there was a directory component, then change thisdir.
5296
if test \"x\$destdir\" != \"x\$file\"; then
5297
case \"\$destdir\" in
5298
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5299
*) thisdir=\"\$thisdir/\$destdir\" ;;
5303
file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5304
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5307
# Try to get the absolute directory name.
5308
absdir=\`cd \"\$thisdir\" && pwd\`
5309
test -n \"\$absdir\" && thisdir=\"\$absdir\"
5312
if test "$fast_install" = yes; then
5314
program=lt-'$outputname'$exeext
5315
progdir=\"\$thisdir/$objdir\"
5317
if test ! -f \"\$progdir/\$program\" || \\
5318
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5319
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5321
file=\"\$\$-\$program\"
5323
if test ! -d \"\$progdir\"; then
5324
$mkdir \"\$progdir\"
5326
$rm \"\$progdir/\$file\"
5331
# relink executable if necessary
5332
if test -n \"\$relink_command\"; then
5333
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5335
$echo \"\$relink_command_output\" >&2
5336
$rm \"\$progdir/\$file\"
5341
$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5342
{ $rm \"\$progdir/\$program\";
5343
$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5344
$rm \"\$progdir/\$file\"
5348
program='$outputname'
5349
progdir=\"\$thisdir/$objdir\"
5355
if test -f \"\$progdir/\$program\"; then"
5357
# Export our shlibpath_var if we have one.
5358
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5360
# Add our own library path to $shlibpath_var
5361
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5363
# Some systems cannot cope with colon-terminated $shlibpath_var
5364
# The second colon is a workaround for a bug in BeOS R4 sed
5365
$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5367
export $shlibpath_var
5371
# fixup the dll searchpath if we need to.
5372
if test -n "$dllsearchpath"; then
5374
# Add the dll search path components to the executable PATH
5375
PATH=$dllsearchpath:\$PATH
5380
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5381
# Run the actual program with our arguments.
5384
# Backslashes separate directories on plain windows
5385
*-*-mingw | *-*-os2*)
5387
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5393
exec \"\$progdir/\$program\" \${1+\"\$@\"}
5398
\$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
5402
# The program doesn't exist.
5403
\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5404
\$echo \"This script is just a wrapper for \$program.\" 1>&2
5405
$echo \"See the $PACKAGE documentation for more information.\" 1>&2
5412
7876
exit $EXIT_SUCCESS
5697
8175
# Directory that this library needs to be installed in:
5698
8176
libdir='$install_libdir'"
5699
8177
if test "$installed" = no && test "$need_relink" = yes; then
5701
8179
relink_command=\"$relink_command\""
5706
8184
# Do a symbolic link so that the libtool archive can be found in
5707
8185
# LD_LIBRARY_PATH before the program is installed.
5708
$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5709
$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5715
# libtool install mode
5717
modename="$modename: install"
5719
# There may be an optional sh(1) argument at the beginning of
5720
# install_prog (especially on Windows NT).
5721
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5722
# Allow the use of GNU shtool's install command.
5723
$echo "X$nonopt" | grep shtool > /dev/null; then
5724
# Aesthetically quote it.
5725
arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5727
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5731
install_prog="$arg "
5739
# The real first argument should be the name of the installation program.
5740
# Aesthetically quote it.
5741
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5743
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5747
install_prog="$install_prog$arg"
5749
# We need to accept at least all the BSD install flags.
5759
if test -n "$dest"; then
5760
files="$files $dest"
5768
case " $install_prog " in
5773
-g | -m | -o) prev=$arg ;;
5781
# If the previous option needed an argument, then skip it.
5782
if test -n "$prev"; then
5791
# Aesthetically quote the argument.
5792
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5794
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5798
install_prog="$install_prog $arg"
5801
if test -z "$install_prog"; then
5802
$echo "$modename: you must specify an install program" 1>&2
5807
if test -n "$prev"; then
5808
$echo "$modename: the \`$prev' option requires an argument" 1>&2
5813
if test -z "$files"; then
5814
if test -z "$dest"; then
5815
$echo "$modename: no file or destination specified" 1>&2
5817
$echo "$modename: you must specify a destination" 1>&2
5823
# Strip any trailing slash from the destination.
5824
dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5826
# Check to see that the destination is a directory.
5827
test -d "$dest" && isdir=yes
5828
if test "$isdir" = yes; then
5832
destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5833
test "X$destdir" = "X$dest" && destdir=.
5834
destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5836
# Not a directory, so check to see that there is only one file specified.
5838
if test "$#" -gt 2; then
5839
$echo "$modename: \`$dest' is not a directory" 1>&2
5845
[\\/]* | [A-Za-z]:[\\/]*) ;;
5847
for file in $files; do
5851
$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5860
# This variable tells wrapper scripts just to set variables rather
5861
# than running their programs.
5862
libtool_install_magic="$magic"
5867
for file in $files; do
5869
# Do each installation.
5872
# Do the static libraries later.
5873
staticlibs="$staticlibs $file"
5877
# Check to see that this really is a libtool archive.
5878
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5880
$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5888
# If there is no directory component, then add one.
5890
*/* | *\\*) . $file ;;
5894
# Add the libdir to current_libdirs if it is the destination.
5895
if test "X$destdir" = "X$libdir"; then
5896
case "$current_libdirs " in
5898
*) current_libdirs="$current_libdirs $libdir" ;;
5901
# Note the libdir as a future libdir.
5902
case "$future_libdirs " in
5904
*) future_libdirs="$future_libdirs $libdir" ;;
5908
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5909
test "X$dir" = "X$file/" && dir=
5912
if test -n "$relink_command"; then
5913
# Determine the prefix the user has applied to our future dir.
5914
inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5916
# Don't allow the user to place us outside of our expected
5917
# location b/c this prevents finding dependent libraries that
5918
# are installed to the same prefix.
5919
# At present, this check doesn't affect windows .dll's that
5920
# are installed into $libdir/../bin (currently, that works fine)
5921
# but it's something to keep an eye on.
5922
if test "$inst_prefix_dir" = "$destdir"; then
5923
$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5927
if test -n "$inst_prefix_dir"; then
5928
# Stick the inst_prefix_dir data into the link command.
5929
relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5931
relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5934
$echo "$modename: warning: relinking \`$file'" 1>&2
5935
$show "$relink_command"
5936
if $run eval "$relink_command"; then :
5938
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5943
# See the names of the shared library.
5944
set dummy $library_names
5945
if test -n "$2"; then
5951
test -n "$relink_command" && srcname="$realname"T
5953
# Install the shared library and build the symlinks.
5954
$show "$install_prog $dir/$srcname $destdir/$realname"
5955
$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5956
if test -n "$stripme" && test -n "$striplib"; then
5957
$show "$striplib $destdir/$realname"
5958
$run eval "$striplib $destdir/$realname" || exit $?
5961
if test "$#" -gt 0; then
5962
# Delete the old symlinks, and create new ones.
5963
# Try `ln -sf' first, because the `ln' binary might depend on
5964
# the symlink we replace! Solaris /bin/ln does not understand -f,
5965
# so we also need to try rm && ln -s.
5968
if test "$linkname" != "$realname"; then
5969
$show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5970
$run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5975
# Do each command in the postinstall commands.
5976
lib="$destdir/$realname"
5977
cmds=$postinstall_cmds
5978
save_ifs="$IFS"; IFS='~'
5979
for cmd in $cmds; do
5983
$run eval "$cmd" || {
5986
# Restore the uninstalled library and exit
5987
if test "$mode" = relink; then
5988
$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
5997
# Install the pseudo-library for information purposes.
5998
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5999
instname="$dir/$name"i
6000
$show "$install_prog $instname $destdir/$name"
6001
$run eval "$install_prog $instname $destdir/$name" || exit $?
6003
# Maybe install the static library, too.
6004
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6008
# Install (i.e. copy) a libtool object.
6010
# Figure out destination file name, if it wasn't already specified.
6011
if test -n "$destname"; then
6012
destfile="$destdir/$destname"
6014
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6015
destfile="$destdir/$destfile"
6018
# Deduce the name of the destination old-style object file.
6021
staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6024
staticdest="$destfile"
6028
$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6034
# Install the libtool object if requested.
6035
if test -n "$destfile"; then
6036
$show "$install_prog $file $destfile"
6037
$run eval "$install_prog $file $destfile" || exit $?
6040
# Install the old object if enabled.
6041
if test "$build_old_libs" = yes; then
6042
# Deduce the name of the old-style object file.
6043
staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6045
$show "$install_prog $staticobj $staticdest"
6046
$run eval "$install_prog \$staticobj \$staticdest" || exit $?
6052
# Figure out destination file name, if it wasn't already specified.
6053
if test -n "$destname"; then
6054
destfile="$destdir/$destname"
6056
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6057
destfile="$destdir/$destfile"
6060
# If the file is missing, and there is a .exe on the end, strip it
6061
# because it is most likely a libtool script we actually want to
6066
if test ! -f "$file"; then
6067
file=`$echo $file|${SED} 's,.exe$,,'`
6073
# Do a test to see if this is really a libtool program.
6076
wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6082
if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6086
# Note that it is not necessary on cygwin/mingw to append a dot to
6087
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6088
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6089
# `FILE.' does not work on cygwin managed mounts.
6091
# If there is no directory component, then add one.
6093
*/* | *\\*) . ${wrapper} ;;
6094
*) . ./${wrapper} ;;
6097
# Check the variables that should have been set.
6098
if test -z "$notinst_deplibs"; then
6099
$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6104
for lib in $notinst_deplibs; do
6105
# Check to see that each library is installed.
6107
if test -f "$lib"; then
6108
# If there is no directory component, then add one.
6110
*/* | *\\*) . $lib ;;
6114
libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6115
if test -n "$libdir" && test ! -f "$libfile"; then
6116
$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6122
# Note that it is not necessary on cygwin/mingw to append a dot to
6123
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6124
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6125
# `FILE.' does not work on cygwin managed mounts.
6127
# If there is no directory component, then add one.
6129
*/* | *\\*) . ${wrapper} ;;
6130
*) . ./${wrapper} ;;
6134
if test "$fast_install" = no && test -n "$relink_command"; then
6135
if test "$finalize" = yes && test -z "$run"; then
6136
tmpdir=`func_mktempdir`
6137
file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6138
outputname="$tmpdir/$file"
6139
# Replace the output file specification.
6140
relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
6142
$show "$relink_command"
6143
if $run eval "$relink_command"; then :
6145
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6151
$echo "$modename: warning: cannot relink \`$file'" 1>&2
6154
# Install the binary that we compiled earlier.
6155
file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6159
# remove .exe since cygwin /usr/bin/install will append another
6161
case $install_prog,$host in
6162
*/usr/bin/install*,*cygwin*)
6163
case $file:$destfile in
6168
destfile=$destfile.exe
6171
destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6176
$show "$install_prog$stripme $file $destfile"
6177
$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6178
test -n "$outputname" && ${rm}r "$tmpdir"
6183
for file in $staticlibs; do
6184
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6186
# Set up the ranlib parameters.
6187
oldlib="$destdir/$name"
6189
$show "$install_prog $file $oldlib"
6190
$run eval "$install_prog \$file \$oldlib" || exit $?
6192
if test -n "$stripme" && test -n "$old_striplib"; then
6193
$show "$old_striplib $oldlib"
6194
$run eval "$old_striplib $oldlib" || exit $?
6197
# Do each command in the postinstall commands.
6198
cmds=$old_postinstall_cmds
6199
save_ifs="$IFS"; IFS='~'
6200
for cmd in $cmds; do
6204
$run eval "$cmd" || exit $?
6209
if test -n "$future_libdirs"; then
6210
$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6213
if test -n "$current_libdirs"; then
6214
# Maybe just do a dry run.
6215
test -n "$run" && current_libdirs=" -n$current_libdirs"
6216
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6222
# libtool finish mode
6224
modename="$modename: finish"
6228
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6231
libdirs="$libdirs $dir"
6234
for libdir in $libdirs; do
6235
if test -n "$finish_cmds"; then
6236
# Do each command in the finish commands.
6238
save_ifs="$IFS"; IFS='~'
6239
for cmd in $cmds; do
6243
$run eval "$cmd" || admincmds="$admincmds
6248
if test -n "$finish_eval"; then
6249
# Do the single finish_eval.
6250
eval cmds=\"$finish_eval\"
6251
$run eval "$cmds" || admincmds="$admincmds
6257
# Exit here if they wanted silent mode.
6258
test "$show" = : && exit $EXIT_SUCCESS
6260
$echo "X----------------------------------------------------------------------" | $Xsed
6261
$echo "Libraries have been installed in:"
6262
for libdir in $libdirs; do
6266
$echo "If you ever happen to want to link against installed libraries"
6267
$echo "in a given directory, LIBDIR, you must either use libtool, and"
6268
$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6269
$echo "flag during linking and do at least one of the following:"
6270
if test -n "$shlibpath_var"; then
6271
$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
6272
$echo " during execution"
6274
if test -n "$runpath_var"; then
6275
$echo " - add LIBDIR to the \`$runpath_var' environment variable"
6276
$echo " during linking"
6278
if test -n "$hardcode_libdir_flag_spec"; then
6280
eval flag=\"$hardcode_libdir_flag_spec\"
6282
$echo " - use the \`$flag' linker flag"
6284
if test -n "$admincmds"; then
6285
$echo " - have your system administrator run these commands:$admincmds"
6287
if test -f /etc/ld.so.conf; then
6288
$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6291
$echo "See any operating system documentation about shared libraries for"
6292
$echo "more information, such as the ld(1) and ld.so(8) manual pages."
6293
$echo "X----------------------------------------------------------------------" | $Xsed
6297
# libtool execute mode
6299
modename="$modename: execute"
6301
# The first argument is the command name.
6303
if test -z "$cmd"; then
6304
$echo "$modename: you must specify a COMMAND" 1>&2
6309
# Handle -dlopen flags immediately.
6310
for file in $execute_dlfiles; do
6311
if test ! -f "$file"; then
6312
$echo "$modename: \`$file' is not a file" 1>&2
6320
# Check to see that this really is a libtool archive.
6321
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6323
$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6328
# Read the libtool library.
6332
# If there is no directory component, then add one.
6334
*/* | *\\*) . $file ;;
6338
# Skip this library if it cannot be dlopened.
6339
if test -z "$dlname"; then
6340
# Warn if it was a shared library.
6341
test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6345
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6346
test "X$dir" = "X$file" && dir=.
6348
if test -f "$dir/$objdir/$dlname"; then
6351
$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6357
# Just add the directory containing the .lo file.
6358
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6359
test "X$dir" = "X$file" && dir=.
6363
$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6368
# Get the absolute pathname.
6369
absdir=`cd "$dir" && pwd`
6370
test -n "$absdir" && dir="$absdir"
6372
# Now add the directory to shlibpath_var.
6373
if eval "test -z \"\$$shlibpath_var\""; then
6374
eval "$shlibpath_var=\"\$dir\""
6376
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6380
# This variable tells wrapper scripts just to set shlibpath_var
6381
# rather than running their programs.
6382
libtool_execute_magic="$magic"
6384
# Check if any of the arguments is a wrapper script.
6391
# Do a test to see if this is really a libtool program.
6392
if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6393
# If there is no directory component, then add one.
6395
*/* | *\\*) . $file ;;
6399
# Transform arg to wrapped name.
6400
file="$progdir/$program"
6404
# Quote arguments (to preserve shell metacharacters).
6405
file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6406
args="$args \"$file\""
6409
if test -z "$run"; then
6410
if test -n "$shlibpath_var"; then
6411
# Export the shlibpath_var.
6412
eval "export $shlibpath_var"
6415
# Restore saved environment variables
6416
if test "${save_LC_ALL+set}" = set; then
6417
LC_ALL="$save_LC_ALL"; export LC_ALL
6419
if test "${save_LANG+set}" = set; then
6420
LANG="$save_LANG"; export LANG
6423
# Now prepare to actually exec the command.
6424
exec_cmd="\$cmd$args"
6426
# Display what would be done.
6427
if test -n "$shlibpath_var"; then
6428
eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6429
$echo "export $shlibpath_var"
6436
# libtool clean and uninstall mode
6438
modename="$modename: $mode"
8186
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8192
{ test "$mode" = link || test "$mode" = relink; } &&
8193
func_mode_link ${1+"$@"}
8196
# func_mode_uninstall arg...
8197
func_mode_uninstall ()