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
4880
7777
# Replace the output file specification.
4881
link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7778
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4883
7780
# Delete the old output files.
4884
$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
7781
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
4886
$show "$link_command"
4887
$run eval "$link_command" || exit $?
7783
func_show_eval "$link_command" 'exit $?'
4889
7785
# Now create the wrapper script.
4890
$show "creating $output"
7786
func_verbose "creating $output"
4892
7788
# Quote the relink command for shipping.
4893
7789
if test -n "$relink_command"; then
4894
7790
# Preserve any variables that may affect compiler behavior
4895
7791
for var in $variables_saved_for_relink; do
4896
7792
if eval test -z \"\${$var+set}\"; then
4897
relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
7793
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
4898
7794
elif eval var_value=\$$var; test -z "$var_value"; then
4899
7795
relink_command="$var=; export $var; $relink_command"
4901
var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4902
relink_command="$var=\"$var_value\"; export $var; $relink_command"
7797
func_quote_for_eval "$var_value"
7798
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
4905
7801
relink_command="(cd `pwd`; $relink_command)"
4906
relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
7802
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4909
# Quote $echo for shipping.
4910
if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
7805
# Quote $ECHO for shipping.
7806
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
4911
7807
case $progpath in
4912
7808
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4913
7809
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4915
qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
7811
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
4917
qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
7813
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
4920
# Only actually do things if our run command is non-null.
4921
if test -z "$run"; then
7816
# Only actually do things if not in dry run mode.
4922
7818
# win32 will think the script is a binary if it has
4923
7819
# a .exe suffix, so we strip it off here.
4924
7820
case $output in
4925
*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
7821
*.exe) func_stripname '' '.exe' "$output"
7822
output=$func_stripname_result ;;
4927
7824
# test for cygwin because mv fails w/o .exe extensions
4931
outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
7828
func_stripname '' '.exe' "$outputname"
7829
outputname=$func_stripname_result ;;
4935
7833
*cygwin* | *mingw* )
4936
output_name=`basename $output`
4937
output_path=`dirname $output`
4938
cwrappersource="$output_path/$objdir/lt-$output_name.c"
4939
cwrapper="$output_path/$output_name.exe"
4940
$rm $cwrappersource $cwrapper
4941
trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4943
cat > $cwrappersource <<EOF
4945
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4946
Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4948
The $output program cannot be directly executed until all the libtool
4949
libraries that it depends on are installed.
4951
This wrapper executable should never be moved out of the build directory.
4952
If it is, it will not operate correctly.
4954
Currently, it simply execs the wrapper *script* "/bin/sh $output",
4955
but could eventually absorb all of the scripts functionality and
4956
exec $objdir/$outputname directly.
4959
cat >> $cwrappersource<<"EOF"
4968
#include <sys/stat.h>
4970
#if defined(PATH_MAX)
4971
# define LT_PATHMAX PATH_MAX
4972
#elif defined(MAXPATHLEN)
4973
# define LT_PATHMAX MAXPATHLEN
4975
# define LT_PATHMAX 1024
4978
#ifndef DIR_SEPARATOR
4979
# define DIR_SEPARATOR '/'
4980
# define PATH_SEPARATOR ':'
4983
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4985
# define HAVE_DOS_BASED_FILE_SYSTEM
4986
# ifndef DIR_SEPARATOR_2
4987
# define DIR_SEPARATOR_2 '\\'
4989
# ifndef PATH_SEPARATOR_2
4990
# define PATH_SEPARATOR_2 ';'
4994
#ifndef DIR_SEPARATOR_2
4995
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4996
#else /* DIR_SEPARATOR_2 */
4997
# define IS_DIR_SEPARATOR(ch) \
4998
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4999
#endif /* DIR_SEPARATOR_2 */
5001
#ifndef PATH_SEPARATOR_2
5002
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5003
#else /* PATH_SEPARATOR_2 */
5004
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5005
#endif /* PATH_SEPARATOR_2 */
5007
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5008
#define XFREE(stale) do { \
5009
if (stale) { free ((void *) stale); stale = 0; } \
5012
/* -DDEBUG is fairly common in CFLAGS. */
5014
#if defined DEBUGWRAPPER
5015
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5017
# define DEBUG(format, ...)
5020
const char *program_name = NULL;
5022
void * xmalloc (size_t num);
5023
char * xstrdup (const char *string);
5024
const char * base_name (const char *name);
5025
char * find_executable(const char *wrapper);
5026
int check_executable(const char *path);
5027
char * strendzap(char *str, const char *pat);
5028
void lt_fatal (const char *message, ...);
5031
main (int argc, char *argv[])
5036
program_name = (char *) xstrdup (base_name (argv[0]));
5037
DEBUG("(main) argv[0] : %s\n",argv[0]);
5038
DEBUG("(main) program_name : %s\n",program_name);
5039
newargz = XMALLOC(char *, argc+2);
5042
cat >> $cwrappersource <<EOF
5043
newargz[0] = (char *) xstrdup("$SHELL");
5046
cat >> $cwrappersource <<"EOF"
5047
newargz[1] = find_executable(argv[0]);
5048
if (newargz[1] == NULL)
5049
lt_fatal("Couldn't find %s", argv[0]);
5050
DEBUG("(main) found exe at : %s\n",newargz[1]);
5051
/* we know the script has the same name, without the .exe */
5052
/* so make sure newargz[1] doesn't end in .exe */
5053
strendzap(newargz[1],".exe");
5054
for (i = 1; i < argc; i++)
5055
newargz[i+1] = xstrdup(argv[i]);
5056
newargz[argc+1] = NULL;
5058
for (i=0; i<argc+1; i++)
5060
DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
5068
cat >> $cwrappersource <<EOF
5069
execv("$SHELL",(char const **)newargz);
5073
cat >> $cwrappersource <<EOF
5074
execv("$SHELL",newargz);
5079
cat >> $cwrappersource <<"EOF"
5084
xmalloc (size_t num)
5086
void * p = (void *) malloc (num);
5088
lt_fatal ("Memory exhausted");
5094
xstrdup (const char *string)
5096
return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5101
base_name (const char *name)
5105
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5106
/* Skip over the disk name in MSDOS pathnames. */
5107
if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5111
for (base = name; *name; name++)
5112
if (IS_DIR_SEPARATOR (*name))
5118
check_executable(const char * path)
5122
DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5123
if ((!path) || (!*path))
5126
if ((stat (path, &st) >= 0) &&
5128
/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5129
#if defined (S_IXOTH)
5130
((st.st_mode & S_IXOTH) == S_IXOTH) ||
5132
#if defined (S_IXGRP)
5133
((st.st_mode & S_IXGRP) == S_IXGRP) ||
5135
((st.st_mode & S_IXUSR) == S_IXUSR))
5142
/* Searches for the full path of the wrapper. Returns
5143
newly allocated full path name if found, NULL otherwise */
5145
find_executable (const char* wrapper)
5150
/* static buffer for getcwd */
5151
char tmp[LT_PATHMAX + 1];
5155
DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5157
if ((wrapper == NULL) || (*wrapper == '\0'))
5160
/* Absolute path? */
5161
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5162
if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5164
concat_name = xstrdup (wrapper);
5165
if (check_executable(concat_name))
5172
if (IS_DIR_SEPARATOR (wrapper[0]))
5174
concat_name = xstrdup (wrapper);
5175
if (check_executable(concat_name))
5179
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5183
for (p = wrapper; *p; p++)
5191
/* no slashes; search PATH */
5192
const char* path = getenv ("PATH");
5195
for (p = path; *p; p = p_next)
5199
for (q = p; *q; q++)
5200
if (IS_PATH_SEPARATOR(*q))
5203
p_next = (*q == '\0' ? q : q + 1);
5206
/* empty path: current directory */
5207
if (getcwd (tmp, LT_PATHMAX) == NULL)
5208
lt_fatal ("getcwd failed");
5209
tmp_len = strlen(tmp);
5210
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5211
memcpy (concat_name, tmp, tmp_len);
5212
concat_name[tmp_len] = '/';
5213
strcpy (concat_name + tmp_len + 1, wrapper);
5217
concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5218
memcpy (concat_name, p, p_len);
5219
concat_name[p_len] = '/';
5220
strcpy (concat_name + p_len + 1, wrapper);
5222
if (check_executable(concat_name))
7834
func_dirname_and_basename "$output" "" "."
7835
output_name=$func_basename_result
7836
output_path=$func_dirname_result
7837
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7838
cwrapper="$output_path/$output_name.exe"
7839
$RM $cwrappersource $cwrapper
7840
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7842
func_emit_cwrapperexe_src > $cwrappersource
7844
# The wrapper executable is built using the $host compiler,
7845
# because it contains $host paths and files. If cross-
7846
# compiling, it, like the target executable, must be
7847
# executed on the $host or under an emulation environment.
7849
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7853
# Now, create the wrapper script for func_source use:
7854
func_ltwrapper_scriptname $cwrapper
7855
$RM $func_ltwrapper_scriptname_result
7856
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7858
# note: this script will not be executed, so do not chmod.
7859
if test "x$build" = "x$host" ; then
7860
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7862
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7868
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7870
func_emit_wrapper no > $output
5227
/* not found in PATH; assume curdir */
5229
/* Relative path | not found in path: prepend cwd */
5230
if (getcwd (tmp, LT_PATHMAX) == NULL)
5231
lt_fatal ("getcwd failed");
5232
tmp_len = strlen(tmp);
5233
concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5234
memcpy (concat_name, tmp, tmp_len);
5235
concat_name[tmp_len] = '/';
5236
strcpy (concat_name + tmp_len + 1, wrapper);
5238
if (check_executable(concat_name))
5245
strendzap(char *str, const char *pat)
5249
assert(str != NULL);
5250
assert(pat != NULL);
5253
patlen = strlen(pat);
5257
str += len - patlen;
5258
if (strcmp(str, pat) == 0)
5265
lt_error_core (int exit_status, const char * mode,
5266
const char * message, va_list ap)
5268
fprintf (stderr, "%s: %s: ", program_name, mode);
5269
vfprintf (stderr, message, ap);
5270
fprintf (stderr, ".\n");
5272
if (exit_status >= 0)
5277
lt_fatal (const char *message, ...)
5280
va_start (ap, message);
5281
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5285
# we should really use a build-platform specific compiler
5286
# here, but OTOH, the wrappers (shell script and this C one)
5287
# are only useful if you want to execute the "real" binary.
5288
# Since the "real" binary is built for $host, then this
5289
# wrapper might as well be built for $host, too.
5290
$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5294
trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5299
# $output - temporary wrapper script for $objdir/$outputname
5300
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5302
# The $output program cannot be directly executed until all the libtool
5303
# libraries that it depends on are installed.
5305
# This wrapper script should never be moved out of the build directory.
5306
# If it is, it will not operate correctly.
5308
# Sed substitution that helps us do robust quoting. It backslashifies
5309
# metacharacters that are still active within double-quoted strings.
5310
Xsed='${SED} -e 1s/^X//'
5311
sed_quote_subst='$sed_quote_subst'
5313
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5314
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5317
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5318
# is contrary to our usage. Disable this feature.
5319
alias -g '\${1+\"\$@\"}'='\"\$@\"'
5320
setopt NO_GLOB_SUBST
5322
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5324
BIN_SH=xpg4; export BIN_SH # for Tru64
5325
DUALCASE=1; export DUALCASE # for MKS sh
5327
# The HP-UX ksh and POSIX shell print the target directory to stdout
5329
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5331
relink_command=\"$relink_command\"
5333
# This environment variable determines our operation mode.
5334
if test \"\$libtool_install_magic\" = \"$magic\"; then
5335
# install mode needs the following variable:
5336
notinst_deplibs='$notinst_deplibs'
5338
# When we are sourced in execute mode, \$file and \$echo are already set.
5339
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5342
# Make sure echo works.
5343
if test \"X\$1\" = X--no-reexec; then
5344
# Discard the --no-reexec flag, and continue.
5346
elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5347
# Yippee, \$echo works!
5350
# Restart under the correct shell, and then maybe \$echo will work.
5351
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5357
# Find the directory that this script lives in.
5358
thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5359
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5361
# Follow symbolic links until we get to the real thisdir.
5362
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5363
while test -n \"\$file\"; do
5364
destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5366
# If there was a directory component, then change thisdir.
5367
if test \"x\$destdir\" != \"x\$file\"; then
5368
case \"\$destdir\" in
5369
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5370
*) thisdir=\"\$thisdir/\$destdir\" ;;
5374
file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5375
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5378
# Try to get the absolute directory name.
5379
absdir=\`cd \"\$thisdir\" && pwd\`
5380
test -n \"\$absdir\" && thisdir=\"\$absdir\"
5383
if test "$fast_install" = yes; then
5385
program=lt-'$outputname'$exeext
5386
progdir=\"\$thisdir/$objdir\"
5388
if test ! -f \"\$progdir/\$program\" || \\
5389
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5390
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5392
file=\"\$\$-\$program\"
5394
if test ! -d \"\$progdir\"; then
5395
$mkdir \"\$progdir\"
5397
$rm \"\$progdir/\$file\"
5402
# relink executable if necessary
5403
if test -n \"\$relink_command\"; then
5404
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5406
$echo \"\$relink_command_output\" >&2
5407
$rm \"\$progdir/\$file\"
5412
$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5413
{ $rm \"\$progdir/\$program\";
5414
$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5415
$rm \"\$progdir/\$file\"
5419
program='$outputname'
5420
progdir=\"\$thisdir/$objdir\"
5426
if test -f \"\$progdir/\$program\"; then"
5428
# Export our shlibpath_var if we have one.
5429
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5431
# Add our own library path to $shlibpath_var
5432
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5434
# Some systems cannot cope with colon-terminated $shlibpath_var
5435
# The second colon is a workaround for a bug in BeOS R4 sed
5436
$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5438
export $shlibpath_var
5442
# fixup the dll searchpath if we need to.
5443
if test -n "$dllsearchpath"; then
5445
# Add the dll search path components to the executable PATH
5446
PATH=$dllsearchpath:\$PATH
5451
if test \"\$libtool_execute_magic\" != \"$magic\"; then
5452
# Run the actual program with our arguments.
5455
# Backslashes separate directories on plain windows
5456
*-*-mingw | *-*-os2*)
5458
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5464
exec \"\$progdir/\$program\" \${1+\"\$@\"}
5469
\$echo \"\$0: cannot exec \$program \$*\"
5473
# The program doesn't exist.
5474
\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5475
\$echo \"This script is just a wrapper for \$program.\" 1>&2
5476
$echo \"See the $PACKAGE documentation for more information.\" 1>&2
5483
7875
exit $EXIT_SUCCESS
5768
8174
# Directory that this library needs to be installed in:
5769
8175
libdir='$install_libdir'"
5770
8176
if test "$installed" = no && test "$need_relink" = yes; then
5772
8178
relink_command=\"$relink_command\""
5777
8183
# Do a symbolic link so that the libtool archive can be found in
5778
8184
# LD_LIBRARY_PATH before the program is installed.
5779
$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5780
$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5786
# libtool install mode
5788
modename="$modename: install"
5790
# There may be an optional sh(1) argument at the beginning of
5791
# install_prog (especially on Windows NT).
5792
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5793
# Allow the use of GNU shtool's install command.
5794
$echo "X$nonopt" | grep shtool > /dev/null; then
5795
# Aesthetically quote it.
5796
arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5798
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5802
install_prog="$arg "
5810
# The real first argument should be the name of the installation program.
5811
# Aesthetically quote it.
5812
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5814
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5818
install_prog="$install_prog$arg"
5820
# We need to accept at least all the BSD install flags.
5830
if test -n "$dest"; then
5831
files="$files $dest"
5839
case " $install_prog " in
5844
-g | -m | -o) prev=$arg ;;
5852
# If the previous option needed an argument, then skip it.
5853
if test -n "$prev"; then
5862
# Aesthetically quote the argument.
5863
arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5865
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5869
install_prog="$install_prog $arg"
5872
if test -z "$install_prog"; then
5873
$echo "$modename: you must specify an install program" 1>&2
5878
if test -n "$prev"; then
5879
$echo "$modename: the \`$prev' option requires an argument" 1>&2
5884
if test -z "$files"; then
5885
if test -z "$dest"; then
5886
$echo "$modename: no file or destination specified" 1>&2
5888
$echo "$modename: you must specify a destination" 1>&2
5894
# Strip any trailing slash from the destination.
5895
dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5897
# Check to see that the destination is a directory.
5898
test -d "$dest" && isdir=yes
5899
if test "$isdir" = yes; then
5903
destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5904
test "X$destdir" = "X$dest" && destdir=.
5905
destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5907
# Not a directory, so check to see that there is only one file specified.
5909
if test "$#" -gt 2; then
5910
$echo "$modename: \`$dest' is not a directory" 1>&2
5916
[\\/]* | [A-Za-z]:[\\/]*) ;;
5918
for file in $files; do
5922
$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5931
# This variable tells wrapper scripts just to set variables rather
5932
# than running their programs.
5933
libtool_install_magic="$magic"
5938
for file in $files; do
5940
# Do each installation.
5943
# Do the static libraries later.
5944
staticlibs="$staticlibs $file"
5948
# Check to see that this really is a libtool archive.
5949
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5951
$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5959
# If there is no directory component, then add one.
5961
*/* | *\\*) . $file ;;
5965
# Add the libdir to current_libdirs if it is the destination.
5966
if test "X$destdir" = "X$libdir"; then
5967
case "$current_libdirs " in
5969
*) current_libdirs="$current_libdirs $libdir" ;;
5972
# Note the libdir as a future libdir.
5973
case "$future_libdirs " in
5975
*) future_libdirs="$future_libdirs $libdir" ;;
5979
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5980
test "X$dir" = "X$file/" && dir=
5983
if test -n "$relink_command"; then
5984
# Determine the prefix the user has applied to our future dir.
5985
inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5987
# Don't allow the user to place us outside of our expected
5988
# location b/c this prevents finding dependent libraries that
5989
# are installed to the same prefix.
5990
# At present, this check doesn't affect windows .dll's that
5991
# are installed into $libdir/../bin (currently, that works fine)
5992
# but it's something to keep an eye on.
5993
if test "$inst_prefix_dir" = "$destdir"; then
5994
$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5998
if test -n "$inst_prefix_dir"; then
5999
# Stick the inst_prefix_dir data into the link command.
6000
relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`
6002
relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`
6005
$echo "$modename: warning: relinking \`$file'" 1>&2
6006
$show "$relink_command"
6007
if $run eval "$relink_command"; then :
6009
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6014
# See the names of the shared library.
6015
set dummy $library_names
6016
if test -n "$2"; then
6022
test -n "$relink_command" && srcname="$realname"T
6024
# Install the shared library and build the symlinks.
6025
$show "$install_prog $dir/$srcname $destdir/$realname"
6026
$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
6027
if test -n "$stripme" && test -n "$striplib"; then
6028
$show "$striplib $destdir/$realname"
6029
$run eval "$striplib $destdir/$realname" || exit $?
6032
if test "$#" -gt 0; then
6033
# Delete the old symlinks, and create new ones.
6034
# Try `ln -sf' first, because the `ln' binary might depend on
6035
# the symlink we replace! Solaris /bin/ln does not understand -f,
6036
# so we also need to try rm && ln -s.
6039
if test "$linkname" != "$realname"; then
6040
$show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6041
$run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6046
# Do each command in the postinstall commands.
6047
lib="$destdir/$realname"
6048
cmds=$postinstall_cmds
6049
save_ifs="$IFS"; IFS='~'
6050
for cmd in $cmds; do
6054
$run eval "$cmd" || {
6057
# Restore the uninstalled library and exit
6058
if test "$mode" = relink; then
6059
$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
6068
# Install the pseudo-library for information purposes.
6069
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6070
instname="$dir/$name"i
6071
$show "$install_prog $instname $destdir/$name"
6072
$run eval "$install_prog $instname $destdir/$name" || exit $?
6074
# Maybe install the static library, too.
6075
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6079
# Install (i.e. copy) a libtool object.
6081
# Figure out destination file name, if it wasn't already specified.
6082
if test -n "$destname"; then
6083
destfile="$destdir/$destname"
6085
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6086
destfile="$destdir/$destfile"
6089
# Deduce the name of the destination old-style object file.
6092
staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6095
staticdest="$destfile"
6099
$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6105
# Install the libtool object if requested.
6106
if test -n "$destfile"; then
6107
$show "$install_prog $file $destfile"
6108
$run eval "$install_prog $file $destfile" || exit $?
6111
# Install the old object if enabled.
6112
if test "$build_old_libs" = yes; then
6113
# Deduce the name of the old-style object file.
6114
staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6116
$show "$install_prog $staticobj $staticdest"
6117
$run eval "$install_prog \$staticobj \$staticdest" || exit $?
6123
# Figure out destination file name, if it wasn't already specified.
6124
if test -n "$destname"; then
6125
destfile="$destdir/$destname"
6127
destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6128
destfile="$destdir/$destfile"
6131
# If the file is missing, and there is a .exe on the end, strip it
6132
# because it is most likely a libtool script we actually want to
6137
if test ! -f "$file"; then
6138
file=`$echo $file|${SED} 's,.exe$,,'`
6144
# Do a test to see if this is really a libtool program.
6147
wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6153
if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6157
# Note that it is not necessary on cygwin/mingw to append a dot to
6158
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6159
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6160
# `FILE.' does not work on cygwin managed mounts.
6162
# If there is no directory component, then add one.
6164
*/* | *\\*) . ${wrapper} ;;
6165
*) . ./${wrapper} ;;
6168
# Check the variables that should have been set.
6169
if test -z "$notinst_deplibs"; then
6170
$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6175
for lib in $notinst_deplibs; do
6176
# Check to see that each library is installed.
6178
if test -f "$lib"; then
6179
# If there is no directory component, then add one.
6181
*/* | *\\*) . $lib ;;
6185
libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6186
if test -n "$libdir" && test ! -f "$libfile"; then
6187
$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6193
# Note that it is not necessary on cygwin/mingw to append a dot to
6194
# foo even if both foo and FILE.exe exist: automatic-append-.exe
6195
# behavior happens only for exec(3), not for open(2)! Also, sourcing
6196
# `FILE.' does not work on cygwin managed mounts.
6198
# If there is no directory component, then add one.
6200
*/* | *\\*) . ${wrapper} ;;
6201
*) . ./${wrapper} ;;
6205
if test "$fast_install" = no && test -n "$relink_command"; then
6206
if test "$finalize" = yes && test -z "$run"; then
6207
tmpdir=`func_mktempdir`
6208
file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6209
outputname="$tmpdir/$file"
6210
# Replace the output file specification.
6211
relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`
6213
$show "$relink_command"
6214
if $run eval "$relink_command"; then :
6216
$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6222
$echo "$modename: warning: cannot relink \`$file'" 1>&2
6225
# Install the binary that we compiled earlier.
6226
file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6230
# remove .exe since cygwin /usr/bin/install will append another
6232
case $install_prog,$host in
6233
*/usr/bin/install*,*cygwin*)
6234
case $file:$destfile in
6239
destfile=$destfile.exe
6242
destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6247
$show "$install_prog$stripme $file $destfile"
6248
$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6249
test -n "$outputname" && ${rm}r "$tmpdir"
6254
for file in $staticlibs; do
6255
name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6257
# Set up the ranlib parameters.
6258
oldlib="$destdir/$name"
6260
$show "$install_prog $file $oldlib"
6261
$run eval "$install_prog \$file \$oldlib" || exit $?
6263
if test -n "$stripme" && test -n "$old_striplib"; then
6264
$show "$old_striplib $oldlib"
6265
$run eval "$old_striplib $oldlib" || exit $?
6268
# Do each command in the postinstall commands.
6269
cmds=$old_postinstall_cmds
6270
save_ifs="$IFS"; IFS='~'
6271
for cmd in $cmds; do
6275
$run eval "$cmd" || exit $?
6280
if test -n "$future_libdirs"; then
6281
$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6284
if test -n "$current_libdirs"; then
6285
# Maybe just do a dry run.
6286
test -n "$run" && current_libdirs=" -n$current_libdirs"
6287
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6293
# libtool finish mode
6295
modename="$modename: finish"
6299
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6302
libdirs="$libdirs $dir"
6305
for libdir in $libdirs; do
6306
if test -n "$finish_cmds"; then
6307
# Do each command in the finish commands.
6309
save_ifs="$IFS"; IFS='~'
6310
for cmd in $cmds; do
6314
$run eval "$cmd" || admincmds="$admincmds
6319
if test -n "$finish_eval"; then
6320
# Do the single finish_eval.
6321
eval cmds=\"$finish_eval\"
6322
$run eval "$cmds" || admincmds="$admincmds
6328
# Exit here if they wanted silent mode.
6329
test "$show" = : && exit $EXIT_SUCCESS
6331
$echo "X----------------------------------------------------------------------" | $Xsed
6332
$echo "Libraries have been installed in:"
6333
for libdir in $libdirs; do
6337
$echo "If you ever happen to want to link against installed libraries"
6338
$echo "in a given directory, LIBDIR, you must either use libtool, and"
6339
$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6340
$echo "flag during linking and do at least one of the following:"
6341
if test -n "$shlibpath_var"; then
6342
$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
6343
$echo " during execution"
6345
if test -n "$runpath_var"; then
6346
$echo " - add LIBDIR to the \`$runpath_var' environment variable"
6347
$echo " during linking"
6349
if test -n "$hardcode_libdir_flag_spec"; then
6351
eval flag=\"$hardcode_libdir_flag_spec\"
6353
$echo " - use the \`$flag' linker flag"
6355
if test -n "$admincmds"; then
6356
$echo " - have your system administrator run these commands:$admincmds"
6358
if test -f /etc/ld.so.conf; then
6359
$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6362
$echo "See any operating system documentation about shared libraries for"
6363
$echo "more information, such as the ld(1) and ld.so(8) manual pages."
6364
$echo "X----------------------------------------------------------------------" | $Xsed
6368
# libtool execute mode
6370
modename="$modename: execute"
6372
# The first argument is the command name.
6374
if test -z "$cmd"; then
6375
$echo "$modename: you must specify a COMMAND" 1>&2
6380
# Handle -dlopen flags immediately.
6381
for file in $execute_dlfiles; do
6382
if test ! -f "$file"; then
6383
$echo "$modename: \`$file' is not a file" 1>&2
6391
# Check to see that this really is a libtool archive.
6392
if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6394
$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6399
# Read the libtool library.
6403
# If there is no directory component, then add one.
6405
*/* | *\\*) . $file ;;
6409
# Skip this library if it cannot be dlopened.
6410
if test -z "$dlname"; then
6411
# Warn if it was a shared library.
6412
test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6416
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6417
test "X$dir" = "X$file" && dir=.
6419
if test -f "$dir/$objdir/$dlname"; then
6422
if test ! -f "$dir/$dlname"; then
6423
$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6430
# Just add the directory containing the .lo file.
6431
dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6432
test "X$dir" = "X$file" && dir=.
6436
$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6441
# Get the absolute pathname.
6442
absdir=`cd "$dir" && pwd`
6443
test -n "$absdir" && dir="$absdir"
6445
# Now add the directory to shlibpath_var.
6446
if eval "test -z \"\$$shlibpath_var\""; then
6447
eval "$shlibpath_var=\"\$dir\""
6449
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6453
# This variable tells wrapper scripts just to set shlibpath_var
6454
# rather than running their programs.
6455
libtool_execute_magic="$magic"
6457
# Check if any of the arguments is a wrapper script.
6464
# Do a test to see if this is really a libtool program.
6465
if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6466
# If there is no directory component, then add one.
6468
*/* | *\\*) . $file ;;
6472
# Transform arg to wrapped name.
6473
file="$progdir/$program"
6477
# Quote arguments (to preserve shell metacharacters).
6478
file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6479
args="$args \"$file\""
6482
if test -z "$run"; then
6483
if test -n "$shlibpath_var"; then
6484
# Export the shlibpath_var.
6485
eval "export $shlibpath_var"
6488
# Restore saved environment variables
6489
for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
6491
eval "if test \"\${save_$lt_var+set}\" = set; then
6492
$lt_var=\$save_$lt_var; export $lt_var
6496
# Now prepare to actually exec the command.
6497
exec_cmd="\$cmd$args"
6499
# Display what would be done.
6500
if test -n "$shlibpath_var"; then
6501
eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6502
$echo "export $shlibpath_var"
6509
# libtool clean and uninstall mode
6511
modename="$modename: $mode"
8185
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8191
{ test "$mode" = link || test "$mode" = relink; } &&
8192
func_mode_link ${1+"$@"}
8195
# func_mode_uninstall arg...
8196
func_mode_uninstall ()