« back to all changes in this revision
Viewing changes to ltmain.sh
- browse files at revision 14
- compare with another revision
- download diff
- download tarball
- view history from revision 14
- Committer: Package Import Robot
- Author(s): Daniel Leidert
- Date: 2012-06-27 22:28:39 UTC
- mfrom: (1.2.9)
- Revision ID: package-import@ubuntu.com-20120627222839-5g0f5s6gpaezfhve
Tags: 2.2.3-1
* New upstream release.
* debian/control: Dropped DM-Upload-Allowed.
(Maintainer): Set to my new address.
(Suggests): Calculate browsers depending on distribution.
(Depends): Added python depends for newly shipped Python scripts.
* debian/copyright: Minor update. Link to GPLv2 text.
* debian/rules: Enabled hardening. Added python2 module. Calculate brwoser
dependencies via dpkg-vendor.
* debian/patches/LP810663_blacklist_from_appmenu.patch: Adjusted.
* debian/control: Dropped DM-Upload-Allowed.
(Maintainer): Set to my new address.
(Suggests): Calculate browsers depending on distribution.
(Depends): Added python depends for newly shipped Python scripts.
* debian/copyright: Minor update. Link to GPLv2 text.
* debian/rules: Enabled hardening. Added python2 module. Calculate brwoser
dependencies via dpkg-vendor.
* debian/patches/LP810663_blacklist_from_appmenu.patch: Adjusted.
- files added:
- data/lipsum
- data/lipsum/data
- files modified:
- AUTHORS
added
removed
ltmain.sh
1
# Generated from ltmain.m4sh.
1
2
2
# libtool (GNU libtool) 2.4
3
# ltmain.sh (GNU libtool) 2.2.6b
3
4
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4
5
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6
# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
7
7
# This is free software; see the source for copying conditions. There is NO
8
8
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9
9
32
32
#
33
33
# Provide generalized library-building support services.
34
34
#
35
# --config show all configuration variables
36
# --debug enable verbose shell tracing
37
# -n, --dry-run display commands without modifying any files
38
# --features display basic configuration information and exit
39
# --mode=MODE use operation mode MODE
40
# --preserve-dup-deps don't remove duplicate dependency libraries
41
# --quiet, --silent don't print informational messages
42
# --no-quiet, --no-silent
43
# print informational messages (default)
44
# --tag=TAG use configuration variables from tag TAG
45
# -v, --verbose print more informational messages than default
46
# --no-verbose don't print the extra informational messages
47
# --version print version information
48
# -h, --help, --help-all print short, long, or detailed help message
35
# --config show all configuration variables
36
# --debug enable verbose shell tracing
37
# -n, --dry-run display commands without modifying any files
38
# --features display basic configuration information and exit
39
# --mode=MODE use operation mode MODE
40
# --preserve-dup-deps don't remove duplicate dependency libraries
41
# --quiet, --silent don't print informational messages
42
# --tag=TAG use configuration variables from tag TAG
43
# -v, --verbose print informational messages (default)
44
# --version print version information
45
# -h, --help print short or long help message
49
46
#
50
47
# MODE must be one of the following:
51
48
#
52
# clean remove files from the build directory
53
# compile compile a source file into a libtool object
54
# execute automatically set library path, then run a program
55
# finish complete the installation of libtool libraries
56
# install install libraries or executables
57
# link create a library or an executable
58
# uninstall remove libraries from an installed directory
49
# clean remove files from the build directory
50
# compile compile a source file into a libtool object
51
# execute automatically set library path, then run a program
52
# finish complete the installation of libtool libraries
53
# install install libraries or executables
54
# link create a library or an executable
55
# uninstall remove libraries from an installed directory
59
56
#
60
# MODE-ARGS vary depending on the MODE. When passed as first option,
61
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
57
# MODE-ARGS vary depending on the MODE.
62
58
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
63
59
#
64
60
# When reporting a bug, please describe a test case to reproduce it and
65
61
# include the following information:
66
62
#
67
# host-triplet: $host
68
# shell: $SHELL
69
# compiler: $LTCC
70
# compiler flags: $LTCFLAGS
71
# linker: $LD (gnu? $with_gnu_ld)
72
# $progname: (GNU libtool) 2.4
73
# automake: $automake_version
74
# autoconf: $autoconf_version
63
# host-triplet: $host
64
# shell: $SHELL
65
# compiler: $LTCC
66
# compiler flags: $LTCFLAGS
67
# linker: $LD (gnu? $with_gnu_ld)
68
# $progname: (GNU libtool) 2.2.6b Debian-2.2.6b-2ubuntu1
69
# automake: $automake_version
70
# autoconf: $autoconf_version
75
71
#
76
72
# Report bugs to <bug-libtool@gnu.org>.
77
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
78
# General help using GNU software: <http://www.gnu.org/gethelp/>.
79
73
80
PROGRAM=libtool
74
PROGRAM=ltmain.sh
81
75
PACKAGE=libtool
82
VERSION=2.4
76
VERSION="2.2.6b Debian-2.2.6b-2ubuntu1"
83
77
TIMESTAMP=""
84
package_revision=1.3293
78
package_revision=1.3017
85
79
86
80
# Be Bourne compatible
87
81
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
97
91
BIN_SH=xpg4; export BIN_SH # for Tru64
98
92
DUALCASE=1; export DUALCASE # for MKS sh
99
93
100
# A function that is used when there is no print builtin or printf.
101
func_fallback_echo ()
102
{
103
eval 'cat <<_LTECHO_EOF
104
$1
105
_LTECHO_EOF'
106
}
107
108
94
# NLS nuisances: We save the old values to restore during execute mode.
95
# Only set LANG and LC_ALL to C if already set.
96
# These must not be set unconditionally because not all systems understand
97
# e.g. LANG=C (notably SCO).
109
98
lt_user_locale=
110
99
lt_safe_locale=
111
100
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
118
107
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
119
108
fi"
120
109
done
121
LC_ALL=C
122
LANGUAGE=C
123
export LANGUAGE LC_ALL
124
110
125
111
$lt_unset CDPATH
126
112
127
113
128
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
129
# is ksh but when the shell is invoked as "sh" and the current value of
130
# the _XPG environment variable is not equal to 1 (one), the special
131
# positional parameter $0, within a function call, is the name of the
132
# function.
133
progpath="$0"
134
114
135
115
136
116
137
117
: ${CP="cp -f"}
138
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
118
: ${ECHO="echo"}
139
119
: ${EGREP="/bin/grep -E"}
140
120
: ${FGREP="/bin/grep -F"}
141
121
: ${GREP="/bin/grep"}
164
144
dirname="s,/[^/]*$,,"
165
145
basename="s,^.*/,,"
166
146
167
# func_dirname file append nondir_replacement
168
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
169
# otherwise set result to NONDIR_REPLACEMENT.
170
func_dirname ()
171
{
172
func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
173
if test "X$func_dirname_result" = "X${1}"; then
174
func_dirname_result="${3}"
175
else
176
func_dirname_result="$func_dirname_result${2}"
177
fi
178
} # func_dirname may be replaced by extended shell implementation
179
180
181
# func_basename file
182
func_basename ()
183
{
184
func_basename_result=`$ECHO "${1}" | $SED "$basename"`
185
} # func_basename may be replaced by extended shell implementation
186
187
188
147
# func_dirname_and_basename file append nondir_replacement
189
148
# perform func_basename and func_dirname in a single function
190
149
# call:
199
158
# those functions but instead duplicate the functionality here.
200
159
func_dirname_and_basename ()
201
160
{
202
# Extract subdirectory from the argument.
203
func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
204
if test "X$func_dirname_result" = "X${1}"; then
205
func_dirname_result="${3}"
206
else
207
func_dirname_result="$func_dirname_result${2}"
208
fi
209
func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
210
} # func_dirname_and_basename may be replaced by extended shell implementation
211
212
213
# func_stripname prefix suffix name
214
# strip PREFIX and SUFFIX off of NAME.
215
# PREFIX and SUFFIX must not contain globbing or regex special
216
# characters, hashes, percent signs, but SUFFIX may contain a leading
217
# dot (in which case that matches only a dot).
218
# func_strip_suffix prefix name
219
func_stripname ()
220
{
221
case ${2} in
222
.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
223
*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
224
esac
225
} # func_stripname may be replaced by extended shell implementation
226
227
228
# These SED scripts presuppose an absolute path with a trailing slash.
229
pathcar='s,^/\([^/]*\).*$,\1,'
230
pathcdr='s,^/[^/]*,,'
231
removedotparts=':dotsl
232
s@/\./@/@g
233
t dotsl
234
s,/\.$,/,'
235
collapseslashes='s@/\{1,\}@/@g'
236
finalslash='s,/*$,/,'
237
238
# func_normal_abspath PATH
239
# Remove doubled-up and trailing slashes, "." path components,
240
# and cancel out any ".." path components in PATH after making
241
# it an absolute path.
242
# value returned in "$func_normal_abspath_result"
243
func_normal_abspath ()
244
{
245
# Start from root dir and reassemble the path.
246
func_normal_abspath_result=
247
func_normal_abspath_tpath=$1
248
func_normal_abspath_altnamespace=
249
case $func_normal_abspath_tpath in
250
"")
251
# Empty path, that just means $cwd.
252
func_stripname '' '/' "`pwd`"
253
func_normal_abspath_result=$func_stripname_result
254
return
255
;;
256
# The next three entries are used to spot a run of precisely
257
# two leading slashes without using negated character classes;
258
# we take advantage of case's first-match behaviour.
259
///*)
260
# Unusual form of absolute path, do nothing.
261
;;
262
//*)
263
# Not necessarily an ordinary path; POSIX reserves leading '//'
264
# and for example Cygwin uses it to access remote file shares
265
# over CIFS/SMB, so we conserve a leading double slash if found.
266
func_normal_abspath_altnamespace=/
267
;;
268
/*)
269
# Absolute path, do nothing.
270
;;
271
*)
272
# Relative path, prepend $cwd.
273
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
274
;;
275
esac
276
# Cancel out all the simple stuff to save iterations. We also want
277
# the path to end with a slash for ease of parsing, so make sure
278
# there is one (and only one) here.
279
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
280
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
281
while :; do
282
# Processed it all yet?
283
if test "$func_normal_abspath_tpath" = / ; then
284
# If we ascended to the root using ".." the result may be empty now.
285
if test -z "$func_normal_abspath_result" ; then
286
func_normal_abspath_result=/
287
fi
288
break
289
fi
290
func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
291
-e "$pathcar"`
292
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
293
-e "$pathcdr"`
294
# Figure out what to do with it
295
case $func_normal_abspath_tcomponent in
296
"")
297
# Trailing empty path component, ignore it.
298
;;
299
..)
300
# Parent dir; strip last assembled component from result.
301
func_dirname "$func_normal_abspath_result"
302
func_normal_abspath_result=$func_dirname_result
303
;;
304
*)
305
# Actual path component, append it.
306
func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
307
;;
308
esac
309
done
310
# Restore leading double-slash if one was found on entry.
311
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
312
}
313
314
# func_relative_path SRCDIR DSTDIR
315
# generates a relative path from SRCDIR to DSTDIR, with a trailing
316
# slash if non-empty, suitable for immediately appending a filename
317
# without needing to append a separator.
318
# value returned in "$func_relative_path_result"
319
func_relative_path ()
320
{
321
func_relative_path_result=
322
func_normal_abspath "$1"
323
func_relative_path_tlibdir=$func_normal_abspath_result
324
func_normal_abspath "$2"
325
func_relative_path_tbindir=$func_normal_abspath_result
326
327
# Ascend the tree starting from libdir
328
while :; do
329
# check if we have found a prefix of bindir
330
case $func_relative_path_tbindir in
331
$func_relative_path_tlibdir)
332
# found an exact match
333
func_relative_path_tcancelled=
334
break
335
;;
336
$func_relative_path_tlibdir*)
337
# found a matching prefix
338
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
339
func_relative_path_tcancelled=$func_stripname_result
340
if test -z "$func_relative_path_result"; then
341
func_relative_path_result=.
342
fi
343
break
344
;;
345
*)
346
func_dirname $func_relative_path_tlibdir
347
func_relative_path_tlibdir=${func_dirname_result}
348
if test "x$func_relative_path_tlibdir" = x ; then
349
# Have to descend all the way to the root!
350
func_relative_path_result=../$func_relative_path_result
351
func_relative_path_tcancelled=$func_relative_path_tbindir
352
break
353
fi
354
func_relative_path_result=../$func_relative_path_result
355
;;
356
esac
357
done
358
359
# Now calculate path; take care to avoid doubling-up slashes.
360
func_stripname '' '/' "$func_relative_path_result"
361
func_relative_path_result=$func_stripname_result
362
func_stripname '/' '/' "$func_relative_path_tcancelled"
363
if test "x$func_stripname_result" != x ; then
364
func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
365
fi
366
367
# Normalisation. If bindir is libdir, return empty string,
368
# else relative path ending with a slash; either way, target
369
# file name can be directly appended.
370
if test ! -z "$func_relative_path_result"; then
371
func_stripname './' '' "$func_relative_path_result/"
372
func_relative_path_result=$func_stripname_result
373
fi
374
}
161
# Extract subdirectory from the argument.
162
func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
163
if test "X$func_dirname_result" = "X${1}"; then
164
func_dirname_result="${3}"
165
else
166
func_dirname_result="$func_dirname_result${2}"
167
fi
168
func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
169
}
170
171
# Generated shell functions inserted here.
172
173
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
174
# is ksh but when the shell is invoked as "sh" and the current value of
175
# the _XPG environment variable is not equal to 1 (one), the special
176
# positional parameter $0, within a function call, is the name of the
177
# function.
178
progpath="$0"
375
179
376
180
# The name of this program:
181
# In the unlikely event $progname began with a '-', it would play havoc with
182
# func_echo (imagine progname=-n), so we prepend ./ in that case:
377
183
func_dirname_and_basename "$progpath"
378
184
progname=$func_basename_result
185
case $progname in
186
-*) progname=./$progname ;;
187
esac
379
188
380
189
# Make sure we have an absolute path for reexecution:
381
190
case $progpath in
406
215
# Same as above, but do not quote variable references.
407
216
double_quote_subst='s/\(["`\\]\)/\\\1/g'
408
217
409
# Sed substitution that turns a string into a regex matching for the
410
# string literally.
411
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
412
413
# Sed substitution that converts a w32 file name or path
414
# which contains forward slashes, into one that contains
415
# (escaped) backslashes. A very naive implementation.
416
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
417
418
218
# Re-`\' parameter expansions in output of double_quote_subst that were
419
219
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
420
220
# in input to double_quote_subst, that '$' was protected from expansion.
443
243
# name if it has been set yet.
444
244
func_echo ()
445
245
{
446
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
246
$ECHO "$progname${mode+: }$mode: $*"
447
247
}
448
248
449
249
# func_verbose arg...
458
258
:
459
259
}
460
260
461
# func_echo_all arg...
462
# Invoke $ECHO with all args, space-separated.
463
func_echo_all ()
464
{
465
$ECHO "$*"
466
}
467
468
261
# func_error arg...
469
262
# Echo program name prefixed message to standard error.
470
263
func_error ()
471
264
{
472
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
473
266
}
474
267
475
268
# func_warning arg...
476
269
# Echo program name prefixed warning message to standard error.
477
270
func_warning ()
478
271
{
479
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
480
273
481
274
# bash bug again:
482
275
:
533
326
case $my_directory_path in */*) ;; *) break ;; esac
534
327
535
328
# ...otherwise throw away the child directory and loop
536
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
537
330
done
538
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
539
332
540
333
save_mkdir_p_IFS="$IFS"; IFS=':'
541
334
for my_dir in $my_dir_list; do
585
378
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
586
379
fi
587
380
588
$ECHO "$my_tmpdir"
381
$ECHO "X$my_tmpdir" | $Xsed
589
382
}
590
383
591
384
599
392
{
600
393
case $1 in
601
394
*[\\\`\"\$]*)
602
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
603
396
*)
604
397
func_quote_for_eval_unquoted_result="$1" ;;
605
398
esac
626
419
{
627
420
case $1 in
628
421
*[\\\`\"]*)
629
my_arg=`$ECHO "$1" | $SED \
422
my_arg=`$ECHO "X$1" | $Xsed \
630
423
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
631
424
*)
632
425
my_arg="$1" ;;
695
488
fi
696
489
}
697
490
698
# func_tr_sh
699
# Turn $1 into a string suitable for a shell variable name.
700
# Result is stored in $func_tr_sh_result. All characters
701
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
702
# if $1 begins with a digit, a '_' is prepended as well.
703
func_tr_sh ()
704
{
705
case $1 in
706
[0-9]* | *[!a-zA-Z0-9_]*)
707
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
708
;;
709
* )
710
func_tr_sh_result=$1
711
;;
712
esac
713
}
491
492
714
493
715
494
716
495
# func_version
717
496
# Echo version message to standard output and exit.
718
497
func_version ()
719
498
{
720
$opt_debug
721
722
$SED -n '/(C)/!b go
723
:more
724
/\./!{
725
N
726
s/\n# / /
727
b more
728
}
729
:go
730
/^# '$PROGRAM' (GNU /,/# warranty; / {
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
731
500
s/^# //
732
501
s/^# *$//
733
502
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
740
509
# Echo short help message to standard output and exit.
741
510
func_usage ()
742
511
{
743
$opt_debug
744
745
$SED -n '/^# Usage:/,/^# *.*--help/ {
512
$SED -n '/^# Usage:/,/# -h/ {
746
513
s/^# //
747
514
s/^# *$//
748
515
s/\$progname/'$progname'/
749
516
p
750
517
}' < "$progpath"
751
echo
518
$ECHO
752
519
$ECHO "run \`$progname --help | more' for full usage"
753
520
exit $?
754
521
}
755
522
756
# func_help [NOEXIT]
757
# Echo long help message to standard output and exit,
758
# unless 'noexit' is passed as argument.
523
# func_help
524
# Echo long help message to standard output and exit.
759
525
func_help ()
760
526
{
761
$opt_debug
762
763
527
$SED -n '/^# Usage:/,/# Report bugs to/ {
764
:print
765
528
s/^# //
766
529
s/^# *$//
767
530
s*\$progname*'$progname'*
774
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
775
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
776
539
p
777
d
778
}
779
/^# .* home page:/b print
780
/^# General help using/b print
781
' < "$progpath"
782
ret=$?
783
if test -z "$1"; then
784
exit $ret
785
fi
540
}' < "$progpath"
541
exit $?
786
542
}
787
543
788
544
# func_missing_arg argname
790
546
# exit_cmd.
791
547
func_missing_arg ()
792
548
{
793
$opt_debug
794
795
func_error "missing argument for $1."
549
func_error "missing argument for $1"
796
550
exit_cmd=exit
797
551
}
798
552
799
800
# func_split_short_opt shortopt
801
# Set func_split_short_opt_name and func_split_short_opt_arg shell
802
# variables after splitting SHORTOPT after the 2nd character.
803
func_split_short_opt ()
804
{
805
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
806
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
807
808
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
809
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
810
} # func_split_short_opt may be replaced by extended shell implementation
811
812
813
# func_split_long_opt longopt
814
# Set func_split_long_opt_name and func_split_long_opt_arg shell
815
# variables after splitting LONGOPT at the `=' sign.
816
func_split_long_opt ()
817
{
818
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
819
my_sed_long_arg='1s/^--[^=]*=//'
820
821
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
822
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
823
} # func_split_long_opt may be replaced by extended shell implementation
824
825
553
exit_cmd=:
826
554
827
555
828
556
829
557
830
558
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.
562
shift
563
elif test "X$1" = X--fallback-echo; then
564
# Avoid inline document here, it may be left over
565
:
566
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567
# Yippee, $ECHO works!
568
:
569
else
570
# Restart under the correct shell, and then maybe $ECHO will work.
571
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
572
fi
573
574
if test "X$1" = X--fallback-echo; then
575
# used as fallback echo
576
shift
577
cat <<EOF
578
$*
579
EOF
580
exit $EXIT_SUCCESS
581
fi
582
831
583
magic="%%%MAGIC variable%%%"
832
584
magic_exe="%%%MAGIC EXE variable%%%"
833
585
834
586
# Global variables.
587
# $mode is unset
835
588
nonopt=
589
execute_dlfiles=
836
590
preserve_args=
837
591
lo2o="s/\\.lo\$/.${objext}/"
838
592
o2lo="s/\\.${objext}\$/.lo/"
839
593
extracted_archives=
840
594
extracted_serial=0
841
595
596
opt_dry_run=false
597
opt_duplicate_deps=false
598
opt_silent=false
599
opt_debug=:
600
842
601
# If this variable is set in any of the actions, the command in it
843
602
# will be execed at the end. This prevents here-documents from being
844
603
# left over by shells.
845
604
exec_cmd=
846
605
847
# func_append var value
848
# Append VALUE to the end of shell variable VAR.
849
func_append ()
850
{
851
eval "${1}=\$${1}\${2}"
852
} # func_append may be replaced by extended shell implementation
853
854
# func_append_quoted var value
855
# Quote VALUE and append to the end of shell variable VAR, separated
856
# by a space.
857
func_append_quoted ()
858
{
859
func_quote_for_eval "${2}"
860
eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
861
} # func_append_quoted may be replaced by extended shell implementation
862
863
864
# func_arith arithmetic-term...
865
func_arith ()
866
{
867
func_arith_result=`expr "${@}"`
868
} # func_arith may be replaced by extended shell implementation
869
870
871
# func_len string
872
# STRING may not start with a hyphen.
873
func_len ()
874
{
875
func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
876
} # func_len may be replaced by extended shell implementation
877
878
879
# func_lo2o object
880
func_lo2o ()
881
{
882
func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
883
} # func_lo2o may be replaced by extended shell implementation
884
885
886
# func_xform libobj-or-source
887
func_xform ()
888
{
889
func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
890
} # func_xform may be replaced by extended shell implementation
891
892
893
606
# func_fatal_configuration arg...
894
607
# Echo program name prefixed message to standard error, followed by
895
608
# a configuration failure hint, and exit.
923
636
# Display the features supported by this script.
924
637
func_features ()
925
638
{
926
echo "host: $host"
639
$ECHO "host: $host"
927
640
if test "$build_libtool_libs" = yes; then
928
echo "enable shared libraries"
641
$ECHO "enable shared libraries"
929
642
else
930
echo "disable shared libraries"
643
$ECHO "disable shared libraries"
931
644
fi
932
645
if test "$build_old_libs" = yes; then
933
echo "enable static libraries"
646
$ECHO "enable static libraries"
934
647
else
935
echo "disable static libraries"
648
$ECHO "disable static libraries"
936
649
fi
937
650
938
651
exit $?
979
692
esac
980
693
}
981
694
695
# Parse options once, thoroughly. This comes as soon as possible in
696
# the script to make things like `libtool --version' happen quickly.
697
{
698
699
# Shorthand for --mode=foo, only valid as the first argument
700
case $1 in
701
clean|clea|cle|cl)
702
shift; set dummy --mode clean ${1+"$@"}; shift
703
;;
704
compile|compil|compi|comp|com|co|c)
705
shift; set dummy --mode compile ${1+"$@"}; shift
706
;;
707
execute|execut|execu|exec|exe|ex|e)
708
shift; set dummy --mode execute ${1+"$@"}; shift
709
;;
710
finish|finis|fini|fin|fi|f)
711
shift; set dummy --mode finish ${1+"$@"}; shift
712
;;
713
install|instal|insta|inst|ins|in|i)
714
shift; set dummy --mode install ${1+"$@"}; shift
715
;;
716
link|lin|li|l)
717
shift; set dummy --mode link ${1+"$@"}; shift
718
;;
719
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720
shift; set dummy --mode uninstall ${1+"$@"}; shift
721
;;
722
esac
723
724
# Parse non-mode specific arguments:
725
while test "$#" -gt 0; do
726
opt="$1"
727
shift
728
729
case $opt in
730
--config) func_config ;;
731
732
--debug) preserve_args="$preserve_args $opt"
733
func_echo "enabling shell trace mode"
734
opt_debug='set -x'
735
$opt_debug
736
;;
737
738
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
739
execute_dlfiles="$execute_dlfiles $1"
740
shift
741
;;
742
743
--dry-run | -n) opt_dry_run=: ;;
744
--features) func_features ;;
745
--finish) mode="finish" ;;
746
747
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
748
case $1 in
749
# Valid mode arguments:
750
clean) ;;
751
compile) ;;
752
execute) ;;
753
finish) ;;
754
install) ;;
755
link) ;;
756
relink) ;;
757
uninstall) ;;
758
759
# Catch anything else as an error
760
*) func_error "invalid argument for $opt"
761
exit_cmd=exit
762
break
763
;;
764
esac
765
766
mode="$1"
767
shift
768
;;
769
770
--preserve-dup-deps)
771
opt_duplicate_deps=: ;;
772
773
--quiet|--silent) preserve_args="$preserve_args $opt"
774
opt_silent=:
775
;;
776
777
--verbose| -v) preserve_args="$preserve_args $opt"
778
opt_silent=false
779
;;
780
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
784
shift
785
;;
786
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+"$@"}
791
shift
792
;;
793
794
-\?|-h) func_usage ;;
795
--help) opt_help=: ;;
796
--version) func_version ;;
797
798
-*) func_fatal_help "unrecognized option \`$opt'" ;;
799
800
*) nonopt="$opt"
801
break
802
;;
803
esac
804
done
805
806
807
case $host in
808
*cygwin* | *mingw* | *pw32* | *cegcc*)
809
# don't eliminate duplications in $postdeps and $predeps
810
opt_duplicate_compiler_generated_deps=:
811
;;
812
*)
813
opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
814
;;
815
esac
816
817
# Having warned about all mis-specified options, bail out if
818
# anything was wrong.
819
$exit_cmd $EXIT_FAILURE
820
}
821
982
822
# func_check_version_match
983
823
# Ensure that we are using m4 macros, and libtool script from the same
984
824
# release of libtool.
1015
855
}
1016
856
1017
857
1018
# Shorthand for --mode=foo, only valid as the first argument
1019
case $1 in
1020
clean|clea|cle|cl)
1021
shift; set dummy --mode clean ${1+"$@"}; shift
1022
;;
1023
compile|compil|compi|comp|com|co|c)
1024
shift; set dummy --mode compile ${1+"$@"}; shift
1025
;;
1026
execute|execut|execu|exec|exe|ex|e)
1027
shift; set dummy --mode execute ${1+"$@"}; shift
1028
;;
1029
finish|finis|fini|fin|fi|f)
1030
shift; set dummy --mode finish ${1+"$@"}; shift
1031
;;
1032
install|instal|insta|inst|ins|in|i)
1033
shift; set dummy --mode install ${1+"$@"}; shift
1034
;;
1035
link|lin|li|l)
1036
shift; set dummy --mode link ${1+"$@"}; shift
1037
;;
1038
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1039
shift; set dummy --mode uninstall ${1+"$@"}; shift
1040
;;
1041
esac
1042
1043
1044
1045
# Option defaults:
1046
opt_debug=:
1047
opt_dry_run=false
1048
opt_config=false
1049
opt_preserve_dup_deps=false
1050
opt_features=false
1051
opt_finish=false
1052
opt_help=false
1053
opt_help_all=false
1054
opt_silent=:
1055
opt_verbose=:
1056
opt_silent=false
1057
opt_verbose=false
1058
1059
1060
# Parse options once, thoroughly. This comes as soon as possible in the
1061
# script to make things like `--version' happen as quickly as we can.
1062
{
1063
# this just eases exit handling
1064
while test $# -gt 0; do
1065
opt="$1"
1066
shift
1067
case $opt in
1068
--debug|-x) opt_debug='set -x'
1069
func_echo "enabling shell trace mode"
1070
$opt_debug
1071
;;
1072
--dry-run|--dryrun|-n)
1073
opt_dry_run=:
1074
;;
1075
--config)
1076
opt_config=:
1077
func_config
1078
;;
1079
--dlopen|-dlopen)
1080
optarg="$1"
1081
opt_dlopen="${opt_dlopen+$opt_dlopen
1082
}$optarg"
1083
shift
1084
;;
1085
--preserve-dup-deps)
1086
opt_preserve_dup_deps=:
1087
;;
1088
--features)
1089
opt_features=:
1090
func_features
1091
;;
1092
--finish)
1093
opt_finish=:
1094
set dummy --mode finish ${1+"$@"}; shift
1095
;;
1096
--help)
1097
opt_help=:
1098
;;
1099
--help-all)
1100
opt_help_all=:
1101
opt_help=': help-all'
1102
;;
1103
--mode)
1104
test $# = 0 && func_missing_arg $opt && break
1105
optarg="$1"
1106
opt_mode="$optarg"
1107
case $optarg in
1108
# Valid mode arguments:
1109
clean|compile|execute|finish|install|link|relink|uninstall) ;;
1110
1111
# Catch anything else as an error
1112
*) func_error "invalid argument for $opt"
1113
exit_cmd=exit
1114
break
1115
;;
1116
esac
1117
shift
1118
;;
1119
--no-silent|--no-quiet)
1120
opt_silent=false
1121
func_append preserve_args " $opt"
1122
;;
1123
--no-verbose)
1124
opt_verbose=false
1125
func_append preserve_args " $opt"
1126
;;
1127
--silent|--quiet)
1128
opt_silent=:
1129
func_append preserve_args " $opt"
1130
opt_verbose=false
1131
;;
1132
--verbose|-v)
1133
opt_verbose=:
1134
func_append preserve_args " $opt"
1135
opt_silent=false
1136
;;
1137
--tag)
1138
test $# = 0 && func_missing_arg $opt && break
1139
optarg="$1"
1140
opt_tag="$optarg"
1141
func_append preserve_args " $opt $optarg"
1142
func_enable_tag "$optarg"
1143
shift
1144
;;
1145
1146
-\?|-h) func_usage ;;
1147
--help) func_help ;;
1148
--version) func_version ;;
1149
1150
# Separate optargs to long options:
1151
--*=*)
1152
func_split_long_opt "$opt"
1153
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1154
shift
1155
;;
1156
1157
# Separate non-argument short options:
1158
-\?*|-h*|-n*|-v*)
1159
func_split_short_opt "$opt"
1160
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1161
shift
1162
;;
1163
1164
--) break ;;
1165
-*) func_fatal_help "unrecognized option \`$opt'" ;;
1166
*) set dummy "$opt" ${1+"$@"}; shift; break ;;
1167
esac
1168
done
1169
1170
# Validate options:
1171
1172
# save first non-option argument
1173
if test "$#" -gt 0; then
1174
nonopt="$opt"
1175
shift
1176
fi
1177
1178
# preserve --debug
1179
test "$opt_debug" = : || func_append preserve_args " --debug"
1180
1181
case $host in
1182
*cygwin* | *mingw* | *pw32* | *cegcc*)
1183
# don't eliminate duplications in $postdeps and $predeps
1184
opt_duplicate_compiler_generated_deps=:
1185
;;
1186
*)
1187
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1188
;;
1189
esac
1190
1191
$opt_help || {
1192
# Sanity checks first:
1193
func_check_version_match
1194
1195
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1196
func_fatal_configuration "not configured to build any kind of library"
1197
fi
1198
1199
# Darwin sucks
1200
eval std_shrext=\"$shrext_cmds\"
1201
1202
# Only execute mode is allowed to have -dlopen flags.
1203
if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1204
func_error "unrecognized option \`-dlopen'"
1205
$ECHO "$help" 1>&2
1206
exit $EXIT_FAILURE
1207
fi
1208
1209
# Change the help message to a mode-specific one.
1210
generic_help="$help"
1211
help="Try \`$progname --help --mode=$opt_mode' for more information."
1212
}
1213
1214
1215
# Bail if the options were screwed
1216
$exit_cmd $EXIT_FAILURE
1217
}
1218
1219
1220
1221
1222
858
## ----------- ##
1223
859
## Main. ##
1224
860
## ----------- ##
1225
861
862
$opt_help || {
863
# Sanity checks first:
864
func_check_version_match
865
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"
868
fi
869
870
test -z "$mode" && func_fatal_error "error: you must specify a MODE."
871
872
873
# Darwin sucks
874
eval std_shrext=\"$shrext_cmds\"
875
876
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'"
880
$ECHO "$help" 1>&2
881
exit $EXIT_FAILURE
882
fi
883
884
# Change the help message to a mode-specific one.
885
generic_help="$help"
886
help="Try \`$progname --help --mode=$mode' for more information."
887
}
888
889
1226
890
# func_lalib_p file
1227
891
# True iff FILE is a libtool `.la' library or `.lo' object file.
1228
892
# This function is only a basic sanity check; it will hardly flush out
1286
950
# temporary ltwrapper_script.
1287
951
func_ltwrapper_scriptname ()
1288
952
{
1289
func_dirname_and_basename "$1" "" "."
1290
func_stripname '' '.exe' "$func_basename_result"
1291
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
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"
958
fi
1292
959
}
1293
960
1294
961
# func_ltwrapper_p file
1334
1001
}
1335
1002
1336
1003
1337
# func_resolve_sysroot PATH
1338
# Replace a leading = in PATH with a sysroot. Store the result into
1339
# func_resolve_sysroot_result
1340
func_resolve_sysroot ()
1341
{
1342
func_resolve_sysroot_result=$1
1343
case $func_resolve_sysroot_result in
1344
=*)
1345
func_stripname '=' '' "$func_resolve_sysroot_result"
1346
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1347
;;
1348
esac
1349
}
1350
1351
# func_replace_sysroot PATH
1352
# If PATH begins with the sysroot, replace it with = and
1353
# store the result into func_replace_sysroot_result.
1354
func_replace_sysroot ()
1355
{
1356
case "$lt_sysroot:$1" in
1357
?*:"$lt_sysroot"*)
1358
func_stripname "$lt_sysroot" '' "$1"
1359
func_replace_sysroot_result="=$func_stripname_result"
1360
;;
1361
*)
1362
# Including no sysroot.
1363
func_replace_sysroot_result=$1
1364
;;
1365
esac
1366
}
1367
1368
1004
# func_infer_tag arg
1369
1005
# Infer tagged configuration to use if any are available and
1370
1006
# if one wasn't chosen via the "--tag" command line option.
1377
1013
if test -n "$available_tags" && test -z "$tagname"; then
1378
1014
CC_quoted=
1379
1015
for arg in $CC; do
1380
func_append_quoted CC_quoted "$arg"
1016
func_quote_for_eval "$arg"
1017
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1381
1018
done
1382
CC_expanded=`func_echo_all $CC`
1383
CC_quoted_expanded=`func_echo_all $CC_quoted`
1384
1019
case $@ in
1385
1020
# Blanks in the command may have been stripped by the calling shell,
1386
1021
# but not from the CC environment variable when configure was run.
1387
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1022
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1389
1023
# Blanks at the start of $base_compile will cause this to fail
1390
1024
# if we don't check for them as well.
1391
1025
*)
1396
1030
CC_quoted=
1397
1031
for arg in $CC; do
1398
1032
# Double-quote args containing other shell metacharacters.
1399
func_append_quoted CC_quoted "$arg"
1033
func_quote_for_eval "$arg"
1034
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1400
1035
done
1401
CC_expanded=`func_echo_all $CC`
1402
CC_quoted_expanded=`func_echo_all $CC_quoted`
1403
1036
case "$@ " in
1404
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1037
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1406
1038
# The compiler in the base compile command matches
1407
1039
# the one in the tagged configuration.
1408
1040
# Assume this is the tagged configuration we want.
1465
1097
}
1466
1098
}
1467
1099
1468
1469
##################################################
1470
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1471
##################################################
1472
1473
# func_convert_core_file_wine_to_w32 ARG
1474
# Helper function used by file name conversion functions when $build is *nix,
1475
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
1476
# correctly configured wine environment available, with the winepath program
1477
# in $build's $PATH.
1478
#
1479
# ARG is the $build file name to be converted to w32 format.
1480
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
1481
# be empty on error (or when ARG is empty)
1482
func_convert_core_file_wine_to_w32 ()
1483
{
1484
$opt_debug
1485
func_convert_core_file_wine_to_w32_result="$1"
1486
if test -n "$1"; then
1487
# Unfortunately, winepath does not exit with a non-zero error code, so we
1488
# are forced to check the contents of stdout. On the other hand, if the
1489
# command is not found, the shell will set an exit code of 127 and print
1490
# *an error message* to stdout. So we must check for both error code of
1491
# zero AND non-empty stdout, which explains the odd construction:
1492
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1493
if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1494
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1495
$SED -e "$lt_sed_naive_backslashify"`
1496
else
1497
func_convert_core_file_wine_to_w32_result=
1498
fi
1499
fi
1500
}
1501
# end: func_convert_core_file_wine_to_w32
1502
1503
1504
# func_convert_core_path_wine_to_w32 ARG
1505
# Helper function used by path conversion functions when $build is *nix, and
1506
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1507
# configured wine environment available, with the winepath program in $build's
1508
# $PATH. Assumes ARG has no leading or trailing path separator characters.
1509
#
1510
# ARG is path to be converted from $build format to win32.
1511
# Result is available in $func_convert_core_path_wine_to_w32_result.
1512
# Unconvertible file (directory) names in ARG are skipped; if no directory names
1513
# are convertible, then the result may be empty.
1514
func_convert_core_path_wine_to_w32 ()
1515
{
1516
$opt_debug
1517
# unfortunately, winepath doesn't convert paths, only file names
1518
func_convert_core_path_wine_to_w32_result=""
1519
if test -n "$1"; then
1520
oldIFS=$IFS
1521
IFS=:
1522
for func_convert_core_path_wine_to_w32_f in $1; do
1523
IFS=$oldIFS
1524
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1525
if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1526
if test -z "$func_convert_core_path_wine_to_w32_result"; then
1527
func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1528
else
1529
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1530
fi
1531
fi
1532
done
1533
IFS=$oldIFS
1534
fi
1535
}
1536
# end: func_convert_core_path_wine_to_w32
1537
1538
1539
# func_cygpath ARGS...
1540
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1541
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1542
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1543
# (2), returns the Cygwin file name or path in func_cygpath_result (input
1544
# file name or path is assumed to be in w32 format, as previously converted
1545
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
1546
# or path in func_cygpath_result (input file name or path is assumed to be in
1547
# Cygwin format). Returns an empty string on error.
1548
#
1549
# ARGS are passed to cygpath, with the last one being the file name or path to
1550
# be converted.
1551
#
1552
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1553
# environment variable; do not put it in $PATH.
1554
func_cygpath ()
1555
{
1556
$opt_debug
1557
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1558
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1559
if test "$?" -ne 0; then
1560
# on failure, ensure result is empty
1561
func_cygpath_result=
1562
fi
1563
else
1564
func_cygpath_result=
1565
func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1566
fi
1567
}
1568
#end: func_cygpath
1569
1570
1571
# func_convert_core_msys_to_w32 ARG
1572
# Convert file name or path ARG from MSYS format to w32 format. Return
1573
# result in func_convert_core_msys_to_w32_result.
1574
func_convert_core_msys_to_w32 ()
1575
{
1576
$opt_debug
1577
# awkward: cmd appends spaces to result
1578
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1579
$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1580
}
1581
#end: func_convert_core_msys_to_w32
1582
1583
1584
# func_convert_file_check ARG1 ARG2
1585
# Verify that ARG1 (a file name in $build format) was converted to $host
1586
# format in ARG2. Otherwise, emit an error message, but continue (resetting
1587
# func_to_host_file_result to ARG1).
1588
func_convert_file_check ()
1589
{
1590
$opt_debug
1591
if test -z "$2" && test -n "$1" ; then
1592
func_error "Could not determine host file name corresponding to"
1593
func_error " \`$1'"
1594
func_error "Continuing, but uninstalled executables may not work."
1595
# Fallback:
1596
func_to_host_file_result="$1"
1597
fi
1598
}
1599
# end func_convert_file_check
1600
1601
1602
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1603
# Verify that FROM_PATH (a path in $build format) was converted to $host
1604
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1605
# func_to_host_file_result to a simplistic fallback value (see below).
1606
func_convert_path_check ()
1607
{
1608
$opt_debug
1609
if test -z "$4" && test -n "$3"; then
1610
func_error "Could not determine the host path corresponding to"
1611
func_error " \`$3'"
1612
func_error "Continuing, but uninstalled executables may not work."
1613
# Fallback. This is a deliberately simplistic "conversion" and
1614
# should not be "improved". See libtool.info.
1615
if test "x$1" != "x$2"; then
1616
lt_replace_pathsep_chars="s|$1|$2|g"
1617
func_to_host_path_result=`echo "$3" |
1618
$SED -e "$lt_replace_pathsep_chars"`
1619
else
1620
func_to_host_path_result="$3"
1621
fi
1622
fi
1623
}
1624
# end func_convert_path_check
1625
1626
1627
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1628
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1629
# and appending REPL if ORIG matches BACKPAT.
1630
func_convert_path_front_back_pathsep ()
1631
{
1632
$opt_debug
1633
case $4 in
1634
$1 ) func_to_host_path_result="$3$func_to_host_path_result"
1635
;;
1636
esac
1637
case $4 in
1638
$2 ) func_append func_to_host_path_result "$3"
1639
;;
1640
esac
1641
}
1642
# end func_convert_path_front_back_pathsep
1643
1644
1645
##################################################
1646
# $build to $host FILE NAME CONVERSION FUNCTIONS #
1647
##################################################
1648
# invoked via `$to_host_file_cmd ARG'
1649
#
1650
# In each case, ARG is the path to be converted from $build to $host format.
1651
# Result will be available in $func_to_host_file_result.
1652
1653
1654
# func_to_host_file ARG
1655
# Converts the file name ARG from $build format to $host format. Return result
1656
# in func_to_host_file_result.
1657
func_to_host_file ()
1658
{
1659
$opt_debug
1660
$to_host_file_cmd "$1"
1661
}
1662
# end func_to_host_file
1663
1664
1665
# func_to_tool_file ARG LAZY
1666
# converts the file name ARG from $build format to toolchain format. Return
1667
# result in func_to_tool_file_result. If the conversion in use is listed
1668
# in (the comma separated) LAZY, no conversion takes place.
1669
func_to_tool_file ()
1670
{
1671
$opt_debug
1672
case ,$2, in
1673
*,"$to_tool_file_cmd",*)
1674
func_to_tool_file_result=$1
1675
;;
1676
*)
1677
$to_tool_file_cmd "$1"
1678
func_to_tool_file_result=$func_to_host_file_result
1679
;;
1680
esac
1681
}
1682
# end func_to_tool_file
1683
1684
1685
# func_convert_file_noop ARG
1686
# Copy ARG to func_to_host_file_result.
1687
func_convert_file_noop ()
1688
{
1689
func_to_host_file_result="$1"
1690
}
1691
# end func_convert_file_noop
1692
1693
1694
# func_convert_file_msys_to_w32 ARG
1695
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1696
# conversion to w32 is not available inside the cwrapper. Returns result in
1697
# func_to_host_file_result.
1698
func_convert_file_msys_to_w32 ()
1699
{
1700
$opt_debug
1701
func_to_host_file_result="$1"
1702
if test -n "$1"; then
1703
func_convert_core_msys_to_w32 "$1"
1704
func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1705
fi
1706
func_convert_file_check "$1" "$func_to_host_file_result"
1707
}
1708
# end func_convert_file_msys_to_w32
1709
1710
1711
# func_convert_file_cygwin_to_w32 ARG
1712
# Convert file name ARG from Cygwin to w32 format. Returns result in
1713
# func_to_host_file_result.
1714
func_convert_file_cygwin_to_w32 ()
1715
{
1716
$opt_debug
1717
func_to_host_file_result="$1"
1718
if test -n "$1"; then
1719
# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1720
# LT_CYGPATH in this case.
1721
func_to_host_file_result=`cygpath -m "$1"`
1722
fi
1723
func_convert_file_check "$1" "$func_to_host_file_result"
1724
}
1725
# end func_convert_file_cygwin_to_w32
1726
1727
1728
# func_convert_file_nix_to_w32 ARG
1729
# Convert file name ARG from *nix to w32 format. Requires a wine environment
1730
# and a working winepath. Returns result in func_to_host_file_result.
1731
func_convert_file_nix_to_w32 ()
1732
{
1733
$opt_debug
1734
func_to_host_file_result="$1"
1735
if test -n "$1"; then
1736
func_convert_core_file_wine_to_w32 "$1"
1737
func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1738
fi
1739
func_convert_file_check "$1" "$func_to_host_file_result"
1740
}
1741
# end func_convert_file_nix_to_w32
1742
1743
1744
# func_convert_file_msys_to_cygwin ARG
1745
# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1746
# Returns result in func_to_host_file_result.
1747
func_convert_file_msys_to_cygwin ()
1748
{
1749
$opt_debug
1750
func_to_host_file_result="$1"
1751
if test -n "$1"; then
1752
func_convert_core_msys_to_w32 "$1"
1753
func_cygpath -u "$func_convert_core_msys_to_w32_result"
1754
func_to_host_file_result="$func_cygpath_result"
1755
fi
1756
func_convert_file_check "$1" "$func_to_host_file_result"
1757
}
1758
# end func_convert_file_msys_to_cygwin
1759
1760
1761
# func_convert_file_nix_to_cygwin ARG
1762
# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1763
# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1764
# in func_to_host_file_result.
1765
func_convert_file_nix_to_cygwin ()
1766
{
1767
$opt_debug
1768
func_to_host_file_result="$1"
1769
if test -n "$1"; then
1770
# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1771
func_convert_core_file_wine_to_w32 "$1"
1772
func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1773
func_to_host_file_result="$func_cygpath_result"
1774
fi
1775
func_convert_file_check "$1" "$func_to_host_file_result"
1776
}
1777
# end func_convert_file_nix_to_cygwin
1778
1779
1780
#############################################
1781
# $build to $host PATH CONVERSION FUNCTIONS #
1782
#############################################
1783
# invoked via `$to_host_path_cmd ARG'
1784
#
1785
# In each case, ARG is the path to be converted from $build to $host format.
1786
# The result will be available in $func_to_host_path_result.
1787
#
1788
# Path separators are also converted from $build format to $host format. If
1789
# ARG begins or ends with a path separator character, it is preserved (but
1790
# converted to $host format) on output.
1791
#
1792
# All path conversion functions are named using the following convention:
1793
# file name conversion function : func_convert_file_X_to_Y ()
1794
# path conversion function : func_convert_path_X_to_Y ()
1795
# where, for any given $build/$host combination the 'X_to_Y' value is the
1796
# same. If conversion functions are added for new $build/$host combinations,
1797
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
1798
# will break.
1799
1800
1801
# func_init_to_host_path_cmd
1802
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
1803
# appropriate value, based on the value of $to_host_file_cmd.
1804
to_host_path_cmd=
1805
func_init_to_host_path_cmd ()
1806
{
1807
$opt_debug
1808
if test -z "$to_host_path_cmd"; then
1809
func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1810
to_host_path_cmd="func_convert_path_${func_stripname_result}"
1811
fi
1812
}
1813
1814
1815
# func_to_host_path ARG
1816
# Converts the path ARG from $build format to $host format. Return result
1817
# in func_to_host_path_result.
1818
func_to_host_path ()
1819
{
1820
$opt_debug
1821
func_init_to_host_path_cmd
1822
$to_host_path_cmd "$1"
1823
}
1824
# end func_to_host_path
1825
1826
1827
# func_convert_path_noop ARG
1828
# Copy ARG to func_to_host_path_result.
1829
func_convert_path_noop ()
1830
{
1831
func_to_host_path_result="$1"
1832
}
1833
# end func_convert_path_noop
1834
1835
1836
# func_convert_path_msys_to_w32 ARG
1837
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1838
# conversion to w32 is not available inside the cwrapper. Returns result in
1839
# func_to_host_path_result.
1840
func_convert_path_msys_to_w32 ()
1841
{
1842
$opt_debug
1843
func_to_host_path_result="$1"
1844
if test -n "$1"; then
1845
# Remove leading and trailing path separator characters from ARG. MSYS
1846
# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1847
# and winepath ignores them completely.
1848
func_stripname : : "$1"
1849
func_to_host_path_tmp1=$func_stripname_result
1850
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1851
func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1852
func_convert_path_check : ";" \
1853
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1854
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1855
fi
1856
}
1857
# end func_convert_path_msys_to_w32
1858
1859
1860
# func_convert_path_cygwin_to_w32 ARG
1861
# Convert path ARG from Cygwin to w32 format. Returns result in
1862
# func_to_host_file_result.
1863
func_convert_path_cygwin_to_w32 ()
1864
{
1865
$opt_debug
1866
func_to_host_path_result="$1"
1867
if test -n "$1"; then
1868
# See func_convert_path_msys_to_w32:
1869
func_stripname : : "$1"
1870
func_to_host_path_tmp1=$func_stripname_result
1871
func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1872
func_convert_path_check : ";" \
1873
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1874
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1875
fi
1876
}
1877
# end func_convert_path_cygwin_to_w32
1878
1879
1880
# func_convert_path_nix_to_w32 ARG
1881
# Convert path ARG from *nix to w32 format. Requires a wine environment and
1882
# a working winepath. Returns result in func_to_host_file_result.
1883
func_convert_path_nix_to_w32 ()
1884
{
1885
$opt_debug
1886
func_to_host_path_result="$1"
1887
if test -n "$1"; then
1888
# See func_convert_path_msys_to_w32:
1889
func_stripname : : "$1"
1890
func_to_host_path_tmp1=$func_stripname_result
1891
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1892
func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1893
func_convert_path_check : ";" \
1894
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1895
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1896
fi
1897
}
1898
# end func_convert_path_nix_to_w32
1899
1900
1901
# func_convert_path_msys_to_cygwin ARG
1902
# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1903
# Returns result in func_to_host_file_result.
1904
func_convert_path_msys_to_cygwin ()
1905
{
1906
$opt_debug
1907
func_to_host_path_result="$1"
1908
if test -n "$1"; then
1909
# See func_convert_path_msys_to_w32:
1910
func_stripname : : "$1"
1911
func_to_host_path_tmp1=$func_stripname_result
1912
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1913
func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1914
func_to_host_path_result="$func_cygpath_result"
1915
func_convert_path_check : : \
1916
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1917
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1918
fi
1919
}
1920
# end func_convert_path_msys_to_cygwin
1921
1922
1923
# func_convert_path_nix_to_cygwin ARG
1924
# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1925
# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1926
# func_to_host_file_result.
1927
func_convert_path_nix_to_cygwin ()
1928
{
1929
$opt_debug
1930
func_to_host_path_result="$1"
1931
if test -n "$1"; then
1932
# Remove leading and trailing path separator characters from
1933
# ARG. msys behavior is inconsistent here, cygpath turns them
1934
# into '.;' and ';.', and winepath ignores them completely.
1935
func_stripname : : "$1"
1936
func_to_host_path_tmp1=$func_stripname_result
1937
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1938
func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1939
func_to_host_path_result="$func_cygpath_result"
1940
func_convert_path_check : : \
1941
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1942
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1943
fi
1944
}
1945
# end func_convert_path_nix_to_cygwin
1946
1947
1948
1100
# func_mode_compile arg...
1949
1101
func_mode_compile ()
1950
1102
{
1985
1137
;;
1986
1138
1987
1139
-pie | -fpie | -fPIE)
1988
func_append pie_flag " $arg"
1140
pie_flag="$pie_flag $arg"
1989
1141
continue
1990
1142
;;
1991
1143
1992
1144
-shared | -static | -prefer-pic | -prefer-non-pic)
1993
func_append later " $arg"
1145
later="$later $arg"
1994
1146
continue
1995
1147
;;
1996
1148
2011
1163
save_ifs="$IFS"; IFS=','
2012
1164
for arg in $args; do
2013
1165
IFS="$save_ifs"
2014
func_append_quoted lastarg "$arg"
1166
func_quote_for_eval "$arg"
1167
lastarg="$lastarg $func_quote_for_eval_result"
2015
1168
done
2016
1169
IFS="$save_ifs"
2017
1170
func_stripname ' ' '' "$lastarg"
2018
1171
lastarg=$func_stripname_result
2019
1172
2020
1173
# Add the arguments to base_compile.
2021
func_append base_compile " $lastarg"
1174
base_compile="$base_compile $lastarg"
2022
1175
continue
2023
1176
;;
2024
1177
2034
1187
esac # case $arg_mode
2035
1188
2036
1189
# Aesthetically quote the previous argument.
2037
func_append_quoted base_compile "$lastarg"
1190
func_quote_for_eval "$lastarg"
1191
base_compile="$base_compile $func_quote_for_eval_result"
2038
1192
done # for arg
2039
1193
2040
1194
case $arg_mode in
2059
1213
*.[cCFSifmso] | \
2060
1214
*.ada | *.adb | *.ads | *.asm | \
2061
1215
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2062
*.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1216
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
2063
1217
func_xform "$libobj"
2064
1218
libobj=$func_xform_result
2065
1219
;;
2134
1288
# Calculate the filename of the output object if compiler does
2135
1289
# not support -o with -c
2136
1290
if test "$compiler_c_o" = no; then
2137
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1291
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
2138
1292
lockfile="$output_obj.lock"
2139
1293
else
2140
1294
output_obj=
2165
1319
$opt_dry_run || $RM $removelist
2166
1320
exit $EXIT_FAILURE
2167
1321
fi
2168
func_append removelist " $output_obj"
1322
removelist="$removelist $output_obj"
2169
1323
$ECHO "$srcfile" > "$lockfile"
2170
1324
fi
2171
1325
2172
1326
$opt_dry_run || $RM $removelist
2173
func_append removelist " $lockfile"
1327
removelist="$removelist $lockfile"
2174
1328
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2175
1329
2176
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177
srcfile=$func_to_tool_file_result
1330
if test -n "$fix_srcfile_path"; then
1331
eval srcfile=\"$fix_srcfile_path\"
1332
fi
2178
1333
func_quote_for_eval "$srcfile"
2179
1334
qsrcfile=$func_quote_for_eval_result
2180
1335
2194
1349
2195
1350
if test -z "$output_obj"; then
2196
1351
# Place PIC objects in $objdir
2197
func_append command " -o $lobj"
1352
command="$command -o $lobj"
2198
1353
fi
2199
1354
2200
1355
func_show_eval_locale "$command" \
2241
1396
command="$base_compile $qsrcfile $pic_flag"
2242
1397
fi
2243
1398
if test "$compiler_c_o" = yes; then
2244
func_append command " -o $obj"
1399
command="$command -o $obj"
2245
1400
fi
2246
1401
2247
1402
# Suppress compiler output if we already did a PIC compilation.
2248
func_append command "$suppress_output"
1403
command="$command$suppress_output"
2249
1404
func_show_eval_locale "$command" \
2250
1405
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2251
1406
2290
1445
}
2291
1446
2292
1447
$opt_help || {
2293
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
1448
test "$mode" = compile && func_mode_compile ${1+"$@"}
2294
1449
}
2295
1450
2296
1451
func_mode_help ()
2297
1452
{
2298
1453
# We need to display help for each of the modes.
2299
case $opt_mode in
1454
case $mode in
2300
1455
"")
2301
1456
# Generic help is extracted from the usage comments
2302
1457
# at the start of this file.
2327
1482
2328
1483
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
2329
1484
-no-suppress do not suppress compiler output for multiple passes
2330
-prefer-pic try to build PIC objects only
2331
-prefer-non-pic try to build non-PIC objects only
1485
-prefer-pic try to building PIC objects only
1486
-prefer-non-pic try to building non-PIC objects only
2332
1487
-shared do not build a \`.o' file suitable for static linking
2333
1488
-static only build a \`.o' file suitable for static linking
2334
-Wc,FLAG pass FLAG directly to the compiler
2335
1489
2336
1490
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2337
1491
from the given SOURCEFILE.
2384
1538
2385
1539
The following components of INSTALL-COMMAND are treated specially:
2386
1540
2387
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1541
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2388
1542
2389
1543
The rest of the components are interpreted as arguments to that command (only
2390
1544
BSD-compatible install options are recognized)."
2404
1558
2405
1559
-all-static do not do any dynamic linking at all
2406
1560
-avoid-version do not add a version suffix if possible
2407
-bindir BINDIR specify path to binaries directory (for systems where
2408
libraries must be found in the PATH setting at runtime)
2409
1561
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2410
1562
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2411
1563
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2434
1586
-version-info CURRENT[:REVISION[:AGE]]
2435
1587
specify library version info [each variable defaults to 0]
2436
1588
-weak LIBNAME declare that the target provides the LIBNAME interface
2437
-Wc,FLAG
2438
-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2439
-Wl,FLAG
2440
-Xlinker FLAG pass linker-specific FLAG directly to the linker
2441
-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2442
1589
2443
1590
All other options (arguments beginning with \`-') are ignored.
2444
1591
2472
1619
;;
2473
1620
2474
1621
*)
2475
func_fatal_help "invalid operation mode \`$opt_mode'"
1622
func_fatal_help "invalid operation mode \`$mode'"
2476
1623
;;
2477
1624
esac
2478
1625
2479
echo
1626
$ECHO
2480
1627
$ECHO "Try \`$progname --help' for more information about other modes."
1628
1629
exit $?
2481
1630
}
2482
1631
2483
# Now that we've collected a possible --mode arg, show help if necessary
2484
if $opt_help; then
2485
if test "$opt_help" = :; then
2486
func_mode_help
2487
else
2488
{
2489
func_help noexit
2490
for opt_mode in compile link execute install finish uninstall clean; do
2491
func_mode_help
2492
done
2493
} | sed -n '1p; 2,$s/^Usage:/ or: /p'
2494
{
2495
func_help noexit
2496
for opt_mode in compile link execute install finish uninstall clean; do
2497
echo
2498
func_mode_help
2499
done
2500
} |
2501
sed '1d
2502
/^When reporting/,/^Report/{
2503
H
2504
d
2505
}
2506
$x
2507
/information about other modes/d
2508
/more detailed .*MODE/d
2509
s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2510
fi
2511
exit $?
2512
fi
1632
# Now that we've collected a possible --mode arg, show help if necessary
1633
$opt_help && func_mode_help
2513
1634
2514
1635
2515
1636
# func_mode_execute arg...
2522
1643
func_fatal_help "you must specify a COMMAND"
2523
1644
2524
1645
# Handle -dlopen flags immediately.
2525
for file in $opt_dlopen; do
1646
for file in $execute_dlfiles; do
2526
1647
test -f "$file" \
2527
1648
|| func_fatal_help "\`$file' is not a file"
2528
1649
2529
1650
dir=
2530
1651
case $file in
2531
1652
*.la)
2532
func_resolve_sysroot "$file"
2533
file=$func_resolve_sysroot_result
2534
2535
1653
# Check to see that this really is a libtool archive.
2536
1654
func_lalib_unsafe_p "$file" \
2537
1655
|| func_fatal_help "\`$lib' is not a valid libtool archive"
2553
1671
dir="$func_dirname_result"
2554
1672
2555
1673
if test -f "$dir/$objdir/$dlname"; then
2556
func_append dir "/$objdir"
1674
dir="$dir/$objdir"
2557
1675
else
2558
1676
if test ! -f "$dir/$dlname"; then
2559
1677
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2594
1712
for file
2595
1713
do
2596
1714
case $file in
2597
-* | *.la | *.lo ) ;;
1715
-*) ;;
2598
1716
*)
2599
1717
# Do a test to see if this is really a libtool program.
2600
1718
if func_ltwrapper_script_p "$file"; then
2610
1728
;;
2611
1729
esac
2612
1730
# Quote arguments (to preserve shell metacharacters).
2613
func_append_quoted args "$file"
1731
func_quote_for_eval "$file"
1732
args="$args $func_quote_for_eval_result"
2614
1733
done
2615
1734
2616
1735
if test "X$opt_dry_run" = Xfalse; then
2635
1754
# Display what would be done.
2636
1755
if test -n "$shlibpath_var"; then
2637
1756
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2638
echo "export $shlibpath_var"
1757
$ECHO "export $shlibpath_var"
2639
1758
fi
2640
1759
$ECHO "$cmd$args"
2641
1760
exit $EXIT_SUCCESS
2642
1761
fi
2643
1762
}
2644
1763
2645
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
1764
test "$mode" = execute && func_mode_execute ${1+"$@"}
2646
1765
2647
1766
2648
1767
# func_mode_finish arg...
2649
1768
func_mode_finish ()
2650
1769
{
2651
1770
$opt_debug
2652
libs=
2653
libdirs=
1771
libdirs="$nonopt"
2654
1772
admincmds=
2655
1773
2656
for opt in "$nonopt" ${1+"$@"}
2657
do
2658
if test -d "$opt"; then
2659
func_append libdirs " $opt"
2660
2661
elif test -f "$opt"; then
2662
if func_lalib_unsafe_p "$opt"; then
2663
func_append libs " $opt"
2664
else
2665
func_warning "\`$opt' is not a valid libtool archive"
2666
fi
2667
2668
else
2669
func_fatal_error "invalid argument \`$opt'"
2670
fi
2671
done
2672
2673
if test -n "$libs"; then
2674
if test -n "$lt_sysroot"; then
2675
sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2676
sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2677
else
2678
sysroot_cmd=
2679
fi
2680
2681
# Remove sysroot references
2682
if $opt_dry_run; then
2683
for lib in $libs; do
2684
echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2685
done
2686
else
2687
tmpdir=`func_mktempdir`
2688
for lib in $libs; do
2689
sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2690
> $tmpdir/tmp-la
2691
mv -f $tmpdir/tmp-la $lib
2692
done
2693
${RM}r "$tmpdir"
2694
fi
2695
fi
2696
2697
1774
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1775
for dir
1776
do
1777
libdirs="$libdirs $dir"
1778
done
1779
2698
1780
for libdir in $libdirs; do
2699
1781
if test -n "$finish_cmds"; then
2700
1782
# Do each command in the finish commands.
2704
1786
if test -n "$finish_eval"; then
2705
1787
# Do the single finish_eval.
2706
1788
eval cmds=\"$finish_eval\"
2707
$opt_dry_run || eval "$cmds" || func_append admincmds "
1789
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
2708
1790
$cmds"
2709
1791
fi
2710
1792
done
2713
1795
# Exit here if they wanted silent mode.
2714
1796
$opt_silent && exit $EXIT_SUCCESS
2715
1797
2716
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2717
echo "----------------------------------------------------------------------"
2718
echo "Libraries have been installed in:"
2719
for libdir in $libdirs; do
2720
$ECHO " $libdir"
2721
done
2722
echo
2723
echo "If you ever happen to want to link against installed libraries"
2724
echo "in a given directory, LIBDIR, you must either use libtool, and"
2725
echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2726
echo "flag during linking and do at least one of the following:"
2727
if test -n "$shlibpath_var"; then
2728
echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2729
echo " during execution"
2730
fi
2731
if test -n "$runpath_var"; then
2732
echo " - add LIBDIR to the \`$runpath_var' environment variable"
2733
echo " during linking"
2734
fi
2735
if test -n "$hardcode_libdir_flag_spec"; then
2736
libdir=LIBDIR
2737
eval flag=\"$hardcode_libdir_flag_spec\"
2738
2739
$ECHO " - use the \`$flag' linker flag"
2740
fi
2741
if test -n "$admincmds"; then
2742
$ECHO " - have your system administrator run these commands:$admincmds"
2743
fi
2744
if test -f /etc/ld.so.conf; then
2745
echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2746
fi
2747
echo
2748
2749
echo "See any operating system documentation about shared libraries for"
2750
case $host in
2751
solaris2.[6789]|solaris2.1[0-9])
2752
echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2753
echo "pages."
2754
;;
2755
*)
2756
echo "more information, such as the ld(1) and ld.so(8) manual pages."
2757
;;
2758
esac
2759
echo "----------------------------------------------------------------------"
2760
fi
1798
$ECHO "X----------------------------------------------------------------------" | $Xsed
1799
$ECHO "Libraries have been installed in:"
1800
for libdir in $libdirs; do
1801
$ECHO " $libdir"
1802
done
1803
$ECHO
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"
1811
fi
1812
if test -n "$runpath_var"; then
1813
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1814
$ECHO " during linking"
1815
fi
1816
if test -n "$hardcode_libdir_flag_spec"; then
1817
libdir=LIBDIR
1818
eval flag=\"$hardcode_libdir_flag_spec\"
1819
1820
$ECHO " - use the \`$flag' linker flag"
1821
fi
1822
if test -n "$admincmds"; then
1823
$ECHO " - have your system administrator run these commands:$admincmds"
1824
fi
1825
if test -f /etc/ld.so.conf; then
1826
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1827
fi
1828
$ECHO
1829
1830
$ECHO "See any operating system documentation about shared libraries for"
1831
case $host in
1832
solaris2.[6789]|solaris2.1[0-9])
1833
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1834
$ECHO "pages."
1835
;;
1836
*)
1837
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1838
;;
1839
esac
1840
$ECHO "X----------------------------------------------------------------------" | $Xsed
2761
1841
exit $EXIT_SUCCESS
2762
1842
}
2763
1843
2764
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
1844
test "$mode" = finish && func_mode_finish ${1+"$@"}
2765
1845
2766
1846
2767
1847
# func_mode_install arg...
2772
1852
# install_prog (especially on Windows NT).
2773
1853
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2774
1854
# Allow the use of GNU shtool's install command.
2775
case $nonopt in *shtool*) :;; *) false;; esac; then
1855
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2776
1856
# Aesthetically quote it.
2777
1857
func_quote_for_eval "$nonopt"
2778
1858
install_prog="$func_quote_for_eval_result "
2786
1866
# The real first argument should be the name of the installation program.
2787
1867
# Aesthetically quote it.
2788
1868
func_quote_for_eval "$arg"
2789
func_append install_prog "$func_quote_for_eval_result"
2790
install_shared_prog=$install_prog
2791
case " $install_prog " in
2792
*[\\\ /]cp\ *) install_cp=: ;;
2793
*) install_cp=false ;;
2794
esac
1869
install_prog="$install_prog$func_quote_for_eval_result"
2795
1870
2796
1871
# We need to accept at least all the BSD install flags.
2797
1872
dest=
2801
1876
install_type=
2802
1877
isdir=no
2803
1878
stripme=
2804
no_mode=:
2805
1879
for arg
2806
1880
do
2807
arg2=
2808
1881
if test -n "$dest"; then
2809
func_append files " $dest"
1882
files="$files $dest"
2810
1883
dest=$arg
2811
1884
continue
2812
1885
fi
2814
1887
case $arg in
2815
1888
-d) isdir=yes ;;
2816
1889
-f)
2817
if $install_cp; then :; else
2818
prev=$arg
2819
fi
1890
case " $install_prog " in
1891
*[\\\ /]cp\ *) ;;
1892
*) prev=$arg ;;
1893
esac
2820
1894
;;
2821
1895
-g | -m | -o)
2822
1896
prev=$arg
2830
1904
*)
2831
1905
# If the previous option needed an argument, then skip it.
2832
1906
if test -n "$prev"; then
2833
if test "x$prev" = x-m && test -n "$install_override_mode"; then
2834
arg2=$install_override_mode
2835
no_mode=false
2836
fi
2837
1907
prev=
2838
1908
else
2839
1909
dest=$arg
2844
1914
2845
1915
# Aesthetically quote the argument.
2846
1916
func_quote_for_eval "$arg"
2847
func_append install_prog " $func_quote_for_eval_result"
2848
if test -n "$arg2"; then
2849
func_quote_for_eval "$arg2"
2850
fi
2851
func_append install_shared_prog " $func_quote_for_eval_result"
1917
install_prog="$install_prog $func_quote_for_eval_result"
2852
1918
done
2853
1919
2854
1920
test -z "$install_prog" && \
2857
1923
test -n "$prev" && \
2858
1924
func_fatal_help "the \`$prev' option requires an argument"
2859
1925
2860
if test -n "$install_override_mode" && $no_mode; then
2861
if $install_cp; then :; else
2862
func_quote_for_eval "$install_override_mode"
2863
func_append install_shared_prog " -m $func_quote_for_eval_result"
2864
fi
2865
fi
2866
2867
1926
if test -z "$files"; then
2868
1927
if test -z "$dest"; then
2869
1928
func_fatal_help "no file or destination specified"
2918
1977
case $file in
2919
1978
*.$libext)
2920
1979
# Do the static libraries later.
2921
func_append staticlibs " $file"
1980
staticlibs="$staticlibs $file"
2922
1981
;;
2923
1982
2924
1983
*.la)
2925
func_resolve_sysroot "$file"
2926
file=$func_resolve_sysroot_result
2927
2928
1984
# Check to see that this really is a libtool archive.
2929
1985
func_lalib_unsafe_p "$file" \
2930
1986
|| func_fatal_help "\`$file' is not a valid libtool archive"
2938
1994
if test "X$destdir" = "X$libdir"; then
2939
1995
case "$current_libdirs " in
2940
1996
*" $libdir "*) ;;
2941
*) func_append current_libdirs " $libdir" ;;
1997
*) current_libdirs="$current_libdirs $libdir" ;;
2942
1998
esac
2943
1999
else
2944
2000
# Note the libdir as a future libdir.
2945
2001
case "$future_libdirs " in
2946
2002
*" $libdir "*) ;;
2947
*) func_append future_libdirs " $libdir" ;;
2003
*) future_libdirs="$future_libdirs $libdir" ;;
2948
2004
esac
2949
2005
fi
2950
2006
2951
2007
func_dirname "$file" "/" ""
2952
2008
dir="$func_dirname_result"
2953
func_append dir "$objdir"
2009
dir="$dir$objdir"
2954
2010
2955
2011
if test -n "$relink_command"; then
2956
2012
# Determine the prefix the user has applied to our future dir.
2957
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2013
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2958
2014
2959
2015
# Don't allow the user to place us outside of our expected
2960
2016
# location b/c this prevents finding dependent libraries that
2967
2023
2968
2024
if test -n "$inst_prefix_dir"; then
2969
2025
# Stick the inst_prefix_dir data into the link command.
2970
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2026
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2971
2027
else
2972
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2028
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2973
2029
fi
2974
2030
2975
2031
func_warning "relinking \`$file'"
2987
2043
test -n "$relink_command" && srcname="$realname"T
2988
2044
2989
2045
# Install the shared library and build the symlinks.
2990
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2046
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2991
2047
'exit $?'
2992
2048
tstripme="$stripme"
2993
2049
case $host_os in
3027
2083
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3028
2084
3029
2085
# Maybe install the static library, too.
3030
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
2086
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
3031
2087
;;
3032
2088
3033
2089
*.lo)
3127
2183
if test -f "$lib"; then
3128
2184
func_source "$lib"
3129
2185
fi
3130
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2186
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
3131
2187
if test -n "$libdir" && test ! -f "$libfile"; then
3132
2188
func_warning "\`$lib' has not been installed in \`$libdir'"
3133
2189
finalize=no
3146
2202
file="$func_basename_result"
3147
2203
outputname="$tmpdir/$file"
3148
2204
# Replace the output file specification.
3149
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2205
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
3150
2206
3151
2207
$opt_silent || {
3152
2208
func_quote_for_expand "$relink_command"
3165
2221
}
3166
2222
else
3167
2223
# Install the binary that we compiled earlier.
3168
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2224
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
3169
2225
fi
3170
2226
fi
3171
2227
3224
2280
fi
3225
2281
}
3226
2282
3227
test "$opt_mode" = install && func_mode_install ${1+"$@"}
2283
test "$mode" = install && func_mode_install ${1+"$@"}
3228
2284
3229
2285
3230
2286
# func_generate_dlsyms outputname originator pic_p
3267
2323
extern \"C\" {
3268
2324
#endif
3269
2325
3270
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3271
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3272
#endif
3273
3274
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3275
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3276
/* DATA imports from DLLs on WIN32 con't be const, because runtime
3277
relocations are performed -- see ld's documentation on pseudo-relocs. */
3278
# define LT_DLSYM_CONST
3279
#elif defined(__osf__)
3280
/* This system does not cope well with relocations in const data. */
3281
# define LT_DLSYM_CONST
3282
#else
3283
# define LT_DLSYM_CONST const
3284
#endif
3285
3286
2326
/* External symbol declarations for the compiler. */\
3287
2327
"
3288
2328
3292
2332
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3293
2333
3294
2334
# Add our own program objects to the symbol list.
3295
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2335
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3296
2336
for progfile in $progfiles; do
3297
func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3298
func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3299
$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
2337
func_verbose "extracting global C symbols from \`$progfile'"
2338
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
3300
2339
done
3301
2340
3302
2341
if test -n "$exclude_expsyms"; then
3332
2371
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3333
2372
eval '$MV "$nlist"T "$nlist"'
3334
2373
case $host in
3335
*cygwin* | *mingw* | *cegcc* )
2374
*cygwin | *mingw* | *cegcc* )
3336
2375
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3337
2376
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3338
2377
;;
3345
2384
func_verbose "extracting global C symbols from \`$dlprefile'"
3346
2385
func_basename "$dlprefile"
3347
2386
name="$func_basename_result"
3348
case $host in
3349
*cygwin* | *mingw* | *cegcc* )
3350
# if an import library, we need to obtain dlname
3351
if func_win32_import_lib_p "$dlprefile"; then
3352
func_tr_sh "$dlprefile"
3353
eval "curr_lafile=\$libfile_$func_tr_sh_result"
3354
dlprefile_dlbasename=""
3355
if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3356
# Use subshell, to avoid clobbering current variable values
3357
dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3358
if test -n "$dlprefile_dlname" ; then
3359
func_basename "$dlprefile_dlname"
3360
dlprefile_dlbasename="$func_basename_result"
3361
else
3362
# no lafile. user explicitly requested -dlpreopen <import library>.
3363
$sharedlib_from_linklib_cmd "$dlprefile"
3364
dlprefile_dlbasename=$sharedlib_from_linklib_result
3365
fi
3366
fi
3367
$opt_dry_run || {
3368
if test -n "$dlprefile_dlbasename" ; then
3369
eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3370
else
3371
func_warning "Could not compute DLL name from $name"
3372
eval '$ECHO ": $name " >> "$nlist"'
3373
fi
3374
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3375
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3376
$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3377
}
3378
else # not an import lib
3379
$opt_dry_run || {
3380
eval '$ECHO ": $name " >> "$nlist"'
3381
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3382
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3383
}
3384
fi
3385
;;
3386
*)
3387
$opt_dry_run || {
3388
eval '$ECHO ": $name " >> "$nlist"'
3389
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3390
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3391
}
3392
;;
3393
esac
2387
$opt_dry_run || {
2388
eval '$ECHO ": $name " >> "$nlist"'
2389
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2390
}
3394
2391
done
3395
2392
3396
2393
$opt_dry_run || {
3418
2415
if test -f "$nlist"S; then
3419
2416
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3420
2417
else
3421
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2418
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
3422
2419
fi
3423
2420
3424
echo >> "$output_objdir/$my_dlsyms" "\
2421
$ECHO >> "$output_objdir/$my_dlsyms" "\
3425
2422
3426
2423
/* The mapping between symbol names and symbols. */
3427
2424
typedef struct {
3428
2425
const char *name;
3429
2426
void *address;
3430
2427
} lt_dlsymlist;
3431
extern LT_DLSYM_CONST lt_dlsymlist
2428
"
2429
case $host in
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. */"
2435
lt_dlsym_const= ;;
2436
*osf5*)
2437
echo >> "$output_objdir/$my_dlsyms" "\
2438
/* This system does not cope well with relocations in const data */"
2439
lt_dlsym_const= ;;
2440
*)
2441
lt_dlsym_const=const ;;
2442
esac
2443
2444
$ECHO >> "$output_objdir/$my_dlsyms" "\
2445
extern $lt_dlsym_const lt_dlsymlist
3432
2446
lt_${my_prefix}_LTX_preloaded_symbols[];
3433
LT_DLSYM_CONST lt_dlsymlist
2447
$lt_dlsym_const lt_dlsymlist
3434
2448
lt_${my_prefix}_LTX_preloaded_symbols[] =
3435
2449
{\
3436
2450
{ \"$my_originator\", (void *) 0 },"
3443
2457
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444
2458
;;
3445
2459
esac
3446
echo >> "$output_objdir/$my_dlsyms" "\
2460
$ECHO >> "$output_objdir/$my_dlsyms" "\
3447
2461
{0, (void *) 0}
3448
2462
};
3449
2463
3486
2500
for arg in $LTCFLAGS; do
3487
2501
case $arg in
3488
2502
-pie | -fpie | -fPIE) ;;
3489
*) func_append symtab_cflags " $arg" ;;
2503
*) symtab_cflags="$symtab_cflags $arg" ;;
3490
2504
esac
3491
2505
done
3492
2506
3501
2515
case $host in
3502
2516
*cygwin* | *mingw* | *cegcc* )
3503
2517
if test -f "$output_objdir/$my_outputname.def"; then
3504
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3505
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
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%"`
3506
2520
else
3507
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3508
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$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%"`
3509
2523
fi
3510
2524
;;
3511
2525
*)
3512
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513
finalize_command=`$ECHO "$finalize_command" | $SED "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%"`
3514
2528
;;
3515
2529
esac
3516
2530
;;
3524
2538
# really was required.
3525
2539
3526
2540
# Nullify the symbol file.
3527
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3528
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2541
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3529
2543
fi
3530
2544
}
3531
2545
3535
2549
# Need a lot of goo to handle *both* DLLs and import libs
3536
2550
# Has to be a shell function in order to 'eat' the argument
3537
2551
# that is supplied when $file_magic_command is called.
3538
# Despite the name, also deal with 64 bit binaries.
3539
2552
func_win32_libid ()
3540
2553
{
3541
2554
$opt_debug
3546
2559
win32_libid_type="x86 archive import"
3547
2560
;;
3548
2561
*ar\ archive*) # could be an import, or static
3549
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3550
2562
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3551
$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3552
func_to_tool_file "$1" func_convert_file_msys_to_w32
3553
win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
2563
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564
win32_nmres=`eval $NM -f posix -A $1 |
3554
2565
$SED -n -e '
3555
2566
1,100{
3556
2567
/ I /{
3579
2590
$ECHO "$win32_libid_type"
3580
2591
}
3581
2592
3582
# func_cygming_dll_for_implib ARG
3583
#
3584
# Platform-specific function to extract the
3585
# name of the DLL associated with the specified
3586
# import library ARG.
3587
# Invoked by eval'ing the libtool variable
3588
# $sharedlib_from_linklib_cmd
3589
# Result is available in the variable
3590
# $sharedlib_from_linklib_result
3591
func_cygming_dll_for_implib ()
3592
{
3593
$opt_debug
3594
sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3595
}
3596
3597
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3598
#
3599
# The is the core of a fallback implementation of a
3600
# platform-specific function to extract the name of the
3601
# DLL associated with the specified import library LIBNAME.
3602
#
3603
# SECTION_NAME is either .idata$6 or .idata$7, depending
3604
# on the platform and compiler that created the implib.
3605
#
3606
# Echos the name of the DLL associated with the
3607
# specified import library.
3608
func_cygming_dll_for_implib_fallback_core ()
3609
{
3610
$opt_debug
3611
match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3612
$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3613
$SED '/^Contents of section '"$match_literal"':/{
3614
# Place marker at beginning of archive member dllname section
3615
s/.*/====MARK====/
3616
p
3617
d
3618
}
3619
# These lines can sometimes be longer than 43 characters, but
3620
# are always uninteresting
3621
/:[ ]*file format pe[i]\{,1\}-/d
3622
/^In archive [^:]*:/d
3623
# Ensure marker is printed
3624
/^====MARK====/p
3625
# Remove all lines with less than 43 characters
3626
/^.\{43\}/!d
3627
# From remaining lines, remove first 43 characters
3628
s/^.\{43\}//' |
3629
$SED -n '
3630
# Join marker and all lines until next marker into a single line
3631
/^====MARK====/ b para
3632
H
3633
$ b para
3634
b
3635
:para
3636
x
3637
s/\n//g
3638
# Remove the marker
3639
s/^====MARK====//
3640
# Remove trailing dots and whitespace
3641
s/[\. \t]*$//
3642
# Print
3643
/./p' |
3644
# we now have a list, one entry per line, of the stringified
3645
# contents of the appropriate section of all members of the
3646
# archive which possess that section. Heuristic: eliminate
3647
# all those which have a first or second character that is
3648
# a '.' (that is, objdump's representation of an unprintable
3649
# character.) This should work for all archives with less than
3650
# 0x302f exports -- but will fail for DLLs whose name actually
3651
# begins with a literal '.' or a single character followed by
3652
# a '.'.
3653
#
3654
# Of those that remain, print the first one.
3655
$SED -e '/^\./d;/^.\./d;q'
3656
}
3657
3658
# func_cygming_gnu_implib_p ARG
3659
# This predicate returns with zero status (TRUE) if
3660
# ARG is a GNU/binutils-style import library. Returns
3661
# with nonzero status (FALSE) otherwise.
3662
func_cygming_gnu_implib_p ()
3663
{
3664
$opt_debug
3665
func_to_tool_file "$1" func_convert_file_msys_to_w32
3666
func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3667
test -n "$func_cygming_gnu_implib_tmp"
3668
}
3669
3670
# func_cygming_ms_implib_p ARG
3671
# This predicate returns with zero status (TRUE) if
3672
# ARG is an MS-style import library. Returns
3673
# with nonzero status (FALSE) otherwise.
3674
func_cygming_ms_implib_p ()
3675
{
3676
$opt_debug
3677
func_to_tool_file "$1" func_convert_file_msys_to_w32
3678
func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3679
test -n "$func_cygming_ms_implib_tmp"
3680
}
3681
3682
# func_cygming_dll_for_implib_fallback ARG
3683
# Platform-specific function to extract the
3684
# name of the DLL associated with the specified
3685
# import library ARG.
3686
#
3687
# This fallback implementation is for use when $DLLTOOL
3688
# does not support the --identify-strict option.
3689
# Invoked by eval'ing the libtool variable
3690
# $sharedlib_from_linklib_cmd
3691
# Result is available in the variable
3692
# $sharedlib_from_linklib_result
3693
func_cygming_dll_for_implib_fallback ()
3694
{
3695
$opt_debug
3696
if func_cygming_gnu_implib_p "$1" ; then
3697
# binutils import library
3698
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3699
elif func_cygming_ms_implib_p "$1" ; then
3700
# ms-generated import library
3701
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3702
else
3703
# unknown
3704
sharedlib_from_linklib_result=""
3705
fi
3706
}
3707
2593
3708
2594
3709
2595
# func_extract_an_archive dir oldlib
3712
2598
$opt_debug
3713
2599
f_ex_an_ar_dir="$1"; shift
3714
2600
f_ex_an_ar_oldlib="$1"
3715
if test "$lock_old_archive_extraction" = yes; then
3716
lockfile=$f_ex_an_ar_oldlib.lock
3717
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3718
func_echo "Waiting for $lockfile to be removed"
3719
sleep 2
3720
done
3721
fi
3722
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3723
'stat=$?; rm -f "$lockfile"; exit $stat'
3724
if test "$lock_old_archive_extraction" = yes; then
3725
$opt_dry_run || rm -f "$lockfile"
3726
fi
2601
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3727
2602
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3728
2603
:
3729
2604
else
3794
2669
darwin_file=
3795
2670
darwin_files=
3796
2671
for darwin_file in $darwin_filelist; do
3797
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
2672
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3798
2673
$LIPO -create -output "$darwin_file" $darwin_files
3799
2674
done # $darwin_filelist
3800
2675
$RM -rf unfat-$$
3809
2684
func_extract_an_archive "$my_xdir" "$my_xabs"
3810
2685
;;
3811
2686
esac
3812
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
2687
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3813
2688
done
3814
2689
3815
2690
func_extract_archives_result="$my_oldobjs"
3816
2691
}
3817
2692
3818
2693
3819
# func_emit_wrapper [arg=no]
3820
#
3821
# Emit a libtool wrapper script on stdout.
3822
# Don't directly open a file because we may want to
3823
# incorporate the script contents within a cygwin/mingw
3824
# wrapper executable. Must ONLY be called from within
3825
# func_mode_link because it depends on a number of variables
3826
# set therein.
3827
#
3828
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3829
# variable will take. If 'yes', then the emitted script
3830
# will assume that the directory in which it is stored is
3831
# the $objdir directory. This is a cygwin/mingw-specific
3832
# behavior.
3833
func_emit_wrapper ()
2694
2695
# func_emit_wrapper_part1 [arg=no]
2696
#
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 ()
3834
2701
{
3835
func_emit_wrapper_arg1=${1-no}
2702
func_emit_wrapper_part1_arg1=no
2703
if test -n "$1" ; then
2704
func_emit_wrapper_part1_arg1=$1
2705
fi
3836
2706
3837
2707
$ECHO "\
3838
2708
#! $SHELL
3848
2718
3849
2719
# Sed substitution that helps us do robust quoting. It backslashifies
3850
2720
# metacharacters that are still active within double-quoted strings.
2721
Xsed='${SED} -e 1s/^X//'
3851
2722
sed_quote_subst='$sed_quote_subst'
3852
2723
3853
2724
# Be Bourne compatible
3878
2749
else
3879
2750
# When we are sourced in execute mode, \$file and \$ECHO are already set.
3880
2751
if test \"\$libtool_execute_magic\" != \"$magic\"; then
3881
file=\"\$0\""
3882
3883
qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3884
$ECHO "\
3885
3886
# A function that is used when there is no print builtin or printf.
3887
func_fallback_echo ()
3888
{
3889
eval 'cat <<_LTECHO_EOF
3890
\$1
3891
_LTECHO_EOF'
3892
}
3893
ECHO=\"$qECHO\"
3894
fi
3895
3896
# Very basic option parsing. These options are (a) specific to
3897
# the libtool wrapper, (b) are identical between the wrapper
3898
# /script/ and the wrapper /executable/ which is used only on
3899
# windows platforms, and (c) all begin with the string "--lt-"
3900
# (application programs are unlikely to have options which match
3901
# this pattern).
3902
#
3903
# There are only two supported options: --lt-debug and
3904
# --lt-dump-script. There is, deliberately, no --lt-help.
3905
#
3906
# The first argument to this parsing function should be the
3907
# script's $0 value, followed by "$@".
3908
lt_option_debug=
3909
func_parse_lt_options ()
3910
{
3911
lt_script_arg0=\$0
3912
shift
3913
for lt_opt
3914
do
3915
case \"\$lt_opt\" in
3916
--lt-debug) lt_option_debug=1 ;;
3917
--lt-dump-script)
3918
lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3919
test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3920
lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3921
cat \"\$lt_dump_D/\$lt_dump_F\"
3922
exit 0
3923
;;
3924
--lt-*)
3925
\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3926
exit 1
3927
;;
3928
esac
3929
done
3930
3931
# Print the debug banner immediately:
3932
if test -n \"\$lt_option_debug\"; then
3933
echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3934
fi
3935
}
3936
3937
# Used when --lt-debug. Prints its arguments to stdout
3938
# (redirection is the responsibility of the caller)
3939
func_lt_dump_args ()
3940
{
3941
lt_dump_args_N=1;
3942
for lt_arg
3943
do
3944
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3945
lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3946
done
3947
}
3948
3949
# Core function for launching the target application
3950
func_exec_program_core ()
3951
{
3952
"
3953
case $host in
3954
# Backslashes separate directories on plain windows
3955
*-*-mingw | *-*-os2* | *-cegcc*)
3956
$ECHO "\
3957
if test -n \"\$lt_option_debug\"; then
3958
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3959
func_lt_dump_args \${1+\"\$@\"} 1>&2
3960
fi
3961
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3962
"
3963
;;
3964
3965
*)
3966
$ECHO "\
3967
if test -n \"\$lt_option_debug\"; then
3968
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3969
func_lt_dump_args \${1+\"\$@\"} 1>&2
3970
fi
3971
exec \"\$progdir/\$program\" \${1+\"\$@\"}
3972
"
3973
;;
3974
esac
3975
$ECHO "\
3976
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3977
exit 1
3978
}
3979
3980
# A function to encapsulate launching the target application
3981
# Strips options in the --lt-* namespace from \$@ and
3982
# launches target application with the remaining arguments.
3983
func_exec_program ()
3984
{
3985
for lt_wr_arg
3986
do
3987
case \$lt_wr_arg in
3988
--lt-*) ;;
3989
*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3990
esac
3991
shift
3992
done
3993
func_exec_program_core \${1+\"\$@\"}
3994
}
3995
3996
# Parse options
3997
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
2752
ECHO=\"$qecho\"
2753
file=\"\$0\"
2754
# Make sure echo works.
2755
if test \"X\$1\" = X--no-reexec; then
2756
# Discard the --no-reexec flag, and continue.
2757
shift
2758
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2759
# Yippee, \$ECHO works!
2760
:
2761
else
2762
# Restart under the correct shell, and then maybe \$ECHO will work.
2763
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2764
fi
2765
fi\
2766
"
2767
$ECHO "\
3998
2768
3999
2769
# Find the directory that this script lives in.
4000
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
2770
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4001
2771
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4002
2772
4003
2773
# Follow symbolic links until we get to the real thisdir.
4004
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
2774
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4005
2775
while test -n \"\$file\"; do
4006
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
2776
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4007
2777
4008
2778
# If there was a directory component, then change thisdir.
4009
2779
if test \"x\$destdir\" != \"x\$file\"; then
4013
2783
esac
4014
2784
fi
4015
2785
4016
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4017
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
2786
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4018
2788
done
2789
"
2790
}
2791
# end: func_emit_wrapper_part1
2792
2793
# func_emit_wrapper_part2 [arg=no]
2794
#
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 ()
2799
{
2800
func_emit_wrapper_part2_arg1=no
2801
if test -n "$1" ; then
2802
func_emit_wrapper_part2_arg1=$1
2803
fi
2804
2805
$ECHO "\
4019
2806
4020
2807
# Usually 'no', except on cygwin/mingw when embedded into
4021
2808
# the cwrapper.
4022
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
2809
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
4023
2810
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4024
2811
# special case for '.'
4025
2812
if test \"\$thisdir\" = \".\"; then
4027
2814
fi
4028
2815
# remove .libs from thisdir
4029
2816
case \"\$thisdir\" in
4030
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
2817
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
4031
2818
$objdir ) thisdir=. ;;
4032
2819
esac
4033
2820
fi
4082
2869
4083
2870
if test -f \"\$progdir/\$program\"; then"
4084
2871
4085
# fixup the dll searchpath if we need to.
4086
#
4087
# Fix the DLL searchpath if we need to. Do this before prepending
4088
# to shlibpath, because on Windows, both are PATH and uninstalled
4089
# libraries must come first.
4090
if test -n "$dllsearchpath"; then
4091
$ECHO "\
4092
# Add the dll search path components to the executable PATH
4093
PATH=$dllsearchpath:\$PATH
4094
"
4095
fi
4096
4097
2872
# Export our shlibpath_var if we have one.
4098
2873
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4099
2874
$ECHO "\
4102
2877
4103
2878
# Some systems cannot cope with colon-terminated $shlibpath_var
4104
2879
# The second colon is a workaround for a bug in BeOS R4 sed
4105
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
2880
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4106
2881
4107
2882
export $shlibpath_var
4108
2883
"
4109
2884
fi
4110
2885
2886
# fixup the dll searchpath if we need to.
2887
if test -n "$dllsearchpath"; then
2888
$ECHO "\
2889
# Add the dll search path components to the executable PATH
2890
PATH=$dllsearchpath:\$PATH
2891
"
2892
fi
2893
4111
2894
$ECHO "\
4112
2895
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4113
2896
# Run the actual program with our arguments.
4114
func_exec_program \${1+\"\$@\"}
2897
"
2898
case $host in
2899
# Backslashes separate directories on plain windows
2900
*-*-mingw | *-*-os2* | *-cegcc*)
2901
$ECHO "\
2902
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2903
"
2904
;;
2905
2906
*)
2907
$ECHO "\
2908
exec \"\$progdir/\$program\" \${1+\"\$@\"}
2909
"
2910
;;
2911
esac
2912
$ECHO "\
2913
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2914
exit 1
4115
2915
fi
4116
2916
else
4117
2917
# The program doesn't exist.
4118
2918
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4119
2919
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4120
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2920
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4121
2921
exit 1
4122
2922
fi
4123
2923
fi\
4124
2924
"
4125
2925
}
4126
2926
# end: func_emit_wrapper_part2
2927
2928
2929
# func_emit_wrapper [arg=no]
2930
#
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
2936
# set therein.
2937
#
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
2942
# behavior.
2943
func_emit_wrapper ()
2944
{
2945
func_emit_wrapper_arg1=no
2946
if test -n "$1" ; then
2947
func_emit_wrapper_arg1=$1
2948
fi
2949
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}"
2954
}
2955
2956
2957
# func_to_host_path arg
2958
#
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:
2963
# $build $host
2964
# mingw (msys) mingw [e.g. native]
2965
# cygwin mingw
2966
# *nix + wine mingw
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.
2974
#
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 ()
2979
{
2980
func_to_host_path_result="$1"
2981
if test -n "$1" ; then
2982
case $host in
2983
*mingw* )
2984
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2985
case $build in
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"`
2993
;;
2994
*cygwin* )
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"`
2998
;;
2999
* )
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"`
3011
else
3012
# Allow warning below.
3013
func_to_host_path_result=""
3014
fi
3015
;;
3016
esac
3017
if test -z "$func_to_host_path_result" ; then
3018
func_error "Could not determine host path corresponding to"
3019
func_error " '$1'"
3020
func_error "Continuing, but uninstalled executables may not work."
3021
# Fallback:
3022
func_to_host_path_result="$1"
3023
fi
3024
;;
3025
esac
3026
fi
3027
}
3028
# end: func_to_host_path
3029
3030
# func_to_host_pathlist arg
3031
#
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):
3036
# $build $host
3037
# mingw (msys) mingw [e.g. native]
3038
# cygwin mingw
3039
# *nix + wine mingw
3040
#
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)
3044
# on output.
3045
#
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 ()
3050
{
3051
func_to_host_pathlist_result="$1"
3052
if test -n "$1" ; then
3053
case $host in
3054
*mingw* )
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|:*$||'`
3064
case $build in
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"`
3072
;;
3073
*cygwin* )
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"`
3077
;;
3078
* )
3079
# unfortunately, winepath doesn't convert pathlists
3080
func_to_host_pathlist_result=""
3081
func_to_host_pathlist_oldIFS=$IFS
3082
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"
3090
else
3091
func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3092
fi
3093
fi
3094
fi
3095
IFS=:
3096
done
3097
IFS=$func_to_host_pathlist_oldIFS
3098
;;
3099
esac
3100
if test -z "$func_to_host_pathlist_result" ; then
3101
func_error "Could not determine the host path(s) corresponding to"
3102
func_error " '$1'"
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"`
3112
fi
3113
# Now, add the leading and trailing path separators back
3114
case "$1" in
3115
:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3116
;;
3117
esac
3118
case "$1" in
3119
*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3120
;;
3121
esac
3122
;;
3123
esac
3124
fi
3125
}
3126
# end: func_to_host_pathlist
4127
3127
4128
3128
# func_emit_cwrapperexe_src
4129
3129
# emit the source code for a wrapper executable on stdout
4141
3141
4142
3142
This wrapper executable should never be moved out of the build directory.
4143
3143
If it is, it will not operate correctly.
3144
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.
4144
3148
*/
4145
3149
EOF
4146
3150
cat <<"EOF"
4147
#ifdef _MSC_VER
4148
# define _CRT_SECURE_NO_DEPRECATE 1
4149
#endif
4150
3151
#include <stdio.h>
4151
3152
#include <stdlib.h>
4152
3153
#ifdef _MSC_VER
4153
3154
# include <direct.h>
4154
3155
# include <process.h>
4155
3156
# include <io.h>
3157
# define setmode _setmode
4156
3158
#else
4157
3159
# include <unistd.h>
4158
3160
# include <stdint.h>
4159
3161
# ifdef __CYGWIN__
4160
3162
# include <io.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);
3168
# endif
4161
3169
# endif
4162
3170
#endif
4163
3171
#include <malloc.h>
4169
3177
#include <fcntl.h>
4170
3178
#include <sys/stat.h>
4171
3179
4172
/* declarations of non-ANSI functions */
4173
#if defined(__MINGW32__)
4174
# ifdef __STRICT_ANSI__
4175
int _putenv (const char *);
4176
# endif
4177
#elif defined(__CYGWIN__)
4178
# ifdef __STRICT_ANSI__
4179
char *realpath (const char *, char *);
4180
int putenv (char *);
4181
int setenv (const char *, const char *, int);
4182
# endif
4183
/* #elif defined (other platforms) ... */
4184
#endif
4185
4186
/* portability defines, excluding path handling macros */
4187
#if defined(_MSC_VER)
4188
# define setmode _setmode
4189
# define stat _stat
4190
# define chmod _chmod
4191
# define getcwd _getcwd
4192
# define putenv _putenv
4193
# define S_IXUSR _S_IEXEC
4194
# ifndef _INTPTR_T_DEFINED
4195
# define _INTPTR_T_DEFINED
4196
# define intptr_t int
4197
# endif
4198
#elif defined(__MINGW32__)
4199
# define setmode _setmode
4200
# define stat _stat
4201
# define chmod _chmod
4202
# define getcwd _getcwd
4203
# define putenv _putenv
4204
#elif defined(__CYGWIN__)
4205
# define HAVE_SETENV
4206
# define FOPEN_WB "wb"
4207
/* #elif defined (other platforms) ... */
4208
#endif
4209
4210
3180
#if defined(PATH_MAX)
4211
3181
# define LT_PATHMAX PATH_MAX
4212
3182
#elif defined(MAXPATHLEN)
4222
3192
# define S_IXGRP 0
4223
3193
#endif
4224
3194
4225
/* path handling portability macros */
3195
#ifdef _MSC_VER
3196
# define S_IXUSR _S_IEXEC
3197
# define stat _stat
3198
# ifndef _INTPTR_T_DEFINED
3199
# define intptr_t int
3200
# endif
3201
#endif
3202
4226
3203
#ifndef DIR_SEPARATOR
4227
3204
# define DIR_SEPARATOR '/'
4228
3205
# define PATH_SEPARATOR ':'
4253
3230
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4254
3231
#endif /* PATH_SEPARATOR_2 */
4255
3232
3233
#ifdef __CYGWIN__
3234
# define FOPEN_WB "wb"
3235
#endif
3236
4256
3237
#ifndef FOPEN_WB
4257
3238
# define FOPEN_WB "w"
4258
3239
#endif
4265
3246
if (stale) { free ((void *) stale); stale = 0; } \
4266
3247
} while (0)
4267
3248
4268
#if defined(LT_DEBUGWRAPPER)
4269
static int lt_debug = 1;
3249
#undef LTWRAPPER_DEBUGPRINTF
3250
#if defined DEBUGWRAPPER
3251
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3252
static void
3253
ltwrapper_debugprintf (const char *fmt, ...)
3254
{
3255
va_list args;
3256
va_start (args, fmt);
3257
(void) vfprintf (stderr, fmt, args);
3258
va_end (args);
3259
}
4270
3260
#else
4271
static int lt_debug = 0;
3261
# define LTWRAPPER_DEBUGPRINTF(args)
4272
3262
#endif
4273
3263
4274
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
3264
const char *program_name = NULL;
4275
3265
4276
3266
void *xmalloc (size_t num);
4277
3267
char *xstrdup (const char *string);
4281
3271
int make_executable (const char *path);
4282
3272
int check_executable (const char *path);
4283
3273
char *strendzap (char *str, const char *pat);
4284
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4285
void lt_fatal (const char *file, int line, const char *message, ...);
4286
static const char *nonnull (const char *s);
4287
static const char *nonempty (const char *s);
3274
void lt_fatal (const char *message, ...);
4288
3275
void lt_setenv (const char *name, const char *value);
4289
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);
4290
3281
void lt_update_exe_path (const char *name, const char *value);
4291
3282
void lt_update_lib_path (const char *name, const char *value);
4292
char **prepare_spawn (char **argv);
4293
void lt_dump_script (FILE *f);
4294
EOF
4295
4296
cat <<EOF
4297
volatile const char * MAGIC_EXE = "$magic_exe";
3283
3284
static const char *script_text_part1 =
3285
EOF
3286
3287
func_emit_wrapper_part1 yes |
3288
$SED -e 's/\([\\"]\)/\\\1/g' \
3289
-e 's/^/ "/' -e 's/$/\\n"/'
3290
echo ";"
3291
cat <<EOF
3292
3293
static const char *script_text_part2 =
3294
EOF
3295
func_emit_wrapper_part2 yes |
3296
$SED -e 's/\([\\"]\)/\\\1/g' \
3297
-e 's/^/ "/' -e 's/$/\\n"/'
3298
echo ";"
3299
3300
cat <<EOF
3301
const char * MAGIC_EXE = "$magic_exe";
4298
3302
const char * LIB_PATH_VARNAME = "$shlibpath_var";
4299
3303
EOF
4300
3304
4301
3305
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4302
func_to_host_path "$temp_rpath"
3306
func_to_host_pathlist "$temp_rpath"
4303
3307
cat <<EOF
4304
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
3308
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
4305
3309
EOF
4306
3310
else
4307
3311
cat <<"EOF"
4310
3314
fi
4311
3315
4312
3316
if test -n "$dllsearchpath"; then
4313
func_to_host_path "$dllsearchpath:"
3317
func_to_host_pathlist "$dllsearchpath:"
4314
3318
cat <<EOF
4315
3319
const char * EXE_PATH_VARNAME = "PATH";
4316
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
3320
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
4317
3321
EOF
4318
3322
else
4319
3323
cat <<"EOF"
4336
3340
cat <<"EOF"
4337
3341
4338
3342
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3343
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
4339
3344
3345
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
4340
3346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3347
4341
3348
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4342
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
3349
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 */
3353
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} */
3357
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 */
4343
3361
4344
3362
int
4345
3363
main (int argc, char *argv[])
4356
3374
int i;
4357
3375
4358
3376
program_name = (char *) xstrdup (base_name (argv[0]));
4359
newargz = XMALLOC (char *, argc + 1);
3377
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3378
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
4360
3379
4361
/* very simple arg parsing; don't want to rely on getopt
4362
* also, copy all non cwrapper options to newargz, except
4363
* argz[0], which is handled differently
4364
*/
4365
newargc=0;
3380
/* very simple arg parsing; don't want to rely on getopt */
4366
3381
for (i = 1; i < argc; i++)
4367
3382
{
4368
3383
if (strcmp (argv[i], dumpscript_opt) == 0)
4376
3391
esac
4377
3392
4378
3393
cat <<"EOF"
4379
lt_dump_script (stdout);
3394
printf ("%s", script_text_part1);
3395
printf ("%s", script_text_part2);
4380
3396
return 0;
4381
3397
}
4382
if (strcmp (argv[i], debug_opt) == 0)
4383
{
4384
lt_debug = 1;
4385
continue;
4386
}
4387
if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4388
{
4389
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4390
namespace, but it is not one of the ones we know about and
4391
have already dealt with, above (inluding dump-script), then
4392
report an error. Otherwise, targets might begin to believe
4393
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4394
namespace. The first time any user complains about this, we'll
4395
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4396
or a configure.ac-settable value.
4397
*/
4398
lt_fatal (__FILE__, __LINE__,
4399
"unrecognized %s option: '%s'",
4400
ltwrapper_option_prefix, argv[i]);
4401
}
4402
/* otherwise ... */
4403
newargz[++newargc] = xstrdup (argv[i]);
4404
3398
}
4405
newargz[++newargc] = NULL;
4406
4407
EOF
4408
cat <<EOF
4409
/* The GNU banner must be the first non-error debug message */
4410
lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4411
EOF
4412
cat <<"EOF"
4413
lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4414
lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4415
3399
3400
newargz = XMALLOC (char *, argc + 1);
4416
3401
tmp_pathspec = find_executable (argv[0]);
4417
3402
if (tmp_pathspec == NULL)
4418
lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4419
lt_debugprintf (__FILE__, __LINE__,
4420
"(main) found exe (before symlink chase) at: %s\n",
4421
tmp_pathspec);
3403
lt_fatal ("Couldn't find %s", argv[0]);
3404
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3405
tmp_pathspec));
4422
3406
4423
3407
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4424
lt_debugprintf (__FILE__, __LINE__,
4425
"(main) found exe (after symlink chase) at: %s\n",
4426
actual_cwrapper_path);
3408
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409
actual_cwrapper_path));
4427
3410
XFREE (tmp_pathspec);
4428
3411
4429
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
3412
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
4430
3413
strendzap (actual_cwrapper_path, actual_cwrapper_name);
4431
3414
4432
3415
/* wrapper name transforms */
4444
3427
target_name = tmp_pathspec;
4445
3428
tmp_pathspec = 0;
4446
3429
4447
lt_debugprintf (__FILE__, __LINE__,
4448
"(main) libtool target name: %s\n",
4449
target_name);
3430
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3431
target_name));
4450
3432
EOF
4451
3433
4452
3434
cat <<EOF
4496
3478
4497
3479
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4498
3480
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4499
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4500
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4501
because on Windows, both *_VARNAMEs are PATH but uninstalled
4502
libraries must come first. */
3481
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4503
3482
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4504
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4505
4506
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4507
nonnull (lt_argv_zero));
3483
3484
newargc=0;
3485
for (i = 1; i < argc; i++)
3486
{
3487
if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3488
{
3489
if (argv[i][env_set_opt_len] == '=')
3490
{
3491
const char *p = argv[i] + env_set_opt_len + 1;
3492
lt_opt_process_env_set (p);
3493
}
3494
else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3495
{
3496
lt_opt_process_env_set (argv[++i]); /* don't copy */
3497
}
3498
else
3499
lt_fatal ("%s missing required argument", env_set_opt);
3500
continue;
3501
}
3502
if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3503
{
3504
if (argv[i][env_prepend_opt_len] == '=')
3505
{
3506
const char *p = argv[i] + env_prepend_opt_len + 1;
3507
lt_opt_process_env_prepend (p);
3508
}
3509
else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3510
{
3511
lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3512
}
3513
else
3514
lt_fatal ("%s missing required argument", env_prepend_opt);
3515
continue;
3516
}
3517
if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3518
{
3519
if (argv[i][env_append_opt_len] == '=')
3520
{
3521
const char *p = argv[i] + env_append_opt_len + 1;
3522
lt_opt_process_env_append (p);
3523
}
3524
else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3525
{
3526
lt_opt_process_env_append (argv[++i]); /* don't copy */
3527
}
3528
else
3529
lt_fatal ("%s missing required argument", env_append_opt);
3530
continue;
3531
}
3532
if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3533
{
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.
3542
*/
3543
lt_fatal ("Unrecognized option in %s namespace: '%s'",
3544
ltwrapper_option_prefix, argv[i]);
3545
}
3546
/* otherwise ... */
3547
newargz[++newargc] = xstrdup (argv[i]);
3548
}
3549
newargz[++newargc] = NULL;
3550
3551
LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
4508
3552
for (i = 0; i < newargc; i++)
4509
3553
{
4510
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4511
i, nonnull (newargz[i]));
3554
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4512
3555
}
4513
3556
4514
3557
EOF
4517
3560
mingw*)
4518
3561
cat <<"EOF"
4519
3562
/* execv doesn't actually work on mingw as expected on unix */
4520
newargz = prepare_spawn (newargz);
4521
3563
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4522
3564
if (rval == -1)
4523
3565
{
4524
3566
/* failed to start process */
4525
lt_debugprintf (__FILE__, __LINE__,
4526
"(main) failed to launch target \"%s\": %s\n",
4527
lt_argv_zero, nonnull (strerror (errno)));
3567
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4528
3568
return 127;
4529
3569
}
4530
3570
return rval;
4546
3586
{
4547
3587
void *p = (void *) malloc (num);
4548
3588
if (!p)
4549
lt_fatal (__FILE__, __LINE__, "memory exhausted");
3589
lt_fatal ("Memory exhausted");
4550
3590
4551
3591
return p;
4552
3592
}
4580
3620
{
4581
3621
struct stat st;
4582
3622
4583
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4584
nonempty (path));
3623
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3624
path ? (*path ? path : "EMPTY!") : "NULL!"));
4585
3625
if ((!path) || (!*path))
4586
3626
return 0;
4587
3627
4598
3638
int rval = 0;
4599
3639
struct stat st;
4600
3640
4601
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4602
nonempty (path));
3641
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3642
path ? (*path ? path : "EMPTY!") : "NULL!"));
4603
3643
if ((!path) || (!*path))
4604
3644
return 0;
4605
3645
4625
3665
int tmp_len;
4626
3666
char *concat_name;
4627
3667
4628
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4629
nonempty (wrapper));
3668
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3669
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4630
3670
4631
3671
if ((wrapper == NULL) || (*wrapper == '\0'))
4632
3672
return NULL;
4679
3719
{
4680
3720
/* empty path: current directory */
4681
3721
if (getcwd (tmp, LT_PATHMAX) == NULL)
4682
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4683
nonnull (strerror (errno)));
3722
lt_fatal ("getcwd failed");
4684
3723
tmp_len = strlen (tmp);
4685
3724
concat_name =
4686
3725
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4705
3744
}
4706
3745
/* Relative path | not found in path: prepend cwd */
4707
3746
if (getcwd (tmp, LT_PATHMAX) == NULL)
4708
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4709
nonnull (strerror (errno)));
3747
lt_fatal ("getcwd failed");
4710
3748
tmp_len = strlen (tmp);
4711
3749
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4712
3750
memcpy (concat_name, tmp, tmp_len);
4732
3770
int has_symlinks = 0;
4733
3771
while (strlen (tmp_pathspec) && !has_symlinks)
4734
3772
{
4735
lt_debugprintf (__FILE__, __LINE__,
4736
"checking path component for symlinks: %s\n",
4737
tmp_pathspec);
3773
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3774
tmp_pathspec));
4738
3775
if (lstat (tmp_pathspec, &s) == 0)
4739
3776
{
4740
3777
if (S_ISLNK (s.st_mode) != 0)
4756
3793
}
4757
3794
else
4758
3795
{
4759
lt_fatal (__FILE__, __LINE__,
4760
"error accessing file \"%s\": %s",
4761
tmp_pathspec, nonnull (strerror (errno)));
3796
char *errstr = strerror (errno);
3797
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4762
3798
}
4763
3799
}
4764
3800
XFREE (tmp_pathspec);
4771
3807
tmp_pathspec = realpath (pathspec, buf);
4772
3808
if (tmp_pathspec == 0)
4773
3809
{
4774
lt_fatal (__FILE__, __LINE__,
4775
"could not follow symlinks for %s", pathspec);
3810
lt_fatal ("Could not follow symlinks for %s", pathspec);
4776
3811
}
4777
3812
return xstrdup (tmp_pathspec);
4778
3813
#endif
4798
3833
return str;
4799
3834
}
4800
3835
4801
void
4802
lt_debugprintf (const char *file, int line, const char *fmt, ...)
4803
{
4804
va_list args;
4805
if (lt_debug)
4806
{
4807
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4808
va_start (args, fmt);
4809
(void) vfprintf (stderr, fmt, args);
4810
va_end (args);
4811
}
4812
}
4813
4814
3836
static void
4815
lt_error_core (int exit_status, const char *file,
4816
int line, const char *mode,
3837
lt_error_core (int exit_status, const char *mode,
4817
3838
const char *message, va_list ap)
4818
3839
{
4819
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
3840
fprintf (stderr, "%s: %s: ", program_name, mode);
4820
3841
vfprintf (stderr, message, ap);
4821
3842
fprintf (stderr, ".\n");
4822
3843
4825
3846
}
4826
3847
4827
3848
void
4828
lt_fatal (const char *file, int line, const char *message, ...)
3849
lt_fatal (const char *message, ...)
4829
3850
{
4830
3851
va_list ap;
4831
3852
va_start (ap, message);
4832
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
3853
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4833
3854
va_end (ap);
4834
3855
}
4835
3856
4836
static const char *
4837
nonnull (const char *s)
4838
{
4839
return s ? s : "(null)";
4840
}
4841
4842
static const char *
4843
nonempty (const char *s)
4844
{
4845
return (s && !*s) ? "(empty)" : nonnull (s);
4846
}
4847
4848
3857
void
4849
3858
lt_setenv (const char *name, const char *value)
4850
3859
{
4851
lt_debugprintf (__FILE__, __LINE__,
4852
"(lt_setenv) setting '%s' to '%s'\n",
4853
nonnull (name), nonnull (value));
3860
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861
(name ? name : "<NULL>"),
3862
(value ? value : "<NULL>")));
4854
3863
{
4855
3864
#ifdef HAVE_SETENV
4856
3865
/* always make a copy, for consistency with !HAVE_SETENV */
4895
3904
return new_value;
4896
3905
}
4897
3906
3907
int
3908
lt_split_name_value (const char *arg, char** name, char** value)
3909
{
3910
const char *p;
3911
int len;
3912
if (!arg || !*arg)
3913
return 1;
3914
3915
p = strchr (arg, (int)'=');
3916
3917
if (!p)
3918
return 1;
3919
3920
*value = xstrdup (++p);
3921
3922
len = strlen (arg) - strlen (*value);
3923
*name = XMALLOC (char, len);
3924
strncpy (*name, arg, len-1);
3925
(*name)[len - 1] = '\0';
3926
3927
return 0;
3928
}
3929
3930
void
3931
lt_opt_process_env_set (const char *arg)
3932
{
3933
char *name = NULL;
3934
char *value = NULL;
3935
3936
if (lt_split_name_value (arg, &name, &value) != 0)
3937
{
3938
XFREE (name);
3939
XFREE (value);
3940
lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3941
}
3942
3943
lt_setenv (name, value);
3944
XFREE (name);
3945
XFREE (value);
3946
}
3947
3948
void
3949
lt_opt_process_env_prepend (const char *arg)
3950
{
3951
char *name = NULL;
3952
char *value = NULL;
3953
char *new_value = NULL;
3954
3955
if (lt_split_name_value (arg, &name, &value) != 0)
3956
{
3957
XFREE (name);
3958
XFREE (value);
3959
lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3960
}
3961
3962
new_value = lt_extend_str (getenv (name), value, 0);
3963
lt_setenv (name, new_value);
3964
XFREE (new_value);
3965
XFREE (name);
3966
XFREE (value);
3967
}
3968
3969
void
3970
lt_opt_process_env_append (const char *arg)
3971
{
3972
char *name = NULL;
3973
char *value = NULL;
3974
char *new_value = NULL;
3975
3976
if (lt_split_name_value (arg, &name, &value) != 0)
3977
{
3978
XFREE (name);
3979
XFREE (value);
3980
lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3981
}
3982
3983
new_value = lt_extend_str (getenv (name), value, 1);
3984
lt_setenv (name, new_value);
3985
XFREE (new_value);
3986
XFREE (name);
3987
XFREE (value);
3988
}
3989
4898
3990
void
4899
3991
lt_update_exe_path (const char *name, const char *value)
4900
3992
{
4901
lt_debugprintf (__FILE__, __LINE__,
4902
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4903
nonnull (name), nonnull (value));
3993
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994
(name ? name : "<NULL>"),
3995
(value ? value : "<NULL>")));
4904
3996
4905
3997
if (name && *name && value && *value)
4906
3998
{
4919
4011
void
4920
4012
lt_update_lib_path (const char *name, const char *value)
4921
4013
{
4922
lt_debugprintf (__FILE__, __LINE__,
4923
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4924
nonnull (name), nonnull (value));
4014
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015
(name ? name : "<NULL>"),
4016
(value ? value : "<NULL>")));
4925
4017
4926
4018
if (name && *name && value && *value)
4927
4019
{
4931
4023
}
4932
4024
}
4933
4025
4934
EOF
4935
case $host_os in
4936
mingw*)
4937
cat <<"EOF"
4938
4939
/* Prepares an argument vector before calling spawn().
4940
Note that spawn() does not by itself call the command interpreter
4941
(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4942
({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4943
GetVersionEx(&v);
4944
v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4945
}) ? "cmd.exe" : "command.com").
4946
Instead it simply concatenates the arguments, separated by ' ', and calls
4947
CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4948
interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4949
special way:
4950
- Space and tab are interpreted as delimiters. They are not treated as
4951
delimiters if they are surrounded by double quotes: "...".
4952
- Unescaped double quotes are removed from the input. Their only effect is
4953
that within double quotes, space and tab are treated like normal
4954
characters.
4955
- Backslashes not followed by double quotes are not special.
4956
- But 2*n+1 backslashes followed by a double quote become
4957
n backslashes followed by a double quote (n >= 0):
4958
\" -> "
4959
\\\" -> \"
4960
\\\\\" -> \\"
4961
*/
4962
#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4963
#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4964
char **
4965
prepare_spawn (char **argv)
4966
{
4967
size_t argc;
4968
char **new_argv;
4969
size_t i;
4970
4971
/* Count number of arguments. */
4972
for (argc = 0; argv[argc] != NULL; argc++)
4973
;
4974
4975
/* Allocate new argument vector. */
4976
new_argv = XMALLOC (char *, argc + 1);
4977
4978
/* Put quoted arguments into the new argument vector. */
4979
for (i = 0; i < argc; i++)
4980
{
4981
const char *string = argv[i];
4982
4983
if (string[0] == '\0')
4984
new_argv[i] = xstrdup ("\"\"");
4985
else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4986
{
4987
int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4988
size_t length;
4989
unsigned int backslashes;
4990
const char *s;
4991
char *quoted_string;
4992
char *p;
4993
4994
length = 0;
4995
backslashes = 0;
4996
if (quote_around)
4997
length++;
4998
for (s = string; *s != '\0'; s++)
4999
{
5000
char c = *s;
5001
if (c == '"')
5002
length += backslashes + 1;
5003
length++;
5004
if (c == '\\')
5005
backslashes++;
5006
else
5007
backslashes = 0;
5008
}
5009
if (quote_around)
5010
length += backslashes + 1;
5011
5012
quoted_string = XMALLOC (char, length + 1);
5013
5014
p = quoted_string;
5015
backslashes = 0;
5016
if (quote_around)
5017
*p++ = '"';
5018
for (s = string; *s != '\0'; s++)
5019
{
5020
char c = *s;
5021
if (c == '"')
5022
{
5023
unsigned int j;
5024
for (j = backslashes + 1; j > 0; j--)
5025
*p++ = '\\';
5026
}
5027
*p++ = c;
5028
if (c == '\\')
5029
backslashes++;
5030
else
5031
backslashes = 0;
5032
}
5033
if (quote_around)
5034
{
5035
unsigned int j;
5036
for (j = backslashes; j > 0; j--)
5037
*p++ = '\\';
5038
*p++ = '"';
5039
}
5040
*p = '\0';
5041
5042
new_argv[i] = quoted_string;
5043
}
5044
else
5045
new_argv[i] = (char *) string;
5046
}
5047
new_argv[argc] = NULL;
5048
5049
return new_argv;
5050
}
5051
EOF
5052
;;
5053
esac
5054
5055
cat <<"EOF"
5056
void lt_dump_script (FILE* f)
5057
{
5058
EOF
5059
func_emit_wrapper yes |
5060
$SED -e 's/\([\\"]\)/\\\1/g' \
5061
-e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
5062
5063
cat <<"EOF"
5064
}
4026
5065
4027
EOF
5066
4028
}
5067
4029
# end: func_emit_cwrapperexe_src
5068
4030
5069
# func_win32_import_lib_p ARG
5070
# True if ARG is an import lib, as indicated by $file_magic_cmd
5071
func_win32_import_lib_p ()
5072
{
5073
$opt_debug
5074
case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5075
*import*) : ;;
5076
*) false ;;
5077
esac
5078
}
5079
5080
4031
# func_mode_link arg...
5081
4032
func_mode_link ()
5082
4033
{
5121
4072
new_inherited_linker_flags=
5122
4073
5123
4074
avoid_version=no
5124
bindir=
5125
4075
dlfiles=
5126
4076
dlprefiles=
5127
4077
dlself=no
5214
4164
esac
5215
4165
5216
4166
case $prev in
5217
bindir)
5218
bindir="$arg"
5219
prev=
5220
continue
5221
;;
5222
4167
dlfiles|dlprefiles)
5223
4168
if test "$preload" = no; then
5224
4169
# Add the symbol object into the linking commands.
5250
4195
;;
5251
4196
*)
5252
4197
if test "$prev" = dlfiles; then
5253
func_append dlfiles " $arg"
4198
dlfiles="$dlfiles $arg"
5254
4199
else
5255
func_append dlprefiles " $arg"
4200
dlprefiles="$dlprefiles $arg"
5256
4201
fi
5257
4202
prev=
5258
4203
continue
5276
4221
*-*-darwin*)
5277
4222
case "$deplibs " in
5278
4223
*" $qarg.ltframework "*) ;;
5279
*) func_append deplibs " $qarg.ltframework" # this is fixed later
4224
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
5280
4225
;;
5281
4226
esac
5282
4227
;;
5295
4240
moreargs=
5296
4241
for fil in `cat "$save_arg"`
5297
4242
do
5298
# func_append moreargs " $fil"
4243
# moreargs="$moreargs $fil"
5299
4244
arg=$fil
5300
4245
# A libtool-controlled object.
5301
4246
5324
4269
5325
4270
if test "$prev" = dlfiles; then
5326
4271
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5327
func_append dlfiles " $pic_object"
4272
dlfiles="$dlfiles $pic_object"
5328
4273
prev=
5329
4274
continue
5330
4275
else
5336
4281
# CHECK ME: I think I busted this. -Ossama
5337
4282
if test "$prev" = dlprefiles; then
5338
4283
# Preload the old-style object.
5339
func_append dlprefiles " $pic_object"
4284
dlprefiles="$dlprefiles $pic_object"
5340
4285
prev=
5341
4286
fi
5342
4287
5406
4351
if test "$prev" = rpath; then
5407
4352
case "$rpath " in
5408
4353
*" $arg "*) ;;
5409
*) func_append rpath " $arg" ;;
4354
*) rpath="$rpath $arg" ;;
5410
4355
esac
5411
4356
else
5412
4357
case "$xrpath " in
5413
4358
*" $arg "*) ;;
5414
*) func_append xrpath " $arg" ;;
4359
*) xrpath="$xrpath $arg" ;;
5415
4360
esac
5416
4361
fi
5417
4362
prev=
5423
4368
continue
5424
4369
;;
5425
4370
weak)
5426
func_append weak_libs " $arg"
4371
weak_libs="$weak_libs $arg"
5427
4372
prev=
5428
4373
continue
5429
4374
;;
5430
4375
xcclinker)
5431
func_append linker_flags " $qarg"
5432
func_append compiler_flags " $qarg"
4376
linker_flags="$linker_flags $qarg"
4377
compiler_flags="$compiler_flags $qarg"
5433
4378
prev=
5434
4379
func_append compile_command " $qarg"
5435
4380
func_append finalize_command " $qarg"
5436
4381
continue
5437
4382
;;
5438
4383
xcompiler)
5439
func_append compiler_flags " $qarg"
4384
compiler_flags="$compiler_flags $qarg"
5440
4385
prev=
5441
4386
func_append compile_command " $qarg"
5442
4387
func_append finalize_command " $qarg"
5443
4388
continue
5444
4389
;;
5445
4390
xlinker)
5446
func_append linker_flags " $qarg"
5447
func_append compiler_flags " $wl$qarg"
4391
linker_flags="$linker_flags $qarg"
4392
compiler_flags="$compiler_flags $wl$qarg"
5448
4393
prev=
5449
4394
func_append compile_command " $wl$qarg"
5450
4395
func_append finalize_command " $wl$qarg"
5480
4425
continue
5481
4426
;;
5482
4427
5483
-bindir)
5484
prev=bindir
5485
continue
5486
;;
5487
5488
4428
-dlopen)
5489
4429
prev=dlfiles
5490
4430
continue
5535
4475
;;
5536
4476
5537
4477
-L*)
5538
func_stripname "-L" '' "$arg"
5539
if test -z "$func_stripname_result"; then
4478
func_stripname '-L' '' "$arg"
4479
dir=$func_stripname_result
4480
if test -z "$dir"; then
5540
4481
if test "$#" -gt 0; then
5541
4482
func_fatal_error "require no space between \`-L' and \`$1'"
5542
4483
else
5543
4484
func_fatal_error "need path for \`-L' option"
5544
4485
fi
5545
4486
fi
5546
func_resolve_sysroot "$func_stripname_result"
5547
dir=$func_resolve_sysroot_result
5548
4487
# We need an absolute path.
5549
4488
case $dir in
5550
4489
[\\/]* | [A-Za-z]:[\\/]*) ;;
5556
4495
;;
5557
4496
esac
5558
4497
case "$deplibs " in
5559
*" -L$dir "* | *" $arg "*)
5560
# Will only happen for absolute or sysroot arguments
5561
;;
4498
*" -L$dir "*) ;;
5562
4499
*)
5563
# Preserve sysroot, but never include relative directories
5564
case $dir in
5565
[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5566
*) func_append deplibs " -L$dir" ;;
5567
esac
5568
func_append lib_search_path " $dir"
4500
deplibs="$deplibs -L$dir"
4501
lib_search_path="$lib_search_path $dir"
5569
4502
;;
5570
4503
esac
5571
4504
case $host in
5572
4505
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5573
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4506
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
5574
4507
case :$dllsearchpath: in
5575
4508
*":$dir:"*) ;;
5576
4509
::) dllsearchpath=$dir;;
5577
*) func_append dllsearchpath ":$dir";;
4510
*) dllsearchpath="$dllsearchpath:$dir";;
5578
4511
esac
5579
4512
case :$dllsearchpath: in
5580
4513
*":$testbindir:"*) ;;
5581
4514
::) dllsearchpath=$testbindir;;
5582
*) func_append dllsearchpath ":$testbindir";;
4515
*) dllsearchpath="$dllsearchpath:$testbindir";;
5583
4516
esac
5584
4517
;;
5585
4518
esac
5589
4522
-l*)
5590
4523
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5591
4524
case $host in
5592
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4525
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5593
4526
# These systems don't actually have a C or math library (as such)
5594
4527
continue
5595
4528
;;
5603
4536
;;
5604
4537
*-*-rhapsody* | *-*-darwin1.[012])
5605
4538
# Rhapsody C and math libraries are in the System framework
5606
func_append deplibs " System.ltframework"
4539
deplibs="$deplibs System.ltframework"
5607
4540
continue
5608
4541
;;
5609
4542
*-*-sco3.2v5* | *-*-sco5v6*)
5623
4556
;;
5624
4557
esac
5625
4558
fi
5626
func_append deplibs " $arg"
4559
deplibs="$deplibs $arg"
5627
4560
continue
5628
4561
;;
5629
4562
5635
4568
# Tru64 UNIX uses -model [arg] to determine the layout of C++
5636
4569
# classes, name mangling, and exception handling.
5637
4570
# Darwin uses the -arch flag to determine output architecture.
5638
-model|-arch|-isysroot|--sysroot)
5639
func_append compiler_flags " $arg"
4571
-model|-arch|-isysroot)
4572
compiler_flags="$compiler_flags $arg"
5640
4573
func_append compile_command " $arg"
5641
4574
func_append finalize_command " $arg"
5642
4575
prev=xcompiler
5644
4577
;;
5645
4578
5646
4579
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5647
func_append compiler_flags " $arg"
4580
compiler_flags="$compiler_flags $arg"
5648
4581
func_append compile_command " $arg"
5649
4582
func_append finalize_command " $arg"
5650
4583
case "$new_inherited_linker_flags " in
5651
4584
*" $arg "*) ;;
5652
* ) func_append new_inherited_linker_flags " $arg" ;;
4585
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5653
4586
esac
5654
4587
continue
5655
4588
;;
5716
4649
# We need an absolute path.
5717
4650
case $dir in
5718
4651
[\\/]* | [A-Za-z]:[\\/]*) ;;
5719
=*)
5720
func_stripname '=' '' "$dir"
5721
dir=$lt_sysroot$func_stripname_result
5722
;;
5723
4652
*)
5724
4653
func_fatal_error "only absolute run-paths are allowed"
5725
4654
;;
5726
4655
esac
5727
4656
case "$xrpath " in
5728
4657
*" $dir "*) ;;
5729
*) func_append xrpath " $dir" ;;
4658
*) xrpath="$xrpath $dir" ;;
5730
4659
esac
5731
4660
continue
5732
4661
;;
5779
4708
for flag in $args; do
5780
4709
IFS="$save_ifs"
5781
4710
func_quote_for_eval "$flag"
5782
func_append arg " $func_quote_for_eval_result"
5783
func_append compiler_flags " $func_quote_for_eval_result"
4711
arg="$arg $wl$func_quote_for_eval_result"
4712
compiler_flags="$compiler_flags $func_quote_for_eval_result"
5784
4713
done
5785
4714
IFS="$save_ifs"
5786
4715
func_stripname ' ' '' "$arg"
5795
4724
for flag in $args; do
5796
4725
IFS="$save_ifs"
5797
4726
func_quote_for_eval "$flag"
5798
func_append arg " $wl$func_quote_for_eval_result"
5799
func_append compiler_flags " $wl$func_quote_for_eval_result"
5800
func_append linker_flags " $func_quote_for_eval_result"
4727
arg="$arg $wl$func_quote_for_eval_result"
4728
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4729
linker_flags="$linker_flags $func_quote_for_eval_result"
5801
4730
done
5802
4731
IFS="$save_ifs"
5803
4732
func_stripname ' ' '' "$arg"
5825
4754
arg="$func_quote_for_eval_result"
5826
4755
;;
5827
4756
5828
# Flags to be passed through unchanged, with rationale:
5829
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5830
# -r[0-9][0-9]* specify processor for the SGI compiler
5831
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5832
# +DA*, +DD* enable 64-bit mode for the HP compiler
5833
# -q* compiler args for the IBM compiler
5834
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5835
# -F/path path to uninstalled frameworks, gcc on darwin
5836
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5837
# @file GCC response files
5838
# -tp=* Portland pgcc target processor selection
5839
# --sysroot=* for sysroot support
5840
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
4757
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4758
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4759
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4760
# +DA*, +DD* enable 64-bit mode on the HP compiler
4761
# -q* pass through compiler args for the IBM compiler
4762
# -m*, -t[45]*, -txscale* pass through architecture-specific
4763
# compiler args for GCC
4764
# -F/path gives path to uninstalled frameworks, gcc on darwin
4765
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4766
# @file GCC response files
5841
4767
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5842
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5843
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
4768
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5844
4769
func_quote_for_eval "$arg"
5845
4770
arg="$func_quote_for_eval_result"
5846
4771
func_append compile_command " $arg"
5847
4772
func_append finalize_command " $arg"
5848
func_append compiler_flags " $arg"
4773
compiler_flags="$compiler_flags $arg"
5849
4774
continue
5850
4775
;;
5851
4776
5857
4782
5858
4783
*.$objext)
5859
4784
# A standard object.
5860
func_append objs " $arg"
4785
objs="$objs $arg"
5861
4786
;;
5862
4787
5863
4788
*.lo)
5888
4813
5889
4814
if test "$prev" = dlfiles; then
5890
4815
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5891
func_append dlfiles " $pic_object"
4816
dlfiles="$dlfiles $pic_object"
5892
4817
prev=
5893
4818
continue
5894
4819
else
5900
4825
# CHECK ME: I think I busted this. -Ossama
5901
4826
if test "$prev" = dlprefiles; then
5902
4827
# Preload the old-style object.
5903
func_append dlprefiles " $pic_object"
4828
dlprefiles="$dlprefiles $pic_object"
5904
4829
prev=
5905
4830
fi
5906
4831
5945
4870
5946
4871
*.$libext)
5947
4872
# An archive.
5948
func_append deplibs " $arg"
5949
func_append old_deplibs " $arg"
4873
deplibs="$deplibs $arg"
4874
old_deplibs="$old_deplibs $arg"
5950
4875
continue
5951
4876
;;
5952
4877
5953
4878
*.la)
5954
4879
# A libtool-controlled library.
5955
4880
5956
func_resolve_sysroot "$arg"
5957
4881
if test "$prev" = dlfiles; then
5958
4882
# This library was specified with -dlopen.
5959
func_append dlfiles " $func_resolve_sysroot_result"
4883
dlfiles="$dlfiles $arg"
5960
4884
prev=
5961
4885
elif test "$prev" = dlprefiles; then
5962
4886
# The library was specified with -dlpreopen.
5963
func_append dlprefiles " $func_resolve_sysroot_result"
4887
dlprefiles="$dlprefiles $arg"
5964
4888
prev=
5965
4889
else
5966
func_append deplibs " $func_resolve_sysroot_result"
4890
deplibs="$deplibs $arg"
5967
4891
fi
5968
4892
continue
5969
4893
;;
6001
4925
6002
4926
if test -n "$shlibpath_var"; then
6003
4927
# get the directories listed in $shlibpath_var
6004
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
4928
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
6005
4929
else
6006
4930
shlib_search_path=
6007
4931
fi
6010
4934
6011
4935
func_dirname "$output" "/" ""
6012
4936
output_objdir="$func_dirname_result$objdir"
6013
func_to_tool_file "$output_objdir/"
6014
tool_output_objdir=$func_to_tool_file_result
6015
4937
# Create the object directory.
6016
4938
func_mkdir_p "$output_objdir"
6017
4939
6032
4954
# Find all interdependent deplibs by searching for libraries
6033
4955
# that are linked more than once (e.g. -la -lb -la)
6034
4956
for deplib in $deplibs; do
6035
if $opt_preserve_dup_deps ; then
4957
if $opt_duplicate_deps ; then
6036
4958
case "$libs " in
6037
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
4959
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6038
4960
esac
6039
4961
fi
6040
func_append libs " $deplib"
4962
libs="$libs $deplib"
6041
4963
done
6042
4964
6043
4965
if test "$linkmode" = lib; then
6050
4972
if $opt_duplicate_compiler_generated_deps; then
6051
4973
for pre_post_dep in $predeps $postdeps; do
6052
4974
case "$pre_post_deps " in
6053
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
4975
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
6054
4976
esac
6055
func_append pre_post_deps " $pre_post_dep"
4977
pre_post_deps="$pre_post_deps $pre_post_dep"
6056
4978
done
6057
4979
fi
6058
4980
pre_post_deps=
6111
5033
case $pass in
6112
5034
dlopen) libs="$dlfiles" ;;
6113
5035
dlpreopen) libs="$dlprefiles" ;;
6114
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5036
link)
5037
libs="$deplibs %DEPLIBS%"
5038
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
5039
;;
6115
5040
esac
6116
5041
fi
6117
5042
if test "$linkmode,$pass" = "lib,dlpreopen"; then
6119
5044
for lib in $dlprefiles; do
6120
5045
# Ignore non-libtool-libs
6121
5046
dependency_libs=
6122
func_resolve_sysroot "$lib"
6123
5047
case $lib in
6124
*.la) func_source "$func_resolve_sysroot_result" ;;
5048
*.la) func_source "$lib" ;;
6125
5049
esac
6126
5050
6127
5051
# Collect preopened libtool deplibs, except any this library
6128
5052
# has declared as weak libs
6129
5053
for deplib in $dependency_libs; do
6130
func_basename "$deplib"
6131
deplib_base=$func_basename_result
5054
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
6132
5055
case " $weak_libs " in
6133
5056
*" $deplib_base "*) ;;
6134
*) func_append deplibs " $deplib" ;;
5057
*) deplibs="$deplibs $deplib" ;;
6135
5058
esac
6136
5059
done
6137
5060
done
6152
5075
compile_deplibs="$deplib $compile_deplibs"
6153
5076
finalize_deplibs="$deplib $finalize_deplibs"
6154
5077
else
6155
func_append compiler_flags " $deplib"
5078
compiler_flags="$compiler_flags $deplib"
6156
5079
if test "$linkmode" = lib ; then
6157
5080
case "$new_inherited_linker_flags " in
6158
5081
*" $deplib "*) ;;
6159
* ) func_append new_inherited_linker_flags " $deplib" ;;
5082
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6160
5083
esac
6161
5084
fi
6162
5085
fi
6241
5164
if test "$linkmode" = lib ; then
6242
5165
case "$new_inherited_linker_flags " in
6243
5166
*" $deplib "*) ;;
6244
* ) func_append new_inherited_linker_flags " $deplib" ;;
5167
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6245
5168
esac
6246
5169
fi
6247
5170
fi
6254
5177
test "$pass" = conv && continue
6255
5178
newdependency_libs="$deplib $newdependency_libs"
6256
5179
func_stripname '-L' '' "$deplib"
6257
func_resolve_sysroot "$func_stripname_result"
6258
func_append newlib_search_path " $func_resolve_sysroot_result"
5180
newlib_search_path="$newlib_search_path $func_stripname_result"
6259
5181
;;
6260
5182
prog)
6261
5183
if test "$pass" = conv; then
6269
5191
finalize_deplibs="$deplib $finalize_deplibs"
6270
5192
fi
6271
5193
func_stripname '-L' '' "$deplib"
6272
func_resolve_sysroot "$func_stripname_result"
6273
func_append newlib_search_path " $func_resolve_sysroot_result"
5194
newlib_search_path="$newlib_search_path $func_stripname_result"
6274
5195
;;
6275
5196
*)
6276
5197
func_warning "\`-L' is ignored for archives/objects"
6281
5202
-R*)
6282
5203
if test "$pass" = link; then
6283
5204
func_stripname '-R' '' "$deplib"
6284
func_resolve_sysroot "$func_stripname_result"
6285
dir=$func_resolve_sysroot_result
5205
dir=$func_stripname_result
6286
5206
# Make sure the xrpath contains only unique directories.
6287
5207
case "$xrpath " in
6288
5208
*" $dir "*) ;;
6289
*) func_append xrpath " $dir" ;;
5209
*) xrpath="$xrpath $dir" ;;
6290
5210
esac
6291
5211
fi
6292
5212
deplibs="$deplib $deplibs"
6293
5213
continue
6294
5214
;;
6295
*.la)
6296
func_resolve_sysroot "$deplib"
6297
lib=$func_resolve_sysroot_result
6298
;;
5215
*.la) lib="$deplib" ;;
6299
5216
*.$libext)
6300
5217
if test "$pass" = conv; then
6301
5218
deplibs="$deplib $deplibs"
6313
5230
match_pattern*)
6314
5231
set dummy $deplibs_check_method; shift
6315
5232
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6316
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5233
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
6317
5234
| $EGREP "$match_pattern_regex" > /dev/null; then
6318
5235
valid_a_lib=yes
6319
5236
fi
6323
5240
;;
6324
5241
esac
6325
5242
if test "$valid_a_lib" != yes; then
6326
echo
5243
$ECHO
6327
5244
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
6328
echo "*** I have the capability to make that library automatically link in when"
6329
echo "*** you link to this library. But I can only do this if you have a"
6330
echo "*** shared version of the library, which you do not appear to have"
6331
echo "*** because the file extensions .$libext of this argument makes me believe"
6332
echo "*** that it is just a static archive that I should not use here."
5245
$ECHO "*** I have the capability to make that library automatically link in when"
5246
$ECHO "*** you link to this library. But I can only do this if you have a"
5247
$ECHO "*** shared version of the library, which you do not appear to have"
5248
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5249
$ECHO "*** that it is just a static archive that I should not use here."
6333
5250
else
6334
echo
5251
$ECHO
6335
5252
$ECHO "*** Warning: Linking the shared library $output against the"
6336
5253
$ECHO "*** static library $deplib is not portable!"
6337
5254
deplibs="$deplib $deplibs"
6358
5275
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6359
5276
# If there is no dlopen support or we're linking statically,
6360
5277
# we need to preload.
6361
func_append newdlprefiles " $deplib"
5278
newdlprefiles="$newdlprefiles $deplib"
6362
5279
compile_deplibs="$deplib $compile_deplibs"
6363
5280
finalize_deplibs="$deplib $finalize_deplibs"
6364
5281
else
6365
func_append newdlfiles " $deplib"
5282
newdlfiles="$newdlfiles $deplib"
6366
5283
fi
6367
5284
fi
6368
5285
continue
6404
5321
6405
5322
# Convert "-framework foo" to "foo.ltframework"
6406
5323
if test -n "$inherited_linker_flags"; then
6407
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5324
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
6408
5325
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6409
5326
case " $new_inherited_linker_flags " in
6410
5327
*" $tmp_inherited_linker_flag "*) ;;
6411
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
5328
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
6412
5329
esac
6413
5330
done
6414
5331
fi
6415
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5332
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6416
5333
if test "$linkmode,$pass" = "lib,link" ||
6417
5334
test "$linkmode,$pass" = "prog,scan" ||
6418
5335
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
6419
test -n "$dlopen" && func_append dlfiles " $dlopen"
6420
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
5336
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5337
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
6421
5338
fi
6422
5339
6423
5340
if test "$pass" = conv; then
6428
5345
func_fatal_error "cannot find name of link library for \`$lib'"
6429
5346
fi
6430
5347
# It is a libtool convenience library, so add in its objects.
6431
func_append convenience " $ladir/$objdir/$old_library"
6432
func_append old_convenience " $ladir/$objdir/$old_library"
5348
convenience="$convenience $ladir/$objdir/$old_library"
5349
old_convenience="$old_convenience $ladir/$objdir/$old_library"
5350
tmp_libs=
5351
for deplib in $dependency_libs; do
5352
deplibs="$deplib $deplibs"
5353
if $opt_duplicate_deps ; then
5354
case "$tmp_libs " in
5355
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5356
esac
5357
fi
5358
tmp_libs="$tmp_libs $deplib"
5359
done
6433
5360
elif test "$linkmode" != prog && test "$linkmode" != lib; then
6434
5361
func_fatal_error "\`$lib' is not a convenience library"
6435
5362
fi
6436
tmp_libs=
6437
for deplib in $dependency_libs; do
6438
deplibs="$deplib $deplibs"
6439
if $opt_preserve_dup_deps ; then
6440
case "$tmp_libs " in
6441
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6442
esac
6443
fi
6444
func_append tmp_libs " $deplib"
6445
done
6446
5363
continue
6447
5364
fi # $pass = conv
6448
5365
6449
5366
6450
5367
# Get the name of the library we link against.
6451
5368
linklib=
6452
if test -n "$old_library" &&
6453
{ test "$prefer_static_libs" = yes ||
6454
test "$prefer_static_libs,$installed" = "built,no"; }; then
6455
linklib=$old_library
6456
else
6457
for l in $old_library $library_names; do
6458
linklib="$l"
6459
done
6460
fi
5369
for l in $old_library $library_names; do
5370
linklib="$l"
5371
done
6461
5372
if test -z "$linklib"; then
6462
5373
func_fatal_error "cannot find name of link library for \`$lib'"
6463
5374
fi
6474
5385
# statically, we need to preload. We also need to preload any
6475
5386
# dependent libraries so libltdl's deplib preloader doesn't
6476
5387
# bomb out in the load deplibs phase.
6477
func_append dlprefiles " $lib $dependency_libs"
5388
dlprefiles="$dlprefiles $lib $dependency_libs"
6478
5389
else
6479
func_append newdlfiles " $lib"
5390
newdlfiles="$newdlfiles $lib"
6480
5391
fi
6481
5392
continue
6482
5393
fi # $pass = dlopen
6498
5409
6499
5410
# Find the relevant object directory and library name.
6500
5411
if test "X$installed" = Xyes; then
6501
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5412
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6502
5413
func_warning "library \`$lib' was moved."
6503
5414
dir="$ladir"
6504
5415
absdir="$abs_ladir"
6505
5416
libdir="$abs_ladir"
6506
5417
else
6507
dir="$lt_sysroot$libdir"
6508
absdir="$lt_sysroot$libdir"
5418
dir="$libdir"
5419
absdir="$libdir"
6509
5420
fi
6510
5421
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6511
5422
else
6513
5424
dir="$ladir"
6514
5425
absdir="$abs_ladir"
6515
5426
# Remove this search path later
6516
func_append notinst_path " $abs_ladir"
5427
notinst_path="$notinst_path $abs_ladir"
6517
5428
else
6518
5429
dir="$ladir/$objdir"
6519
5430
absdir="$abs_ladir/$objdir"
6520
5431
# Remove this search path later
6521
func_append notinst_path " $abs_ladir"
5432
notinst_path="$notinst_path $abs_ladir"
6522
5433
fi
6523
5434
fi # $installed = yes
6524
5435
func_stripname 'lib' '.la' "$laname"
6529
5440
if test -z "$libdir" && test "$linkmode" = prog; then
6530
5441
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6531
5442
fi
6532
case "$host" in
6533
# special handling for platforms with PE-DLLs.
6534
*cygwin* | *mingw* | *cegcc* )
6535
# Linker will automatically link against shared library if both
6536
# static and shared are present. Therefore, ensure we extract
6537
# symbols from the import library if a shared library is present
6538
# (otherwise, the dlopen module name will be incorrect). We do
6539
# this by putting the import library name into $newdlprefiles.
6540
# We recover the dlopen module name by 'saving' the la file
6541
# name in a special purpose variable, and (later) extracting the
6542
# dlname from the la file.
6543
if test -n "$dlname"; then
6544
func_tr_sh "$dir/$linklib"
6545
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6546
func_append newdlprefiles " $dir/$linklib"
6547
else
6548
func_append newdlprefiles " $dir/$old_library"
6549
# Keep a list of preopened convenience libraries to check
6550
# that they are being used correctly in the link pass.
6551
test -z "$libdir" && \
6552
func_append dlpreconveniencelibs " $dir/$old_library"
6553
fi
6554
;;
6555
* )
6556
# Prefer using a static library (so that no silly _DYNAMIC symbols
6557
# are required to link).
6558
if test -n "$old_library"; then
6559
func_append newdlprefiles " $dir/$old_library"
6560
# Keep a list of preopened convenience libraries to check
6561
# that they are being used correctly in the link pass.
6562
test -z "$libdir" && \
6563
func_append dlpreconveniencelibs " $dir/$old_library"
6564
# Otherwise, use the dlname, so that lt_dlopen finds it.
6565
elif test -n "$dlname"; then
6566
func_append newdlprefiles " $dir/$dlname"
6567
else
6568
func_append newdlprefiles " $dir/$linklib"
6569
fi
6570
;;
6571
esac
5443
# Prefer using a static library (so that no silly _DYNAMIC symbols
5444
# are required to link).
5445
if test -n "$old_library"; then
5446
newdlprefiles="$newdlprefiles $dir/$old_library"
5447
# Keep a list of preopened convenience libraries to check
5448
# that they are being used correctly in the link pass.
5449
test -z "$libdir" && \
5450
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5451
# Otherwise, use the dlname, so that lt_dlopen finds it.
5452
elif test -n "$dlname"; then
5453
newdlprefiles="$newdlprefiles $dir/$dlname"
5454
else
5455
newdlprefiles="$newdlprefiles $dir/$linklib"
5456
fi
6572
5457
fi # $pass = dlpreopen
6573
5458
6574
5459
if test -z "$libdir"; then
6586
5471
6587
5472
6588
5473
if test "$linkmode" = prog && test "$pass" != link; then
6589
func_append newlib_search_path " $ladir"
5474
newlib_search_path="$newlib_search_path $ladir"
6590
5475
deplibs="$lib $deplibs"
6591
5476
6592
5477
linkalldeplibs=no
6599
5484
for deplib in $dependency_libs; do
6600
5485
case $deplib in
6601
5486
-L*) func_stripname '-L' '' "$deplib"
6602
func_resolve_sysroot "$func_stripname_result"
6603
func_append newlib_search_path " $func_resolve_sysroot_result"
5487
newlib_search_path="$newlib_search_path $func_stripname_result"
6604
5488
;;
6605
5489
esac
6606
5490
# Need to link against all dependency_libs?
6611
5495
# or/and link against static libraries
6612
5496
newdependency_libs="$deplib $newdependency_libs"
6613
5497
fi
6614
if $opt_preserve_dup_deps ; then
5498
if $opt_duplicate_deps ; then
6615
5499
case "$tmp_libs " in
6616
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
5500
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6617
5501
esac
6618
5502
fi
6619
func_append tmp_libs " $deplib"
5503
tmp_libs="$tmp_libs $deplib"
6620
5504
done # for deplib
6621
5505
continue
6622
5506
fi # $linkmode = prog...
6631
5515
# Make sure the rpath contains only unique directories.
6632
5516
case "$temp_rpath:" in
6633
5517
*"$absdir:"*) ;;
6634
*) func_append temp_rpath "$absdir:" ;;
5518
*) temp_rpath="$temp_rpath$absdir:" ;;
6635
5519
esac
6636
5520
fi
6637
5521
6643
5527
*)
6644
5528
case "$compile_rpath " in
6645
5529
*" $absdir "*) ;;
6646
*) func_append compile_rpath " $absdir" ;;
5530
*) compile_rpath="$compile_rpath $absdir"
6647
5531
esac
6648
5532
;;
6649
5533
esac
6652
5536
*)
6653
5537
case "$finalize_rpath " in
6654
5538
*" $libdir "*) ;;
6655
*) func_append finalize_rpath " $libdir" ;;
5539
*) finalize_rpath="$finalize_rpath $libdir"
6656
5540
esac
6657
5541
;;
6658
5542
esac
6677
5561
case $host in
6678
5562
*cygwin* | *mingw* | *cegcc*)
6679
5563
# No point in relinking DLLs because paths are not encoded
6680
func_append notinst_deplibs " $lib"
5564
notinst_deplibs="$notinst_deplibs $lib"
6681
5565
need_relink=no
6682
5566
;;
6683
5567
*)
6684
5568
if test "$installed" = no; then
6685
func_append notinst_deplibs " $lib"
5569
notinst_deplibs="$notinst_deplibs $lib"
6686
5570
need_relink=yes
6687
5571
fi
6688
5572
;;
6699
5583
fi
6700
5584
done
6701
5585
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6702
echo
5586
$ECHO
6703
5587
if test "$linkmode" = prog; then
6704
5588
$ECHO "*** Warning: Linking the executable $output against the loadable module"
6705
5589
else
6717
5601
*)
6718
5602
case "$compile_rpath " in
6719
5603
*" $absdir "*) ;;
6720
*) func_append compile_rpath " $absdir" ;;
5604
*) compile_rpath="$compile_rpath $absdir"
6721
5605
esac
6722
5606
;;
6723
5607
esac
6726
5610
*)
6727
5611
case "$finalize_rpath " in
6728
5612
*" $libdir "*) ;;
6729
*) func_append finalize_rpath " $libdir" ;;
5613
*) finalize_rpath="$finalize_rpath $libdir"
6730
5614
esac
6731
5615
;;
6732
5616
esac
6780
5664
linklib=$newlib
6781
5665
fi # test -n "$old_archive_from_expsyms_cmds"
6782
5666
6783
if test "$linkmode" = prog || test "$opt_mode" != relink; then
5667
if test "$linkmode" = prog || test "$mode" != relink; then
6784
5668
add_shlibpath=
6785
5669
add_dir=
6786
5670
add=
6802
5686
if test "X$dlopenmodule" != "X$lib"; then
6803
5687
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6804
5688
if test -z "$old_library" ; then
6805
echo
6806
echo "*** And there doesn't seem to be a static archive available"
6807
echo "*** The link will probably fail, sorry"
5689
$ECHO
5690
$ECHO "*** And there doesn't seem to be a static archive available"
5691
$ECHO "*** The link will probably fail, sorry"
6808
5692
else
6809
5693
add="$dir/$old_library"
6810
5694
fi
6836
5720
if test -n "$inst_prefix_dir"; then
6837
5721
case $libdir in
6838
5722
[\\/]*)
6839
func_append add_dir " -L$inst_prefix_dir$libdir"
5723
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6840
5724
;;
6841
5725
esac
6842
5726
fi
6858
5742
if test -n "$add_shlibpath"; then
6859
5743
case :$compile_shlibpath: in
6860
5744
*":$add_shlibpath:"*) ;;
6861
*) func_append compile_shlibpath "$add_shlibpath:" ;;
5745
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6862
5746
esac
6863
5747
fi
6864
5748
if test "$linkmode" = prog; then
6872
5756
test "$hardcode_shlibpath_var" = yes; then
6873
5757
case :$finalize_shlibpath: in
6874
5758
*":$libdir:"*) ;;
6875
*) func_append finalize_shlibpath "$libdir:" ;;
5759
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6876
5760
esac
6877
5761
fi
6878
5762
fi
6879
5763
fi
6880
5764
6881
if test "$linkmode" = prog || test "$opt_mode" = relink; then
5765
if test "$linkmode" = prog || test "$mode" = relink; then
6882
5766
add_shlibpath=
6883
5767
add_dir=
6884
5768
add=
6892
5776
elif test "$hardcode_shlibpath_var" = yes; then
6893
5777
case :$finalize_shlibpath: in
6894
5778
*":$libdir:"*) ;;
6895
*) func_append finalize_shlibpath "$libdir:" ;;
5779
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6896
5780
esac
6897
5781
add="-l$name"
6898
5782
elif test "$hardcode_automatic" = yes; then
6909
5793
if test -n "$inst_prefix_dir"; then
6910
5794
case $libdir in
6911
5795
[\\/]*)
6912
func_append add_dir " -L$inst_prefix_dir$libdir"
5796
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6913
5797
;;
6914
5798
esac
6915
5799
fi
6944
5828
6945
5829
# Just print a warning and add the library to dependency_libs so
6946
5830
# that the program can be linked against the static library.
6947
echo
5831
$ECHO
6948
5832
$ECHO "*** Warning: This system can not link to static lib archive $lib."
6949
echo "*** I have the capability to make that library automatically link in when"
6950
echo "*** you link to this library. But I can only do this if you have a"
6951
echo "*** shared version of the library, which you do not appear to have."
5833
$ECHO "*** I have the capability to make that library automatically link in when"
5834
$ECHO "*** you link to this library. But I can only do this if you have a"
5835
$ECHO "*** shared version of the library, which you do not appear to have."
6952
5836
if test "$module" = yes; then
6953
echo "*** But as you try to build a module library, libtool will still create "
6954
echo "*** a static module, that should work as long as the dlopening application"
6955
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
5837
$ECHO "*** But as you try to build a module library, libtool will still create "
5838
$ECHO "*** a static module, that should work as long as the dlopening application"
5839
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6956
5840
if test -z "$global_symbol_pipe"; then
6957
echo
6958
echo "*** However, this would only work if libtool was able to extract symbol"
6959
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6960
echo "*** not find such a program. So, this module is probably useless."
6961
echo "*** \`nm' from GNU binutils and a full rebuild may help."
5841
$ECHO
5842
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5843
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5844
$ECHO "*** not find such a program. So, this module is probably useless."
5845
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6962
5846
fi
6963
5847
if test "$build_old_libs" = no; then
6964
5848
build_libtool_libs=module
6986
5870
temp_xrpath=$func_stripname_result
6987
5871
case " $xrpath " in
6988
5872
*" $temp_xrpath "*) ;;
6989
*) func_append xrpath " $temp_xrpath";;
5873
*) xrpath="$xrpath $temp_xrpath";;
6990
5874
esac;;
6991
*) func_append temp_deplibs " $libdir";;
5875
*) temp_deplibs="$temp_deplibs $libdir";;
6992
5876
esac
6993
5877
done
6994
5878
dependency_libs="$temp_deplibs"
6995
5879
fi
6996
5880
6997
func_append newlib_search_path " $absdir"
5881
newlib_search_path="$newlib_search_path $absdir"
6998
5882
# Link against this library
6999
5883
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7000
5884
# ... and its dependency_libs
7001
5885
tmp_libs=
7002
5886
for deplib in $dependency_libs; do
7003
5887
newdependency_libs="$deplib $newdependency_libs"
7004
case $deplib in
7005
-L*) func_stripname '-L' '' "$deplib"
7006
func_resolve_sysroot "$func_stripname_result";;
7007
*) func_resolve_sysroot "$deplib" ;;
7008
esac
7009
if $opt_preserve_dup_deps ; then
5888
if $opt_duplicate_deps ; then
7010
5889
case "$tmp_libs " in
7011
*" $func_resolve_sysroot_result "*)
7012
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
5890
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
7013
5891
esac
7014
5892
fi
7015
func_append tmp_libs " $func_resolve_sysroot_result"
5893
tmp_libs="$tmp_libs $deplib"
7016
5894
done
7017
5895
7018
5896
if test "$link_all_deplibs" != no; then
7022
5900
case $deplib in
7023
5901
-L*) path="$deplib" ;;
7024
5902
*.la)
7025
func_resolve_sysroot "$deplib"
7026
deplib=$func_resolve_sysroot_result
7027
5903
func_dirname "$deplib" "" "."
7028
dir=$func_dirname_result
5904
dir="$func_dirname_result"
7029
5905
# We need an absolute path.
7030
5906
case $dir in
7031
5907
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7052
5928
if test -z "$darwin_install_name"; then
7053
5929
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7054
5930
fi
7055
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7056
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
5931
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5932
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
7057
5933
path=
7058
5934
fi
7059
5935
fi
7086
5962
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7087
5963
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7088
5964
else
7089
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5965
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7090
5966
fi
7091
5967
fi
7092
5968
dependency_libs="$newdependency_libs"
7103
5979
for dir in $newlib_search_path; do
7104
5980
case "$lib_search_path " in
7105
5981
*" $dir "*) ;;
7106
*) func_append lib_search_path " $dir" ;;
5982
*) lib_search_path="$lib_search_path $dir" ;;
7107
5983
esac
7108
5984
done
7109
5985
newlib_search_path=
7161
6037
-L*)
7162
6038
case " $tmp_libs " in
7163
6039
*" $deplib "*) ;;
7164
*) func_append tmp_libs " $deplib" ;;
6040
*) tmp_libs="$tmp_libs $deplib" ;;
7165
6041
esac
7166
6042
;;
7167
*) func_append tmp_libs " $deplib" ;;
6043
*) tmp_libs="$tmp_libs $deplib" ;;
7168
6044
esac
7169
6045
done
7170
6046
eval $var=\"$tmp_libs\"
7180
6056
;;
7181
6057
esac
7182
6058
if test -n "$i" ; then
7183
func_append tmp_libs " $i"
6059
tmp_libs="$tmp_libs $i"
7184
6060
fi
7185
6061
done
7186
6062
dependency_libs=$tmp_libs
7221
6097
# Now set the variables for building old libraries.
7222
6098
build_libtool_libs=no
7223
6099
oldlibs="$output"
7224
func_append objs "$old_deplibs"
6100
objs="$objs$old_deplibs"
7225
6101
;;
7226
6102
7227
6103
lib)
7254
6130
if test "$deplibs_check_method" != pass_all; then
7255
6131
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7256
6132
else
7257
echo
6133
$ECHO
7258
6134
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7259
6135
$ECHO "*** objects $objs is not portable!"
7260
func_append libobjs " $objs"
6136
libobjs="$libobjs $objs"
7261
6137
fi
7262
6138
fi
7263
6139
7322
6198
age="$number_minor"
7323
6199
revision="$number_revision"
7324
6200
;;
7325
freebsd-aout|freebsd-elf|qnx|sunos)
6201
freebsd-aout|freebsd-elf|sunos)
7326
6202
current="$number_major"
7327
6203
revision="$number_minor"
7328
6204
age="0"
7334
6210
revision="$number_minor"
7335
6211
lt_irix_increment=no
7336
6212
;;
6213
*)
6214
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
6215
;;
7337
6216
esac
7338
6217
;;
7339
6218
no)
7455
6334
done
7456
6335
7457
6336
# Make executables depend on our current version.
7458
func_append verstring ":${current}.0"
6337
verstring="$verstring:${current}.0"
7459
6338
;;
7460
6339
7461
6340
qnx)
7523
6402
fi
7524
6403
7525
6404
func_generate_dlsyms "$libname" "$libname" "yes"
7526
func_append libobjs " $symfileobj"
6405
libobjs="$libobjs $symfileobj"
7527
6406
test "X$libobjs" = "X " && libobjs=
7528
6407
7529
if test "$opt_mode" != relink; then
6408
if test "$mode" != relink; then
7530
6409
# Remove our outputs, but don't remove object files since they
7531
6410
# may have been created when compiling PIC objects.
7532
6411
removelist=
7542
6421
continue
7543
6422
fi
7544
6423
fi
7545
func_append removelist " $p"
6424
removelist="$removelist $p"
7546
6425
;;
7547
6426
*) ;;
7548
6427
esac
7553
6432
7554
6433
# Now set the variables for building old libraries.
7555
6434
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7556
func_append oldlibs " $output_objdir/$libname.$libext"
6435
oldlibs="$oldlibs $output_objdir/$libname.$libext"
7557
6436
7558
6437
# Transform .lo files to .o files.
7559
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6438
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
7560
6439
fi
7561
6440
7562
6441
# Eliminate all temporary directories.
7563
6442
#for path in $notinst_path; do
7564
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7565
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7566
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6443
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6444
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6445
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
7567
6446
#done
7568
6447
7569
6448
if test -n "$xrpath"; then
7570
6449
# If the user specified any rpath flags, then add them.
7571
6450
temp_xrpath=
7572
6451
for libdir in $xrpath; do
7573
func_replace_sysroot "$libdir"
7574
func_append temp_xrpath " -R$func_replace_sysroot_result"
6452
temp_xrpath="$temp_xrpath -R$libdir"
7575
6453
case "$finalize_rpath " in
7576
6454
*" $libdir "*) ;;
7577
*) func_append finalize_rpath " $libdir" ;;
6455
*) finalize_rpath="$finalize_rpath $libdir" ;;
7578
6456
esac
7579
6457
done
7580
6458
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7588
6466
for lib in $old_dlfiles; do
7589
6467
case " $dlprefiles $dlfiles " in
7590
6468
*" $lib "*) ;;
7591
*) func_append dlfiles " $lib" ;;
6469
*) dlfiles="$dlfiles $lib" ;;
7592
6470
esac
7593
6471
done
7594
6472
7598
6476
for lib in $old_dlprefiles; do
7599
6477
case "$dlprefiles " in
7600
6478
*" $lib "*) ;;
7601
*) func_append dlprefiles " $lib" ;;
6479
*) dlprefiles="$dlprefiles $lib" ;;
7602
6480
esac
7603
6481
done
7604
6482
7605
6483
if test "$build_libtool_libs" = yes; then
7606
6484
if test -n "$rpath"; then
7607
6485
case $host in
7608
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
6486
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
7609
6487
# these systems don't actually have a c library (as such)!
7610
6488
;;
7611
6489
*-*-rhapsody* | *-*-darwin1.[012])
7612
6490
# Rhapsody C library is in the System framework
7613
func_append deplibs " System.ltframework"
6491
deplibs="$deplibs System.ltframework"
7614
6492
;;
7615
6493
*-*-netbsd*)
7616
6494
# Don't link with libc until the a.out ld.so is fixed.
7627
6505
*)
7628
6506
# Add libc to deplibs on all other systems if necessary.
7629
6507
if test "$build_libtool_need_lc" = "yes"; then
7630
func_append deplibs " -lc"
6508
deplibs="$deplibs -lc"
7631
6509
fi
7632
6510
;;
7633
6511
esac
7676
6554
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7677
6555
case " $predeps $postdeps " in
7678
6556
*" $i "*)
7679
func_append newdeplibs " $i"
6557
newdeplibs="$newdeplibs $i"
7680
6558
i=""
7681
6559
;;
7682
6560
esac
7687
6565
set dummy $deplib_matches; shift
7688
6566
deplib_match=$1
7689
6567
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7690
func_append newdeplibs " $i"
6568
newdeplibs="$newdeplibs $i"
7691
6569
else
7692
6570
droppeddeps=yes
7693
echo
6571
$ECHO
7694
6572
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7695
echo "*** I have the capability to make that library automatically link in when"
7696
echo "*** you link to this library. But I can only do this if you have a"
7697
echo "*** shared version of the library, which I believe you do not have"
7698
echo "*** because a test_compile did reveal that the linker did not use it for"
7699
echo "*** its dynamic dependency list that programs get resolved with at runtime."
6573
$ECHO "*** I have the capability to make that library automatically link in when"
6574
$ECHO "*** you link to this library. But I can only do this if you have a"
6575
$ECHO "*** shared version of the library, which I believe you do not have"
6576
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6577
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7700
6578
fi
7701
6579
fi
7702
6580
;;
7703
6581
*)
7704
func_append newdeplibs " $i"
6582
newdeplibs="$newdeplibs $i"
7705
6583
;;
7706
6584
esac
7707
6585
done
7719
6597
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7720
6598
case " $predeps $postdeps " in
7721
6599
*" $i "*)
7722
func_append newdeplibs " $i"
6600
newdeplibs="$newdeplibs $i"
7723
6601
i=""
7724
6602
;;
7725
6603
esac
7730
6608
set dummy $deplib_matches; shift
7731
6609
deplib_match=$1
7732
6610
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7733
func_append newdeplibs " $i"
6611
newdeplibs="$newdeplibs $i"
7734
6612
else
7735
6613
droppeddeps=yes
7736
echo
6614
$ECHO
7737
6615
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7738
echo "*** I have the capability to make that library automatically link in when"
7739
echo "*** you link to this library. But I can only do this if you have a"
7740
echo "*** shared version of the library, which you do not appear to have"
7741
echo "*** because a test_compile did reveal that the linker did not use this one"
7742
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6616
$ECHO "*** I have the capability to make that library automatically link in when"
6617
$ECHO "*** you link to this library. But I can only do this if you have a"
6618
$ECHO "*** shared version of the library, which you do not appear to have"
6619
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6620
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7743
6621
fi
7744
6622
fi
7745
6623
else
7746
6624
droppeddeps=yes
7747
echo
6625
$ECHO
7748
6626
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7749
echo "*** make it link in! You will probably need to install it or some"
7750
echo "*** library that it depends on before this library will be fully"
7751
echo "*** functional. Installing it before continuing would be even better."
6627
$ECHO "*** make it link in! You will probably need to install it or some"
6628
$ECHO "*** library that it depends on before this library will be fully"
6629
$ECHO "*** functional. Installing it before continuing would be even better."
7752
6630
fi
7753
6631
;;
7754
6632
*)
7755
func_append newdeplibs " $i"
6633
newdeplibs="$newdeplibs $i"
7756
6634
;;
7757
6635
esac
7758
6636
done
7769
6647
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7770
6648
case " $predeps $postdeps " in
7771
6649
*" $a_deplib "*)
7772
func_append newdeplibs " $a_deplib"
6650
newdeplibs="$newdeplibs $a_deplib"
7773
6651
a_deplib=""
7774
6652
;;
7775
6653
esac
7776
6654
fi
7777
6655
if test -n "$a_deplib" ; then
7778
6656
libname=`eval "\\$ECHO \"$libname_spec\""`
7779
if test -n "$file_magic_glob"; then
7780
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7781
else
7782
libnameglob=$libname
7783
fi
7784
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7785
6657
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7786
if test "$want_nocaseglob" = yes; then
7787
shopt -s nocaseglob
7788
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7789
$nocaseglob
7790
else
7791
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7792
fi
6658
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7793
6659
for potent_lib in $potential_libs; do
7794
6660
# Follow soft links.
7795
6661
if ls -lLd "$potent_lib" 2>/dev/null |
7806
6672
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7807
6673
case $potliblink in
7808
6674
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7809
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
6675
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7810
6676
esac
7811
6677
done
7812
6678
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7813
6679
$SED -e 10q |
7814
6680
$EGREP "$file_magic_regex" > /dev/null; then
7815
func_append newdeplibs " $a_deplib"
6681
newdeplibs="$newdeplibs $a_deplib"
7816
6682
a_deplib=""
7817
6683
break 2
7818
6684
fi
7821
6687
fi
7822
6688
if test -n "$a_deplib" ; then
7823
6689
droppeddeps=yes
7824
echo
6690
$ECHO
7825
6691
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7826
echo "*** I have the capability to make that library automatically link in when"
7827
echo "*** you link to this library. But I can only do this if you have a"
7828
echo "*** shared version of the library, which you do not appear to have"
7829
echo "*** because I did check the linker path looking for a file starting"
6692
$ECHO "*** I have the capability to make that library automatically link in when"
6693
$ECHO "*** you link to this library. But I can only do this if you have a"
6694
$ECHO "*** shared version of the library, which you do not appear to have"
6695
$ECHO "*** because I did check the linker path looking for a file starting"
7830
6696
if test -z "$potlib" ; then
7831
6697
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7832
6698
else
7837
6703
;;
7838
6704
*)
7839
6705
# Add a -L argument.
7840
func_append newdeplibs " $a_deplib"
6706
newdeplibs="$newdeplibs $a_deplib"
7841
6707
;;
7842
6708
esac
7843
6709
done # Gone through all deplibs.
7853
6719
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7854
6720
case " $predeps $postdeps " in
7855
6721
*" $a_deplib "*)
7856
func_append newdeplibs " $a_deplib"
6722
newdeplibs="$newdeplibs $a_deplib"
7857
6723
a_deplib=""
7858
6724
;;
7859
6725
esac
7864
6730
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7865
6731
for potent_lib in $potential_libs; do
7866
6732
potlib="$potent_lib" # see symlink-check above in file_magic test
7867
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
6733
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7868
6734
$EGREP "$match_pattern_regex" > /dev/null; then
7869
func_append newdeplibs " $a_deplib"
6735
newdeplibs="$newdeplibs $a_deplib"
7870
6736
a_deplib=""
7871
6737
break 2
7872
6738
fi
7875
6741
fi
7876
6742
if test -n "$a_deplib" ; then
7877
6743
droppeddeps=yes
7878
echo
6744
$ECHO
7879
6745
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7880
echo "*** I have the capability to make that library automatically link in when"
7881
echo "*** you link to this library. But I can only do this if you have a"
7882
echo "*** shared version of the library, which you do not appear to have"
7883
echo "*** because I did check the linker path looking for a file starting"
6746
$ECHO "*** I have the capability to make that library automatically link in when"
6747
$ECHO "*** you link to this library. But I can only do this if you have a"
6748
$ECHO "*** shared version of the library, which you do not appear to have"
6749
$ECHO "*** because I did check the linker path looking for a file starting"
7884
6750
if test -z "$potlib" ; then
7885
6751
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7886
6752
else
7891
6757
;;
7892
6758
*)
7893
6759
# Add a -L argument.
7894
func_append newdeplibs " $a_deplib"
6760
newdeplibs="$newdeplibs $a_deplib"
7895
6761
;;
7896
6762
esac
7897
6763
done # Gone through all deplibs.
7898
6764
;;
7899
6765
none | unknown | *)
7900
6766
newdeplibs=""
7901
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6767
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6768
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7902
6769
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7903
6770
for i in $predeps $postdeps ; do
7904
6771
# can't use Xsed below, because $i might contain '/'
7905
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
6772
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7906
6773
done
7907
6774
fi
7908
case $tmp_deplibs in
7909
*[!\ \ ]*)
7910
echo
6775
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6776
$GREP . >/dev/null; then
6777
$ECHO
7911
6778
if test "X$deplibs_check_method" = "Xnone"; then
7912
echo "*** Warning: inter-library dependencies are not supported in this platform."
6779
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7913
6780
else
7914
echo "*** Warning: inter-library dependencies are not known to be supported."
6781
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
7915
6782
fi
7916
echo "*** All declared inter-library dependencies are being dropped."
6783
$ECHO "*** All declared inter-library dependencies are being dropped."
7917
6784
droppeddeps=yes
7918
;;
7919
esac
6785
fi
7920
6786
;;
7921
6787
esac
7922
6788
versuffix=$versuffix_save
7928
6794
case $host in
7929
6795
*-*-rhapsody* | *-*-darwin1.[012])
7930
6796
# On Rhapsody replace the C library with the System framework
7931
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
6797
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7932
6798
;;
7933
6799
esac
7934
6800
7935
6801
if test "$droppeddeps" = yes; then
7936
6802
if test "$module" = yes; then
7937
echo
7938
echo "*** Warning: libtool could not satisfy all declared inter-library"
6803
$ECHO
6804
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7939
6805
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7940
echo "*** a static module, that should work as long as the dlopening"
7941
echo "*** application is linked with the -dlopen flag."
6806
$ECHO "*** a static module, that should work as long as the dlopening"
6807
$ECHO "*** application is linked with the -dlopen flag."
7942
6808
if test -z "$global_symbol_pipe"; then
7943
echo
7944
echo "*** However, this would only work if libtool was able to extract symbol"
7945
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7946
echo "*** not find such a program. So, this module is probably useless."
7947
echo "*** \`nm' from GNU binutils and a full rebuild may help."
6809
$ECHO
6810
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6811
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6812
$ECHO "*** not find such a program. So, this module is probably useless."
6813
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7948
6814
fi
7949
6815
if test "$build_old_libs" = no; then
7950
6816
oldlibs="$output_objdir/$libname.$libext"
7954
6820
build_libtool_libs=no
7955
6821
fi
7956
6822
else
7957
echo "*** The inter-library dependencies that have been dropped here will be"
7958
echo "*** automatically added whenever a program is linked with this library"
7959
echo "*** or is declared to -dlopen it."
6823
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6824
$ECHO "*** automatically added whenever a program is linked with this library"
6825
$ECHO "*** or is declared to -dlopen it."
7960
6826
7961
6827
if test "$allow_undefined" = no; then
7962
echo
7963
echo "*** Since this library must not contain undefined symbols,"
7964
echo "*** because either the platform does not support them or"
7965
echo "*** it was explicitly requested with -no-undefined,"
7966
echo "*** libtool will only create a static version of it."
6828
$ECHO
6829
$ECHO "*** Since this library must not contain undefined symbols,"
6830
$ECHO "*** because either the platform does not support them or"
6831
$ECHO "*** it was explicitly requested with -no-undefined,"
6832
$ECHO "*** libtool will only create a static version of it."
7967
6833
if test "$build_old_libs" = no; then
7968
6834
oldlibs="$output_objdir/$libname.$libext"
7969
6835
build_libtool_libs=module
7980
6846
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7981
6847
case $host in
7982
6848
*-*-darwin*)
7983
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7984
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7985
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6849
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6850
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6851
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7986
6852
;;
7987
6853
esac
7988
6854
7995
6861
*)
7996
6862
case " $deplibs " in
7997
6863
*" -L$path/$objdir "*)
7998
func_append new_libs " -L$path/$objdir" ;;
6864
new_libs="$new_libs -L$path/$objdir" ;;
7999
6865
esac
8000
6866
;;
8001
6867
esac
8005
6871
-L*)
8006
6872
case " $new_libs " in
8007
6873
*" $deplib "*) ;;
8008
*) func_append new_libs " $deplib" ;;
6874
*) new_libs="$new_libs $deplib" ;;
8009
6875
esac
8010
6876
;;
8011
*) func_append new_libs " $deplib" ;;
6877
*) new_libs="$new_libs $deplib" ;;
8012
6878
esac
8013
6879
done
8014
6880
deplibs="$new_libs"
8025
6891
hardcode_libdirs=
8026
6892
dep_rpath=
8027
6893
rpath="$finalize_rpath"
8028
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
6894
test "$mode" != relink && rpath="$compile_rpath$rpath"
8029
6895
for libdir in $rpath; do
8030
6896
if test -n "$hardcode_libdir_flag_spec"; then
8031
6897
if test -n "$hardcode_libdir_separator"; then
8032
func_replace_sysroot "$libdir"
8033
libdir=$func_replace_sysroot_result
8034
6898
if test -z "$hardcode_libdirs"; then
8035
6899
hardcode_libdirs="$libdir"
8036
6900
else
8039
6903
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8040
6904
;;
8041
6905
*)
8042
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
6906
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8043
6907
;;
8044
6908
esac
8045
6909
fi
8046
6910
else
8047
6911
eval flag=\"$hardcode_libdir_flag_spec\"
8048
func_append dep_rpath " $flag"
6912
dep_rpath="$dep_rpath $flag"
8049
6913
fi
8050
6914
elif test -n "$runpath_var"; then
8051
6915
case "$perm_rpath " in
8052
6916
*" $libdir "*) ;;
8053
*) func_append perm_rpath " $libdir" ;;
6917
*) perm_rpath="$perm_rpath $libdir" ;;
8054
6918
esac
8055
6919
fi
8056
6920
done
8068
6932
# We should set the runpath_var.
8069
6933
rpath=
8070
6934
for dir in $perm_rpath; do
8071
func_append rpath "$dir:"
6935
rpath="$rpath$dir:"
8072
6936
done
8073
6937
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8074
6938
fi
8076
6940
fi
8077
6941
8078
6942
shlibpath="$finalize_shlibpath"
8079
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6943
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8080
6944
if test -n "$shlibpath"; then
8081
6945
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8082
6946
fi
8102
6966
linknames=
8103
6967
for link
8104
6968
do
8105
func_append linknames " $link"
6969
linknames="$linknames $link"
8106
6970
done
8107
6971
8108
6972
# Use standard objects if they are pic
8109
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
6973
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8110
6974
test "X$libobjs" = "X " && libobjs=
8111
6975
8112
6976
delfiles=
8113
6977
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8114
6978
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8115
6979
export_symbols="$output_objdir/$libname.uexp"
8116
func_append delfiles " $export_symbols"
6980
delfiles="$delfiles $export_symbols"
8117
6981
fi
8118
6982
8119
6983
orig_export_symbols=
8144
7008
$opt_dry_run || $RM $export_symbols
8145
7009
cmds=$export_symbols_cmds
8146
7010
save_ifs="$IFS"; IFS='~'
8147
for cmd1 in $cmds; do
7011
for cmd in $cmds; do
8148
7012
IFS="$save_ifs"
8149
# Take the normal branch if the nm_file_list_spec branch
8150
# doesn't work or if tool conversion is not needed.
8151
case $nm_file_list_spec~$to_tool_file_cmd in
8152
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8153
try_normal_branch=yes
8154
eval cmd=\"$cmd1\"
8155
func_len " $cmd"
8156
len=$func_len_result
8157
;;
8158
*)
8159
try_normal_branch=no
8160
;;
8161
esac
8162
if test "$try_normal_branch" = yes \
8163
&& { test "$len" -lt "$max_cmd_len" \
8164
|| test "$max_cmd_len" -le -1; }
8165
then
8166
func_show_eval "$cmd" 'exit $?'
8167
skipped_export=false
8168
elif test -n "$nm_file_list_spec"; then
8169
func_basename "$output"
8170
output_la=$func_basename_result
8171
save_libobjs=$libobjs
8172
save_output=$output
8173
output=${output_objdir}/${output_la}.nm
8174
func_to_tool_file "$output"
8175
libobjs=$nm_file_list_spec$func_to_tool_file_result
8176
func_append delfiles " $output"
8177
func_verbose "creating $NM input file list: $output"
8178
for obj in $save_libobjs; do
8179
func_to_tool_file "$obj"
8180
$ECHO "$func_to_tool_file_result"
8181
done > "$output"
8182
eval cmd=\"$cmd1\"
8183
func_show_eval "$cmd" 'exit $?'
8184
output=$save_output
8185
libobjs=$save_libobjs
7013
eval cmd=\"$cmd\"
7014
func_len " $cmd"
7015
len=$func_len_result
7016
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7017
func_show_eval "$cmd" 'exit $?'
8186
7018
skipped_export=false
8187
7019
else
8188
7020
# The command line is too long to execute in one step.
8204
7036
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8205
7037
tmp_export_symbols="$export_symbols"
8206
7038
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8207
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7039
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
8208
7040
fi
8209
7041
8210
7042
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8216
7048
# global variables. join(1) would be nice here, but unfortunately
8217
7049
# isn't a blessed tool.
8218
7050
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8219
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7051
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
8220
7052
export_symbols=$output_objdir/$libname.def
8221
7053
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8222
7054
fi
8226
7058
case " $convenience " in
8227
7059
*" $test_deplib "*) ;;
8228
7060
*)
8229
func_append tmp_deplibs " $test_deplib"
7061
tmp_deplibs="$tmp_deplibs $test_deplib"
8230
7062
;;
8231
7063
esac
8232
7064
done
8246
7078
test "X$libobjs" = "X " && libobjs=
8247
7079
else
8248
7080
gentop="$output_objdir/${outputname}x"
8249
func_append generated " $gentop"
7081
generated="$generated $gentop"
8250
7082
8251
7083
func_extract_archives $gentop $convenience
8252
func_append libobjs " $func_extract_archives_result"
7084
libobjs="$libobjs $func_extract_archives_result"
8253
7085
test "X$libobjs" = "X " && libobjs=
8254
7086
fi
8255
7087
fi
8256
7088
8257
7089
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8258
7090
eval flag=\"$thread_safe_flag_spec\"
8259
func_append linker_flags " $flag"
7091
linker_flags="$linker_flags $flag"
8260
7092
fi
8261
7093
8262
7094
# Make a backup of the uninstalled library when relinking
8263
if test "$opt_mode" = relink; then
7095
if test "$mode" = relink; then
8264
7096
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8265
7097
fi
8266
7098
8305
7137
save_libobjs=$libobjs
8306
7138
fi
8307
7139
save_output=$output
8308
func_basename "$output"
8309
output_la=$func_basename_result
7140
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
8310
7141
8311
7142
# Clear the reloadable object creation command queue and
8312
7143
# initialize k to one.
8319
7150
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8320
7151
output=${output_objdir}/${output_la}.lnkscript
8321
7152
func_verbose "creating GNU ld script: $output"
8322
echo 'INPUT (' > $output
7153
$ECHO 'INPUT (' > $output
8323
7154
for obj in $save_libobjs
8324
7155
do
8325
func_to_tool_file "$obj"
8326
$ECHO "$func_to_tool_file_result" >> $output
7156
$ECHO "$obj" >> $output
8327
7157
done
8328
echo ')' >> $output
8329
func_append delfiles " $output"
8330
func_to_tool_file "$output"
8331
output=$func_to_tool_file_result
7158
$ECHO ')' >> $output
7159
delfiles="$delfiles $output"
8332
7160
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8333
7161
output=${output_objdir}/${output_la}.lnk
8334
7162
func_verbose "creating linker input file list: $output"
8342
7170
fi
8343
7171
for obj
8344
7172
do
8345
func_to_tool_file "$obj"
8346
$ECHO "$func_to_tool_file_result" >> $output
7173
$ECHO "$obj" >> $output
8347
7174
done
8348
func_append delfiles " $output"
8349
func_to_tool_file "$output"
8350
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
7175
delfiles="$delfiles $output"
7176
output=$firstobj\"$file_list_spec$output\"
8351
7177
else
8352
7178
if test -n "$save_libobjs"; then
8353
7179
func_verbose "creating reloadable object files..."
8371
7197
# command to the queue.
8372
7198
if test "$k" -eq 1 ; then
8373
7199
# The first file doesn't have a previous command to add.
8374
reload_objs=$objlist
8375
eval concat_cmds=\"$reload_cmds\"
7200
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
8376
7201
else
8377
7202
# All subsequent reloadable object files will link in
8378
7203
# the last one created.
8379
reload_objs="$objlist $last_robj"
8380
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
7204
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
8381
7205
fi
8382
7206
last_robj=$output_objdir/$output_la-${k}.$objext
8383
7207
func_arith $k + 1
8384
7208
k=$func_arith_result
8385
7209
output=$output_objdir/$output_la-${k}.$objext
8386
objlist=" $obj"
7210
objlist=$obj
8387
7211
func_len " $last_robj"
8388
7212
func_arith $len0 + $func_len_result
8389
7213
len=$func_arith_result
8393
7217
# reloadable object file. All subsequent reloadable object
8394
7218
# files will link in the last one created.
8395
7219
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8396
reload_objs="$objlist $last_robj"
8397
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
7220
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
8398
7221
if test -n "$last_robj"; then
8399
7222
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8400
7223
fi
8401
func_append delfiles " $output"
7224
delfiles="$delfiles $output"
8402
7225
8403
7226
else
8404
7227
output=
8432
7255
lt_exit=$?
8433
7256
8434
7257
# Restore the uninstalled library and exit
8435
if test "$opt_mode" = relink; then
7258
if test "$mode" = relink; then
8436
7259
( cd "$output_objdir" && \
8437
7260
$RM "${realname}T" && \
8438
7261
$MV "${realname}U" "$realname" )
8453
7276
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8454
7277
tmp_export_symbols="$export_symbols"
8455
7278
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8456
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7279
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
8457
7280
fi
8458
7281
8459
7282
if test -n "$orig_export_symbols"; then
8465
7288
# global variables. join(1) would be nice here, but unfortunately
8466
7289
# isn't a blessed tool.
8467
7290
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8468
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7291
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
8469
7292
export_symbols=$output_objdir/$libname.def
8470
7293
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8471
7294
fi
8506
7329
# Add any objects from preloaded convenience libraries
8507
7330
if test -n "$dlprefiles"; then
8508
7331
gentop="$output_objdir/${outputname}x"
8509
func_append generated " $gentop"
7332
generated="$generated $gentop"
8510
7333
8511
7334
func_extract_archives $gentop $dlprefiles
8512
func_append libobjs " $func_extract_archives_result"
7335
libobjs="$libobjs $func_extract_archives_result"
8513
7336
test "X$libobjs" = "X " && libobjs=
8514
7337
fi
8515
7338
8525
7348
lt_exit=$?
8526
7349
8527
7350
# Restore the uninstalled library and exit
8528
if test "$opt_mode" = relink; then
7351
if test "$mode" = relink; then
8529
7352
( cd "$output_objdir" && \
8530
7353
$RM "${realname}T" && \
8531
7354
$MV "${realname}U" "$realname" )
8537
7360
IFS="$save_ifs"
8538
7361
8539
7362
# Restore the uninstalled library and exit
8540
if test "$opt_mode" = relink; then
7363
if test "$mode" = relink; then
8541
7364
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8542
7365
8543
7366
if test -n "$convenience"; then
8618
7441
if test -n "$convenience"; then
8619
7442
if test -n "$whole_archive_flag_spec"; then
8620
7443
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8621
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
7444
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
8622
7445
else
8623
7446
gentop="$output_objdir/${obj}x"
8624
func_append generated " $gentop"
7447
generated="$generated $gentop"
8625
7448
8626
7449
func_extract_archives $gentop $convenience
8627
7450
reload_conv_objs="$reload_objs $func_extract_archives_result"
8628
7451
fi
8629
7452
fi
8630
7453
8631
# If we're not building shared, we need to use non_pic_objs
8632
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8633
8634
7454
# Create the old-style object.
8635
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7455
reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8636
7456
8637
7457
output="$obj"
8638
7458
func_execute_cmds "$reload_cmds" 'exit $?'
8692
7512
case $host in
8693
7513
*-*-rhapsody* | *-*-darwin1.[012])
8694
7514
# On Rhapsody replace the C library is the System framework
8695
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8696
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
7515
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7516
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8697
7517
;;
8698
7518
esac
8699
7519
8704
7524
if test "$tagname" = CXX ; then
8705
7525
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8706
7526
10.[0123])
8707
func_append compile_command " ${wl}-bind_at_load"
8708
func_append finalize_command " ${wl}-bind_at_load"
7527
compile_command="$compile_command ${wl}-bind_at_load"
7528
finalize_command="$finalize_command ${wl}-bind_at_load"
8709
7529
;;
8710
7530
esac
8711
7531
fi
8712
7532
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8713
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8714
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7533
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7534
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8715
7535
;;
8716
7536
esac
8717
7537
8725
7545
*)
8726
7546
case " $compile_deplibs " in
8727
7547
*" -L$path/$objdir "*)
8728
func_append new_libs " -L$path/$objdir" ;;
7548
new_libs="$new_libs -L$path/$objdir" ;;
8729
7549
esac
8730
7550
;;
8731
7551
esac
8735
7555
-L*)
8736
7556
case " $new_libs " in
8737
7557
*" $deplib "*) ;;
8738
*) func_append new_libs " $deplib" ;;
7558
*) new_libs="$new_libs $deplib" ;;
8739
7559
esac
8740
7560
;;
8741
*) func_append new_libs " $deplib" ;;
7561
*) new_libs="$new_libs $deplib" ;;
8742
7562
esac
8743
7563
done
8744
7564
compile_deplibs="$new_libs"
8745
7565
8746
7566
8747
func_append compile_command " $compile_deplibs"
8748
func_append finalize_command " $finalize_deplibs"
7567
compile_command="$compile_command $compile_deplibs"
7568
finalize_command="$finalize_command $finalize_deplibs"
8749
7569
8750
7570
if test -n "$rpath$xrpath"; then
8751
7571
# If the user specified any rpath flags, then add them.
8753
7573
# This is the magic to use -rpath.
8754
7574
case "$finalize_rpath " in
8755
7575
*" $libdir "*) ;;
8756
*) func_append finalize_rpath " $libdir" ;;
7576
*) finalize_rpath="$finalize_rpath $libdir" ;;
8757
7577
esac
8758
7578
done
8759
7579
fi
8772
7592
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8773
7593
;;
8774
7594
*)
8775
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7595
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8776
7596
;;
8777
7597
esac
8778
7598
fi
8779
7599
else
8780
7600
eval flag=\"$hardcode_libdir_flag_spec\"
8781
func_append rpath " $flag"
7601
rpath="$rpath $flag"
8782
7602
fi
8783
7603
elif test -n "$runpath_var"; then
8784
7604
case "$perm_rpath " in
8785
7605
*" $libdir "*) ;;
8786
*) func_append perm_rpath " $libdir" ;;
7606
*) perm_rpath="$perm_rpath $libdir" ;;
8787
7607
esac
8788
7608
fi
8789
7609
case $host in
8792
7612
case :$dllsearchpath: in
8793
7613
*":$libdir:"*) ;;
8794
7614
::) dllsearchpath=$libdir;;
8795
*) func_append dllsearchpath ":$libdir";;
7615
*) dllsearchpath="$dllsearchpath:$libdir";;
8796
7616
esac
8797
7617
case :$dllsearchpath: in
8798
7618
*":$testbindir:"*) ;;
8799
7619
::) dllsearchpath=$testbindir;;
8800
*) func_append dllsearchpath ":$testbindir";;
7620
*) dllsearchpath="$dllsearchpath:$testbindir";;
8801
7621
esac
8802
7622
;;
8803
7623
esac
8823
7643
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8824
7644
;;
8825
7645
*)
8826
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7646
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8827
7647
;;
8828
7648
esac
8829
7649
fi
8830
7650
else
8831
7651
eval flag=\"$hardcode_libdir_flag_spec\"
8832
func_append rpath " $flag"
7652
rpath="$rpath $flag"
8833
7653
fi
8834
7654
elif test -n "$runpath_var"; then
8835
7655
case "$finalize_perm_rpath " in
8836
7656
*" $libdir "*) ;;
8837
*) func_append finalize_perm_rpath " $libdir" ;;
7657
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8838
7658
esac
8839
7659
fi
8840
7660
done
8848
7668
8849
7669
if test -n "$libobjs" && test "$build_old_libs" = yes; then
8850
7670
# Transform all the library objects into standard objects.
8851
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8852
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7671
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7672
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8853
7673
fi
8854
7674
8855
7675
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8861
7681
8862
7682
wrappers_required=yes
8863
7683
case $host in
8864
*cegcc* | *mingw32ce*)
8865
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8866
wrappers_required=no
8867
;;
8868
7684
*cygwin* | *mingw* )
8869
7685
if test "$build_libtool_libs" != yes; then
8870
7686
wrappers_required=no
8871
7687
fi
8872
7688
;;
7689
*cegcc)
7690
# Disable wrappers for cegcc, we are cross compiling anyway.
7691
wrappers_required=no
7692
;;
8873
7693
*)
8874
7694
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8875
7695
wrappers_required=no
8878
7698
esac
8879
7699
if test "$wrappers_required" = no; then
8880
7700
# Replace the output file specification.
8881
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7701
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8882
7702
link_command="$compile_command$compile_rpath"
8883
7703
8884
7704
# We have no uninstalled library dependencies, so finalize right now.
8885
7705
exit_status=0
8886
7706
func_show_eval "$link_command" 'exit_status=$?'
8887
7707
8888
if test -n "$postlink_cmds"; then
8889
func_to_tool_file "$output"
8890
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8891
func_execute_cmds "$postlink_cmds" 'exit $?'
8892
fi
8893
8894
7708
# Delete the generated files.
8895
7709
if test -f "$output_objdir/${outputname}S.${objext}"; then
8896
7710
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8913
7727
# We should set the runpath_var.
8914
7728
rpath=
8915
7729
for dir in $perm_rpath; do
8916
func_append rpath "$dir:"
7730
rpath="$rpath$dir:"
8917
7731
done
8918
7732
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8919
7733
fi
8921
7735
# We should set the runpath_var.
8922
7736
rpath=
8923
7737
for dir in $finalize_perm_rpath; do
8924
func_append rpath "$dir:"
7738
rpath="$rpath$dir:"
8925
7739
done
8926
7740
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8927
7741
fi
8931
7745
# We don't need to create a wrapper script.
8932
7746
link_command="$compile_var$compile_command$compile_rpath"
8933
7747
# Replace the output file specification.
8934
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7748
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8935
7749
# Delete the old output file.
8936
7750
$opt_dry_run || $RM $output
8937
7751
# Link the executable and exit
8938
7752
func_show_eval "$link_command" 'exit $?'
8939
8940
if test -n "$postlink_cmds"; then
8941
func_to_tool_file "$output"
8942
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8943
func_execute_cmds "$postlink_cmds" 'exit $?'
8944
fi
8945
8946
7753
exit $EXIT_SUCCESS
8947
7754
fi
8948
7755
8957
7764
if test "$fast_install" != no; then
8958
7765
link_command="$finalize_var$compile_command$finalize_rpath"
8959
7766
if test "$fast_install" = yes; then
8960
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7767
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8961
7768
else
8962
7769
# fast_install is set to needless
8963
7770
relink_command=
8969
7776
fi
8970
7777
8971
7778
# Replace the output file specification.
8972
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7779
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8973
7780
8974
7781
# Delete the old output files.
8975
7782
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8976
7783
8977
7784
func_show_eval "$link_command" 'exit $?'
8978
7785
8979
if test -n "$postlink_cmds"; then
8980
func_to_tool_file "$output_objdir/$outputname"
8981
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8982
func_execute_cmds "$postlink_cmds" 'exit $?'
8983
fi
8984
8985
7786
# Now create the wrapper script.
8986
7787
func_verbose "creating $output"
8987
7788
8999
7800
fi
9000
7801
done
9001
7802
relink_command="(cd `pwd`; $relink_command)"
9002
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
7803
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7804
fi
7805
7806
# Quote $ECHO for shipping.
7807
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7808
case $progpath in
7809
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7810
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7811
esac
7812
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7813
else
7814
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
9003
7815
fi
9004
7816
9005
7817
# Only actually do things if not in dry run mode.
9079
7891
else
9080
7892
oldobjs="$old_deplibs $non_pic_objects"
9081
7893
if test "$preload" = yes && test -f "$symfileobj"; then
9082
func_append oldobjs " $symfileobj"
7894
oldobjs="$oldobjs $symfileobj"
9083
7895
fi
9084
7896
fi
9085
7897
addlibs="$old_convenience"
9087
7899
9088
7900
if test -n "$addlibs"; then
9089
7901
gentop="$output_objdir/${outputname}x"
9090
func_append generated " $gentop"
7902
generated="$generated $gentop"
9091
7903
9092
7904
func_extract_archives $gentop $addlibs
9093
func_append oldobjs " $func_extract_archives_result"
7905
oldobjs="$oldobjs $func_extract_archives_result"
9094
7906
fi
9095
7907
9096
7908
# Do each command in the archive commands.
9101
7913
# Add any objects from preloaded convenience libraries
9102
7914
if test -n "$dlprefiles"; then
9103
7915
gentop="$output_objdir/${outputname}x"
9104
func_append generated " $gentop"
7916
generated="$generated $gentop"
9105
7917
9106
7918
func_extract_archives $gentop $dlprefiles
9107
func_append oldobjs " $func_extract_archives_result"
7919
oldobjs="$oldobjs $func_extract_archives_result"
9108
7920
fi
9109
7921
9110
7922
# POSIX demands no paths to be encoded in archives. We have
9120
7932
done | sort | sort -uc >/dev/null 2>&1); then
9121
7933
:
9122
7934
else
9123
echo "copying selected object files to avoid basename conflicts..."
7935
$ECHO "copying selected object files to avoid basename conflicts..."
9124
7936
gentop="$output_objdir/${outputname}x"
9125
func_append generated " $gentop"
7937
generated="$generated $gentop"
9126
7938
func_mkdir_p "$gentop"
9127
7939
save_oldobjs=$oldobjs
9128
7940
oldobjs=
9146
7958
esac
9147
7959
done
9148
7960
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9149
func_append oldobjs " $gentop/$newobj"
7961
oldobjs="$oldobjs $gentop/$newobj"
9150
7962
;;
9151
*) func_append oldobjs " $obj" ;;
7963
*) oldobjs="$oldobjs $obj" ;;
9152
7964
esac
9153
7965
done
9154
7966
fi
9158
7970
len=$func_len_result
9159
7971
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9160
7972
cmds=$old_archive_cmds
9161
elif test -n "$archiver_list_spec"; then
9162
func_verbose "using command file archive linking..."
9163
for obj in $oldobjs
9164
do
9165
func_to_tool_file "$obj"
9166
$ECHO "$func_to_tool_file_result"
9167
done > $output_objdir/$libname.libcmd
9168
func_to_tool_file "$output_objdir/$libname.libcmd"
9169
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9170
cmds=$old_archive_cmds
9171
7973
else
9172
7974
# the command line is too long to link in one step, link in parts
9173
7975
func_verbose "using piecewise archive linking..."
9241
8043
done
9242
8044
# Quote the link command for shipping.
9243
8045
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9244
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8046
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
9245
8047
if test "$hardcode_automatic" = yes ; then
9246
8048
relink_command=
9247
8049
fi
9264
8066
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9265
8067
test -z "$libdir" && \
9266
8068
func_fatal_error "\`$deplib' is not a valid libtool archive"
9267
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9268
;;
9269
-L*)
9270
func_stripname -L '' "$deplib"
9271
func_replace_sysroot "$func_stripname_result"
9272
func_append newdependency_libs " -L$func_replace_sysroot_result"
9273
;;
9274
-R*)
9275
func_stripname -R '' "$deplib"
9276
func_replace_sysroot "$func_stripname_result"
9277
func_append newdependency_libs " -R$func_replace_sysroot_result"
9278
;;
9279
*) func_append newdependency_libs " $deplib" ;;
8069
newdependency_libs="$newdependency_libs $libdir/$name"
8070
;;
8071
*) newdependency_libs="$newdependency_libs $deplib" ;;
9280
8072
esac
9281
8073
done
9282
8074
dependency_libs="$newdependency_libs"
9290
8082
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9291
8083
test -z "$libdir" && \
9292
8084
func_fatal_error "\`$lib' is not a valid libtool archive"
9293
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
8085
newdlfiles="$newdlfiles $libdir/$name"
9294
8086
;;
9295
*) func_append newdlfiles " $lib" ;;
8087
*) newdlfiles="$newdlfiles $lib" ;;
9296
8088
esac
9297
8089
done
9298
8090
dlfiles="$newdlfiles"
9309
8101
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310
8102
test -z "$libdir" && \
9311
8103
func_fatal_error "\`$lib' is not a valid libtool archive"
9312
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
8104
newdlprefiles="$newdlprefiles $libdir/$name"
9313
8105
;;
9314
8106
esac
9315
8107
done
9321
8113
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9322
8114
*) abs=`pwd`"/$lib" ;;
9323
8115
esac
9324
func_append newdlfiles " $abs"
8116
newdlfiles="$newdlfiles $abs"
9325
8117
done
9326
8118
dlfiles="$newdlfiles"
9327
8119
newdlprefiles=
9330
8122
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9331
8123
*) abs=`pwd`"/$lib" ;;
9332
8124
esac
9333
func_append newdlprefiles " $abs"
8125
newdlprefiles="$newdlprefiles $abs"
9334
8126
done
9335
8127
dlprefiles="$newdlprefiles"
9336
8128
fi
9337
8129
$RM $output
9338
8130
# place dlname in correct position for cygwin
9339
# In fact, it would be nice if we could use this code for all target
9340
# systems that can't hard-code library paths into their executables
9341
# and that have no shared library path variable independent of PATH,
9342
# but it turns out we can't easily determine that from inspecting
9343
# libtool variables, so we have to hard-code the OSs to which it
9344
# applies here; at the moment, that means platforms that use the PE
9345
# object format with DLL files. See the long comment at the top of
9346
# tests/bindir.at for full details.
9347
8131
tdlname=$dlname
9348
8132
case $host,$output,$installed,$module,$dlname in
9349
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9350
# If a -bindir argument was supplied, place the dll there.
9351
if test "x$bindir" != x ;
9352
then
9353
func_relative_path "$install_libdir" "$bindir"
9354
tdlname=$func_relative_path_result$dlname
9355
else
9356
# Otherwise fall back on heuristic.
9357
tdlname=../bin/$dlname
9358
fi
9359
;;
8133
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
9360
8134
esac
9361
8135
$ECHO > $output "\
9362
8136
# $outputname - a libtool library file
9415
8189
exit $EXIT_SUCCESS
9416
8190
}
9417
8191
9418
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
8192
{ test "$mode" = link || test "$mode" = relink; } &&
9419
8193
func_mode_link ${1+"$@"}
9420
8194
9421
8195
9435
8209
for arg
9436
8210
do
9437
8211
case $arg in
9438
-f) func_append RM " $arg"; rmforce=yes ;;
9439
-*) func_append RM " $arg" ;;
9440
*) func_append files " $arg" ;;
8212
-f) RM="$RM $arg"; rmforce=yes ;;
8213
-*) RM="$RM $arg" ;;
8214
*) files="$files $arg" ;;
9441
8215
esac
9442
8216
done
9443
8217
9446
8220
9447
8221
rmdirs=
9448
8222
8223
origobjdir="$objdir"
9449
8224
for file in $files; do
9450
8225
func_dirname "$file" "" "."
9451
8226
dir="$func_dirname_result"
9452
8227
if test "X$dir" = X.; then
9453
odir="$objdir"
8228
objdir="$origobjdir"
9454
8229
else
9455
odir="$dir/$objdir"
8230
objdir="$dir/$origobjdir"
9456
8231
fi
9457
8232
func_basename "$file"
9458
8233
name="$func_basename_result"
9459
test "$opt_mode" = uninstall && odir="$dir"
8234
test "$mode" = uninstall && objdir="$dir"
9460
8235
9461
# Remember odir for removal later, being careful to avoid duplicates
9462
if test "$opt_mode" = clean; then
8236
# Remember objdir for removal later, being careful to avoid duplicates
8237
if test "$mode" = clean; then
9463
8238
case " $rmdirs " in
9464
*" $odir "*) ;;
9465
*) func_append rmdirs " $odir" ;;
8239
*" $objdir "*) ;;
8240
*) rmdirs="$rmdirs $objdir" ;;
9466
8241
esac
9467
8242
fi
9468
8243
9488
8263
9489
8264
# Delete the libtool libraries and symlinks.
9490
8265
for n in $library_names; do
9491
func_append rmfiles " $odir/$n"
8266
rmfiles="$rmfiles $objdir/$n"
9492
8267
done
9493
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
8268
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
9494
8269
9495
case "$opt_mode" in
8270
case "$mode" in
9496
8271
clean)
9497
case " $library_names " in
8272
case " $library_names " in
8273
# " " in the beginning catches empty $dlname
9498
8274
*" $dlname "*) ;;
9499
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
8275
*) rmfiles="$rmfiles $objdir/$dlname" ;;
9500
8276
esac
9501
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
8277
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
9502
8278
;;
9503
8279
uninstall)
9504
8280
if test -n "$library_names"; then
9526
8302
# Add PIC object to the list of files to remove.
9527
8303
if test -n "$pic_object" &&
9528
8304
test "$pic_object" != none; then
9529
func_append rmfiles " $dir/$pic_object"
8305
rmfiles="$rmfiles $dir/$pic_object"
9530
8306
fi
9531
8307
9532
8308
# Add non-PIC object to the list of files to remove.
9533
8309
if test -n "$non_pic_object" &&
9534
8310
test "$non_pic_object" != none; then
9535
func_append rmfiles " $dir/$non_pic_object"
8311
rmfiles="$rmfiles $dir/$non_pic_object"
9536
8312
fi
9537
8313
fi
9538
8314
;;
9539
8315
9540
8316
*)
9541
if test "$opt_mode" = clean ; then
8317
if test "$mode" = clean ; then
9542
8318
noexename=$name
9543
8319
case $file in
9544
8320
*.exe)
9548
8324
noexename=$func_stripname_result
9549
8325
# $file with .exe has already been added to rmfiles,
9550
8326
# add $file without .exe
9551
func_append rmfiles " $file"
8327
rmfiles="$rmfiles $file"
9552
8328
;;
9553
8329
esac
9554
8330
# Do a test to see if this is a libtool program.
9557
8333
func_ltwrapper_scriptname "$file"
9558
8334
relink_command=
9559
8335
func_source $func_ltwrapper_scriptname_result
9560
func_append rmfiles " $func_ltwrapper_scriptname_result"
8336
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
9561
8337
else
9562
8338
relink_command=
9563
8339
func_source $dir/$noexename
9565
8341
9566
8342
# note $name still contains .exe if it was in $file originally
9567
8343
# as does the version of $file that was added into $rmfiles
9568
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
8344
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
9569
8345
if test "$fast_install" = yes && test -n "$relink_command"; then
9570
func_append rmfiles " $odir/lt-$name"
8346
rmfiles="$rmfiles $objdir/lt-$name"
9571
8347
fi
9572
8348
if test "X$noexename" != "X$name" ; then
9573
func_append rmfiles " $odir/lt-${noexename}.c"
8349
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
9574
8350
fi
9575
8351
fi
9576
8352
fi
9578
8354
esac
9579
8355
func_show_eval "$RM $rmfiles" 'exit_status=1'
9580
8356
done
8357
objdir="$origobjdir"
9581
8358
9582
8359
# Try to remove the ${objdir}s in the directories where we deleted files
9583
8360
for dir in $rmdirs; do
9589
8366
exit $exit_status
9590
8367
}
9591
8368
9592
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
8369
{ test "$mode" = uninstall || test "$mode" = clean; } &&
9593
8370
func_mode_uninstall ${1+"$@"}
9594
8371
9595
test -z "$opt_mode" && {
8372
test -z "$mode" && {
9596
8373
help="$generic_help"
9597
8374
func_fatal_help "you must specify a MODE"
9598
8375
}
9599
8376
9600
8377
test -z "$exec_cmd" && \
9601
func_fatal_help "invalid operation mode \`$opt_mode'"
8378
func_fatal_help "invalid operation mode \`$mode'"
9602
8379
9603
8380
if test -n "$exec_cmd"; then
9604
8381
eval exec "$exec_cmd"
Loggerhead is a web-based interface for Breezy
Version: 2.0.1