« back to all changes in this revision
Viewing changes to ltmain.sh
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Package Import Robot
- Author(s): Timo Aaltonen
- Date: 2014-02-03 11:08:50 UTC
- mfrom: (0.2.1)
- Revision ID: package-import@ubuntu.com-20140203110850-tjzx85elnke9fiu3
Tags: 1.3.2.9-1
* New upstream release.
- fixes CVE-2013-0336 (Closes: #704077)
- fixes CVE-2013-1897 (Closes: #704421)
- fixes CVE-2013-2219 (Closes: #718325)
- fixes CVE-2013-4283 (Closes: #721222)
- fixes CVE-2013-4485 (Closes: #730115)
* Drop fix-CVE-2013-0312.diff, upstream.
* rules: Add new scripts to rename.
* fix-sasl-path.diff: Use a triplet path to find libsasl2. (LP:
#1088822)
* admin_scripts.diff: Add patch from upstream #47511 to fix bashisms.
* control: Add ldap-utils to -base depends.
* rules, rename-online-scripts.diff: Some scripts with .pl suffix are
meant for an online server, so instead of overwriting the offline
scripts use -online suffix.
* rules: Enable parallel build, but limit the jobs to 1 for
dh_auto_install.
* control: Bump policy to 3.9.5, no changes.
* rules: Add get-orig-source target.
* lintian-overrides: Drop obsolete entries, add comments for the rest.
- fixes CVE-2013-0336 (Closes: #704077)
- fixes CVE-2013-1897 (Closes: #704421)
- fixes CVE-2013-2219 (Closes: #718325)
- fixes CVE-2013-4283 (Closes: #721222)
- fixes CVE-2013-4485 (Closes: #730115)
* Drop fix-CVE-2013-0312.diff, upstream.
* rules: Add new scripts to rename.
* fix-sasl-path.diff: Use a triplet path to find libsasl2. (LP:
#1088822)
* admin_scripts.diff: Add patch from upstream #47511 to fix bashisms.
* control: Add ldap-utils to -base depends.
* rules, rename-online-scripts.diff: Some scripts with .pl suffix are
meant for an online server, so instead of overwriting the offline
scripts use -online suffix.
* rules: Enable parallel build, but limit the jobs to 1 for
dh_auto_install.
* control: Bump policy to 3.9.5, no changes.
* rules: Add get-orig-source target.
* lintian-overrides: Drop obsolete entries, add comments for the rest.
- files added:
- .pc/admin_scripts.diff
- .pc/admin_scripts.diff/ldap
- .pc/admin_scripts.diff/ldap/admin
- .pc/admin_scripts.diff/ldap/admin/src
- .pc/admin_scripts.diff/ldap/admin/src/scripts
- .pc/fix-sasl-path.diff
- .pc/fix-sasl-path.diff/ldap
- .pc/fix-sasl-path.diff/ldap/servers
- .pc/fix-sasl-path.diff/ldap/servers/slapd
- .pc/rename-online-scripts.diff
- .pc/rename-online-scripts.diff/ldap
- .pc/rename-online-scripts.diff/ldap/admin
- .pc/rename-online-scripts.diff/ldap/admin/src
- .pc/rename-online-scripts.diff/ldap/admin/src/scripts
- ldap/servers/plugins/sync
- ldap/servers/plugins/whoami
- rpm
- files removed:
- .pc/fix-CVE-2013-0312.diff
- .pc/fix-CVE-2013-0312.diff/ldap
- .pc/fix-CVE-2013-0312.diff/ldap/servers
- .pc/fix-CVE-2013-0312.diff/ldap/servers/plugins
- .pc/fix-CVE-2013-0312.diff/ldap/servers/plugins/chainingdb
- .pc/fix-CVE-2013-0312.diff/ldap/servers/plugins/deref
- .pc/fix-CVE-2013-0312.diff/ldap/servers/plugins/dna
- .pc/fix-CVE-2013-0312.diff/ldap/servers/plugins/replication
- .pc/fix-CVE-2013-0312.diff/ldap/servers/slapd
- .pc/fix-CVE-2013-0312.diff/ldap/servers/slapd/back-ldbm
- files modified:
- .pc/applied-patches
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.2
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, 2011 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
# --no-warn don't display warning messages
45
# --tag=TAG use configuration variables from tag TAG
46
# -v, --verbose print more informational messages than default
47
# --no-verbose don't print the extra informational messages
48
# --version print version information
49
# -h, --help, --help-all print short, long, or detailed help message
46
50
#
47
51
# MODE must be one of the following:
48
52
#
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
53
# clean remove files from the build directory
54
# compile compile a source file into a libtool object
55
# execute automatically set library path, then run a program
56
# finish complete the installation of libtool libraries
57
# install install libraries or executables
58
# link create a library or an executable
59
# uninstall remove libraries from an installed directory
56
60
#
57
# MODE-ARGS vary depending on the MODE.
61
# MODE-ARGS vary depending on the MODE. When passed as first option,
62
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
58
63
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
59
64
#
60
65
# When reporting a bug, please describe a test case to reproduce it and
61
66
# include the following information:
62
67
#
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
68
# host-triplet: $host
69
# shell: $SHELL
70
# compiler: $LTCC
71
# compiler flags: $LTCFLAGS
72
# linker: $LD (gnu? $with_gnu_ld)
73
# $progname: (GNU libtool) 2.4.2
74
# automake: $automake_version
75
# autoconf: $autoconf_version
71
76
#
72
77
# Report bugs to <bug-libtool@gnu.org>.
78
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79
# General help using GNU software: <http://www.gnu.org/gethelp/>.
73
80
74
PROGRAM=ltmain.sh
81
PROGRAM=libtool
75
82
PACKAGE=libtool
76
VERSION=2.2.6b
83
VERSION=2.4.2
77
84
TIMESTAMP=""
78
package_revision=1.3017
85
package_revision=1.3337
79
86
80
87
# Be Bourne compatible
81
88
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
91
98
BIN_SH=xpg4; export BIN_SH # for Tru64
92
99
DUALCASE=1; export DUALCASE # for MKS sh
93
100
101
# A function that is used when there is no print builtin or printf.
102
func_fallback_echo ()
103
{
104
eval 'cat <<_LTECHO_EOF
105
$1
106
_LTECHO_EOF'
107
}
108
94
109
# 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
110
lt_user_locale=
99
111
lt_safe_locale=
100
112
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
107
119
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
108
120
fi"
109
121
done
122
LC_ALL=C
123
LANGUAGE=C
124
export LANGUAGE LC_ALL
110
125
111
126
$lt_unset CDPATH
112
127
113
128
129
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130
# is ksh but when the shell is invoked as "sh" and the current value of
131
# the _XPG environment variable is not equal to 1 (one), the special
132
# positional parameter $0, within a function call, is the name of the
133
# function.
134
progpath="$0"
114
135
115
136
116
137
117
138
: ${CP="cp -f"}
118
: ${ECHO="echo"}
119
: ${EGREP="/bin/grep -E"}
120
: ${FGREP="/bin/grep -F"}
121
: ${GREP="/bin/grep"}
122
: ${LN_S="ln -s"}
139
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
123
140
: ${MAKE="make"}
124
141
: ${MKDIR="mkdir"}
125
142
: ${MV="mv -f"}
126
143
: ${RM="rm -f"}
127
: ${SED="/bin/sed"}
128
144
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
129
145
: ${Xsed="$SED -e 1s/^X//"}
130
146
144
160
dirname="s,/[^/]*$,,"
145
161
basename="s,^.*/,,"
146
162
163
# func_dirname file append nondir_replacement
164
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
165
# otherwise set result to NONDIR_REPLACEMENT.
166
func_dirname ()
167
{
168
func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
169
if test "X$func_dirname_result" = "X${1}"; then
170
func_dirname_result="${3}"
171
else
172
func_dirname_result="$func_dirname_result${2}"
173
fi
174
} # func_dirname may be replaced by extended shell implementation
175
176
177
# func_basename file
178
func_basename ()
179
{
180
func_basename_result=`$ECHO "${1}" | $SED "$basename"`
181
} # func_basename may be replaced by extended shell implementation
182
183
147
184
# func_dirname_and_basename file append nondir_replacement
148
185
# perform func_basename and func_dirname in a single function
149
186
# call:
158
195
# those functions but instead duplicate the functionality here.
159
196
func_dirname_and_basename ()
160
197
{
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"
198
# Extract subdirectory from the argument.
199
func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
200
if test "X$func_dirname_result" = "X${1}"; then
201
func_dirname_result="${3}"
202
else
203
func_dirname_result="$func_dirname_result${2}"
204
fi
205
func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
206
} # func_dirname_and_basename may be replaced by extended shell implementation
207
208
209
# func_stripname prefix suffix name
210
# strip PREFIX and SUFFIX off of NAME.
211
# PREFIX and SUFFIX must not contain globbing or regex special
212
# characters, hashes, percent signs, but SUFFIX may contain a leading
213
# dot (in which case that matches only a dot).
214
# func_strip_suffix prefix name
215
func_stripname ()
216
{
217
case ${2} in
218
.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219
*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
220
esac
221
} # func_stripname may be replaced by extended shell implementation
222
223
224
# These SED scripts presuppose an absolute path with a trailing slash.
225
pathcar='s,^/\([^/]*\).*$,\1,'
226
pathcdr='s,^/[^/]*,,'
227
removedotparts=':dotsl
228
s@/\./@/@g
229
t dotsl
230
s,/\.$,/,'
231
collapseslashes='s@/\{1,\}@/@g'
232
finalslash='s,/*$,/,'
233
234
# func_normal_abspath PATH
235
# Remove doubled-up and trailing slashes, "." path components,
236
# and cancel out any ".." path components in PATH after making
237
# it an absolute path.
238
# value returned in "$func_normal_abspath_result"
239
func_normal_abspath ()
240
{
241
# Start from root dir and reassemble the path.
242
func_normal_abspath_result=
243
func_normal_abspath_tpath=$1
244
func_normal_abspath_altnamespace=
245
case $func_normal_abspath_tpath in
246
"")
247
# Empty path, that just means $cwd.
248
func_stripname '' '/' "`pwd`"
249
func_normal_abspath_result=$func_stripname_result
250
return
251
;;
252
# The next three entries are used to spot a run of precisely
253
# two leading slashes without using negated character classes;
254
# we take advantage of case's first-match behaviour.
255
///*)
256
# Unusual form of absolute path, do nothing.
257
;;
258
//*)
259
# Not necessarily an ordinary path; POSIX reserves leading '//'
260
# and for example Cygwin uses it to access remote file shares
261
# over CIFS/SMB, so we conserve a leading double slash if found.
262
func_normal_abspath_altnamespace=/
263
;;
264
/*)
265
# Absolute path, do nothing.
266
;;
267
*)
268
# Relative path, prepend $cwd.
269
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
270
;;
271
esac
272
# Cancel out all the simple stuff to save iterations. We also want
273
# the path to end with a slash for ease of parsing, so make sure
274
# there is one (and only one) here.
275
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
276
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
277
while :; do
278
# Processed it all yet?
279
if test "$func_normal_abspath_tpath" = / ; then
280
# If we ascended to the root using ".." the result may be empty now.
281
if test -z "$func_normal_abspath_result" ; then
282
func_normal_abspath_result=/
283
fi
284
break
285
fi
286
func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
287
-e "$pathcar"`
288
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
289
-e "$pathcdr"`
290
# Figure out what to do with it
291
case $func_normal_abspath_tcomponent in
292
"")
293
# Trailing empty path component, ignore it.
294
;;
295
..)
296
# Parent dir; strip last assembled component from result.
297
func_dirname "$func_normal_abspath_result"
298
func_normal_abspath_result=$func_dirname_result
299
;;
300
*)
301
# Actual path component, append it.
302
func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
303
;;
304
esac
305
done
306
# Restore leading double-slash if one was found on entry.
307
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
308
}
309
310
# func_relative_path SRCDIR DSTDIR
311
# generates a relative path from SRCDIR to DSTDIR, with a trailing
312
# slash if non-empty, suitable for immediately appending a filename
313
# without needing to append a separator.
314
# value returned in "$func_relative_path_result"
315
func_relative_path ()
316
{
317
func_relative_path_result=
318
func_normal_abspath "$1"
319
func_relative_path_tlibdir=$func_normal_abspath_result
320
func_normal_abspath "$2"
321
func_relative_path_tbindir=$func_normal_abspath_result
322
323
# Ascend the tree starting from libdir
324
while :; do
325
# check if we have found a prefix of bindir
326
case $func_relative_path_tbindir in
327
$func_relative_path_tlibdir)
328
# found an exact match
329
func_relative_path_tcancelled=
330
break
331
;;
332
$func_relative_path_tlibdir*)
333
# found a matching prefix
334
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335
func_relative_path_tcancelled=$func_stripname_result
336
if test -z "$func_relative_path_result"; then
337
func_relative_path_result=.
338
fi
339
break
340
;;
341
*)
342
func_dirname $func_relative_path_tlibdir
343
func_relative_path_tlibdir=${func_dirname_result}
344
if test "x$func_relative_path_tlibdir" = x ; then
345
# Have to descend all the way to the root!
346
func_relative_path_result=../$func_relative_path_result
347
func_relative_path_tcancelled=$func_relative_path_tbindir
348
break
349
fi
350
func_relative_path_result=../$func_relative_path_result
351
;;
352
esac
353
done
354
355
# Now calculate path; take care to avoid doubling-up slashes.
356
func_stripname '' '/' "$func_relative_path_result"
357
func_relative_path_result=$func_stripname_result
358
func_stripname '/' '/' "$func_relative_path_tcancelled"
359
if test "x$func_stripname_result" != x ; then
360
func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
361
fi
362
363
# Normalisation. If bindir is libdir, return empty string,
364
# else relative path ending with a slash; either way, target
365
# file name can be directly appended.
366
if test ! -z "$func_relative_path_result"; then
367
func_stripname './' '' "$func_relative_path_result/"
368
func_relative_path_result=$func_stripname_result
369
fi
370
}
179
371
180
372
# 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
373
func_dirname_and_basename "$progpath"
184
374
progname=$func_basename_result
185
case $progname in
186
-*) progname=./$progname ;;
187
esac
188
375
189
376
# Make sure we have an absolute path for reexecution:
190
377
case $progpath in
196
383
;;
197
384
*)
198
385
save_IFS="$IFS"
199
IFS=:
386
IFS=${PATH_SEPARATOR-:}
200
387
for progdir in $PATH; do
201
388
IFS="$save_IFS"
202
389
test -x "$progdir/$progname" && break
215
402
# Same as above, but do not quote variable references.
216
403
double_quote_subst='s/\(["`\\]\)/\\\1/g'
217
404
405
# Sed substitution that turns a string into a regex matching for the
406
# string literally.
407
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
408
409
# Sed substitution that converts a w32 file name or path
410
# which contains forward slashes, into one that contains
411
# (escaped) backslashes. A very naive implementation.
412
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
413
218
414
# Re-`\' parameter expansions in output of double_quote_subst that were
219
415
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
220
416
# in input to double_quote_subst, that '$' was protected from expansion.
243
439
# name if it has been set yet.
244
440
func_echo ()
245
441
{
246
$ECHO "$progname${mode+: }$mode: $*"
442
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
247
443
}
248
444
249
445
# func_verbose arg...
258
454
:
259
455
}
260
456
457
# func_echo_all arg...
458
# Invoke $ECHO with all args, space-separated.
459
func_echo_all ()
460
{
461
$ECHO "$*"
462
}
463
261
464
# func_error arg...
262
465
# Echo program name prefixed message to standard error.
263
466
func_error ()
264
467
{
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
468
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
266
469
}
267
470
268
471
# func_warning arg...
269
472
# Echo program name prefixed warning message to standard error.
270
473
func_warning ()
271
474
{
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
475
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
273
476
274
477
# bash bug again:
275
478
:
326
529
case $my_directory_path in */*) ;; *) break ;; esac
327
530
328
531
# ...otherwise throw away the child directory and loop
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
532
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
330
533
done
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
534
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
332
535
333
536
save_mkdir_p_IFS="$IFS"; IFS=':'
334
537
for my_dir in $my_dir_list; do
378
581
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
379
582
fi
380
583
381
$ECHO "X$my_tmpdir" | $Xsed
584
$ECHO "$my_tmpdir"
382
585
}
383
586
384
587
392
595
{
393
596
case $1 in
394
597
*[\\\`\"\$]*)
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
598
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
396
599
*)
397
600
func_quote_for_eval_unquoted_result="$1" ;;
398
601
esac
419
622
{
420
623
case $1 in
421
624
*[\\\`\"]*)
422
my_arg=`$ECHO "X$1" | $Xsed \
625
my_arg=`$ECHO "$1" | $SED \
423
626
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
424
627
*)
425
628
my_arg="$1" ;;
488
691
fi
489
692
}
490
693
491
492
694
# func_tr_sh
695
# Turn $1 into a string suitable for a shell variable name.
696
# Result is stored in $func_tr_sh_result. All characters
697
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698
# if $1 begins with a digit, a '_' is prepended as well.
699
func_tr_sh ()
700
{
701
case $1 in
702
[0-9]* | *[!a-zA-Z0-9_]*)
703
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
704
;;
705
* )
706
func_tr_sh_result=$1
707
;;
708
esac
709
}
493
710
494
711
495
712
# func_version
496
713
# Echo version message to standard output and exit.
497
714
func_version ()
498
715
{
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
716
$opt_debug
717
718
$SED -n '/(C)/!b go
719
:more
720
/\./!{
721
N
722
s/\n# / /
723
b more
724
}
725
:go
726
/^# '$PROGRAM' (GNU /,/# warranty; / {
500
727
s/^# //
501
728
s/^# *$//
502
729
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
509
736
# Echo short help message to standard output and exit.
510
737
func_usage ()
511
738
{
512
$SED -n '/^# Usage:/,/# -h/ {
739
$opt_debug
740
741
$SED -n '/^# Usage:/,/^# *.*--help/ {
513
742
s/^# //
514
743
s/^# *$//
515
744
s/\$progname/'$progname'/
516
745
p
517
746
}' < "$progpath"
518
$ECHO
747
echo
519
748
$ECHO "run \`$progname --help | more' for full usage"
520
749
exit $?
521
750
}
522
751
523
# func_help
524
# Echo long help message to standard output and exit.
752
# func_help [NOEXIT]
753
# Echo long help message to standard output and exit,
754
# unless 'noexit' is passed as argument.
525
755
func_help ()
526
756
{
757
$opt_debug
758
527
759
$SED -n '/^# Usage:/,/# Report bugs to/ {
760
:print
528
761
s/^# //
529
762
s/^# *$//
530
763
s*\$progname*'$progname'*
534
767
s*\$LTCFLAGS*'"$LTCFLAGS"'*
535
768
s*\$LD*'"$LD"'*
536
769
s/\$with_gnu_ld/'"$with_gnu_ld"'/
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
770
s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771
s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
539
772
p
540
}' < "$progpath"
541
exit $?
773
d
774
}
775
/^# .* home page:/b print
776
/^# General help using/b print
777
' < "$progpath"
778
ret=$?
779
if test -z "$1"; then
780
exit $ret
781
fi
542
782
}
543
783
544
784
# func_missing_arg argname
546
786
# exit_cmd.
547
787
func_missing_arg ()
548
788
{
549
func_error "missing argument for $1"
789
$opt_debug
790
791
func_error "missing argument for $1."
550
792
exit_cmd=exit
551
793
}
552
794
795
796
# func_split_short_opt shortopt
797
# Set func_split_short_opt_name and func_split_short_opt_arg shell
798
# variables after splitting SHORTOPT after the 2nd character.
799
func_split_short_opt ()
800
{
801
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
802
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
803
804
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806
} # func_split_short_opt may be replaced by extended shell implementation
807
808
809
# func_split_long_opt longopt
810
# Set func_split_long_opt_name and func_split_long_opt_arg shell
811
# variables after splitting LONGOPT at the `=' sign.
812
func_split_long_opt ()
813
{
814
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
815
my_sed_long_arg='1s/^--[^=]*=//'
816
817
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819
} # func_split_long_opt may be replaced by extended shell implementation
820
553
821
exit_cmd=:
554
822
555
823
556
824
557
825
558
826
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
827
magic="%%%MAGIC variable%%%"
584
828
magic_exe="%%%MAGIC EXE variable%%%"
585
829
586
830
# Global variables.
587
# $mode is unset
588
831
nonopt=
589
execute_dlfiles=
590
832
preserve_args=
591
833
lo2o="s/\\.lo\$/.${objext}/"
592
834
o2lo="s/\\.${objext}\$/.lo/"
593
835
extracted_archives=
594
836
extracted_serial=0
595
837
596
opt_dry_run=false
597
opt_duplicate_deps=false
598
opt_silent=false
599
opt_debug=:
600
601
838
# If this variable is set in any of the actions, the command in it
602
839
# will be execed at the end. This prevents here-documents from being
603
840
# left over by shells.
604
841
exec_cmd=
605
842
843
# func_append var value
844
# Append VALUE to the end of shell variable VAR.
845
func_append ()
846
{
847
eval "${1}=\$${1}\${2}"
848
} # func_append may be replaced by extended shell implementation
849
850
# func_append_quoted var value
851
# Quote VALUE and append to the end of shell variable VAR, separated
852
# by a space.
853
func_append_quoted ()
854
{
855
func_quote_for_eval "${2}"
856
eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857
} # func_append_quoted may be replaced by extended shell implementation
858
859
860
# func_arith arithmetic-term...
861
func_arith ()
862
{
863
func_arith_result=`expr "${@}"`
864
} # func_arith may be replaced by extended shell implementation
865
866
867
# func_len string
868
# STRING may not start with a hyphen.
869
func_len ()
870
{
871
func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872
} # func_len may be replaced by extended shell implementation
873
874
875
# func_lo2o object
876
func_lo2o ()
877
{
878
func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
879
} # func_lo2o may be replaced by extended shell implementation
880
881
882
# func_xform libobj-or-source
883
func_xform ()
884
{
885
func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886
} # func_xform may be replaced by extended shell implementation
887
888
606
889
# func_fatal_configuration arg...
607
890
# Echo program name prefixed message to standard error, followed by
608
891
# a configuration failure hint, and exit.
636
919
# Display the features supported by this script.
637
920
func_features ()
638
921
{
639
$ECHO "host: $host"
922
echo "host: $host"
640
923
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
924
echo "enable shared libraries"
642
925
else
643
$ECHO "disable shared libraries"
926
echo "disable shared libraries"
644
927
fi
645
928
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
929
echo "enable static libraries"
647
930
else
648
$ECHO "disable static libraries"
931
echo "disable static libraries"
649
932
fi
650
933
651
934
exit $?
692
975
esac
693
976
}
694
977
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
978
# func_check_version_match
823
979
# Ensure that we are using m4 macros, and libtool script from the same
824
980
# release of libtool.
855
1011
}
856
1012
857
1013
1014
# Shorthand for --mode=foo, only valid as the first argument
1015
case $1 in
1016
clean|clea|cle|cl)
1017
shift; set dummy --mode clean ${1+"$@"}; shift
1018
;;
1019
compile|compil|compi|comp|com|co|c)
1020
shift; set dummy --mode compile ${1+"$@"}; shift
1021
;;
1022
execute|execut|execu|exec|exe|ex|e)
1023
shift; set dummy --mode execute ${1+"$@"}; shift
1024
;;
1025
finish|finis|fini|fin|fi|f)
1026
shift; set dummy --mode finish ${1+"$@"}; shift
1027
;;
1028
install|instal|insta|inst|ins|in|i)
1029
shift; set dummy --mode install ${1+"$@"}; shift
1030
;;
1031
link|lin|li|l)
1032
shift; set dummy --mode link ${1+"$@"}; shift
1033
;;
1034
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1035
shift; set dummy --mode uninstall ${1+"$@"}; shift
1036
;;
1037
esac
1038
1039
1040
1041
# Option defaults:
1042
opt_debug=:
1043
opt_dry_run=false
1044
opt_config=false
1045
opt_preserve_dup_deps=false
1046
opt_features=false
1047
opt_finish=false
1048
opt_help=false
1049
opt_help_all=false
1050
opt_silent=:
1051
opt_warning=:
1052
opt_verbose=:
1053
opt_silent=false
1054
opt_verbose=false
1055
1056
1057
# Parse options once, thoroughly. This comes as soon as possible in the
1058
# script to make things like `--version' happen as quickly as we can.
1059
{
1060
# this just eases exit handling
1061
while test $# -gt 0; do
1062
opt="$1"
1063
shift
1064
case $opt in
1065
--debug|-x) opt_debug='set -x'
1066
func_echo "enabling shell trace mode"
1067
$opt_debug
1068
;;
1069
--dry-run|--dryrun|-n)
1070
opt_dry_run=:
1071
;;
1072
--config)
1073
opt_config=:
1074
func_config
1075
;;
1076
--dlopen|-dlopen)
1077
optarg="$1"
1078
opt_dlopen="${opt_dlopen+$opt_dlopen
1079
}$optarg"
1080
shift
1081
;;
1082
--preserve-dup-deps)
1083
opt_preserve_dup_deps=:
1084
;;
1085
--features)
1086
opt_features=:
1087
func_features
1088
;;
1089
--finish)
1090
opt_finish=:
1091
set dummy --mode finish ${1+"$@"}; shift
1092
;;
1093
--help)
1094
opt_help=:
1095
;;
1096
--help-all)
1097
opt_help_all=:
1098
opt_help=': help-all'
1099
;;
1100
--mode)
1101
test $# = 0 && func_missing_arg $opt && break
1102
optarg="$1"
1103
opt_mode="$optarg"
1104
case $optarg in
1105
# Valid mode arguments:
1106
clean|compile|execute|finish|install|link|relink|uninstall) ;;
1107
1108
# Catch anything else as an error
1109
*) func_error "invalid argument for $opt"
1110
exit_cmd=exit
1111
break
1112
;;
1113
esac
1114
shift
1115
;;
1116
--no-silent|--no-quiet)
1117
opt_silent=false
1118
func_append preserve_args " $opt"
1119
;;
1120
--no-warning|--no-warn)
1121
opt_warning=false
1122
func_append preserve_args " $opt"
1123
;;
1124
--no-verbose)
1125
opt_verbose=false
1126
func_append preserve_args " $opt"
1127
;;
1128
--silent|--quiet)
1129
opt_silent=:
1130
func_append preserve_args " $opt"
1131
opt_verbose=false
1132
;;
1133
--verbose|-v)
1134
opt_verbose=:
1135
func_append preserve_args " $opt"
1136
opt_silent=false
1137
;;
1138
--tag)
1139
test $# = 0 && func_missing_arg $opt && break
1140
optarg="$1"
1141
opt_tag="$optarg"
1142
func_append preserve_args " $opt $optarg"
1143
func_enable_tag "$optarg"
1144
shift
1145
;;
1146
1147
-\?|-h) func_usage ;;
1148
--help) func_help ;;
1149
--version) func_version ;;
1150
1151
# Separate optargs to long options:
1152
--*=*)
1153
func_split_long_opt "$opt"
1154
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1155
shift
1156
;;
1157
1158
# Separate non-argument short options:
1159
-\?*|-h*|-n*|-v*)
1160
func_split_short_opt "$opt"
1161
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1162
shift
1163
;;
1164
1165
--) break ;;
1166
-*) func_fatal_help "unrecognized option \`$opt'" ;;
1167
*) set dummy "$opt" ${1+"$@"}; shift; break ;;
1168
esac
1169
done
1170
1171
# Validate options:
1172
1173
# save first non-option argument
1174
if test "$#" -gt 0; then
1175
nonopt="$opt"
1176
shift
1177
fi
1178
1179
# preserve --debug
1180
test "$opt_debug" = : || func_append preserve_args " --debug"
1181
1182
case $host in
1183
*cygwin* | *mingw* | *pw32* | *cegcc*)
1184
# don't eliminate duplications in $postdeps and $predeps
1185
opt_duplicate_compiler_generated_deps=:
1186
;;
1187
*)
1188
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1189
;;
1190
esac
1191
1192
$opt_help || {
1193
# Sanity checks first:
1194
func_check_version_match
1195
1196
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197
func_fatal_configuration "not configured to build any kind of library"
1198
fi
1199
1200
# Darwin sucks
1201
eval std_shrext=\"$shrext_cmds\"
1202
1203
# Only execute mode is allowed to have -dlopen flags.
1204
if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1205
func_error "unrecognized option \`-dlopen'"
1206
$ECHO "$help" 1>&2
1207
exit $EXIT_FAILURE
1208
fi
1209
1210
# Change the help message to a mode-specific one.
1211
generic_help="$help"
1212
help="Try \`$progname --help --mode=$opt_mode' for more information."
1213
}
1214
1215
1216
# Bail if the options were screwed
1217
$exit_cmd $EXIT_FAILURE
1218
}
1219
1220
1221
1222
858
1223
## ----------- ##
859
1224
## Main. ##
860
1225
## ----------- ##
861
1226
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
1227
# func_lalib_p file
891
1228
# True iff FILE is a libtool `.la' library or `.lo' object file.
892
1229
# This function is only a basic sanity check; it will hardly flush out
950
1287
# temporary ltwrapper_script.
951
1288
func_ltwrapper_scriptname ()
952
1289
{
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
1290
func_dirname_and_basename "$1" "" "."
1291
func_stripname '' '.exe' "$func_basename_result"
1292
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
959
1293
}
960
1294
961
1295
# func_ltwrapper_p file
1001
1335
}
1002
1336
1003
1337
1338
# func_resolve_sysroot PATH
1339
# Replace a leading = in PATH with a sysroot. Store the result into
1340
# func_resolve_sysroot_result
1341
func_resolve_sysroot ()
1342
{
1343
func_resolve_sysroot_result=$1
1344
case $func_resolve_sysroot_result in
1345
=*)
1346
func_stripname '=' '' "$func_resolve_sysroot_result"
1347
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1348
;;
1349
esac
1350
}
1351
1352
# func_replace_sysroot PATH
1353
# If PATH begins with the sysroot, replace it with = and
1354
# store the result into func_replace_sysroot_result.
1355
func_replace_sysroot ()
1356
{
1357
case "$lt_sysroot:$1" in
1358
?*:"$lt_sysroot"*)
1359
func_stripname "$lt_sysroot" '' "$1"
1360
func_replace_sysroot_result="=$func_stripname_result"
1361
;;
1362
*)
1363
# Including no sysroot.
1364
func_replace_sysroot_result=$1
1365
;;
1366
esac
1367
}
1368
1004
1369
# func_infer_tag arg
1005
1370
# Infer tagged configuration to use if any are available and
1006
1371
# if one wasn't chosen via the "--tag" command line option.
1013
1378
if test -n "$available_tags" && test -z "$tagname"; then
1014
1379
CC_quoted=
1015
1380
for arg in $CC; do
1016
func_quote_for_eval "$arg"
1017
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1381
func_append_quoted CC_quoted "$arg"
1018
1382
done
1383
CC_expanded=`func_echo_all $CC`
1384
CC_quoted_expanded=`func_echo_all $CC_quoted`
1019
1385
case $@ in
1020
1386
# Blanks in the command may have been stripped by the calling shell,
1021
1387
# 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` "*) ;;
1388
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1023
1390
# Blanks at the start of $base_compile will cause this to fail
1024
1391
# if we don't check for them as well.
1025
1392
*)
1030
1397
CC_quoted=
1031
1398
for arg in $CC; do
1032
1399
# Double-quote args containing other shell metacharacters.
1033
func_quote_for_eval "$arg"
1034
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1400
func_append_quoted CC_quoted "$arg"
1035
1401
done
1402
CC_expanded=`func_echo_all $CC`
1403
CC_quoted_expanded=`func_echo_all $CC_quoted`
1036
1404
case "$@ " in
1037
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1405
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1038
1407
# The compiler in the base compile command matches
1039
1408
# the one in the tagged configuration.
1040
1409
# Assume this is the tagged configuration we want.
1097
1466
}
1098
1467
}
1099
1468
1469
1470
##################################################
1471
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472
##################################################
1473
1474
# func_convert_core_file_wine_to_w32 ARG
1475
# Helper function used by file name conversion functions when $build is *nix,
1476
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477
# correctly configured wine environment available, with the winepath program
1478
# in $build's $PATH.
1479
#
1480
# ARG is the $build file name to be converted to w32 format.
1481
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482
# be empty on error (or when ARG is empty)
1483
func_convert_core_file_wine_to_w32 ()
1484
{
1485
$opt_debug
1486
func_convert_core_file_wine_to_w32_result="$1"
1487
if test -n "$1"; then
1488
# Unfortunately, winepath does not exit with a non-zero error code, so we
1489
# are forced to check the contents of stdout. On the other hand, if the
1490
# command is not found, the shell will set an exit code of 127 and print
1491
# *an error message* to stdout. So we must check for both error code of
1492
# zero AND non-empty stdout, which explains the odd construction:
1493
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1494
if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496
$SED -e "$lt_sed_naive_backslashify"`
1497
else
1498
func_convert_core_file_wine_to_w32_result=
1499
fi
1500
fi
1501
}
1502
# end: func_convert_core_file_wine_to_w32
1503
1504
1505
# func_convert_core_path_wine_to_w32 ARG
1506
# Helper function used by path conversion functions when $build is *nix, and
1507
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508
# configured wine environment available, with the winepath program in $build's
1509
# $PATH. Assumes ARG has no leading or trailing path separator characters.
1510
#
1511
# ARG is path to be converted from $build format to win32.
1512
# Result is available in $func_convert_core_path_wine_to_w32_result.
1513
# Unconvertible file (directory) names in ARG are skipped; if no directory names
1514
# are convertible, then the result may be empty.
1515
func_convert_core_path_wine_to_w32 ()
1516
{
1517
$opt_debug
1518
# unfortunately, winepath doesn't convert paths, only file names
1519
func_convert_core_path_wine_to_w32_result=""
1520
if test -n "$1"; then
1521
oldIFS=$IFS
1522
IFS=:
1523
for func_convert_core_path_wine_to_w32_f in $1; do
1524
IFS=$oldIFS
1525
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1526
if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527
if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528
func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529
else
1530
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1531
fi
1532
fi
1533
done
1534
IFS=$oldIFS
1535
fi
1536
}
1537
# end: func_convert_core_path_wine_to_w32
1538
1539
1540
# func_cygpath ARGS...
1541
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544
# (2), returns the Cygwin file name or path in func_cygpath_result (input
1545
# file name or path is assumed to be in w32 format, as previously converted
1546
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547
# or path in func_cygpath_result (input file name or path is assumed to be in
1548
# Cygwin format). Returns an empty string on error.
1549
#
1550
# ARGS are passed to cygpath, with the last one being the file name or path to
1551
# be converted.
1552
#
1553
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554
# environment variable; do not put it in $PATH.
1555
func_cygpath ()
1556
{
1557
$opt_debug
1558
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1560
if test "$?" -ne 0; then
1561
# on failure, ensure result is empty
1562
func_cygpath_result=
1563
fi
1564
else
1565
func_cygpath_result=
1566
func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1567
fi
1568
}
1569
#end: func_cygpath
1570
1571
1572
# func_convert_core_msys_to_w32 ARG
1573
# Convert file name or path ARG from MSYS format to w32 format. Return
1574
# result in func_convert_core_msys_to_w32_result.
1575
func_convert_core_msys_to_w32 ()
1576
{
1577
$opt_debug
1578
# awkward: cmd appends spaces to result
1579
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1580
$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581
}
1582
#end: func_convert_core_msys_to_w32
1583
1584
1585
# func_convert_file_check ARG1 ARG2
1586
# Verify that ARG1 (a file name in $build format) was converted to $host
1587
# format in ARG2. Otherwise, emit an error message, but continue (resetting
1588
# func_to_host_file_result to ARG1).
1589
func_convert_file_check ()
1590
{
1591
$opt_debug
1592
if test -z "$2" && test -n "$1" ; then
1593
func_error "Could not determine host file name corresponding to"
1594
func_error " \`$1'"
1595
func_error "Continuing, but uninstalled executables may not work."
1596
# Fallback:
1597
func_to_host_file_result="$1"
1598
fi
1599
}
1600
# end func_convert_file_check
1601
1602
1603
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604
# Verify that FROM_PATH (a path in $build format) was converted to $host
1605
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606
# func_to_host_file_result to a simplistic fallback value (see below).
1607
func_convert_path_check ()
1608
{
1609
$opt_debug
1610
if test -z "$4" && test -n "$3"; then
1611
func_error "Could not determine the host path corresponding to"
1612
func_error " \`$3'"
1613
func_error "Continuing, but uninstalled executables may not work."
1614
# Fallback. This is a deliberately simplistic "conversion" and
1615
# should not be "improved". See libtool.info.
1616
if test "x$1" != "x$2"; then
1617
lt_replace_pathsep_chars="s|$1|$2|g"
1618
func_to_host_path_result=`echo "$3" |
1619
$SED -e "$lt_replace_pathsep_chars"`
1620
else
1621
func_to_host_path_result="$3"
1622
fi
1623
fi
1624
}
1625
# end func_convert_path_check
1626
1627
1628
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630
# and appending REPL if ORIG matches BACKPAT.
1631
func_convert_path_front_back_pathsep ()
1632
{
1633
$opt_debug
1634
case $4 in
1635
$1 ) func_to_host_path_result="$3$func_to_host_path_result"
1636
;;
1637
esac
1638
case $4 in
1639
$2 ) func_append func_to_host_path_result "$3"
1640
;;
1641
esac
1642
}
1643
# end func_convert_path_front_back_pathsep
1644
1645
1646
##################################################
1647
# $build to $host FILE NAME CONVERSION FUNCTIONS #
1648
##################################################
1649
# invoked via `$to_host_file_cmd ARG'
1650
#
1651
# In each case, ARG is the path to be converted from $build to $host format.
1652
# Result will be available in $func_to_host_file_result.
1653
1654
1655
# func_to_host_file ARG
1656
# Converts the file name ARG from $build format to $host format. Return result
1657
# in func_to_host_file_result.
1658
func_to_host_file ()
1659
{
1660
$opt_debug
1661
$to_host_file_cmd "$1"
1662
}
1663
# end func_to_host_file
1664
1665
1666
# func_to_tool_file ARG LAZY
1667
# converts the file name ARG from $build format to toolchain format. Return
1668
# result in func_to_tool_file_result. If the conversion in use is listed
1669
# in (the comma separated) LAZY, no conversion takes place.
1670
func_to_tool_file ()
1671
{
1672
$opt_debug
1673
case ,$2, in
1674
*,"$to_tool_file_cmd",*)
1675
func_to_tool_file_result=$1
1676
;;
1677
*)
1678
$to_tool_file_cmd "$1"
1679
func_to_tool_file_result=$func_to_host_file_result
1680
;;
1681
esac
1682
}
1683
# end func_to_tool_file
1684
1685
1686
# func_convert_file_noop ARG
1687
# Copy ARG to func_to_host_file_result.
1688
func_convert_file_noop ()
1689
{
1690
func_to_host_file_result="$1"
1691
}
1692
# end func_convert_file_noop
1693
1694
1695
# func_convert_file_msys_to_w32 ARG
1696
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697
# conversion to w32 is not available inside the cwrapper. Returns result in
1698
# func_to_host_file_result.
1699
func_convert_file_msys_to_w32 ()
1700
{
1701
$opt_debug
1702
func_to_host_file_result="$1"
1703
if test -n "$1"; then
1704
func_convert_core_msys_to_w32 "$1"
1705
func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706
fi
1707
func_convert_file_check "$1" "$func_to_host_file_result"
1708
}
1709
# end func_convert_file_msys_to_w32
1710
1711
1712
# func_convert_file_cygwin_to_w32 ARG
1713
# Convert file name ARG from Cygwin to w32 format. Returns result in
1714
# func_to_host_file_result.
1715
func_convert_file_cygwin_to_w32 ()
1716
{
1717
$opt_debug
1718
func_to_host_file_result="$1"
1719
if test -n "$1"; then
1720
# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721
# LT_CYGPATH in this case.
1722
func_to_host_file_result=`cygpath -m "$1"`
1723
fi
1724
func_convert_file_check "$1" "$func_to_host_file_result"
1725
}
1726
# end func_convert_file_cygwin_to_w32
1727
1728
1729
# func_convert_file_nix_to_w32 ARG
1730
# Convert file name ARG from *nix to w32 format. Requires a wine environment
1731
# and a working winepath. Returns result in func_to_host_file_result.
1732
func_convert_file_nix_to_w32 ()
1733
{
1734
$opt_debug
1735
func_to_host_file_result="$1"
1736
if test -n "$1"; then
1737
func_convert_core_file_wine_to_w32 "$1"
1738
func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739
fi
1740
func_convert_file_check "$1" "$func_to_host_file_result"
1741
}
1742
# end func_convert_file_nix_to_w32
1743
1744
1745
# func_convert_file_msys_to_cygwin ARG
1746
# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1747
# Returns result in func_to_host_file_result.
1748
func_convert_file_msys_to_cygwin ()
1749
{
1750
$opt_debug
1751
func_to_host_file_result="$1"
1752
if test -n "$1"; then
1753
func_convert_core_msys_to_w32 "$1"
1754
func_cygpath -u "$func_convert_core_msys_to_w32_result"
1755
func_to_host_file_result="$func_cygpath_result"
1756
fi
1757
func_convert_file_check "$1" "$func_to_host_file_result"
1758
}
1759
# end func_convert_file_msys_to_cygwin
1760
1761
1762
# func_convert_file_nix_to_cygwin ARG
1763
# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1764
# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1765
# in func_to_host_file_result.
1766
func_convert_file_nix_to_cygwin ()
1767
{
1768
$opt_debug
1769
func_to_host_file_result="$1"
1770
if test -n "$1"; then
1771
# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772
func_convert_core_file_wine_to_w32 "$1"
1773
func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1774
func_to_host_file_result="$func_cygpath_result"
1775
fi
1776
func_convert_file_check "$1" "$func_to_host_file_result"
1777
}
1778
# end func_convert_file_nix_to_cygwin
1779
1780
1781
#############################################
1782
# $build to $host PATH CONVERSION FUNCTIONS #
1783
#############################################
1784
# invoked via `$to_host_path_cmd ARG'
1785
#
1786
# In each case, ARG is the path to be converted from $build to $host format.
1787
# The result will be available in $func_to_host_path_result.
1788
#
1789
# Path separators are also converted from $build format to $host format. If
1790
# ARG begins or ends with a path separator character, it is preserved (but
1791
# converted to $host format) on output.
1792
#
1793
# All path conversion functions are named using the following convention:
1794
# file name conversion function : func_convert_file_X_to_Y ()
1795
# path conversion function : func_convert_path_X_to_Y ()
1796
# where, for any given $build/$host combination the 'X_to_Y' value is the
1797
# same. If conversion functions are added for new $build/$host combinations,
1798
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
1799
# will break.
1800
1801
1802
# func_init_to_host_path_cmd
1803
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804
# appropriate value, based on the value of $to_host_file_cmd.
1805
to_host_path_cmd=
1806
func_init_to_host_path_cmd ()
1807
{
1808
$opt_debug
1809
if test -z "$to_host_path_cmd"; then
1810
func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1811
to_host_path_cmd="func_convert_path_${func_stripname_result}"
1812
fi
1813
}
1814
1815
1816
# func_to_host_path ARG
1817
# Converts the path ARG from $build format to $host format. Return result
1818
# in func_to_host_path_result.
1819
func_to_host_path ()
1820
{
1821
$opt_debug
1822
func_init_to_host_path_cmd
1823
$to_host_path_cmd "$1"
1824
}
1825
# end func_to_host_path
1826
1827
1828
# func_convert_path_noop ARG
1829
# Copy ARG to func_to_host_path_result.
1830
func_convert_path_noop ()
1831
{
1832
func_to_host_path_result="$1"
1833
}
1834
# end func_convert_path_noop
1835
1836
1837
# func_convert_path_msys_to_w32 ARG
1838
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839
# conversion to w32 is not available inside the cwrapper. Returns result in
1840
# func_to_host_path_result.
1841
func_convert_path_msys_to_w32 ()
1842
{
1843
$opt_debug
1844
func_to_host_path_result="$1"
1845
if test -n "$1"; then
1846
# Remove leading and trailing path separator characters from ARG. MSYS
1847
# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848
# and winepath ignores them completely.
1849
func_stripname : : "$1"
1850
func_to_host_path_tmp1=$func_stripname_result
1851
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1852
func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1853
func_convert_path_check : ";" \
1854
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1855
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1856
fi
1857
}
1858
# end func_convert_path_msys_to_w32
1859
1860
1861
# func_convert_path_cygwin_to_w32 ARG
1862
# Convert path ARG from Cygwin to w32 format. Returns result in
1863
# func_to_host_file_result.
1864
func_convert_path_cygwin_to_w32 ()
1865
{
1866
$opt_debug
1867
func_to_host_path_result="$1"
1868
if test -n "$1"; then
1869
# See func_convert_path_msys_to_w32:
1870
func_stripname : : "$1"
1871
func_to_host_path_tmp1=$func_stripname_result
1872
func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1873
func_convert_path_check : ";" \
1874
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1875
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1876
fi
1877
}
1878
# end func_convert_path_cygwin_to_w32
1879
1880
1881
# func_convert_path_nix_to_w32 ARG
1882
# Convert path ARG from *nix to w32 format. Requires a wine environment and
1883
# a working winepath. Returns result in func_to_host_file_result.
1884
func_convert_path_nix_to_w32 ()
1885
{
1886
$opt_debug
1887
func_to_host_path_result="$1"
1888
if test -n "$1"; then
1889
# See func_convert_path_msys_to_w32:
1890
func_stripname : : "$1"
1891
func_to_host_path_tmp1=$func_stripname_result
1892
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1893
func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1894
func_convert_path_check : ";" \
1895
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1896
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1897
fi
1898
}
1899
# end func_convert_path_nix_to_w32
1900
1901
1902
# func_convert_path_msys_to_cygwin ARG
1903
# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1904
# Returns result in func_to_host_file_result.
1905
func_convert_path_msys_to_cygwin ()
1906
{
1907
$opt_debug
1908
func_to_host_path_result="$1"
1909
if test -n "$1"; then
1910
# See func_convert_path_msys_to_w32:
1911
func_stripname : : "$1"
1912
func_to_host_path_tmp1=$func_stripname_result
1913
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1914
func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1915
func_to_host_path_result="$func_cygpath_result"
1916
func_convert_path_check : : \
1917
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1918
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1919
fi
1920
}
1921
# end func_convert_path_msys_to_cygwin
1922
1923
1924
# func_convert_path_nix_to_cygwin ARG
1925
# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1926
# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1927
# func_to_host_file_result.
1928
func_convert_path_nix_to_cygwin ()
1929
{
1930
$opt_debug
1931
func_to_host_path_result="$1"
1932
if test -n "$1"; then
1933
# Remove leading and trailing path separator characters from
1934
# ARG. msys behavior is inconsistent here, cygpath turns them
1935
# into '.;' and ';.', and winepath ignores them completely.
1936
func_stripname : : "$1"
1937
func_to_host_path_tmp1=$func_stripname_result
1938
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1939
func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1940
func_to_host_path_result="$func_cygpath_result"
1941
func_convert_path_check : : \
1942
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1943
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1944
fi
1945
}
1946
# end func_convert_path_nix_to_cygwin
1947
1948
1100
1949
# func_mode_compile arg...
1101
1950
func_mode_compile ()
1102
1951
{
1137
1986
;;
1138
1987
1139
1988
-pie | -fpie | -fPIE)
1140
pie_flag="$pie_flag $arg"
1989
func_append pie_flag " $arg"
1141
1990
continue
1142
1991
;;
1143
1992
1144
1993
-shared | -static | -prefer-pic | -prefer-non-pic)
1145
later="$later $arg"
1994
func_append later " $arg"
1146
1995
continue
1147
1996
;;
1148
1997
1163
2012
save_ifs="$IFS"; IFS=','
1164
2013
for arg in $args; do
1165
2014
IFS="$save_ifs"
1166
func_quote_for_eval "$arg"
1167
lastarg="$lastarg $func_quote_for_eval_result"
2015
func_append_quoted lastarg "$arg"
1168
2016
done
1169
2017
IFS="$save_ifs"
1170
2018
func_stripname ' ' '' "$lastarg"
1171
2019
lastarg=$func_stripname_result
1172
2020
1173
2021
# Add the arguments to base_compile.
1174
base_compile="$base_compile $lastarg"
2022
func_append base_compile " $lastarg"
1175
2023
continue
1176
2024
;;
1177
2025
1187
2035
esac # case $arg_mode
1188
2036
1189
2037
# Aesthetically quote the previous argument.
1190
func_quote_for_eval "$lastarg"
1191
base_compile="$base_compile $func_quote_for_eval_result"
2038
func_append_quoted base_compile "$lastarg"
1192
2039
done # for arg
1193
2040
1194
2041
case $arg_mode in
1213
2060
*.[cCFSifmso] | \
1214
2061
*.ada | *.adb | *.ads | *.asm | \
1215
2062
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1216
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
2063
*.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
1217
2064
func_xform "$libobj"
1218
2065
libobj=$func_xform_result
1219
2066
;;
1288
2135
# Calculate the filename of the output object if compiler does
1289
2136
# not support -o with -c
1290
2137
if test "$compiler_c_o" = no; then
1291
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
2138
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1292
2139
lockfile="$output_obj.lock"
1293
2140
else
1294
2141
output_obj=
1319
2166
$opt_dry_run || $RM $removelist
1320
2167
exit $EXIT_FAILURE
1321
2168
fi
1322
removelist="$removelist $output_obj"
2169
func_append removelist " $output_obj"
1323
2170
$ECHO "$srcfile" > "$lockfile"
1324
2171
fi
1325
2172
1326
2173
$opt_dry_run || $RM $removelist
1327
removelist="$removelist $lockfile"
2174
func_append removelist " $lockfile"
1328
2175
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1329
2176
1330
if test -n "$fix_srcfile_path"; then
1331
eval srcfile=\"$fix_srcfile_path\"
1332
fi
2177
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178
srcfile=$func_to_tool_file_result
1333
2179
func_quote_for_eval "$srcfile"
1334
2180
qsrcfile=$func_quote_for_eval_result
1335
2181
1349
2195
1350
2196
if test -z "$output_obj"; then
1351
2197
# Place PIC objects in $objdir
1352
command="$command -o $lobj"
2198
func_append command " -o $lobj"
1353
2199
fi
1354
2200
1355
2201
func_show_eval_locale "$command" \
1396
2242
command="$base_compile $qsrcfile $pic_flag"
1397
2243
fi
1398
2244
if test "$compiler_c_o" = yes; then
1399
command="$command -o $obj"
2245
func_append command " -o $obj"
1400
2246
fi
1401
2247
1402
2248
# Suppress compiler output if we already did a PIC compilation.
1403
command="$command$suppress_output"
2249
func_append command "$suppress_output"
1404
2250
func_show_eval_locale "$command" \
1405
2251
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1406
2252
1445
2291
}
1446
2292
1447
2293
$opt_help || {
1448
test "$mode" = compile && func_mode_compile ${1+"$@"}
2294
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
1449
2295
}
1450
2296
1451
2297
func_mode_help ()
1452
2298
{
1453
2299
# We need to display help for each of the modes.
1454
case $mode in
2300
case $opt_mode in
1455
2301
"")
1456
2302
# Generic help is extracted from the usage comments
1457
2303
# at the start of this file.
1482
2328
1483
2329
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1484
2330
-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
2331
-prefer-pic try to build PIC objects only
2332
-prefer-non-pic try to build non-PIC objects only
1487
2333
-shared do not build a \`.o' file suitable for static linking
1488
2334
-static only build a \`.o' file suitable for static linking
2335
-Wc,FLAG pass FLAG directly to the compiler
1489
2336
1490
2337
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1491
2338
from the given SOURCEFILE.
1538
2385
1539
2386
The following components of INSTALL-COMMAND are treated specially:
1540
2387
1541
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2388
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1542
2389
1543
2390
The rest of the components are interpreted as arguments to that command (only
1544
2391
BSD-compatible install options are recognized)."
1558
2405
1559
2406
-all-static do not do any dynamic linking at all
1560
2407
-avoid-version do not add a version suffix if possible
2408
-bindir BINDIR specify path to binaries directory (for systems where
2409
libraries must be found in the PATH setting at runtime)
1561
2410
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1562
2411
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1563
2412
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1586
2435
-version-info CURRENT[:REVISION[:AGE]]
1587
2436
specify library version info [each variable defaults to 0]
1588
2437
-weak LIBNAME declare that the target provides the LIBNAME interface
2438
-Wc,FLAG
2439
-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2440
-Wl,FLAG
2441
-Xlinker FLAG pass linker-specific FLAG directly to the linker
2442
-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
1589
2443
1590
2444
All other options (arguments beginning with \`-') are ignored.
1591
2445
1619
2473
;;
1620
2474
1621
2475
*)
1622
func_fatal_help "invalid operation mode \`$mode'"
2476
func_fatal_help "invalid operation mode \`$opt_mode'"
1623
2477
;;
1624
2478
esac
1625
2479
1626
$ECHO
2480
echo
1627
2481
$ECHO "Try \`$progname --help' for more information about other modes."
1628
1629
exit $?
1630
2482
}
1631
2483
1632
# Now that we've collected a possible --mode arg, show help if necessary
1633
$opt_help && func_mode_help
2484
# Now that we've collected a possible --mode arg, show help if necessary
2485
if $opt_help; then
2486
if test "$opt_help" = :; then
2487
func_mode_help
2488
else
2489
{
2490
func_help noexit
2491
for opt_mode in compile link execute install finish uninstall clean; do
2492
func_mode_help
2493
done
2494
} | sed -n '1p; 2,$s/^Usage:/ or: /p'
2495
{
2496
func_help noexit
2497
for opt_mode in compile link execute install finish uninstall clean; do
2498
echo
2499
func_mode_help
2500
done
2501
} |
2502
sed '1d
2503
/^When reporting/,/^Report/{
2504
H
2505
d
2506
}
2507
$x
2508
/information about other modes/d
2509
/more detailed .*MODE/d
2510
s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2511
fi
2512
exit $?
2513
fi
1634
2514
1635
2515
1636
2516
# func_mode_execute arg...
1643
2523
func_fatal_help "you must specify a COMMAND"
1644
2524
1645
2525
# Handle -dlopen flags immediately.
1646
for file in $execute_dlfiles; do
2526
for file in $opt_dlopen; do
1647
2527
test -f "$file" \
1648
2528
|| func_fatal_help "\`$file' is not a file"
1649
2529
1650
2530
dir=
1651
2531
case $file in
1652
2532
*.la)
2533
func_resolve_sysroot "$file"
2534
file=$func_resolve_sysroot_result
2535
1653
2536
# Check to see that this really is a libtool archive.
1654
2537
func_lalib_unsafe_p "$file" \
1655
2538
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1671
2554
dir="$func_dirname_result"
1672
2555
1673
2556
if test -f "$dir/$objdir/$dlname"; then
1674
dir="$dir/$objdir"
2557
func_append dir "/$objdir"
1675
2558
else
1676
2559
if test ! -f "$dir/$dlname"; then
1677
2560
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1712
2595
for file
1713
2596
do
1714
2597
case $file in
1715
-*) ;;
2598
-* | *.la | *.lo ) ;;
1716
2599
*)
1717
2600
# Do a test to see if this is really a libtool program.
1718
2601
if func_ltwrapper_script_p "$file"; then
1728
2611
;;
1729
2612
esac
1730
2613
# Quote arguments (to preserve shell metacharacters).
1731
func_quote_for_eval "$file"
1732
args="$args $func_quote_for_eval_result"
2614
func_append_quoted args "$file"
1733
2615
done
1734
2616
1735
2617
if test "X$opt_dry_run" = Xfalse; then
1754
2636
# Display what would be done.
1755
2637
if test -n "$shlibpath_var"; then
1756
2638
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1757
$ECHO "export $shlibpath_var"
2639
echo "export $shlibpath_var"
1758
2640
fi
1759
2641
$ECHO "$cmd$args"
1760
2642
exit $EXIT_SUCCESS
1761
2643
fi
1762
2644
}
1763
2645
1764
test "$mode" = execute && func_mode_execute ${1+"$@"}
2646
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
1765
2647
1766
2648
1767
2649
# func_mode_finish arg...
1768
2650
func_mode_finish ()
1769
2651
{
1770
2652
$opt_debug
1771
libdirs="$nonopt"
2653
libs=
2654
libdirs=
1772
2655
admincmds=
1773
2656
2657
for opt in "$nonopt" ${1+"$@"}
2658
do
2659
if test -d "$opt"; then
2660
func_append libdirs " $opt"
2661
2662
elif test -f "$opt"; then
2663
if func_lalib_unsafe_p "$opt"; then
2664
func_append libs " $opt"
2665
else
2666
func_warning "\`$opt' is not a valid libtool archive"
2667
fi
2668
2669
else
2670
func_fatal_error "invalid argument \`$opt'"
2671
fi
2672
done
2673
2674
if test -n "$libs"; then
2675
if test -n "$lt_sysroot"; then
2676
sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677
sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2678
else
2679
sysroot_cmd=
2680
fi
2681
2682
# Remove sysroot references
2683
if $opt_dry_run; then
2684
for lib in $libs; do
2685
echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2686
done
2687
else
2688
tmpdir=`func_mktempdir`
2689
for lib in $libs; do
2690
sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691
> $tmpdir/tmp-la
2692
mv -f $tmpdir/tmp-la $lib
2693
done
2694
${RM}r "$tmpdir"
2695
fi
2696
fi
2697
1774
2698
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1775
for dir
1776
do
1777
libdirs="$libdirs $dir"
1778
done
1779
1780
2699
for libdir in $libdirs; do
1781
2700
if test -n "$finish_cmds"; then
1782
2701
# Do each command in the finish commands.
1786
2705
if test -n "$finish_eval"; then
1787
2706
# Do the single finish_eval.
1788
2707
eval cmds=\"$finish_eval\"
1789
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
2708
$opt_dry_run || eval "$cmds" || func_append admincmds "
1790
2709
$cmds"
1791
2710
fi
1792
2711
done
1795
2714
# Exit here if they wanted silent mode.
1796
2715
$opt_silent && exit $EXIT_SUCCESS
1797
2716
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
2717
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718
echo "----------------------------------------------------------------------"
2719
echo "Libraries have been installed in:"
2720
for libdir in $libdirs; do
2721
$ECHO " $libdir"
2722
done
2723
echo
2724
echo "If you ever happen to want to link against installed libraries"
2725
echo "in a given directory, LIBDIR, you must either use libtool, and"
2726
echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727
echo "flag during linking and do at least one of the following:"
2728
if test -n "$shlibpath_var"; then
2729
echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2730
echo " during execution"
2731
fi
2732
if test -n "$runpath_var"; then
2733
echo " - add LIBDIR to the \`$runpath_var' environment variable"
2734
echo " during linking"
2735
fi
2736
if test -n "$hardcode_libdir_flag_spec"; then
2737
libdir=LIBDIR
2738
eval flag=\"$hardcode_libdir_flag_spec\"
2739
2740
$ECHO " - use the \`$flag' linker flag"
2741
fi
2742
if test -n "$admincmds"; then
2743
$ECHO " - have your system administrator run these commands:$admincmds"
2744
fi
2745
if test -f /etc/ld.so.conf; then
2746
echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2747
fi
2748
echo
2749
2750
echo "See any operating system documentation about shared libraries for"
2751
case $host in
2752
solaris2.[6789]|solaris2.1[0-9])
2753
echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2754
echo "pages."
2755
;;
2756
*)
2757
echo "more information, such as the ld(1) and ld.so(8) manual pages."
2758
;;
2759
esac
2760
echo "----------------------------------------------------------------------"
2761
fi
1841
2762
exit $EXIT_SUCCESS
1842
2763
}
1843
2764
1844
test "$mode" = finish && func_mode_finish ${1+"$@"}
2765
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
1845
2766
1846
2767
1847
2768
# func_mode_install arg...
1852
2773
# install_prog (especially on Windows NT).
1853
2774
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1854
2775
# Allow the use of GNU shtool's install command.
1855
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2776
case $nonopt in *shtool*) :;; *) false;; esac; then
1856
2777
# Aesthetically quote it.
1857
2778
func_quote_for_eval "$nonopt"
1858
2779
install_prog="$func_quote_for_eval_result "
1866
2787
# The real first argument should be the name of the installation program.
1867
2788
# Aesthetically quote it.
1868
2789
func_quote_for_eval "$arg"
1869
install_prog="$install_prog$func_quote_for_eval_result"
2790
func_append install_prog "$func_quote_for_eval_result"
2791
install_shared_prog=$install_prog
2792
case " $install_prog " in
2793
*[\\\ /]cp\ *) install_cp=: ;;
2794
*) install_cp=false ;;
2795
esac
1870
2796
1871
2797
# We need to accept at least all the BSD install flags.
1872
2798
dest=
1876
2802
install_type=
1877
2803
isdir=no
1878
2804
stripme=
2805
no_mode=:
1879
2806
for arg
1880
2807
do
2808
arg2=
1881
2809
if test -n "$dest"; then
1882
files="$files $dest"
2810
func_append files " $dest"
1883
2811
dest=$arg
1884
2812
continue
1885
2813
fi
1887
2815
case $arg in
1888
2816
-d) isdir=yes ;;
1889
2817
-f)
1890
case " $install_prog " in
1891
*[\\\ /]cp\ *) ;;
1892
*) prev=$arg ;;
1893
esac
2818
if $install_cp; then :; else
2819
prev=$arg
2820
fi
1894
2821
;;
1895
2822
-g | -m | -o)
1896
2823
prev=$arg
1904
2831
*)
1905
2832
# If the previous option needed an argument, then skip it.
1906
2833
if test -n "$prev"; then
2834
if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835
arg2=$install_override_mode
2836
no_mode=false
2837
fi
1907
2838
prev=
1908
2839
else
1909
2840
dest=$arg
1914
2845
1915
2846
# Aesthetically quote the argument.
1916
2847
func_quote_for_eval "$arg"
1917
install_prog="$install_prog $func_quote_for_eval_result"
2848
func_append install_prog " $func_quote_for_eval_result"
2849
if test -n "$arg2"; then
2850
func_quote_for_eval "$arg2"
2851
fi
2852
func_append install_shared_prog " $func_quote_for_eval_result"
1918
2853
done
1919
2854
1920
2855
test -z "$install_prog" && \
1923
2858
test -n "$prev" && \
1924
2859
func_fatal_help "the \`$prev' option requires an argument"
1925
2860
2861
if test -n "$install_override_mode" && $no_mode; then
2862
if $install_cp; then :; else
2863
func_quote_for_eval "$install_override_mode"
2864
func_append install_shared_prog " -m $func_quote_for_eval_result"
2865
fi
2866
fi
2867
1926
2868
if test -z "$files"; then
1927
2869
if test -z "$dest"; then
1928
2870
func_fatal_help "no file or destination specified"
1977
2919
case $file in
1978
2920
*.$libext)
1979
2921
# Do the static libraries later.
1980
staticlibs="$staticlibs $file"
2922
func_append staticlibs " $file"
1981
2923
;;
1982
2924
1983
2925
*.la)
2926
func_resolve_sysroot "$file"
2927
file=$func_resolve_sysroot_result
2928
1984
2929
# Check to see that this really is a libtool archive.
1985
2930
func_lalib_unsafe_p "$file" \
1986
2931
|| func_fatal_help "\`$file' is not a valid libtool archive"
1994
2939
if test "X$destdir" = "X$libdir"; then
1995
2940
case "$current_libdirs " in
1996
2941
*" $libdir "*) ;;
1997
*) current_libdirs="$current_libdirs $libdir" ;;
2942
*) func_append current_libdirs " $libdir" ;;
1998
2943
esac
1999
2944
else
2000
2945
# Note the libdir as a future libdir.
2001
2946
case "$future_libdirs " in
2002
2947
*" $libdir "*) ;;
2003
*) future_libdirs="$future_libdirs $libdir" ;;
2948
*) func_append future_libdirs " $libdir" ;;
2004
2949
esac
2005
2950
fi
2006
2951
2007
2952
func_dirname "$file" "/" ""
2008
2953
dir="$func_dirname_result"
2009
dir="$dir$objdir"
2954
func_append dir "$objdir"
2010
2955
2011
2956
if test -n "$relink_command"; then
2012
2957
# Determine the prefix the user has applied to our future dir.
2013
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2958
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2014
2959
2015
2960
# Don't allow the user to place us outside of our expected
2016
2961
# location b/c this prevents finding dependent libraries that
2023
2968
2024
2969
if test -n "$inst_prefix_dir"; then
2025
2970
# 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%"`
2971
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2027
2972
else
2028
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2973
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2029
2974
fi
2030
2975
2031
2976
func_warning "relinking \`$file'"
2043
2988
test -n "$relink_command" && srcname="$realname"T
2044
2989
2045
2990
# Install the shared library and build the symlinks.
2046
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2991
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2047
2992
'exit $?'
2048
2993
tstripme="$stripme"
2049
2994
case $host_os in
2083
3028
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2084
3029
2085
3030
# Maybe install the static library, too.
2086
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
3031
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
2087
3032
;;
2088
3033
2089
3034
*.lo)
2183
3128
if test -f "$lib"; then
2184
3129
func_source "$lib"
2185
3130
fi
2186
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
3131
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187
3132
if test -n "$libdir" && test ! -f "$libfile"; then
2188
3133
func_warning "\`$lib' has not been installed in \`$libdir'"
2189
3134
finalize=no
2202
3147
file="$func_basename_result"
2203
3148
outputname="$tmpdir/$file"
2204
3149
# Replace the output file specification.
2205
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
3150
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2206
3151
2207
3152
$opt_silent || {
2208
3153
func_quote_for_expand "$relink_command"
2221
3166
}
2222
3167
else
2223
3168
# Install the binary that we compiled earlier.
2224
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
3169
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2225
3170
fi
2226
3171
fi
2227
3172
2257
3202
2258
3203
# Set up the ranlib parameters.
2259
3204
oldlib="$destdir/$name"
3205
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206
tool_oldlib=$func_to_tool_file_result
2260
3207
2261
3208
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2262
3209
2263
3210
if test -n "$stripme" && test -n "$old_striplib"; then
2264
func_show_eval "$old_striplib $oldlib" 'exit $?'
3211
func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
2265
3212
fi
2266
3213
2267
3214
# Do each command in the postinstall commands.
2280
3227
fi
2281
3228
}
2282
3229
2283
test "$mode" = install && func_mode_install ${1+"$@"}
3230
test "$opt_mode" = install && func_mode_install ${1+"$@"}
2284
3231
2285
3232
2286
3233
# func_generate_dlsyms outputname originator pic_p
2323
3270
extern \"C\" {
2324
3271
#endif
2325
3272
3273
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3275
#endif
3276
3277
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3278
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279
/* DATA imports from DLLs on WIN32 con't be const, because runtime
3280
relocations are performed -- see ld's documentation on pseudo-relocs. */
3281
# define LT_DLSYM_CONST
3282
#elif defined(__osf__)
3283
/* This system does not cope well with relocations in const data. */
3284
# define LT_DLSYM_CONST
3285
#else
3286
# define LT_DLSYM_CONST const
3287
#endif
3288
2326
3289
/* External symbol declarations for the compiler. */\
2327
3290
"
2328
3291
2332
3295
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2333
3296
2334
3297
# Add our own program objects to the symbol list.
2335
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3298
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2336
3299
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'"
3300
func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3301
func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3302
$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
2339
3303
done
2340
3304
2341
3305
if test -n "$exclude_expsyms"; then
2371
3335
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372
3336
eval '$MV "$nlist"T "$nlist"'
2373
3337
case $host in
2374
*cygwin | *mingw* | *cegcc* )
3338
*cygwin* | *mingw* | *cegcc* )
2375
3339
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376
3340
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2377
3341
;;
2384
3348
func_verbose "extracting global C symbols from \`$dlprefile'"
2385
3349
func_basename "$dlprefile"
2386
3350
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
}
3351
case $host in
3352
*cygwin* | *mingw* | *cegcc* )
3353
# if an import library, we need to obtain dlname
3354
if func_win32_import_lib_p "$dlprefile"; then
3355
func_tr_sh "$dlprefile"
3356
eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357
dlprefile_dlbasename=""
3358
if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3359
# Use subshell, to avoid clobbering current variable values
3360
dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3361
if test -n "$dlprefile_dlname" ; then
3362
func_basename "$dlprefile_dlname"
3363
dlprefile_dlbasename="$func_basename_result"
3364
else
3365
# no lafile. user explicitly requested -dlpreopen <import library>.
3366
$sharedlib_from_linklib_cmd "$dlprefile"
3367
dlprefile_dlbasename=$sharedlib_from_linklib_result
3368
fi
3369
fi
3370
$opt_dry_run || {
3371
if test -n "$dlprefile_dlbasename" ; then
3372
eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3373
else
3374
func_warning "Could not compute DLL name from $name"
3375
eval '$ECHO ": $name " >> "$nlist"'
3376
fi
3377
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3378
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379
$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3380
}
3381
else # not an import lib
3382
$opt_dry_run || {
3383
eval '$ECHO ": $name " >> "$nlist"'
3384
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3386
}
3387
fi
3388
;;
3389
*)
3390
$opt_dry_run || {
3391
eval '$ECHO ": $name " >> "$nlist"'
3392
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3393
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3394
}
3395
;;
3396
esac
2391
3397
done
2392
3398
2393
3399
$opt_dry_run || {
2415
3421
if test -f "$nlist"S; then
2416
3422
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2417
3423
else
2418
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
3424
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2419
3425
fi
2420
3426
2421
$ECHO >> "$output_objdir/$my_dlsyms" "\
3427
echo >> "$output_objdir/$my_dlsyms" "\
2422
3428
2423
3429
/* The mapping between symbol names and symbols. */
2424
3430
typedef struct {
2425
3431
const char *name;
2426
3432
void *address;
2427
3433
} 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
3434
extern LT_DLSYM_CONST lt_dlsymlist
2446
3435
lt_${my_prefix}_LTX_preloaded_symbols[];
2447
$lt_dlsym_const lt_dlsymlist
3436
LT_DLSYM_CONST lt_dlsymlist
2448
3437
lt_${my_prefix}_LTX_preloaded_symbols[] =
2449
3438
{\
2450
3439
{ \"$my_originator\", (void *) 0 },"
2457
3446
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2458
3447
;;
2459
3448
esac
2460
$ECHO >> "$output_objdir/$my_dlsyms" "\
3449
echo >> "$output_objdir/$my_dlsyms" "\
2461
3450
{0, (void *) 0}
2462
3451
};
2463
3452
2484
3473
# linked before any other PIC object. But we must not use
2485
3474
# pic_flag when linking with -static. The problem exists in
2486
3475
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2487
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3476
*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2488
3477
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2489
3478
*-*-hpux*)
2490
3479
pic_flag_for_symtable=" $pic_flag" ;;
2500
3489
for arg in $LTCFLAGS; do
2501
3490
case $arg in
2502
3491
-pie | -fpie | -fPIE) ;;
2503
*) symtab_cflags="$symtab_cflags $arg" ;;
3492
*) func_append symtab_cflags " $arg" ;;
2504
3493
esac
2505
3494
done
2506
3495
2515
3504
case $host in
2516
3505
*cygwin* | *mingw* | *cegcc* )
2517
3506
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%"`
3507
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2520
3509
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%"`
3510
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2523
3512
fi
2524
3513
;;
2525
3514
*)
2526
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3515
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2528
3517
;;
2529
3518
esac
2530
3519
;;
2538
3527
# really was required.
2539
3528
2540
3529
# 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@%%"`
3530
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2543
3532
fi
2544
3533
}
2545
3534
2549
3538
# Need a lot of goo to handle *both* DLLs and import libs
2550
3539
# Has to be a shell function in order to 'eat' the argument
2551
3540
# that is supplied when $file_magic_command is called.
3541
# Despite the name, also deal with 64 bit binaries.
2552
3542
func_win32_libid ()
2553
3543
{
2554
3544
$opt_debug
2559
3549
win32_libid_type="x86 archive import"
2560
3550
;;
2561
3551
*ar\ archive*) # could be an import, or static
3552
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
2562
3553
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 |
3554
$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3555
func_to_tool_file "$1" func_convert_file_msys_to_w32
3556
win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
2565
3557
$SED -n -e '
2566
3558
1,100{
2567
3559
/ I /{
2590
3582
$ECHO "$win32_libid_type"
2591
3583
}
2592
3584
3585
# func_cygming_dll_for_implib ARG
3586
#
3587
# Platform-specific function to extract the
3588
# name of the DLL associated with the specified
3589
# import library ARG.
3590
# Invoked by eval'ing the libtool variable
3591
# $sharedlib_from_linklib_cmd
3592
# Result is available in the variable
3593
# $sharedlib_from_linklib_result
3594
func_cygming_dll_for_implib ()
3595
{
3596
$opt_debug
3597
sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3598
}
3599
3600
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3601
#
3602
# The is the core of a fallback implementation of a
3603
# platform-specific function to extract the name of the
3604
# DLL associated with the specified import library LIBNAME.
3605
#
3606
# SECTION_NAME is either .idata$6 or .idata$7, depending
3607
# on the platform and compiler that created the implib.
3608
#
3609
# Echos the name of the DLL associated with the
3610
# specified import library.
3611
func_cygming_dll_for_implib_fallback_core ()
3612
{
3613
$opt_debug
3614
match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615
$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3616
$SED '/^Contents of section '"$match_literal"':/{
3617
# Place marker at beginning of archive member dllname section
3618
s/.*/====MARK====/
3619
p
3620
d
3621
}
3622
# These lines can sometimes be longer than 43 characters, but
3623
# are always uninteresting
3624
/:[ ]*file format pe[i]\{,1\}-/d
3625
/^In archive [^:]*:/d
3626
# Ensure marker is printed
3627
/^====MARK====/p
3628
# Remove all lines with less than 43 characters
3629
/^.\{43\}/!d
3630
# From remaining lines, remove first 43 characters
3631
s/^.\{43\}//' |
3632
$SED -n '
3633
# Join marker and all lines until next marker into a single line
3634
/^====MARK====/ b para
3635
H
3636
$ b para
3637
b
3638
:para
3639
x
3640
s/\n//g
3641
# Remove the marker
3642
s/^====MARK====//
3643
# Remove trailing dots and whitespace
3644
s/[\. \t]*$//
3645
# Print
3646
/./p' |
3647
# we now have a list, one entry per line, of the stringified
3648
# contents of the appropriate section of all members of the
3649
# archive which possess that section. Heuristic: eliminate
3650
# all those which have a first or second character that is
3651
# a '.' (that is, objdump's representation of an unprintable
3652
# character.) This should work for all archives with less than
3653
# 0x302f exports -- but will fail for DLLs whose name actually
3654
# begins with a literal '.' or a single character followed by
3655
# a '.'.
3656
#
3657
# Of those that remain, print the first one.
3658
$SED -e '/^\./d;/^.\./d;q'
3659
}
3660
3661
# func_cygming_gnu_implib_p ARG
3662
# This predicate returns with zero status (TRUE) if
3663
# ARG is a GNU/binutils-style import library. Returns
3664
# with nonzero status (FALSE) otherwise.
3665
func_cygming_gnu_implib_p ()
3666
{
3667
$opt_debug
3668
func_to_tool_file "$1" func_convert_file_msys_to_w32
3669
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)$'`
3670
test -n "$func_cygming_gnu_implib_tmp"
3671
}
3672
3673
# func_cygming_ms_implib_p ARG
3674
# This predicate returns with zero status (TRUE) if
3675
# ARG is an MS-style import library. Returns
3676
# with nonzero status (FALSE) otherwise.
3677
func_cygming_ms_implib_p ()
3678
{
3679
$opt_debug
3680
func_to_tool_file "$1" func_convert_file_msys_to_w32
3681
func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682
test -n "$func_cygming_ms_implib_tmp"
3683
}
3684
3685
# func_cygming_dll_for_implib_fallback ARG
3686
# Platform-specific function to extract the
3687
# name of the DLL associated with the specified
3688
# import library ARG.
3689
#
3690
# This fallback implementation is for use when $DLLTOOL
3691
# does not support the --identify-strict option.
3692
# Invoked by eval'ing the libtool variable
3693
# $sharedlib_from_linklib_cmd
3694
# Result is available in the variable
3695
# $sharedlib_from_linklib_result
3696
func_cygming_dll_for_implib_fallback ()
3697
{
3698
$opt_debug
3699
if func_cygming_gnu_implib_p "$1" ; then
3700
# binutils import library
3701
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702
elif func_cygming_ms_implib_p "$1" ; then
3703
# ms-generated import library
3704
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3705
else
3706
# unknown
3707
sharedlib_from_linklib_result=""
3708
fi
3709
}
2593
3710
2594
3711
2595
3712
# func_extract_an_archive dir oldlib
2598
3715
$opt_debug
2599
3716
f_ex_an_ar_dir="$1"; shift
2600
3717
f_ex_an_ar_oldlib="$1"
2601
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3718
if test "$lock_old_archive_extraction" = yes; then
3719
lockfile=$f_ex_an_ar_oldlib.lock
3720
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3721
func_echo "Waiting for $lockfile to be removed"
3722
sleep 2
3723
done
3724
fi
3725
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726
'stat=$?; rm -f "$lockfile"; exit $stat'
3727
if test "$lock_old_archive_extraction" = yes; then
3728
$opt_dry_run || rm -f "$lockfile"
3729
fi
2602
3730
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2603
3731
:
2604
3732
else
2669
3797
darwin_file=
2670
3798
darwin_files=
2671
3799
for darwin_file in $darwin_filelist; do
2672
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3800
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
2673
3801
$LIPO -create -output "$darwin_file" $darwin_files
2674
3802
done # $darwin_filelist
2675
3803
$RM -rf unfat-$$
2684
3812
func_extract_an_archive "$my_xdir" "$my_xabs"
2685
3813
;;
2686
3814
esac
2687
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3815
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
2688
3816
done
2689
3817
2690
3818
func_extract_archives_result="$my_oldobjs"
2691
3819
}
2692
3820
2693
3821
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 ()
3822
# func_emit_wrapper [arg=no]
3823
#
3824
# Emit a libtool wrapper script on stdout.
3825
# Don't directly open a file because we may want to
3826
# incorporate the script contents within a cygwin/mingw
3827
# wrapper executable. Must ONLY be called from within
3828
# func_mode_link because it depends on a number of variables
3829
# set therein.
3830
#
3831
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832
# variable will take. If 'yes', then the emitted script
3833
# will assume that the directory in which it is stored is
3834
# the $objdir directory. This is a cygwin/mingw-specific
3835
# behavior.
3836
func_emit_wrapper ()
2701
3837
{
2702
func_emit_wrapper_part1_arg1=no
2703
if test -n "$1" ; then
2704
func_emit_wrapper_part1_arg1=$1
2705
fi
3838
func_emit_wrapper_arg1=${1-no}
2706
3839
2707
3840
$ECHO "\
2708
3841
#! $SHELL
2718
3851
2719
3852
# Sed substitution that helps us do robust quoting. It backslashifies
2720
3853
# metacharacters that are still active within double-quoted strings.
2721
Xsed='${SED} -e 1s/^X//'
2722
3854
sed_quote_subst='$sed_quote_subst'
2723
3855
2724
3856
# Be Bourne compatible
2749
3881
else
2750
3882
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2751
3883
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.
3884
file=\"\$0\""
3885
3886
qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3887
$ECHO "\
3888
3889
# A function that is used when there is no print builtin or printf.
3890
func_fallback_echo ()
3891
{
3892
eval 'cat <<_LTECHO_EOF
3893
\$1
3894
_LTECHO_EOF'
3895
}
3896
ECHO=\"$qECHO\"
3897
fi
3898
3899
# Very basic option parsing. These options are (a) specific to
3900
# the libtool wrapper, (b) are identical between the wrapper
3901
# /script/ and the wrapper /executable/ which is used only on
3902
# windows platforms, and (c) all begin with the string "--lt-"
3903
# (application programs are unlikely to have options which match
3904
# this pattern).
3905
#
3906
# There are only two supported options: --lt-debug and
3907
# --lt-dump-script. There is, deliberately, no --lt-help.
3908
#
3909
# The first argument to this parsing function should be the
3910
# script's $0 value, followed by "$@".
3911
lt_option_debug=
3912
func_parse_lt_options ()
3913
{
3914
lt_script_arg0=\$0
3915
shift
3916
for lt_opt
3917
do
3918
case \"\$lt_opt\" in
3919
--lt-debug) lt_option_debug=1 ;;
3920
--lt-dump-script)
3921
lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922
test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923
lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924
cat \"\$lt_dump_D/\$lt_dump_F\"
3925
exit 0
3926
;;
3927
--lt-*)
3928
\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3929
exit 1
3930
;;
3931
esac
3932
done
3933
3934
# Print the debug banner immediately:
3935
if test -n \"\$lt_option_debug\"; then
3936
echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937
fi
3938
}
3939
3940
# Used when --lt-debug. Prints its arguments to stdout
3941
# (redirection is the responsibility of the caller)
3942
func_lt_dump_args ()
3943
{
3944
lt_dump_args_N=1;
3945
for lt_arg
3946
do
3947
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948
lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949
done
3950
}
3951
3952
# Core function for launching the target application
3953
func_exec_program_core ()
3954
{
3955
"
3956
case $host in
3957
# Backslashes separate directories on plain windows
3958
*-*-mingw | *-*-os2* | *-cegcc*)
3959
$ECHO "\
3960
if test -n \"\$lt_option_debug\"; then
3961
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962
func_lt_dump_args \${1+\"\$@\"} 1>&2
3963
fi
3964
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3965
"
3966
;;
3967
3968
*)
3969
$ECHO "\
3970
if test -n \"\$lt_option_debug\"; then
3971
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3972
func_lt_dump_args \${1+\"\$@\"} 1>&2
3973
fi
3974
exec \"\$progdir/\$program\" \${1+\"\$@\"}
3975
"
3976
;;
3977
esac
3978
$ECHO "\
3979
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3980
exit 1
3981
}
3982
3983
# A function to encapsulate launching the target application
3984
# Strips options in the --lt-* namespace from \$@ and
3985
# launches target application with the remaining arguments.
3986
func_exec_program ()
3987
{
3988
case \" \$* \" in
3989
*\\ --lt-*)
3990
for lt_wr_arg
3991
do
3992
case \$lt_wr_arg in
3993
--lt-*) ;;
3994
*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3995
esac
2757
3996
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 "\
3997
done ;;
3998
esac
3999
func_exec_program_core \${1+\"\$@\"}
4000
}
4001
4002
# Parse options
4003
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
2768
4004
2769
4005
# Find the directory that this script lives in.
2770
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4006
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
2771
4007
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2772
4008
2773
4009
# Follow symbolic links until we get to the real thisdir.
2774
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4010
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
2775
4011
while test -n \"\$file\"; do
2776
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4012
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
2777
4013
2778
4014
# If there was a directory component, then change thisdir.
2779
4015
if test \"x\$destdir\" != \"x\$file\"; then
2783
4019
esac
2784
4020
fi
2785
4021
2786
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4022
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
2788
4024
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
4025
2807
4026
# Usually 'no', except on cygwin/mingw when embedded into
2808
4027
# the cwrapper.
2809
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
4028
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
2810
4029
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811
4030
# special case for '.'
2812
4031
if test \"\$thisdir\" = \".\"; then
2814
4033
fi
2815
4034
# remove .libs from thisdir
2816
4035
case \"\$thisdir\" in
2817
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
4036
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818
4037
$objdir ) thisdir=. ;;
2819
4038
esac
2820
4039
fi
2869
4088
2870
4089
if test -f \"\$progdir/\$program\"; then"
2871
4090
4091
# fixup the dll searchpath if we need to.
4092
#
4093
# Fix the DLL searchpath if we need to. Do this before prepending
4094
# to shlibpath, because on Windows, both are PATH and uninstalled
4095
# libraries must come first.
4096
if test -n "$dllsearchpath"; then
4097
$ECHO "\
4098
# Add the dll search path components to the executable PATH
4099
PATH=$dllsearchpath:\$PATH
4100
"
4101
fi
4102
2872
4103
# Export our shlibpath_var if we have one.
2873
4104
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2874
4105
$ECHO "\
2877
4108
2878
4109
# Some systems cannot cope with colon-terminated $shlibpath_var
2879
4110
# The second colon is a workaround for a bug in BeOS R4 sed
2880
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4111
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
2881
4112
2882
4113
export $shlibpath_var
2883
4114
"
2884
4115
fi
2885
4116
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
4117
$ECHO "\
2895
4118
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896
4119
# 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
4120
func_exec_program \${1+\"\$@\"}
2915
4121
fi
2916
4122
else
2917
4123
# The program doesn't exist.
2918
4124
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919
4125
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4126
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2921
4127
exit 1
2922
4128
fi
2923
4129
fi\
2924
4130
"
2925
4131
}
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
4132
3127
4133
3128
4134
# func_emit_cwrapperexe_src
3129
4135
# emit the source code for a wrapper executable on stdout
3141
4147
3142
4148
This wrapper executable should never be moved out of the build directory.
3143
4149
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
4150
*/
3149
4151
EOF
3150
4152
cat <<"EOF"
4153
#ifdef _MSC_VER
4154
# define _CRT_SECURE_NO_DEPRECATE 1
4155
#endif
3151
4156
#include <stdio.h>
3152
4157
#include <stdlib.h>
3153
4158
#ifdef _MSC_VER
3154
4159
# include <direct.h>
3155
4160
# include <process.h>
3156
4161
# include <io.h>
3157
# define setmode _setmode
3158
4162
#else
3159
4163
# include <unistd.h>
3160
4164
# include <stdint.h>
3161
4165
# ifdef __CYGWIN__
3162
4166
# 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
4167
# endif
3170
4168
#endif
3171
4169
#include <malloc.h>
3177
4175
#include <fcntl.h>
3178
4176
#include <sys/stat.h>
3179
4177
4178
/* declarations of non-ANSI functions */
4179
#if defined(__MINGW32__)
4180
# ifdef __STRICT_ANSI__
4181
int _putenv (const char *);
4182
# endif
4183
#elif defined(__CYGWIN__)
4184
# ifdef __STRICT_ANSI__
4185
char *realpath (const char *, char *);
4186
int putenv (char *);
4187
int setenv (const char *, const char *, int);
4188
# endif
4189
/* #elif defined (other platforms) ... */
4190
#endif
4191
4192
/* portability defines, excluding path handling macros */
4193
#if defined(_MSC_VER)
4194
# define setmode _setmode
4195
# define stat _stat
4196
# define chmod _chmod
4197
# define getcwd _getcwd
4198
# define putenv _putenv
4199
# define S_IXUSR _S_IEXEC
4200
# ifndef _INTPTR_T_DEFINED
4201
# define _INTPTR_T_DEFINED
4202
# define intptr_t int
4203
# endif
4204
#elif defined(__MINGW32__)
4205
# define setmode _setmode
4206
# define stat _stat
4207
# define chmod _chmod
4208
# define getcwd _getcwd
4209
# define putenv _putenv
4210
#elif defined(__CYGWIN__)
4211
# define HAVE_SETENV
4212
# define FOPEN_WB "wb"
4213
/* #elif defined (other platforms) ... */
4214
#endif
4215
3180
4216
#if defined(PATH_MAX)
3181
4217
# define LT_PATHMAX PATH_MAX
3182
4218
#elif defined(MAXPATHLEN)
3192
4228
# define S_IXGRP 0
3193
4229
#endif
3194
4230
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
4231
/* path handling portability macros */
3203
4232
#ifndef DIR_SEPARATOR
3204
4233
# define DIR_SEPARATOR '/'
3205
4234
# define PATH_SEPARATOR ':'
3230
4259
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231
4260
#endif /* PATH_SEPARATOR_2 */
3232
4261
3233
#ifdef __CYGWIN__
3234
# define FOPEN_WB "wb"
3235
#endif
3236
3237
4262
#ifndef FOPEN_WB
3238
4263
# define FOPEN_WB "w"
3239
4264
#endif
3246
4271
if (stale) { free ((void *) stale); stale = 0; } \
3247
4272
} while (0)
3248
4273
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
}
4274
#if defined(LT_DEBUGWRAPPER)
4275
static int lt_debug = 1;
3260
4276
#else
3261
# define LTWRAPPER_DEBUGPRINTF(args)
4277
static int lt_debug = 0;
3262
4278
#endif
3263
4279
3264
const char *program_name = NULL;
4280
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
3265
4281
3266
4282
void *xmalloc (size_t num);
3267
4283
char *xstrdup (const char *string);
3271
4287
int make_executable (const char *path);
3272
4288
int check_executable (const char *path);
3273
4289
char *strendzap (char *str, const char *pat);
3274
void lt_fatal (const char *message, ...);
4290
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4291
void lt_fatal (const char *file, int line, const char *message, ...);
4292
static const char *nonnull (const char *s);
4293
static const char *nonempty (const char *s);
3275
4294
void lt_setenv (const char *name, const char *value);
3276
4295
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
4296
void lt_update_exe_path (const char *name, const char *value);
3282
4297
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";
4298
char **prepare_spawn (char **argv);
4299
void lt_dump_script (FILE *f);
4300
EOF
4301
4302
cat <<EOF
4303
volatile const char * MAGIC_EXE = "$magic_exe";
3302
4304
const char * LIB_PATH_VARNAME = "$shlibpath_var";
3303
4305
EOF
3304
4306
3305
4307
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306
func_to_host_pathlist "$temp_rpath"
4308
func_to_host_path "$temp_rpath"
3307
4309
cat <<EOF
3308
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
4310
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
3309
4311
EOF
3310
4312
else
3311
4313
cat <<"EOF"
3314
4316
fi
3315
4317
3316
4318
if test -n "$dllsearchpath"; then
3317
func_to_host_pathlist "$dllsearchpath:"
4319
func_to_host_path "$dllsearchpath:"
3318
4320
cat <<EOF
3319
4321
const char * EXE_PATH_VARNAME = "PATH";
3320
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
4322
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
3321
4323
EOF
3322
4324
else
3323
4325
cat <<"EOF"
3340
4342
cat <<"EOF"
3341
4343
3342
4344
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3343
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3344
4345
3345
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346
4346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3347
3348
4347
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 */
4348
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
3361
4349
3362
4350
int
3363
4351
main (int argc, char *argv[])
3374
4362
int i;
3375
4363
3376
4364
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));
4365
newargz = XMALLOC (char *, argc + 1);
3379
4366
3380
/* very simple arg parsing; don't want to rely on getopt */
4367
/* very simple arg parsing; don't want to rely on getopt
4368
* also, copy all non cwrapper options to newargz, except
4369
* argz[0], which is handled differently
4370
*/
4371
newargc=0;
3381
4372
for (i = 1; i < argc; i++)
3382
4373
{
3383
4374
if (strcmp (argv[i], dumpscript_opt) == 0)
3391
4382
esac
3392
4383
3393
4384
cat <<"EOF"
3394
printf ("%s", script_text_part1);
3395
printf ("%s", script_text_part2);
4385
lt_dump_script (stdout);
3396
4386
return 0;
3397
4387
}
4388
if (strcmp (argv[i], debug_opt) == 0)
4389
{
4390
lt_debug = 1;
4391
continue;
4392
}
4393
if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4394
{
4395
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4396
namespace, but it is not one of the ones we know about and
4397
have already dealt with, above (inluding dump-script), then
4398
report an error. Otherwise, targets might begin to believe
4399
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4400
namespace. The first time any user complains about this, we'll
4401
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4402
or a configure.ac-settable value.
4403
*/
4404
lt_fatal (__FILE__, __LINE__,
4405
"unrecognized %s option: '%s'",
4406
ltwrapper_option_prefix, argv[i]);
4407
}
4408
/* otherwise ... */
4409
newargz[++newargc] = xstrdup (argv[i]);
3398
4410
}
3399
3400
newargz = XMALLOC (char *, argc + 1);
4411
newargz[++newargc] = NULL;
4412
4413
EOF
4414
cat <<EOF
4415
/* The GNU banner must be the first non-error debug message */
4416
lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4417
EOF
4418
cat <<"EOF"
4419
lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4420
lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4421
3401
4422
tmp_pathspec = find_executable (argv[0]);
3402
4423
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));
4424
lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4425
lt_debugprintf (__FILE__, __LINE__,
4426
"(main) found exe (before symlink chase) at: %s\n",
4427
tmp_pathspec);
3406
4428
3407
4429
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3408
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409
actual_cwrapper_path));
4430
lt_debugprintf (__FILE__, __LINE__,
4431
"(main) found exe (after symlink chase) at: %s\n",
4432
actual_cwrapper_path);
3410
4433
XFREE (tmp_pathspec);
3411
4434
3412
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
4435
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
3413
4436
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3414
4437
3415
4438
/* wrapper name transforms */
3427
4450
target_name = tmp_pathspec;
3428
4451
tmp_pathspec = 0;
3429
4452
3430
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3431
target_name));
4453
lt_debugprintf (__FILE__, __LINE__,
4454
"(main) libtool target name: %s\n",
4455
target_name);
3432
4456
EOF
3433
4457
3434
4458
cat <<EOF
3478
4502
3479
4503
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3480
4504
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4505
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4506
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4507
because on Windows, both *_VARNAMEs are PATH but uninstalled
4508
libraries must come first. */
4509
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3481
4510
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>")));
4511
4512
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513
nonnull (lt_argv_zero));
3552
4514
for (i = 0; i < newargc; i++)
3553
4515
{
3554
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4516
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517
i, nonnull (newargz[i]));
3555
4518
}
3556
4519
3557
4520
EOF
3560
4523
mingw*)
3561
4524
cat <<"EOF"
3562
4525
/* execv doesn't actually work on mingw as expected on unix */
4526
newargz = prepare_spawn (newargz);
3563
4527
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3564
4528
if (rval == -1)
3565
4529
{
3566
4530
/* failed to start process */
3567
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4531
lt_debugprintf (__FILE__, __LINE__,
4532
"(main) failed to launch target \"%s\": %s\n",
4533
lt_argv_zero, nonnull (strerror (errno)));
3568
4534
return 127;
3569
4535
}
3570
4536
return rval;
3586
4552
{
3587
4553
void *p = (void *) malloc (num);
3588
4554
if (!p)
3589
lt_fatal ("Memory exhausted");
4555
lt_fatal (__FILE__, __LINE__, "memory exhausted");
3590
4556
3591
4557
return p;
3592
4558
}
3620
4586
{
3621
4587
struct stat st;
3622
4588
3623
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3624
path ? (*path ? path : "EMPTY!") : "NULL!"));
4589
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4590
nonempty (path));
3625
4591
if ((!path) || (!*path))
3626
4592
return 0;
3627
4593
3638
4604
int rval = 0;
3639
4605
struct stat st;
3640
4606
3641
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3642
path ? (*path ? path : "EMPTY!") : "NULL!"));
4607
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4608
nonempty (path));
3643
4609
if ((!path) || (!*path))
3644
4610
return 0;
3645
4611
3665
4631
int tmp_len;
3666
4632
char *concat_name;
3667
4633
3668
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3669
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4634
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4635
nonempty (wrapper));
3670
4636
3671
4637
if ((wrapper == NULL) || (*wrapper == '\0'))
3672
4638
return NULL;
3719
4685
{
3720
4686
/* empty path: current directory */
3721
4687
if (getcwd (tmp, LT_PATHMAX) == NULL)
3722
lt_fatal ("getcwd failed");
4688
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4689
nonnull (strerror (errno)));
3723
4690
tmp_len = strlen (tmp);
3724
4691
concat_name =
3725
4692
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3744
4711
}
3745
4712
/* Relative path | not found in path: prepend cwd */
3746
4713
if (getcwd (tmp, LT_PATHMAX) == NULL)
3747
lt_fatal ("getcwd failed");
4714
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4715
nonnull (strerror (errno)));
3748
4716
tmp_len = strlen (tmp);
3749
4717
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3750
4718
memcpy (concat_name, tmp, tmp_len);
3770
4738
int has_symlinks = 0;
3771
4739
while (strlen (tmp_pathspec) && !has_symlinks)
3772
4740
{
3773
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3774
tmp_pathspec));
4741
lt_debugprintf (__FILE__, __LINE__,
4742
"checking path component for symlinks: %s\n",
4743
tmp_pathspec);
3775
4744
if (lstat (tmp_pathspec, &s) == 0)
3776
4745
{
3777
4746
if (S_ISLNK (s.st_mode) != 0)
3793
4762
}
3794
4763
else
3795
4764
{
3796
char *errstr = strerror (errno);
3797
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4765
lt_fatal (__FILE__, __LINE__,
4766
"error accessing file \"%s\": %s",
4767
tmp_pathspec, nonnull (strerror (errno)));
3798
4768
}
3799
4769
}
3800
4770
XFREE (tmp_pathspec);
3807
4777
tmp_pathspec = realpath (pathspec, buf);
3808
4778
if (tmp_pathspec == 0)
3809
4779
{
3810
lt_fatal ("Could not follow symlinks for %s", pathspec);
4780
lt_fatal (__FILE__, __LINE__,
4781
"could not follow symlinks for %s", pathspec);
3811
4782
}
3812
4783
return xstrdup (tmp_pathspec);
3813
4784
#endif
3833
4804
return str;
3834
4805
}
3835
4806
4807
void
4808
lt_debugprintf (const char *file, int line, const char *fmt, ...)
4809
{
4810
va_list args;
4811
if (lt_debug)
4812
{
4813
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4814
va_start (args, fmt);
4815
(void) vfprintf (stderr, fmt, args);
4816
va_end (args);
4817
}
4818
}
4819
3836
4820
static void
3837
lt_error_core (int exit_status, const char *mode,
4821
lt_error_core (int exit_status, const char *file,
4822
int line, const char *mode,
3838
4823
const char *message, va_list ap)
3839
4824
{
3840
fprintf (stderr, "%s: %s: ", program_name, mode);
4825
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
3841
4826
vfprintf (stderr, message, ap);
3842
4827
fprintf (stderr, ".\n");
3843
4828
3846
4831
}
3847
4832
3848
4833
void
3849
lt_fatal (const char *message, ...)
4834
lt_fatal (const char *file, int line, const char *message, ...)
3850
4835
{
3851
4836
va_list ap;
3852
4837
va_start (ap, message);
3853
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4838
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
3854
4839
va_end (ap);
3855
4840
}
3856
4841
4842
static const char *
4843
nonnull (const char *s)
4844
{
4845
return s ? s : "(null)";
4846
}
4847
4848
static const char *
4849
nonempty (const char *s)
4850
{
4851
return (s && !*s) ? "(empty)" : nonnull (s);
4852
}
4853
3857
4854
void
3858
4855
lt_setenv (const char *name, const char *value)
3859
4856
{
3860
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861
(name ? name : "<NULL>"),
3862
(value ? value : "<NULL>")));
4857
lt_debugprintf (__FILE__, __LINE__,
4858
"(lt_setenv) setting '%s' to '%s'\n",
4859
nonnull (name), nonnull (value));
3863
4860
{
3864
4861
#ifdef HAVE_SETENV
3865
4862
/* always make a copy, for consistency with !HAVE_SETENV */
3904
4901
return new_value;
3905
4902
}
3906
4903
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
4904
void
3991
4905
lt_update_exe_path (const char *name, const char *value)
3992
4906
{
3993
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994
(name ? name : "<NULL>"),
3995
(value ? value : "<NULL>")));
4907
lt_debugprintf (__FILE__, __LINE__,
4908
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909
nonnull (name), nonnull (value));
3996
4910
3997
4911
if (name && *name && value && *value)
3998
4912
{
4011
4925
void
4012
4926
lt_update_lib_path (const char *name, const char *value)
4013
4927
{
4014
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015
(name ? name : "<NULL>"),
4016
(value ? value : "<NULL>")));
4928
lt_debugprintf (__FILE__, __LINE__,
4929
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930
nonnull (name), nonnull (value));
4017
4931
4018
4932
if (name && *name && value && *value)
4019
4933
{
4023
4937
}
4024
4938
}
4025
4939
4026
4940
EOF
4941
case $host_os in
4942
mingw*)
4943
cat <<"EOF"
4944
4945
/* Prepares an argument vector before calling spawn().
4946
Note that spawn() does not by itself call the command interpreter
4947
(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4948
({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4949
GetVersionEx(&v);
4950
v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4951
}) ? "cmd.exe" : "command.com").
4952
Instead it simply concatenates the arguments, separated by ' ', and calls
4953
CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4954
interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4955
special way:
4956
- Space and tab are interpreted as delimiters. They are not treated as
4957
delimiters if they are surrounded by double quotes: "...".
4958
- Unescaped double quotes are removed from the input. Their only effect is
4959
that within double quotes, space and tab are treated like normal
4960
characters.
4961
- Backslashes not followed by double quotes are not special.
4962
- But 2*n+1 backslashes followed by a double quote become
4963
n backslashes followed by a double quote (n >= 0):
4964
\" -> "
4965
\\\" -> \"
4966
\\\\\" -> \\"
4967
*/
4968
#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"
4969
#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"
4970
char **
4971
prepare_spawn (char **argv)
4972
{
4973
size_t argc;
4974
char **new_argv;
4975
size_t i;
4976
4977
/* Count number of arguments. */
4978
for (argc = 0; argv[argc] != NULL; argc++)
4979
;
4980
4981
/* Allocate new argument vector. */
4982
new_argv = XMALLOC (char *, argc + 1);
4983
4984
/* Put quoted arguments into the new argument vector. */
4985
for (i = 0; i < argc; i++)
4986
{
4987
const char *string = argv[i];
4988
4989
if (string[0] == '\0')
4990
new_argv[i] = xstrdup ("\"\"");
4991
else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4992
{
4993
int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4994
size_t length;
4995
unsigned int backslashes;
4996
const char *s;
4997
char *quoted_string;
4998
char *p;
4999
5000
length = 0;
5001
backslashes = 0;
5002
if (quote_around)
5003
length++;
5004
for (s = string; *s != '\0'; s++)
5005
{
5006
char c = *s;
5007
if (c == '"')
5008
length += backslashes + 1;
5009
length++;
5010
if (c == '\\')
5011
backslashes++;
5012
else
5013
backslashes = 0;
5014
}
5015
if (quote_around)
5016
length += backslashes + 1;
5017
5018
quoted_string = XMALLOC (char, length + 1);
5019
5020
p = quoted_string;
5021
backslashes = 0;
5022
if (quote_around)
5023
*p++ = '"';
5024
for (s = string; *s != '\0'; s++)
5025
{
5026
char c = *s;
5027
if (c == '"')
5028
{
5029
unsigned int j;
5030
for (j = backslashes + 1; j > 0; j--)
5031
*p++ = '\\';
5032
}
5033
*p++ = c;
5034
if (c == '\\')
5035
backslashes++;
5036
else
5037
backslashes = 0;
5038
}
5039
if (quote_around)
5040
{
5041
unsigned int j;
5042
for (j = backslashes; j > 0; j--)
5043
*p++ = '\\';
5044
*p++ = '"';
5045
}
5046
*p = '\0';
5047
5048
new_argv[i] = quoted_string;
5049
}
5050
else
5051
new_argv[i] = (char *) string;
5052
}
5053
new_argv[argc] = NULL;
5054
5055
return new_argv;
5056
}
5057
EOF
5058
;;
5059
esac
5060
5061
cat <<"EOF"
5062
void lt_dump_script (FILE* f)
5063
{
5064
EOF
5065
func_emit_wrapper yes |
5066
$SED -n -e '
5067
s/^\(.\{79\}\)\(..*\)/\1\
5068
\2/
5069
h
5070
s/\([\\"]\)/\\\1/g
5071
s/$/\\n/
5072
s/\([^\n]*\).*/ fputs ("\1", f);/p
5073
g
5074
D'
5075
cat <<"EOF"
5076
}
4027
5077
EOF
4028
5078
}
4029
5079
# end: func_emit_cwrapperexe_src
4030
5080
5081
# func_win32_import_lib_p ARG
5082
# True if ARG is an import lib, as indicated by $file_magic_cmd
5083
func_win32_import_lib_p ()
5084
{
5085
$opt_debug
5086
case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5087
*import*) : ;;
5088
*) false ;;
5089
esac
5090
}
5091
4031
5092
# func_mode_link arg...
4032
5093
func_mode_link ()
4033
5094
{
4072
5133
new_inherited_linker_flags=
4073
5134
4074
5135
avoid_version=no
5136
bindir=
4075
5137
dlfiles=
4076
5138
dlprefiles=
4077
5139
dlself=no
4164
5226
esac
4165
5227
4166
5228
case $prev in
5229
bindir)
5230
bindir="$arg"
5231
prev=
5232
continue
5233
;;
4167
5234
dlfiles|dlprefiles)
4168
5235
if test "$preload" = no; then
4169
5236
# Add the symbol object into the linking commands.
4195
5262
;;
4196
5263
*)
4197
5264
if test "$prev" = dlfiles; then
4198
dlfiles="$dlfiles $arg"
5265
func_append dlfiles " $arg"
4199
5266
else
4200
dlprefiles="$dlprefiles $arg"
5267
func_append dlprefiles " $arg"
4201
5268
fi
4202
5269
prev=
4203
5270
continue
4221
5288
*-*-darwin*)
4222
5289
case "$deplibs " in
4223
5290
*" $qarg.ltframework "*) ;;
4224
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
5291
*) func_append deplibs " $qarg.ltframework" # this is fixed later
4225
5292
;;
4226
5293
esac
4227
5294
;;
4240
5307
moreargs=
4241
5308
for fil in `cat "$save_arg"`
4242
5309
do
4243
# moreargs="$moreargs $fil"
5310
# func_append moreargs " $fil"
4244
5311
arg=$fil
4245
5312
# A libtool-controlled object.
4246
5313
4269
5336
4270
5337
if test "$prev" = dlfiles; then
4271
5338
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4272
dlfiles="$dlfiles $pic_object"
5339
func_append dlfiles " $pic_object"
4273
5340
prev=
4274
5341
continue
4275
5342
else
4281
5348
# CHECK ME: I think I busted this. -Ossama
4282
5349
if test "$prev" = dlprefiles; then
4283
5350
# Preload the old-style object.
4284
dlprefiles="$dlprefiles $pic_object"
5351
func_append dlprefiles " $pic_object"
4285
5352
prev=
4286
5353
fi
4287
5354
4351
5418
if test "$prev" = rpath; then
4352
5419
case "$rpath " in
4353
5420
*" $arg "*) ;;
4354
*) rpath="$rpath $arg" ;;
5421
*) func_append rpath " $arg" ;;
4355
5422
esac
4356
5423
else
4357
5424
case "$xrpath " in
4358
5425
*" $arg "*) ;;
4359
*) xrpath="$xrpath $arg" ;;
5426
*) func_append xrpath " $arg" ;;
4360
5427
esac
4361
5428
fi
4362
5429
prev=
4368
5435
continue
4369
5436
;;
4370
5437
weak)
4371
weak_libs="$weak_libs $arg"
5438
func_append weak_libs " $arg"
4372
5439
prev=
4373
5440
continue
4374
5441
;;
4375
5442
xcclinker)
4376
linker_flags="$linker_flags $qarg"
4377
compiler_flags="$compiler_flags $qarg"
5443
func_append linker_flags " $qarg"
5444
func_append compiler_flags " $qarg"
4378
5445
prev=
4379
5446
func_append compile_command " $qarg"
4380
5447
func_append finalize_command " $qarg"
4381
5448
continue
4382
5449
;;
4383
5450
xcompiler)
4384
compiler_flags="$compiler_flags $qarg"
5451
func_append compiler_flags " $qarg"
4385
5452
prev=
4386
5453
func_append compile_command " $qarg"
4387
5454
func_append finalize_command " $qarg"
4388
5455
continue
4389
5456
;;
4390
5457
xlinker)
4391
linker_flags="$linker_flags $qarg"
4392
compiler_flags="$compiler_flags $wl$qarg"
5458
func_append linker_flags " $qarg"
5459
func_append compiler_flags " $wl$qarg"
4393
5460
prev=
4394
5461
func_append compile_command " $wl$qarg"
4395
5462
func_append finalize_command " $wl$qarg"
4425
5492
continue
4426
5493
;;
4427
5494
5495
-bindir)
5496
prev=bindir
5497
continue
5498
;;
5499
4428
5500
-dlopen)
4429
5501
prev=dlfiles
4430
5502
continue
4475
5547
;;
4476
5548
4477
5549
-L*)
4478
func_stripname '-L' '' "$arg"
4479
dir=$func_stripname_result
4480
if test -z "$dir"; then
5550
func_stripname "-L" '' "$arg"
5551
if test -z "$func_stripname_result"; then
4481
5552
if test "$#" -gt 0; then
4482
5553
func_fatal_error "require no space between \`-L' and \`$1'"
4483
5554
else
4484
5555
func_fatal_error "need path for \`-L' option"
4485
5556
fi
4486
5557
fi
5558
func_resolve_sysroot "$func_stripname_result"
5559
dir=$func_resolve_sysroot_result
4487
5560
# We need an absolute path.
4488
5561
case $dir in
4489
5562
[\\/]* | [A-Za-z]:[\\/]*) ;;
4495
5568
;;
4496
5569
esac
4497
5570
case "$deplibs " in
4498
*" -L$dir "*) ;;
5571
*" -L$dir "* | *" $arg "*)
5572
# Will only happen for absolute or sysroot arguments
5573
;;
4499
5574
*)
4500
deplibs="$deplibs -L$dir"
4501
lib_search_path="$lib_search_path $dir"
5575
# Preserve sysroot, but never include relative directories
5576
case $dir in
5577
[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5578
*) func_append deplibs " -L$dir" ;;
5579
esac
5580
func_append lib_search_path " $dir"
4502
5581
;;
4503
5582
esac
4504
5583
case $host in
4505
5584
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4506
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
5585
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4507
5586
case :$dllsearchpath: in
4508
5587
*":$dir:"*) ;;
4509
5588
::) dllsearchpath=$dir;;
4510
*) dllsearchpath="$dllsearchpath:$dir";;
5589
*) func_append dllsearchpath ":$dir";;
4511
5590
esac
4512
5591
case :$dllsearchpath: in
4513
5592
*":$testbindir:"*) ;;
4514
5593
::) dllsearchpath=$testbindir;;
4515
*) dllsearchpath="$dllsearchpath:$testbindir";;
5594
*) func_append dllsearchpath ":$testbindir";;
4516
5595
esac
4517
5596
;;
4518
5597
esac
4522
5601
-l*)
4523
5602
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4524
5603
case $host in
4525
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5604
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4526
5605
# These systems don't actually have a C or math library (as such)
4527
5606
continue
4528
5607
;;
4536
5615
;;
4537
5616
*-*-rhapsody* | *-*-darwin1.[012])
4538
5617
# Rhapsody C and math libraries are in the System framework
4539
deplibs="$deplibs System.ltframework"
5618
func_append deplibs " System.ltframework"
4540
5619
continue
4541
5620
;;
4542
5621
*-*-sco3.2v5* | *-*-sco5v6*)
4556
5635
;;
4557
5636
esac
4558
5637
fi
4559
deplibs="$deplibs $arg"
5638
func_append deplibs " $arg"
4560
5639
continue
4561
5640
;;
4562
5641
4568
5647
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4569
5648
# classes, name mangling, and exception handling.
4570
5649
# Darwin uses the -arch flag to determine output architecture.
4571
-model|-arch|-isysroot)
4572
compiler_flags="$compiler_flags $arg"
5650
-model|-arch|-isysroot|--sysroot)
5651
func_append compiler_flags " $arg"
4573
5652
func_append compile_command " $arg"
4574
5653
func_append finalize_command " $arg"
4575
5654
prev=xcompiler
4576
5655
continue
4577
5656
;;
4578
5657
4579
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4580
compiler_flags="$compiler_flags $arg"
5658
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660
func_append compiler_flags " $arg"
4581
5661
func_append compile_command " $arg"
4582
5662
func_append finalize_command " $arg"
4583
5663
case "$new_inherited_linker_flags " in
4584
5664
*" $arg "*) ;;
4585
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5665
* ) func_append new_inherited_linker_flags " $arg" ;;
4586
5666
esac
4587
5667
continue
4588
5668
;;
4649
5729
# We need an absolute path.
4650
5730
case $dir in
4651
5731
[\\/]* | [A-Za-z]:[\\/]*) ;;
5732
=*)
5733
func_stripname '=' '' "$dir"
5734
dir=$lt_sysroot$func_stripname_result
5735
;;
4652
5736
*)
4653
5737
func_fatal_error "only absolute run-paths are allowed"
4654
5738
;;
4655
5739
esac
4656
5740
case "$xrpath " in
4657
5741
*" $dir "*) ;;
4658
*) xrpath="$xrpath $dir" ;;
5742
*) func_append xrpath " $dir" ;;
4659
5743
esac
4660
5744
continue
4661
5745
;;
4708
5792
for flag in $args; do
4709
5793
IFS="$save_ifs"
4710
5794
func_quote_for_eval "$flag"
4711
arg="$arg $wl$func_quote_for_eval_result"
4712
compiler_flags="$compiler_flags $func_quote_for_eval_result"
5795
func_append arg " $func_quote_for_eval_result"
5796
func_append compiler_flags " $func_quote_for_eval_result"
4713
5797
done
4714
5798
IFS="$save_ifs"
4715
5799
func_stripname ' ' '' "$arg"
4724
5808
for flag in $args; do
4725
5809
IFS="$save_ifs"
4726
5810
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"
5811
func_append arg " $wl$func_quote_for_eval_result"
5812
func_append compiler_flags " $wl$func_quote_for_eval_result"
5813
func_append linker_flags " $func_quote_for_eval_result"
4730
5814
done
4731
5815
IFS="$save_ifs"
4732
5816
func_stripname ' ' '' "$arg"
4754
5838
arg="$func_quote_for_eval_result"
4755
5839
;;
4756
5840
4757
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4758
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4759
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4760
# +DA*, +DD* enable 64-bit mode on the HP compiler
4761
# -q* pass through compiler args for the IBM compiler
4762
# -m*, -t[45]*, -txscale* pass through architecture-specific
4763
# compiler args for GCC
4764
# -F/path gives path to uninstalled frameworks, gcc on darwin
4765
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4766
# @file GCC response files
5841
# Flags to be passed through unchanged, with rationale:
5842
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5843
# -r[0-9][0-9]* specify processor for the SGI compiler
5844
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5845
# +DA*, +DD* enable 64-bit mode for the HP compiler
5846
# -q* compiler args for the IBM compiler
5847
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5848
# -F/path path to uninstalled frameworks, gcc on darwin
5849
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5850
# @file GCC response files
5851
# -tp=* Portland pgcc target processor selection
5852
# --sysroot=* for sysroot support
5853
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
4767
5854
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4768
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5855
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
4769
5857
func_quote_for_eval "$arg"
4770
5858
arg="$func_quote_for_eval_result"
4771
5859
func_append compile_command " $arg"
4772
5860
func_append finalize_command " $arg"
4773
compiler_flags="$compiler_flags $arg"
5861
func_append compiler_flags " $arg"
4774
5862
continue
4775
5863
;;
4776
5864
4782
5870
4783
5871
*.$objext)
4784
5872
# A standard object.
4785
objs="$objs $arg"
5873
func_append objs " $arg"
4786
5874
;;
4787
5875
4788
5876
*.lo)
4813
5901
4814
5902
if test "$prev" = dlfiles; then
4815
5903
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4816
dlfiles="$dlfiles $pic_object"
5904
func_append dlfiles " $pic_object"
4817
5905
prev=
4818
5906
continue
4819
5907
else
4825
5913
# CHECK ME: I think I busted this. -Ossama
4826
5914
if test "$prev" = dlprefiles; then
4827
5915
# Preload the old-style object.
4828
dlprefiles="$dlprefiles $pic_object"
5916
func_append dlprefiles " $pic_object"
4829
5917
prev=
4830
5918
fi
4831
5919
4870
5958
4871
5959
*.$libext)
4872
5960
# An archive.
4873
deplibs="$deplibs $arg"
4874
old_deplibs="$old_deplibs $arg"
5961
func_append deplibs " $arg"
5962
func_append old_deplibs " $arg"
4875
5963
continue
4876
5964
;;
4877
5965
4878
5966
*.la)
4879
5967
# A libtool-controlled library.
4880
5968
5969
func_resolve_sysroot "$arg"
4881
5970
if test "$prev" = dlfiles; then
4882
5971
# This library was specified with -dlopen.
4883
dlfiles="$dlfiles $arg"
5972
func_append dlfiles " $func_resolve_sysroot_result"
4884
5973
prev=
4885
5974
elif test "$prev" = dlprefiles; then
4886
5975
# The library was specified with -dlpreopen.
4887
dlprefiles="$dlprefiles $arg"
5976
func_append dlprefiles " $func_resolve_sysroot_result"
4888
5977
prev=
4889
5978
else
4890
deplibs="$deplibs $arg"
5979
func_append deplibs " $func_resolve_sysroot_result"
4891
5980
fi
4892
5981
continue
4893
5982
;;
4925
6014
4926
6015
if test -n "$shlibpath_var"; then
4927
6016
# get the directories listed in $shlibpath_var
4928
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
6017
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
4929
6018
else
4930
6019
shlib_search_path=
4931
6020
fi
4934
6023
4935
6024
func_dirname "$output" "/" ""
4936
6025
output_objdir="$func_dirname_result$objdir"
6026
func_to_tool_file "$output_objdir/"
6027
tool_output_objdir=$func_to_tool_file_result
4937
6028
# Create the object directory.
4938
6029
func_mkdir_p "$output_objdir"
4939
6030
4954
6045
# Find all interdependent deplibs by searching for libraries
4955
6046
# that are linked more than once (e.g. -la -lb -la)
4956
6047
for deplib in $deplibs; do
4957
if $opt_duplicate_deps ; then
6048
if $opt_preserve_dup_deps ; then
4958
6049
case "$libs " in
4959
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6050
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
4960
6051
esac
4961
6052
fi
4962
libs="$libs $deplib"
6053
func_append libs " $deplib"
4963
6054
done
4964
6055
4965
6056
if test "$linkmode" = lib; then
4972
6063
if $opt_duplicate_compiler_generated_deps; then
4973
6064
for pre_post_dep in $predeps $postdeps; do
4974
6065
case "$pre_post_deps " in
4975
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
6066
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
4976
6067
esac
4977
pre_post_deps="$pre_post_deps $pre_post_dep"
6068
func_append pre_post_deps " $pre_post_dep"
4978
6069
done
4979
6070
fi
4980
6071
pre_post_deps=
5041
6132
for lib in $dlprefiles; do
5042
6133
# Ignore non-libtool-libs
5043
6134
dependency_libs=
6135
func_resolve_sysroot "$lib"
5044
6136
case $lib in
5045
*.la) func_source "$lib" ;;
6137
*.la) func_source "$func_resolve_sysroot_result" ;;
5046
6138
esac
5047
6139
5048
6140
# Collect preopened libtool deplibs, except any this library
5049
6141
# has declared as weak libs
5050
6142
for deplib in $dependency_libs; do
5051
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
6143
func_basename "$deplib"
6144
deplib_base=$func_basename_result
5052
6145
case " $weak_libs " in
5053
6146
*" $deplib_base "*) ;;
5054
*) deplibs="$deplibs $deplib" ;;
6147
*) func_append deplibs " $deplib" ;;
5055
6148
esac
5056
6149
done
5057
6150
done
5067
6160
lib=
5068
6161
found=no
5069
6162
case $deplib in
5070
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
6163
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6164
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5071
6165
if test "$linkmode,$pass" = "prog,link"; then
5072
6166
compile_deplibs="$deplib $compile_deplibs"
5073
6167
finalize_deplibs="$deplib $finalize_deplibs"
5074
6168
else
5075
compiler_flags="$compiler_flags $deplib"
6169
func_append compiler_flags " $deplib"
5076
6170
if test "$linkmode" = lib ; then
5077
6171
case "$new_inherited_linker_flags " in
5078
6172
*" $deplib "*) ;;
5079
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6173
* ) func_append new_inherited_linker_flags " $deplib" ;;
5080
6174
esac
5081
6175
fi
5082
6176
fi
5161
6255
if test "$linkmode" = lib ; then
5162
6256
case "$new_inherited_linker_flags " in
5163
6257
*" $deplib "*) ;;
5164
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
6258
* ) func_append new_inherited_linker_flags " $deplib" ;;
5165
6259
esac
5166
6260
fi
5167
6261
fi
5174
6268
test "$pass" = conv && continue
5175
6269
newdependency_libs="$deplib $newdependency_libs"
5176
6270
func_stripname '-L' '' "$deplib"
5177
newlib_search_path="$newlib_search_path $func_stripname_result"
6271
func_resolve_sysroot "$func_stripname_result"
6272
func_append newlib_search_path " $func_resolve_sysroot_result"
5178
6273
;;
5179
6274
prog)
5180
6275
if test "$pass" = conv; then
5188
6283
finalize_deplibs="$deplib $finalize_deplibs"
5189
6284
fi
5190
6285
func_stripname '-L' '' "$deplib"
5191
newlib_search_path="$newlib_search_path $func_stripname_result"
6286
func_resolve_sysroot "$func_stripname_result"
6287
func_append newlib_search_path " $func_resolve_sysroot_result"
5192
6288
;;
5193
6289
*)
5194
6290
func_warning "\`-L' is ignored for archives/objects"
5199
6295
-R*)
5200
6296
if test "$pass" = link; then
5201
6297
func_stripname '-R' '' "$deplib"
5202
dir=$func_stripname_result
6298
func_resolve_sysroot "$func_stripname_result"
6299
dir=$func_resolve_sysroot_result
5203
6300
# Make sure the xrpath contains only unique directories.
5204
6301
case "$xrpath " in
5205
6302
*" $dir "*) ;;
5206
*) xrpath="$xrpath $dir" ;;
6303
*) func_append xrpath " $dir" ;;
5207
6304
esac
5208
6305
fi
5209
6306
deplibs="$deplib $deplibs"
5210
6307
continue
5211
6308
;;
5212
*.la) lib="$deplib" ;;
6309
*.la)
6310
func_resolve_sysroot "$deplib"
6311
lib=$func_resolve_sysroot_result
6312
;;
5213
6313
*.$libext)
5214
6314
if test "$pass" = conv; then
5215
6315
deplibs="$deplib $deplibs"
5227
6327
match_pattern*)
5228
6328
set dummy $deplibs_check_method; shift
5229
6329
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5230
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
6330
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5231
6331
| $EGREP "$match_pattern_regex" > /dev/null; then
5232
6332
valid_a_lib=yes
5233
6333
fi
5237
6337
;;
5238
6338
esac
5239
6339
if test "$valid_a_lib" != yes; then
5240
$ECHO
6340
echo
5241
6341
$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."
6342
echo "*** I have the capability to make that library automatically link in when"
6343
echo "*** you link to this library. But I can only do this if you have a"
6344
echo "*** shared version of the library, which you do not appear to have"
6345
echo "*** because the file extensions .$libext of this argument makes me believe"
6346
echo "*** that it is just a static archive that I should not use here."
5247
6347
else
5248
$ECHO
6348
echo
5249
6349
$ECHO "*** Warning: Linking the shared library $output against the"
5250
6350
$ECHO "*** static library $deplib is not portable!"
5251
6351
deplibs="$deplib $deplibs"
5272
6372
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5273
6373
# If there is no dlopen support or we're linking statically,
5274
6374
# we need to preload.
5275
newdlprefiles="$newdlprefiles $deplib"
6375
func_append newdlprefiles " $deplib"
5276
6376
compile_deplibs="$deplib $compile_deplibs"
5277
6377
finalize_deplibs="$deplib $finalize_deplibs"
5278
6378
else
5279
newdlfiles="$newdlfiles $deplib"
6379
func_append newdlfiles " $deplib"
5280
6380
fi
5281
6381
fi
5282
6382
continue
5318
6418
5319
6419
# Convert "-framework foo" to "foo.ltframework"
5320
6420
if test -n "$inherited_linker_flags"; then
5321
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
6421
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5322
6422
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5323
6423
case " $new_inherited_linker_flags " in
5324
6424
*" $tmp_inherited_linker_flag "*) ;;
5325
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
6425
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
5326
6426
esac
5327
6427
done
5328
6428
fi
5329
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6429
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5330
6430
if test "$linkmode,$pass" = "lib,link" ||
5331
6431
test "$linkmode,$pass" = "prog,scan" ||
5332
6432
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5333
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5334
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
6433
test -n "$dlopen" && func_append dlfiles " $dlopen"
6434
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
5335
6435
fi
5336
6436
5337
6437
if test "$pass" = conv; then
5342
6442
func_fatal_error "cannot find name of link library for \`$lib'"
5343
6443
fi
5344
6444
# 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"
6445
func_append convenience " $ladir/$objdir/$old_library"
6446
func_append old_convenience " $ladir/$objdir/$old_library"
5347
6447
elif test "$linkmode" != prog && test "$linkmode" != lib; then
5348
6448
func_fatal_error "\`$lib' is not a convenience library"
5349
6449
fi
5350
6450
tmp_libs=
5351
6451
for deplib in $dependency_libs; do
5352
6452
deplibs="$deplib $deplibs"
5353
if $opt_duplicate_deps ; then
6453
if $opt_preserve_dup_deps ; then
5354
6454
case "$tmp_libs " in
5355
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6455
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
5356
6456
esac
5357
6457
fi
5358
tmp_libs="$tmp_libs $deplib"
6458
func_append tmp_libs " $deplib"
5359
6459
done
5360
6460
continue
5361
6461
fi # $pass = conv
5363
6463
5364
6464
# Get the name of the library we link against.
5365
6465
linklib=
5366
for l in $old_library $library_names; do
5367
linklib="$l"
5368
done
6466
if test -n "$old_library" &&
6467
{ test "$prefer_static_libs" = yes ||
6468
test "$prefer_static_libs,$installed" = "built,no"; }; then
6469
linklib=$old_library
6470
else
6471
for l in $old_library $library_names; do
6472
linklib="$l"
6473
done
6474
fi
5369
6475
if test -z "$linklib"; then
5370
6476
func_fatal_error "cannot find name of link library for \`$lib'"
5371
6477
fi
5382
6488
# statically, we need to preload. We also need to preload any
5383
6489
# dependent libraries so libltdl's deplib preloader doesn't
5384
6490
# bomb out in the load deplibs phase.
5385
dlprefiles="$dlprefiles $lib $dependency_libs"
6491
func_append dlprefiles " $lib $dependency_libs"
5386
6492
else
5387
newdlfiles="$newdlfiles $lib"
6493
func_append newdlfiles " $lib"
5388
6494
fi
5389
6495
continue
5390
6496
fi # $pass = dlopen
5406
6512
5407
6513
# Find the relevant object directory and library name.
5408
6514
if test "X$installed" = Xyes; then
5409
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6515
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5410
6516
func_warning "library \`$lib' was moved."
5411
6517
dir="$ladir"
5412
6518
absdir="$abs_ladir"
5413
6519
libdir="$abs_ladir"
5414
6520
else
5415
dir="$libdir"
5416
absdir="$libdir"
6521
dir="$lt_sysroot$libdir"
6522
absdir="$lt_sysroot$libdir"
5417
6523
fi
5418
6524
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5419
6525
else
5421
6527
dir="$ladir"
5422
6528
absdir="$abs_ladir"
5423
6529
# Remove this search path later
5424
notinst_path="$notinst_path $abs_ladir"
6530
func_append notinst_path " $abs_ladir"
5425
6531
else
5426
6532
dir="$ladir/$objdir"
5427
6533
absdir="$abs_ladir/$objdir"
5428
6534
# Remove this search path later
5429
notinst_path="$notinst_path $abs_ladir"
6535
func_append notinst_path " $abs_ladir"
5430
6536
fi
5431
6537
fi # $installed = yes
5432
6538
func_stripname 'lib' '.la' "$laname"
5437
6543
if test -z "$libdir" && test "$linkmode" = prog; then
5438
6544
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5439
6545
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
6546
case "$host" in
6547
# special handling for platforms with PE-DLLs.
6548
*cygwin* | *mingw* | *cegcc* )
6549
# Linker will automatically link against shared library if both
6550
# static and shared are present. Therefore, ensure we extract
6551
# symbols from the import library if a shared library is present
6552
# (otherwise, the dlopen module name will be incorrect). We do
6553
# this by putting the import library name into $newdlprefiles.
6554
# We recover the dlopen module name by 'saving' the la file
6555
# name in a special purpose variable, and (later) extracting the
6556
# dlname from the la file.
6557
if test -n "$dlname"; then
6558
func_tr_sh "$dir/$linklib"
6559
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6560
func_append newdlprefiles " $dir/$linklib"
6561
else
6562
func_append newdlprefiles " $dir/$old_library"
6563
# Keep a list of preopened convenience libraries to check
6564
# that they are being used correctly in the link pass.
6565
test -z "$libdir" && \
6566
func_append dlpreconveniencelibs " $dir/$old_library"
6567
fi
6568
;;
6569
* )
6570
# Prefer using a static library (so that no silly _DYNAMIC symbols
6571
# are required to link).
6572
if test -n "$old_library"; then
6573
func_append newdlprefiles " $dir/$old_library"
6574
# Keep a list of preopened convenience libraries to check
6575
# that they are being used correctly in the link pass.
6576
test -z "$libdir" && \
6577
func_append dlpreconveniencelibs " $dir/$old_library"
6578
# Otherwise, use the dlname, so that lt_dlopen finds it.
6579
elif test -n "$dlname"; then
6580
func_append newdlprefiles " $dir/$dlname"
6581
else
6582
func_append newdlprefiles " $dir/$linklib"
6583
fi
6584
;;
6585
esac
5454
6586
fi # $pass = dlpreopen
5455
6587
5456
6588
if test -z "$libdir"; then
5468
6600
5469
6601
5470
6602
if test "$linkmode" = prog && test "$pass" != link; then
5471
newlib_search_path="$newlib_search_path $ladir"
6603
func_append newlib_search_path " $ladir"
5472
6604
deplibs="$lib $deplibs"
5473
6605
5474
6606
linkalldeplibs=no
5481
6613
for deplib in $dependency_libs; do
5482
6614
case $deplib in
5483
6615
-L*) func_stripname '-L' '' "$deplib"
5484
newlib_search_path="$newlib_search_path $func_stripname_result"
6616
func_resolve_sysroot "$func_stripname_result"
6617
func_append newlib_search_path " $func_resolve_sysroot_result"
5485
6618
;;
5486
6619
esac
5487
6620
# Need to link against all dependency_libs?
5492
6625
# or/and link against static libraries
5493
6626
newdependency_libs="$deplib $newdependency_libs"
5494
6627
fi
5495
if $opt_duplicate_deps ; then
6628
if $opt_preserve_dup_deps ; then
5496
6629
case "$tmp_libs " in
5497
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6630
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
5498
6631
esac
5499
6632
fi
5500
tmp_libs="$tmp_libs $deplib"
6633
func_append tmp_libs " $deplib"
5501
6634
done # for deplib
5502
6635
continue
5503
6636
fi # $linkmode = prog...
5512
6645
# Make sure the rpath contains only unique directories.
5513
6646
case "$temp_rpath:" in
5514
6647
*"$absdir:"*) ;;
5515
*) temp_rpath="$temp_rpath$absdir:" ;;
6648
*) func_append temp_rpath "$absdir:" ;;
5516
6649
esac
5517
6650
fi
5518
6651
5524
6657
*)
5525
6658
case "$compile_rpath " in
5526
6659
*" $absdir "*) ;;
5527
*) compile_rpath="$compile_rpath $absdir"
6660
*) func_append compile_rpath " $absdir" ;;
5528
6661
esac
5529
6662
;;
5530
6663
esac
5533
6666
*)
5534
6667
case "$finalize_rpath " in
5535
6668
*" $libdir "*) ;;
5536
*) finalize_rpath="$finalize_rpath $libdir"
6669
*) func_append finalize_rpath " $libdir" ;;
5537
6670
esac
5538
6671
;;
5539
6672
esac
5558
6691
case $host in
5559
6692
*cygwin* | *mingw* | *cegcc*)
5560
6693
# No point in relinking DLLs because paths are not encoded
5561
notinst_deplibs="$notinst_deplibs $lib"
6694
func_append notinst_deplibs " $lib"
5562
6695
need_relink=no
5563
6696
;;
5564
6697
*)
5565
6698
if test "$installed" = no; then
5566
notinst_deplibs="$notinst_deplibs $lib"
6699
func_append notinst_deplibs " $lib"
5567
6700
need_relink=yes
5568
6701
fi
5569
6702
;;
5580
6713
fi
5581
6714
done
5582
6715
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5583
$ECHO
6716
echo
5584
6717
if test "$linkmode" = prog; then
5585
6718
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5586
6719
else
5598
6731
*)
5599
6732
case "$compile_rpath " in
5600
6733
*" $absdir "*) ;;
5601
*) compile_rpath="$compile_rpath $absdir"
6734
*) func_append compile_rpath " $absdir" ;;
5602
6735
esac
5603
6736
;;
5604
6737
esac
5607
6740
*)
5608
6741
case "$finalize_rpath " in
5609
6742
*" $libdir "*) ;;
5610
*) finalize_rpath="$finalize_rpath $libdir"
6743
*) func_append finalize_rpath " $libdir" ;;
5611
6744
esac
5612
6745
;;
5613
6746
esac
5661
6794
linklib=$newlib
5662
6795
fi # test -n "$old_archive_from_expsyms_cmds"
5663
6796
5664
if test "$linkmode" = prog || test "$mode" != relink; then
6797
if test "$linkmode" = prog || test "$opt_mode" != relink; then
5665
6798
add_shlibpath=
5666
6799
add_dir=
5667
6800
add=
5683
6816
if test "X$dlopenmodule" != "X$lib"; then
5684
6817
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5685
6818
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"
6819
echo
6820
echo "*** And there doesn't seem to be a static archive available"
6821
echo "*** The link will probably fail, sorry"
5689
6822
else
5690
6823
add="$dir/$old_library"
5691
6824
fi
5712
6845
test "$hardcode_direct_absolute" = no; then
5713
6846
add="$dir/$linklib"
5714
6847
elif test "$hardcode_minus_L" = yes; then
5715
add_dir="-L$dir"
6848
add_dir="-L$absdir"
5716
6849
# Try looking first in the location we're being installed to.
5717
6850
if test -n "$inst_prefix_dir"; then
5718
6851
case $libdir in
5719
6852
[\\/]*)
5720
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6853
func_append add_dir " -L$inst_prefix_dir$libdir"
5721
6854
;;
5722
6855
esac
5723
6856
fi
5739
6872
if test -n "$add_shlibpath"; then
5740
6873
case :$compile_shlibpath: in
5741
6874
*":$add_shlibpath:"*) ;;
5742
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6875
*) func_append compile_shlibpath "$add_shlibpath:" ;;
5743
6876
esac
5744
6877
fi
5745
6878
if test "$linkmode" = prog; then
5753
6886
test "$hardcode_shlibpath_var" = yes; then
5754
6887
case :$finalize_shlibpath: in
5755
6888
*":$libdir:"*) ;;
5756
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6889
*) func_append finalize_shlibpath "$libdir:" ;;
5757
6890
esac
5758
6891
fi
5759
6892
fi
5760
6893
fi
5761
6894
5762
if test "$linkmode" = prog || test "$mode" = relink; then
6895
if test "$linkmode" = prog || test "$opt_mode" = relink; then
5763
6896
add_shlibpath=
5764
6897
add_dir=
5765
6898
add=
5773
6906
elif test "$hardcode_shlibpath_var" = yes; then
5774
6907
case :$finalize_shlibpath: in
5775
6908
*":$libdir:"*) ;;
5776
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6909
*) func_append finalize_shlibpath "$libdir:" ;;
5777
6910
esac
5778
6911
add="-l$name"
5779
6912
elif test "$hardcode_automatic" = yes; then
5790
6923
if test -n "$inst_prefix_dir"; then
5791
6924
case $libdir in
5792
6925
[\\/]*)
5793
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6926
func_append add_dir " -L$inst_prefix_dir$libdir"
5794
6927
;;
5795
6928
esac
5796
6929
fi
5825
6958
5826
6959
# Just print a warning and add the library to dependency_libs so
5827
6960
# that the program can be linked against the static library.
5828
$ECHO
6961
echo
5829
6962
$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."
6963
echo "*** I have the capability to make that library automatically link in when"
6964
echo "*** you link to this library. But I can only do this if you have a"
6965
echo "*** shared version of the library, which you do not appear to have."
5833
6966
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."
6967
echo "*** But as you try to build a module library, libtool will still create "
6968
echo "*** a static module, that should work as long as the dlopening application"
6969
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
5837
6970
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."
6971
echo
6972
echo "*** However, this would only work if libtool was able to extract symbol"
6973
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6974
echo "*** not find such a program. So, this module is probably useless."
6975
echo "*** \`nm' from GNU binutils and a full rebuild may help."
5843
6976
fi
5844
6977
if test "$build_old_libs" = no; then
5845
6978
build_libtool_libs=module
5867
7000
temp_xrpath=$func_stripname_result
5868
7001
case " $xrpath " in
5869
7002
*" $temp_xrpath "*) ;;
5870
*) xrpath="$xrpath $temp_xrpath";;
7003
*) func_append xrpath " $temp_xrpath";;
5871
7004
esac;;
5872
*) temp_deplibs="$temp_deplibs $libdir";;
7005
*) func_append temp_deplibs " $libdir";;
5873
7006
esac
5874
7007
done
5875
7008
dependency_libs="$temp_deplibs"
5876
7009
fi
5877
7010
5878
newlib_search_path="$newlib_search_path $absdir"
7011
func_append newlib_search_path " $absdir"
5879
7012
# Link against this library
5880
7013
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5881
7014
# ... and its dependency_libs
5882
7015
tmp_libs=
5883
7016
for deplib in $dependency_libs; do
5884
7017
newdependency_libs="$deplib $newdependency_libs"
5885
if $opt_duplicate_deps ; then
7018
case $deplib in
7019
-L*) func_stripname '-L' '' "$deplib"
7020
func_resolve_sysroot "$func_stripname_result";;
7021
*) func_resolve_sysroot "$deplib" ;;
7022
esac
7023
if $opt_preserve_dup_deps ; then
5886
7024
case "$tmp_libs " in
5887
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
7025
*" $func_resolve_sysroot_result "*)
7026
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
5888
7027
esac
5889
7028
fi
5890
tmp_libs="$tmp_libs $deplib"
7029
func_append tmp_libs " $func_resolve_sysroot_result"
5891
7030
done
5892
7031
5893
7032
if test "$link_all_deplibs" != no; then
5894
7033
# Add the search paths of all dependency libraries
5895
7034
for deplib in $dependency_libs; do
7035
path=
5896
7036
case $deplib in
5897
7037
-L*) path="$deplib" ;;
5898
7038
*.la)
7039
func_resolve_sysroot "$deplib"
7040
deplib=$func_resolve_sysroot_result
5899
7041
func_dirname "$deplib" "" "."
5900
dir="$func_dirname_result"
7042
dir=$func_dirname_result
5901
7043
# We need an absolute path.
5902
7044
case $dir in
5903
7045
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5924
7066
if test -z "$darwin_install_name"; then
5925
7067
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5926
7068
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}"
7069
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7070
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
5929
7071
path=
5930
7072
fi
5931
7073
fi
5958
7100
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5959
7101
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5960
7102
else
5961
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7103
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5962
7104
fi
5963
7105
fi
5964
7106
dependency_libs="$newdependency_libs"
5975
7117
for dir in $newlib_search_path; do
5976
7118
case "$lib_search_path " in
5977
7119
*" $dir "*) ;;
5978
*) lib_search_path="$lib_search_path $dir" ;;
7120
*) func_append lib_search_path " $dir" ;;
5979
7121
esac
5980
7122
done
5981
7123
newlib_search_path=
6033
7175
-L*)
6034
7176
case " $tmp_libs " in
6035
7177
*" $deplib "*) ;;
6036
*) tmp_libs="$tmp_libs $deplib" ;;
7178
*) func_append tmp_libs " $deplib" ;;
6037
7179
esac
6038
7180
;;
6039
*) tmp_libs="$tmp_libs $deplib" ;;
7181
*) func_append tmp_libs " $deplib" ;;
6040
7182
esac
6041
7183
done
6042
7184
eval $var=\"$tmp_libs\"
6052
7194
;;
6053
7195
esac
6054
7196
if test -n "$i" ; then
6055
tmp_libs="$tmp_libs $i"
7197
func_append tmp_libs " $i"
6056
7198
fi
6057
7199
done
6058
7200
dependency_libs=$tmp_libs
6093
7235
# Now set the variables for building old libraries.
6094
7236
build_libtool_libs=no
6095
7237
oldlibs="$output"
6096
objs="$objs$old_deplibs"
7238
func_append objs "$old_deplibs"
6097
7239
;;
6098
7240
6099
7241
lib)
6126
7268
if test "$deplibs_check_method" != pass_all; then
6127
7269
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6128
7270
else
6129
$ECHO
7271
echo
6130
7272
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6131
7273
$ECHO "*** objects $objs is not portable!"
6132
libobjs="$libobjs $objs"
7274
func_append libobjs " $objs"
6133
7275
fi
6134
7276
fi
6135
7277
6188
7330
# which has an extra 1 added just for fun
6189
7331
#
6190
7332
case $version_type in
7333
# correct linux to gnu/linux during the next big refactor
6191
7334
darwin|linux|osf|windows|none)
6192
7335
func_arith $number_major + $number_minor
6193
7336
current=$func_arith_result
6194
7337
age="$number_minor"
6195
7338
revision="$number_revision"
6196
7339
;;
6197
freebsd-aout|freebsd-elf|sunos)
7340
freebsd-aout|freebsd-elf|qnx|sunos)
6198
7341
current="$number_major"
6199
7342
revision="$number_minor"
6200
7343
age="0"
6304
7447
versuffix="$major.$revision"
6305
7448
;;
6306
7449
6307
linux)
7450
linux) # correct to gnu/linux during the next big refactor
6308
7451
func_arith $current - $age
6309
7452
major=.$func_arith_result
6310
7453
versuffix="$major.$age.$revision"
6327
7470
done
6328
7471
6329
7472
# Make executables depend on our current version.
6330
verstring="$verstring:${current}.0"
7473
func_append verstring ":${current}.0"
6331
7474
;;
6332
7475
6333
7476
qnx)
6395
7538
fi
6396
7539
6397
7540
func_generate_dlsyms "$libname" "$libname" "yes"
6398
libobjs="$libobjs $symfileobj"
7541
func_append libobjs " $symfileobj"
6399
7542
test "X$libobjs" = "X " && libobjs=
6400
7543
6401
if test "$mode" != relink; then
7544
if test "$opt_mode" != relink; then
6402
7545
# Remove our outputs, but don't remove object files since they
6403
7546
# may have been created when compiling PIC objects.
6404
7547
removelist=
6414
7557
continue
6415
7558
fi
6416
7559
fi
6417
removelist="$removelist $p"
7560
func_append removelist " $p"
6418
7561
;;
6419
7562
*) ;;
6420
7563
esac
6425
7568
6426
7569
# Now set the variables for building old libraries.
6427
7570
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6428
oldlibs="$oldlibs $output_objdir/$libname.$libext"
7571
func_append oldlibs " $output_objdir/$libname.$libext"
6429
7572
6430
7573
# Transform .lo files to .o files.
6431
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
7574
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6432
7575
fi
6433
7576
6434
7577
# Eliminate all temporary directories.
6435
7578
#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"`
7579
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7580
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7581
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6439
7582
#done
6440
7583
6441
7584
if test -n "$xrpath"; then
6442
7585
# If the user specified any rpath flags, then add them.
6443
7586
temp_xrpath=
6444
7587
for libdir in $xrpath; do
6445
temp_xrpath="$temp_xrpath -R$libdir"
7588
func_replace_sysroot "$libdir"
7589
func_append temp_xrpath " -R$func_replace_sysroot_result"
6446
7590
case "$finalize_rpath " in
6447
7591
*" $libdir "*) ;;
6448
*) finalize_rpath="$finalize_rpath $libdir" ;;
7592
*) func_append finalize_rpath " $libdir" ;;
6449
7593
esac
6450
7594
done
6451
7595
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6459
7603
for lib in $old_dlfiles; do
6460
7604
case " $dlprefiles $dlfiles " in
6461
7605
*" $lib "*) ;;
6462
*) dlfiles="$dlfiles $lib" ;;
7606
*) func_append dlfiles " $lib" ;;
6463
7607
esac
6464
7608
done
6465
7609
6469
7613
for lib in $old_dlprefiles; do
6470
7614
case "$dlprefiles " in
6471
7615
*" $lib "*) ;;
6472
*) dlprefiles="$dlprefiles $lib" ;;
7616
*) func_append dlprefiles " $lib" ;;
6473
7617
esac
6474
7618
done
6475
7619
6476
7620
if test "$build_libtool_libs" = yes; then
6477
7621
if test -n "$rpath"; then
6478
7622
case $host in
6479
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
7623
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
6480
7624
# these systems don't actually have a c library (as such)!
6481
7625
;;
6482
7626
*-*-rhapsody* | *-*-darwin1.[012])
6483
7627
# Rhapsody C library is in the System framework
6484
deplibs="$deplibs System.ltframework"
7628
func_append deplibs " System.ltframework"
6485
7629
;;
6486
7630
*-*-netbsd*)
6487
7631
# Don't link with libc until the a.out ld.so is fixed.
6498
7642
*)
6499
7643
# Add libc to deplibs on all other systems if necessary.
6500
7644
if test "$build_libtool_need_lc" = "yes"; then
6501
deplibs="$deplibs -lc"
7645
func_append deplibs " -lc"
6502
7646
fi
6503
7647
;;
6504
7648
esac
6547
7691
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6548
7692
case " $predeps $postdeps " in
6549
7693
*" $i "*)
6550
newdeplibs="$newdeplibs $i"
7694
func_append newdeplibs " $i"
6551
7695
i=""
6552
7696
;;
6553
7697
esac
6558
7702
set dummy $deplib_matches; shift
6559
7703
deplib_match=$1
6560
7704
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6561
newdeplibs="$newdeplibs $i"
7705
func_append newdeplibs " $i"
6562
7706
else
6563
7707
droppeddeps=yes
6564
$ECHO
7708
echo
6565
7709
$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."
7710
echo "*** I have the capability to make that library automatically link in when"
7711
echo "*** you link to this library. But I can only do this if you have a"
7712
echo "*** shared version of the library, which I believe you do not have"
7713
echo "*** because a test_compile did reveal that the linker did not use it for"
7714
echo "*** its dynamic dependency list that programs get resolved with at runtime."
6571
7715
fi
6572
7716
fi
6573
7717
;;
6574
7718
*)
6575
newdeplibs="$newdeplibs $i"
7719
func_append newdeplibs " $i"
6576
7720
;;
6577
7721
esac
6578
7722
done
6590
7734
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6591
7735
case " $predeps $postdeps " in
6592
7736
*" $i "*)
6593
newdeplibs="$newdeplibs $i"
7737
func_append newdeplibs " $i"
6594
7738
i=""
6595
7739
;;
6596
7740
esac
6601
7745
set dummy $deplib_matches; shift
6602
7746
deplib_match=$1
6603
7747
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6604
newdeplibs="$newdeplibs $i"
7748
func_append newdeplibs " $i"
6605
7749
else
6606
7750
droppeddeps=yes
6607
$ECHO
7751
echo
6608
7752
$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."
7753
echo "*** I have the capability to make that library automatically link in when"
7754
echo "*** you link to this library. But I can only do this if you have a"
7755
echo "*** shared version of the library, which you do not appear to have"
7756
echo "*** because a test_compile did reveal that the linker did not use this one"
7757
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6614
7758
fi
6615
7759
fi
6616
7760
else
6617
7761
droppeddeps=yes
6618
$ECHO
7762
echo
6619
7763
$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."
7764
echo "*** make it link in! You will probably need to install it or some"
7765
echo "*** library that it depends on before this library will be fully"
7766
echo "*** functional. Installing it before continuing would be even better."
6623
7767
fi
6624
7768
;;
6625
7769
*)
6626
newdeplibs="$newdeplibs $i"
7770
func_append newdeplibs " $i"
6627
7771
;;
6628
7772
esac
6629
7773
done
6640
7784
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6641
7785
case " $predeps $postdeps " in
6642
7786
*" $a_deplib "*)
6643
newdeplibs="$newdeplibs $a_deplib"
7787
func_append newdeplibs " $a_deplib"
6644
7788
a_deplib=""
6645
7789
;;
6646
7790
esac
6647
7791
fi
6648
7792
if test -n "$a_deplib" ; then
6649
7793
libname=`eval "\\$ECHO \"$libname_spec\""`
7794
if test -n "$file_magic_glob"; then
7795
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7796
else
7797
libnameglob=$libname
7798
fi
7799
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
6650
7800
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6651
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7801
if test "$want_nocaseglob" = yes; then
7802
shopt -s nocaseglob
7803
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7804
$nocaseglob
7805
else
7806
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7807
fi
6652
7808
for potent_lib in $potential_libs; do
6653
7809
# Follow soft links.
6654
7810
if ls -lLd "$potent_lib" 2>/dev/null |
6665
7821
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6666
7822
case $potliblink in
6667
7823
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6668
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7824
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
6669
7825
esac
6670
7826
done
6671
7827
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6672
7828
$SED -e 10q |
6673
7829
$EGREP "$file_magic_regex" > /dev/null; then
6674
newdeplibs="$newdeplibs $a_deplib"
7830
func_append newdeplibs " $a_deplib"
6675
7831
a_deplib=""
6676
7832
break 2
6677
7833
fi
6680
7836
fi
6681
7837
if test -n "$a_deplib" ; then
6682
7838
droppeddeps=yes
6683
$ECHO
7839
echo
6684
7840
$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"
7841
echo "*** I have the capability to make that library automatically link in when"
7842
echo "*** you link to this library. But I can only do this if you have a"
7843
echo "*** shared version of the library, which you do not appear to have"
7844
echo "*** because I did check the linker path looking for a file starting"
6689
7845
if test -z "$potlib" ; then
6690
7846
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6691
7847
else
6696
7852
;;
6697
7853
*)
6698
7854
# Add a -L argument.
6699
newdeplibs="$newdeplibs $a_deplib"
7855
func_append newdeplibs " $a_deplib"
6700
7856
;;
6701
7857
esac
6702
7858
done # Gone through all deplibs.
6712
7868
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6713
7869
case " $predeps $postdeps " in
6714
7870
*" $a_deplib "*)
6715
newdeplibs="$newdeplibs $a_deplib"
7871
func_append newdeplibs " $a_deplib"
6716
7872
a_deplib=""
6717
7873
;;
6718
7874
esac
6723
7879
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6724
7880
for potent_lib in $potential_libs; do
6725
7881
potlib="$potent_lib" # see symlink-check above in file_magic test
6726
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7882
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
6727
7883
$EGREP "$match_pattern_regex" > /dev/null; then
6728
newdeplibs="$newdeplibs $a_deplib"
7884
func_append newdeplibs " $a_deplib"
6729
7885
a_deplib=""
6730
7886
break 2
6731
7887
fi
6734
7890
fi
6735
7891
if test -n "$a_deplib" ; then
6736
7892
droppeddeps=yes
6737
$ECHO
7893
echo
6738
7894
$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"
7895
echo "*** I have the capability to make that library automatically link in when"
7896
echo "*** you link to this library. But I can only do this if you have a"
7897
echo "*** shared version of the library, which you do not appear to have"
7898
echo "*** because I did check the linker path looking for a file starting"
6743
7899
if test -z "$potlib" ; then
6744
7900
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6745
7901
else
6750
7906
;;
6751
7907
*)
6752
7908
# Add a -L argument.
6753
newdeplibs="$newdeplibs $a_deplib"
7909
func_append newdeplibs " $a_deplib"
6754
7910
;;
6755
7911
esac
6756
7912
done # Gone through all deplibs.
6757
7913
;;
6758
7914
none | unknown | *)
6759
7915
newdeplibs=""
6760
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6761
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7916
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6762
7917
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6763
7918
for i in $predeps $postdeps ; do
6764
7919
# can't use Xsed below, because $i might contain '/'
6765
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7920
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
6766
7921
done
6767
7922
fi
6768
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6769
$GREP . >/dev/null; then
6770
$ECHO
7923
case $tmp_deplibs in
7924
*[!\ \ ]*)
7925
echo
6771
7926
if test "X$deplibs_check_method" = "Xnone"; then
6772
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7927
echo "*** Warning: inter-library dependencies are not supported in this platform."
6773
7928
else
6774
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
7929
echo "*** Warning: inter-library dependencies are not known to be supported."
6775
7930
fi
6776
$ECHO "*** All declared inter-library dependencies are being dropped."
7931
echo "*** All declared inter-library dependencies are being dropped."
6777
7932
droppeddeps=yes
6778
fi
7933
;;
7934
esac
6779
7935
;;
6780
7936
esac
6781
7937
versuffix=$versuffix_save
6787
7943
case $host in
6788
7944
*-*-rhapsody* | *-*-darwin1.[012])
6789
7945
# On Rhapsody replace the C library with the System framework
6790
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7946
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
6791
7947
;;
6792
7948
esac
6793
7949
6794
7950
if test "$droppeddeps" = yes; then
6795
7951
if test "$module" = yes; then
6796
$ECHO
6797
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7952
echo
7953
echo "*** Warning: libtool could not satisfy all declared inter-library"
6798
7954
$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."
7955
echo "*** a static module, that should work as long as the dlopening"
7956
echo "*** application is linked with the -dlopen flag."
6801
7957
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."
7958
echo
7959
echo "*** However, this would only work if libtool was able to extract symbol"
7960
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7961
echo "*** not find such a program. So, this module is probably useless."
7962
echo "*** \`nm' from GNU binutils and a full rebuild may help."
6807
7963
fi
6808
7964
if test "$build_old_libs" = no; then
6809
7965
oldlibs="$output_objdir/$libname.$libext"
6813
7969
build_libtool_libs=no
6814
7970
fi
6815
7971
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."
7972
echo "*** The inter-library dependencies that have been dropped here will be"
7973
echo "*** automatically added whenever a program is linked with this library"
7974
echo "*** or is declared to -dlopen it."
6819
7975
6820
7976
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."
7977
echo
7978
echo "*** Since this library must not contain undefined symbols,"
7979
echo "*** because either the platform does not support them or"
7980
echo "*** it was explicitly requested with -no-undefined,"
7981
echo "*** libtool will only create a static version of it."
6826
7982
if test "$build_old_libs" = no; then
6827
7983
oldlibs="$output_objdir/$libname.$libext"
6828
7984
build_libtool_libs=module
6839
7995
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6840
7996
case $host in
6841
7997
*-*-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'`
7998
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7999
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8000
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6845
8001
;;
6846
8002
esac
6847
8003
6854
8010
*)
6855
8011
case " $deplibs " in
6856
8012
*" -L$path/$objdir "*)
6857
new_libs="$new_libs -L$path/$objdir" ;;
8013
func_append new_libs " -L$path/$objdir" ;;
6858
8014
esac
6859
8015
;;
6860
8016
esac
6864
8020
-L*)
6865
8021
case " $new_libs " in
6866
8022
*" $deplib "*) ;;
6867
*) new_libs="$new_libs $deplib" ;;
8023
*) func_append new_libs " $deplib" ;;
6868
8024
esac
6869
8025
;;
6870
*) new_libs="$new_libs $deplib" ;;
8026
*) func_append new_libs " $deplib" ;;
6871
8027
esac
6872
8028
done
6873
8029
deplibs="$new_libs"
6879
8035
6880
8036
# Test again, we may have decided not to build it any more
6881
8037
if test "$build_libtool_libs" = yes; then
8038
# Remove ${wl} instances when linking with ld.
8039
# FIXME: should test the right _cmds variable.
8040
case $archive_cmds in
8041
*\$LD\ *) wl= ;;
8042
esac
6882
8043
if test "$hardcode_into_libs" = yes; then
6883
8044
# Hardcode the library paths
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_append perm_rpath " $libdir" ;;
6911
8074
esac
6912
8075
fi
6913
8076
done
6915
8078
if test -n "$hardcode_libdir_separator" &&
6916
8079
test -n "$hardcode_libdirs"; then
6917
8080
libdir="$hardcode_libdirs"
6918
if test -n "$hardcode_libdir_flag_spec_ld"; then
6919
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6920
else
6921
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6922
fi
8081
eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
6923
8082
fi
6924
8083
if test -n "$runpath_var" && test -n "$perm_rpath"; then
6925
8084
# We should set the runpath_var.
6926
8085
rpath=
6927
8086
for dir in $perm_rpath; do
6928
rpath="$rpath$dir:"
8087
func_append rpath "$dir:"
6929
8088
done
6930
8089
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6931
8090
fi
6933
8092
fi
6934
8093
6935
8094
shlibpath="$finalize_shlibpath"
6936
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8095
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6937
8096
if test -n "$shlibpath"; then
6938
8097
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6939
8098
fi
6959
8118
linknames=
6960
8119
for link
6961
8120
do
6962
linknames="$linknames $link"
8121
func_append linknames " $link"
6963
8122
done
6964
8123
6965
8124
# Use standard objects if they are pic
6966
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8125
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
6967
8126
test "X$libobjs" = "X " && libobjs=
6968
8127
6969
8128
delfiles=
6970
8129
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6971
8130
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6972
8131
export_symbols="$output_objdir/$libname.uexp"
6973
delfiles="$delfiles $export_symbols"
8132
func_append delfiles " $export_symbols"
6974
8133
fi
6975
8134
6976
8135
orig_export_symbols=
7001
8160
$opt_dry_run || $RM $export_symbols
7002
8161
cmds=$export_symbols_cmds
7003
8162
save_ifs="$IFS"; IFS='~'
7004
for cmd in $cmds; do
8163
for cmd1 in $cmds; do
7005
8164
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 $?'
8165
# Take the normal branch if the nm_file_list_spec branch
8166
# doesn't work or if tool conversion is not needed.
8167
case $nm_file_list_spec~$to_tool_file_cmd in
8168
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8169
try_normal_branch=yes
8170
eval cmd=\"$cmd1\"
8171
func_len " $cmd"
8172
len=$func_len_result
8173
;;
8174
*)
8175
try_normal_branch=no
8176
;;
8177
esac
8178
if test "$try_normal_branch" = yes \
8179
&& { test "$len" -lt "$max_cmd_len" \
8180
|| test "$max_cmd_len" -le -1; }
8181
then
8182
func_show_eval "$cmd" 'exit $?'
8183
skipped_export=false
8184
elif test -n "$nm_file_list_spec"; then
8185
func_basename "$output"
8186
output_la=$func_basename_result
8187
save_libobjs=$libobjs
8188
save_output=$output
8189
output=${output_objdir}/${output_la}.nm
8190
func_to_tool_file "$output"
8191
libobjs=$nm_file_list_spec$func_to_tool_file_result
8192
func_append delfiles " $output"
8193
func_verbose "creating $NM input file list: $output"
8194
for obj in $save_libobjs; do
8195
func_to_tool_file "$obj"
8196
$ECHO "$func_to_tool_file_result"
8197
done > "$output"
8198
eval cmd=\"$cmd1\"
8199
func_show_eval "$cmd" 'exit $?'
8200
output=$save_output
8201
libobjs=$save_libobjs
7011
8202
skipped_export=false
7012
8203
else
7013
8204
# The command line is too long to execute in one step.
7029
8220
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7030
8221
tmp_export_symbols="$export_symbols"
7031
8222
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"'
8223
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7033
8224
fi
7034
8225
7035
8226
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7041
8232
# global variables. join(1) would be nice here, but unfortunately
7042
8233
# isn't a blessed tool.
7043
8234
$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"
8235
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7045
8236
export_symbols=$output_objdir/$libname.def
7046
8237
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7047
8238
fi
7051
8242
case " $convenience " in
7052
8243
*" $test_deplib "*) ;;
7053
8244
*)
7054
tmp_deplibs="$tmp_deplibs $test_deplib"
8245
func_append tmp_deplibs " $test_deplib"
7055
8246
;;
7056
8247
esac
7057
8248
done
7071
8262
test "X$libobjs" = "X " && libobjs=
7072
8263
else
7073
8264
gentop="$output_objdir/${outputname}x"
7074
generated="$generated $gentop"
8265
func_append generated " $gentop"
7075
8266
7076
8267
func_extract_archives $gentop $convenience
7077
libobjs="$libobjs $func_extract_archives_result"
8268
func_append libobjs " $func_extract_archives_result"
7078
8269
test "X$libobjs" = "X " && libobjs=
7079
8270
fi
7080
8271
fi
7081
8272
7082
8273
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7083
8274
eval flag=\"$thread_safe_flag_spec\"
7084
linker_flags="$linker_flags $flag"
8275
func_append linker_flags " $flag"
7085
8276
fi
7086
8277
7087
8278
# Make a backup of the uninstalled library when relinking
7088
if test "$mode" = relink; then
8279
if test "$opt_mode" = relink; then
7089
8280
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7090
8281
fi
7091
8282
7130
8321
save_libobjs=$libobjs
7131
8322
fi
7132
8323
save_output=$output
7133
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
8324
func_basename "$output"
8325
output_la=$func_basename_result
7134
8326
7135
8327
# Clear the reloadable object creation command queue and
7136
8328
# initialize k to one.
7143
8335
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7144
8336
output=${output_objdir}/${output_la}.lnkscript
7145
8337
func_verbose "creating GNU ld script: $output"
7146
$ECHO 'INPUT (' > $output
8338
echo 'INPUT (' > $output
7147
8339
for obj in $save_libobjs
7148
8340
do
7149
$ECHO "$obj" >> $output
8341
func_to_tool_file "$obj"
8342
$ECHO "$func_to_tool_file_result" >> $output
7150
8343
done
7151
$ECHO ')' >> $output
7152
delfiles="$delfiles $output"
8344
echo ')' >> $output
8345
func_append delfiles " $output"
8346
func_to_tool_file "$output"
8347
output=$func_to_tool_file_result
7153
8348
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7154
8349
output=${output_objdir}/${output_la}.lnk
7155
8350
func_verbose "creating linker input file list: $output"
7163
8358
fi
7164
8359
for obj
7165
8360
do
7166
$ECHO "$obj" >> $output
8361
func_to_tool_file "$obj"
8362
$ECHO "$func_to_tool_file_result" >> $output
7167
8363
done
7168
delfiles="$delfiles $output"
7169
output=$firstobj\"$file_list_spec$output\"
8364
func_append delfiles " $output"
8365
func_to_tool_file "$output"
8366
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
7170
8367
else
7171
8368
if test -n "$save_libobjs"; then
7172
8369
func_verbose "creating reloadable object files..."
7190
8387
# command to the queue.
7191
8388
if test "$k" -eq 1 ; then
7192
8389
# The first file doesn't have a previous command to add.
7193
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
8390
reload_objs=$objlist
8391
eval concat_cmds=\"$reload_cmds\"
7194
8392
else
7195
8393
# All subsequent reloadable object files will link in
7196
8394
# the last one created.
7197
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
8395
reload_objs="$objlist $last_robj"
8396
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
7198
8397
fi
7199
8398
last_robj=$output_objdir/$output_la-${k}.$objext
7200
8399
func_arith $k + 1
7201
8400
k=$func_arith_result
7202
8401
output=$output_objdir/$output_la-${k}.$objext
7203
objlist=$obj
8402
objlist=" $obj"
7204
8403
func_len " $last_robj"
7205
8404
func_arith $len0 + $func_len_result
7206
8405
len=$func_arith_result
7210
8409
# reloadable object file. All subsequent reloadable object
7211
8410
# files will link in the last one created.
7212
8411
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7213
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
8412
reload_objs="$objlist $last_robj"
8413
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
7214
8414
if test -n "$last_robj"; then
7215
8415
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7216
8416
fi
7217
delfiles="$delfiles $output"
8417
func_append delfiles " $output"
7218
8418
7219
8419
else
7220
8420
output=
7248
8448
lt_exit=$?
7249
8449
7250
8450
# Restore the uninstalled library and exit
7251
if test "$mode" = relink; then
8451
if test "$opt_mode" = relink; then
7252
8452
( cd "$output_objdir" && \
7253
8453
$RM "${realname}T" && \
7254
8454
$MV "${realname}U" "$realname" )
7269
8469
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7270
8470
tmp_export_symbols="$export_symbols"
7271
8471
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"'
8472
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
7273
8473
fi
7274
8474
7275
8475
if test -n "$orig_export_symbols"; then
7281
8481
# global variables. join(1) would be nice here, but unfortunately
7282
8482
# isn't a blessed tool.
7283
8483
$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"
8484
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
7285
8485
export_symbols=$output_objdir/$libname.def
7286
8486
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7287
8487
fi
7322
8522
# Add any objects from preloaded convenience libraries
7323
8523
if test -n "$dlprefiles"; then
7324
8524
gentop="$output_objdir/${outputname}x"
7325
generated="$generated $gentop"
8525
func_append generated " $gentop"
7326
8526
7327
8527
func_extract_archives $gentop $dlprefiles
7328
libobjs="$libobjs $func_extract_archives_result"
8528
func_append libobjs " $func_extract_archives_result"
7329
8529
test "X$libobjs" = "X " && libobjs=
7330
8530
fi
7331
8531
7341
8541
lt_exit=$?
7342
8542
7343
8543
# Restore the uninstalled library and exit
7344
if test "$mode" = relink; then
8544
if test "$opt_mode" = relink; then
7345
8545
( cd "$output_objdir" && \
7346
8546
$RM "${realname}T" && \
7347
8547
$MV "${realname}U" "$realname" )
7353
8553
IFS="$save_ifs"
7354
8554
7355
8555
# Restore the uninstalled library and exit
7356
if test "$mode" = relink; then
8556
if test "$opt_mode" = relink; then
7357
8557
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7358
8558
7359
8559
if test -n "$convenience"; then
7434
8634
if test -n "$convenience"; then
7435
8635
if test -n "$whole_archive_flag_spec"; then
7436
8636
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'`
8637
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
7438
8638
else
7439
8639
gentop="$output_objdir/${obj}x"
7440
generated="$generated $gentop"
8640
func_append generated " $gentop"
7441
8641
7442
8642
func_extract_archives $gentop $convenience
7443
8643
reload_conv_objs="$reload_objs $func_extract_archives_result"
7444
8644
fi
7445
8645
fi
7446
8646
8647
# If we're not building shared, we need to use non_pic_objs
8648
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8649
7447
8650
# 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
8651
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7449
8652
7450
8653
output="$obj"
7451
8654
func_execute_cmds "$reload_cmds" 'exit $?'
7505
8708
case $host in
7506
8709
*-*-rhapsody* | *-*-darwin1.[012])
7507
8710
# 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 /'`
8711
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8712
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
7510
8713
;;
7511
8714
esac
7512
8715
7517
8720
if test "$tagname" = CXX ; then
7518
8721
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7519
8722
10.[0123])
7520
compile_command="$compile_command ${wl}-bind_at_load"
7521
finalize_command="$finalize_command ${wl}-bind_at_load"
8723
func_append compile_command " ${wl}-bind_at_load"
8724
func_append finalize_command " ${wl}-bind_at_load"
7522
8725
;;
7523
8726
esac
7524
8727
fi
7525
8728
# 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'`
8729
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7528
8731
;;
7529
8732
esac
7530
8733
7538
8741
*)
7539
8742
case " $compile_deplibs " in
7540
8743
*" -L$path/$objdir "*)
7541
new_libs="$new_libs -L$path/$objdir" ;;
8744
func_append new_libs " -L$path/$objdir" ;;
7542
8745
esac
7543
8746
;;
7544
8747
esac
7548
8751
-L*)
7549
8752
case " $new_libs " in
7550
8753
*" $deplib "*) ;;
7551
*) new_libs="$new_libs $deplib" ;;
8754
*) func_append new_libs " $deplib" ;;
7552
8755
esac
7553
8756
;;
7554
*) new_libs="$new_libs $deplib" ;;
8757
*) func_append new_libs " $deplib" ;;
7555
8758
esac
7556
8759
done
7557
8760
compile_deplibs="$new_libs"
7558
8761
7559
8762
7560
compile_command="$compile_command $compile_deplibs"
7561
finalize_command="$finalize_command $finalize_deplibs"
8763
func_append compile_command " $compile_deplibs"
8764
func_append finalize_command " $finalize_deplibs"
7562
8765
7563
8766
if test -n "$rpath$xrpath"; then
7564
8767
# If the user specified any rpath flags, then add them.
7566
8769
# This is the magic to use -rpath.
7567
8770
case "$finalize_rpath " in
7568
8771
*" $libdir "*) ;;
7569
*) finalize_rpath="$finalize_rpath $libdir" ;;
8772
*) func_append finalize_rpath " $libdir" ;;
7570
8773
esac
7571
8774
done
7572
8775
fi
7585
8788
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7586
8789
;;
7587
8790
*)
7588
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8791
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7589
8792
;;
7590
8793
esac
7591
8794
fi
7592
8795
else
7593
8796
eval flag=\"$hardcode_libdir_flag_spec\"
7594
rpath="$rpath $flag"
8797
func_append rpath " $flag"
7595
8798
fi
7596
8799
elif test -n "$runpath_var"; then
7597
8800
case "$perm_rpath " in
7598
8801
*" $libdir "*) ;;
7599
*) perm_rpath="$perm_rpath $libdir" ;;
8802
*) func_append perm_rpath " $libdir" ;;
7600
8803
esac
7601
8804
fi
7602
8805
case $host in
7605
8808
case :$dllsearchpath: in
7606
8809
*":$libdir:"*) ;;
7607
8810
::) dllsearchpath=$libdir;;
7608
*) dllsearchpath="$dllsearchpath:$libdir";;
8811
*) func_append dllsearchpath ":$libdir";;
7609
8812
esac
7610
8813
case :$dllsearchpath: in
7611
8814
*":$testbindir:"*) ;;
7612
8815
::) dllsearchpath=$testbindir;;
7613
*) dllsearchpath="$dllsearchpath:$testbindir";;
8816
*) func_append dllsearchpath ":$testbindir";;
7614
8817
esac
7615
8818
;;
7616
8819
esac
7636
8839
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7637
8840
;;
7638
8841
*)
7639
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8842
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
7640
8843
;;
7641
8844
esac
7642
8845
fi
7643
8846
else
7644
8847
eval flag=\"$hardcode_libdir_flag_spec\"
7645
rpath="$rpath $flag"
8848
func_append rpath " $flag"
7646
8849
fi
7647
8850
elif test -n "$runpath_var"; then
7648
8851
case "$finalize_perm_rpath " in
7649
8852
*" $libdir "*) ;;
7650
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8853
*) func_append finalize_perm_rpath " $libdir" ;;
7651
8854
esac
7652
8855
fi
7653
8856
done
7661
8864
7662
8865
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7663
8866
# 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`
8867
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8868
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7666
8869
fi
7667
8870
7668
8871
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7674
8877
7675
8878
wrappers_required=yes
7676
8879
case $host in
8880
*cegcc* | *mingw32ce*)
8881
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8882
wrappers_required=no
8883
;;
7677
8884
*cygwin* | *mingw* )
7678
8885
if test "$build_libtool_libs" != yes; then
7679
8886
wrappers_required=no
7680
8887
fi
7681
8888
;;
7682
*cegcc)
7683
# Disable wrappers for cegcc, we are cross compiling anyway.
7684
wrappers_required=no
7685
;;
7686
8889
*)
7687
8890
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7688
8891
wrappers_required=no
7691
8894
esac
7692
8895
if test "$wrappers_required" = no; then
7693
8896
# Replace the output file specification.
7694
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8897
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7695
8898
link_command="$compile_command$compile_rpath"
7696
8899
7697
8900
# We have no uninstalled library dependencies, so finalize right now.
7698
8901
exit_status=0
7699
8902
func_show_eval "$link_command" 'exit_status=$?'
7700
8903
8904
if test -n "$postlink_cmds"; then
8905
func_to_tool_file "$output"
8906
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8907
func_execute_cmds "$postlink_cmds" 'exit $?'
8908
fi
8909
7701
8910
# Delete the generated files.
7702
8911
if test -f "$output_objdir/${outputname}S.${objext}"; then
7703
8912
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7720
8929
# We should set the runpath_var.
7721
8930
rpath=
7722
8931
for dir in $perm_rpath; do
7723
rpath="$rpath$dir:"
8932
func_append rpath "$dir:"
7724
8933
done
7725
8934
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7726
8935
fi
7728
8937
# We should set the runpath_var.
7729
8938
rpath=
7730
8939
for dir in $finalize_perm_rpath; do
7731
rpath="$rpath$dir:"
8940
func_append rpath "$dir:"
7732
8941
done
7733
8942
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7734
8943
fi
7738
8947
# We don't need to create a wrapper script.
7739
8948
link_command="$compile_var$compile_command$compile_rpath"
7740
8949
# Replace the output file specification.
7741
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8950
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7742
8951
# Delete the old output file.
7743
8952
$opt_dry_run || $RM $output
7744
8953
# Link the executable and exit
7745
8954
func_show_eval "$link_command" 'exit $?'
8955
8956
if test -n "$postlink_cmds"; then
8957
func_to_tool_file "$output"
8958
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8959
func_execute_cmds "$postlink_cmds" 'exit $?'
8960
fi
8961
7746
8962
exit $EXIT_SUCCESS
7747
8963
fi
7748
8964
7757
8973
if test "$fast_install" != no; then
7758
8974
link_command="$finalize_var$compile_command$finalize_rpath"
7759
8975
if test "$fast_install" = yes; then
7760
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8976
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7761
8977
else
7762
8978
# fast_install is set to needless
7763
8979
relink_command=
7769
8985
fi
7770
8986
7771
8987
# Replace the output file specification.
7772
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8988
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7773
8989
7774
8990
# Delete the old output files.
7775
8991
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7776
8992
7777
8993
func_show_eval "$link_command" 'exit $?'
7778
8994
8995
if test -n "$postlink_cmds"; then
8996
func_to_tool_file "$output_objdir/$outputname"
8997
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'`
8998
func_execute_cmds "$postlink_cmds" 'exit $?'
8999
fi
9000
7779
9001
# Now create the wrapper script.
7780
9002
func_verbose "creating $output"
7781
9003
7793
9015
fi
7794
9016
done
7795
9017
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"`
9018
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
7808
9019
fi
7809
9020
7810
9021
# Only actually do things if not in dry run mode.
7884
9095
else
7885
9096
oldobjs="$old_deplibs $non_pic_objects"
7886
9097
if test "$preload" = yes && test -f "$symfileobj"; then
7887
oldobjs="$oldobjs $symfileobj"
9098
func_append oldobjs " $symfileobj"
7888
9099
fi
7889
9100
fi
7890
9101
addlibs="$old_convenience"
7892
9103
7893
9104
if test -n "$addlibs"; then
7894
9105
gentop="$output_objdir/${outputname}x"
7895
generated="$generated $gentop"
9106
func_append generated " $gentop"
7896
9107
7897
9108
func_extract_archives $gentop $addlibs
7898
oldobjs="$oldobjs $func_extract_archives_result"
9109
func_append oldobjs " $func_extract_archives_result"
7899
9110
fi
7900
9111
7901
9112
# Do each command in the archive commands.
7906
9117
# Add any objects from preloaded convenience libraries
7907
9118
if test -n "$dlprefiles"; then
7908
9119
gentop="$output_objdir/${outputname}x"
7909
generated="$generated $gentop"
9120
func_append generated " $gentop"
7910
9121
7911
9122
func_extract_archives $gentop $dlprefiles
7912
oldobjs="$oldobjs $func_extract_archives_result"
9123
func_append oldobjs " $func_extract_archives_result"
7913
9124
fi
7914
9125
7915
9126
# POSIX demands no paths to be encoded in archives. We have
7925
9136
done | sort | sort -uc >/dev/null 2>&1); then
7926
9137
:
7927
9138
else
7928
$ECHO "copying selected object files to avoid basename conflicts..."
9139
echo "copying selected object files to avoid basename conflicts..."
7929
9140
gentop="$output_objdir/${outputname}x"
7930
generated="$generated $gentop"
9141
func_append generated " $gentop"
7931
9142
func_mkdir_p "$gentop"
7932
9143
save_oldobjs=$oldobjs
7933
9144
oldobjs=
7951
9162
esac
7952
9163
done
7953
9164
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7954
oldobjs="$oldobjs $gentop/$newobj"
9165
func_append oldobjs " $gentop/$newobj"
7955
9166
;;
7956
*) oldobjs="$oldobjs $obj" ;;
9167
*) func_append oldobjs " $obj" ;;
7957
9168
esac
7958
9169
done
7959
9170
fi
9171
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9172
tool_oldlib=$func_to_tool_file_result
7960
9173
eval cmds=\"$old_archive_cmds\"
7961
9174
7962
9175
func_len " $cmds"
7963
9176
len=$func_len_result
7964
9177
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7965
9178
cmds=$old_archive_cmds
9179
elif test -n "$archiver_list_spec"; then
9180
func_verbose "using command file archive linking..."
9181
for obj in $oldobjs
9182
do
9183
func_to_tool_file "$obj"
9184
$ECHO "$func_to_tool_file_result"
9185
done > $output_objdir/$libname.libcmd
9186
func_to_tool_file "$output_objdir/$libname.libcmd"
9187
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9188
cmds=$old_archive_cmds
7966
9189
else
7967
9190
# the command line is too long to link in one step, link in parts
7968
9191
func_verbose "using piecewise archive linking..."
8036
9259
done
8037
9260
# Quote the link command for shipping.
8038
9261
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"`
9262
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8040
9263
if test "$hardcode_automatic" = yes ; then
8041
9264
relink_command=
8042
9265
fi
8056
9279
*.la)
8057
9280
func_basename "$deplib"
8058
9281
name="$func_basename_result"
8059
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9282
func_resolve_sysroot "$deplib"
9283
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
8060
9284
test -z "$libdir" && \
8061
9285
func_fatal_error "\`$deplib' is not a valid libtool archive"
8062
newdependency_libs="$newdependency_libs $libdir/$name"
8063
;;
8064
*) newdependency_libs="$newdependency_libs $deplib" ;;
9286
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9287
;;
9288
-L*)
9289
func_stripname -L '' "$deplib"
9290
func_replace_sysroot "$func_stripname_result"
9291
func_append newdependency_libs " -L$func_replace_sysroot_result"
9292
;;
9293
-R*)
9294
func_stripname -R '' "$deplib"
9295
func_replace_sysroot "$func_stripname_result"
9296
func_append newdependency_libs " -R$func_replace_sysroot_result"
9297
;;
9298
*) func_append newdependency_libs " $deplib" ;;
8065
9299
esac
8066
9300
done
8067
9301
dependency_libs="$newdependency_libs"
8075
9309
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8076
9310
test -z "$libdir" && \
8077
9311
func_fatal_error "\`$lib' is not a valid libtool archive"
8078
newdlfiles="$newdlfiles $libdir/$name"
9312
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
8079
9313
;;
8080
*) newdlfiles="$newdlfiles $lib" ;;
9314
*) func_append newdlfiles " $lib" ;;
8081
9315
esac
8082
9316
done
8083
9317
dlfiles="$newdlfiles"
8094
9328
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8095
9329
test -z "$libdir" && \
8096
9330
func_fatal_error "\`$lib' is not a valid libtool archive"
8097
newdlprefiles="$newdlprefiles $libdir/$name"
9331
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
8098
9332
;;
8099
9333
esac
8100
9334
done
8106
9340
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8107
9341
*) abs=`pwd`"/$lib" ;;
8108
9342
esac
8109
newdlfiles="$newdlfiles $abs"
9343
func_append newdlfiles " $abs"
8110
9344
done
8111
9345
dlfiles="$newdlfiles"
8112
9346
newdlprefiles=
8115
9349
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8116
9350
*) abs=`pwd`"/$lib" ;;
8117
9351
esac
8118
newdlprefiles="$newdlprefiles $abs"
9352
func_append newdlprefiles " $abs"
8119
9353
done
8120
9354
dlprefiles="$newdlprefiles"
8121
9355
fi
8122
9356
$RM $output
8123
9357
# place dlname in correct position for cygwin
9358
# In fact, it would be nice if we could use this code for all target
9359
# systems that can't hard-code library paths into their executables
9360
# and that have no shared library path variable independent of PATH,
9361
# but it turns out we can't easily determine that from inspecting
9362
# libtool variables, so we have to hard-code the OSs to which it
9363
# applies here; at the moment, that means platforms that use the PE
9364
# object format with DLL files. See the long comment at the top of
9365
# tests/bindir.at for full details.
8124
9366
tdlname=$dlname
8125
9367
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 ;;
9368
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9369
# If a -bindir argument was supplied, place the dll there.
9370
if test "x$bindir" != x ;
9371
then
9372
func_relative_path "$install_libdir" "$bindir"
9373
tdlname=$func_relative_path_result$dlname
9374
else
9375
# Otherwise fall back on heuristic.
9376
tdlname=../bin/$dlname
9377
fi
9378
;;
8127
9379
esac
8128
9380
$ECHO > $output "\
8129
9381
# $outputname - a libtool library file
8182
9434
exit $EXIT_SUCCESS
8183
9435
}
8184
9436
8185
{ test "$mode" = link || test "$mode" = relink; } &&
9437
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
8186
9438
func_mode_link ${1+"$@"}
8187
9439
8188
9440
8202
9454
for arg
8203
9455
do
8204
9456
case $arg in
8205
-f) RM="$RM $arg"; rmforce=yes ;;
8206
-*) RM="$RM $arg" ;;
8207
*) files="$files $arg" ;;
9457
-f) func_append RM " $arg"; rmforce=yes ;;
9458
-*) func_append RM " $arg" ;;
9459
*) func_append files " $arg" ;;
8208
9460
esac
8209
9461
done
8210
9462
8213
9465
8214
9466
rmdirs=
8215
9467
8216
origobjdir="$objdir"
8217
9468
for file in $files; do
8218
9469
func_dirname "$file" "" "."
8219
9470
dir="$func_dirname_result"
8220
9471
if test "X$dir" = X.; then
8221
objdir="$origobjdir"
9472
odir="$objdir"
8222
9473
else
8223
objdir="$dir/$origobjdir"
9474
odir="$dir/$objdir"
8224
9475
fi
8225
9476
func_basename "$file"
8226
9477
name="$func_basename_result"
8227
test "$mode" = uninstall && objdir="$dir"
9478
test "$opt_mode" = uninstall && odir="$dir"
8228
9479
8229
# Remember objdir for removal later, being careful to avoid duplicates
8230
if test "$mode" = clean; then
9480
# Remember odir for removal later, being careful to avoid duplicates
9481
if test "$opt_mode" = clean; then
8231
9482
case " $rmdirs " in
8232
*" $objdir "*) ;;
8233
*) rmdirs="$rmdirs $objdir" ;;
9483
*" $odir "*) ;;
9484
*) func_append rmdirs " $odir" ;;
8234
9485
esac
8235
9486
fi
8236
9487
8256
9507
8257
9508
# Delete the libtool libraries and symlinks.
8258
9509
for n in $library_names; do
8259
rmfiles="$rmfiles $objdir/$n"
9510
func_append rmfiles " $odir/$n"
8260
9511
done
8261
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
9512
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
8262
9513
8263
case "$mode" in
9514
case "$opt_mode" in
8264
9515
clean)
8265
case " $library_names " in
8266
# " " in the beginning catches empty $dlname
9516
case " $library_names " in
8267
9517
*" $dlname "*) ;;
8268
*) rmfiles="$rmfiles $objdir/$dlname" ;;
9518
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
8269
9519
esac
8270
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
9520
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
8271
9521
;;
8272
9522
uninstall)
8273
9523
if test -n "$library_names"; then
8295
9545
# Add PIC object to the list of files to remove.
8296
9546
if test -n "$pic_object" &&
8297
9547
test "$pic_object" != none; then
8298
rmfiles="$rmfiles $dir/$pic_object"
9548
func_append rmfiles " $dir/$pic_object"
8299
9549
fi
8300
9550
8301
9551
# Add non-PIC object to the list of files to remove.
8302
9552
if test -n "$non_pic_object" &&
8303
9553
test "$non_pic_object" != none; then
8304
rmfiles="$rmfiles $dir/$non_pic_object"
9554
func_append rmfiles " $dir/$non_pic_object"
8305
9555
fi
8306
9556
fi
8307
9557
;;
8308
9558
8309
9559
*)
8310
if test "$mode" = clean ; then
9560
if test "$opt_mode" = clean ; then
8311
9561
noexename=$name
8312
9562
case $file in
8313
9563
*.exe)
8317
9567
noexename=$func_stripname_result
8318
9568
# $file with .exe has already been added to rmfiles,
8319
9569
# add $file without .exe
8320
rmfiles="$rmfiles $file"
9570
func_append rmfiles " $file"
8321
9571
;;
8322
9572
esac
8323
9573
# Do a test to see if this is a libtool program.
8326
9576
func_ltwrapper_scriptname "$file"
8327
9577
relink_command=
8328
9578
func_source $func_ltwrapper_scriptname_result
8329
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
9579
func_append rmfiles " $func_ltwrapper_scriptname_result"
8330
9580
else
8331
9581
relink_command=
8332
9582
func_source $dir/$noexename
8334
9584
8335
9585
# note $name still contains .exe if it was in $file originally
8336
9586
# as does the version of $file that was added into $rmfiles
8337
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
9587
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
8338
9588
if test "$fast_install" = yes && test -n "$relink_command"; then
8339
rmfiles="$rmfiles $objdir/lt-$name"
9589
func_append rmfiles " $odir/lt-$name"
8340
9590
fi
8341
9591
if test "X$noexename" != "X$name" ; then
8342
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
9592
func_append rmfiles " $odir/lt-${noexename}.c"
8343
9593
fi
8344
9594
fi
8345
9595
fi
8347
9597
esac
8348
9598
func_show_eval "$RM $rmfiles" 'exit_status=1'
8349
9599
done
8350
objdir="$origobjdir"
8351
9600
8352
9601
# Try to remove the ${objdir}s in the directories where we deleted files
8353
9602
for dir in $rmdirs; do
8359
9608
exit $exit_status
8360
9609
}
8361
9610
8362
{ test "$mode" = uninstall || test "$mode" = clean; } &&
9611
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
8363
9612
func_mode_uninstall ${1+"$@"}
8364
9613
8365
test -z "$mode" && {
9614
test -z "$opt_mode" && {
8366
9615
help="$generic_help"
8367
9616
func_fatal_help "you must specify a MODE"
8368
9617
}
8369
9618
8370
9619
test -z "$exec_cmd" && \
8371
func_fatal_help "invalid operation mode \`$mode'"
9620
func_fatal_help "invalid operation mode \`$opt_mode'"
8372
9621
8373
9622
if test -n "$exec_cmd"; then
8374
9623
eval exec "$exec_cmd"
Loggerhead is a web-based interface for Breezy
Version: 2.0.1