170
364
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
172
366
if test ! -d "$my_tmpdir"; then
173
# Failing that, at least try and use $RANDOM to avoid a race
174
my_tmpdir="${my_template}-${RANDOM-0}$$"
367
# Failing that, at least try and use $RANDOM to avoid a race
368
my_tmpdir="${my_template}-${RANDOM-0}$$"
176
save_mktempdir_umask=`umask`
179
umask $save_mktempdir_umask
370
save_mktempdir_umask=`umask`
373
umask $save_mktempdir_umask
182
376
# If we're not in dry-run mode, bomb out on failure
183
test -d "$my_tmpdir" || {
184
$echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
189
$echo "X$my_tmpdir" | $Xsed
193
# func_win32_libid arg
194
# return the library type of file 'arg'
196
# Need a lot of goo to handle *both* DLLs and import libs
197
# Has to be a shell function in order to 'eat' the argument
198
# that is supplied when $file_magic_command is called.
201
win32_libid_type="unknown"
202
win32_fileres=`file -L $1 2>/dev/null`
203
case $win32_fileres in
204
*ar\ archive\ import\ library*) # definitely import
205
win32_libid_type="x86 archive import"
207
*ar\ archive*) # could be an import, or static
208
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
209
$EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
210
win32_nmres=`eval $NM -f posix -A $1 | \
219
import*) win32_libid_type="x86 archive import";;
220
*) win32_libid_type="x86 archive static";;
225
win32_libid_type="x86 DLL"
227
*executable*) # but shell scripts are "executable" too...
228
case $win32_fileres in
229
*MS\ Windows\ PE\ Intel*)
230
win32_libid_type="x86 DLL"
235
$echo $win32_libid_type
377
test -d "$my_tmpdir" || \
378
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
381
$ECHO "X$my_tmpdir" | $Xsed
385
# func_quote_for_eval arg
386
# Aesthetically quote ARG to be evaled later.
387
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
388
# is double-quoted, suitable for a subsequent eval, whereas
389
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
390
# which are still active within double quotes backslashified.
391
func_quote_for_eval ()
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
397
func_quote_for_eval_unquoted_result="$1" ;;
400
case $func_quote_for_eval_unquoted_result in
401
# Double-quote args containing shell metacharacters to delay
402
# word splitting, command substitution and and variable
403
# expansion for a subsequent eval.
404
# Many Bourne shells cannot handle close brackets correctly
405
# in scan sets, so we specify it separately.
406
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
407
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
410
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
415
# func_quote_for_expand arg
416
# Aesthetically quote ARG to be evaled later; same as above,
417
# but do not quote variable references.
418
func_quote_for_expand ()
422
my_arg=`$ECHO "X$1" | $Xsed \
423
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
429
# Double-quote args containing shell metacharacters to delay
430
# word splitting and command substitution for a subsequent eval.
431
# Many Bourne shells cannot handle close brackets correctly
432
# in scan sets, so we specify it separately.
433
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
438
func_quote_for_expand_result="$my_arg"
442
# func_show_eval cmd [fail_exp]
443
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
444
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
445
# is given, then evaluate it.
451
${opt_silent-false} || {
452
func_quote_for_expand "$my_cmd"
453
eval "func_echo $func_quote_for_expand_result"
456
if ${opt_dry_run-false}; then :; else
459
if test "$my_status" -eq 0; then :; else
460
eval "(exit $my_status); $my_fail_exp"
466
# func_show_eval_locale cmd [fail_exp]
467
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
468
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
469
# is given, then evaluate it. Use the saved locale for evaluation.
470
func_show_eval_locale ()
475
${opt_silent-false} || {
476
func_quote_for_expand "$my_cmd"
477
eval "func_echo $func_quote_for_expand_result"
480
if ${opt_dry_run-false}; then :; else
481
eval "$lt_user_locale
484
eval "$lt_safe_locale"
485
if test "$my_status" -eq 0; then :; else
486
eval "(exit $my_status); $my_fail_exp"
496
# Echo version message to standard output and exit.
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
502
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
509
# Echo short help message to standard output and exit.
512
$SED -n '/^# Usage:/,/# -h/ {
515
s/\$progname/'$progname'/
519
$ECHO "run \`$progname --help | more' for full usage"
524
# Echo long help message to standard output and exit.
527
$SED -n '/^# Usage:/,/# Report bugs to/ {
530
s*\$progname*'$progname'*
532
s*\$SHELL*'"$SHELL"'*
534
s*\$LTCFLAGS*'"$LTCFLAGS"'*
536
s/\$with_gnu_ld/'"$with_gnu_ld"'/
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
544
# func_missing_arg argname
545
# Echo program name prefixed message to standard error and set global
549
func_error "missing argument for $1"
559
# Check that we have a working $ECHO.
560
if test "X$1" = X--no-reexec; then
561
# Discard the --no-reexec flag, and continue.
563
elif test "X$1" = X--fallback-echo; then
564
# Avoid inline document here, it may be left over
566
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567
# Yippee, $ECHO works!
570
# Restart under the correct shell, and then maybe $ECHO will work.
571
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
574
if test "X$1" = X--fallback-echo; then
575
# used as fallback echo
583
magic="%%%MAGIC variable%%%"
584
magic_exe="%%%MAGIC EXE variable%%%"
591
lo2o="s/\\.lo\$/.${objext}/"
592
o2lo="s/\\.${objext}\$/.lo/"
597
opt_duplicate_deps=false
601
# If this variable is set in any of the actions, the command in it
602
# will be execed at the end. This prevents here-documents from being
603
# left over by shells.
606
# func_fatal_configuration arg...
607
# Echo program name prefixed message to standard error, followed by
608
# a configuration failure hint, and exit.
609
func_fatal_configuration ()
612
func_error "See the $PACKAGE documentation for more information."
613
func_fatal_error "Fatal configuration error."
618
# Display the configuration for all the tags in this script.
621
re_begincf='^# ### BEGIN LIBTOOL'
622
re_endcf='^# ### END LIBTOOL'
624
# Default configuration.
625
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
627
# Now print the configurations for the tags.
628
for tagname in $taglist; do
629
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
636
# Display the features supported by this script.
640
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
643
$ECHO "disable shared libraries"
645
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
648
$ECHO "disable static libraries"
654
# func_enable_tag tagname
655
# Verify that TAGNAME is valid, and either flag an error and exit, or
656
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
663
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
664
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
665
sed_extractcf="/$re_begincf/,/$re_endcf/p"
670
func_fatal_error "invalid tag name: $tagname"
674
# Don't test for the "default" C tag, as we know it's
675
# there but not specially marked.
679
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
680
taglist="$taglist $tagname"
682
# Evaluate the configuration. Be careful to quote the path
683
# and the sed script, to avoid splitting on whitespace, but
684
# also don't use non-portable quotes within backquotes within
685
# quotes we have to do it in 2 steps:
686
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
689
func_error "ignoring unknown tag $tagname"
695
# Parse options once, thoroughly. This comes as soon as possible in
696
# the script to make things like `libtool --version' happen quickly.
699
# Shorthand for --mode=foo, only valid as the first argument
702
shift; set dummy --mode clean ${1+"$@"}; shift
704
compile|compil|compi|comp|com|co|c)
705
shift; set dummy --mode compile ${1+"$@"}; shift
707
execute|execut|execu|exec|exe|ex|e)
708
shift; set dummy --mode execute ${1+"$@"}; shift
710
finish|finis|fini|fin|fi|f)
711
shift; set dummy --mode finish ${1+"$@"}; shift
713
install|instal|insta|inst|ins|in|i)
714
shift; set dummy --mode install ${1+"$@"}; shift
717
shift; set dummy --mode link ${1+"$@"}; shift
719
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720
shift; set dummy --mode uninstall ${1+"$@"}; shift
724
# Parse non-mode specific arguments:
725
while test "$#" -gt 0; do
730
--config) func_config ;;
732
--debug) preserve_args="$preserve_args $opt"
733
func_echo "enabling shell trace mode"
738
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
739
execute_dlfiles="$execute_dlfiles $1"
743
--dry-run | -n) opt_dry_run=: ;;
744
--features) func_features ;;
745
--finish) mode="finish" ;;
747
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
749
# Valid mode arguments:
759
# Catch anything else as an error
760
*) func_error "invalid argument for $opt"
771
opt_duplicate_deps=: ;;
773
--quiet|--silent) preserve_args="$preserve_args $opt"
777
--verbose| -v) preserve_args="$preserve_args $opt"
781
--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
782
preserve_args="$preserve_args $opt $1"
783
func_enable_tag "$1" # tagname is set here
787
# Separate optargs to long options:
788
-dlopen=*|--mode=*|--tag=*)
789
func_opt_split "$opt"
790
set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
794
-\?|-h) func_usage ;;
795
--help) opt_help=: ;;
796
--version) func_version ;;
798
-*) func_fatal_help "unrecognized option \`$opt'" ;;
808
*cygwin* | *mingw* | *pw32* | *cegcc*)
809
# don't eliminate duplications in $postdeps and $predeps
810
opt_duplicate_compiler_generated_deps=:
813
opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
817
# Having warned about all mis-specified options, bail out if
818
# anything was wrong.
819
$exit_cmd $EXIT_FAILURE
822
# func_check_version_match
823
# Ensure that we are using m4 macros, and libtool script from the same
824
# release of libtool.
825
func_check_version_match ()
827
if test "$package_revision" != "$macro_revision"; then
828
if test "$VERSION" != "$macro_version"; then
829
if test -z "$macro_version"; then
831
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
832
$progname: definition of this LT_INIT comes from an older release.
833
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
834
$progname: and run autoconf again.
838
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
839
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
840
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
841
$progname: and run autoconf again.
846
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
847
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
848
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
849
$progname: of $PACKAGE $VERSION and run autoconf again.
863
# Sanity checks first:
864
func_check_version_match
866
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
867
func_fatal_configuration "not configured to build any kind of library"
870
test -z "$mode" && func_fatal_error "error: you must specify a MODE."
874
eval std_shrext=\"$shrext_cmds\"
877
# Only execute mode is allowed to have -dlopen flags.
878
if test -n "$execute_dlfiles" && test "$mode" != execute; then
879
func_error "unrecognized option \`-dlopen'"
884
# Change the help message to a mode-specific one.
886
help="Try \`$progname --help --mode=$mode' for more information."
891
# True iff FILE is a libtool `.la' library or `.lo' object file.
892
# This function is only a basic sanity check; it will hardly flush out
893
# determined imposters.
897
$SED -e 4q "$1" 2>/dev/null \
898
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
901
# func_lalib_unsafe_p file
902
# True iff FILE is a libtool `.la' library or `.lo' object file.
903
# This function implements the same check as func_lalib_p without
904
# resorting to external programs. To this end, it redirects stdin and
905
# closes it afterwards, without saving the original file descriptor.
906
# As a safety measure, use it only where a negative result would be
907
# fatal anyway. Works if `file' does not exist.
908
func_lalib_unsafe_p ()
911
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
912
for lalib_p_l in 1 2 3 4
915
case "$lalib_p_line" in
916
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
921
test "$lalib_p" = yes
924
# func_ltwrapper_script_p file
925
# True iff FILE is a libtool wrapper script
926
# This function is only a basic sanity check; it will hardly flush out
927
# determined imposters.
928
func_ltwrapper_script_p ()
933
# func_ltwrapper_executable_p file
934
# True iff FILE is a libtool wrapper executable
935
# This function is only a basic sanity check; it will hardly flush out
936
# determined imposters.
937
func_ltwrapper_executable_p ()
939
func_ltwrapper_exec_suffix=
942
*) func_ltwrapper_exec_suffix=.exe ;;
944
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
947
# func_ltwrapper_scriptname file
948
# Assumes file is an ltwrapper_executable
949
# uses $file to determine the appropriate filename for a
950
# temporary ltwrapper_script.
951
func_ltwrapper_scriptname ()
953
func_ltwrapper_scriptname_result=""
954
if func_ltwrapper_executable_p "$1"; then
955
func_dirname_and_basename "$1" "" "."
956
func_stripname '' '.exe' "$func_basename_result"
957
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
961
# func_ltwrapper_p file
962
# True iff FILE is a libtool wrapper script or wrapper executable
963
# This function is only a basic sanity check; it will hardly flush out
964
# determined imposters.
967
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
971
# func_execute_cmds commands fail_cmd
972
# Execute tilde-delimited COMMANDS.
973
# If FAIL_CMD is given, eval that upon failure.
974
# FAIL_CMD may read-access the current command in variable CMD!
978
save_ifs=$IFS; IFS='~'
982
func_show_eval "$cmd" "${2-:}"
989
# Source FILE, adding directory component if necessary.
990
# Note that it is not necessary on cygwin/mingw to append a dot to
991
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
992
# behavior happens only for exec(3), not for open(2)! Also, sourcing
993
# `FILE.' does not work on cygwin managed mounts.
998
*/* | *\\*) . "$1" ;;
1050
1420
avoid parallel builds (make -j) in this platform, or get a better
1053
$run $rm $removelist
1423
$opt_dry_run || $RM $removelist
1054
1424
exit $EXIT_FAILURE
1057
1427
# Just move the object if needed
1058
1428
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1059
$show "$mv $output_obj $obj"
1060
if $run $mv $output_obj $obj; then :
1063
$run $rm $removelist
1068
# Append the name of the non-PIC object the libtool object file.
1069
# Only append if the libtool object file exists.
1070
test -z "$run" && cat >> ${libobj}T <<EOF
1071
# Name of the non-PIC object.
1072
non_pic_object='$objname'
1076
# Append the name of the non-PIC object the libtool object file.
1077
# Only append if the libtool object file exists.
1078
test -z "$run" && cat >> ${libobj}T <<EOF
1079
# Name of the non-PIC object.
1085
$run $mv "${libobj}T" "${libobj}"
1087
# Unlock the critical section if it was locked
1088
if test "$need_locks" != no; then
1089
$run $rm "$lockfile"
1097
modename="$modename: link"
1099
*-*-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*)
1100
4037
# It is impossible to link a dll without this setting, and
1101
4038
# we shouldn't force the makefile maintainer to figure out
1102
4039
# which system we are compiling for in order to pass an extra
4872
7771
# Replace the output file specification.
4873
link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7772
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4875
7774
# Delete the old output files.
4876
$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
7775
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
4878
$show "$link_command"
4879
$run eval "$link_command" || exit $?
7777
func_show_eval "$link_command" 'exit $?'
4881
7779
# Now create the wrapper script.
4882
$show "creating $output"
7780
func_verbose "creating $output"
4884
7782
# Quote the relink command for shipping.
4885
7783
if test -n "$relink_command"; then
4886
7784
# Preserve any variables that may affect compiler behavior
4887
7785
for var in $variables_saved_for_relink; do
4888
7786
if eval test -z \"\${$var+set}\"; then
4889
relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
7787
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
4890
7788
elif eval var_value=\$$var; test -z "$var_value"; then
4891
7789
relink_command="$var=; export $var; $relink_command"
4893
var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4894
relink_command="$var=\"$var_value\"; export $var; $relink_command"
7791
func_quote_for_eval "$var_value"
7792
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
4897
7795
relink_command="(cd `pwd`; $relink_command)"
4898
relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
7796
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4901
# Quote $echo for shipping.
4902
if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
7799
# Quote $ECHO for shipping.
7800
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
4903
7801
case $progpath in
4904
7802
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4905
7803
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4907
qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
7805
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
4909
qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
7807
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
4912
# Only actually do things if our run command is non-null.
4913
if test -z "$run"; then
7810
# Only actually do things if not in dry run mode.
4914
7812
# win32 will think the script is a binary if it has
4915
7813
# a .exe suffix, so we strip it off here.
4916
7814
case $output in
4917
*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
7815
*.exe) func_stripname '' '.exe' "$output"
7816
output=$func_stripname_result ;;
4919
7818
# test for cygwin because mv fails w/o .exe extensions
4923
outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
7822
func_stripname '' '.exe' "$outputname"
7823
outputname=$func_stripname_result ;;
4927
7827
*cygwin* | *mingw* )
4928
output_name=`basename $output`
4929
output_path=`dirname $output`
4930
cwrappersource="$output_path/$objdir/lt-$output_name.c"
4931
cwrapper="$output_path/$output_name.exe"
4932
$rm $cwrappersource $cwrapper
4933
trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4935
cat > $cwrappersource <<EOF
4937
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4938
Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4940
The $output program cannot be directly executed until all the libtool
4941
libraries that it depends on are installed.
4943
This wrapper executable should never be moved out of the build directory.
4944
If it is, it will not operate correctly.
4946
Currently, it simply execs the wrapper *script* "/bin/sh $output",
4947
but could eventually absorb all of the scripts functionality and
4948
exec $objdir/$outputname directly.
4951
cat >> $cwrappersource<<"EOF"
4960
#include <sys/stat.h>
4962
#if defined(PATH_MAX)
4963
# define LT_PATHMAX PATH_MAX
4964
#elif defined(MAXPATHLEN)
4965
# define LT_PATHMAX MAXPATHLEN
4967
# define LT_PATHMAX 1024
4970
#ifndef DIR_SEPARATOR
4971
# define DIR_SEPARATOR '/'
4972
# define PATH_SEPARATOR ':'
4975
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4977
# define HAVE_DOS_BASED_FILE_SYSTEM
4978
# ifndef DIR_SEPARATOR_2
4979
# define DIR_SEPARATOR_2 '\\'
4981
# ifndef PATH_SEPARATOR_2
4982
# define PATH_SEPARATOR_2 ';'
4986
#ifndef DIR_SEPARATOR_2
4987
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4988
#else /* DIR_SEPARATOR_2 */
4989
# define IS_DIR_SEPARATOR(ch) \
4990
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4991
#endif /* DIR_SEPARATOR_2 */
4993
#ifndef PATH_SEPARATOR_2
4994
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4995
#else /* PATH_SEPARATOR_2 */
4996
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4997
#endif /* PATH_SEPARATOR_2 */
4999
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5000
#define XFREE(stale) do { \
5001
if (stale) { free ((void *) stale); stale = 0; } \
5004
/* -DDEBUG is fairly common in CFLAGS. */
5006
#if defined DEBUGWRAPPER
5007
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5009
# define DEBUG(format, ...)
5012
const char *program_name = NULL;
5014
void * xmalloc (size_t num);
5015
char * xstrdup (const char *string);
5016
const char * base_name (const char *name);
5017
char * find_executable(const char *wrapper);
5018
int check_executable(const char *path);
5019
char * strendzap(char *str, const char *pat);
5020
void lt_fatal (const char *message, ...);
5023
main (int argc, char *argv[])
5028
program_name = (char *) xstrdup (base_name (argv[0]));
5029
DEBUG("(main) argv[0] : %s\n",argv[0]);
5030
DEBUG("(main) program_name : %s\n",program_name);
5031
newargz = XMALLOC(char *, argc+2);
5034
cat >> $cwrappersource <<EOF
5035
newargz[0] = (char *) xstrdup("$SHELL");
5038
cat >> $cwrappersource <<"EOF"
5039
newargz[1] = find_executable(argv[0]);
5040
if (newargz[1] == NULL)
5041
lt_fatal("Couldn't find %s", argv[0]);
5042
DEBUG("(main) found exe at : %s\n",newargz[1]);
5043
/* we know the script has the same name, without the .exe */
5044
/* so make sure newargz[1] doesn't end in .exe */
5045
strendzap(newargz[1],".exe");
5046
for (i = 1; i < argc; i++)
5047
newargz[i+1] = xstrdup(argv[i]);
5048
newargz[argc+1] = NULL;
5050
for (i=0; i<argc+1; i++)
5052
DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
5060
cat >> $cwrappersource <<EOF
5061
execv("$SHELL",(char const **)newargz);
5065
cat >> $cwrappersource <<EOF
5066
execv("$SHELL",newargz);
5071
cat >> $cwrappersource <<"EOF"
5076
xmalloc (size_t num)
5078
void * p = (void *) malloc (num);
5080
lt_fatal ("Memory exhausted");
5086
xstrdup (const char *string)
5088
return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5093
base_name (const char *name)
5097
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5098
/* Skip over the disk name in MSDOS pathnames. */
5099
if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5103
for (base = name; *name; name++)
5104
if (IS_DIR_SEPARATOR (*name))
5110
check_executable(const char * path)
5114
DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5115
if ((!path) || (!*path))
5118
if ((stat (path, &st) >= 0) &&
5120
/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5121
#if defined (S_IXOTH)
5122
((st.st_mode & S_IXOTH) == S_IXOTH) ||
5124
#if defined (S_IXGRP)
5125
((st.st_mode & S_IXGRP) == S_IXGRP) ||
5127
((st.st_mode & S_IXUSR) == S_IXUSR))
5134
/* Searches for the full path of the wrapper. Returns
5135
newly allocated full path name if found, NULL otherwise */
5137
find_executable (const char* wrapper)
5142
/* static buffer for getcwd */
5143
char tmp[LT_PATHMAX + 1];
5147
DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5149
if ((wrapper == NULL) || (*wrapper == '\0'))
5152
/* Absolute path? */
5153
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5154
if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5156
concat_name = xstrdup (wrapper);
5157
if (check_executable(concat_name))
5164
if (IS_DIR_SEPARATOR (wrapper[0]))
5166
concat_name = xstrdup (wrapper);
5167
if (check_executable(concat_name))
5171
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5175
for (p = wrapper; *p; p++)
5183
/* no slashes; search PATH */
5184
const char* path = getenv ("PATH");
5187
for (p = path; *p; p = p_next)
5191
for (q = p; *q; q++)
5192
if (IS_PATH_SEPARATOR(*q))
5195
p_next = (*q == '\0' ? q : q + 1);
5198
/* empty path: current directory */
5199
if (getcwd (tmp, LT_PATHMAX) == NULL)
5200
lt_fatal ("getcwd failed");
5201
tmp_len = strlen(tmp);
5202
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5203
memcpy (concat_name, tmp, tmp_len);
5204
concat_name[tmp_len] = '/';
5205
strcpy (concat_name + tmp_len + 1, wrapper);
5209
concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5210
memcpy (concat_name, p, p_len);
5211
concat_name[p_len] = '/';
5212
strcpy (concat_name + p_len + 1, wrapper);
5214
if (check_executable(concat_name))
7828
func_dirname_and_basename "$output" "" "."
7829
output_name=$func_basename_result
7830
output_path=$func_dirname_result
7831
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7832
cwrapper="$output_path/$output_name.exe"
7833
$RM $cwrappersource $cwrapper
7834
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7836
func_emit_cwrapperexe_src > $cwrappersource
7838
# The wrapper executable is built using the $host compiler,
7839
# because it contains $host paths and files. If cross-
7840
# compiling, it, like the target executable, must be
7841
# executed on the $host or under an emulation environment.
7843
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7847
# Now, create the wrapper script for func_source use:
7848
func_ltwrapper_scriptname $cwrapper
7849
$RM $func_ltwrapper_scriptname_result
7850
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7852
# note: this script will not be executed, so do not chmod.
7853
if test "x$build" = "x$host" ; then
7854
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7856
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7862
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7864
func_emit_wrapper no > $output
5219
/* not found in PATH; assume curdir */
5221
/* Relative path | not found in path: prepend cwd */
5222
if (getcwd (tmp, LT_PATHMAX) == NULL)
5223
lt_fatal ("getcwd failed");
5224
tmp_len = strlen(tmp);
5225
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5226
memcpy (concat_name, tmp, tmp_len);
5227
concat_name[tmp_len] = '/';
5228
strcpy (concat_name + tmp_len + 1, wrapper);
5230
if (check_executable(concat_name))
5237
strendzap(char *str, const char *pat)
5241
assert(str != NULL);
5242
assert(pat != NULL);
5245
patlen = strlen(pat);
5249
str += len - patlen;
5250
if (strcmp(str, pat) == 0)
5257
lt_error_core (int exit_status, const char * mode,
5258
const char * message, va_list ap)
5260
fprintf (stderr, "%s: %s: ", program_name, mode);
5261
vfprintf (stderr, message, ap);
5262
fprintf (stderr, ".\n");
5264
if (exit_status >= 0)
5269
lt_fatal (const char *message, ...)
5272
va_start (ap, message);
5273
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5277
# we should really use a build-platform specific compiler
5278
# here, but OTOH, the wrappers (shell script and this C one)
5279
# are only useful if you want to execute the "real" binary.
5280
# Since the "real" binary is built for $host, then this
5281
# wrapper might as well be built for $host, too.
5282
$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5286
trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5291
# $output - temporary wrapper script for $objdir/$outputname
5292
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5294
# The $output program cannot be directly executed until all the libtool
5295
# libraries that it depends on are installed.
5297
# This wrapper script should never be moved out of the build directory.
5298
# If it is, it will not operate correctly.
5300
# Sed substitution that helps us do robust quoting. It backslashifies
5301
# metacharacters that are still active within double-quoted strings.
5302
Xsed='${SED} -e 1s/^X//'
5303
sed_quote_subst='$sed_quote_subst'
5305
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5306
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5309
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5310
# is contrary to our usage. Disable this feature.
5311
alias -g '\${1+\"\$@\"}'='\"\$@\"'
5312
setopt NO_GLOB_SUBST
5314
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5316
BIN_SH=xpg4; export BIN_SH # for Tru64
5317
DUALCASE=1; export DUALCASE # for MKS sh
5319
# The HP-UX ksh and POSIX shell print the target directory to stdout
5321
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5323
relink_command=\"$relink_command\"
5325
# This environment variable determines our operation mode.
5326
if test \"\$libtool_install_magic\" = \"$magic\"; then
5327
# install mode needs the following variable:
5328
notinst_deplibs='$notinst_deplibs'
5330
# When we are sourced in execute mode, \$file and \$echo are already set.
5331
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5334
# Make sure echo works.
5335
if test \"X\$1\" = X--no-reexec; then
5336
# Discard the --no-reexec flag, and continue.
5338
elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5339
# Yippee, \$echo works!
5342
# Restart under the correct shell, and then maybe \$echo will work.
5343
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5349
# Find the directory that this script lives in.
5350
thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5351
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5353
# Follow symbolic links until we get to the real thisdir.
5354
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5355
while test -n \"\$file\"; do
5356
destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5358
# If there was a directory component, then change thisdir.
5359
if test \"x\$destdir\" != \"x\$file\"; then
5360
case \"\$destdir\" in
5361
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5362
*) thisdir=\"\$thisdir/\$destdir\" ;;
5366
file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5367
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5370
# Try to get the absolute directory name.
5371
absdir=\`cd \"\$thisdir\" && pwd\`
5372
test -n \"\$absdir\" && thisdir=\"\$absdir\"
5375
if test "$fast_install" = yes; then
5377
program=lt-'$outputname'$exeext
5378
progdir=\"\$thisdir/$objdir\"
5380
if test ! -f \"\$progdir/\$program\" || \\
5381
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5382
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5384
file=\"\$\$-\$program\"
5386
if test ! -d \"\$progdir\"; then
5387
$mkdir \"\$progdir\"
5389
$rm \"\$progdir/\$file\"
5394
# relink executable if necessary
5395
if test -n \"\$relink_command\"; then
5396
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5398
$echo \"\$relink_command_output\" >&2
5399
$rm \"\$progdir/\$file\"
5404
$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5405
{ $rm \"\$progdir/\$program\";
5406
$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5407
$rm \"\$progdir/\$file\"
5411
program='$outputname'
5412
progdir=\"\$thisdir/$objdir\"
5418
if test -f \"\$progdir/\$program\"; then"
5420
# Export our shlibpath_var if we have one.
5421
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5423
# Add our own library path to $shlibpath_var
5424
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5426
# Some systems cannot cope with colon-terminated $shlibpath_var
5427
# The second colon is a workaround for a bug in BeOS R4 sed
5428
$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5430
export $shlibpath_var
5434
# fixup the dll searchpath if we need to.
5435
if test -n "$dllsearchpath"; then
5437
# Add the dll search path components to the executable PATH
5438
PATH=$dllsearchpath:\$PATH
5443
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5444
# Run the actual program with our arguments.
5447
# Backslashes separate directories on plain windows
5448
*-*-mingw | *-*-os2*)
5450
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5456
exec \"\$progdir/\$program\" \${1+\"\$@\"}
5461
\$echo \"\$0: cannot exec \$program \$*\"
5465
# The program doesn't exist.
5466
\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5467
\$echo \"This script is just a wrapper for \$program.\" 1>&2
5468
$echo \"See the $PACKAGE documentation for more information.\" 1>&2
5475
7869
exit $EXIT_SUCCESS
5760
8168
# Directory that this library needs to be installed in:
5761
8169
libdir='$install_libdir'"
5762
8170
if test "$installed" = no && test "$need_relink" = yes; then
5764
8172
relink_command=\"$relink_command\""
5769
8177
# Do a symbolic link so that the libtool archive can be found in
5770
8178
# LD_LIBRARY_PATH before the program is installed.
5771
$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5772
$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5778
# libtool install mode
5780
modename="$modename: install"
5782
# There may be an optional sh(1) argument at the beginning of
5783
# install_prog (especially on Windows NT).
5784
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5785
# Allow the use of GNU shtool's install command.
5786
$echo "X$nonopt" | grep shtool > /dev/null; then
5787
# Aesthetically quote it.
5788
arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5790
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5794
install_prog="$arg "
5802
# The real first argument should be the name of the installation program.
5803
# Aesthetically quote it.
5804
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5806
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5810
install_prog="$install_prog$arg"
5812
# We need to accept at least all the BSD install flags.
5822
if test -n "$dest"; then
5823
files="$files $dest"
5831
case " $install_prog " in
5836
-g | -m | -o) prev=$arg ;;
5844
# If the previous option needed an argument, then skip it.
5845
if test -n "$prev"; then
5854
# Aesthetically quote the argument.
5855
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5857
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5861
install_prog="$install_prog $arg"
5864
if test -z "$install_prog"; then
5865
$echo "$modename: you must specify an install program" 1>&2
5870
if test -n "$prev"; then
5871
$echo "$modename: the \`$prev' option requires an argument" 1>&2
5876
if test -z "$files"; then
5877
if test -z "$dest"; then
5878
$echo "$modename: no file or destination specified" 1>&2
5880
$echo "$modename: you must specify a destination" 1>&2
5886
# Strip any trailing slash from the destination.
5887
dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5889
# Check to see that the destination is a directory.
5890
test -d "$dest" && isdir=yes
5891
if test "$isdir" = yes; then
5895
destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5896
test "X$destdir" = "X$dest" && destdir=.
5897
destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5899
# Not a directory, so check to see that there is only one file specified.
5901
if test "$#" -gt 2; then
5902
$echo "$modename: \`$dest' is not a directory" 1>&2
5908
[\\/]* | [A-Za-z]:[\\/]*) ;;
5910
for file in $files; do
5914
$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5923
# This variable tells wrapper scripts just to set variables rather
5924
# than running their programs.
5925
libtool_install_magic="$magic"
5930
for file in $files; do
5932
# Do each installation.
5935
# Do the static libraries later.
5936
staticlibs="$staticlibs $file"
5940
# Check to see that this really is a libtool archive.
5941
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5943
$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5951
# If there is no directory component, then add one.
5953
*/* | *\\*) . $file ;;
5957
# Add the libdir to current_libdirs if it is the destination.
5958
if test "X$destdir" = "X$libdir"; then
5959
case "$current_libdirs " in
5961
*) current_libdirs="$current_libdirs $libdir" ;;
5964
# Note the libdir as a future libdir.
5965
case "$future_libdirs " in
5967
*) future_libdirs="$future_libdirs $libdir" ;;
5971
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5972
test "X$dir" = "X$file/" && dir=
5975
if test -n "$relink_command"; then
5976
# Determine the prefix the user has applied to our future dir.
5977
inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5979
# Don't allow the user to place us outside of our expected
5980
# location b/c this prevents finding dependent libraries that
5981
# are installed to the same prefix.
5982
# At present, this check doesn't affect windows .dll's that
5983
# are installed into $libdir/../bin (currently, that works fine)
5984
# but it's something to keep an eye on.
5985
if test "$inst_prefix_dir" = "$destdir"; then
5986
$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5990
if test -n "$inst_prefix_dir"; then
5991
# Stick the inst_prefix_dir data into the link command.
5992
relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`
5994
relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`
5997
$echo "$modename: warning: relinking \`$file'" 1>&2
5998
$show "$relink_command"
5999
if $run eval "$relink_command"; then :
6001
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6006
# See the names of the shared library.
6007
set dummy $library_names
6008
if test -n "$2"; then
6014
test -n "$relink_command" && srcname="$realname"T
6016
# Install the shared library and build the symlinks.
6017
$show "$install_prog $dir/$srcname $destdir/$realname"
6018
$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
6019
if test -n "$stripme" && test -n "$striplib"; then
6020
$show "$striplib $destdir/$realname"
6021
$run eval "$striplib $destdir/$realname" || exit $?
6024
if test "$#" -gt 0; then
6025
# Delete the old symlinks, and create new ones.
6026
# Try `ln -sf' first, because the `ln' binary might depend on
6027
# the symlink we replace! Solaris /bin/ln does not understand -f,
6028
# so we also need to try rm && ln -s.
6031
if test "$linkname" != "$realname"; then
6032
$show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6033
$run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6038
# Do each command in the postinstall commands.
6039
lib="$destdir/$realname"
6040
cmds=$postinstall_cmds
6041
save_ifs="$IFS"; IFS='~'
6042
for cmd in $cmds; do
6046
$run eval "$cmd" || {
6049
# Restore the uninstalled library and exit
6050
if test "$mode" = relink; then
6051
$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
6060
# Install the pseudo-library for information purposes.
6061
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6062
instname="$dir/$name"i
6063
$show "$install_prog $instname $destdir/$name"
6064
$run eval "$install_prog $instname $destdir/$name" || exit $?
6066
# Maybe install the static library, too.
6067
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6071
# Install (i.e. copy) a libtool object.
6073
# Figure out destination file name, if it wasn't already specified.
6074
if test -n "$destname"; then
6075
destfile="$destdir/$destname"
6077
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6078
destfile="$destdir/$destfile"
6081
# Deduce the name of the destination old-style object file.
6084
staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6087
staticdest="$destfile"
6091
$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6097
# Install the libtool object if requested.
6098
if test -n "$destfile"; then
6099
$show "$install_prog $file $destfile"
6100
$run eval "$install_prog $file $destfile" || exit $?
6103
# Install the old object if enabled.
6104
if test "$build_old_libs" = yes; then
6105
# Deduce the name of the old-style object file.
6106
staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6108
$show "$install_prog $staticobj $staticdest"
6109
$run eval "$install_prog \$staticobj \$staticdest" || exit $?
6115
# Figure out destination file name, if it wasn't already specified.
6116
if test -n "$destname"; then
6117
destfile="$destdir/$destname"
6119
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6120
destfile="$destdir/$destfile"
6123
# If the file is missing, and there is a .exe on the end, strip it
6124
# because it is most likely a libtool script we actually want to
6129
if test ! -f "$file"; then
6130
file=`$echo $file|${SED} 's,.exe$,,'`
6136
# Do a test to see if this is really a libtool program.
6139
wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6145
if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6149
# Note that it is not necessary on cygwin/mingw to append a dot to
6150
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6151
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6152
# `FILE.' does not work on cygwin managed mounts.
6154
# If there is no directory component, then add one.
6156
*/* | *\\*) . ${wrapper} ;;
6157
*) . ./${wrapper} ;;
6160
# Check the variables that should have been set.
6161
if test -z "$notinst_deplibs"; then
6162
$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6167
for lib in $notinst_deplibs; do
6168
# Check to see that each library is installed.
6170
if test -f "$lib"; then
6171
# If there is no directory component, then add one.
6173
*/* | *\\*) . $lib ;;
6177
libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6178
if test -n "$libdir" && test ! -f "$libfile"; then
6179
$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6185
# Note that it is not necessary on cygwin/mingw to append a dot to
6186
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6187
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6188
# `FILE.' does not work on cygwin managed mounts.
6190
# If there is no directory component, then add one.
6192
*/* | *\\*) . ${wrapper} ;;
6193
*) . ./${wrapper} ;;
6197
if test "$fast_install" = no && test -n "$relink_command"; then
6198
if test "$finalize" = yes && test -z "$run"; then
6199
tmpdir=`func_mktempdir`
6200
file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6201
outputname="$tmpdir/$file"
6202
# Replace the output file specification.
6203
relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`
6205
$show "$relink_command"
6206
if $run eval "$relink_command"; then :
6208
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6214
$echo "$modename: warning: cannot relink \`$file'" 1>&2
6217
# Install the binary that we compiled earlier.
6218
file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6222
# remove .exe since cygwin /usr/bin/install will append another
6224
case $install_prog,$host in
6225
*/usr/bin/install*,*cygwin*)
6226
case $file:$destfile in
6231
destfile=$destfile.exe
6234
destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6239
$show "$install_prog$stripme $file $destfile"
6240
$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6241
test -n "$outputname" && ${rm}r "$tmpdir"
6246
for file in $staticlibs; do
6247
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6249
# Set up the ranlib parameters.
6250
oldlib="$destdir/$name"
6252
$show "$install_prog $file $oldlib"
6253
$run eval "$install_prog \$file \$oldlib" || exit $?
6255
if test -n "$stripme" && test -n "$old_striplib"; then
6256
$show "$old_striplib $oldlib"
6257
$run eval "$old_striplib $oldlib" || exit $?
6260
# Do each command in the postinstall commands.
6261
cmds=$old_postinstall_cmds
6262
save_ifs="$IFS"; IFS='~'
6263
for cmd in $cmds; do
6267
$run eval "$cmd" || exit $?
6272
if test -n "$future_libdirs"; then
6273
$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6276
if test -n "$current_libdirs"; then
6277
# Maybe just do a dry run.
6278
test -n "$run" && current_libdirs=" -n$current_libdirs"
6279
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6285
# libtool finish mode
6287
modename="$modename: finish"
6291
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6294
libdirs="$libdirs $dir"
6297
for libdir in $libdirs; do
6298
if test -n "$finish_cmds"; then
6299
# Do each command in the finish commands.
6301
save_ifs="$IFS"; IFS='~'
6302
for cmd in $cmds; do
6306
$run eval "$cmd" || admincmds="$admincmds
6311
if test -n "$finish_eval"; then
6312
# Do the single finish_eval.
6313
eval cmds=\"$finish_eval\"
6314
$run eval "$cmds" || admincmds="$admincmds
6320
# Exit here if they wanted silent mode.
6321
test "$show" = : && exit $EXIT_SUCCESS
6323
$echo "X----------------------------------------------------------------------" | $Xsed
6324
$echo "Libraries have been installed in:"
6325
for libdir in $libdirs; do
6329
$echo "If you ever happen to want to link against installed libraries"
6330
$echo "in a given directory, LIBDIR, you must either use libtool, and"
6331
$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6332
$echo "flag during linking and do at least one of the following:"
6333
if test -n "$shlibpath_var"; then
6334
$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
6335
$echo " during execution"
6337
if test -n "$runpath_var"; then
6338
$echo " - add LIBDIR to the \`$runpath_var' environment variable"
6339
$echo " during linking"
6341
if test -n "$hardcode_libdir_flag_spec"; then
6343
eval flag=\"$hardcode_libdir_flag_spec\"
6345
$echo " - use the \`$flag' linker flag"
6347
if test -n "$admincmds"; then
6348
$echo " - have your system administrator run these commands:$admincmds"
6350
if test -f /etc/ld.so.conf; then
6351
$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6354
$echo "See any operating system documentation about shared libraries for"
6355
$echo "more information, such as the ld(1) and ld.so(8) manual pages."
6356
$echo "X----------------------------------------------------------------------" | $Xsed
6360
# libtool execute mode
6362
modename="$modename: execute"
6364
# The first argument is the command name.
6366
if test -z "$cmd"; then
6367
$echo "$modename: you must specify a COMMAND" 1>&2
6372
# Handle -dlopen flags immediately.
6373
for file in $execute_dlfiles; do
6374
if test ! -f "$file"; then
6375
$echo "$modename: \`$file' is not a file" 1>&2
6383
# Check to see that this really is a libtool archive.
6384
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6386
$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6391
# Read the libtool library.
6395
# If there is no directory component, then add one.
6397
*/* | *\\*) . $file ;;
6401
# Skip this library if it cannot be dlopened.
6402
if test -z "$dlname"; then
6403
# Warn if it was a shared library.
6404
test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6408
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6409
test "X$dir" = "X$file" && dir=.
6411
if test -f "$dir/$objdir/$dlname"; then
6414
if test ! -f "$dir/$dlname"; then
6415
$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6422
# Just add the directory containing the .lo file.
6423
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6424
test "X$dir" = "X$file" && dir=.
6428
$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6433
# Get the absolute pathname.
6434
absdir=`cd "$dir" && pwd`
6435
test -n "$absdir" && dir="$absdir"
6437
# Now add the directory to shlibpath_var.
6438
if eval "test -z \"\$$shlibpath_var\""; then
6439
eval "$shlibpath_var=\"\$dir\""
6441
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6445
# This variable tells wrapper scripts just to set shlibpath_var
6446
# rather than running their programs.
6447
libtool_execute_magic="$magic"
6449
# Check if any of the arguments is a wrapper script.
6456
# Do a test to see if this is really a libtool program.
6457
if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6458
# If there is no directory component, then add one.
6460
*/* | *\\*) . $file ;;
6464
# Transform arg to wrapped name.
6465
file="$progdir/$program"
6469
# Quote arguments (to preserve shell metacharacters).
6470
file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6471
args="$args \"$file\""
6474
if test -z "$run"; then
6475
if test -n "$shlibpath_var"; then
6476
# Export the shlibpath_var.
6477
eval "export $shlibpath_var"
6480
# Restore saved environment variables
6481
for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
6483
eval "if test \"\${save_$lt_var+set}\" = set; then
6484
$lt_var=\$save_$lt_var; export $lt_var
6488
# Now prepare to actually exec the command.
6489
exec_cmd="\$cmd$args"
6491
# Display what would be done.
6492
if test -n "$shlibpath_var"; then
6493
eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6494
$echo "export $shlibpath_var"
6501
# libtool clean and uninstall mode
6503
modename="$modename: $mode"
8179
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8185
{ test "$mode" = link || test "$mode" = relink; } &&
8186
func_mode_link ${1+"$@"}
8189
# func_mode_uninstall arg...
8190
func_mode_uninstall ()