« back to all changes in this revision
Viewing changes to ltmain.sh
- browse files at revision 16
- compare with another revision
- download diff
- download tarball
- view history from revision 16
- Committer: Bazaar Package Importer
- Author(s): Laurent Bigonville
- Date: 2011-07-17 21:04:16 UTC
- mfrom: (15.1.1 experimental)
- Revision ID: james.westby@ubuntu.com-20110717210416-nt5qi659qei7a2yy
Tags: 3.0.1-2
* debian/control.in:
- Change gir1.2-cheese-3.0 Section to libs
- Make library packages depend against cheese-common package
- Make cheese package recommends against hicolor-icon-theme
- Move gst Dependency to libcheese package
* debian/patches/0002-fix-linking.patch: Add missing library to fix linking
* debian/watch:
- Switch to .bz2 tarballs.
- Bump version to 3
- Change gir1.2-cheese-3.0 Section to libs
- Make library packages depend against cheese-common package
- Make cheese package recommends against hicolor-icon-theme
- Move gst Dependency to libcheese package
* debian/patches/0002-fix-linking.patch: Add missing library to fix linking
* debian/watch:
- Switch to .bz2 tarballs.
- Bump version to 3
- files added:
- .pc
- .pc/0001-fix-pc-file.patch
- .pc/0001-fix-pc-file.patch/data
- .pc/0002-fix-linking.patch
- .pc/99_ltmain_as-needed.patch
- debian/patches
- help/fi
- help/fi/figures
- help/pa
- help/sl
- m4
- src/thumbview
- files removed:
- cheese-gtk.pc.in
- data/effects
- docs/reference/tmpl
- files modified:
- AUTHORS
added
removed
ltmain.sh
1
# Generated from ltmain.m4sh.
2
1
3
# ltmain.sh (GNU libtool) 2.2.6b
2
# libtool (GNU libtool) 2.4
4
3
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5
4
6
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6
# 2007, 2008, 2009, 2010 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
# --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
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
46
49
#
47
50
# MODE must be one of the following:
48
51
#
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
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
56
59
#
57
# MODE-ARGS vary depending on the MODE.
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.
58
62
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
59
63
#
60
64
# When reporting a bug, please describe a test case to reproduce it and
61
65
# include the following information:
62
66
#
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
69
# automake: $automake_version
70
# autoconf: $autoconf_version
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 Debian-2.4-2
73
# automake: $automake_version
74
# autoconf: $autoconf_version
71
75
#
72
76
# 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/>.
73
79
74
PROGRAM=ltmain.sh
80
PROGRAM=libtool
75
81
PACKAGE=libtool
76
VERSION=2.2.6b
82
VERSION="2.4 Debian-2.4-2"
77
83
TIMESTAMP=""
78
package_revision=1.3017
84
package_revision=1.3293
79
85
80
86
# Be Bourne compatible
81
87
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
91
97
BIN_SH=xpg4; export BIN_SH # for Tru64
92
98
DUALCASE=1; export DUALCASE # for MKS sh
93
99
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
94
108
# 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).
98
109
lt_user_locale=
99
110
lt_safe_locale=
100
111
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
107
118
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
108
119
fi"
109
120
done
121
LC_ALL=C
122
LANGUAGE=C
123
export LANGUAGE LC_ALL
110
124
111
125
$lt_unset CDPATH
112
126
113
127
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"
114
134
115
135
116
136
117
137
: ${CP="cp -f"}
118
: ${ECHO="echo"}
138
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
119
139
: ${EGREP="/bin/grep -E"}
120
140
: ${FGREP="/bin/grep -F"}
121
141
: ${GREP="/bin/grep"}
144
164
dirname="s,/[^/]*$,,"
145
165
basename="s,^.*/,,"
146
166
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
147
188
# func_dirname_and_basename file append nondir_replacement
148
189
# perform func_basename and func_dirname in a single function
149
190
# call:
158
199
# those functions but instead duplicate the functionality here.
159
200
func_dirname_and_basename ()
160
201
{
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"
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
}
179
375
180
376
# 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:
183
377
func_dirname_and_basename "$progpath"
184
378
progname=$func_basename_result
185
case $progname in
186
-*) progname=./$progname ;;
187
esac
188
379
189
380
# Make sure we have an absolute path for reexecution:
190
381
case $progpath in
215
406
# Same as above, but do not quote variable references.
216
407
double_quote_subst='s/\(["`\\]\)/\\\1/g'
217
408
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
218
418
# Re-`\' parameter expansions in output of double_quote_subst that were
219
419
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
220
420
# in input to double_quote_subst, that '$' was protected from expansion.
243
443
# name if it has been set yet.
244
444
func_echo ()
245
445
{
246
$ECHO "$progname${mode+: }$mode: $*"
446
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
247
447
}
248
448
249
449
# func_verbose arg...
258
458
:
259
459
}
260
460
461
# func_echo_all arg...
462
# Invoke $ECHO with all args, space-separated.
463
func_echo_all ()
464
{
465
$ECHO "$*"
466
}
467
261
468
# func_error arg...
262
469
# Echo program name prefixed message to standard error.
263
470
func_error ()
264
471
{
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
472
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
266
473
}
267
474
268
475
# func_warning arg...
269
476
# Echo program name prefixed warning message to standard error.
270
477
func_warning ()
271
478
{
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
479
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
273
480
274
481
# bash bug again:
275
482
:
326
533
case $my_directory_path in */*) ;; *) break ;; esac
327
534
328
535
# ...otherwise throw away the child directory and loop
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
536
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
330
537
done
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
538
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
332
539
333
540
save_mkdir_p_IFS="$IFS"; IFS=':'
334
541
for my_dir in $my_dir_list; do
378
585
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
379
586
fi
380
587
381
$ECHO "X$my_tmpdir" | $Xsed
588
$ECHO "$my_tmpdir"
382
589
}
383
590
384
591
392
599
{
393
600
case $1 in
394
601
*[\\\`\"\$]*)
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
602
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
396
603
*)
397
604
func_quote_for_eval_unquoted_result="$1" ;;
398
605
esac
419
626
{
420
627
case $1 in
421
628
*[\\\`\"]*)
422
my_arg=`$ECHO "X$1" | $Xsed \
629
my_arg=`$ECHO "$1" | $SED \
423
630
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
424
631
*)
425
632
my_arg="$1" ;;
488
695
fi
489
696
}
490
697
491
492
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
}
493
714
494
715
495
716
# func_version
496
717
# Echo version message to standard output and exit.
497
718
func_version ()
498
719
{
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
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; / {
500
731
s/^# //
501
732
s/^# *$//
502
733
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
509
740
# Echo short help message to standard output and exit.
510
741
func_usage ()
511
742
{
512
$SED -n '/^# Usage:/,/# -h/ {
743
$opt_debug
744
745
$SED -n '/^# Usage:/,/^# *.*--help/ {
513
746
s/^# //
514
747
s/^# *$//
515
748
s/\$progname/'$progname'/
516
749
p
517
750
}' < "$progpath"
518
$ECHO
751
echo
519
752
$ECHO "run \`$progname --help | more' for full usage"
520
753
exit $?
521
754
}
522
755
523
# func_help
524
# Echo long help message to standard output and exit.
756
# func_help [NOEXIT]
757
# Echo long help message to standard output and exit,
758
# unless 'noexit' is passed as argument.
525
759
func_help ()
526
760
{
761
$opt_debug
762
527
763
$SED -n '/^# Usage:/,/# Report bugs to/ {
764
:print
528
765
s/^# //
529
766
s/^# *$//
530
767
s*\$progname*'$progname'*
537
774
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
775
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
539
776
p
540
}' < "$progpath"
541
exit $?
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
542
786
}
543
787
544
788
# func_missing_arg argname
546
790
# exit_cmd.
547
791
func_missing_arg ()
548
792
{
549
func_error "missing argument for $1"
793
$opt_debug
794
795
func_error "missing argument for $1."
550
796
exit_cmd=exit
551
797
}
552
798
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
553
825
exit_cmd=:
554
826
555
827
556
828
557
829
558
830
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
583
831
magic="%%%MAGIC variable%%%"
584
832
magic_exe="%%%MAGIC EXE variable%%%"
585
833
586
834
# Global variables.
587
# $mode is unset
588
835
nonopt=
589
execute_dlfiles=
590
836
preserve_args=
591
837
lo2o="s/\\.lo\$/.${objext}/"
592
838
o2lo="s/\\.${objext}\$/.lo/"
593
839
extracted_archives=
594
840
extracted_serial=0
595
841
596
opt_dry_run=false
597
opt_duplicate_deps=false
598
opt_silent=false
599
opt_debug=:
600
601
842
# If this variable is set in any of the actions, the command in it
602
843
# will be execed at the end. This prevents here-documents from being
603
844
# left over by shells.
604
845
exec_cmd=
605
846
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
606
893
# func_fatal_configuration arg...
607
894
# Echo program name prefixed message to standard error, followed by
608
895
# a configuration failure hint, and exit.
636
923
# Display the features supported by this script.
637
924
func_features ()
638
925
{
639
$ECHO "host: $host"
926
echo "host: $host"
640
927
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
928
echo "enable shared libraries"
642
929
else
643
$ECHO "disable shared libraries"
930
echo "disable shared libraries"
644
931
fi
645
932
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
933
echo "enable static libraries"
647
934
else
648
$ECHO "disable static libraries"
935
echo "disable static libraries"
649
936
fi
650
937
651
938
exit $?
692
979
esac
693
980
}
694
981
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
822
982
# func_check_version_match
823
983
# Ensure that we are using m4 macros, and libtool script from the same
824
984
# release of libtool.
855
1015
}
856
1016
857
1017
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
858
1222
## ----------- ##
859
1223
## Main. ##
860
1224
## ----------- ##
861
1225
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
890
1226
# func_lalib_p file
891
1227
# True iff FILE is a libtool `.la' library or `.lo' object file.
892
1228
# This function is only a basic sanity check; it will hardly flush out
950
1286
# temporary ltwrapper_script.
951
1287
func_ltwrapper_scriptname ()
952
1288
{
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
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"
959
1292
}
960
1293
961
1294
# func_ltwrapper_p file
1001
1334
}
1002
1335
1003
1336
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
1004
1368
# func_infer_tag arg
1005
1369
# Infer tagged configuration to use if any are available and
1006
1370
# if one wasn't chosen via the "--tag" command line option.
1013
1377
if test -n "$available_tags" && test -z "$tagname"; then
1014
1378
CC_quoted=
1015
1379
for arg in $CC; do
1016
func_quote_for_eval "$arg"
1017
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1380
func_append_quoted CC_quoted "$arg"
1018
1381
done
1382
CC_expanded=`func_echo_all $CC`
1383
CC_quoted_expanded=`func_echo_all $CC_quoted`
1019
1384
case $@ in
1020
1385
# Blanks in the command may have been stripped by the calling shell,
1021
1386
# but not from the CC environment variable when configure was run.
1022
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1387
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1023
1389
# Blanks at the start of $base_compile will cause this to fail
1024
1390
# if we don't check for them as well.
1025
1391
*)
1030
1396
CC_quoted=
1031
1397
for arg in $CC; do
1032
1398
# Double-quote args containing other shell metacharacters.
1033
func_quote_for_eval "$arg"
1034
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1399
func_append_quoted CC_quoted "$arg"
1035
1400
done
1401
CC_expanded=`func_echo_all $CC`
1402
CC_quoted_expanded=`func_echo_all $CC_quoted`
1036
1403
case "$@ " in
1037
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1404
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1038
1406
# The compiler in the base compile command matches
1039
1407
# the one in the tagged configuration.
1040
1408
# Assume this is the tagged configuration we want.
1097
1465
}
1098
1466
}
1099
1467
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
1100
1948
# func_mode_compile arg...
1101
1949
func_mode_compile ()
1102
1950
{
1137
1985
;;
1138
1986
1139
1987
-pie | -fpie | -fPIE)
1140
pie_flag="$pie_flag $arg"
1988
func_append pie_flag " $arg"
1141
1989
continue
1142
1990
;;
1143
1991
1144
1992
-shared | -static | -prefer-pic | -prefer-non-pic)
1145
later="$later $arg"
1993
func_append later " $arg"
1146
1994
continue
1147
1995
;;
1148
1996
1163
2011
save_ifs="$IFS"; IFS=','
1164
2012
for arg in $args; do
1165
2013
IFS="$save_ifs"
1166
func_quote_for_eval "$arg"
1167
lastarg="$lastarg $func_quote_for_eval_result"
2014
func_append_quoted lastarg "$arg"
1168
2015
done
1169
2016
IFS="$save_ifs"
1170
2017
func_stripname ' ' '' "$lastarg"
1171
2018
lastarg=$func_stripname_result
1172
2019
1173
2020
# Add the arguments to base_compile.
1174
base_compile="$base_compile $lastarg"
2021
func_append base_compile " $lastarg"
1175
2022
continue
1176
2023
;;
1177
2024
1187
2034
esac # case $arg_mode
1188
2035
1189
2036
# Aesthetically quote the previous argument.
1190
func_quote_for_eval "$lastarg"
1191
base_compile="$base_compile $func_quote_for_eval_result"
2037
func_append_quoted base_compile "$lastarg"
1192
2038
done # for arg
1193
2039
1194
2040
case $arg_mode in
1213
2059
*.[cCFSifmso] | \
1214
2060
*.ada | *.adb | *.ads | *.asm | \
1215
2061
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1216
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
2062
*.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1217
2063
func_xform "$libobj"
1218
2064
libobj=$func_xform_result
1219
2065
;;
1288
2134
# Calculate the filename of the output object if compiler does
1289
2135
# not support -o with -c
1290
2136
if test "$compiler_c_o" = no; then
1291
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
2137
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1292
2138
lockfile="$output_obj.lock"
1293
2139
else
1294
2140
output_obj=
1319
2165
$opt_dry_run || $RM $removelist
1320
2166
exit $EXIT_FAILURE
1321
2167
fi
1322
removelist="$removelist $output_obj"
2168
func_append removelist " $output_obj"
1323
2169
$ECHO "$srcfile" > "$lockfile"
1324
2170
fi
1325
2171
1326
2172
$opt_dry_run || $RM $removelist
1327
removelist="$removelist $lockfile"
2173
func_append removelist " $lockfile"
1328
2174
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1329
2175
1330
if test -n "$fix_srcfile_path"; then
1331
eval srcfile=\"$fix_srcfile_path\"
1332
fi
2176
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177
srcfile=$func_to_tool_file_result
1333
2178
func_quote_for_eval "$srcfile"
1334
2179
qsrcfile=$func_quote_for_eval_result
1335
2180
1349
2194
1350
2195
if test -z "$output_obj"; then
1351
2196
# Place PIC objects in $objdir
1352
command="$command -o $lobj"
2197
func_append command " -o $lobj"
1353
2198
fi
1354
2199
1355
2200
func_show_eval_locale "$command" \
1396
2241
command="$base_compile $qsrcfile $pic_flag"
1397
2242
fi
1398
2243
if test "$compiler_c_o" = yes; then
1399
command="$command -o $obj"
2244
func_append command " -o $obj"
1400
2245
fi
1401
2246
1402
2247
# Suppress compiler output if we already did a PIC compilation.
1403
command="$command$suppress_output"
2248
func_append command "$suppress_output"
1404
2249
func_show_eval_locale "$command" \
1405
2250
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1406
2251
1445
2290
}
1446
2291
1447
2292
$opt_help || {
1448
test "$mode" = compile && func_mode_compile ${1+"$@"}
2293
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
1449
2294
}
1450
2295
1451
2296
func_mode_help ()
1452
2297
{
1453
2298
# We need to display help for each of the modes.
1454
case $mode in
2299
case $opt_mode in
1455
2300
"")
1456
2301
# Generic help is extracted from the usage comments
1457
2302
# at the start of this file.
1482
2327
1483
2328
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1484
2329
-no-suppress do not suppress compiler output for multiple passes
1485
-prefer-pic try to building PIC objects only
1486
-prefer-non-pic try to building non-PIC objects only
2330
-prefer-pic try to build PIC objects only
2331
-prefer-non-pic try to build non-PIC objects only
1487
2332
-shared do not build a \`.o' file suitable for static linking
1488
2333
-static only build a \`.o' file suitable for static linking
2334
-Wc,FLAG pass FLAG directly to the compiler
1489
2335
1490
2336
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1491
2337
from the given SOURCEFILE.
1538
2384
1539
2385
The following components of INSTALL-COMMAND are treated specially:
1540
2386
1541
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2387
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1542
2388
1543
2389
The rest of the components are interpreted as arguments to that command (only
1544
2390
BSD-compatible install options are recognized)."
1558
2404
1559
2405
-all-static do not do any dynamic linking at all
1560
2406
-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)
1561
2409
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1562
2410
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1563
2411
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1586
2434
-version-info CURRENT[:REVISION[:AGE]]
1587
2435
specify library version info [each variable defaults to 0]
1588
2436
-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)
1589
2442
1590
2443
All other options (arguments beginning with \`-') are ignored.
1591
2444
1619
2472
;;
1620
2473
1621
2474
*)
1622
func_fatal_help "invalid operation mode \`$mode'"
2475
func_fatal_help "invalid operation mode \`$opt_mode'"
1623
2476
;;
1624
2477
esac
1625
2478
1626
$ECHO
2479
echo
1627
2480
$ECHO "Try \`$progname --help' for more information about other modes."
1628
1629
exit $?
1630
2481
}
1631
2482
1632
# Now that we've collected a possible --mode arg, show help if necessary
1633
$opt_help && func_mode_help
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
1634
2513
1635
2514
1636
2515
# func_mode_execute arg...
1643
2522
func_fatal_help "you must specify a COMMAND"
1644
2523
1645
2524
# Handle -dlopen flags immediately.
1646
for file in $execute_dlfiles; do
2525
for file in $opt_dlopen; do
1647
2526
test -f "$file" \
1648
2527
|| func_fatal_help "\`$file' is not a file"
1649
2528
1650
2529
dir=
1651
2530
case $file in
1652
2531
*.la)
2532
func_resolve_sysroot "$file"
2533
file=$func_resolve_sysroot_result
2534
1653
2535
# Check to see that this really is a libtool archive.
1654
2536
func_lalib_unsafe_p "$file" \
1655
2537
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1671
2553
dir="$func_dirname_result"
1672
2554
1673
2555
if test -f "$dir/$objdir/$dlname"; then
1674
dir="$dir/$objdir"
2556
func_append dir "/$objdir"
1675
2557
else
1676
2558
if test ! -f "$dir/$dlname"; then
1677
2559
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1712
2594
for file
1713
2595
do
1714
2596
case $file in
1715
-*) ;;
2597
-* | *.la | *.lo ) ;;
1716
2598
*)
1717
2599
# Do a test to see if this is really a libtool program.
1718
2600
if func_ltwrapper_script_p "$file"; then
1728
2610
;;
1729
2611
esac
1730
2612
# Quote arguments (to preserve shell metacharacters).
1731
func_quote_for_eval "$file"
1732
args="$args $func_quote_for_eval_result"
2613
func_append_quoted args "$file"
1733
2614
done
1734
2615
1735
2616
if test "X$opt_dry_run" = Xfalse; then
1754
2635
# Display what would be done.
1755
2636
if test -n "$shlibpath_var"; then
1756
2637
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1757
$ECHO "export $shlibpath_var"
2638
echo "export $shlibpath_var"
1758
2639
fi
1759
2640
$ECHO "$cmd$args"
1760
2641
exit $EXIT_SUCCESS
1761
2642
fi
1762
2643
}
1763
2644
1764
test "$mode" = execute && func_mode_execute ${1+"$@"}
2645
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
1765
2646
1766
2647
1767
2648
# func_mode_finish arg...
1768
2649
func_mode_finish ()
1769
2650
{
1770
2651
$opt_debug
1771
libdirs="$nonopt"
2652
libs=
2653
libdirs=
1772
2654
admincmds=
1773
2655
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
1774
2697
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1775
for dir
1776
do
1777
libdirs="$libdirs $dir"
1778
done
1779
1780
2698
for libdir in $libdirs; do
1781
2699
if test -n "$finish_cmds"; then
1782
2700
# Do each command in the finish commands.
1786
2704
if test -n "$finish_eval"; then
1787
2705
# Do the single finish_eval.
1788
2706
eval cmds=\"$finish_eval\"
1789
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
2707
$opt_dry_run || eval "$cmds" || func_append admincmds "
1790
2708
$cmds"
1791
2709
fi
1792
2710
done
1795
2713
# Exit here if they wanted silent mode.
1796
2714
$opt_silent && exit $EXIT_SUCCESS
1797
2715
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
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
1841
2761
exit $EXIT_SUCCESS
1842
2762
}
1843
2763
1844
test "$mode" = finish && func_mode_finish ${1+"$@"}
2764
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
1845
2765
1846
2766
1847
2767
# func_mode_install arg...
1852
2772
# install_prog (especially on Windows NT).
1853
2773
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1854
2774
# Allow the use of GNU shtool's install command.
1855
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2775
case $nonopt in *shtool*) :;; *) false;; esac; then
1856
2776
# Aesthetically quote it.
1857
2777
func_quote_for_eval "$nonopt"
1858
2778
install_prog="$func_quote_for_eval_result "
1866
2786
# The real first argument should be the name of the installation program.
1867
2787
# Aesthetically quote it.
1868
2788
func_quote_for_eval "$arg"
1869
install_prog="$install_prog$func_quote_for_eval_result"
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
1870
2795
1871
2796
# We need to accept at least all the BSD install flags.
1872
2797
dest=
1876
2801
install_type=
1877
2802
isdir=no
1878
2803
stripme=
2804
no_mode=:
1879
2805
for arg
1880
2806
do
2807
arg2=
1881
2808
if test -n "$dest"; then
1882
files="$files $dest"
2809
func_append files " $dest"
1883
2810
dest=$arg
1884
2811
continue
1885
2812
fi
1887
2814
case $arg in
1888
2815
-d) isdir=yes ;;
1889
2816
-f)
1890
case " $install_prog " in
1891
*[\\\ /]cp\ *) ;;
1892
*) prev=$arg ;;
1893
esac
2817
if $install_cp; then :; else
2818
prev=$arg
2819
fi
1894
2820
;;
1895
2821
-g | -m | -o)
1896
2822
prev=$arg
1904
2830
*)
1905
2831
# If the previous option needed an argument, then skip it.
1906
2832
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
1907
2837
prev=
1908
2838
else
1909
2839
dest=$arg
1914
2844
1915
2845
# Aesthetically quote the argument.
1916
2846
func_quote_for_eval "$arg"
1917
install_prog="$install_prog $func_quote_for_eval_result"
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"
1918
2852
done
1919
2853
1920
2854
test -z "$install_prog" && \
1923
2857
test -n "$prev" && \
1924
2858
func_fatal_help "the \`$prev' option requires an argument"
1925
2859
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
1926
2867
if test -z "$files"; then
1927
2868
if test -z "$dest"; then
1928
2869
func_fatal_help "no file or destination specified"
1977
2918
case $file in
1978
2919
*.$libext)
1979
2920
# Do the static libraries later.
1980
staticlibs="$staticlibs $file"
2921
func_append staticlibs " $file"
1981
2922
;;
1982
2923
1983
2924
*.la)
2925
func_resolve_sysroot "$file"
2926
file=$func_resolve_sysroot_result
2927
1984
2928
# Check to see that this really is a libtool archive.
1985
2929
func_lalib_unsafe_p "$file" \
1986
2930
|| func_fatal_help "\`$file' is not a valid libtool archive"
1994
2938
if test "X$destdir" = "X$libdir"; then
1995
2939
case "$current_libdirs " in
1996
2940
*" $libdir "*) ;;
1997
*) current_libdirs="$current_libdirs $libdir" ;;
2941
*) func_append current_libdirs " $libdir" ;;
1998
2942
esac
1999
2943
else
2000
2944
# Note the libdir as a future libdir.
2001
2945
case "$future_libdirs " in
2002
2946
*" $libdir "*) ;;
2003
*) future_libdirs="$future_libdirs $libdir" ;;
2947
*) func_append future_libdirs " $libdir" ;;
2004
2948
esac
2005
2949
fi
2006
2950
2007
2951
func_dirname "$file" "/" ""
2008
2952
dir="$func_dirname_result"
2009
dir="$dir$objdir"
2953
func_append dir "$objdir"
2010
2954
2011
2955
if test -n "$relink_command"; then
2012
2956
# Determine the prefix the user has applied to our future dir.
2013
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2957
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2014
2958
2015
2959
# Don't allow the user to place us outside of our expected
2016
2960
# location b/c this prevents finding dependent libraries that
2023
2967
2024
2968
if test -n "$inst_prefix_dir"; then
2025
2969
# Stick the inst_prefix_dir data into the link command.
2026
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2970
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2027
2971
else
2028
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2972
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2029
2973
fi
2030
2974
2031
2975
func_warning "relinking \`$file'"
2043
2987
test -n "$relink_command" && srcname="$realname"T
2044
2988
2045
2989
# Install the shared library and build the symlinks.
2046
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2990
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2047
2991
'exit $?'
2048
2992
tstripme="$stripme"
2049
2993
case $host_os in
2083
3027
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2084
3028
2085
3029
# Maybe install the static library, too.
2086
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
3030
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
2087
3031
;;
2088
3032
2089
3033
*.lo)
2183
3127
if test -f "$lib"; then
2184
3128
func_source "$lib"
2185
3129
fi
2186
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
3130
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187
3131
if test -n "$libdir" && test ! -f "$libfile"; then
2188
3132
func_warning "\`$lib' has not been installed in \`$libdir'"
2189
3133
finalize=no
2202
3146
file="$func_basename_result"
2203
3147
outputname="$tmpdir/$file"
2204
3148
# Replace the output file specification.
2205
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
3149
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2206
3150
2207
3151
$opt_silent || {
2208
3152
func_quote_for_expand "$relink_command"
2221
3165
}
2222
3166
else
2223
3167
# Install the binary that we compiled earlier.
2224
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
3168
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2225
3169
fi
2226
3170
fi
2227
3171
2280
3224
fi
2281
3225
}
2282
3226
2283
test "$mode" = install && func_mode_install ${1+"$@"}
3227
test "$opt_mode" = install && func_mode_install ${1+"$@"}
2284
3228
2285
3229
2286
3230
# func_generate_dlsyms outputname originator pic_p
2323
3267
extern \"C\" {
2324
3268
#endif
2325
3269
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
2326
3286
/* External symbol declarations for the compiler. */\
2327
3287
"
2328
3288
2332
3292
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2333
3293
2334
3294
# Add our own program objects to the symbol list.
2335
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3295
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2336
3296
for progfile in $progfiles; do
2337
func_verbose "extracting global C symbols from \`$progfile'"
2338
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
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'"
2339
3300
done
2340
3301
2341
3302
if test -n "$exclude_expsyms"; then
2371
3332
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372
3333
eval '$MV "$nlist"T "$nlist"'
2373
3334
case $host in
2374
*cygwin | *mingw* | *cegcc* )
3335
*cygwin* | *mingw* | *cegcc* )
2375
3336
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376
3337
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2377
3338
;;
2384
3345
func_verbose "extracting global C symbols from \`$dlprefile'"
2385
3346
func_basename "$dlprefile"
2386
3347
name="$func_basename_result"
2387
$opt_dry_run || {
2388
eval '$ECHO ": $name " >> "$nlist"'
2389
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2390
}
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
2391
3394
done
2392
3395
2393
3396
$opt_dry_run || {
2415
3418
if test -f "$nlist"S; then
2416
3419
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2417
3420
else
2418
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
3421
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2419
3422
fi
2420
3423
2421
$ECHO >> "$output_objdir/$my_dlsyms" "\
3424
echo >> "$output_objdir/$my_dlsyms" "\
2422
3425
2423
3426
/* The mapping between symbol names and symbols. */
2424
3427
typedef struct {
2425
3428
const char *name;
2426
3429
void *address;
2427
3430
} 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
3431
extern LT_DLSYM_CONST lt_dlsymlist
2446
3432
lt_${my_prefix}_LTX_preloaded_symbols[];
2447
$lt_dlsym_const lt_dlsymlist
3433
LT_DLSYM_CONST lt_dlsymlist
2448
3434
lt_${my_prefix}_LTX_preloaded_symbols[] =
2449
3435
{\
2450
3436
{ \"$my_originator\", (void *) 0 },"
2457
3443
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2458
3444
;;
2459
3445
esac
2460
$ECHO >> "$output_objdir/$my_dlsyms" "\
3446
echo >> "$output_objdir/$my_dlsyms" "\
2461
3447
{0, (void *) 0}
2462
3448
};
2463
3449
2500
3486
for arg in $LTCFLAGS; do
2501
3487
case $arg in
2502
3488
-pie | -fpie | -fPIE) ;;
2503
*) symtab_cflags="$symtab_cflags $arg" ;;
3489
*) func_append symtab_cflags " $arg" ;;
2504
3490
esac
2505
3491
done
2506
3492
2515
3501
case $host in
2516
3502
*cygwin* | *mingw* | *cegcc* )
2517
3503
if test -f "$output_objdir/$my_outputname.def"; then
2518
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
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%"`
2520
3506
else
2521
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3507
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3508
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2523
3509
fi
2524
3510
;;
2525
3511
*)
2526
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3512
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2528
3514
;;
2529
3515
esac
2530
3516
;;
2538
3524
# really was required.
2539
3525
2540
3526
# Nullify the symbol file.
2541
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3527
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3528
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2543
3529
fi
2544
3530
}
2545
3531
2549
3535
# Need a lot of goo to handle *both* DLLs and import libs
2550
3536
# Has to be a shell function in order to 'eat' the argument
2551
3537
# that is supplied when $file_magic_command is called.
3538
# Despite the name, also deal with 64 bit binaries.
2552
3539
func_win32_libid ()
2553
3540
{
2554
3541
$opt_debug
2559
3546
win32_libid_type="x86 archive import"
2560
3547
;;
2561
3548
*ar\ archive*) # could be an import, or static
3549
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
2562
3550
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2563
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564
win32_nmres=`eval $NM -f posix -A $1 |
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\" |
2565
3554
$SED -n -e '
2566
3555
1,100{
2567
3556
/ I /{
2590
3579
$ECHO "$win32_libid_type"
2591
3580
}
2592
3581
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
}
2593
3707
2594
3708
2595
3709
# func_extract_an_archive dir oldlib
2598
3712
$opt_debug
2599
3713
f_ex_an_ar_dir="$1"; shift
2600
3714
f_ex_an_ar_oldlib="$1"
2601
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
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
2602
3727
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2603
3728
:
2604
3729
else
2669
3794
darwin_file=
2670
3795
darwin_files=
2671
3796
for darwin_file in $darwin_filelist; do
2672
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3797
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
2673
3798
$LIPO -create -output "$darwin_file" $darwin_files
2674
3799
done # $darwin_filelist
2675
3800
$RM -rf unfat-$$
2684
3809
func_extract_an_archive "$my_xdir" "$my_xabs"
2685
3810
;;
2686
3811
esac
2687
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3812
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
2688
3813
done
2689
3814
2690
3815
func_extract_archives_result="$my_oldobjs"
2691
3816
}
2692
3817
2693
3818
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 ()
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 ()
2701
3834
{
2702
func_emit_wrapper_part1_arg1=no
2703
if test -n "$1" ; then
2704
func_emit_wrapper_part1_arg1=$1
2705
fi
3835
func_emit_wrapper_arg1=${1-no}
2706
3836
2707
3837
$ECHO "\
2708
3838
#! $SHELL
2718
3848
2719
3849
# Sed substitution that helps us do robust quoting. It backslashifies
2720
3850
# metacharacters that are still active within double-quoted strings.
2721
Xsed='${SED} -e 1s/^X//'
2722
3851
sed_quote_subst='$sed_quote_subst'
2723
3852
2724
3853
# Be Bourne compatible
2749
3878
else
2750
3879
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2751
3880
if test \"\$libtool_execute_magic\" != \"$magic\"; then
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 "\
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+\"\$@\"}
2768
3998
2769
3999
# Find the directory that this script lives in.
2770
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4000
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
2771
4001
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2772
4002
2773
4003
# Follow symbolic links until we get to the real thisdir.
2774
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4004
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
2775
4005
while test -n \"\$file\"; do
2776
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4006
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
2777
4007
2778
4008
# If there was a directory component, then change thisdir.
2779
4009
if test \"x\$destdir\" != \"x\$file\"; then
2783
4013
esac
2784
4014
fi
2785
4015
2786
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4016
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4017
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
2788
4018
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 "\
2806
4019
2807
4020
# Usually 'no', except on cygwin/mingw when embedded into
2808
4021
# the cwrapper.
2809
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
4022
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
2810
4023
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811
4024
# special case for '.'
2812
4025
if test \"\$thisdir\" = \".\"; then
2814
4027
fi
2815
4028
# remove .libs from thisdir
2816
4029
case \"\$thisdir\" in
2817
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
4030
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818
4031
$objdir ) thisdir=. ;;
2819
4032
esac
2820
4033
fi
2869
4082
2870
4083
if test -f \"\$progdir/\$program\"; then"
2871
4084
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
2872
4097
# Export our shlibpath_var if we have one.
2873
4098
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2874
4099
$ECHO "\
2877
4102
2878
4103
# Some systems cannot cope with colon-terminated $shlibpath_var
2879
4104
# The second colon is a workaround for a bug in BeOS R4 sed
2880
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4105
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
2881
4106
2882
4107
export $shlibpath_var
2883
4108
"
2884
4109
fi
2885
4110
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
2894
4111
$ECHO "\
2895
4112
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896
4113
# Run the actual program with our arguments.
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
4114
func_exec_program \${1+\"\$@\"}
2915
4115
fi
2916
4116
else
2917
4117
# The program doesn't exist.
2918
4118
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919
4119
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4120
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2921
4121
exit 1
2922
4122
fi
2923
4123
fi\
2924
4124
"
2925
4125
}
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
4126
3127
4127
3128
4128
# func_emit_cwrapperexe_src
3129
4129
# emit the source code for a wrapper executable on stdout
3141
4141
3142
4142
This wrapper executable should never be moved out of the build directory.
3143
4143
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.
3148
4144
*/
3149
4145
EOF
3150
4146
cat <<"EOF"
4147
#ifdef _MSC_VER
4148
# define _CRT_SECURE_NO_DEPRECATE 1
4149
#endif
3151
4150
#include <stdio.h>
3152
4151
#include <stdlib.h>
3153
4152
#ifdef _MSC_VER
3154
4153
# include <direct.h>
3155
4154
# include <process.h>
3156
4155
# include <io.h>
3157
# define setmode _setmode
3158
4156
#else
3159
4157
# include <unistd.h>
3160
4158
# include <stdint.h>
3161
4159
# ifdef __CYGWIN__
3162
4160
# 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
3169
4161
# endif
3170
4162
#endif
3171
4163
#include <malloc.h>
3177
4169
#include <fcntl.h>
3178
4170
#include <sys/stat.h>
3179
4171
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
3180
4210
#if defined(PATH_MAX)
3181
4211
# define LT_PATHMAX PATH_MAX
3182
4212
#elif defined(MAXPATHLEN)
3192
4222
# define S_IXGRP 0
3193
4223
#endif
3194
4224
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
4225
/* path handling portability macros */
3203
4226
#ifndef DIR_SEPARATOR
3204
4227
# define DIR_SEPARATOR '/'
3205
4228
# define PATH_SEPARATOR ':'
3230
4253
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231
4254
#endif /* PATH_SEPARATOR_2 */
3232
4255
3233
#ifdef __CYGWIN__
3234
# define FOPEN_WB "wb"
3235
#endif
3236
3237
4256
#ifndef FOPEN_WB
3238
4257
# define FOPEN_WB "w"
3239
4258
#endif
3246
4265
if (stale) { free ((void *) stale); stale = 0; } \
3247
4266
} while (0)
3248
4267
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
}
4268
#if defined(LT_DEBUGWRAPPER)
4269
static int lt_debug = 1;
3260
4270
#else
3261
# define LTWRAPPER_DEBUGPRINTF(args)
4271
static int lt_debug = 0;
3262
4272
#endif
3263
4273
3264
const char *program_name = NULL;
4274
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
3265
4275
3266
4276
void *xmalloc (size_t num);
3267
4277
char *xstrdup (const char *string);
3271
4281
int make_executable (const char *path);
3272
4282
int check_executable (const char *path);
3273
4283
char *strendzap (char *str, const char *pat);
3274
void lt_fatal (const char *message, ...);
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);
3275
4288
void lt_setenv (const char *name, const char *value);
3276
4289
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3277
void lt_opt_process_env_set (const char *arg);
3278
void lt_opt_process_env_prepend (const char *arg);
3279
void lt_opt_process_env_append (const char *arg);
3280
int lt_split_name_value (const char *arg, char** name, char** value);
3281
4290
void lt_update_exe_path (const char *name, const char *value);
3282
4291
void lt_update_lib_path (const char *name, const char *value);
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";
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";
3302
4298
const char * LIB_PATH_VARNAME = "$shlibpath_var";
3303
4299
EOF
3304
4300
3305
4301
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306
func_to_host_pathlist "$temp_rpath"
4302
func_to_host_path "$temp_rpath"
3307
4303
cat <<EOF
3308
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
4304
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
3309
4305
EOF
3310
4306
else
3311
4307
cat <<"EOF"
3314
4310
fi
3315
4311
3316
4312
if test -n "$dllsearchpath"; then
3317
func_to_host_pathlist "$dllsearchpath:"
4313
func_to_host_path "$dllsearchpath:"
3318
4314
cat <<EOF
3319
4315
const char * EXE_PATH_VARNAME = "PATH";
3320
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
4316
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
3321
4317
EOF
3322
4318
else
3323
4319
cat <<"EOF"
3340
4336
cat <<"EOF"
3341
4337
3342
4338
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3343
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3344
4339
3345
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346
4340
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3347
3348
4341
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
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 */
4342
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
3361
4343
3362
4344
int
3363
4345
main (int argc, char *argv[])
3374
4356
int i;
3375
4357
3376
4358
program_name = (char *) xstrdup (base_name (argv[0]));
3377
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3378
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
4359
newargz = XMALLOC (char *, argc + 1);
3379
4360
3380
/* very simple arg parsing; don't want to rely on getopt */
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;
3381
4366
for (i = 1; i < argc; i++)
3382
4367
{
3383
4368
if (strcmp (argv[i], dumpscript_opt) == 0)
3391
4376
esac
3392
4377
3393
4378
cat <<"EOF"
3394
printf ("%s", script_text_part1);
3395
printf ("%s", script_text_part2);
4379
lt_dump_script (stdout);
3396
4380
return 0;
3397
4381
}
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]);
3398
4404
}
3399
3400
newargz = XMALLOC (char *, argc + 1);
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
3401
4416
tmp_pathspec = find_executable (argv[0]);
3402
4417
if (tmp_pathspec == NULL)
3403
lt_fatal ("Couldn't find %s", argv[0]);
3404
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3405
tmp_pathspec));
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);
3406
4422
3407
4423
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3408
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409
actual_cwrapper_path));
4424
lt_debugprintf (__FILE__, __LINE__,
4425
"(main) found exe (after symlink chase) at: %s\n",
4426
actual_cwrapper_path);
3410
4427
XFREE (tmp_pathspec);
3411
4428
3412
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
4429
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
3413
4430
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3414
4431
3415
4432
/* wrapper name transforms */
3427
4444
target_name = tmp_pathspec;
3428
4445
tmp_pathspec = 0;
3429
4446
3430
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3431
target_name));
4447
lt_debugprintf (__FILE__, __LINE__,
4448
"(main) libtool target name: %s\n",
4449
target_name);
3432
4450
EOF
3433
4451
3434
4452
cat <<EOF
3478
4496
3479
4497
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3480
4498
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. */
4503
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3481
4504
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3482
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
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>")));
4505
4506
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4507
nonnull (lt_argv_zero));
3552
4508
for (i = 0; i < newargc; i++)
3553
4509
{
3554
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4510
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4511
i, nonnull (newargz[i]));
3555
4512
}
3556
4513
3557
4514
EOF
3560
4517
mingw*)
3561
4518
cat <<"EOF"
3562
4519
/* execv doesn't actually work on mingw as expected on unix */
4520
newargz = prepare_spawn (newargz);
3563
4521
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3564
4522
if (rval == -1)
3565
4523
{
3566
4524
/* failed to start process */
3567
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4525
lt_debugprintf (__FILE__, __LINE__,
4526
"(main) failed to launch target \"%s\": %s\n",
4527
lt_argv_zero, nonnull (strerror (errno)));
3568
4528
return 127;
3569
4529
}
3570
4530
return rval;
3586
4546
{
3587
4547
void *p = (void *) malloc (num);
3588
4548
if (!p)
3589
lt_fatal ("Memory exhausted");
4549
lt_fatal (__FILE__, __LINE__, "memory exhausted");
3590
4550
3591
4551
return p;
3592
4552
}
3620
4580
{
3621
4581
struct stat st;
3622
4582
3623
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3624
path ? (*path ? path : "EMPTY!") : "NULL!"));
4583
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4584
nonempty (path));
3625
4585
if ((!path) || (!*path))
3626
4586
return 0;
3627
4587
3638
4598
int rval = 0;
3639
4599
struct stat st;
3640
4600
3641
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3642
path ? (*path ? path : "EMPTY!") : "NULL!"));
4601
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4602
nonempty (path));
3643
4603
if ((!path) || (!*path))
3644
4604
return 0;
3645
4605
3665
4625
int tmp_len;
3666
4626
char *concat_name;
3667
4627
3668
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3669
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4628
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4629
nonempty (wrapper));
3670
4630
3671
4631
if ((wrapper == NULL) || (*wrapper == '\0'))
3672
4632
return NULL;
3719
4679
{
3720
4680
/* empty path: current directory */
3721
4681
if (getcwd (tmp, LT_PATHMAX) == NULL)
3722
lt_fatal ("getcwd failed");
4682
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4683
nonnull (strerror (errno)));
3723
4684
tmp_len = strlen (tmp);
3724
4685
concat_name =
3725
4686
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3744
4705
}
3745
4706
/* Relative path | not found in path: prepend cwd */
3746
4707
if (getcwd (tmp, LT_PATHMAX) == NULL)
3747
lt_fatal ("getcwd failed");
4708
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4709
nonnull (strerror (errno)));
3748
4710
tmp_len = strlen (tmp);
3749
4711
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3750
4712
memcpy (concat_name, tmp, tmp_len);
3770
4732
int has_symlinks = 0;
3771
4733
while (strlen (tmp_pathspec) && !has_symlinks)
3772
4734
{
3773
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3774
tmp_pathspec));
4735
lt_debugprintf (__FILE__, __LINE__,
4736
"checking path component for symlinks: %s\n",
4737
tmp_pathspec);
3775
4738
if (lstat (tmp_pathspec, &s) == 0)
3776
4739
{
3777
4740
if (S_ISLNK (s.st_mode) != 0)
3793
4756
}
3794
4757
else
3795
4758
{
3796
char *errstr = strerror (errno);
3797
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4759
lt_fatal (__FILE__, __LINE__,
4760
"error accessing file \"%s\": %s",
4761
tmp_pathspec, nonnull (strerror (errno)));
3798
4762
}
3799
4763
}
3800
4764
XFREE (tmp_pathspec);
3807
4771
tmp_pathspec = realpath (pathspec, buf);
3808
4772
if (tmp_pathspec == 0)
3809
4773
{
3810
lt_fatal ("Could not follow symlinks for %s", pathspec);
4774
lt_fatal (__FILE__, __LINE__,
4775
"could not follow symlinks for %s", pathspec);
3811
4776
}
3812
4777
return xstrdup (tmp_pathspec);
3813
4778
#endif
3833
4798
return str;
3834
4799
}
3835
4800
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
3836
4814
static void
3837
lt_error_core (int exit_status, const char *mode,
4815
lt_error_core (int exit_status, const char *file,
4816
int line, const char *mode,
3838
4817
const char *message, va_list ap)
3839
4818
{
3840
fprintf (stderr, "%s: %s: ", program_name, mode);
4819
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
3841
4820
vfprintf (stderr, message, ap);
3842
4821
fprintf (stderr, ".\n");
3843
4822
3846
4825
}
3847
4826
3848
4827
void
3849
lt_fatal (const char *message, ...)
4828
lt_fatal (const char *file, int line, const char *message, ...)
3850
4829
{
3851
4830
va_list ap;
3852
4831
va_start (ap, message);
3853
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4832
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
3854
4833
va_end (ap);
3855
4834
}
3856
4835
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
3857
4848
void
3858
4849
lt_setenv (const char *name, const char *value)
3859
4850
{
3860
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861
(name ? name : "<NULL>"),
3862
(value ? value : "<NULL>")));
4851
lt_debugprintf (__FILE__, __LINE__,
4852
"(lt_setenv) setting '%s' to '%s'\n",
4853
nonnull (name), nonnull (value));
3863
4854
{
3864
4855
#ifdef HAVE_SETENV
3865
4856
/* always make a copy, for consistency with !HAVE_SETENV */
3904
4895
return new_value;
3905
4896
}
3906
4897
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
3990
4898
void
3991
4899
lt_update_exe_path (const char *name, const char *value)
3992
4900
{
3993
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994
(name ? name : "<NULL>"),
3995
(value ? value : "<NULL>")));
4901
lt_debugprintf (__FILE__, __LINE__,
4902
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4903
nonnull (name), nonnull (value));
3996
4904
3997
4905
if (name && *name && value && *value)
3998
4906
{
4011
4919
void
4012
4920
lt_update_lib_path (const char *name, const char *value)
4013
4921
{
4014
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015
(name ? name : "<NULL>"),
4016
(value ? value : "<NULL>")));
4922
lt_debugprintf (__FILE__, __LINE__,
4923
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4924
nonnull (name), nonnull (value));
4017
4925
4018
4926
if (name && *name && value && *value)
4019
4927
{
4023
4931
}
4024
4932
}
4025
4933
4026
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
}
4027
5065
EOF
4028
5066
}
4029
5067
# end: func_emit_cwrapperexe_src
4030
5068
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
4031
5080
# func_mode_link arg...
4032
5081
func_mode_link ()
4033
5082
{
4072
5121
new_inherited_linker_flags=
4073
5122
4074
5123
avoid_version=no
5124
bindir=
4075
5125
dlfiles=
4076
5126
dlprefiles=
4077
5127
dlself=no
4164
5214
esac
4165
5215
4166
5216
case $prev in
5217
bindir)
5218
bindir="$arg"
5219
prev=
5220
continue
5221
;;
4167
5222
dlfiles|dlprefiles)
4168
5223
if test "$preload" = no; then
4169
5224
# Add the symbol object into the linking commands.
4195
5250
;;
4196
5251
*)
4197
5252
if test "$prev" = dlfiles; then
4198
dlfiles="$dlfiles $arg"
5253
func_append dlfiles " $arg"
4199
5254
else
4200
dlprefiles="$dlprefiles $arg"
5255
func_append dlprefiles " $arg"
4201
5256
fi
4202
5257
prev=
4203
5258
continue
4221
5276
*-*-darwin*)
4222
5277
case "$deplibs " in
4223
5278
*" $qarg.ltframework "*) ;;
4224
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
5279
*) func_append deplibs " $qarg.ltframework" # this is fixed later
4225
5280
;;
4226
5281
esac
4227
5282
;;
4240
5295
moreargs=
4241
5296
for fil in `cat "$save_arg"`
4242
5297
do
4243
# moreargs="$moreargs $fil"
5298
# func_append moreargs " $fil"
4244
5299
arg=$fil
4245
5300
# A libtool-controlled object.
4246
5301
4269
5324
4270
5325
if test "$prev" = dlfiles; then
4271
5326
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4272
dlfiles="$dlfiles $pic_object"
5327
func_append dlfiles " $pic_object"
4273
5328
prev=
4274
5329
continue
4275
5330
else
4281
5336
# CHECK ME: I think I busted this. -Ossama
4282
5337
if test "$prev" = dlprefiles; then
4283
5338
# Preload the old-style object.
4284
dlprefiles="$dlprefiles $pic_object"
5339
func_append dlprefiles " $pic_object"
4285
5340
prev=
4286
5341
fi
4287
5342
4351
5406
if test "$prev" = rpath; then
4352
5407
case "$rpath " in
4353
5408
*" $arg "*) ;;
4354
*) rpath="$rpath $arg" ;;
5409
*) func_append rpath " $arg" ;;
4355
5410
esac
4356
5411
else
4357
5412
case "$xrpath " in
4358
5413
*" $arg "*) ;;
4359
*) xrpath="$xrpath $arg" ;;
5414
*) func_append xrpath " $arg" ;;
4360
5415
esac
4361
5416
fi
4362
5417
prev=
4368
5423
continue
4369
5424
;;
4370
5425
weak)
4371
weak_libs="$weak_libs $arg"
5426
func_append weak_libs " $arg"
4372
5427
prev=
4373
5428
continue
4374
5429
;;
4375
5430
xcclinker)
4376
linker_flags="$linker_flags $qarg"
4377
compiler_flags="$compiler_flags $qarg"
5431
func_append linker_flags " $qarg"
5432
func_append compiler_flags " $qarg"
4378
5433
prev=
4379
5434
func_append compile_command " $qarg"
4380
5435
func_append finalize_command " $qarg"
4381
5436
continue
4382
5437
;;
4383
5438
xcompiler)
4384
compiler_flags="$compiler_flags $qarg"
5439
func_append compiler_flags " $qarg"
4385
5440
prev=
4386
5441
func_append compile_command " $qarg"
4387
5442
func_append finalize_command " $qarg"
4388
5443
continue
4389
5444
;;
4390
5445
xlinker)
4391
linker_flags="$linker_flags $qarg"
4392
compiler_flags="$compiler_flags $wl$qarg"
5446
func_append linker_flags " $qarg"
5447
func_append compiler_flags " $wl$qarg"
4393
5448
prev=
4394
5449
func_append compile_command " $wl$qarg"
4395
5450
func_append finalize_command " $wl$qarg"
4425
5480
continue
4426
5481
;;
4427
5482
5483
-bindir)
5484
prev=bindir
5485
continue
5486
;;
5487
4428
5488
-dlopen)
4429
5489
prev=dlfiles
4430
5490
continue
4475
5535
;;
4476
5536
4477
5537
-L*)
4478
func_stripname '-L' '' "$arg"
4479
dir=$func_stripname_result
4480
if test -z "$dir"; then
5538
func_stripname "-L" '' "$arg"
5539
if test -z "$func_stripname_result"; then
4481
5540
if test "$#" -gt 0; then
4482
5541
func_fatal_error "require no space between \`-L' and \`$1'"
4483
5542
else
4484
5543
func_fatal_error "need path for \`-L' option"
4485
5544
fi
4486
5545
fi
5546
func_resolve_sysroot "$func_stripname_result"
5547
dir=$func_resolve_sysroot_result
4487
5548
# We need an absolute path.
4488
5549
case $dir in
4489
5550
[\\/]* | [A-Za-z]:[\\/]*) ;;
4495
5556
;;
4496
5557
esac
4497
5558
case "$deplibs " in
4498
*" -L$dir "*) ;;
5559
*" -L$dir "* | *" $arg "*)
5560
# Will only happen for absolute or sysroot arguments
5561
;;
4499
5562
*)
4500
deplibs="$deplibs -L$dir"
4501
lib_search_path="$lib_search_path $dir"
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"
4502
5569
;;
4503
5570
esac
4504
5571
case $host in
4505
5572
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4506
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
5573
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4507
5574
case :$dllsearchpath: in
4508
5575
*":$dir:"*) ;;
4509
5576
::) dllsearchpath=$dir;;
4510
*) dllsearchpath="$dllsearchpath:$dir";;
5577
*) func_append dllsearchpath ":$dir";;
4511
5578
esac
4512
5579
case :$dllsearchpath: in
4513
5580
*":$testbindir:"*) ;;
4514
5581
::) dllsearchpath=$testbindir;;
4515
*) dllsearchpath="$dllsearchpath:$testbindir";;
5582
*) func_append dllsearchpath ":$testbindir";;
4516
5583
esac
4517
5584
;;
4518
5585
esac
4522
5589
-l*)
4523
5590
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4524
5591
case $host in
4525
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5592
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4526
5593
# These systems don't actually have a C or math library (as such)
4527
5594
continue
4528
5595
;;
4536
5603
;;
4537
5604
*-*-rhapsody* | *-*-darwin1.[012])
4538
5605
# Rhapsody C and math libraries are in the System framework
4539
deplibs="$deplibs System.ltframework"
5606
func_append deplibs " System.ltframework"
4540
5607
continue
4541
5608
;;
4542
5609
*-*-sco3.2v5* | *-*-sco5v6*)
4556
5623
;;
4557
5624
esac
4558
5625
fi
4559
deplibs="$deplibs $arg"
5626
func_append deplibs " $arg"
4560
5627
continue
4561
5628
;;
4562
5629
4568
5635
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4569
5636
# classes, name mangling, and exception handling.
4570
5637
# Darwin uses the -arch flag to determine output architecture.
4571
-model|-arch|-isysroot)
4572
compiler_flags="$compiler_flags $arg"
5638
-model|-arch|-isysroot|--sysroot)
5639
func_append compiler_flags " $arg"
4573
5640
func_append compile_command " $arg"
4574
5641
func_append finalize_command " $arg"
4575
5642
prev=xcompiler
4577
5644
;;
4578
5645
4579
5646
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4580
compiler_flags="$compiler_flags $arg"
5647
func_append compiler_flags " $arg"
4581
5648
func_append compile_command " $arg"
4582
5649
func_append finalize_command " $arg"
4583
5650
case "$new_inherited_linker_flags " in
4584
5651
*" $arg "*) ;;
4585
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5652
* ) func_append new_inherited_linker_flags " $arg" ;;
4586
5653
esac
4587
5654
continue
4588
5655
;;
4649
5716
# We need an absolute path.
4650
5717
case $dir in
4651
5718
[\\/]* | [A-Za-z]:[\\/]*) ;;
5719
=*)
5720
func_stripname '=' '' "$dir"
5721
dir=$lt_sysroot$func_stripname_result
5722
;;
4652
5723
*)
4653
5724
func_fatal_error "only absolute run-paths are allowed"
4654
5725
;;
4655
5726
esac
4656
5727
case "$xrpath " in
4657
5728
*" $dir "*) ;;
4658
*) xrpath="$xrpath $dir" ;;
5729
*) func_append xrpath " $dir" ;;
4659
5730
esac
4660
5731
continue
4661
5732
;;
4708
5779
for flag in $args; do
4709
5780
IFS="$save_ifs"
4710
5781
func_quote_for_eval "$flag"
4711
arg="$arg $wl$func_quote_for_eval_result"
4712
compiler_flags="$compiler_flags $func_quote_for_eval_result"
5782
func_append arg " $func_quote_for_eval_result"
5783
func_append compiler_flags " $func_quote_for_eval_result"
4713
5784
done
4714
5785
IFS="$save_ifs"
4715
5786
func_stripname ' ' '' "$arg"
4716
5787
arg=$func_stripname_result
4717
5788
;;
4718
5789
5790
-Wl,--as-needed)
5791
deplibs="$deplibs $arg"
5792
continue
5793
;;
5794
4719
5795
-Wl,*)
4720
5796
func_stripname '-Wl,' '' "$arg"
4721
5797
args=$func_stripname_result
4724
5800
for flag in $args; do
4725
5801
IFS="$save_ifs"
4726
5802
func_quote_for_eval "$flag"
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"
5803
func_append arg " $wl$func_quote_for_eval_result"
5804
func_append compiler_flags " $wl$func_quote_for_eval_result"
5805
func_append linker_flags " $func_quote_for_eval_result"
4730
5806
done
4731
5807
IFS="$save_ifs"
4732
5808
func_stripname ' ' '' "$arg"
4754
5830
arg="$func_quote_for_eval_result"
4755
5831
;;
4756
5832
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
5833
# Flags to be passed through unchanged, with rationale:
5834
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5835
# -r[0-9][0-9]* specify processor for the SGI compiler
5836
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5837
# +DA*, +DD* enable 64-bit mode for the HP compiler
5838
# -q* compiler args for the IBM compiler
5839
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5840
# -F/path path to uninstalled frameworks, gcc on darwin
5841
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5842
# @file GCC response files
5843
# -tp=* Portland pgcc target processor selection
5844
# --sysroot=* for sysroot support
5845
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
4767
5846
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4768
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5847
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5848
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
4769
5849
func_quote_for_eval "$arg"
4770
5850
arg="$func_quote_for_eval_result"
4771
5851
func_append compile_command " $arg"
4772
5852
func_append finalize_command " $arg"
4773
compiler_flags="$compiler_flags $arg"
5853
func_append compiler_flags " $arg"
4774
5854
continue
4775
5855
;;
4776
5856
4782
5862
4783
5863
*.$objext)
4784
5864
# A standard object.
4785
objs="$objs $arg"
5865
func_append objs " $arg"
4786
5866
;;
4787
5867
4788
5868
*.lo)
4813
5893
4814
5894
if test "$prev" = dlfiles; then
4815
5895
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4816
dlfiles="$dlfiles $pic_object"
5896
func_append dlfiles " $pic_object"
4817
5897
prev=
4818
5898
continue
4819
5899
else
4825
5905
# CHECK ME: I think I busted this. -Ossama
4826
5906
if test "$prev" = dlprefiles; then
4827
5907
# Preload the old-style object.
4828
dlprefiles="$dlprefiles $pic_object"
5908
func_append dlprefiles " $pic_object"
4829
5909
prev=
4830
5910
fi
4831
5911
4870
5950
4871
5951
*.$libext)
4872
5952
# An archive.
4873
deplibs="$deplibs $arg"
4874
old_deplibs="$old_deplibs $arg"
5953
func_append deplibs " $arg"
5954
func_append old_deplibs " $arg"
4875
5955
continue
4876
5956
;;
4877
5957
4878
5958
*.la)
4879
5959
# A libtool-controlled library.
4880
5960
5961
func_resolve_sysroot "$arg"
4881
5962
if test "$prev" = dlfiles; then
4882
5963
# This library was specified with -dlopen.
4883
dlfiles="$dlfiles $arg"
5964
func_append dlfiles " $func_resolve_sysroot_result"
4884
5965
prev=
4885
5966
elif test "$prev" = dlprefiles; then
4886
5967
# The library was specified with -dlpreopen.
4887
dlprefiles="$dlprefiles $arg"
5968
func_append dlprefiles " $func_resolve_sysroot_result"
4888
5969
prev=
4889
5970
else
4890
deplibs="$deplibs $arg"
5971
func_append deplibs " $func_resolve_sysroot_result"
4891
5972
fi
4892
5973
continue
4893
5974
;;
4925
6006
4926
6007
if test -n "$shlibpath_var"; then
4927
6008
# get the directories listed in $shlibpath_var
4928
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
6009
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
4929
6010
else
4930
6011
shlib_search_path=
4931
6012
fi
4934
6015
4935
6016
func_dirname "$output" "/" ""
4936
6017
output_objdir="$func_dirname_result$objdir"
6018
func_to_tool_file "$output_objdir/"
6019
tool_output_objdir=$func_to_tool_file_result
4937
6020
# Create the object directory.
4938
6021
func_mkdir_p "$output_objdir"
4939
6022
4954
6037
# Find all interdependent deplibs by searching for libraries
4955
6038
# that are linked more than once (e.g. -la -lb -la)
4956
6039
for deplib in $deplibs; do
4957
if $opt_duplicate_deps ; then
6040
if $opt_preserve_dup_deps ; then
4958
6041
case "$libs " in
4959
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6042
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
4960
6043
esac
4961
6044
fi
4962
libs="$libs $deplib"
6045
func_append libs " $deplib"
4963
6046
done
4964
6047
4965
6048
if test "$linkmode" = lib; then
4972
6055
if $opt_duplicate_compiler_generated_deps; then
4973
6056
for pre_post_dep in $predeps $postdeps; do
4974
6057
case "$pre_post_deps " in
4975
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
6058
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
4976
6059
esac
4977
pre_post_deps="$pre_post_deps $pre_post_dep"
6060
func_append pre_post_deps " $pre_post_dep"
4978
6061
done
4979
6062
fi
4980
6063
pre_post_deps=
5033
6116
case $pass in
5034
6117
dlopen) libs="$dlfiles" ;;
5035
6118
dlpreopen) libs="$dlprefiles" ;;
5036
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6119
link)
6120
libs="$deplibs %DEPLIBS%"
6121
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
6122
;;
5037
6123
esac
5038
6124
fi
5039
6125
if test "$linkmode,$pass" = "lib,dlpreopen"; then
5041
6127
for lib in $dlprefiles; do
5042
6128
# Ignore non-libtool-libs
5043
6129
dependency_libs=
6130
func_resolve_sysroot "$lib"
5044
6131
case $lib in
5045
*.la) func_source "$lib" ;;
6132
*.la) func_source "$func_resolve_sysroot_result" ;;
5046
6133
esac
5047
6134
5048
6135
# Collect preopened libtool deplibs, except any this library
5049
6136
# has declared as weak libs
5050
6137
for deplib in $dependency_libs; do
5051
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
6138
func_basename "$deplib"
6139
deplib_base=$func_basename_result
5052
6140
case " $weak_libs " in
5053
6141
*" $deplib_base "*) ;;
5054
*) deplibs="$deplibs $deplib" ;;
6142
*) func_append deplibs " $deplib" ;;
5055
6143
esac
5056
6144
done
5057
6145
done
5067
6155
lib=
5068
6156
found=no
5069
6157
case $deplib in
6158
-Wl,--as-needed)
6159
if test "$linkmode,$pass" = "prog,link"; then
6160
compile_deplibs="$deplib $compile_deplibs"
6161
finalize_deplibs="$deplib $finalize_deplibs"
6162
else
6163
deplibs="$deplib $deplibs"
6164
fi
6165
continue
6166
;;
5070
6167
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5071
6168
if test "$linkmode,$pass" = "prog,link"; then
5072
6169
compile_deplibs="$deplib $compile_deplibs"
5073
6170
finalize_deplibs="$deplib $finalize_deplibs"
5074
6171
else
5075
compiler_flags="$compiler_flags $deplib"
6172
func_append compiler_flags " $deplib"
5076
6173
if test "$linkmode" = lib ; then
5077
6174
case "$new_inherited_linker_flags " in
5078
6175
*" $deplib "*) ;;
5079
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6176
* ) func_append new_inherited_linker_flags " $deplib" ;;
5080
6177
esac
5081
6178
fi
5082
6179
fi
5161
6258
if test "$linkmode" = lib ; then
5162
6259
case "$new_inherited_linker_flags " in
5163
6260
*" $deplib "*) ;;
5164
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6261
* ) func_append new_inherited_linker_flags " $deplib" ;;
5165
6262
esac
5166
6263
fi
5167
6264
fi
5174
6271
test "$pass" = conv && continue
5175
6272
newdependency_libs="$deplib $newdependency_libs"
5176
6273
func_stripname '-L' '' "$deplib"
5177
newlib_search_path="$newlib_search_path $func_stripname_result"
6274
func_resolve_sysroot "$func_stripname_result"
6275
func_append newlib_search_path " $func_resolve_sysroot_result"
5178
6276
;;
5179
6277
prog)
5180
6278
if test "$pass" = conv; then
5188
6286
finalize_deplibs="$deplib $finalize_deplibs"
5189
6287
fi
5190
6288
func_stripname '-L' '' "$deplib"
5191
newlib_search_path="$newlib_search_path $func_stripname_result"
6289
func_resolve_sysroot "$func_stripname_result"
6290
func_append newlib_search_path " $func_resolve_sysroot_result"
5192
6291
;;
5193
6292
*)
5194
6293
func_warning "\`-L' is ignored for archives/objects"
5199
6298
-R*)
5200
6299
if test "$pass" = link; then
5201
6300
func_stripname '-R' '' "$deplib"
5202
dir=$func_stripname_result
6301
func_resolve_sysroot "$func_stripname_result"
6302
dir=$func_resolve_sysroot_result
5203
6303
# Make sure the xrpath contains only unique directories.
5204
6304
case "$xrpath " in
5205
6305
*" $dir "*) ;;
5206
*) xrpath="$xrpath $dir" ;;
6306
*) func_append xrpath " $dir" ;;
5207
6307
esac
5208
6308
fi
5209
6309
deplibs="$deplib $deplibs"
5210
6310
continue
5211
6311
;;
5212
*.la) lib="$deplib" ;;
6312
*.la)
6313
func_resolve_sysroot "$deplib"
6314
lib=$func_resolve_sysroot_result
6315
;;
5213
6316
*.$libext)
5214
6317
if test "$pass" = conv; then
5215
6318
deplibs="$deplib $deplibs"
5227
6330
match_pattern*)
5228
6331
set dummy $deplibs_check_method; shift
5229
6332
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5230
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
6333
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5231
6334
| $EGREP "$match_pattern_regex" > /dev/null; then
5232
6335
valid_a_lib=yes
5233
6336
fi
5237
6340
;;
5238
6341
esac
5239
6342
if test "$valid_a_lib" != yes; then
5240
$ECHO
6343
echo
5241
6344
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5242
$ECHO "*** I have the capability to make that library automatically link in when"
5243
$ECHO "*** you link to this library. But I can only do this if you have a"
5244
$ECHO "*** shared version of the library, which you do not appear to have"
5245
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5246
$ECHO "*** that it is just a static archive that I should not use here."
6345
echo "*** I have the capability to make that library automatically link in when"
6346
echo "*** you link to this library. But I can only do this if you have a"
6347
echo "*** shared version of the library, which you do not appear to have"
6348
echo "*** because the file extensions .$libext of this argument makes me believe"
6349
echo "*** that it is just a static archive that I should not use here."
5247
6350
else
5248
$ECHO
6351
echo
5249
6352
$ECHO "*** Warning: Linking the shared library $output against the"
5250
6353
$ECHO "*** static library $deplib is not portable!"
5251
6354
deplibs="$deplib $deplibs"
5272
6375
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5273
6376
# If there is no dlopen support or we're linking statically,
5274
6377
# we need to preload.
5275
newdlprefiles="$newdlprefiles $deplib"
6378
func_append newdlprefiles " $deplib"
5276
6379
compile_deplibs="$deplib $compile_deplibs"
5277
6380
finalize_deplibs="$deplib $finalize_deplibs"
5278
6381
else
5279
newdlfiles="$newdlfiles $deplib"
6382
func_append newdlfiles " $deplib"
5280
6383
fi
5281
6384
fi
5282
6385
continue
5318
6421
5319
6422
# Convert "-framework foo" to "foo.ltframework"
5320
6423
if test -n "$inherited_linker_flags"; then
5321
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
6424
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5322
6425
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5323
6426
case " $new_inherited_linker_flags " in
5324
6427
*" $tmp_inherited_linker_flag "*) ;;
5325
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
6428
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
5326
6429
esac
5327
6430
done
5328
6431
fi
5329
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6432
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5330
6433
if test "$linkmode,$pass" = "lib,link" ||
5331
6434
test "$linkmode,$pass" = "prog,scan" ||
5332
6435
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5333
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5334
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
6436
test -n "$dlopen" && func_append dlfiles " $dlopen"
6437
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
5335
6438
fi
5336
6439
5337
6440
if test "$pass" = conv; then
5342
6445
func_fatal_error "cannot find name of link library for \`$lib'"
5343
6446
fi
5344
6447
# It is a libtool convenience library, so add in its objects.
5345
convenience="$convenience $ladir/$objdir/$old_library"
5346
old_convenience="$old_convenience $ladir/$objdir/$old_library"
6448
func_append convenience " $ladir/$objdir/$old_library"
6449
func_append old_convenience " $ladir/$objdir/$old_library"
6450
tmp_libs=
6451
for deplib in $dependency_libs; do
6452
deplibs="$deplib $deplibs"
6453
if $opt_preserve_dup_deps ; then
6454
case "$tmp_libs " in
6455
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6456
esac
6457
fi
6458
func_append tmp_libs " $deplib"
6459
done
5347
6460
elif test "$linkmode" != prog && test "$linkmode" != lib; then
5348
6461
func_fatal_error "\`$lib' is not a convenience library"
5349
6462
fi
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
5360
6463
continue
5361
6464
fi # $pass = conv
5362
6465
5363
6466
5364
6467
# Get the name of the library we link against.
5365
6468
linklib=
5366
for l in $old_library $library_names; do
5367
linklib="$l"
5368
done
6469
if test -n "$old_library" &&
6470
{ test "$prefer_static_libs" = yes ||
6471
test "$prefer_static_libs,$installed" = "built,no"; }; then
6472
linklib=$old_library
6473
else
6474
for l in $old_library $library_names; do
6475
linklib="$l"
6476
done
6477
fi
5369
6478
if test -z "$linklib"; then
5370
6479
func_fatal_error "cannot find name of link library for \`$lib'"
5371
6480
fi
5382
6491
# statically, we need to preload. We also need to preload any
5383
6492
# dependent libraries so libltdl's deplib preloader doesn't
5384
6493
# bomb out in the load deplibs phase.
5385
dlprefiles="$dlprefiles $lib $dependency_libs"
6494
func_append dlprefiles " $lib $dependency_libs"
5386
6495
else
5387
newdlfiles="$newdlfiles $lib"
6496
func_append newdlfiles " $lib"
5388
6497
fi
5389
6498
continue
5390
6499
fi # $pass = dlopen
5406
6515
5407
6516
# Find the relevant object directory and library name.
5408
6517
if test "X$installed" = Xyes; then
5409
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6518
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5410
6519
func_warning "library \`$lib' was moved."
5411
6520
dir="$ladir"
5412
6521
absdir="$abs_ladir"
5413
6522
libdir="$abs_ladir"
5414
6523
else
5415
dir="$libdir"
5416
absdir="$libdir"
6524
dir="$lt_sysroot$libdir"
6525
absdir="$lt_sysroot$libdir"
5417
6526
fi
5418
6527
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5419
6528
else
5421
6530
dir="$ladir"
5422
6531
absdir="$abs_ladir"
5423
6532
# Remove this search path later
5424
notinst_path="$notinst_path $abs_ladir"
6533
func_append notinst_path " $abs_ladir"
5425
6534
else
5426
6535
dir="$ladir/$objdir"
5427
6536
absdir="$abs_ladir/$objdir"
5428
6537
# Remove this search path later
5429
notinst_path="$notinst_path $abs_ladir"
6538
func_append notinst_path " $abs_ladir"
5430
6539
fi
5431
6540
fi # $installed = yes
5432
6541
func_stripname 'lib' '.la' "$laname"
5437
6546
if test -z "$libdir" && test "$linkmode" = prog; then
5438
6547
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5439
6548
fi
5440
# Prefer using a static library (so that no silly _DYNAMIC symbols
5441
# are required to link).
5442
if test -n "$old_library"; then
5443
newdlprefiles="$newdlprefiles $dir/$old_library"
5444
# Keep a list of preopened convenience libraries to check
5445
# that they are being used correctly in the link pass.
5446
test -z "$libdir" && \
5447
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5448
# Otherwise, use the dlname, so that lt_dlopen finds it.
5449
elif test -n "$dlname"; then
5450
newdlprefiles="$newdlprefiles $dir/$dlname"
5451
else
5452
newdlprefiles="$newdlprefiles $dir/$linklib"
5453
fi
6549
case "$host" in
6550
# special handling for platforms with PE-DLLs.
6551
*cygwin* | *mingw* | *cegcc* )
6552
# Linker will automatically link against shared library if both
6553
# static and shared are present. Therefore, ensure we extract
6554
# symbols from the import library if a shared library is present
6555
# (otherwise, the dlopen module name will be incorrect). We do
6556
# this by putting the import library name into $newdlprefiles.
6557
# We recover the dlopen module name by 'saving' the la file
6558
# name in a special purpose variable, and (later) extracting the
6559
# dlname from the la file.
6560
if test -n "$dlname"; then
6561
func_tr_sh "$dir/$linklib"
6562
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6563
func_append newdlprefiles " $dir/$linklib"
6564
else
6565
func_append newdlprefiles " $dir/$old_library"
6566
# Keep a list of preopened convenience libraries to check
6567
# that they are being used correctly in the link pass.
6568
test -z "$libdir" && \
6569
func_append dlpreconveniencelibs " $dir/$old_library"
6570
fi
6571
;;
6572
* )
6573
# Prefer using a static library (so that no silly _DYNAMIC symbols
6574
# are required to link).
6575
if test -n "$old_library"; then
6576
func_append newdlprefiles " $dir/$old_library"
6577
# Keep a list of preopened convenience libraries to check
6578
# that they are being used correctly in the link pass.
6579
test -z "$libdir" && \
6580
func_append dlpreconveniencelibs " $dir/$old_library"
6581
# Otherwise, use the dlname, so that lt_dlopen finds it.
6582
elif test -n "$dlname"; then
6583
func_append newdlprefiles " $dir/$dlname"
6584
else
6585
func_append newdlprefiles " $dir/$linklib"
6586
fi
6587
;;
6588
esac
5454
6589
fi # $pass = dlpreopen
5455
6590
5456
6591
if test -z "$libdir"; then
5468
6603
5469
6604
5470
6605
if test "$linkmode" = prog && test "$pass" != link; then
5471
newlib_search_path="$newlib_search_path $ladir"
6606
func_append newlib_search_path " $ladir"
5472
6607
deplibs="$lib $deplibs"
5473
6608
5474
6609
linkalldeplibs=no
5481
6616
for deplib in $dependency_libs; do
5482
6617
case $deplib in
5483
6618
-L*) func_stripname '-L' '' "$deplib"
5484
newlib_search_path="$newlib_search_path $func_stripname_result"
6619
func_resolve_sysroot "$func_stripname_result"
6620
func_append newlib_search_path " $func_resolve_sysroot_result"
5485
6621
;;
5486
6622
esac
5487
6623
# Need to link against all dependency_libs?
5492
6628
# or/and link against static libraries
5493
6629
newdependency_libs="$deplib $newdependency_libs"
5494
6630
fi
5495
if $opt_duplicate_deps ; then
6631
if $opt_preserve_dup_deps ; then
5496
6632
case "$tmp_libs " in
5497
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6633
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
5498
6634
esac
5499
6635
fi
5500
tmp_libs="$tmp_libs $deplib"
6636
func_append tmp_libs " $deplib"
5501
6637
done # for deplib
5502
6638
continue
5503
6639
fi # $linkmode = prog...
5512
6648
# Make sure the rpath contains only unique directories.
5513
6649
case "$temp_rpath:" in
5514
6650
*"$absdir:"*) ;;
5515
*) temp_rpath="$temp_rpath$absdir:" ;;
6651
*) func_append temp_rpath "$absdir:" ;;
5516
6652
esac
5517
6653
fi
5518
6654
5524
6660
*)
5525
6661
case "$compile_rpath " in
5526
6662
*" $absdir "*) ;;
5527
*) compile_rpath="$compile_rpath $absdir"
6663
*) func_append compile_rpath " $absdir" ;;
5528
6664
esac
5529
6665
;;
5530
6666
esac
5533
6669
*)
5534
6670
case "$finalize_rpath " in
5535
6671
*" $libdir "*) ;;
5536
*) finalize_rpath="$finalize_rpath $libdir"
6672
*) func_append finalize_rpath " $libdir" ;;
5537
6673
esac
5538
6674
;;
5539
6675
esac
5558
6694
case $host in
5559
6695
*cygwin* | *mingw* | *cegcc*)
5560
6696
# No point in relinking DLLs because paths are not encoded
5561
notinst_deplibs="$notinst_deplibs $lib"
6697
func_append notinst_deplibs " $lib"
5562
6698
need_relink=no
5563
6699
;;
5564
6700
*)
5565
6701
if test "$installed" = no; then
5566
notinst_deplibs="$notinst_deplibs $lib"
6702
func_append notinst_deplibs " $lib"
5567
6703
need_relink=yes
5568
6704
fi
5569
6705
;;
5580
6716
fi
5581
6717
done
5582
6718
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5583
$ECHO
6719
echo
5584
6720
if test "$linkmode" = prog; then
5585
6721
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5586
6722
else
5598
6734
*)
5599
6735
case "$compile_rpath " in
5600
6736
*" $absdir "*) ;;
5601
*) compile_rpath="$compile_rpath $absdir"
6737
*) func_append compile_rpath " $absdir" ;;
5602
6738
esac
5603
6739
;;
5604
6740
esac
5607
6743
*)
5608
6744
case "$finalize_rpath " in
5609
6745
*" $libdir "*) ;;
5610
*) finalize_rpath="$finalize_rpath $libdir"
6746
*) func_append finalize_rpath " $libdir" ;;
5611
6747
esac
5612
6748
;;
5613
6749
esac
5661
6797
linklib=$newlib
5662
6798
fi # test -n "$old_archive_from_expsyms_cmds"
5663
6799
5664
if test "$linkmode" = prog || test "$mode" != relink; then
6800
if test "$linkmode" = prog || test "$opt_mode" != relink; then
5665
6801
add_shlibpath=
5666
6802
add_dir=
5667
6803
add=
5683
6819
if test "X$dlopenmodule" != "X$lib"; then
5684
6820
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5685
6821
if test -z "$old_library" ; then
5686
$ECHO
5687
$ECHO "*** And there doesn't seem to be a static archive available"
5688
$ECHO "*** The link will probably fail, sorry"
6822
echo
6823
echo "*** And there doesn't seem to be a static archive available"
6824
echo "*** The link will probably fail, sorry"
5689
6825
else
5690
6826
add="$dir/$old_library"
5691
6827
fi
5717
6853
if test -n "$inst_prefix_dir"; then
5718
6854
case $libdir in
5719
6855
[\\/]*)
5720
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6856
func_append add_dir " -L$inst_prefix_dir$libdir"
5721
6857
;;
5722
6858
esac
5723
6859
fi
5739
6875
if test -n "$add_shlibpath"; then
5740
6876
case :$compile_shlibpath: in
5741
6877
*":$add_shlibpath:"*) ;;
5742
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6878
*) func_append compile_shlibpath "$add_shlibpath:" ;;
5743
6879
esac
5744
6880
fi
5745
6881
if test "$linkmode" = prog; then
5753
6889
test "$hardcode_shlibpath_var" = yes; then
5754
6890
case :$finalize_shlibpath: in
5755
6891
*":$libdir:"*) ;;
5756
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6892
*) func_append finalize_shlibpath "$libdir:" ;;
5757
6893
esac
5758
6894
fi
5759
6895
fi
5760
6896
fi
5761
6897
5762
if test "$linkmode" = prog || test "$mode" = relink; then
6898
if test "$linkmode" = prog || test "$opt_mode" = relink; then
5763
6899
add_shlibpath=
5764
6900
add_dir=
5765
6901
add=
5773
6909
elif test "$hardcode_shlibpath_var" = yes; then
5774
6910
case :$finalize_shlibpath: in
5775
6911
*":$libdir:"*) ;;
5776
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6912
*) func_append finalize_shlibpath "$libdir:" ;;
5777
6913
esac
5778
6914
add="-l$name"
5779
6915
elif test "$hardcode_automatic" = yes; then
5790
6926
if test -n "$inst_prefix_dir"; then
5791
6927
case $libdir in
5792
6928
[\\/]*)
5793
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6929
func_append add_dir " -L$inst_prefix_dir$libdir"
5794
6930
;;
5795
6931
esac
5796
6932
fi
5825
6961
5826
6962
# Just print a warning and add the library to dependency_libs so
5827
6963
# that the program can be linked against the static library.
5828
$ECHO
6964
echo
5829
6965
$ECHO "*** Warning: This system can not link to static lib archive $lib."
5830
$ECHO "*** I have the capability to make that library automatically link in when"
5831
$ECHO "*** you link to this library. But I can only do this if you have a"
5832
$ECHO "*** shared version of the library, which you do not appear to have."
6966
echo "*** I have the capability to make that library automatically link in when"
6967
echo "*** you link to this library. But I can only do this if you have a"
6968
echo "*** shared version of the library, which you do not appear to have."
5833
6969
if test "$module" = yes; then
5834
$ECHO "*** But as you try to build a module library, libtool will still create "
5835
$ECHO "*** a static module, that should work as long as the dlopening application"
5836
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6970
echo "*** But as you try to build a module library, libtool will still create "
6971
echo "*** a static module, that should work as long as the dlopening application"
6972
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
5837
6973
if test -z "$global_symbol_pipe"; then
5838
$ECHO
5839
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5840
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5841
$ECHO "*** not find such a program. So, this module is probably useless."
5842
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6974
echo
6975
echo "*** However, this would only work if libtool was able to extract symbol"
6976
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6977
echo "*** not find such a program. So, this module is probably useless."
6978
echo "*** \`nm' from GNU binutils and a full rebuild may help."
5843
6979
fi
5844
6980
if test "$build_old_libs" = no; then
5845
6981
build_libtool_libs=module
5867
7003
temp_xrpath=$func_stripname_result
5868
7004
case " $xrpath " in
5869
7005
*" $temp_xrpath "*) ;;
5870
*) xrpath="$xrpath $temp_xrpath";;
7006
*) func_append xrpath " $temp_xrpath";;
5871
7007
esac;;
5872
*) temp_deplibs="$temp_deplibs $libdir";;
7008
*) func_append temp_deplibs " $libdir";;
5873
7009
esac
5874
7010
done
5875
7011
dependency_libs="$temp_deplibs"
5876
7012
fi
5877
7013
5878
newlib_search_path="$newlib_search_path $absdir"
7014
func_append newlib_search_path " $absdir"
5879
7015
# Link against this library
5880
7016
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5881
7017
# ... and its dependency_libs
5882
7018
tmp_libs=
5883
7019
for deplib in $dependency_libs; do
5884
7020
newdependency_libs="$deplib $newdependency_libs"
5885
if $opt_duplicate_deps ; then
7021
case $deplib in
7022
-L*) func_stripname '-L' '' "$deplib"
7023
func_resolve_sysroot "$func_stripname_result";;
7024
*) func_resolve_sysroot "$deplib" ;;
7025
esac
7026
if $opt_preserve_dup_deps ; then
5886
7027
case "$tmp_libs " in
5887
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
7028
*" $func_resolve_sysroot_result "*)
7029
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
5888
7030
esac
5889
7031
fi
5890
tmp_libs="$tmp_libs $deplib"
7032
func_append tmp_libs " $func_resolve_sysroot_result"
5891
7033
done
5892
7034
5893
7035
if test "$link_all_deplibs" != no; then
5894
7036
# Add the search paths of all dependency libraries
5895
7037
for deplib in $dependency_libs; do
7038
path=
5896
7039
case $deplib in
5897
7040
-L*) path="$deplib" ;;
5898
7041
*.la)
7042
func_resolve_sysroot "$deplib"
7043
deplib=$func_resolve_sysroot_result
5899
7044
func_dirname "$deplib" "" "."
5900
dir="$func_dirname_result"
7045
dir=$func_dirname_result
5901
7046
# We need an absolute path.
5902
7047
case $dir in
5903
7048
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5924
7069
if test -z "$darwin_install_name"; then
5925
7070
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5926
7071
fi
5927
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5928
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
7072
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7073
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
5929
7074
path=
5930
7075
fi
5931
7076
fi
5958
7103
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5959
7104
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5960
7105
else
5961
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7106
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5962
7107
fi
5963
7108
fi
5964
7109
dependency_libs="$newdependency_libs"
5975
7120
for dir in $newlib_search_path; do
5976
7121
case "$lib_search_path " in
5977
7122
*" $dir "*) ;;
5978
*) lib_search_path="$lib_search_path $dir" ;;
7123
*) func_append lib_search_path " $dir" ;;
5979
7124
esac
5980
7125
done
5981
7126
newlib_search_path=
6033
7178
-L*)
6034
7179
case " $tmp_libs " in
6035
7180
*" $deplib "*) ;;
6036
*) tmp_libs="$tmp_libs $deplib" ;;
7181
*) func_append tmp_libs " $deplib" ;;
6037
7182
esac
6038
7183
;;
6039
*) tmp_libs="$tmp_libs $deplib" ;;
7184
*) func_append tmp_libs " $deplib" ;;
6040
7185
esac
6041
7186
done
6042
7187
eval $var=\"$tmp_libs\"
6052
7197
;;
6053
7198
esac
6054
7199
if test -n "$i" ; then
6055
tmp_libs="$tmp_libs $i"
7200
func_append tmp_libs " $i"
6056
7201
fi
6057
7202
done
6058
7203
dependency_libs=$tmp_libs
6093
7238
# Now set the variables for building old libraries.
6094
7239
build_libtool_libs=no
6095
7240
oldlibs="$output"
6096
objs="$objs$old_deplibs"
7241
func_append objs "$old_deplibs"
6097
7242
;;
6098
7243
6099
7244
lib)
6126
7271
if test "$deplibs_check_method" != pass_all; then
6127
7272
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6128
7273
else
6129
$ECHO
7274
echo
6130
7275
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6131
7276
$ECHO "*** objects $objs is not portable!"
6132
libobjs="$libobjs $objs"
7277
func_append libobjs " $objs"
6133
7278
fi
6134
7279
fi
6135
7280
6194
7339
age="$number_minor"
6195
7340
revision="$number_revision"
6196
7341
;;
6197
freebsd-aout|freebsd-elf|sunos)
7342
freebsd-aout|freebsd-elf|qnx|sunos)
6198
7343
current="$number_major"
6199
7344
revision="$number_minor"
6200
7345
age="0"
6206
7351
revision="$number_minor"
6207
7352
lt_irix_increment=no
6208
7353
;;
7354
*)
7355
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
7356
;;
6209
7357
esac
6210
7358
;;
6211
7359
no)
6327
7475
done
6328
7476
6329
7477
# Make executables depend on our current version.
6330
verstring="$verstring:${current}.0"
7478
func_append verstring ":${current}.0"
6331
7479
;;
6332
7480
6333
7481
qnx)
6395
7543
fi
6396
7544
6397
7545
func_generate_dlsyms "$libname" "$libname" "yes"
6398
libobjs="$libobjs $symfileobj"
7546
func_append libobjs " $symfileobj"
6399
7547
test "X$libobjs" = "X " && libobjs=
6400
7548
6401
if test "$mode" != relink; then
7549
if test "$opt_mode" != relink; then
6402
7550
# Remove our outputs, but don't remove object files since they
6403
7551
# may have been created when compiling PIC objects.
6404
7552
removelist=
6414
7562
continue
6415
7563
fi
6416
7564
fi
6417
removelist="$removelist $p"
7565
func_append removelist " $p"
6418
7566
;;
6419
7567
*) ;;
6420
7568
esac
6425
7573
6426
7574
# Now set the variables for building old libraries.
6427
7575
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6428
oldlibs="$oldlibs $output_objdir/$libname.$libext"
7576
func_append oldlibs " $output_objdir/$libname.$libext"
6429
7577
6430
7578
# Transform .lo files to .o files.
6431
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
7579
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6432
7580
fi
6433
7581
6434
7582
# Eliminate all temporary directories.
6435
7583
#for path in $notinst_path; do
6436
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6437
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6438
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
7584
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7585
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7586
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6439
7587
#done
6440
7588
6441
7589
if test -n "$xrpath"; then
6442
7590
# If the user specified any rpath flags, then add them.
6443
7591
temp_xrpath=
6444
7592
for libdir in $xrpath; do
6445
temp_xrpath="$temp_xrpath -R$libdir"
7593
func_replace_sysroot "$libdir"
7594
func_append temp_xrpath " -R$func_replace_sysroot_result"
6446
7595
case "$finalize_rpath " in
6447
7596
*" $libdir "*) ;;
6448
*) finalize_rpath="$finalize_rpath $libdir" ;;
7597
*) func_append finalize_rpath " $libdir" ;;
6449
7598
esac
6450
7599
done
6451
7600
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6459
7608
for lib in $old_dlfiles; do
6460
7609
case " $dlprefiles $dlfiles " in
6461
7610
*" $lib "*) ;;
6462
*) dlfiles="$dlfiles $lib" ;;
7611
*) func_append dlfiles " $lib" ;;
6463
7612
esac
6464
7613
done
6465
7614
6469
7618
for lib in $old_dlprefiles; do
6470
7619
case "$dlprefiles " in
6471
7620
*" $lib "*) ;;
6472
*) dlprefiles="$dlprefiles $lib" ;;
7621
*) func_append dlprefiles " $lib" ;;
6473
7622
esac
6474
7623
done
6475
7624
6476
7625
if test "$build_libtool_libs" = yes; then
6477
7626
if test -n "$rpath"; then
6478
7627
case $host in
6479
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
7628
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
6480
7629
# these systems don't actually have a c library (as such)!
6481
7630
;;
6482
7631
*-*-rhapsody* | *-*-darwin1.[012])
6483
7632
# Rhapsody C library is in the System framework
6484
deplibs="$deplibs System.ltframework"
7633
func_append deplibs " System.ltframework"
6485
7634
;;
6486
7635
*-*-netbsd*)
6487
7636
# Don't link with libc until the a.out ld.so is fixed.
6498
7647
*)
6499
7648
# Add libc to deplibs on all other systems if necessary.
6500
7649
if test "$build_libtool_need_lc" = "yes"; then
6501
deplibs="$deplibs -lc"
7650
func_append deplibs " -lc"
6502
7651
fi
6503
7652
;;
6504
7653
esac
6547
7696
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6548
7697
case " $predeps $postdeps " in
6549
7698
*" $i "*)
6550
newdeplibs="$newdeplibs $i"
7699
func_append newdeplibs " $i"
6551
7700
i=""
6552
7701
;;
6553
7702
esac
6558
7707
set dummy $deplib_matches; shift
6559
7708
deplib_match=$1
6560
7709
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6561
newdeplibs="$newdeplibs $i"
7710
func_append newdeplibs " $i"
6562
7711
else
6563
7712
droppeddeps=yes
6564
$ECHO
7713
echo
6565
7714
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6566
$ECHO "*** I have the capability to make that library automatically link in when"
6567
$ECHO "*** you link to this library. But I can only do this if you have a"
6568
$ECHO "*** shared version of the library, which I believe you do not have"
6569
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6570
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7715
echo "*** I have the capability to make that library automatically link in when"
7716
echo "*** you link to this library. But I can only do this if you have a"
7717
echo "*** shared version of the library, which I believe you do not have"
7718
echo "*** because a test_compile did reveal that the linker did not use it for"
7719
echo "*** its dynamic dependency list that programs get resolved with at runtime."
6571
7720
fi
6572
7721
fi
6573
7722
;;
6574
7723
*)
6575
newdeplibs="$newdeplibs $i"
7724
func_append newdeplibs " $i"
6576
7725
;;
6577
7726
esac
6578
7727
done
6590
7739
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6591
7740
case " $predeps $postdeps " in
6592
7741
*" $i "*)
6593
newdeplibs="$newdeplibs $i"
7742
func_append newdeplibs " $i"
6594
7743
i=""
6595
7744
;;
6596
7745
esac
6601
7750
set dummy $deplib_matches; shift
6602
7751
deplib_match=$1
6603
7752
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6604
newdeplibs="$newdeplibs $i"
7753
func_append newdeplibs " $i"
6605
7754
else
6606
7755
droppeddeps=yes
6607
$ECHO
7756
echo
6608
7757
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6609
$ECHO "*** I have the capability to make that library automatically link in when"
6610
$ECHO "*** you link to this library. But I can only do this if you have a"
6611
$ECHO "*** shared version of the library, which you do not appear to have"
6612
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6613
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7758
echo "*** I have the capability to make that library automatically link in when"
7759
echo "*** you link to this library. But I can only do this if you have a"
7760
echo "*** shared version of the library, which you do not appear to have"
7761
echo "*** because a test_compile did reveal that the linker did not use this one"
7762
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6614
7763
fi
6615
7764
fi
6616
7765
else
6617
7766
droppeddeps=yes
6618
$ECHO
7767
echo
6619
7768
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6620
$ECHO "*** make it link in! You will probably need to install it or some"
6621
$ECHO "*** library that it depends on before this library will be fully"
6622
$ECHO "*** functional. Installing it before continuing would be even better."
7769
echo "*** make it link in! You will probably need to install it or some"
7770
echo "*** library that it depends on before this library will be fully"
7771
echo "*** functional. Installing it before continuing would be even better."
6623
7772
fi
6624
7773
;;
6625
7774
*)
6626
newdeplibs="$newdeplibs $i"
7775
func_append newdeplibs " $i"
6627
7776
;;
6628
7777
esac
6629
7778
done
6640
7789
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6641
7790
case " $predeps $postdeps " in
6642
7791
*" $a_deplib "*)
6643
newdeplibs="$newdeplibs $a_deplib"
7792
func_append newdeplibs " $a_deplib"
6644
7793
a_deplib=""
6645
7794
;;
6646
7795
esac
6647
7796
fi
6648
7797
if test -n "$a_deplib" ; then
6649
7798
libname=`eval "\\$ECHO \"$libname_spec\""`
7799
if test -n "$file_magic_glob"; then
7800
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7801
else
7802
libnameglob=$libname
7803
fi
7804
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
6650
7805
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6651
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7806
if test "$want_nocaseglob" = yes; then
7807
shopt -s nocaseglob
7808
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7809
$nocaseglob
7810
else
7811
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7812
fi
6652
7813
for potent_lib in $potential_libs; do
6653
7814
# Follow soft links.
6654
7815
if ls -lLd "$potent_lib" 2>/dev/null |
6665
7826
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6666
7827
case $potliblink in
6667
7828
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6668
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7829
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
6669
7830
esac
6670
7831
done
6671
7832
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6672
7833
$SED -e 10q |
6673
7834
$EGREP "$file_magic_regex" > /dev/null; then
6674
newdeplibs="$newdeplibs $a_deplib"
7835
func_append newdeplibs " $a_deplib"
6675
7836
a_deplib=""
6676
7837
break 2
6677
7838
fi
6680
7841
fi
6681
7842
if test -n "$a_deplib" ; then
6682
7843
droppeddeps=yes
6683
$ECHO
7844
echo
6684
7845
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6685
$ECHO "*** I have the capability to make that library automatically link in when"
6686
$ECHO "*** you link to this library. But I can only do this if you have a"
6687
$ECHO "*** shared version of the library, which you do not appear to have"
6688
$ECHO "*** because I did check the linker path looking for a file starting"
7846
echo "*** I have the capability to make that library automatically link in when"
7847
echo "*** you link to this library. But I can only do this if you have a"
7848
echo "*** shared version of the library, which you do not appear to have"
7849
echo "*** because I did check the linker path looking for a file starting"
6689
7850
if test -z "$potlib" ; then
6690
7851
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6691
7852
else
6696
7857
;;
6697
7858
*)
6698
7859
# Add a -L argument.
6699
newdeplibs="$newdeplibs $a_deplib"
7860
func_append newdeplibs " $a_deplib"
6700
7861
;;
6701
7862
esac
6702
7863
done # Gone through all deplibs.
6712
7873
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6713
7874
case " $predeps $postdeps " in
6714
7875
*" $a_deplib "*)
6715
newdeplibs="$newdeplibs $a_deplib"
7876
func_append newdeplibs " $a_deplib"
6716
7877
a_deplib=""
6717
7878
;;
6718
7879
esac
6723
7884
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6724
7885
for potent_lib in $potential_libs; do
6725
7886
potlib="$potent_lib" # see symlink-check above in file_magic test
6726
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7887
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
6727
7888
$EGREP "$match_pattern_regex" > /dev/null; then
6728
newdeplibs="$newdeplibs $a_deplib"
7889
func_append newdeplibs " $a_deplib"
6729
7890
a_deplib=""
6730
7891
break 2
6731
7892
fi
6734
7895
fi
6735
7896
if test -n "$a_deplib" ; then
6736
7897
droppeddeps=yes
6737
$ECHO
7898
echo
6738
7899
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6739
$ECHO "*** I have the capability to make that library automatically link in when"
6740
$ECHO "*** you link to this library. But I can only do this if you have a"
6741
$ECHO "*** shared version of the library, which you do not appear to have"
6742
$ECHO "*** because I did check the linker path looking for a file starting"
7900
echo "*** I have the capability to make that library automatically link in when"
7901
echo "*** you link to this library. But I can only do this if you have a"
7902
echo "*** shared version of the library, which you do not appear to have"
7903
echo "*** because I did check the linker path looking for a file starting"
6743
7904
if test -z "$potlib" ; then
6744
7905
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6745
7906
else
6750
7911
;;
6751
7912
*)
6752
7913
# Add a -L argument.
6753
newdeplibs="$newdeplibs $a_deplib"
7914
func_append newdeplibs " $a_deplib"
6754
7915
;;
6755
7916
esac
6756
7917
done # Gone through all deplibs.
6757
7918
;;
6758
7919
none | unknown | *)
6759
7920
newdeplibs=""
6760
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6761
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7921
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6762
7922
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6763
7923
for i in $predeps $postdeps ; do
6764
7924
# can't use Xsed below, because $i might contain '/'
6765
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7925
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
6766
7926
done
6767
7927
fi
6768
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6769
$GREP . >/dev/null; then
6770
$ECHO
7928
case $tmp_deplibs in
7929
*[!\ \ ]*)
7930
echo
6771
7931
if test "X$deplibs_check_method" = "Xnone"; then
6772
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7932
echo "*** Warning: inter-library dependencies are not supported in this platform."
6773
7933
else
6774
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
7934
echo "*** Warning: inter-library dependencies are not known to be supported."
6775
7935
fi
6776
$ECHO "*** All declared inter-library dependencies are being dropped."
7936
echo "*** All declared inter-library dependencies are being dropped."
6777
7937
droppeddeps=yes
6778
fi
7938
;;
7939
esac
6779
7940
;;
6780
7941
esac
6781
7942
versuffix=$versuffix_save
6787
7948
case $host in
6788
7949
*-*-rhapsody* | *-*-darwin1.[012])
6789
7950
# On Rhapsody replace the C library with the System framework
6790
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7951
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
6791
7952
;;
6792
7953
esac
6793
7954
6794
7955
if test "$droppeddeps" = yes; then
6795
7956
if test "$module" = yes; then
6796
$ECHO
6797
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7957
echo
7958
echo "*** Warning: libtool could not satisfy all declared inter-library"
6798
7959
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6799
$ECHO "*** a static module, that should work as long as the dlopening"
6800
$ECHO "*** application is linked with the -dlopen flag."
7960
echo "*** a static module, that should work as long as the dlopening"
7961
echo "*** application is linked with the -dlopen flag."
6801
7962
if test -z "$global_symbol_pipe"; then
6802
$ECHO
6803
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6804
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6805
$ECHO "*** not find such a program. So, this module is probably useless."
6806
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7963
echo
7964
echo "*** However, this would only work if libtool was able to extract symbol"
7965
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7966
echo "*** not find such a program. So, this module is probably useless."
7967
echo "*** \`nm' from GNU binutils and a full rebuild may help."
6807
7968
fi
6808
7969
if test "$build_old_libs" = no; then
6809
7970
oldlibs="$output_objdir/$libname.$libext"
6813
7974
build_libtool_libs=no
6814
7975
fi
6815
7976
else
6816
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6817
$ECHO "*** automatically added whenever a program is linked with this library"
6818
$ECHO "*** or is declared to -dlopen it."
7977
echo "*** The inter-library dependencies that have been dropped here will be"
7978
echo "*** automatically added whenever a program is linked with this library"
7979
echo "*** or is declared to -dlopen it."
6819
7980
6820
7981
if test "$allow_undefined" = no; then
6821
$ECHO
6822
$ECHO "*** Since this library must not contain undefined symbols,"
6823
$ECHO "*** because either the platform does not support them or"
6824
$ECHO "*** it was explicitly requested with -no-undefined,"
6825
$ECHO "*** libtool will only create a static version of it."
7982
echo
7983
echo "*** Since this library must not contain undefined symbols,"
7984
echo "*** because either the platform does not support them or"
7985
echo "*** it was explicitly requested with -no-undefined,"
7986
echo "*** libtool will only create a static version of it."
6826
7987
if test "$build_old_libs" = no; then
6827
7988
oldlibs="$output_objdir/$libname.$libext"
6828
7989
build_libtool_libs=module
6839
8000
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6840
8001
case $host in
6841
8002
*-*-darwin*)
6842
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6843
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6844
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8003
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8004
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8005
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6845
8006
;;
6846
8007
esac
6847
8008
6854
8015
*)
6855
8016
case " $deplibs " in
6856
8017
*" -L$path/$objdir "*)
6857
new_libs="$new_libs -L$path/$objdir" ;;
8018
func_append new_libs " -L$path/$objdir" ;;
6858
8019
esac
6859
8020
;;
6860
8021
esac
6864
8025
-L*)
6865
8026
case " $new_libs " in
6866
8027
*" $deplib "*) ;;
6867
*) new_libs="$new_libs $deplib" ;;
8028
*) func_append new_libs " $deplib" ;;
6868
8029
esac
6869
8030
;;
6870
*) new_libs="$new_libs $deplib" ;;
8031
*) func_append new_libs " $deplib" ;;
6871
8032
esac
6872
8033
done
6873
8034
deplibs="$new_libs"
6884
8045
hardcode_libdirs=
6885
8046
dep_rpath=
6886
8047
rpath="$finalize_rpath"
6887
test "$mode" != relink && rpath="$compile_rpath$rpath"
8048
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
6888
8049
for libdir in $rpath; do
6889
8050
if test -n "$hardcode_libdir_flag_spec"; then
6890
8051
if test -n "$hardcode_libdir_separator"; then
8052
func_replace_sysroot "$libdir"
8053
libdir=$func_replace_sysroot_result
6891
8054
if test -z "$hardcode_libdirs"; then
6892
8055
hardcode_libdirs="$libdir"
6893
8056
else
6896
8059
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6897
8060
;;
6898
8061
*)
6899
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8062
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
6900
8063
;;
6901
8064
esac
6902
8065
fi
6903
8066
else
6904
8067
eval flag=\"$hardcode_libdir_flag_spec\"
6905
dep_rpath="$dep_rpath $flag"
8068
func_append dep_rpath " $flag"
6906
8069
fi
6907
8070
elif test -n "$runpath_var"; then
6908
8071
case "$perm_rpath " in
6909
8072
*" $libdir "*) ;;
6910
*) perm_rpath="$perm_rpath $libdir" ;;
8073
*) func_apped perm_rpath " $libdir" ;;
6911
8074
esac
6912
8075
fi
6913
8076
done
6925
8088
# We should set the runpath_var.
6926
8089
rpath=
6927
8090
for dir in $perm_rpath; do
6928
rpath="$rpath$dir:"
8091
func_append rpath "$dir:"
6929
8092
done
6930
8093
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6931
8094
fi
6933
8096
fi
6934
8097
6935
8098
shlibpath="$finalize_shlibpath"
6936
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8099
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6937
8100
if test -n "$shlibpath"; then
6938
8101
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6939
8102
fi
6959
8122
linknames=
6960
8123
for link
6961
8124
do
6962
linknames="$linknames $link"
8125
func_append linknames " $link"
6963
8126
done
6964
8127
6965
8128
# Use standard objects if they are pic
6966
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8129
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
6967
8130
test "X$libobjs" = "X " && libobjs=
6968
8131
6969
8132
delfiles=
6970
8133
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6971
8134
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6972
8135
export_symbols="$output_objdir/$libname.uexp"
6973
delfiles="$delfiles $export_symbols"
8136
func_append delfiles " $export_symbols"
6974
8137
fi
6975
8138
6976
8139
orig_export_symbols=
7001
8164
$opt_dry_run || $RM $export_symbols
7002
8165
cmds=$export_symbols_cmds
7003
8166
save_ifs="$IFS"; IFS='~'
7004
for cmd in $cmds; do
8167
for cmd1 in $cmds; do
7005
8168
IFS="$save_ifs"
7006
eval cmd=\"$cmd\"
7007
func_len " $cmd"
7008
len=$func_len_result
7009
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7010
func_show_eval "$cmd" 'exit $?'
8169
# Take the normal branch if the nm_file_list_spec branch
8170
# doesn't work or if tool conversion is not needed.
8171
case $nm_file_list_spec~$to_tool_file_cmd in
8172
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8173
try_normal_branch=yes
8174
eval cmd=\"$cmd1\"
8175
func_len " $cmd"
8176
len=$func_len_result
8177
;;
8178
*)
8179
try_normal_branch=no
8180
;;
8181
esac
8182
if test "$try_normal_branch" = yes \
8183
&& { test "$len" -lt "$max_cmd_len" \
8184
|| test "$max_cmd_len" -le -1; }
8185
then
8186
func_show_eval "$cmd" 'exit $?'
8187
skipped_export=false
8188
elif test -n "$nm_file_list_spec"; then
8189
func_basename "$output"
8190
output_la=$func_basename_result
8191
save_libobjs=$libobjs
8192
save_output=$output
8193
output=${output_objdir}/${output_la}.nm
8194
func_to_tool_file "$output"
8195
libobjs=$nm_file_list_spec$func_to_tool_file_result
8196
func_append delfiles " $output"
8197
func_verbose "creating $NM input file list: $output"
8198
for obj in $save_libobjs; do
8199
func_to_tool_file "$obj"
8200
$ECHO "$func_to_tool_file_result"
8201
done > "$output"
8202
eval cmd=\"$cmd1\"
8203
func_show_eval "$cmd" 'exit $?'
8204
output=$save_output
8205
libobjs=$save_libobjs
7011
8206
skipped_export=false
7012
8207
else
7013
8208
# The command line is too long to execute in one step.
7029
8224
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7030
8225
tmp_export_symbols="$export_symbols"
7031
8226
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7032
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
8227
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7033
8228
fi
7034
8229
7035
8230
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7041
8236
# global variables. join(1) would be nice here, but unfortunately
7042
8237
# isn't a blessed tool.
7043
8238
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7044
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
8239
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7045
8240
export_symbols=$output_objdir/$libname.def
7046
8241
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7047
8242
fi
7051
8246
case " $convenience " in
7052
8247
*" $test_deplib "*) ;;
7053
8248
*)
7054
tmp_deplibs="$tmp_deplibs $test_deplib"
8249
func_append tmp_deplibs " $test_deplib"
7055
8250
;;
7056
8251
esac
7057
8252
done
7071
8266
test "X$libobjs" = "X " && libobjs=
7072
8267
else
7073
8268
gentop="$output_objdir/${outputname}x"
7074
generated="$generated $gentop"
8269
func_append generated " $gentop"
7075
8270
7076
8271
func_extract_archives $gentop $convenience
7077
libobjs="$libobjs $func_extract_archives_result"
8272
func_append libobjs " $func_extract_archives_result"
7078
8273
test "X$libobjs" = "X " && libobjs=
7079
8274
fi
7080
8275
fi
7081
8276
7082
8277
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7083
8278
eval flag=\"$thread_safe_flag_spec\"
7084
linker_flags="$linker_flags $flag"
8279
func_append linker_flags " $flag"
7085
8280
fi
7086
8281
7087
8282
# Make a backup of the uninstalled library when relinking
7088
if test "$mode" = relink; then
8283
if test "$opt_mode" = relink; then
7089
8284
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7090
8285
fi
7091
8286
7130
8325
save_libobjs=$libobjs
7131
8326
fi
7132
8327
save_output=$output
7133
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
8328
func_basename "$output"
8329
output_la=$func_basename_result
7134
8330
7135
8331
# Clear the reloadable object creation command queue and
7136
8332
# initialize k to one.
7143
8339
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7144
8340
output=${output_objdir}/${output_la}.lnkscript
7145
8341
func_verbose "creating GNU ld script: $output"
7146
$ECHO 'INPUT (' > $output
8342
echo 'INPUT (' > $output
7147
8343
for obj in $save_libobjs
7148
8344
do
7149
$ECHO "$obj" >> $output
8345
func_to_tool_file "$obj"
8346
$ECHO "$func_to_tool_file_result" >> $output
7150
8347
done
7151
$ECHO ')' >> $output
7152
delfiles="$delfiles $output"
8348
echo ')' >> $output
8349
func_append delfiles " $output"
8350
func_to_tool_file "$output"
8351
output=$func_to_tool_file_result
7153
8352
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7154
8353
output=${output_objdir}/${output_la}.lnk
7155
8354
func_verbose "creating linker input file list: $output"
7163
8362
fi
7164
8363
for obj
7165
8364
do
7166
$ECHO "$obj" >> $output
8365
func_to_tool_file "$obj"
8366
$ECHO "$func_to_tool_file_result" >> $output
7167
8367
done
7168
delfiles="$delfiles $output"
7169
output=$firstobj\"$file_list_spec$output\"
8368
func_append delfiles " $output"
8369
func_to_tool_file "$output"
8370
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
7170
8371
else
7171
8372
if test -n "$save_libobjs"; then
7172
8373
func_verbose "creating reloadable object files..."
7190
8391
# command to the queue.
7191
8392
if test "$k" -eq 1 ; then
7192
8393
# The first file doesn't have a previous command to add.
7193
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
8394
reload_objs=$objlist
8395
eval concat_cmds=\"$reload_cmds\"
7194
8396
else
7195
8397
# All subsequent reloadable object files will link in
7196
8398
# the last one created.
7197
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
8399
reload_objs="$objlist $last_robj"
8400
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
7198
8401
fi
7199
8402
last_robj=$output_objdir/$output_la-${k}.$objext
7200
8403
func_arith $k + 1
7201
8404
k=$func_arith_result
7202
8405
output=$output_objdir/$output_la-${k}.$objext
7203
objlist=$obj
8406
objlist=" $obj"
7204
8407
func_len " $last_robj"
7205
8408
func_arith $len0 + $func_len_result
7206
8409
len=$func_arith_result
7210
8413
# reloadable object file. All subsequent reloadable object
7211
8414
# files will link in the last one created.
7212
8415
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7213
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
8416
reload_objs="$objlist $last_robj"
8417
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
7214
8418
if test -n "$last_robj"; then
7215
8419
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7216
8420
fi
7217
delfiles="$delfiles $output"
8421
func_append delfiles " $output"
7218
8422
7219
8423
else
7220
8424
output=
7248
8452
lt_exit=$?
7249
8453
7250
8454
# Restore the uninstalled library and exit
7251
if test "$mode" = relink; then
8455
if test "$opt_mode" = relink; then
7252
8456
( cd "$output_objdir" && \
7253
8457
$RM "${realname}T" && \
7254
8458
$MV "${realname}U" "$realname" )
7269
8473
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7270
8474
tmp_export_symbols="$export_symbols"
7271
8475
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7272
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
8476
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7273
8477
fi
7274
8478
7275
8479
if test -n "$orig_export_symbols"; then
7281
8485
# global variables. join(1) would be nice here, but unfortunately
7282
8486
# isn't a blessed tool.
7283
8487
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7284
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
8488
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7285
8489
export_symbols=$output_objdir/$libname.def
7286
8490
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7287
8491
fi
7322
8526
# Add any objects from preloaded convenience libraries
7323
8527
if test -n "$dlprefiles"; then
7324
8528
gentop="$output_objdir/${outputname}x"
7325
generated="$generated $gentop"
8529
func_append generated " $gentop"
7326
8530
7327
8531
func_extract_archives $gentop $dlprefiles
7328
libobjs="$libobjs $func_extract_archives_result"
8532
func_append libobjs " $func_extract_archives_result"
7329
8533
test "X$libobjs" = "X " && libobjs=
7330
8534
fi
7331
8535
7341
8545
lt_exit=$?
7342
8546
7343
8547
# Restore the uninstalled library and exit
7344
if test "$mode" = relink; then
8548
if test "$opt_mode" = relink; then
7345
8549
( cd "$output_objdir" && \
7346
8550
$RM "${realname}T" && \
7347
8551
$MV "${realname}U" "$realname" )
7353
8557
IFS="$save_ifs"
7354
8558
7355
8559
# Restore the uninstalled library and exit
7356
if test "$mode" = relink; then
8560
if test "$opt_mode" = relink; then
7357
8561
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7358
8562
7359
8563
if test -n "$convenience"; then
7434
8638
if test -n "$convenience"; then
7435
8639
if test -n "$whole_archive_flag_spec"; then
7436
8640
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7437
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
8641
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
7438
8642
else
7439
8643
gentop="$output_objdir/${obj}x"
7440
generated="$generated $gentop"
8644
func_append generated " $gentop"
7441
8645
7442
8646
func_extract_archives $gentop $convenience
7443
8647
reload_conv_objs="$reload_objs $func_extract_archives_result"
7444
8648
fi
7445
8649
fi
7446
8650
8651
# If we're not building shared, we need to use non_pic_objs
8652
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8653
7447
8654
# Create the old-style object.
7448
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
8655
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7449
8656
7450
8657
output="$obj"
7451
8658
func_execute_cmds "$reload_cmds" 'exit $?'
7505
8712
case $host in
7506
8713
*-*-rhapsody* | *-*-darwin1.[012])
7507
8714
# On Rhapsody replace the C library is the System framework
7508
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7509
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8715
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8716
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
7510
8717
;;
7511
8718
esac
7512
8719
7517
8724
if test "$tagname" = CXX ; then
7518
8725
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7519
8726
10.[0123])
7520
compile_command="$compile_command ${wl}-bind_at_load"
7521
finalize_command="$finalize_command ${wl}-bind_at_load"
8727
func_append compile_command " ${wl}-bind_at_load"
8728
func_append finalize_command " ${wl}-bind_at_load"
7522
8729
;;
7523
8730
esac
7524
8731
fi
7525
8732
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7526
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7527
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8733
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8734
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7528
8735
;;
7529
8736
esac
7530
8737
7538
8745
*)
7539
8746
case " $compile_deplibs " in
7540
8747
*" -L$path/$objdir "*)
7541
new_libs="$new_libs -L$path/$objdir" ;;
8748
func_append new_libs " -L$path/$objdir" ;;
7542
8749
esac
7543
8750
;;
7544
8751
esac
7548
8755
-L*)
7549
8756
case " $new_libs " in
7550
8757
*" $deplib "*) ;;
7551
*) new_libs="$new_libs $deplib" ;;
8758
*) func_append new_libs " $deplib" ;;
7552
8759
esac
7553
8760
;;
7554
*) new_libs="$new_libs $deplib" ;;
8761
*) func_append new_libs " $deplib" ;;
7555
8762
esac
7556
8763
done
7557
8764
compile_deplibs="$new_libs"
7558
8765
7559
8766
7560
compile_command="$compile_command $compile_deplibs"
7561
finalize_command="$finalize_command $finalize_deplibs"
8767
func_append compile_command " $compile_deplibs"
8768
func_append finalize_command " $finalize_deplibs"
7562
8769
7563
8770
if test -n "$rpath$xrpath"; then
7564
8771
# If the user specified any rpath flags, then add them.
7566
8773
# This is the magic to use -rpath.
7567
8774
case "$finalize_rpath " in
7568
8775
*" $libdir "*) ;;
7569
*) finalize_rpath="$finalize_rpath $libdir" ;;
8776
*) func_append finalize_rpath " $libdir" ;;
7570
8777
esac
7571
8778
done
7572
8779
fi
7585
8792
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7586
8793
;;
7587
8794
*)
7588
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8795
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7589
8796
;;
7590
8797
esac
7591
8798
fi
7592
8799
else
7593
8800
eval flag=\"$hardcode_libdir_flag_spec\"
7594
rpath="$rpath $flag"
8801
func_append rpath " $flag"
7595
8802
fi
7596
8803
elif test -n "$runpath_var"; then
7597
8804
case "$perm_rpath " in
7598
8805
*" $libdir "*) ;;
7599
*) perm_rpath="$perm_rpath $libdir" ;;
8806
*) func_append perm_rpath " $libdir" ;;
7600
8807
esac
7601
8808
fi
7602
8809
case $host in
7605
8812
case :$dllsearchpath: in
7606
8813
*":$libdir:"*) ;;
7607
8814
::) dllsearchpath=$libdir;;
7608
*) dllsearchpath="$dllsearchpath:$libdir";;
8815
*) func_append dllsearchpath ":$libdir";;
7609
8816
esac
7610
8817
case :$dllsearchpath: in
7611
8818
*":$testbindir:"*) ;;
7612
8819
::) dllsearchpath=$testbindir;;
7613
*) dllsearchpath="$dllsearchpath:$testbindir";;
8820
*) func_append dllsearchpath ":$testbindir";;
7614
8821
esac
7615
8822
;;
7616
8823
esac
7636
8843
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7637
8844
;;
7638
8845
*)
7639
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8846
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7640
8847
;;
7641
8848
esac
7642
8849
fi
7643
8850
else
7644
8851
eval flag=\"$hardcode_libdir_flag_spec\"
7645
rpath="$rpath $flag"
8852
func_append rpath " $flag"
7646
8853
fi
7647
8854
elif test -n "$runpath_var"; then
7648
8855
case "$finalize_perm_rpath " in
7649
8856
*" $libdir "*) ;;
7650
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8857
*) func_append finalize_perm_rpath " $libdir" ;;
7651
8858
esac
7652
8859
fi
7653
8860
done
7661
8868
7662
8869
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7663
8870
# Transform all the library objects into standard objects.
7664
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7665
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8871
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8872
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7666
8873
fi
7667
8874
7668
8875
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7674
8881
7675
8882
wrappers_required=yes
7676
8883
case $host in
8884
*cegcc* | *mingw32ce*)
8885
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8886
wrappers_required=no
8887
;;
7677
8888
*cygwin* | *mingw* )
7678
8889
if test "$build_libtool_libs" != yes; then
7679
8890
wrappers_required=no
7680
8891
fi
7681
8892
;;
7682
*cegcc)
7683
# Disable wrappers for cegcc, we are cross compiling anyway.
7684
wrappers_required=no
7685
;;
7686
8893
*)
7687
8894
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7688
8895
wrappers_required=no
7691
8898
esac
7692
8899
if test "$wrappers_required" = no; then
7693
8900
# Replace the output file specification.
7694
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8901
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7695
8902
link_command="$compile_command$compile_rpath"
7696
8903
7697
8904
# We have no uninstalled library dependencies, so finalize right now.
7698
8905
exit_status=0
7699
8906
func_show_eval "$link_command" 'exit_status=$?'
7700
8907
8908
if test -n "$postlink_cmds"; then
8909
func_to_tool_file "$output"
8910
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8911
func_execute_cmds "$postlink_cmds" 'exit $?'
8912
fi
8913
7701
8914
# Delete the generated files.
7702
8915
if test -f "$output_objdir/${outputname}S.${objext}"; then
7703
8916
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7720
8933
# We should set the runpath_var.
7721
8934
rpath=
7722
8935
for dir in $perm_rpath; do
7723
rpath="$rpath$dir:"
8936
func_append rpath "$dir:"
7724
8937
done
7725
8938
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7726
8939
fi
7728
8941
# We should set the runpath_var.
7729
8942
rpath=
7730
8943
for dir in $finalize_perm_rpath; do
7731
rpath="$rpath$dir:"
8944
func_append rpath "$dir:"
7732
8945
done
7733
8946
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7734
8947
fi
7738
8951
# We don't need to create a wrapper script.
7739
8952
link_command="$compile_var$compile_command$compile_rpath"
7740
8953
# Replace the output file specification.
7741
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8954
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7742
8955
# Delete the old output file.
7743
8956
$opt_dry_run || $RM $output
7744
8957
# Link the executable and exit
7745
8958
func_show_eval "$link_command" 'exit $?'
8959
8960
if test -n "$postlink_cmds"; then
8961
func_to_tool_file "$output"
8962
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8963
func_execute_cmds "$postlink_cmds" 'exit $?'
8964
fi
8965
7746
8966
exit $EXIT_SUCCESS
7747
8967
fi
7748
8968
7757
8977
if test "$fast_install" != no; then
7758
8978
link_command="$finalize_var$compile_command$finalize_rpath"
7759
8979
if test "$fast_install" = yes; then
7760
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8980
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7761
8981
else
7762
8982
# fast_install is set to needless
7763
8983
relink_command=
7769
8989
fi
7770
8990
7771
8991
# Replace the output file specification.
7772
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8992
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7773
8993
7774
8994
# Delete the old output files.
7775
8995
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7776
8996
7777
8997
func_show_eval "$link_command" 'exit $?'
7778
8998
8999
if test -n "$postlink_cmds"; then
9000
func_to_tool_file "$output_objdir/$outputname"
9001
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'`
9002
func_execute_cmds "$postlink_cmds" 'exit $?'
9003
fi
9004
7779
9005
# Now create the wrapper script.
7780
9006
func_verbose "creating $output"
7781
9007
7793
9019
fi
7794
9020
done
7795
9021
relink_command="(cd `pwd`; $relink_command)"
7796
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7797
fi
7798
7799
# Quote $ECHO for shipping.
7800
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7801
case $progpath in
7802
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7803
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7804
esac
7805
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7806
else
7807
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
9022
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
7808
9023
fi
7809
9024
7810
9025
# Only actually do things if not in dry run mode.
7884
9099
else
7885
9100
oldobjs="$old_deplibs $non_pic_objects"
7886
9101
if test "$preload" = yes && test -f "$symfileobj"; then
7887
oldobjs="$oldobjs $symfileobj"
9102
func_append oldobjs " $symfileobj"
7888
9103
fi
7889
9104
fi
7890
9105
addlibs="$old_convenience"
7892
9107
7893
9108
if test -n "$addlibs"; then
7894
9109
gentop="$output_objdir/${outputname}x"
7895
generated="$generated $gentop"
9110
func_append generated " $gentop"
7896
9111
7897
9112
func_extract_archives $gentop $addlibs
7898
oldobjs="$oldobjs $func_extract_archives_result"
9113
func_append oldobjs " $func_extract_archives_result"
7899
9114
fi
7900
9115
7901
9116
# Do each command in the archive commands.
7906
9121
# Add any objects from preloaded convenience libraries
7907
9122
if test -n "$dlprefiles"; then
7908
9123
gentop="$output_objdir/${outputname}x"
7909
generated="$generated $gentop"
9124
func_append generated " $gentop"
7910
9125
7911
9126
func_extract_archives $gentop $dlprefiles
7912
oldobjs="$oldobjs $func_extract_archives_result"
9127
func_append oldobjs " $func_extract_archives_result"
7913
9128
fi
7914
9129
7915
9130
# POSIX demands no paths to be encoded in archives. We have
7925
9140
done | sort | sort -uc >/dev/null 2>&1); then
7926
9141
:
7927
9142
else
7928
$ECHO "copying selected object files to avoid basename conflicts..."
9143
echo "copying selected object files to avoid basename conflicts..."
7929
9144
gentop="$output_objdir/${outputname}x"
7930
generated="$generated $gentop"
9145
func_append generated " $gentop"
7931
9146
func_mkdir_p "$gentop"
7932
9147
save_oldobjs=$oldobjs
7933
9148
oldobjs=
7951
9166
esac
7952
9167
done
7953
9168
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7954
oldobjs="$oldobjs $gentop/$newobj"
9169
func_append oldobjs " $gentop/$newobj"
7955
9170
;;
7956
*) oldobjs="$oldobjs $obj" ;;
9171
*) func_append oldobjs " $obj" ;;
7957
9172
esac
7958
9173
done
7959
9174
fi
7963
9178
len=$func_len_result
7964
9179
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7965
9180
cmds=$old_archive_cmds
9181
elif test -n "$archiver_list_spec"; then
9182
func_verbose "using command file archive linking..."
9183
for obj in $oldobjs
9184
do
9185
func_to_tool_file "$obj"
9186
$ECHO "$func_to_tool_file_result"
9187
done > $output_objdir/$libname.libcmd
9188
func_to_tool_file "$output_objdir/$libname.libcmd"
9189
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9190
cmds=$old_archive_cmds
7966
9191
else
7967
9192
# the command line is too long to link in one step, link in parts
7968
9193
func_verbose "using piecewise archive linking..."
8036
9261
done
8037
9262
# Quote the link command for shipping.
8038
9263
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8039
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
9264
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8040
9265
if test "$hardcode_automatic" = yes ; then
8041
9266
relink_command=
8042
9267
fi
8059
9284
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8060
9285
test -z "$libdir" && \
8061
9286
func_fatal_error "\`$deplib' is not a valid libtool archive"
8062
newdependency_libs="$newdependency_libs $libdir/$name"
8063
;;
8064
*) newdependency_libs="$newdependency_libs $deplib" ;;
9287
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9288
;;
9289
-L*)
9290
func_stripname -L '' "$deplib"
9291
func_replace_sysroot "$func_stripname_result"
9292
func_append newdependency_libs " -L$func_replace_sysroot_result"
9293
;;
9294
-R*)
9295
func_stripname -R '' "$deplib"
9296
func_replace_sysroot "$func_stripname_result"
9297
func_append newdependency_libs " -R$func_replace_sysroot_result"
9298
;;
9299
*) func_append newdependency_libs " $deplib" ;;
8065
9300
esac
8066
9301
done
8067
9302
dependency_libs="$newdependency_libs"
8075
9310
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8076
9311
test -z "$libdir" && \
8077
9312
func_fatal_error "\`$lib' is not a valid libtool archive"
8078
newdlfiles="$newdlfiles $libdir/$name"
9313
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
8079
9314
;;
8080
*) newdlfiles="$newdlfiles $lib" ;;
9315
*) func_append newdlfiles " $lib" ;;
8081
9316
esac
8082
9317
done
8083
9318
dlfiles="$newdlfiles"
8094
9329
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8095
9330
test -z "$libdir" && \
8096
9331
func_fatal_error "\`$lib' is not a valid libtool archive"
8097
newdlprefiles="$newdlprefiles $libdir/$name"
9332
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
8098
9333
;;
8099
9334
esac
8100
9335
done
8106
9341
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8107
9342
*) abs=`pwd`"/$lib" ;;
8108
9343
esac
8109
newdlfiles="$newdlfiles $abs"
9344
func_append newdlfiles " $abs"
8110
9345
done
8111
9346
dlfiles="$newdlfiles"
8112
9347
newdlprefiles=
8115
9350
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8116
9351
*) abs=`pwd`"/$lib" ;;
8117
9352
esac
8118
newdlprefiles="$newdlprefiles $abs"
9353
func_append newdlprefiles " $abs"
8119
9354
done
8120
9355
dlprefiles="$newdlprefiles"
8121
9356
fi
8122
9357
$RM $output
8123
9358
# place dlname in correct position for cygwin
9359
# In fact, it would be nice if we could use this code for all target
9360
# systems that can't hard-code library paths into their executables
9361
# and that have no shared library path variable independent of PATH,
9362
# but it turns out we can't easily determine that from inspecting
9363
# libtool variables, so we have to hard-code the OSs to which it
9364
# applies here; at the moment, that means platforms that use the PE
9365
# object format with DLL files. See the long comment at the top of
9366
# tests/bindir.at for full details.
8124
9367
tdlname=$dlname
8125
9368
case $host,$output,$installed,$module,$dlname in
8126
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
9369
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9370
# If a -bindir argument was supplied, place the dll there.
9371
if test "x$bindir" != x ;
9372
then
9373
func_relative_path "$install_libdir" "$bindir"
9374
tdlname=$func_relative_path_result$dlname
9375
else
9376
# Otherwise fall back on heuristic.
9377
tdlname=../bin/$dlname
9378
fi
9379
;;
8127
9380
esac
8128
9381
$ECHO > $output "\
8129
9382
# $outputname - a libtool library file
8182
9435
exit $EXIT_SUCCESS
8183
9436
}
8184
9437
8185
{ test "$mode" = link || test "$mode" = relink; } &&
9438
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
8186
9439
func_mode_link ${1+"$@"}
8187
9440
8188
9441
8202
9455
for arg
8203
9456
do
8204
9457
case $arg in
8205
-f) RM="$RM $arg"; rmforce=yes ;;
8206
-*) RM="$RM $arg" ;;
8207
*) files="$files $arg" ;;
9458
-f) func_append RM " $arg"; rmforce=yes ;;
9459
-*) func_append RM " $arg" ;;
9460
*) func_append files " $arg" ;;
8208
9461
esac
8209
9462
done
8210
9463
8213
9466
8214
9467
rmdirs=
8215
9468
8216
origobjdir="$objdir"
8217
9469
for file in $files; do
8218
9470
func_dirname "$file" "" "."
8219
9471
dir="$func_dirname_result"
8220
9472
if test "X$dir" = X.; then
8221
objdir="$origobjdir"
9473
odir="$objdir"
8222
9474
else
8223
objdir="$dir/$origobjdir"
9475
odir="$dir/$objdir"
8224
9476
fi
8225
9477
func_basename "$file"
8226
9478
name="$func_basename_result"
8227
test "$mode" = uninstall && objdir="$dir"
9479
test "$opt_mode" = uninstall && odir="$dir"
8228
9480
8229
# Remember objdir for removal later, being careful to avoid duplicates
8230
if test "$mode" = clean; then
9481
# Remember odir for removal later, being careful to avoid duplicates
9482
if test "$opt_mode" = clean; then
8231
9483
case " $rmdirs " in
8232
*" $objdir "*) ;;
8233
*) rmdirs="$rmdirs $objdir" ;;
9484
*" $odir "*) ;;
9485
*) func_append rmdirs " $odir" ;;
8234
9486
esac
8235
9487
fi
8236
9488
8256
9508
8257
9509
# Delete the libtool libraries and symlinks.
8258
9510
for n in $library_names; do
8259
rmfiles="$rmfiles $objdir/$n"
9511
func_append rmfiles " $odir/$n"
8260
9512
done
8261
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
9513
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
8262
9514
8263
case "$mode" in
9515
case "$opt_mode" in
8264
9516
clean)
8265
case " $library_names " in
8266
# " " in the beginning catches empty $dlname
9517
case " $library_names " in
8267
9518
*" $dlname "*) ;;
8268
*) rmfiles="$rmfiles $objdir/$dlname" ;;
9519
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
8269
9520
esac
8270
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
9521
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
8271
9522
;;
8272
9523
uninstall)
8273
9524
if test -n "$library_names"; then
8295
9546
# Add PIC object to the list of files to remove.
8296
9547
if test -n "$pic_object" &&
8297
9548
test "$pic_object" != none; then
8298
rmfiles="$rmfiles $dir/$pic_object"
9549
func_append rmfiles " $dir/$pic_object"
8299
9550
fi
8300
9551
8301
9552
# Add non-PIC object to the list of files to remove.
8302
9553
if test -n "$non_pic_object" &&
8303
9554
test "$non_pic_object" != none; then
8304
rmfiles="$rmfiles $dir/$non_pic_object"
9555
func_append rmfiles " $dir/$non_pic_object"
8305
9556
fi
8306
9557
fi
8307
9558
;;
8308
9559
8309
9560
*)
8310
if test "$mode" = clean ; then
9561
if test "$opt_mode" = clean ; then
8311
9562
noexename=$name
8312
9563
case $file in
8313
9564
*.exe)
8317
9568
noexename=$func_stripname_result
8318
9569
# $file with .exe has already been added to rmfiles,
8319
9570
# add $file without .exe
8320
rmfiles="$rmfiles $file"
9571
func_append rmfiles " $file"
8321
9572
;;
8322
9573
esac
8323
9574
# Do a test to see if this is a libtool program.
8326
9577
func_ltwrapper_scriptname "$file"
8327
9578
relink_command=
8328
9579
func_source $func_ltwrapper_scriptname_result
8329
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
9580
func_append rmfiles " $func_ltwrapper_scriptname_result"
8330
9581
else
8331
9582
relink_command=
8332
9583
func_source $dir/$noexename
8334
9585
8335
9586
# note $name still contains .exe if it was in $file originally
8336
9587
# as does the version of $file that was added into $rmfiles
8337
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
9588
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
8338
9589
if test "$fast_install" = yes && test -n "$relink_command"; then
8339
rmfiles="$rmfiles $objdir/lt-$name"
9590
func_append rmfiles " $odir/lt-$name"
8340
9591
fi
8341
9592
if test "X$noexename" != "X$name" ; then
8342
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
9593
func_append rmfiles " $odir/lt-${noexename}.c"
8343
9594
fi
8344
9595
fi
8345
9596
fi
8347
9598
esac
8348
9599
func_show_eval "$RM $rmfiles" 'exit_status=1'
8349
9600
done
8350
objdir="$origobjdir"
8351
9601
8352
9602
# Try to remove the ${objdir}s in the directories where we deleted files
8353
9603
for dir in $rmdirs; do
8359
9609
exit $exit_status
8360
9610
}
8361
9611
8362
{ test "$mode" = uninstall || test "$mode" = clean; } &&
9612
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
8363
9613
func_mode_uninstall ${1+"$@"}
8364
9614
8365
test -z "$mode" && {
9615
test -z "$opt_mode" && {
8366
9616
help="$generic_help"
8367
9617
func_fatal_help "you must specify a MODE"
8368
9618
}
8369
9619
8370
9620
test -z "$exec_cmd" && \
8371
func_fatal_help "invalid operation mode \`$mode'"
9621
func_fatal_help "invalid operation mode \`$opt_mode'"
8372
9622
8373
9623
if test -n "$exec_cmd"; then
8374
9624
eval exec "$exec_cmd"
Loggerhead is a web-based interface for Breezy
Version: 2.0.1