« back to all changes in this revision
Viewing changes to build-aux/ltmain.sh
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Package Import Robot
- Author(s): Marco d'Itri
- Date: 2012-01-08 20:47:12 UTC
- Revision ID: package-import@ubuntu.com-20120108204712-alwv3y55vx2zyq7e
Tags: upstream-3
Import upstream version 3
- files added:
- build-aux
- libkmod
- m4
- test
- tools
added
removed
build-aux/ltmain.sh
1
2
# libtool (GNU libtool) 2.4.2
3
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6
# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7
# This is free software; see the source for copying conditions. There is NO
8
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9
10
# GNU Libtool is free software; you can redistribute it and/or modify
11
# it under the terms of the GNU General Public License as published by
12
# the Free Software Foundation; either version 2 of the License, or
13
# (at your option) any later version.
14
#
15
# As a special exception to the GNU General Public License,
16
# if you distribute this file as part of a program or library that
17
# is built using GNU Libtool, you may include this file under the
18
# same distribution terms that you use for the rest of that program.
19
#
20
# GNU Libtool is distributed in the hope that it will be useful, but
21
# WITHOUT ANY WARRANTY; without even the implied warranty of
22
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
# General Public License for more details.
24
#
25
# You should have received a copy of the GNU General Public License
26
# along with GNU Libtool; see the file COPYING. If not, a copy
27
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
28
# or obtained by writing to the Free Software Foundation, Inc.,
29
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30
31
# Usage: $progname [OPTION]... [MODE-ARG]...
32
#
33
# Provide generalized library-building support services.
34
#
35
# --config show all configuration variables
36
# --debug enable verbose shell tracing
37
# -n, --dry-run display commands without modifying any files
38
# --features display basic configuration information and exit
39
# --mode=MODE use operation mode MODE
40
# --preserve-dup-deps don't remove duplicate dependency libraries
41
# --quiet, --silent don't print informational messages
42
# --no-quiet, --no-silent
43
# print informational messages (default)
44
# --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
50
#
51
# MODE must be one of the following:
52
#
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
60
#
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.
63
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64
#
65
# When reporting a bug, please describe a test case to reproduce it and
66
# include the following information:
67
#
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
76
#
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/>.
80
81
PROGRAM=libtool
82
PACKAGE=libtool
83
VERSION=2.4.2
84
TIMESTAMP=""
85
package_revision=1.3337
86
87
# Be Bourne compatible
88
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
89
emulate sh
90
NULLCMD=:
91
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92
# is contrary to our usage. Disable this feature.
93
alias -g '${1+"$@"}'='"$@"'
94
setopt NO_GLOB_SUBST
95
else
96
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97
fi
98
BIN_SH=xpg4; export BIN_SH # for Tru64
99
DUALCASE=1; export DUALCASE # for MKS sh
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
109
# NLS nuisances: We save the old values to restore during execute mode.
110
lt_user_locale=
111
lt_safe_locale=
112
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113
do
114
eval "if test \"\${$lt_var+set}\" = set; then
115
save_$lt_var=\$$lt_var
116
$lt_var=C
117
export $lt_var
118
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
120
fi"
121
done
122
LC_ALL=C
123
LANGUAGE=C
124
export LANGUAGE LC_ALL
125
126
$lt_unset CDPATH
127
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"
135
136
137
138
: ${CP="cp -f"}
139
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
140
: ${MAKE="make"}
141
: ${MKDIR="mkdir"}
142
: ${MV="mv -f"}
143
: ${RM="rm -f"}
144
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145
: ${Xsed="$SED -e 1s/^X//"}
146
147
# Global variables:
148
EXIT_SUCCESS=0
149
EXIT_FAILURE=1
150
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
151
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
152
153
exit_status=$EXIT_SUCCESS
154
155
# Make sure IFS has a sensible default
156
lt_nl='
157
'
158
IFS=" $lt_nl"
159
160
dirname="s,/[^/]*$,,"
161
basename="s,^.*/,,"
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
184
# func_dirname_and_basename file append nondir_replacement
185
# perform func_basename and func_dirname in a single function
186
# call:
187
# dirname: Compute the dirname of FILE. If nonempty,
188
# add APPEND to the result, otherwise set result
189
# to NONDIR_REPLACEMENT.
190
# value returned in "$func_dirname_result"
191
# basename: Compute filename of FILE.
192
# value retuned in "$func_basename_result"
193
# Implementation must be kept synchronized with func_dirname
194
# and func_basename. For efficiency, we do not delegate to
195
# those functions but instead duplicate the functionality here.
196
func_dirname_and_basename ()
197
{
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
}
371
372
# The name of this program:
373
func_dirname_and_basename "$progpath"
374
progname=$func_basename_result
375
376
# Make sure we have an absolute path for reexecution:
377
case $progpath in
378
[\\/]*|[A-Za-z]:\\*) ;;
379
*[\\/]*)
380
progdir=$func_dirname_result
381
progdir=`cd "$progdir" && pwd`
382
progpath="$progdir/$progname"
383
;;
384
*)
385
save_IFS="$IFS"
386
IFS=${PATH_SEPARATOR-:}
387
for progdir in $PATH; do
388
IFS="$save_IFS"
389
test -x "$progdir/$progname" && break
390
done
391
IFS="$save_IFS"
392
test -n "$progdir" || progdir=`pwd`
393
progpath="$progdir/$progname"
394
;;
395
esac
396
397
# Sed substitution that helps us do robust quoting. It backslashifies
398
# metacharacters that are still active within double-quoted strings.
399
Xsed="${SED}"' -e 1s/^X//'
400
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
401
402
# Same as above, but do not quote variable references.
403
double_quote_subst='s/\(["`\\]\)/\\\1/g'
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
414
# Re-`\' parameter expansions in output of double_quote_subst that were
415
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
416
# in input to double_quote_subst, that '$' was protected from expansion.
417
# Since each input `\' is now two `\'s, look for any number of runs of
418
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
419
bs='\\'
420
bs2='\\\\'
421
bs4='\\\\\\\\'
422
dollar='\$'
423
sed_double_backslash="\
424
s/$bs4/&\\
425
/g
426
s/^$bs2$dollar/$bs&/
427
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
428
s/\n//g"
429
430
# Standard options:
431
opt_dry_run=false
432
opt_help=false
433
opt_quiet=false
434
opt_verbose=false
435
opt_warning=:
436
437
# func_echo arg...
438
# Echo program name prefixed message, along with the current mode
439
# name if it has been set yet.
440
func_echo ()
441
{
442
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
443
}
444
445
# func_verbose arg...
446
# Echo program name prefixed message in verbose mode only.
447
func_verbose ()
448
{
449
$opt_verbose && func_echo ${1+"$@"}
450
451
# A bug in bash halts the script if the last line of a function
452
# fails when set -e is in force, so we need another command to
453
# work around that:
454
:
455
}
456
457
# func_echo_all arg...
458
# Invoke $ECHO with all args, space-separated.
459
func_echo_all ()
460
{
461
$ECHO "$*"
462
}
463
464
# func_error arg...
465
# Echo program name prefixed message to standard error.
466
func_error ()
467
{
468
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
469
}
470
471
# func_warning arg...
472
# Echo program name prefixed warning message to standard error.
473
func_warning ()
474
{
475
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
476
477
# bash bug again:
478
:
479
}
480
481
# func_fatal_error arg...
482
# Echo program name prefixed message to standard error, and exit.
483
func_fatal_error ()
484
{
485
func_error ${1+"$@"}
486
exit $EXIT_FAILURE
487
}
488
489
# func_fatal_help arg...
490
# Echo program name prefixed message to standard error, followed by
491
# a help hint, and exit.
492
func_fatal_help ()
493
{
494
func_error ${1+"$@"}
495
func_fatal_error "$help"
496
}
497
help="Try \`$progname --help' for more information." ## default
498
499
500
# func_grep expression filename
501
# Check whether EXPRESSION matches any line of FILENAME, without output.
502
func_grep ()
503
{
504
$GREP "$1" "$2" >/dev/null 2>&1
505
}
506
507
508
# func_mkdir_p directory-path
509
# Make sure the entire path to DIRECTORY-PATH is available.
510
func_mkdir_p ()
511
{
512
my_directory_path="$1"
513
my_dir_list=
514
515
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
516
517
# Protect directory names starting with `-'
518
case $my_directory_path in
519
-*) my_directory_path="./$my_directory_path" ;;
520
esac
521
522
# While some portion of DIR does not yet exist...
523
while test ! -d "$my_directory_path"; do
524
# ...make a list in topmost first order. Use a colon delimited
525
# list incase some portion of path contains whitespace.
526
my_dir_list="$my_directory_path:$my_dir_list"
527
528
# If the last portion added has no slash in it, the list is done
529
case $my_directory_path in */*) ;; *) break ;; esac
530
531
# ...otherwise throw away the child directory and loop
532
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
533
done
534
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
535
536
save_mkdir_p_IFS="$IFS"; IFS=':'
537
for my_dir in $my_dir_list; do
538
IFS="$save_mkdir_p_IFS"
539
# mkdir can fail with a `File exist' error if two processes
540
# try to create one of the directories concurrently. Don't
541
# stop in that case!
542
$MKDIR "$my_dir" 2>/dev/null || :
543
done
544
IFS="$save_mkdir_p_IFS"
545
546
# Bail out if we (or some other process) failed to create a directory.
547
test -d "$my_directory_path" || \
548
func_fatal_error "Failed to create \`$1'"
549
fi
550
}
551
552
553
# func_mktempdir [string]
554
# Make a temporary directory that won't clash with other running
555
# libtool processes, and avoids race conditions if possible. If
556
# given, STRING is the basename for that directory.
557
func_mktempdir ()
558
{
559
my_template="${TMPDIR-/tmp}/${1-$progname}"
560
561
if test "$opt_dry_run" = ":"; then
562
# Return a directory name, but don't create it in dry-run mode
563
my_tmpdir="${my_template}-$$"
564
else
565
566
# If mktemp works, use that first and foremost
567
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
568
569
if test ! -d "$my_tmpdir"; then
570
# Failing that, at least try and use $RANDOM to avoid a race
571
my_tmpdir="${my_template}-${RANDOM-0}$$"
572
573
save_mktempdir_umask=`umask`
574
umask 0077
575
$MKDIR "$my_tmpdir"
576
umask $save_mktempdir_umask
577
fi
578
579
# If we're not in dry-run mode, bomb out on failure
580
test -d "$my_tmpdir" || \
581
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
582
fi
583
584
$ECHO "$my_tmpdir"
585
}
586
587
588
# func_quote_for_eval arg
589
# Aesthetically quote ARG to be evaled later.
590
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591
# is double-quoted, suitable for a subsequent eval, whereas
592
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593
# which are still active within double quotes backslashified.
594
func_quote_for_eval ()
595
{
596
case $1 in
597
*[\\\`\"\$]*)
598
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
599
*)
600
func_quote_for_eval_unquoted_result="$1" ;;
601
esac
602
603
case $func_quote_for_eval_unquoted_result in
604
# Double-quote args containing shell metacharacters to delay
605
# word splitting, command substitution and and variable
606
# expansion for a subsequent eval.
607
# Many Bourne shells cannot handle close brackets correctly
608
# in scan sets, so we specify it separately.
609
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
610
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
611
;;
612
*)
613
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
614
esac
615
}
616
617
618
# func_quote_for_expand arg
619
# Aesthetically quote ARG to be evaled later; same as above,
620
# but do not quote variable references.
621
func_quote_for_expand ()
622
{
623
case $1 in
624
*[\\\`\"]*)
625
my_arg=`$ECHO "$1" | $SED \
626
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
627
*)
628
my_arg="$1" ;;
629
esac
630
631
case $my_arg in
632
# Double-quote args containing shell metacharacters to delay
633
# word splitting and command substitution for a subsequent eval.
634
# Many Bourne shells cannot handle close brackets correctly
635
# in scan sets, so we specify it separately.
636
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
637
my_arg="\"$my_arg\""
638
;;
639
esac
640
641
func_quote_for_expand_result="$my_arg"
642
}
643
644
645
# func_show_eval cmd [fail_exp]
646
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
647
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
648
# is given, then evaluate it.
649
func_show_eval ()
650
{
651
my_cmd="$1"
652
my_fail_exp="${2-:}"
653
654
${opt_silent-false} || {
655
func_quote_for_expand "$my_cmd"
656
eval "func_echo $func_quote_for_expand_result"
657
}
658
659
if ${opt_dry_run-false}; then :; else
660
eval "$my_cmd"
661
my_status=$?
662
if test "$my_status" -eq 0; then :; else
663
eval "(exit $my_status); $my_fail_exp"
664
fi
665
fi
666
}
667
668
669
# func_show_eval_locale cmd [fail_exp]
670
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
671
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
672
# is given, then evaluate it. Use the saved locale for evaluation.
673
func_show_eval_locale ()
674
{
675
my_cmd="$1"
676
my_fail_exp="${2-:}"
677
678
${opt_silent-false} || {
679
func_quote_for_expand "$my_cmd"
680
eval "func_echo $func_quote_for_expand_result"
681
}
682
683
if ${opt_dry_run-false}; then :; else
684
eval "$lt_user_locale
685
$my_cmd"
686
my_status=$?
687
eval "$lt_safe_locale"
688
if test "$my_status" -eq 0; then :; else
689
eval "(exit $my_status); $my_fail_exp"
690
fi
691
fi
692
}
693
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
}
710
711
712
# func_version
713
# Echo version message to standard output and exit.
714
func_version ()
715
{
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; / {
727
s/^# //
728
s/^# *$//
729
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
730
p
731
}' < "$progpath"
732
exit $?
733
}
734
735
# func_usage
736
# Echo short help message to standard output and exit.
737
func_usage ()
738
{
739
$opt_debug
740
741
$SED -n '/^# Usage:/,/^# *.*--help/ {
742
s/^# //
743
s/^# *$//
744
s/\$progname/'$progname'/
745
p
746
}' < "$progpath"
747
echo
748
$ECHO "run \`$progname --help | more' for full usage"
749
exit $?
750
}
751
752
# func_help [NOEXIT]
753
# Echo long help message to standard output and exit,
754
# unless 'noexit' is passed as argument.
755
func_help ()
756
{
757
$opt_debug
758
759
$SED -n '/^# Usage:/,/# Report bugs to/ {
760
:print
761
s/^# //
762
s/^# *$//
763
s*\$progname*'$progname'*
764
s*\$host*'"$host"'*
765
s*\$SHELL*'"$SHELL"'*
766
s*\$LTCC*'"$LTCC"'*
767
s*\$LTCFLAGS*'"$LTCFLAGS"'*
768
s*\$LD*'"$LD"'*
769
s/\$with_gnu_ld/'"$with_gnu_ld"'/
770
s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771
s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
772
p
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
782
}
783
784
# func_missing_arg argname
785
# Echo program name prefixed message to standard error and set global
786
# exit_cmd.
787
func_missing_arg ()
788
{
789
$opt_debug
790
791
func_error "missing argument for $1."
792
exit_cmd=exit
793
}
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
821
exit_cmd=:
822
823
824
825
826
827
magic="%%%MAGIC variable%%%"
828
magic_exe="%%%MAGIC EXE variable%%%"
829
830
# Global variables.
831
nonopt=
832
preserve_args=
833
lo2o="s/\\.lo\$/.${objext}/"
834
o2lo="s/\\.${objext}\$/.lo/"
835
extracted_archives=
836
extracted_serial=0
837
838
# If this variable is set in any of the actions, the command in it
839
# will be execed at the end. This prevents here-documents from being
840
# left over by shells.
841
exec_cmd=
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
889
# func_fatal_configuration arg...
890
# Echo program name prefixed message to standard error, followed by
891
# a configuration failure hint, and exit.
892
func_fatal_configuration ()
893
{
894
func_error ${1+"$@"}
895
func_error "See the $PACKAGE documentation for more information."
896
func_fatal_error "Fatal configuration error."
897
}
898
899
900
# func_config
901
# Display the configuration for all the tags in this script.
902
func_config ()
903
{
904
re_begincf='^# ### BEGIN LIBTOOL'
905
re_endcf='^# ### END LIBTOOL'
906
907
# Default configuration.
908
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
909
910
# Now print the configurations for the tags.
911
for tagname in $taglist; do
912
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
913
done
914
915
exit $?
916
}
917
918
# func_features
919
# Display the features supported by this script.
920
func_features ()
921
{
922
echo "host: $host"
923
if test "$build_libtool_libs" = yes; then
924
echo "enable shared libraries"
925
else
926
echo "disable shared libraries"
927
fi
928
if test "$build_old_libs" = yes; then
929
echo "enable static libraries"
930
else
931
echo "disable static libraries"
932
fi
933
934
exit $?
935
}
936
937
# func_enable_tag tagname
938
# Verify that TAGNAME is valid, and either flag an error and exit, or
939
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
940
# variable here.
941
func_enable_tag ()
942
{
943
# Global variable:
944
tagname="$1"
945
946
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948
sed_extractcf="/$re_begincf/,/$re_endcf/p"
949
950
# Validate tagname.
951
case $tagname in
952
*[!-_A-Za-z0-9,/]*)
953
func_fatal_error "invalid tag name: $tagname"
954
;;
955
esac
956
957
# Don't test for the "default" C tag, as we know it's
958
# there but not specially marked.
959
case $tagname in
960
CC) ;;
961
*)
962
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
963
taglist="$taglist $tagname"
964
965
# Evaluate the configuration. Be careful to quote the path
966
# and the sed script, to avoid splitting on whitespace, but
967
# also don't use non-portable quotes within backquotes within
968
# quotes we have to do it in 2 steps:
969
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
970
eval "$extractedcf"
971
else
972
func_error "ignoring unknown tag $tagname"
973
fi
974
;;
975
esac
976
}
977
978
# func_check_version_match
979
# Ensure that we are using m4 macros, and libtool script from the same
980
# release of libtool.
981
func_check_version_match ()
982
{
983
if test "$package_revision" != "$macro_revision"; then
984
if test "$VERSION" != "$macro_version"; then
985
if test -z "$macro_version"; then
986
cat >&2 <<_LT_EOF
987
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
988
$progname: definition of this LT_INIT comes from an older release.
989
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990
$progname: and run autoconf again.
991
_LT_EOF
992
else
993
cat >&2 <<_LT_EOF
994
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
995
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997
$progname: and run autoconf again.
998
_LT_EOF
999
fi
1000
else
1001
cat >&2 <<_LT_EOF
1002
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1003
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005
$progname: of $PACKAGE $VERSION and run autoconf again.
1006
_LT_EOF
1007
fi
1008
1009
exit $EXIT_MISMATCH
1010
fi
1011
}
1012
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
1223
## ----------- ##
1224
## Main. ##
1225
## ----------- ##
1226
1227
# func_lalib_p file
1228
# True iff FILE is a libtool `.la' library or `.lo' object file.
1229
# This function is only a basic sanity check; it will hardly flush out
1230
# determined imposters.
1231
func_lalib_p ()
1232
{
1233
test -f "$1" &&
1234
$SED -e 4q "$1" 2>/dev/null \
1235
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1236
}
1237
1238
# func_lalib_unsafe_p file
1239
# True iff FILE is a libtool `.la' library or `.lo' object file.
1240
# This function implements the same check as func_lalib_p without
1241
# resorting to external programs. To this end, it redirects stdin and
1242
# closes it afterwards, without saving the original file descriptor.
1243
# As a safety measure, use it only where a negative result would be
1244
# fatal anyway. Works if `file' does not exist.
1245
func_lalib_unsafe_p ()
1246
{
1247
lalib_p=no
1248
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249
for lalib_p_l in 1 2 3 4
1250
do
1251
read lalib_p_line
1252
case "$lalib_p_line" in
1253
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1254
esac
1255
done
1256
exec 0<&5 5<&-
1257
fi
1258
test "$lalib_p" = yes
1259
}
1260
1261
# func_ltwrapper_script_p file
1262
# True iff FILE is a libtool wrapper script
1263
# This function is only a basic sanity check; it will hardly flush out
1264
# determined imposters.
1265
func_ltwrapper_script_p ()
1266
{
1267
func_lalib_p "$1"
1268
}
1269
1270
# func_ltwrapper_executable_p file
1271
# True iff FILE is a libtool wrapper executable
1272
# This function is only a basic sanity check; it will hardly flush out
1273
# determined imposters.
1274
func_ltwrapper_executable_p ()
1275
{
1276
func_ltwrapper_exec_suffix=
1277
case $1 in
1278
*.exe) ;;
1279
*) func_ltwrapper_exec_suffix=.exe ;;
1280
esac
1281
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1282
}
1283
1284
# func_ltwrapper_scriptname file
1285
# Assumes file is an ltwrapper_executable
1286
# uses $file to determine the appropriate filename for a
1287
# temporary ltwrapper_script.
1288
func_ltwrapper_scriptname ()
1289
{
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"
1293
}
1294
1295
# func_ltwrapper_p file
1296
# True iff FILE is a libtool wrapper script or wrapper executable
1297
# This function is only a basic sanity check; it will hardly flush out
1298
# determined imposters.
1299
func_ltwrapper_p ()
1300
{
1301
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1302
}
1303
1304
1305
# func_execute_cmds commands fail_cmd
1306
# Execute tilde-delimited COMMANDS.
1307
# If FAIL_CMD is given, eval that upon failure.
1308
# FAIL_CMD may read-access the current command in variable CMD!
1309
func_execute_cmds ()
1310
{
1311
$opt_debug
1312
save_ifs=$IFS; IFS='~'
1313
for cmd in $1; do
1314
IFS=$save_ifs
1315
eval cmd=\"$cmd\"
1316
func_show_eval "$cmd" "${2-:}"
1317
done
1318
IFS=$save_ifs
1319
}
1320
1321
1322
# func_source file
1323
# Source FILE, adding directory component if necessary.
1324
# Note that it is not necessary on cygwin/mingw to append a dot to
1325
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326
# behavior happens only for exec(3), not for open(2)! Also, sourcing
1327
# `FILE.' does not work on cygwin managed mounts.
1328
func_source ()
1329
{
1330
$opt_debug
1331
case $1 in
1332
*/* | *\\*) . "$1" ;;
1333
*) . "./$1" ;;
1334
esac
1335
}
1336
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
1369
# func_infer_tag arg
1370
# Infer tagged configuration to use if any are available and
1371
# if one wasn't chosen via the "--tag" command line option.
1372
# Only attempt this if the compiler in the base compile
1373
# command doesn't match the default compiler.
1374
# arg is usually of the form 'gcc ...'
1375
func_infer_tag ()
1376
{
1377
$opt_debug
1378
if test -n "$available_tags" && test -z "$tagname"; then
1379
CC_quoted=
1380
for arg in $CC; do
1381
func_append_quoted CC_quoted "$arg"
1382
done
1383
CC_expanded=`func_echo_all $CC`
1384
CC_quoted_expanded=`func_echo_all $CC_quoted`
1385
case $@ in
1386
# Blanks in the command may have been stripped by the calling shell,
1387
# but not from the CC environment variable when configure was run.
1388
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1390
# Blanks at the start of $base_compile will cause this to fail
1391
# if we don't check for them as well.
1392
*)
1393
for z in $available_tags; do
1394
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1395
# Evaluate the configuration.
1396
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1397
CC_quoted=
1398
for arg in $CC; do
1399
# Double-quote args containing other shell metacharacters.
1400
func_append_quoted CC_quoted "$arg"
1401
done
1402
CC_expanded=`func_echo_all $CC`
1403
CC_quoted_expanded=`func_echo_all $CC_quoted`
1404
case "$@ " in
1405
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1407
# The compiler in the base compile command matches
1408
# the one in the tagged configuration.
1409
# Assume this is the tagged configuration we want.
1410
tagname=$z
1411
break
1412
;;
1413
esac
1414
fi
1415
done
1416
# If $tagname still isn't set, then no tagged configuration
1417
# was found and let the user know that the "--tag" command
1418
# line option must be used.
1419
if test -z "$tagname"; then
1420
func_echo "unable to infer tagged configuration"
1421
func_fatal_error "specify a tag with \`--tag'"
1422
# else
1423
# func_verbose "using $tagname tagged configuration"
1424
fi
1425
;;
1426
esac
1427
fi
1428
}
1429
1430
1431
1432
# func_write_libtool_object output_name pic_name nonpic_name
1433
# Create a libtool object file (analogous to a ".la" file),
1434
# but don't create it if we're doing a dry run.
1435
func_write_libtool_object ()
1436
{
1437
write_libobj=${1}
1438
if test "$build_libtool_libs" = yes; then
1439
write_lobj=\'${2}\'
1440
else
1441
write_lobj=none
1442
fi
1443
1444
if test "$build_old_libs" = yes; then
1445
write_oldobj=\'${3}\'
1446
else
1447
write_oldobj=none
1448
fi
1449
1450
$opt_dry_run || {
1451
cat >${write_libobj}T <<EOF
1452
# $write_libobj - a libtool object file
1453
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454
#
1455
# Please DO NOT delete this file!
1456
# It is necessary for linking the library.
1457
1458
# Name of the PIC object.
1459
pic_object=$write_lobj
1460
1461
# Name of the non-PIC object
1462
non_pic_object=$write_oldobj
1463
1464
EOF
1465
$MV "${write_libobj}T" "${write_libobj}"
1466
}
1467
}
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
1949
# func_mode_compile arg...
1950
func_mode_compile ()
1951
{
1952
$opt_debug
1953
# Get the compilation command and the source file.
1954
base_compile=
1955
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1956
suppress_opt=yes
1957
suppress_output=
1958
arg_mode=normal
1959
libobj=
1960
later=
1961
pie_flag=
1962
1963
for arg
1964
do
1965
case $arg_mode in
1966
arg )
1967
# do not "continue". Instead, add this to base_compile
1968
lastarg="$arg"
1969
arg_mode=normal
1970
;;
1971
1972
target )
1973
libobj="$arg"
1974
arg_mode=normal
1975
continue
1976
;;
1977
1978
normal )
1979
# Accept any command-line options.
1980
case $arg in
1981
-o)
1982
test -n "$libobj" && \
1983
func_fatal_error "you cannot specify \`-o' more than once"
1984
arg_mode=target
1985
continue
1986
;;
1987
1988
-pie | -fpie | -fPIE)
1989
func_append pie_flag " $arg"
1990
continue
1991
;;
1992
1993
-shared | -static | -prefer-pic | -prefer-non-pic)
1994
func_append later " $arg"
1995
continue
1996
;;
1997
1998
-no-suppress)
1999
suppress_opt=no
2000
continue
2001
;;
2002
2003
-Xcompiler)
2004
arg_mode=arg # the next one goes into the "base_compile" arg list
2005
continue # The current "srcfile" will either be retained or
2006
;; # replaced later. I would guess that would be a bug.
2007
2008
-Wc,*)
2009
func_stripname '-Wc,' '' "$arg"
2010
args=$func_stripname_result
2011
lastarg=
2012
save_ifs="$IFS"; IFS=','
2013
for arg in $args; do
2014
IFS="$save_ifs"
2015
func_append_quoted lastarg "$arg"
2016
done
2017
IFS="$save_ifs"
2018
func_stripname ' ' '' "$lastarg"
2019
lastarg=$func_stripname_result
2020
2021
# Add the arguments to base_compile.
2022
func_append base_compile " $lastarg"
2023
continue
2024
;;
2025
2026
*)
2027
# Accept the current argument as the source file.
2028
# The previous "srcfile" becomes the current argument.
2029
#
2030
lastarg="$srcfile"
2031
srcfile="$arg"
2032
;;
2033
esac # case $arg
2034
;;
2035
esac # case $arg_mode
2036
2037
# Aesthetically quote the previous argument.
2038
func_append_quoted base_compile "$lastarg"
2039
done # for arg
2040
2041
case $arg_mode in
2042
arg)
2043
func_fatal_error "you must specify an argument for -Xcompile"
2044
;;
2045
target)
2046
func_fatal_error "you must specify a target with \`-o'"
2047
;;
2048
*)
2049
# Get the name of the library object.
2050
test -z "$libobj" && {
2051
func_basename "$srcfile"
2052
libobj="$func_basename_result"
2053
}
2054
;;
2055
esac
2056
2057
# Recognize several different file suffixes.
2058
# If the user specifies -o file.o, it is replaced with file.lo
2059
case $libobj in
2060
*.[cCFSifmso] | \
2061
*.ada | *.adb | *.ads | *.asm | \
2062
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2063
*.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
2064
func_xform "$libobj"
2065
libobj=$func_xform_result
2066
;;
2067
esac
2068
2069
case $libobj in
2070
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071
*)
2072
func_fatal_error "cannot determine name of library object from \`$libobj'"
2073
;;
2074
esac
2075
2076
func_infer_tag $base_compile
2077
2078
for arg in $later; do
2079
case $arg in
2080
-shared)
2081
test "$build_libtool_libs" != yes && \
2082
func_fatal_configuration "can not build a shared library"
2083
build_old_libs=no
2084
continue
2085
;;
2086
2087
-static)
2088
build_libtool_libs=no
2089
build_old_libs=yes
2090
continue
2091
;;
2092
2093
-prefer-pic)
2094
pic_mode=yes
2095
continue
2096
;;
2097
2098
-prefer-non-pic)
2099
pic_mode=no
2100
continue
2101
;;
2102
esac
2103
done
2104
2105
func_quote_for_eval "$libobj"
2106
test "X$libobj" != "X$func_quote_for_eval_result" \
2107
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2108
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
2109
func_dirname_and_basename "$obj" "/" ""
2110
objname="$func_basename_result"
2111
xdir="$func_dirname_result"
2112
lobj=${xdir}$objdir/$objname
2113
2114
test -z "$base_compile" && \
2115
func_fatal_help "you must specify a compilation command"
2116
2117
# Delete any leftover library objects.
2118
if test "$build_old_libs" = yes; then
2119
removelist="$obj $lobj $libobj ${libobj}T"
2120
else
2121
removelist="$lobj $libobj ${libobj}T"
2122
fi
2123
2124
# On Cygwin there's no "real" PIC flag so we must build both object types
2125
case $host_os in
2126
cygwin* | mingw* | pw32* | os2* | cegcc*)
2127
pic_mode=default
2128
;;
2129
esac
2130
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2131
# non-PIC code in shared libraries is not supported
2132
pic_mode=default
2133
fi
2134
2135
# Calculate the filename of the output object if compiler does
2136
# not support -o with -c
2137
if test "$compiler_c_o" = no; then
2138
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2139
lockfile="$output_obj.lock"
2140
else
2141
output_obj=
2142
need_locks=no
2143
lockfile=
2144
fi
2145
2146
# Lock this critical section if it is needed
2147
# We use this script file to make the link, it avoids creating a new file
2148
if test "$need_locks" = yes; then
2149
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2150
func_echo "Waiting for $lockfile to be removed"
2151
sleep 2
2152
done
2153
elif test "$need_locks" = warn; then
2154
if test -f "$lockfile"; then
2155
$ECHO "\
2156
*** ERROR, $lockfile exists and contains:
2157
`cat $lockfile 2>/dev/null`
2158
2159
This indicates that another process is trying to use the same
2160
temporary object file, and libtool could not work around it because
2161
your compiler does not support \`-c' and \`-o' together. If you
2162
repeat this compilation, it may succeed, by chance, but you had better
2163
avoid parallel builds (make -j) in this platform, or get a better
2164
compiler."
2165
2166
$opt_dry_run || $RM $removelist
2167
exit $EXIT_FAILURE
2168
fi
2169
func_append removelist " $output_obj"
2170
$ECHO "$srcfile" > "$lockfile"
2171
fi
2172
2173
$opt_dry_run || $RM $removelist
2174
func_append removelist " $lockfile"
2175
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176
2177
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178
srcfile=$func_to_tool_file_result
2179
func_quote_for_eval "$srcfile"
2180
qsrcfile=$func_quote_for_eval_result
2181
2182
# Only build a PIC object if we are building libtool libraries.
2183
if test "$build_libtool_libs" = yes; then
2184
# Without this assignment, base_compile gets emptied.
2185
fbsd_hideous_sh_bug=$base_compile
2186
2187
if test "$pic_mode" != no; then
2188
command="$base_compile $qsrcfile $pic_flag"
2189
else
2190
# Don't build PIC code
2191
command="$base_compile $qsrcfile"
2192
fi
2193
2194
func_mkdir_p "$xdir$objdir"
2195
2196
if test -z "$output_obj"; then
2197
# Place PIC objects in $objdir
2198
func_append command " -o $lobj"
2199
fi
2200
2201
func_show_eval_locale "$command" \
2202
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203
2204
if test "$need_locks" = warn &&
2205
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206
$ECHO "\
2207
*** ERROR, $lockfile contains:
2208
`cat $lockfile 2>/dev/null`
2209
2210
but it should contain:
2211
$srcfile
2212
2213
This indicates that another process is trying to use the same
2214
temporary object file, and libtool could not work around it because
2215
your compiler does not support \`-c' and \`-o' together. If you
2216
repeat this compilation, it may succeed, by chance, but you had better
2217
avoid parallel builds (make -j) in this platform, or get a better
2218
compiler."
2219
2220
$opt_dry_run || $RM $removelist
2221
exit $EXIT_FAILURE
2222
fi
2223
2224
# Just move the object if needed, then go on to compile the next one
2225
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226
func_show_eval '$MV "$output_obj" "$lobj"' \
2227
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2228
fi
2229
2230
# Allow error messages only from the first compilation.
2231
if test "$suppress_opt" = yes; then
2232
suppress_output=' >/dev/null 2>&1'
2233
fi
2234
fi
2235
2236
# Only build a position-dependent object if we build old libraries.
2237
if test "$build_old_libs" = yes; then
2238
if test "$pic_mode" != yes; then
2239
# Don't build PIC code
2240
command="$base_compile $qsrcfile$pie_flag"
2241
else
2242
command="$base_compile $qsrcfile $pic_flag"
2243
fi
2244
if test "$compiler_c_o" = yes; then
2245
func_append command " -o $obj"
2246
fi
2247
2248
# Suppress compiler output if we already did a PIC compilation.
2249
func_append command "$suppress_output"
2250
func_show_eval_locale "$command" \
2251
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252
2253
if test "$need_locks" = warn &&
2254
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255
$ECHO "\
2256
*** ERROR, $lockfile contains:
2257
`cat $lockfile 2>/dev/null`
2258
2259
but it should contain:
2260
$srcfile
2261
2262
This indicates that another process is trying to use the same
2263
temporary object file, and libtool could not work around it because
2264
your compiler does not support \`-c' and \`-o' together. If you
2265
repeat this compilation, it may succeed, by chance, but you had better
2266
avoid parallel builds (make -j) in this platform, or get a better
2267
compiler."
2268
2269
$opt_dry_run || $RM $removelist
2270
exit $EXIT_FAILURE
2271
fi
2272
2273
# Just move the object if needed
2274
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275
func_show_eval '$MV "$output_obj" "$obj"' \
2276
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2277
fi
2278
fi
2279
2280
$opt_dry_run || {
2281
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282
2283
# Unlock the critical section if it was locked
2284
if test "$need_locks" != no; then
2285
removelist=$lockfile
2286
$RM "$lockfile"
2287
fi
2288
}
2289
2290
exit $EXIT_SUCCESS
2291
}
2292
2293
$opt_help || {
2294
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2295
}
2296
2297
func_mode_help ()
2298
{
2299
# We need to display help for each of the modes.
2300
case $opt_mode in
2301
"")
2302
# Generic help is extracted from the usage comments
2303
# at the start of this file.
2304
func_help
2305
;;
2306
2307
clean)
2308
$ECHO \
2309
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310
2311
Remove files from the build directory.
2312
2313
RM is the name of the program to use to delete files associated with each FILE
2314
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2315
to RM.
2316
2317
If FILE is a libtool library, object or program, all the files associated
2318
with it are deleted. Otherwise, only FILE itself is deleted using RM."
2319
;;
2320
2321
compile)
2322
$ECHO \
2323
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324
2325
Compile a source file into a libtool library object.
2326
2327
This mode accepts the following additional options:
2328
2329
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
2330
-no-suppress do not suppress compiler output for multiple passes
2331
-prefer-pic try to build PIC objects only
2332
-prefer-non-pic try to build non-PIC objects only
2333
-shared do not build a \`.o' file suitable for static linking
2334
-static only build a \`.o' file suitable for static linking
2335
-Wc,FLAG pass FLAG directly to the compiler
2336
2337
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338
from the given SOURCEFILE.
2339
2340
The output file name is determined by removing the directory component from
2341
SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342
library object suffix, \`.lo'."
2343
;;
2344
2345
execute)
2346
$ECHO \
2347
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348
2349
Automatically set library path, then run a program.
2350
2351
This mode accepts the following additional options:
2352
2353
-dlopen FILE add the directory containing FILE to the library path
2354
2355
This mode sets the library path environment variable according to \`-dlopen'
2356
flags.
2357
2358
If any of the ARGS are libtool executable wrappers, then they are translated
2359
into their corresponding uninstalled binary, and any of their required library
2360
directories are added to the library path.
2361
2362
Then, COMMAND is executed, with ARGS as arguments."
2363
;;
2364
2365
finish)
2366
$ECHO \
2367
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368
2369
Complete the installation of libtool libraries.
2370
2371
Each LIBDIR is a directory that contains libtool libraries.
2372
2373
The commands that this mode executes may require superuser privileges. Use
2374
the \`--dry-run' option if you just want to see what would be executed."
2375
;;
2376
2377
install)
2378
$ECHO \
2379
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380
2381
Install executables or libraries.
2382
2383
INSTALL-COMMAND is the installation command. The first component should be
2384
either the \`install' or \`cp' program.
2385
2386
The following components of INSTALL-COMMAND are treated specially:
2387
2388
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2389
2390
The rest of the components are interpreted as arguments to that command (only
2391
BSD-compatible install options are recognized)."
2392
;;
2393
2394
link)
2395
$ECHO \
2396
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397
2398
Link object files or libraries together to form another library, or to
2399
create an executable program.
2400
2401
LINK-COMMAND is a command using the C compiler that you would use to create
2402
a program from several object files.
2403
2404
The following components of LINK-COMMAND are treated specially:
2405
2406
-all-static do not do any dynamic linking at all
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)
2410
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2412
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413
-export-symbols SYMFILE
2414
try to export only the symbols listed in SYMFILE
2415
-export-symbols-regex REGEX
2416
try to export only the symbols matching REGEX
2417
-LLIBDIR search LIBDIR for required installed libraries
2418
-lNAME OUTPUT-FILE requires the installed library libNAME
2419
-module build a library that can dlopened
2420
-no-fast-install disable the fast-install mode
2421
-no-install link a not-installable executable
2422
-no-undefined declare that a library does not refer to external symbols
2423
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2424
-objectlist FILE Use a list of object files found in FILE to specify objects
2425
-precious-files-regex REGEX
2426
don't remove output files matching REGEX
2427
-release RELEASE specify package release information
2428
-rpath LIBDIR the created library will eventually be installed in LIBDIR
2429
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2430
-shared only do dynamic linking of libtool libraries
2431
-shrext SUFFIX override the standard shared library file extension
2432
-static do not do any dynamic linking of uninstalled libtool libraries
2433
-static-libtool-libs
2434
do not do any dynamic linking of libtool libraries
2435
-version-info CURRENT[:REVISION[:AGE]]
2436
specify library version info [each variable defaults to 0]
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)
2443
2444
All other options (arguments beginning with \`-') are ignored.
2445
2446
Every other argument is treated as a filename. Files ending in \`.la' are
2447
treated as uninstalled libtool libraries, other files are standard or library
2448
object files.
2449
2450
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451
only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452
required, except when creating a convenience library.
2453
2454
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455
using \`ar' and \`ranlib', or on Windows using \`lib'.
2456
2457
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458
is created, otherwise an executable program is created."
2459
;;
2460
2461
uninstall)
2462
$ECHO \
2463
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464
2465
Remove libraries from an installation directory.
2466
2467
RM is the name of the program to use to delete files associated with each FILE
2468
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2469
to RM.
2470
2471
If FILE is a libtool library, all the files associated with it are deleted.
2472
Otherwise, only FILE itself is deleted using RM."
2473
;;
2474
2475
*)
2476
func_fatal_help "invalid operation mode \`$opt_mode'"
2477
;;
2478
esac
2479
2480
echo
2481
$ECHO "Try \`$progname --help' for more information about other modes."
2482
}
2483
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
2514
2515
2516
# func_mode_execute arg...
2517
func_mode_execute ()
2518
{
2519
$opt_debug
2520
# The first argument is the command name.
2521
cmd="$nonopt"
2522
test -z "$cmd" && \
2523
func_fatal_help "you must specify a COMMAND"
2524
2525
# Handle -dlopen flags immediately.
2526
for file in $opt_dlopen; do
2527
test -f "$file" \
2528
|| func_fatal_help "\`$file' is not a file"
2529
2530
dir=
2531
case $file in
2532
*.la)
2533
func_resolve_sysroot "$file"
2534
file=$func_resolve_sysroot_result
2535
2536
# Check to see that this really is a libtool archive.
2537
func_lalib_unsafe_p "$file" \
2538
|| func_fatal_help "\`$lib' is not a valid libtool archive"
2539
2540
# Read the libtool library.
2541
dlname=
2542
library_names=
2543
func_source "$file"
2544
2545
# Skip this library if it cannot be dlopened.
2546
if test -z "$dlname"; then
2547
# Warn if it was a shared library.
2548
test -n "$library_names" && \
2549
func_warning "\`$file' was not linked with \`-export-dynamic'"
2550
continue
2551
fi
2552
2553
func_dirname "$file" "" "."
2554
dir="$func_dirname_result"
2555
2556
if test -f "$dir/$objdir/$dlname"; then
2557
func_append dir "/$objdir"
2558
else
2559
if test ! -f "$dir/$dlname"; then
2560
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2561
fi
2562
fi
2563
;;
2564
2565
*.lo)
2566
# Just add the directory containing the .lo file.
2567
func_dirname "$file" "" "."
2568
dir="$func_dirname_result"
2569
;;
2570
2571
*)
2572
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2573
continue
2574
;;
2575
esac
2576
2577
# Get the absolute pathname.
2578
absdir=`cd "$dir" && pwd`
2579
test -n "$absdir" && dir="$absdir"
2580
2581
# Now add the directory to shlibpath_var.
2582
if eval "test -z \"\$$shlibpath_var\""; then
2583
eval "$shlibpath_var=\"\$dir\""
2584
else
2585
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2586
fi
2587
done
2588
2589
# This variable tells wrapper scripts just to set shlibpath_var
2590
# rather than running their programs.
2591
libtool_execute_magic="$magic"
2592
2593
# Check if any of the arguments is a wrapper script.
2594
args=
2595
for file
2596
do
2597
case $file in
2598
-* | *.la | *.lo ) ;;
2599
*)
2600
# Do a test to see if this is really a libtool program.
2601
if func_ltwrapper_script_p "$file"; then
2602
func_source "$file"
2603
# Transform arg to wrapped name.
2604
file="$progdir/$program"
2605
elif func_ltwrapper_executable_p "$file"; then
2606
func_ltwrapper_scriptname "$file"
2607
func_source "$func_ltwrapper_scriptname_result"
2608
# Transform arg to wrapped name.
2609
file="$progdir/$program"
2610
fi
2611
;;
2612
esac
2613
# Quote arguments (to preserve shell metacharacters).
2614
func_append_quoted args "$file"
2615
done
2616
2617
if test "X$opt_dry_run" = Xfalse; then
2618
if test -n "$shlibpath_var"; then
2619
# Export the shlibpath_var.
2620
eval "export $shlibpath_var"
2621
fi
2622
2623
# Restore saved environment variables
2624
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625
do
2626
eval "if test \"\${save_$lt_var+set}\" = set; then
2627
$lt_var=\$save_$lt_var; export $lt_var
2628
else
2629
$lt_unset $lt_var
2630
fi"
2631
done
2632
2633
# Now prepare to actually exec the command.
2634
exec_cmd="\$cmd$args"
2635
else
2636
# Display what would be done.
2637
if test -n "$shlibpath_var"; then
2638
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639
echo "export $shlibpath_var"
2640
fi
2641
$ECHO "$cmd$args"
2642
exit $EXIT_SUCCESS
2643
fi
2644
}
2645
2646
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2647
2648
2649
# func_mode_finish arg...
2650
func_mode_finish ()
2651
{
2652
$opt_debug
2653
libs=
2654
libdirs=
2655
admincmds=
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
2698
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699
for libdir in $libdirs; do
2700
if test -n "$finish_cmds"; then
2701
# Do each command in the finish commands.
2702
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2703
'"$cmd"'"'
2704
fi
2705
if test -n "$finish_eval"; then
2706
# Do the single finish_eval.
2707
eval cmds=\"$finish_eval\"
2708
$opt_dry_run || eval "$cmds" || func_append admincmds "
2709
$cmds"
2710
fi
2711
done
2712
fi
2713
2714
# Exit here if they wanted silent mode.
2715
$opt_silent && exit $EXIT_SUCCESS
2716
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
2762
exit $EXIT_SUCCESS
2763
}
2764
2765
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2766
2767
2768
# func_mode_install arg...
2769
func_mode_install ()
2770
{
2771
$opt_debug
2772
# There may be an optional sh(1) argument at the beginning of
2773
# install_prog (especially on Windows NT).
2774
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775
# Allow the use of GNU shtool's install command.
2776
case $nonopt in *shtool*) :;; *) false;; esac; then
2777
# Aesthetically quote it.
2778
func_quote_for_eval "$nonopt"
2779
install_prog="$func_quote_for_eval_result "
2780
arg=$1
2781
shift
2782
else
2783
install_prog=
2784
arg=$nonopt
2785
fi
2786
2787
# The real first argument should be the name of the installation program.
2788
# Aesthetically quote it.
2789
func_quote_for_eval "$arg"
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
2796
2797
# We need to accept at least all the BSD install flags.
2798
dest=
2799
files=
2800
opts=
2801
prev=
2802
install_type=
2803
isdir=no
2804
stripme=
2805
no_mode=:
2806
for arg
2807
do
2808
arg2=
2809
if test -n "$dest"; then
2810
func_append files " $dest"
2811
dest=$arg
2812
continue
2813
fi
2814
2815
case $arg in
2816
-d) isdir=yes ;;
2817
-f)
2818
if $install_cp; then :; else
2819
prev=$arg
2820
fi
2821
;;
2822
-g | -m | -o)
2823
prev=$arg
2824
;;
2825
-s)
2826
stripme=" -s"
2827
continue
2828
;;
2829
-*)
2830
;;
2831
*)
2832
# If the previous option needed an argument, then skip it.
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
2838
prev=
2839
else
2840
dest=$arg
2841
continue
2842
fi
2843
;;
2844
esac
2845
2846
# Aesthetically quote the argument.
2847
func_quote_for_eval "$arg"
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"
2853
done
2854
2855
test -z "$install_prog" && \
2856
func_fatal_help "you must specify an install program"
2857
2858
test -n "$prev" && \
2859
func_fatal_help "the \`$prev' option requires an argument"
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
2868
if test -z "$files"; then
2869
if test -z "$dest"; then
2870
func_fatal_help "no file or destination specified"
2871
else
2872
func_fatal_help "you must specify a destination"
2873
fi
2874
fi
2875
2876
# Strip any trailing slash from the destination.
2877
func_stripname '' '/' "$dest"
2878
dest=$func_stripname_result
2879
2880
# Check to see that the destination is a directory.
2881
test -d "$dest" && isdir=yes
2882
if test "$isdir" = yes; then
2883
destdir="$dest"
2884
destname=
2885
else
2886
func_dirname_and_basename "$dest" "" "."
2887
destdir="$func_dirname_result"
2888
destname="$func_basename_result"
2889
2890
# Not a directory, so check to see that there is only one file specified.
2891
set dummy $files; shift
2892
test "$#" -gt 1 && \
2893
func_fatal_help "\`$dest' is not a directory"
2894
fi
2895
case $destdir in
2896
[\\/]* | [A-Za-z]:[\\/]*) ;;
2897
*)
2898
for file in $files; do
2899
case $file in
2900
*.lo) ;;
2901
*)
2902
func_fatal_help "\`$destdir' must be an absolute directory name"
2903
;;
2904
esac
2905
done
2906
;;
2907
esac
2908
2909
# This variable tells wrapper scripts just to set variables rather
2910
# than running their programs.
2911
libtool_install_magic="$magic"
2912
2913
staticlibs=
2914
future_libdirs=
2915
current_libdirs=
2916
for file in $files; do
2917
2918
# Do each installation.
2919
case $file in
2920
*.$libext)
2921
# Do the static libraries later.
2922
func_append staticlibs " $file"
2923
;;
2924
2925
*.la)
2926
func_resolve_sysroot "$file"
2927
file=$func_resolve_sysroot_result
2928
2929
# Check to see that this really is a libtool archive.
2930
func_lalib_unsafe_p "$file" \
2931
|| func_fatal_help "\`$file' is not a valid libtool archive"
2932
2933
library_names=
2934
old_library=
2935
relink_command=
2936
func_source "$file"
2937
2938
# Add the libdir to current_libdirs if it is the destination.
2939
if test "X$destdir" = "X$libdir"; then
2940
case "$current_libdirs " in
2941
*" $libdir "*) ;;
2942
*) func_append current_libdirs " $libdir" ;;
2943
esac
2944
else
2945
# Note the libdir as a future libdir.
2946
case "$future_libdirs " in
2947
*" $libdir "*) ;;
2948
*) func_append future_libdirs " $libdir" ;;
2949
esac
2950
fi
2951
2952
func_dirname "$file" "/" ""
2953
dir="$func_dirname_result"
2954
func_append dir "$objdir"
2955
2956
if test -n "$relink_command"; then
2957
# Determine the prefix the user has applied to our future dir.
2958
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959
2960
# Don't allow the user to place us outside of our expected
2961
# location b/c this prevents finding dependent libraries that
2962
# are installed to the same prefix.
2963
# At present, this check doesn't affect windows .dll's that
2964
# are installed into $libdir/../bin (currently, that works fine)
2965
# but it's something to keep an eye on.
2966
test "$inst_prefix_dir" = "$destdir" && \
2967
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968
2969
if test -n "$inst_prefix_dir"; then
2970
# Stick the inst_prefix_dir data into the link command.
2971
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972
else
2973
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2974
fi
2975
2976
func_warning "relinking \`$file'"
2977
func_show_eval "$relink_command" \
2978
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2979
fi
2980
2981
# See the names of the shared library.
2982
set dummy $library_names; shift
2983
if test -n "$1"; then
2984
realname="$1"
2985
shift
2986
2987
srcname="$realname"
2988
test -n "$relink_command" && srcname="$realname"T
2989
2990
# Install the shared library and build the symlinks.
2991
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2992
'exit $?'
2993
tstripme="$stripme"
2994
case $host_os in
2995
cygwin* | mingw* | pw32* | cegcc*)
2996
case $realname in
2997
*.dll.a)
2998
tstripme=""
2999
;;
3000
esac
3001
;;
3002
esac
3003
if test -n "$tstripme" && test -n "$striplib"; then
3004
func_show_eval "$striplib $destdir/$realname" 'exit $?'
3005
fi
3006
3007
if test "$#" -gt 0; then
3008
# Delete the old symlinks, and create new ones.
3009
# Try `ln -sf' first, because the `ln' binary might depend on
3010
# the symlink we replace! Solaris /bin/ln does not understand -f,
3011
# so we also need to try rm && ln -s.
3012
for linkname
3013
do
3014
test "$linkname" != "$realname" \
3015
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3016
done
3017
fi
3018
3019
# Do each command in the postinstall commands.
3020
lib="$destdir/$realname"
3021
func_execute_cmds "$postinstall_cmds" 'exit $?'
3022
fi
3023
3024
# Install the pseudo-library for information purposes.
3025
func_basename "$file"
3026
name="$func_basename_result"
3027
instname="$dir/$name"i
3028
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029
3030
# Maybe install the static library, too.
3031
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3032
;;
3033
3034
*.lo)
3035
# Install (i.e. copy) a libtool object.
3036
3037
# Figure out destination file name, if it wasn't already specified.
3038
if test -n "$destname"; then
3039
destfile="$destdir/$destname"
3040
else
3041
func_basename "$file"
3042
destfile="$func_basename_result"
3043
destfile="$destdir/$destfile"
3044
fi
3045
3046
# Deduce the name of the destination old-style object file.
3047
case $destfile in
3048
*.lo)
3049
func_lo2o "$destfile"
3050
staticdest=$func_lo2o_result
3051
;;
3052
*.$objext)
3053
staticdest="$destfile"
3054
destfile=
3055
;;
3056
*)
3057
func_fatal_help "cannot copy a libtool object to \`$destfile'"
3058
;;
3059
esac
3060
3061
# Install the libtool object if requested.
3062
test -n "$destfile" && \
3063
func_show_eval "$install_prog $file $destfile" 'exit $?'
3064
3065
# Install the old object if enabled.
3066
if test "$build_old_libs" = yes; then
3067
# Deduce the name of the old-style object file.
3068
func_lo2o "$file"
3069
staticobj=$func_lo2o_result
3070
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3071
fi
3072
exit $EXIT_SUCCESS
3073
;;
3074
3075
*)
3076
# Figure out destination file name, if it wasn't already specified.
3077
if test -n "$destname"; then
3078
destfile="$destdir/$destname"
3079
else
3080
func_basename "$file"
3081
destfile="$func_basename_result"
3082
destfile="$destdir/$destfile"
3083
fi
3084
3085
# If the file is missing, and there is a .exe on the end, strip it
3086
# because it is most likely a libtool script we actually want to
3087
# install
3088
stripped_ext=""
3089
case $file in
3090
*.exe)
3091
if test ! -f "$file"; then
3092
func_stripname '' '.exe' "$file"
3093
file=$func_stripname_result
3094
stripped_ext=".exe"
3095
fi
3096
;;
3097
esac
3098
3099
# Do a test to see if this is really a libtool program.
3100
case $host in
3101
*cygwin* | *mingw*)
3102
if func_ltwrapper_executable_p "$file"; then
3103
func_ltwrapper_scriptname "$file"
3104
wrapper=$func_ltwrapper_scriptname_result
3105
else
3106
func_stripname '' '.exe' "$file"
3107
wrapper=$func_stripname_result
3108
fi
3109
;;
3110
*)
3111
wrapper=$file
3112
;;
3113
esac
3114
if func_ltwrapper_script_p "$wrapper"; then
3115
notinst_deplibs=
3116
relink_command=
3117
3118
func_source "$wrapper"
3119
3120
# Check the variables that should have been set.
3121
test -z "$generated_by_libtool_version" && \
3122
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3123
3124
finalize=yes
3125
for lib in $notinst_deplibs; do
3126
# Check to see that each library is installed.
3127
libdir=
3128
if test -f "$lib"; then
3129
func_source "$lib"
3130
fi
3131
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132
if test -n "$libdir" && test ! -f "$libfile"; then
3133
func_warning "\`$lib' has not been installed in \`$libdir'"
3134
finalize=no
3135
fi
3136
done
3137
3138
relink_command=
3139
func_source "$wrapper"
3140
3141
outputname=
3142
if test "$fast_install" = no && test -n "$relink_command"; then
3143
$opt_dry_run || {
3144
if test "$finalize" = yes; then
3145
tmpdir=`func_mktempdir`
3146
func_basename "$file$stripped_ext"
3147
file="$func_basename_result"
3148
outputname="$tmpdir/$file"
3149
# Replace the output file specification.
3150
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3151
3152
$opt_silent || {
3153
func_quote_for_expand "$relink_command"
3154
eval "func_echo $func_quote_for_expand_result"
3155
}
3156
if eval "$relink_command"; then :
3157
else
3158
func_error "error: relink \`$file' with the above command before installing it"
3159
$opt_dry_run || ${RM}r "$tmpdir"
3160
continue
3161
fi
3162
file="$outputname"
3163
else
3164
func_warning "cannot relink \`$file'"
3165
fi
3166
}
3167
else
3168
# Install the binary that we compiled earlier.
3169
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3170
fi
3171
fi
3172
3173
# remove .exe since cygwin /usr/bin/install will append another
3174
# one anyway
3175
case $install_prog,$host in
3176
*/usr/bin/install*,*cygwin*)
3177
case $file:$destfile in
3178
*.exe:*.exe)
3179
# this is ok
3180
;;
3181
*.exe:*)
3182
destfile=$destfile.exe
3183
;;
3184
*:*.exe)
3185
func_stripname '' '.exe' "$destfile"
3186
destfile=$func_stripname_result
3187
;;
3188
esac
3189
;;
3190
esac
3191
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192
$opt_dry_run || if test -n "$outputname"; then
3193
${RM}r "$tmpdir"
3194
fi
3195
;;
3196
esac
3197
done
3198
3199
for file in $staticlibs; do
3200
func_basename "$file"
3201
name="$func_basename_result"
3202
3203
# Set up the ranlib parameters.
3204
oldlib="$destdir/$name"
3205
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206
tool_oldlib=$func_to_tool_file_result
3207
3208
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3209
3210
if test -n "$stripme" && test -n "$old_striplib"; then
3211
func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3212
fi
3213
3214
# Do each command in the postinstall commands.
3215
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3216
done
3217
3218
test -n "$future_libdirs" && \
3219
func_warning "remember to run \`$progname --finish$future_libdirs'"
3220
3221
if test -n "$current_libdirs"; then
3222
# Maybe just do a dry run.
3223
$opt_dry_run && current_libdirs=" -n$current_libdirs"
3224
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3225
else
3226
exit $EXIT_SUCCESS
3227
fi
3228
}
3229
3230
test "$opt_mode" = install && func_mode_install ${1+"$@"}
3231
3232
3233
# func_generate_dlsyms outputname originator pic_p
3234
# Extract symbols from dlprefiles and create ${outputname}S.o with
3235
# a dlpreopen symbol table.
3236
func_generate_dlsyms ()
3237
{
3238
$opt_debug
3239
my_outputname="$1"
3240
my_originator="$2"
3241
my_pic_p="${3-no}"
3242
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3243
my_dlsyms=
3244
3245
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3246
if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247
my_dlsyms="${my_outputname}S.c"
3248
else
3249
func_error "not configured to extract global symbols from dlpreopened files"
3250
fi
3251
fi
3252
3253
if test -n "$my_dlsyms"; then
3254
case $my_dlsyms in
3255
"") ;;
3256
*.c)
3257
# Discover the nlist of each of the dlfiles.
3258
nlist="$output_objdir/${my_outputname}.nm"
3259
3260
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3261
3262
# Parse the name list into a source file.
3263
func_verbose "creating $output_objdir/$my_dlsyms"
3264
3265
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3266
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3268
3269
#ifdef __cplusplus
3270
extern \"C\" {
3271
#endif
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
3289
/* External symbol declarations for the compiler. */\
3290
"
3291
3292
if test "$dlself" = yes; then
3293
func_verbose "generating symbol list for \`$output'"
3294
3295
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3296
3297
# Add our own program objects to the symbol list.
3298
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299
for progfile in $progfiles; do
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'"
3303
done
3304
3305
if test -n "$exclude_expsyms"; then
3306
$opt_dry_run || {
3307
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308
eval '$MV "$nlist"T "$nlist"'
3309
}
3310
fi
3311
3312
if test -n "$export_symbols_regex"; then
3313
$opt_dry_run || {
3314
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315
eval '$MV "$nlist"T "$nlist"'
3316
}
3317
fi
3318
3319
# Prepare the list of exported symbols
3320
if test -z "$export_symbols"; then
3321
export_symbols="$output_objdir/$outputname.exp"
3322
$opt_dry_run || {
3323
$RM $export_symbols
3324
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3325
case $host in
3326
*cygwin* | *mingw* | *cegcc* )
3327
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3329
;;
3330
esac
3331
}
3332
else
3333
$opt_dry_run || {
3334
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336
eval '$MV "$nlist"T "$nlist"'
3337
case $host in
3338
*cygwin* | *mingw* | *cegcc* )
3339
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3341
;;
3342
esac
3343
}
3344
fi
3345
fi
3346
3347
for dlprefile in $dlprefiles; do
3348
func_verbose "extracting global C symbols from \`$dlprefile'"
3349
func_basename "$dlprefile"
3350
name="$func_basename_result"
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
3397
done
3398
3399
$opt_dry_run || {
3400
# Make sure we have at least an empty file.
3401
test -f "$nlist" || : > "$nlist"
3402
3403
if test -n "$exclude_expsyms"; then
3404
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405
$MV "$nlist"T "$nlist"
3406
fi
3407
3408
# Try sorting and uniquifying the output.
3409
if $GREP -v "^: " < "$nlist" |
3410
if sort -k 3 </dev/null >/dev/null 2>&1; then
3411
sort -k 3
3412
else
3413
sort +2
3414
fi |
3415
uniq > "$nlist"S; then
3416
:
3417
else
3418
$GREP -v "^: " < "$nlist" > "$nlist"S
3419
fi
3420
3421
if test -f "$nlist"S; then
3422
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3423
else
3424
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3425
fi
3426
3427
echo >> "$output_objdir/$my_dlsyms" "\
3428
3429
/* The mapping between symbol names and symbols. */
3430
typedef struct {
3431
const char *name;
3432
void *address;
3433
} lt_dlsymlist;
3434
extern LT_DLSYM_CONST lt_dlsymlist
3435
lt_${my_prefix}_LTX_preloaded_symbols[];
3436
LT_DLSYM_CONST lt_dlsymlist
3437
lt_${my_prefix}_LTX_preloaded_symbols[] =
3438
{\
3439
{ \"$my_originator\", (void *) 0 },"
3440
3441
case $need_lib_prefix in
3442
no)
3443
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444
;;
3445
*)
3446
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3447
;;
3448
esac
3449
echo >> "$output_objdir/$my_dlsyms" "\
3450
{0, (void *) 0}
3451
};
3452
3453
/* This works around a problem in FreeBSD linker */
3454
#ifdef FREEBSD_WORKAROUND
3455
static const void *lt_preloaded_setup() {
3456
return lt_${my_prefix}_LTX_preloaded_symbols;
3457
}
3458
#endif
3459
3460
#ifdef __cplusplus
3461
}
3462
#endif\
3463
"
3464
} # !$opt_dry_run
3465
3466
pic_flag_for_symtable=
3467
case "$compile_command " in
3468
*" -static "*) ;;
3469
*)
3470
case $host in
3471
# compiling the symbol table file with pic_flag works around
3472
# a FreeBSD bug that causes programs to crash when -lm is
3473
# linked before any other PIC object. But we must not use
3474
# pic_flag when linking with -static. The problem exists in
3475
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476
*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3477
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3478
*-*-hpux*)
3479
pic_flag_for_symtable=" $pic_flag" ;;
3480
*)
3481
if test "X$my_pic_p" != Xno; then
3482
pic_flag_for_symtable=" $pic_flag"
3483
fi
3484
;;
3485
esac
3486
;;
3487
esac
3488
symtab_cflags=
3489
for arg in $LTCFLAGS; do
3490
case $arg in
3491
-pie | -fpie | -fPIE) ;;
3492
*) func_append symtab_cflags " $arg" ;;
3493
esac
3494
done
3495
3496
# Now compile the dynamic symbol file.
3497
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3498
3499
# Clean up the generated files.
3500
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3501
3502
# Transform the symbol file into the correct name.
3503
symfileobj="$output_objdir/${my_outputname}S.$objext"
3504
case $host in
3505
*cygwin* | *mingw* | *cegcc* )
3506
if test -f "$output_objdir/$my_outputname.def"; then
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%"`
3509
else
3510
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512
fi
3513
;;
3514
*)
3515
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3517
;;
3518
esac
3519
;;
3520
*)
3521
func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522
;;
3523
esac
3524
else
3525
# We keep going just in case the user didn't refer to
3526
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3527
# really was required.
3528
3529
# Nullify the symbol file.
3530
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532
fi
3533
}
3534
3535
# func_win32_libid arg
3536
# return the library type of file 'arg'
3537
#
3538
# Need a lot of goo to handle *both* DLLs and import libs
3539
# Has to be a shell function in order to 'eat' the argument
3540
# that is supplied when $file_magic_command is called.
3541
# Despite the name, also deal with 64 bit binaries.
3542
func_win32_libid ()
3543
{
3544
$opt_debug
3545
win32_libid_type="unknown"
3546
win32_fileres=`file -L $1 2>/dev/null`
3547
case $win32_fileres in
3548
*ar\ archive\ import\ library*) # definitely import
3549
win32_libid_type="x86 archive import"
3550
;;
3551
*ar\ archive*) # could be an import, or static
3552
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
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\" |
3557
$SED -n -e '
3558
1,100{
3559
/ I /{
3560
s,.*,import,
3561
p
3562
q
3563
}
3564
}'`
3565
case $win32_nmres in
3566
import*) win32_libid_type="x86 archive import";;
3567
*) win32_libid_type="x86 archive static";;
3568
esac
3569
fi
3570
;;
3571
*DLL*)
3572
win32_libid_type="x86 DLL"
3573
;;
3574
*executable*) # but shell scripts are "executable" too...
3575
case $win32_fileres in
3576
*MS\ Windows\ PE\ Intel*)
3577
win32_libid_type="x86 DLL"
3578
;;
3579
esac
3580
;;
3581
esac
3582
$ECHO "$win32_libid_type"
3583
}
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
}
3710
3711
3712
# func_extract_an_archive dir oldlib
3713
func_extract_an_archive ()
3714
{
3715
$opt_debug
3716
f_ex_an_ar_dir="$1"; shift
3717
f_ex_an_ar_oldlib="$1"
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
3730
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3731
:
3732
else
3733
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3734
fi
3735
}
3736
3737
3738
# func_extract_archives gentop oldlib ...
3739
func_extract_archives ()
3740
{
3741
$opt_debug
3742
my_gentop="$1"; shift
3743
my_oldlibs=${1+"$@"}
3744
my_oldobjs=""
3745
my_xlib=""
3746
my_xabs=""
3747
my_xdir=""
3748
3749
for my_xlib in $my_oldlibs; do
3750
# Extract the objects.
3751
case $my_xlib in
3752
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3753
*) my_xabs=`pwd`"/$my_xlib" ;;
3754
esac
3755
func_basename "$my_xlib"
3756
my_xlib="$func_basename_result"
3757
my_xlib_u=$my_xlib
3758
while :; do
3759
case " $extracted_archives " in
3760
*" $my_xlib_u "*)
3761
func_arith $extracted_serial + 1
3762
extracted_serial=$func_arith_result
3763
my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764
*) break ;;
3765
esac
3766
done
3767
extracted_archives="$extracted_archives $my_xlib_u"
3768
my_xdir="$my_gentop/$my_xlib_u"
3769
3770
func_mkdir_p "$my_xdir"
3771
3772
case $host in
3773
*-darwin*)
3774
func_verbose "Extracting $my_xabs"
3775
# Do not bother doing anything if just a dry run
3776
$opt_dry_run || {
3777
darwin_orig_dir=`pwd`
3778
cd $my_xdir || exit $?
3779
darwin_archive=$my_xabs
3780
darwin_curdir=`pwd`
3781
darwin_base_archive=`basename "$darwin_archive"`
3782
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783
if test -n "$darwin_arches"; then
3784
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3785
darwin_arch=
3786
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3787
for darwin_arch in $darwin_arches ; do
3788
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3792
cd "$darwin_curdir"
3793
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794
done # $darwin_arches
3795
## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3797
darwin_file=
3798
darwin_files=
3799
for darwin_file in $darwin_filelist; do
3800
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801
$LIPO -create -output "$darwin_file" $darwin_files
3802
done # $darwin_filelist
3803
$RM -rf unfat-$$
3804
cd "$darwin_orig_dir"
3805
else
3806
cd $darwin_orig_dir
3807
func_extract_an_archive "$my_xdir" "$my_xabs"
3808
fi # $darwin_arches
3809
} # !$opt_dry_run
3810
;;
3811
*)
3812
func_extract_an_archive "$my_xdir" "$my_xabs"
3813
;;
3814
esac
3815
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3816
done
3817
3818
func_extract_archives_result="$my_oldobjs"
3819
}
3820
3821
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 ()
3837
{
3838
func_emit_wrapper_arg1=${1-no}
3839
3840
$ECHO "\
3841
#! $SHELL
3842
3843
# $output - temporary wrapper script for $objdir/$outputname
3844
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3845
#
3846
# The $output program cannot be directly executed until all the libtool
3847
# libraries that it depends on are installed.
3848
#
3849
# This wrapper script should never be moved out of the build directory.
3850
# If it is, it will not operate correctly.
3851
3852
# Sed substitution that helps us do robust quoting. It backslashifies
3853
# metacharacters that are still active within double-quoted strings.
3854
sed_quote_subst='$sed_quote_subst'
3855
3856
# Be Bourne compatible
3857
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3858
emulate sh
3859
NULLCMD=:
3860
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861
# is contrary to our usage. Disable this feature.
3862
alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863
setopt NO_GLOB_SUBST
3864
else
3865
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3866
fi
3867
BIN_SH=xpg4; export BIN_SH # for Tru64
3868
DUALCASE=1; export DUALCASE # for MKS sh
3869
3870
# The HP-UX ksh and POSIX shell print the target directory to stdout
3871
# if CDPATH is set.
3872
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3873
3874
relink_command=\"$relink_command\"
3875
3876
# This environment variable determines our operation mode.
3877
if test \"\$libtool_install_magic\" = \"$magic\"; then
3878
# install mode needs the following variables:
3879
generated_by_libtool_version='$macro_version'
3880
notinst_deplibs='$notinst_deplibs'
3881
else
3882
# When we are sourced in execute mode, \$file and \$ECHO are already set.
3883
if test \"\$libtool_execute_magic\" != \"$magic\"; then
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
3996
shift
3997
done ;;
3998
esac
3999
func_exec_program_core \${1+\"\$@\"}
4000
}
4001
4002
# Parse options
4003
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4004
4005
# Find the directory that this script lives in.
4006
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4007
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4008
4009
# Follow symbolic links until we get to the real thisdir.
4010
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4011
while test -n \"\$file\"; do
4012
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4013
4014
# If there was a directory component, then change thisdir.
4015
if test \"x\$destdir\" != \"x\$file\"; then
4016
case \"\$destdir\" in
4017
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4018
*) thisdir=\"\$thisdir/\$destdir\" ;;
4019
esac
4020
fi
4021
4022
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4024
done
4025
4026
# Usually 'no', except on cygwin/mingw when embedded into
4027
# the cwrapper.
4028
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4029
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4030
# special case for '.'
4031
if test \"\$thisdir\" = \".\"; then
4032
thisdir=\`pwd\`
4033
fi
4034
# remove .libs from thisdir
4035
case \"\$thisdir\" in
4036
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4037
$objdir ) thisdir=. ;;
4038
esac
4039
fi
4040
4041
# Try to get the absolute directory name.
4042
absdir=\`cd \"\$thisdir\" && pwd\`
4043
test -n \"\$absdir\" && thisdir=\"\$absdir\"
4044
"
4045
4046
if test "$fast_install" = yes; then
4047
$ECHO "\
4048
program='$outputname'$exeext
4049
progdir=\"\$thisdir/$objdir\"
4050
4051
if test ! -f \"\$progdir/\$program\" ||
4052
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4053
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4054
4055
file=\"\$\$-\$program\"
4056
4057
if test ! -d \"\$progdir\"; then
4058
$MKDIR \"\$progdir\"
4059
else
4060
$RM \"\$progdir/\$file\"
4061
fi"
4062
4063
$ECHO "\
4064
4065
# relink executable if necessary
4066
if test -n \"\$relink_command\"; then
4067
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4068
else
4069
$ECHO \"\$relink_command_output\" >&2
4070
$RM \"\$progdir/\$file\"
4071
exit 1
4072
fi
4073
fi
4074
4075
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4076
{ $RM \"\$progdir/\$program\";
4077
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4078
$RM \"\$progdir/\$file\"
4079
fi"
4080
else
4081
$ECHO "\
4082
program='$outputname'
4083
progdir=\"\$thisdir/$objdir\"
4084
"
4085
fi
4086
4087
$ECHO "\
4088
4089
if test -f \"\$progdir/\$program\"; then"
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
4103
# Export our shlibpath_var if we have one.
4104
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4105
$ECHO "\
4106
# Add our own library path to $shlibpath_var
4107
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4108
4109
# Some systems cannot cope with colon-terminated $shlibpath_var
4110
# The second colon is a workaround for a bug in BeOS R4 sed
4111
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4112
4113
export $shlibpath_var
4114
"
4115
fi
4116
4117
$ECHO "\
4118
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4119
# Run the actual program with our arguments.
4120
func_exec_program \${1+\"\$@\"}
4121
fi
4122
else
4123
# The program doesn't exist.
4124
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4125
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4126
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4127
exit 1
4128
fi
4129
fi\
4130
"
4131
}
4132
4133
4134
# func_emit_cwrapperexe_src
4135
# emit the source code for a wrapper executable on stdout
4136
# Must ONLY be called from within func_mode_link because
4137
# it depends on a number of variable set therein.
4138
func_emit_cwrapperexe_src ()
4139
{
4140
cat <<EOF
4141
4142
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4143
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4144
4145
The $output program cannot be directly executed until all the libtool
4146
libraries that it depends on are installed.
4147
4148
This wrapper executable should never be moved out of the build directory.
4149
If it is, it will not operate correctly.
4150
*/
4151
EOF
4152
cat <<"EOF"
4153
#ifdef _MSC_VER
4154
# define _CRT_SECURE_NO_DEPRECATE 1
4155
#endif
4156
#include <stdio.h>
4157
#include <stdlib.h>
4158
#ifdef _MSC_VER
4159
# include <direct.h>
4160
# include <process.h>
4161
# include <io.h>
4162
#else
4163
# include <unistd.h>
4164
# include <stdint.h>
4165
# ifdef __CYGWIN__
4166
# include <io.h>
4167
# endif
4168
#endif
4169
#include <malloc.h>
4170
#include <stdarg.h>
4171
#include <assert.h>
4172
#include <string.h>
4173
#include <ctype.h>
4174
#include <errno.h>
4175
#include <fcntl.h>
4176
#include <sys/stat.h>
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
4216
#if defined(PATH_MAX)
4217
# define LT_PATHMAX PATH_MAX
4218
#elif defined(MAXPATHLEN)
4219
# define LT_PATHMAX MAXPATHLEN
4220
#else
4221
# define LT_PATHMAX 1024
4222
#endif
4223
4224
#ifndef S_IXOTH
4225
# define S_IXOTH 0
4226
#endif
4227
#ifndef S_IXGRP
4228
# define S_IXGRP 0
4229
#endif
4230
4231
/* path handling portability macros */
4232
#ifndef DIR_SEPARATOR
4233
# define DIR_SEPARATOR '/'
4234
# define PATH_SEPARATOR ':'
4235
#endif
4236
4237
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4238
defined (__OS2__)
4239
# define HAVE_DOS_BASED_FILE_SYSTEM
4240
# define FOPEN_WB "wb"
4241
# ifndef DIR_SEPARATOR_2
4242
# define DIR_SEPARATOR_2 '\\'
4243
# endif
4244
# ifndef PATH_SEPARATOR_2
4245
# define PATH_SEPARATOR_2 ';'
4246
# endif
4247
#endif
4248
4249
#ifndef DIR_SEPARATOR_2
4250
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4251
#else /* DIR_SEPARATOR_2 */
4252
# define IS_DIR_SEPARATOR(ch) \
4253
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4254
#endif /* DIR_SEPARATOR_2 */
4255
4256
#ifndef PATH_SEPARATOR_2
4257
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4258
#else /* PATH_SEPARATOR_2 */
4259
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4260
#endif /* PATH_SEPARATOR_2 */
4261
4262
#ifndef FOPEN_WB
4263
# define FOPEN_WB "w"
4264
#endif
4265
#ifndef _O_BINARY
4266
# define _O_BINARY 0
4267
#endif
4268
4269
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4270
#define XFREE(stale) do { \
4271
if (stale) { free ((void *) stale); stale = 0; } \
4272
} while (0)
4273
4274
#if defined(LT_DEBUGWRAPPER)
4275
static int lt_debug = 1;
4276
#else
4277
static int lt_debug = 0;
4278
#endif
4279
4280
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4281
4282
void *xmalloc (size_t num);
4283
char *xstrdup (const char *string);
4284
const char *base_name (const char *name);
4285
char *find_executable (const char *wrapper);
4286
char *chase_symlinks (const char *pathspec);
4287
int make_executable (const char *path);
4288
int check_executable (const char *path);
4289
char *strendzap (char *str, const char *pat);
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);
4294
void lt_setenv (const char *name, const char *value);
4295
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4296
void lt_update_exe_path (const char *name, const char *value);
4297
void lt_update_lib_path (const char *name, const char *value);
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";
4304
const char * LIB_PATH_VARNAME = "$shlibpath_var";
4305
EOF
4306
4307
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4308
func_to_host_path "$temp_rpath"
4309
cat <<EOF
4310
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4311
EOF
4312
else
4313
cat <<"EOF"
4314
const char * LIB_PATH_VALUE = "";
4315
EOF
4316
fi
4317
4318
if test -n "$dllsearchpath"; then
4319
func_to_host_path "$dllsearchpath:"
4320
cat <<EOF
4321
const char * EXE_PATH_VARNAME = "PATH";
4322
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4323
EOF
4324
else
4325
cat <<"EOF"
4326
const char * EXE_PATH_VARNAME = "";
4327
const char * EXE_PATH_VALUE = "";
4328
EOF
4329
fi
4330
4331
if test "$fast_install" = yes; then
4332
cat <<EOF
4333
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4334
EOF
4335
else
4336
cat <<EOF
4337
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4338
EOF
4339
fi
4340
4341
4342
cat <<"EOF"
4343
4344
#define LTWRAPPER_OPTION_PREFIX "--lt-"
4345
4346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4347
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4348
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
4349
4350
int
4351
main (int argc, char *argv[])
4352
{
4353
char **newargz;
4354
int newargc;
4355
char *tmp_pathspec;
4356
char *actual_cwrapper_path;
4357
char *actual_cwrapper_name;
4358
char *target_name;
4359
char *lt_argv_zero;
4360
intptr_t rval = 127;
4361
4362
int i;
4363
4364
program_name = (char *) xstrdup (base_name (argv[0]));
4365
newargz = XMALLOC (char *, argc + 1);
4366
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;
4372
for (i = 1; i < argc; i++)
4373
{
4374
if (strcmp (argv[i], dumpscript_opt) == 0)
4375
{
4376
EOF
4377
case "$host" in
4378
*mingw* | *cygwin* )
4379
# make stdout use "unix" line endings
4380
echo " setmode(1,_O_BINARY);"
4381
;;
4382
esac
4383
4384
cat <<"EOF"
4385
lt_dump_script (stdout);
4386
return 0;
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]);
4410
}
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
4422
tmp_pathspec = find_executable (argv[0]);
4423
if (tmp_pathspec == NULL)
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);
4428
4429
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4430
lt_debugprintf (__FILE__, __LINE__,
4431
"(main) found exe (after symlink chase) at: %s\n",
4432
actual_cwrapper_path);
4433
XFREE (tmp_pathspec);
4434
4435
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4436
strendzap (actual_cwrapper_path, actual_cwrapper_name);
4437
4438
/* wrapper name transforms */
4439
strendzap (actual_cwrapper_name, ".exe");
4440
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4441
XFREE (actual_cwrapper_name);
4442
actual_cwrapper_name = tmp_pathspec;
4443
tmp_pathspec = 0;
4444
4445
/* target_name transforms -- use actual target program name; might have lt- prefix */
4446
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4447
strendzap (target_name, ".exe");
4448
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4449
XFREE (target_name);
4450
target_name = tmp_pathspec;
4451
tmp_pathspec = 0;
4452
4453
lt_debugprintf (__FILE__, __LINE__,
4454
"(main) libtool target name: %s\n",
4455
target_name);
4456
EOF
4457
4458
cat <<EOF
4459
newargz[0] =
4460
XMALLOC (char, (strlen (actual_cwrapper_path) +
4461
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4462
strcpy (newargz[0], actual_cwrapper_path);
4463
strcat (newargz[0], "$objdir");
4464
strcat (newargz[0], "/");
4465
EOF
4466
4467
cat <<"EOF"
4468
/* stop here, and copy so we don't have to do this twice */
4469
tmp_pathspec = xstrdup (newargz[0]);
4470
4471
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4472
strcat (newargz[0], actual_cwrapper_name);
4473
4474
/* DO want the lt- prefix here if it exists, so use target_name */
4475
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4476
XFREE (tmp_pathspec);
4477
tmp_pathspec = NULL;
4478
EOF
4479
4480
case $host_os in
4481
mingw*)
4482
cat <<"EOF"
4483
{
4484
char* p;
4485
while ((p = strchr (newargz[0], '\\')) != NULL)
4486
{
4487
*p = '/';
4488
}
4489
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4490
{
4491
*p = '/';
4492
}
4493
}
4494
EOF
4495
;;
4496
esac
4497
4498
cat <<"EOF"
4499
XFREE (target_name);
4500
XFREE (actual_cwrapper_path);
4501
XFREE (actual_cwrapper_name);
4502
4503
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
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);
4510
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4511
4512
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513
nonnull (lt_argv_zero));
4514
for (i = 0; i < newargc; i++)
4515
{
4516
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517
i, nonnull (newargz[i]));
4518
}
4519
4520
EOF
4521
4522
case $host_os in
4523
mingw*)
4524
cat <<"EOF"
4525
/* execv doesn't actually work on mingw as expected on unix */
4526
newargz = prepare_spawn (newargz);
4527
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4528
if (rval == -1)
4529
{
4530
/* failed to start process */
4531
lt_debugprintf (__FILE__, __LINE__,
4532
"(main) failed to launch target \"%s\": %s\n",
4533
lt_argv_zero, nonnull (strerror (errno)));
4534
return 127;
4535
}
4536
return rval;
4537
EOF
4538
;;
4539
*)
4540
cat <<"EOF"
4541
execv (lt_argv_zero, newargz);
4542
return rval; /* =127, but avoids unused variable warning */
4543
EOF
4544
;;
4545
esac
4546
4547
cat <<"EOF"
4548
}
4549
4550
void *
4551
xmalloc (size_t num)
4552
{
4553
void *p = (void *) malloc (num);
4554
if (!p)
4555
lt_fatal (__FILE__, __LINE__, "memory exhausted");
4556
4557
return p;
4558
}
4559
4560
char *
4561
xstrdup (const char *string)
4562
{
4563
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4564
string) : NULL;
4565
}
4566
4567
const char *
4568
base_name (const char *name)
4569
{
4570
const char *base;
4571
4572
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4573
/* Skip over the disk name in MSDOS pathnames. */
4574
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4575
name += 2;
4576
#endif
4577
4578
for (base = name; *name; name++)
4579
if (IS_DIR_SEPARATOR (*name))
4580
base = name + 1;
4581
return base;
4582
}
4583
4584
int
4585
check_executable (const char *path)
4586
{
4587
struct stat st;
4588
4589
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4590
nonempty (path));
4591
if ((!path) || (!*path))
4592
return 0;
4593
4594
if ((stat (path, &st) >= 0)
4595
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4596
return 1;
4597
else
4598
return 0;
4599
}
4600
4601
int
4602
make_executable (const char *path)
4603
{
4604
int rval = 0;
4605
struct stat st;
4606
4607
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4608
nonempty (path));
4609
if ((!path) || (!*path))
4610
return 0;
4611
4612
if (stat (path, &st) >= 0)
4613
{
4614
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4615
}
4616
return rval;
4617
}
4618
4619
/* Searches for the full path of the wrapper. Returns
4620
newly allocated full path name if found, NULL otherwise
4621
Does not chase symlinks, even on platforms that support them.
4622
*/
4623
char *
4624
find_executable (const char *wrapper)
4625
{
4626
int has_slash = 0;
4627
const char *p;
4628
const char *p_next;
4629
/* static buffer for getcwd */
4630
char tmp[LT_PATHMAX + 1];
4631
int tmp_len;
4632
char *concat_name;
4633
4634
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4635
nonempty (wrapper));
4636
4637
if ((wrapper == NULL) || (*wrapper == '\0'))
4638
return NULL;
4639
4640
/* Absolute path? */
4641
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4642
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4643
{
4644
concat_name = xstrdup (wrapper);
4645
if (check_executable (concat_name))
4646
return concat_name;
4647
XFREE (concat_name);
4648
}
4649
else
4650
{
4651
#endif
4652
if (IS_DIR_SEPARATOR (wrapper[0]))
4653
{
4654
concat_name = xstrdup (wrapper);
4655
if (check_executable (concat_name))
4656
return concat_name;
4657
XFREE (concat_name);
4658
}
4659
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4660
}
4661
#endif
4662
4663
for (p = wrapper; *p; p++)
4664
if (*p == '/')
4665
{
4666
has_slash = 1;
4667
break;
4668
}
4669
if (!has_slash)
4670
{
4671
/* no slashes; search PATH */
4672
const char *path = getenv ("PATH");
4673
if (path != NULL)
4674
{
4675
for (p = path; *p; p = p_next)
4676
{
4677
const char *q;
4678
size_t p_len;
4679
for (q = p; *q; q++)
4680
if (IS_PATH_SEPARATOR (*q))
4681
break;
4682
p_len = q - p;
4683
p_next = (*q == '\0' ? q : q + 1);
4684
if (p_len == 0)
4685
{
4686
/* empty path: current directory */
4687
if (getcwd (tmp, LT_PATHMAX) == NULL)
4688
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4689
nonnull (strerror (errno)));
4690
tmp_len = strlen (tmp);
4691
concat_name =
4692
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4693
memcpy (concat_name, tmp, tmp_len);
4694
concat_name[tmp_len] = '/';
4695
strcpy (concat_name + tmp_len + 1, wrapper);
4696
}
4697
else
4698
{
4699
concat_name =
4700
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4701
memcpy (concat_name, p, p_len);
4702
concat_name[p_len] = '/';
4703
strcpy (concat_name + p_len + 1, wrapper);
4704
}
4705
if (check_executable (concat_name))
4706
return concat_name;
4707
XFREE (concat_name);
4708
}
4709
}
4710
/* not found in PATH; assume curdir */
4711
}
4712
/* Relative path | not found in path: prepend cwd */
4713
if (getcwd (tmp, LT_PATHMAX) == NULL)
4714
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4715
nonnull (strerror (errno)));
4716
tmp_len = strlen (tmp);
4717
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4718
memcpy (concat_name, tmp, tmp_len);
4719
concat_name[tmp_len] = '/';
4720
strcpy (concat_name + tmp_len + 1, wrapper);
4721
4722
if (check_executable (concat_name))
4723
return concat_name;
4724
XFREE (concat_name);
4725
return NULL;
4726
}
4727
4728
char *
4729
chase_symlinks (const char *pathspec)
4730
{
4731
#ifndef S_ISLNK
4732
return xstrdup (pathspec);
4733
#else
4734
char buf[LT_PATHMAX];
4735
struct stat s;
4736
char *tmp_pathspec = xstrdup (pathspec);
4737
char *p;
4738
int has_symlinks = 0;
4739
while (strlen (tmp_pathspec) && !has_symlinks)
4740
{
4741
lt_debugprintf (__FILE__, __LINE__,
4742
"checking path component for symlinks: %s\n",
4743
tmp_pathspec);
4744
if (lstat (tmp_pathspec, &s) == 0)
4745
{
4746
if (S_ISLNK (s.st_mode) != 0)
4747
{
4748
has_symlinks = 1;
4749
break;
4750
}
4751
4752
/* search backwards for last DIR_SEPARATOR */
4753
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4754
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4755
p--;
4756
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4757
{
4758
/* no more DIR_SEPARATORS left */
4759
break;
4760
}
4761
*p = '\0';
4762
}
4763
else
4764
{
4765
lt_fatal (__FILE__, __LINE__,
4766
"error accessing file \"%s\": %s",
4767
tmp_pathspec, nonnull (strerror (errno)));
4768
}
4769
}
4770
XFREE (tmp_pathspec);
4771
4772
if (!has_symlinks)
4773
{
4774
return xstrdup (pathspec);
4775
}
4776
4777
tmp_pathspec = realpath (pathspec, buf);
4778
if (tmp_pathspec == 0)
4779
{
4780
lt_fatal (__FILE__, __LINE__,
4781
"could not follow symlinks for %s", pathspec);
4782
}
4783
return xstrdup (tmp_pathspec);
4784
#endif
4785
}
4786
4787
char *
4788
strendzap (char *str, const char *pat)
4789
{
4790
size_t len, patlen;
4791
4792
assert (str != NULL);
4793
assert (pat != NULL);
4794
4795
len = strlen (str);
4796
patlen = strlen (pat);
4797
4798
if (patlen <= len)
4799
{
4800
str += len - patlen;
4801
if (strcmp (str, pat) == 0)
4802
*str = '\0';
4803
}
4804
return str;
4805
}
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
4820
static void
4821
lt_error_core (int exit_status, const char *file,
4822
int line, const char *mode,
4823
const char *message, va_list ap)
4824
{
4825
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4826
vfprintf (stderr, message, ap);
4827
fprintf (stderr, ".\n");
4828
4829
if (exit_status >= 0)
4830
exit (exit_status);
4831
}
4832
4833
void
4834
lt_fatal (const char *file, int line, const char *message, ...)
4835
{
4836
va_list ap;
4837
va_start (ap, message);
4838
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4839
va_end (ap);
4840
}
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
4854
void
4855
lt_setenv (const char *name, const char *value)
4856
{
4857
lt_debugprintf (__FILE__, __LINE__,
4858
"(lt_setenv) setting '%s' to '%s'\n",
4859
nonnull (name), nonnull (value));
4860
{
4861
#ifdef HAVE_SETENV
4862
/* always make a copy, for consistency with !HAVE_SETENV */
4863
char *str = xstrdup (value);
4864
setenv (name, str, 1);
4865
#else
4866
int len = strlen (name) + 1 + strlen (value) + 1;
4867
char *str = XMALLOC (char, len);
4868
sprintf (str, "%s=%s", name, value);
4869
if (putenv (str) != EXIT_SUCCESS)
4870
{
4871
XFREE (str);
4872
}
4873
#endif
4874
}
4875
}
4876
4877
char *
4878
lt_extend_str (const char *orig_value, const char *add, int to_end)
4879
{
4880
char *new_value;
4881
if (orig_value && *orig_value)
4882
{
4883
int orig_value_len = strlen (orig_value);
4884
int add_len = strlen (add);
4885
new_value = XMALLOC (char, add_len + orig_value_len + 1);
4886
if (to_end)
4887
{
4888
strcpy (new_value, orig_value);
4889
strcpy (new_value + orig_value_len, add);
4890
}
4891
else
4892
{
4893
strcpy (new_value, add);
4894
strcpy (new_value + add_len, orig_value);
4895
}
4896
}
4897
else
4898
{
4899
new_value = xstrdup (add);
4900
}
4901
return new_value;
4902
}
4903
4904
void
4905
lt_update_exe_path (const char *name, const char *value)
4906
{
4907
lt_debugprintf (__FILE__, __LINE__,
4908
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909
nonnull (name), nonnull (value));
4910
4911
if (name && *name && value && *value)
4912
{
4913
char *new_value = lt_extend_str (getenv (name), value, 0);
4914
/* some systems can't cope with a ':'-terminated path #' */
4915
int len = strlen (new_value);
4916
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4917
{
4918
new_value[len-1] = '\0';
4919
}
4920
lt_setenv (name, new_value);
4921
XFREE (new_value);
4922
}
4923
}
4924
4925
void
4926
lt_update_lib_path (const char *name, const char *value)
4927
{
4928
lt_debugprintf (__FILE__, __LINE__,
4929
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930
nonnull (name), nonnull (value));
4931
4932
if (name && *name && value && *value)
4933
{
4934
char *new_value = lt_extend_str (getenv (name), value, 0);
4935
lt_setenv (name, new_value);
4936
XFREE (new_value);
4937
}
4938
}
4939
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
}
5077
EOF
5078
}
5079
# end: func_emit_cwrapperexe_src
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
5092
# func_mode_link arg...
5093
func_mode_link ()
5094
{
5095
$opt_debug
5096
case $host in
5097
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5098
# It is impossible to link a dll without this setting, and
5099
# we shouldn't force the makefile maintainer to figure out
5100
# which system we are compiling for in order to pass an extra
5101
# flag for every libtool invocation.
5102
# allow_undefined=no
5103
5104
# FIXME: Unfortunately, there are problems with the above when trying
5105
# to make a dll which has undefined symbols, in which case not
5106
# even a static library is built. For now, we need to specify
5107
# -no-undefined on the libtool link line when we can be certain
5108
# that all symbols are satisfied, otherwise we get a static library.
5109
allow_undefined=yes
5110
;;
5111
*)
5112
allow_undefined=yes
5113
;;
5114
esac
5115
libtool_args=$nonopt
5116
base_compile="$nonopt $@"
5117
compile_command=$nonopt
5118
finalize_command=$nonopt
5119
5120
compile_rpath=
5121
finalize_rpath=
5122
compile_shlibpath=
5123
finalize_shlibpath=
5124
convenience=
5125
old_convenience=
5126
deplibs=
5127
old_deplibs=
5128
compiler_flags=
5129
linker_flags=
5130
dllsearchpath=
5131
lib_search_path=`pwd`
5132
inst_prefix_dir=
5133
new_inherited_linker_flags=
5134
5135
avoid_version=no
5136
bindir=
5137
dlfiles=
5138
dlprefiles=
5139
dlself=no
5140
export_dynamic=no
5141
export_symbols=
5142
export_symbols_regex=
5143
generated=
5144
libobjs=
5145
ltlibs=
5146
module=no
5147
no_install=no
5148
objs=
5149
non_pic_objects=
5150
precious_files_regex=
5151
prefer_static_libs=no
5152
preload=no
5153
prev=
5154
prevarg=
5155
release=
5156
rpath=
5157
xrpath=
5158
perm_rpath=
5159
temp_rpath=
5160
thread_safe=no
5161
vinfo=
5162
vinfo_number=no
5163
weak_libs=
5164
single_module="${wl}-single_module"
5165
func_infer_tag $base_compile
5166
5167
# We need to know -static, to get the right output filenames.
5168
for arg
5169
do
5170
case $arg in
5171
-shared)
5172
test "$build_libtool_libs" != yes && \
5173
func_fatal_configuration "can not build a shared library"
5174
build_old_libs=no
5175
break
5176
;;
5177
-all-static | -static | -static-libtool-libs)
5178
case $arg in
5179
-all-static)
5180
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5181
func_warning "complete static linking is impossible in this configuration"
5182
fi
5183
if test -n "$link_static_flag"; then
5184
dlopen_self=$dlopen_self_static
5185
fi
5186
prefer_static_libs=yes
5187
;;
5188
-static)
5189
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5190
dlopen_self=$dlopen_self_static
5191
fi
5192
prefer_static_libs=built
5193
;;
5194
-static-libtool-libs)
5195
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5196
dlopen_self=$dlopen_self_static
5197
fi
5198
prefer_static_libs=yes
5199
;;
5200
esac
5201
build_libtool_libs=no
5202
build_old_libs=yes
5203
break
5204
;;
5205
esac
5206
done
5207
5208
# See if our shared archives depend on static archives.
5209
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5210
5211
# Go through the arguments, transforming them on the way.
5212
while test "$#" -gt 0; do
5213
arg="$1"
5214
shift
5215
func_quote_for_eval "$arg"
5216
qarg=$func_quote_for_eval_unquoted_result
5217
func_append libtool_args " $func_quote_for_eval_result"
5218
5219
# If the previous option needs an argument, assign it.
5220
if test -n "$prev"; then
5221
case $prev in
5222
output)
5223
func_append compile_command " @OUTPUT@"
5224
func_append finalize_command " @OUTPUT@"
5225
;;
5226
esac
5227
5228
case $prev in
5229
bindir)
5230
bindir="$arg"
5231
prev=
5232
continue
5233
;;
5234
dlfiles|dlprefiles)
5235
if test "$preload" = no; then
5236
# Add the symbol object into the linking commands.
5237
func_append compile_command " @SYMFILE@"
5238
func_append finalize_command " @SYMFILE@"
5239
preload=yes
5240
fi
5241
case $arg in
5242
*.la | *.lo) ;; # We handle these cases below.
5243
force)
5244
if test "$dlself" = no; then
5245
dlself=needless
5246
export_dynamic=yes
5247
fi
5248
prev=
5249
continue
5250
;;
5251
self)
5252
if test "$prev" = dlprefiles; then
5253
dlself=yes
5254
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5255
dlself=yes
5256
else
5257
dlself=needless
5258
export_dynamic=yes
5259
fi
5260
prev=
5261
continue
5262
;;
5263
*)
5264
if test "$prev" = dlfiles; then
5265
func_append dlfiles " $arg"
5266
else
5267
func_append dlprefiles " $arg"
5268
fi
5269
prev=
5270
continue
5271
;;
5272
esac
5273
;;
5274
expsyms)
5275
export_symbols="$arg"
5276
test -f "$arg" \
5277
|| func_fatal_error "symbol file \`$arg' does not exist"
5278
prev=
5279
continue
5280
;;
5281
expsyms_regex)
5282
export_symbols_regex="$arg"
5283
prev=
5284
continue
5285
;;
5286
framework)
5287
case $host in
5288
*-*-darwin*)
5289
case "$deplibs " in
5290
*" $qarg.ltframework "*) ;;
5291
*) func_append deplibs " $qarg.ltframework" # this is fixed later
5292
;;
5293
esac
5294
;;
5295
esac
5296
prev=
5297
continue
5298
;;
5299
inst_prefix)
5300
inst_prefix_dir="$arg"
5301
prev=
5302
continue
5303
;;
5304
objectlist)
5305
if test -f "$arg"; then
5306
save_arg=$arg
5307
moreargs=
5308
for fil in `cat "$save_arg"`
5309
do
5310
# func_append moreargs " $fil"
5311
arg=$fil
5312
# A libtool-controlled object.
5313
5314
# Check to see that this really is a libtool object.
5315
if func_lalib_unsafe_p "$arg"; then
5316
pic_object=
5317
non_pic_object=
5318
5319
# Read the .lo file
5320
func_source "$arg"
5321
5322
if test -z "$pic_object" ||
5323
test -z "$non_pic_object" ||
5324
test "$pic_object" = none &&
5325
test "$non_pic_object" = none; then
5326
func_fatal_error "cannot find name of object for \`$arg'"
5327
fi
5328
5329
# Extract subdirectory from the argument.
5330
func_dirname "$arg" "/" ""
5331
xdir="$func_dirname_result"
5332
5333
if test "$pic_object" != none; then
5334
# Prepend the subdirectory the object is found in.
5335
pic_object="$xdir$pic_object"
5336
5337
if test "$prev" = dlfiles; then
5338
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5339
func_append dlfiles " $pic_object"
5340
prev=
5341
continue
5342
else
5343
# If libtool objects are unsupported, then we need to preload.
5344
prev=dlprefiles
5345
fi
5346
fi
5347
5348
# CHECK ME: I think I busted this. -Ossama
5349
if test "$prev" = dlprefiles; then
5350
# Preload the old-style object.
5351
func_append dlprefiles " $pic_object"
5352
prev=
5353
fi
5354
5355
# A PIC object.
5356
func_append libobjs " $pic_object"
5357
arg="$pic_object"
5358
fi
5359
5360
# Non-PIC object.
5361
if test "$non_pic_object" != none; then
5362
# Prepend the subdirectory the object is found in.
5363
non_pic_object="$xdir$non_pic_object"
5364
5365
# A standard non-PIC object
5366
func_append non_pic_objects " $non_pic_object"
5367
if test -z "$pic_object" || test "$pic_object" = none ; then
5368
arg="$non_pic_object"
5369
fi
5370
else
5371
# If the PIC object exists, use it instead.
5372
# $xdir was prepended to $pic_object above.
5373
non_pic_object="$pic_object"
5374
func_append non_pic_objects " $non_pic_object"
5375
fi
5376
else
5377
# Only an error if not doing a dry-run.
5378
if $opt_dry_run; then
5379
# Extract subdirectory from the argument.
5380
func_dirname "$arg" "/" ""
5381
xdir="$func_dirname_result"
5382
5383
func_lo2o "$arg"
5384
pic_object=$xdir$objdir/$func_lo2o_result
5385
non_pic_object=$xdir$func_lo2o_result
5386
func_append libobjs " $pic_object"
5387
func_append non_pic_objects " $non_pic_object"
5388
else
5389
func_fatal_error "\`$arg' is not a valid libtool object"
5390
fi
5391
fi
5392
done
5393
else
5394
func_fatal_error "link input file \`$arg' does not exist"
5395
fi
5396
arg=$save_arg
5397
prev=
5398
continue
5399
;;
5400
precious_regex)
5401
precious_files_regex="$arg"
5402
prev=
5403
continue
5404
;;
5405
release)
5406
release="-$arg"
5407
prev=
5408
continue
5409
;;
5410
rpath | xrpath)
5411
# We need an absolute path.
5412
case $arg in
5413
[\\/]* | [A-Za-z]:[\\/]*) ;;
5414
*)
5415
func_fatal_error "only absolute run-paths are allowed"
5416
;;
5417
esac
5418
if test "$prev" = rpath; then
5419
case "$rpath " in
5420
*" $arg "*) ;;
5421
*) func_append rpath " $arg" ;;
5422
esac
5423
else
5424
case "$xrpath " in
5425
*" $arg "*) ;;
5426
*) func_append xrpath " $arg" ;;
5427
esac
5428
fi
5429
prev=
5430
continue
5431
;;
5432
shrext)
5433
shrext_cmds="$arg"
5434
prev=
5435
continue
5436
;;
5437
weak)
5438
func_append weak_libs " $arg"
5439
prev=
5440
continue
5441
;;
5442
xcclinker)
5443
func_append linker_flags " $qarg"
5444
func_append compiler_flags " $qarg"
5445
prev=
5446
func_append compile_command " $qarg"
5447
func_append finalize_command " $qarg"
5448
continue
5449
;;
5450
xcompiler)
5451
func_append compiler_flags " $qarg"
5452
prev=
5453
func_append compile_command " $qarg"
5454
func_append finalize_command " $qarg"
5455
continue
5456
;;
5457
xlinker)
5458
func_append linker_flags " $qarg"
5459
func_append compiler_flags " $wl$qarg"
5460
prev=
5461
func_append compile_command " $wl$qarg"
5462
func_append finalize_command " $wl$qarg"
5463
continue
5464
;;
5465
*)
5466
eval "$prev=\"\$arg\""
5467
prev=
5468
continue
5469
;;
5470
esac
5471
fi # test -n "$prev"
5472
5473
prevarg="$arg"
5474
5475
case $arg in
5476
-all-static)
5477
if test -n "$link_static_flag"; then
5478
# See comment for -static flag below, for more details.
5479
func_append compile_command " $link_static_flag"
5480
func_append finalize_command " $link_static_flag"
5481
fi
5482
continue
5483
;;
5484
5485
-allow-undefined)
5486
# FIXME: remove this flag sometime in the future.
5487
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5488
;;
5489
5490
-avoid-version)
5491
avoid_version=yes
5492
continue
5493
;;
5494
5495
-bindir)
5496
prev=bindir
5497
continue
5498
;;
5499
5500
-dlopen)
5501
prev=dlfiles
5502
continue
5503
;;
5504
5505
-dlpreopen)
5506
prev=dlprefiles
5507
continue
5508
;;
5509
5510
-export-dynamic)
5511
export_dynamic=yes
5512
continue
5513
;;
5514
5515
-export-symbols | -export-symbols-regex)
5516
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5517
func_fatal_error "more than one -exported-symbols argument is not allowed"
5518
fi
5519
if test "X$arg" = "X-export-symbols"; then
5520
prev=expsyms
5521
else
5522
prev=expsyms_regex
5523
fi
5524
continue
5525
;;
5526
5527
-framework)
5528
prev=framework
5529
continue
5530
;;
5531
5532
-inst-prefix-dir)
5533
prev=inst_prefix
5534
continue
5535
;;
5536
5537
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5538
# so, if we see these flags be careful not to treat them like -L
5539
-L[A-Z][A-Z]*:*)
5540
case $with_gcc/$host in
5541
no/*-*-irix* | /*-*-irix*)
5542
func_append compile_command " $arg"
5543
func_append finalize_command " $arg"
5544
;;
5545
esac
5546
continue
5547
;;
5548
5549
-L*)
5550
func_stripname "-L" '' "$arg"
5551
if test -z "$func_stripname_result"; then
5552
if test "$#" -gt 0; then
5553
func_fatal_error "require no space between \`-L' and \`$1'"
5554
else
5555
func_fatal_error "need path for \`-L' option"
5556
fi
5557
fi
5558
func_resolve_sysroot "$func_stripname_result"
5559
dir=$func_resolve_sysroot_result
5560
# We need an absolute path.
5561
case $dir in
5562
[\\/]* | [A-Za-z]:[\\/]*) ;;
5563
*)
5564
absdir=`cd "$dir" && pwd`
5565
test -z "$absdir" && \
5566
func_fatal_error "cannot determine absolute directory name of \`$dir'"
5567
dir="$absdir"
5568
;;
5569
esac
5570
case "$deplibs " in
5571
*" -L$dir "* | *" $arg "*)
5572
# Will only happen for absolute or sysroot arguments
5573
;;
5574
*)
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"
5581
;;
5582
esac
5583
case $host in
5584
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5585
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5586
case :$dllsearchpath: in
5587
*":$dir:"*) ;;
5588
::) dllsearchpath=$dir;;
5589
*) func_append dllsearchpath ":$dir";;
5590
esac
5591
case :$dllsearchpath: in
5592
*":$testbindir:"*) ;;
5593
::) dllsearchpath=$testbindir;;
5594
*) func_append dllsearchpath ":$testbindir";;
5595
esac
5596
;;
5597
esac
5598
continue
5599
;;
5600
5601
-l*)
5602
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5603
case $host in
5604
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5605
# These systems don't actually have a C or math library (as such)
5606
continue
5607
;;
5608
*-*-os2*)
5609
# These systems don't actually have a C library (as such)
5610
test "X$arg" = "X-lc" && continue
5611
;;
5612
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5613
# Do not include libc due to us having libc/libc_r.
5614
test "X$arg" = "X-lc" && continue
5615
;;
5616
*-*-rhapsody* | *-*-darwin1.[012])
5617
# Rhapsody C and math libraries are in the System framework
5618
func_append deplibs " System.ltframework"
5619
continue
5620
;;
5621
*-*-sco3.2v5* | *-*-sco5v6*)
5622
# Causes problems with __ctype
5623
test "X$arg" = "X-lc" && continue
5624
;;
5625
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5626
# Compiler inserts libc in the correct place for threads to work
5627
test "X$arg" = "X-lc" && continue
5628
;;
5629
esac
5630
elif test "X$arg" = "X-lc_r"; then
5631
case $host in
5632
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5633
# Do not include libc_r directly, use -pthread flag.
5634
continue
5635
;;
5636
esac
5637
fi
5638
func_append deplibs " $arg"
5639
continue
5640
;;
5641
5642
-module)
5643
module=yes
5644
continue
5645
;;
5646
5647
# Tru64 UNIX uses -model [arg] to determine the layout of C++
5648
# classes, name mangling, and exception handling.
5649
# Darwin uses the -arch flag to determine output architecture.
5650
-model|-arch|-isysroot|--sysroot)
5651
func_append compiler_flags " $arg"
5652
func_append compile_command " $arg"
5653
func_append finalize_command " $arg"
5654
prev=xcompiler
5655
continue
5656
;;
5657
5658
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660
func_append compiler_flags " $arg"
5661
func_append compile_command " $arg"
5662
func_append finalize_command " $arg"
5663
case "$new_inherited_linker_flags " in
5664
*" $arg "*) ;;
5665
* ) func_append new_inherited_linker_flags " $arg" ;;
5666
esac
5667
continue
5668
;;
5669
5670
-multi_module)
5671
single_module="${wl}-multi_module"
5672
continue
5673
;;
5674
5675
-no-fast-install)
5676
fast_install=no
5677
continue
5678
;;
5679
5680
-no-install)
5681
case $host in
5682
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5683
# The PATH hackery in wrapper scripts is required on Windows
5684
# and Darwin in order for the loader to find any dlls it needs.
5685
func_warning "\`-no-install' is ignored for $host"
5686
func_warning "assuming \`-no-fast-install' instead"
5687
fast_install=no
5688
;;
5689
*) no_install=yes ;;
5690
esac
5691
continue
5692
;;
5693
5694
-no-undefined)
5695
allow_undefined=no
5696
continue
5697
;;
5698
5699
-objectlist)
5700
prev=objectlist
5701
continue
5702
;;
5703
5704
-o) prev=output ;;
5705
5706
-precious-files-regex)
5707
prev=precious_regex
5708
continue
5709
;;
5710
5711
-release)
5712
prev=release
5713
continue
5714
;;
5715
5716
-rpath)
5717
prev=rpath
5718
continue
5719
;;
5720
5721
-R)
5722
prev=xrpath
5723
continue
5724
;;
5725
5726
-R*)
5727
func_stripname '-R' '' "$arg"
5728
dir=$func_stripname_result
5729
# We need an absolute path.
5730
case $dir in
5731
[\\/]* | [A-Za-z]:[\\/]*) ;;
5732
=*)
5733
func_stripname '=' '' "$dir"
5734
dir=$lt_sysroot$func_stripname_result
5735
;;
5736
*)
5737
func_fatal_error "only absolute run-paths are allowed"
5738
;;
5739
esac
5740
case "$xrpath " in
5741
*" $dir "*) ;;
5742
*) func_append xrpath " $dir" ;;
5743
esac
5744
continue
5745
;;
5746
5747
-shared)
5748
# The effects of -shared are defined in a previous loop.
5749
continue
5750
;;
5751
5752
-shrext)
5753
prev=shrext
5754
continue
5755
;;
5756
5757
-static | -static-libtool-libs)
5758
# The effects of -static are defined in a previous loop.
5759
# We used to do the same as -all-static on platforms that
5760
# didn't have a PIC flag, but the assumption that the effects
5761
# would be equivalent was wrong. It would break on at least
5762
# Digital Unix and AIX.
5763
continue
5764
;;
5765
5766
-thread-safe)
5767
thread_safe=yes
5768
continue
5769
;;
5770
5771
-version-info)
5772
prev=vinfo
5773
continue
5774
;;
5775
5776
-version-number)
5777
prev=vinfo
5778
vinfo_number=yes
5779
continue
5780
;;
5781
5782
-weak)
5783
prev=weak
5784
continue
5785
;;
5786
5787
-Wc,*)
5788
func_stripname '-Wc,' '' "$arg"
5789
args=$func_stripname_result
5790
arg=
5791
save_ifs="$IFS"; IFS=','
5792
for flag in $args; do
5793
IFS="$save_ifs"
5794
func_quote_for_eval "$flag"
5795
func_append arg " $func_quote_for_eval_result"
5796
func_append compiler_flags " $func_quote_for_eval_result"
5797
done
5798
IFS="$save_ifs"
5799
func_stripname ' ' '' "$arg"
5800
arg=$func_stripname_result
5801
;;
5802
5803
-Wl,*)
5804
func_stripname '-Wl,' '' "$arg"
5805
args=$func_stripname_result
5806
arg=
5807
save_ifs="$IFS"; IFS=','
5808
for flag in $args; do
5809
IFS="$save_ifs"
5810
func_quote_for_eval "$flag"
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"
5814
done
5815
IFS="$save_ifs"
5816
func_stripname ' ' '' "$arg"
5817
arg=$func_stripname_result
5818
;;
5819
5820
-Xcompiler)
5821
prev=xcompiler
5822
continue
5823
;;
5824
5825
-Xlinker)
5826
prev=xlinker
5827
continue
5828
;;
5829
5830
-XCClinker)
5831
prev=xcclinker
5832
continue
5833
;;
5834
5835
# -msg_* for osf cc
5836
-msg_*)
5837
func_quote_for_eval "$arg"
5838
arg="$func_quote_for_eval_result"
5839
;;
5840
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
5854
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5855
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5857
func_quote_for_eval "$arg"
5858
arg="$func_quote_for_eval_result"
5859
func_append compile_command " $arg"
5860
func_append finalize_command " $arg"
5861
func_append compiler_flags " $arg"
5862
continue
5863
;;
5864
5865
# Some other compiler flag.
5866
-* | +*)
5867
func_quote_for_eval "$arg"
5868
arg="$func_quote_for_eval_result"
5869
;;
5870
5871
*.$objext)
5872
# A standard object.
5873
func_append objs " $arg"
5874
;;
5875
5876
*.lo)
5877
# A libtool-controlled object.
5878
5879
# Check to see that this really is a libtool object.
5880
if func_lalib_unsafe_p "$arg"; then
5881
pic_object=
5882
non_pic_object=
5883
5884
# Read the .lo file
5885
func_source "$arg"
5886
5887
if test -z "$pic_object" ||
5888
test -z "$non_pic_object" ||
5889
test "$pic_object" = none &&
5890
test "$non_pic_object" = none; then
5891
func_fatal_error "cannot find name of object for \`$arg'"
5892
fi
5893
5894
# Extract subdirectory from the argument.
5895
func_dirname "$arg" "/" ""
5896
xdir="$func_dirname_result"
5897
5898
if test "$pic_object" != none; then
5899
# Prepend the subdirectory the object is found in.
5900
pic_object="$xdir$pic_object"
5901
5902
if test "$prev" = dlfiles; then
5903
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5904
func_append dlfiles " $pic_object"
5905
prev=
5906
continue
5907
else
5908
# If libtool objects are unsupported, then we need to preload.
5909
prev=dlprefiles
5910
fi
5911
fi
5912
5913
# CHECK ME: I think I busted this. -Ossama
5914
if test "$prev" = dlprefiles; then
5915
# Preload the old-style object.
5916
func_append dlprefiles " $pic_object"
5917
prev=
5918
fi
5919
5920
# A PIC object.
5921
func_append libobjs " $pic_object"
5922
arg="$pic_object"
5923
fi
5924
5925
# Non-PIC object.
5926
if test "$non_pic_object" != none; then
5927
# Prepend the subdirectory the object is found in.
5928
non_pic_object="$xdir$non_pic_object"
5929
5930
# A standard non-PIC object
5931
func_append non_pic_objects " $non_pic_object"
5932
if test -z "$pic_object" || test "$pic_object" = none ; then
5933
arg="$non_pic_object"
5934
fi
5935
else
5936
# If the PIC object exists, use it instead.
5937
# $xdir was prepended to $pic_object above.
5938
non_pic_object="$pic_object"
5939
func_append non_pic_objects " $non_pic_object"
5940
fi
5941
else
5942
# Only an error if not doing a dry-run.
5943
if $opt_dry_run; then
5944
# Extract subdirectory from the argument.
5945
func_dirname "$arg" "/" ""
5946
xdir="$func_dirname_result"
5947
5948
func_lo2o "$arg"
5949
pic_object=$xdir$objdir/$func_lo2o_result
5950
non_pic_object=$xdir$func_lo2o_result
5951
func_append libobjs " $pic_object"
5952
func_append non_pic_objects " $non_pic_object"
5953
else
5954
func_fatal_error "\`$arg' is not a valid libtool object"
5955
fi
5956
fi
5957
;;
5958
5959
*.$libext)
5960
# An archive.
5961
func_append deplibs " $arg"
5962
func_append old_deplibs " $arg"
5963
continue
5964
;;
5965
5966
*.la)
5967
# A libtool-controlled library.
5968
5969
func_resolve_sysroot "$arg"
5970
if test "$prev" = dlfiles; then
5971
# This library was specified with -dlopen.
5972
func_append dlfiles " $func_resolve_sysroot_result"
5973
prev=
5974
elif test "$prev" = dlprefiles; then
5975
# The library was specified with -dlpreopen.
5976
func_append dlprefiles " $func_resolve_sysroot_result"
5977
prev=
5978
else
5979
func_append deplibs " $func_resolve_sysroot_result"
5980
fi
5981
continue
5982
;;
5983
5984
# Some other compiler argument.
5985
*)
5986
# Unknown arguments in both finalize_command and compile_command need
5987
# to be aesthetically quoted because they are evaled later.
5988
func_quote_for_eval "$arg"
5989
arg="$func_quote_for_eval_result"
5990
;;
5991
esac # arg
5992
5993
# Now actually substitute the argument into the commands.
5994
if test -n "$arg"; then
5995
func_append compile_command " $arg"
5996
func_append finalize_command " $arg"
5997
fi
5998
done # argument parsing loop
5999
6000
test -n "$prev" && \
6001
func_fatal_help "the \`$prevarg' option requires an argument"
6002
6003
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6004
eval arg=\"$export_dynamic_flag_spec\"
6005
func_append compile_command " $arg"
6006
func_append finalize_command " $arg"
6007
fi
6008
6009
oldlibs=
6010
# calculate the name of the file, without its directory
6011
func_basename "$output"
6012
outputname="$func_basename_result"
6013
libobjs_save="$libobjs"
6014
6015
if test -n "$shlibpath_var"; then
6016
# get the directories listed in $shlibpath_var
6017
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6018
else
6019
shlib_search_path=
6020
fi
6021
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6022
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6023
6024
func_dirname "$output" "/" ""
6025
output_objdir="$func_dirname_result$objdir"
6026
func_to_tool_file "$output_objdir/"
6027
tool_output_objdir=$func_to_tool_file_result
6028
# Create the object directory.
6029
func_mkdir_p "$output_objdir"
6030
6031
# Determine the type of output
6032
case $output in
6033
"")
6034
func_fatal_help "you must specify an output file"
6035
;;
6036
*.$libext) linkmode=oldlib ;;
6037
*.lo | *.$objext) linkmode=obj ;;
6038
*.la) linkmode=lib ;;
6039
*) linkmode=prog ;; # Anything else should be a program.
6040
esac
6041
6042
specialdeplibs=
6043
6044
libs=
6045
# Find all interdependent deplibs by searching for libraries
6046
# that are linked more than once (e.g. -la -lb -la)
6047
for deplib in $deplibs; do
6048
if $opt_preserve_dup_deps ; then
6049
case "$libs " in
6050
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6051
esac
6052
fi
6053
func_append libs " $deplib"
6054
done
6055
6056
if test "$linkmode" = lib; then
6057
libs="$predeps $libs $compiler_lib_search_path $postdeps"
6058
6059
# Compute libraries that are listed more than once in $predeps
6060
# $postdeps and mark them as special (i.e., whose duplicates are
6061
# not to be eliminated).
6062
pre_post_deps=
6063
if $opt_duplicate_compiler_generated_deps; then
6064
for pre_post_dep in $predeps $postdeps; do
6065
case "$pre_post_deps " in
6066
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6067
esac
6068
func_append pre_post_deps " $pre_post_dep"
6069
done
6070
fi
6071
pre_post_deps=
6072
fi
6073
6074
deplibs=
6075
newdependency_libs=
6076
newlib_search_path=
6077
need_relink=no # whether we're linking any uninstalled libtool libraries
6078
notinst_deplibs= # not-installed libtool libraries
6079
notinst_path= # paths that contain not-installed libtool libraries
6080
6081
case $linkmode in
6082
lib)
6083
passes="conv dlpreopen link"
6084
for file in $dlfiles $dlprefiles; do
6085
case $file in
6086
*.la) ;;
6087
*)
6088
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6089
;;
6090
esac
6091
done
6092
;;
6093
prog)
6094
compile_deplibs=
6095
finalize_deplibs=
6096
alldeplibs=no
6097
newdlfiles=
6098
newdlprefiles=
6099
passes="conv scan dlopen dlpreopen link"
6100
;;
6101
*) passes="conv"
6102
;;
6103
esac
6104
6105
for pass in $passes; do
6106
# The preopen pass in lib mode reverses $deplibs; put it back here
6107
# so that -L comes before libs that need it for instance...
6108
if test "$linkmode,$pass" = "lib,link"; then
6109
## FIXME: Find the place where the list is rebuilt in the wrong
6110
## order, and fix it there properly
6111
tmp_deplibs=
6112
for deplib in $deplibs; do
6113
tmp_deplibs="$deplib $tmp_deplibs"
6114
done
6115
deplibs="$tmp_deplibs"
6116
fi
6117
6118
if test "$linkmode,$pass" = "lib,link" ||
6119
test "$linkmode,$pass" = "prog,scan"; then
6120
libs="$deplibs"
6121
deplibs=
6122
fi
6123
if test "$linkmode" = prog; then
6124
case $pass in
6125
dlopen) libs="$dlfiles" ;;
6126
dlpreopen) libs="$dlprefiles" ;;
6127
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6128
esac
6129
fi
6130
if test "$linkmode,$pass" = "lib,dlpreopen"; then
6131
# Collect and forward deplibs of preopened libtool libs
6132
for lib in $dlprefiles; do
6133
# Ignore non-libtool-libs
6134
dependency_libs=
6135
func_resolve_sysroot "$lib"
6136
case $lib in
6137
*.la) func_source "$func_resolve_sysroot_result" ;;
6138
esac
6139
6140
# Collect preopened libtool deplibs, except any this library
6141
# has declared as weak libs
6142
for deplib in $dependency_libs; do
6143
func_basename "$deplib"
6144
deplib_base=$func_basename_result
6145
case " $weak_libs " in
6146
*" $deplib_base "*) ;;
6147
*) func_append deplibs " $deplib" ;;
6148
esac
6149
done
6150
done
6151
libs="$dlprefiles"
6152
fi
6153
if test "$pass" = dlopen; then
6154
# Collect dlpreopened libraries
6155
save_deplibs="$deplibs"
6156
deplibs=
6157
fi
6158
6159
for deplib in $libs; do
6160
lib=
6161
found=no
6162
case $deplib in
6163
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6164
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6165
if test "$linkmode,$pass" = "prog,link"; then
6166
compile_deplibs="$deplib $compile_deplibs"
6167
finalize_deplibs="$deplib $finalize_deplibs"
6168
else
6169
func_append compiler_flags " $deplib"
6170
if test "$linkmode" = lib ; then
6171
case "$new_inherited_linker_flags " in
6172
*" $deplib "*) ;;
6173
* ) func_append new_inherited_linker_flags " $deplib" ;;
6174
esac
6175
fi
6176
fi
6177
continue
6178
;;
6179
-l*)
6180
if test "$linkmode" != lib && test "$linkmode" != prog; then
6181
func_warning "\`-l' is ignored for archives/objects"
6182
continue
6183
fi
6184
func_stripname '-l' '' "$deplib"
6185
name=$func_stripname_result
6186
if test "$linkmode" = lib; then
6187
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6188
else
6189
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6190
fi
6191
for searchdir in $searchdirs; do
6192
for search_ext in .la $std_shrext .so .a; do
6193
# Search the libtool library
6194
lib="$searchdir/lib${name}${search_ext}"
6195
if test -f "$lib"; then
6196
if test "$search_ext" = ".la"; then
6197
found=yes
6198
else
6199
found=no
6200
fi
6201
break 2
6202
fi
6203
done
6204
done
6205
if test "$found" != yes; then
6206
# deplib doesn't seem to be a libtool library
6207
if test "$linkmode,$pass" = "prog,link"; then
6208
compile_deplibs="$deplib $compile_deplibs"
6209
finalize_deplibs="$deplib $finalize_deplibs"
6210
else
6211
deplibs="$deplib $deplibs"
6212
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6213
fi
6214
continue
6215
else # deplib is a libtool library
6216
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6217
# We need to do some special things here, and not later.
6218
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6219
case " $predeps $postdeps " in
6220
*" $deplib "*)
6221
if func_lalib_p "$lib"; then
6222
library_names=
6223
old_library=
6224
func_source "$lib"
6225
for l in $old_library $library_names; do
6226
ll="$l"
6227
done
6228
if test "X$ll" = "X$old_library" ; then # only static version available
6229
found=no
6230
func_dirname "$lib" "" "."
6231
ladir="$func_dirname_result"
6232
lib=$ladir/$old_library
6233
if test "$linkmode,$pass" = "prog,link"; then
6234
compile_deplibs="$deplib $compile_deplibs"
6235
finalize_deplibs="$deplib $finalize_deplibs"
6236
else
6237
deplibs="$deplib $deplibs"
6238
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6239
fi
6240
continue
6241
fi
6242
fi
6243
;;
6244
*) ;;
6245
esac
6246
fi
6247
fi
6248
;; # -l
6249
*.ltframework)
6250
if test "$linkmode,$pass" = "prog,link"; then
6251
compile_deplibs="$deplib $compile_deplibs"
6252
finalize_deplibs="$deplib $finalize_deplibs"
6253
else
6254
deplibs="$deplib $deplibs"
6255
if test "$linkmode" = lib ; then
6256
case "$new_inherited_linker_flags " in
6257
*" $deplib "*) ;;
6258
* ) func_append new_inherited_linker_flags " $deplib" ;;
6259
esac
6260
fi
6261
fi
6262
continue
6263
;;
6264
-L*)
6265
case $linkmode in
6266
lib)
6267
deplibs="$deplib $deplibs"
6268
test "$pass" = conv && continue
6269
newdependency_libs="$deplib $newdependency_libs"
6270
func_stripname '-L' '' "$deplib"
6271
func_resolve_sysroot "$func_stripname_result"
6272
func_append newlib_search_path " $func_resolve_sysroot_result"
6273
;;
6274
prog)
6275
if test "$pass" = conv; then
6276
deplibs="$deplib $deplibs"
6277
continue
6278
fi
6279
if test "$pass" = scan; then
6280
deplibs="$deplib $deplibs"
6281
else
6282
compile_deplibs="$deplib $compile_deplibs"
6283
finalize_deplibs="$deplib $finalize_deplibs"
6284
fi
6285
func_stripname '-L' '' "$deplib"
6286
func_resolve_sysroot "$func_stripname_result"
6287
func_append newlib_search_path " $func_resolve_sysroot_result"
6288
;;
6289
*)
6290
func_warning "\`-L' is ignored for archives/objects"
6291
;;
6292
esac # linkmode
6293
continue
6294
;; # -L
6295
-R*)
6296
if test "$pass" = link; then
6297
func_stripname '-R' '' "$deplib"
6298
func_resolve_sysroot "$func_stripname_result"
6299
dir=$func_resolve_sysroot_result
6300
# Make sure the xrpath contains only unique directories.
6301
case "$xrpath " in
6302
*" $dir "*) ;;
6303
*) func_append xrpath " $dir" ;;
6304
esac
6305
fi
6306
deplibs="$deplib $deplibs"
6307
continue
6308
;;
6309
*.la)
6310
func_resolve_sysroot "$deplib"
6311
lib=$func_resolve_sysroot_result
6312
;;
6313
*.$libext)
6314
if test "$pass" = conv; then
6315
deplibs="$deplib $deplibs"
6316
continue
6317
fi
6318
case $linkmode in
6319
lib)
6320
# Linking convenience modules into shared libraries is allowed,
6321
# but linking other static libraries is non-portable.
6322
case " $dlpreconveniencelibs " in
6323
*" $deplib "*) ;;
6324
*)
6325
valid_a_lib=no
6326
case $deplibs_check_method in
6327
match_pattern*)
6328
set dummy $deplibs_check_method; shift
6329
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6330
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6331
| $EGREP "$match_pattern_regex" > /dev/null; then
6332
valid_a_lib=yes
6333
fi
6334
;;
6335
pass_all)
6336
valid_a_lib=yes
6337
;;
6338
esac
6339
if test "$valid_a_lib" != yes; then
6340
echo
6341
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
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."
6347
else
6348
echo
6349
$ECHO "*** Warning: Linking the shared library $output against the"
6350
$ECHO "*** static library $deplib is not portable!"
6351
deplibs="$deplib $deplibs"
6352
fi
6353
;;
6354
esac
6355
continue
6356
;;
6357
prog)
6358
if test "$pass" != link; then
6359
deplibs="$deplib $deplibs"
6360
else
6361
compile_deplibs="$deplib $compile_deplibs"
6362
finalize_deplibs="$deplib $finalize_deplibs"
6363
fi
6364
continue
6365
;;
6366
esac # linkmode
6367
;; # *.$libext
6368
*.lo | *.$objext)
6369
if test "$pass" = conv; then
6370
deplibs="$deplib $deplibs"
6371
elif test "$linkmode" = prog; then
6372
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6373
# If there is no dlopen support or we're linking statically,
6374
# we need to preload.
6375
func_append newdlprefiles " $deplib"
6376
compile_deplibs="$deplib $compile_deplibs"
6377
finalize_deplibs="$deplib $finalize_deplibs"
6378
else
6379
func_append newdlfiles " $deplib"
6380
fi
6381
fi
6382
continue
6383
;;
6384
%DEPLIBS%)
6385
alldeplibs=yes
6386
continue
6387
;;
6388
esac # case $deplib
6389
6390
if test "$found" = yes || test -f "$lib"; then :
6391
else
6392
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6393
fi
6394
6395
# Check to see that this really is a libtool archive.
6396
func_lalib_unsafe_p "$lib" \
6397
|| func_fatal_error "\`$lib' is not a valid libtool archive"
6398
6399
func_dirname "$lib" "" "."
6400
ladir="$func_dirname_result"
6401
6402
dlname=
6403
dlopen=
6404
dlpreopen=
6405
libdir=
6406
library_names=
6407
old_library=
6408
inherited_linker_flags=
6409
# If the library was installed with an old release of libtool,
6410
# it will not redefine variables installed, or shouldnotlink
6411
installed=yes
6412
shouldnotlink=no
6413
avoidtemprpath=
6414
6415
6416
# Read the .la file
6417
func_source "$lib"
6418
6419
# Convert "-framework foo" to "foo.ltframework"
6420
if test -n "$inherited_linker_flags"; then
6421
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6422
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6423
case " $new_inherited_linker_flags " in
6424
*" $tmp_inherited_linker_flag "*) ;;
6425
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6426
esac
6427
done
6428
fi
6429
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6430
if test "$linkmode,$pass" = "lib,link" ||
6431
test "$linkmode,$pass" = "prog,scan" ||
6432
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
6433
test -n "$dlopen" && func_append dlfiles " $dlopen"
6434
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6435
fi
6436
6437
if test "$pass" = conv; then
6438
# Only check for convenience libraries
6439
deplibs="$lib $deplibs"
6440
if test -z "$libdir"; then
6441
if test -z "$old_library"; then
6442
func_fatal_error "cannot find name of link library for \`$lib'"
6443
fi
6444
# It is a libtool convenience library, so add in its objects.
6445
func_append convenience " $ladir/$objdir/$old_library"
6446
func_append old_convenience " $ladir/$objdir/$old_library"
6447
elif test "$linkmode" != prog && test "$linkmode" != lib; then
6448
func_fatal_error "\`$lib' is not a convenience library"
6449
fi
6450
tmp_libs=
6451
for deplib in $dependency_libs; do
6452
deplibs="$deplib $deplibs"
6453
if $opt_preserve_dup_deps ; then
6454
case "$tmp_libs " in
6455
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6456
esac
6457
fi
6458
func_append tmp_libs " $deplib"
6459
done
6460
continue
6461
fi # $pass = conv
6462
6463
6464
# Get the name of the library we link against.
6465
linklib=
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
6475
if test -z "$linklib"; then
6476
func_fatal_error "cannot find name of link library for \`$lib'"
6477
fi
6478
6479
# This library was specified with -dlopen.
6480
if test "$pass" = dlopen; then
6481
if test -z "$libdir"; then
6482
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6483
fi
6484
if test -z "$dlname" ||
6485
test "$dlopen_support" != yes ||
6486
test "$build_libtool_libs" = no; then
6487
# If there is no dlname, no dlopen support or we're linking
6488
# statically, we need to preload. We also need to preload any
6489
# dependent libraries so libltdl's deplib preloader doesn't
6490
# bomb out in the load deplibs phase.
6491
func_append dlprefiles " $lib $dependency_libs"
6492
else
6493
func_append newdlfiles " $lib"
6494
fi
6495
continue
6496
fi # $pass = dlopen
6497
6498
# We need an absolute path.
6499
case $ladir in
6500
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6501
*)
6502
abs_ladir=`cd "$ladir" && pwd`
6503
if test -z "$abs_ladir"; then
6504
func_warning "cannot determine absolute directory name of \`$ladir'"
6505
func_warning "passing it literally to the linker, although it might fail"
6506
abs_ladir="$ladir"
6507
fi
6508
;;
6509
esac
6510
func_basename "$lib"
6511
laname="$func_basename_result"
6512
6513
# Find the relevant object directory and library name.
6514
if test "X$installed" = Xyes; then
6515
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6516
func_warning "library \`$lib' was moved."
6517
dir="$ladir"
6518
absdir="$abs_ladir"
6519
libdir="$abs_ladir"
6520
else
6521
dir="$lt_sysroot$libdir"
6522
absdir="$lt_sysroot$libdir"
6523
fi
6524
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6525
else
6526
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6527
dir="$ladir"
6528
absdir="$abs_ladir"
6529
# Remove this search path later
6530
func_append notinst_path " $abs_ladir"
6531
else
6532
dir="$ladir/$objdir"
6533
absdir="$abs_ladir/$objdir"
6534
# Remove this search path later
6535
func_append notinst_path " $abs_ladir"
6536
fi
6537
fi # $installed = yes
6538
func_stripname 'lib' '.la' "$laname"
6539
name=$func_stripname_result
6540
6541
# This library was specified with -dlpreopen.
6542
if test "$pass" = dlpreopen; then
6543
if test -z "$libdir" && test "$linkmode" = prog; then
6544
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6545
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
6586
fi # $pass = dlpreopen
6587
6588
if test -z "$libdir"; then
6589
# Link the convenience library
6590
if test "$linkmode" = lib; then
6591
deplibs="$dir/$old_library $deplibs"
6592
elif test "$linkmode,$pass" = "prog,link"; then
6593
compile_deplibs="$dir/$old_library $compile_deplibs"
6594
finalize_deplibs="$dir/$old_library $finalize_deplibs"
6595
else
6596
deplibs="$lib $deplibs" # used for prog,scan pass
6597
fi
6598
continue
6599
fi
6600
6601
6602
if test "$linkmode" = prog && test "$pass" != link; then
6603
func_append newlib_search_path " $ladir"
6604
deplibs="$lib $deplibs"
6605
6606
linkalldeplibs=no
6607
if test "$link_all_deplibs" != no || test -z "$library_names" ||
6608
test "$build_libtool_libs" = no; then
6609
linkalldeplibs=yes
6610
fi
6611
6612
tmp_libs=
6613
for deplib in $dependency_libs; do
6614
case $deplib in
6615
-L*) func_stripname '-L' '' "$deplib"
6616
func_resolve_sysroot "$func_stripname_result"
6617
func_append newlib_search_path " $func_resolve_sysroot_result"
6618
;;
6619
esac
6620
# Need to link against all dependency_libs?
6621
if test "$linkalldeplibs" = yes; then
6622
deplibs="$deplib $deplibs"
6623
else
6624
# Need to hardcode shared library paths
6625
# or/and link against static libraries
6626
newdependency_libs="$deplib $newdependency_libs"
6627
fi
6628
if $opt_preserve_dup_deps ; then
6629
case "$tmp_libs " in
6630
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6631
esac
6632
fi
6633
func_append tmp_libs " $deplib"
6634
done # for deplib
6635
continue
6636
fi # $linkmode = prog...
6637
6638
if test "$linkmode,$pass" = "prog,link"; then
6639
if test -n "$library_names" &&
6640
{ { test "$prefer_static_libs" = no ||
6641
test "$prefer_static_libs,$installed" = "built,yes"; } ||
6642
test -z "$old_library"; }; then
6643
# We need to hardcode the library path
6644
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6645
# Make sure the rpath contains only unique directories.
6646
case "$temp_rpath:" in
6647
*"$absdir:"*) ;;
6648
*) func_append temp_rpath "$absdir:" ;;
6649
esac
6650
fi
6651
6652
# Hardcode the library path.
6653
# Skip directories that are in the system default run-time
6654
# search path.
6655
case " $sys_lib_dlsearch_path " in
6656
*" $absdir "*) ;;
6657
*)
6658
case "$compile_rpath " in
6659
*" $absdir "*) ;;
6660
*) func_append compile_rpath " $absdir" ;;
6661
esac
6662
;;
6663
esac
6664
case " $sys_lib_dlsearch_path " in
6665
*" $libdir "*) ;;
6666
*)
6667
case "$finalize_rpath " in
6668
*" $libdir "*) ;;
6669
*) func_append finalize_rpath " $libdir" ;;
6670
esac
6671
;;
6672
esac
6673
fi # $linkmode,$pass = prog,link...
6674
6675
if test "$alldeplibs" = yes &&
6676
{ test "$deplibs_check_method" = pass_all ||
6677
{ test "$build_libtool_libs" = yes &&
6678
test -n "$library_names"; }; }; then
6679
# We only need to search for static libraries
6680
continue
6681
fi
6682
fi
6683
6684
link_static=no # Whether the deplib will be linked statically
6685
use_static_libs=$prefer_static_libs
6686
if test "$use_static_libs" = built && test "$installed" = yes; then
6687
use_static_libs=no
6688
fi
6689
if test -n "$library_names" &&
6690
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
6691
case $host in
6692
*cygwin* | *mingw* | *cegcc*)
6693
# No point in relinking DLLs because paths are not encoded
6694
func_append notinst_deplibs " $lib"
6695
need_relink=no
6696
;;
6697
*)
6698
if test "$installed" = no; then
6699
func_append notinst_deplibs " $lib"
6700
need_relink=yes
6701
fi
6702
;;
6703
esac
6704
# This is a shared library
6705
6706
# Warn about portability, can't link against -module's on some
6707
# systems (darwin). Don't bleat about dlopened modules though!
6708
dlopenmodule=""
6709
for dlpremoduletest in $dlprefiles; do
6710
if test "X$dlpremoduletest" = "X$lib"; then
6711
dlopenmodule="$dlpremoduletest"
6712
break
6713
fi
6714
done
6715
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6716
echo
6717
if test "$linkmode" = prog; then
6718
$ECHO "*** Warning: Linking the executable $output against the loadable module"
6719
else
6720
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
6721
fi
6722
$ECHO "*** $linklib is not portable!"
6723
fi
6724
if test "$linkmode" = lib &&
6725
test "$hardcode_into_libs" = yes; then
6726
# Hardcode the library path.
6727
# Skip directories that are in the system default run-time
6728
# search path.
6729
case " $sys_lib_dlsearch_path " in
6730
*" $absdir "*) ;;
6731
*)
6732
case "$compile_rpath " in
6733
*" $absdir "*) ;;
6734
*) func_append compile_rpath " $absdir" ;;
6735
esac
6736
;;
6737
esac
6738
case " $sys_lib_dlsearch_path " in
6739
*" $libdir "*) ;;
6740
*)
6741
case "$finalize_rpath " in
6742
*" $libdir "*) ;;
6743
*) func_append finalize_rpath " $libdir" ;;
6744
esac
6745
;;
6746
esac
6747
fi
6748
6749
if test -n "$old_archive_from_expsyms_cmds"; then
6750
# figure out the soname
6751
set dummy $library_names
6752
shift
6753
realname="$1"
6754
shift
6755
libname=`eval "\\$ECHO \"$libname_spec\""`
6756
# use dlname if we got it. it's perfectly good, no?
6757
if test -n "$dlname"; then
6758
soname="$dlname"
6759
elif test -n "$soname_spec"; then
6760
# bleh windows
6761
case $host in
6762
*cygwin* | mingw* | *cegcc*)
6763
func_arith $current - $age
6764
major=$func_arith_result
6765
versuffix="-$major"
6766
;;
6767
esac
6768
eval soname=\"$soname_spec\"
6769
else
6770
soname="$realname"
6771
fi
6772
6773
# Make a new name for the extract_expsyms_cmds to use
6774
soroot="$soname"
6775
func_basename "$soroot"
6776
soname="$func_basename_result"
6777
func_stripname 'lib' '.dll' "$soname"
6778
newlib=libimp-$func_stripname_result.a
6779
6780
# If the library has no export list, then create one now
6781
if test -f "$output_objdir/$soname-def"; then :
6782
else
6783
func_verbose "extracting exported symbol list from \`$soname'"
6784
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6785
fi
6786
6787
# Create $newlib
6788
if test -f "$output_objdir/$newlib"; then :; else
6789
func_verbose "generating import library for \`$soname'"
6790
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6791
fi
6792
# make sure the library variables are pointing to the new library
6793
dir=$output_objdir
6794
linklib=$newlib
6795
fi # test -n "$old_archive_from_expsyms_cmds"
6796
6797
if test "$linkmode" = prog || test "$opt_mode" != relink; then
6798
add_shlibpath=
6799
add_dir=
6800
add=
6801
lib_linked=yes
6802
case $hardcode_action in
6803
immediate | unsupported)
6804
if test "$hardcode_direct" = no; then
6805
add="$dir/$linklib"
6806
case $host in
6807
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6808
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
6809
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6810
*-*-unixware7*) add_dir="-L$dir" ;;
6811
*-*-darwin* )
6812
# if the lib is a (non-dlopened) module then we can not
6813
# link against it, someone is ignoring the earlier warnings
6814
if /usr/bin/file -L $add 2> /dev/null |
6815
$GREP ": [^:]* bundle" >/dev/null ; then
6816
if test "X$dlopenmodule" != "X$lib"; then
6817
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6818
if test -z "$old_library" ; then
6819
echo
6820
echo "*** And there doesn't seem to be a static archive available"
6821
echo "*** The link will probably fail, sorry"
6822
else
6823
add="$dir/$old_library"
6824
fi
6825
elif test -n "$old_library"; then
6826
add="$dir/$old_library"
6827
fi
6828
fi
6829
esac
6830
elif test "$hardcode_minus_L" = no; then
6831
case $host in
6832
*-*-sunos*) add_shlibpath="$dir" ;;
6833
esac
6834
add_dir="-L$dir"
6835
add="-l$name"
6836
elif test "$hardcode_shlibpath_var" = no; then
6837
add_shlibpath="$dir"
6838
add="-l$name"
6839
else
6840
lib_linked=no
6841
fi
6842
;;
6843
relink)
6844
if test "$hardcode_direct" = yes &&
6845
test "$hardcode_direct_absolute" = no; then
6846
add="$dir/$linklib"
6847
elif test "$hardcode_minus_L" = yes; then
6848
add_dir="-L$absdir"
6849
# Try looking first in the location we're being installed to.
6850
if test -n "$inst_prefix_dir"; then
6851
case $libdir in
6852
[\\/]*)
6853
func_append add_dir " -L$inst_prefix_dir$libdir"
6854
;;
6855
esac
6856
fi
6857
add="-l$name"
6858
elif test "$hardcode_shlibpath_var" = yes; then
6859
add_shlibpath="$dir"
6860
add="-l$name"
6861
else
6862
lib_linked=no
6863
fi
6864
;;
6865
*) lib_linked=no ;;
6866
esac
6867
6868
if test "$lib_linked" != yes; then
6869
func_fatal_configuration "unsupported hardcode properties"
6870
fi
6871
6872
if test -n "$add_shlibpath"; then
6873
case :$compile_shlibpath: in
6874
*":$add_shlibpath:"*) ;;
6875
*) func_append compile_shlibpath "$add_shlibpath:" ;;
6876
esac
6877
fi
6878
if test "$linkmode" = prog; then
6879
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6880
test -n "$add" && compile_deplibs="$add $compile_deplibs"
6881
else
6882
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6883
test -n "$add" && deplibs="$add $deplibs"
6884
if test "$hardcode_direct" != yes &&
6885
test "$hardcode_minus_L" != yes &&
6886
test "$hardcode_shlibpath_var" = yes; then
6887
case :$finalize_shlibpath: in
6888
*":$libdir:"*) ;;
6889
*) func_append finalize_shlibpath "$libdir:" ;;
6890
esac
6891
fi
6892
fi
6893
fi
6894
6895
if test "$linkmode" = prog || test "$opt_mode" = relink; then
6896
add_shlibpath=
6897
add_dir=
6898
add=
6899
# Finalize command for both is simple: just hardcode it.
6900
if test "$hardcode_direct" = yes &&
6901
test "$hardcode_direct_absolute" = no; then
6902
add="$libdir/$linklib"
6903
elif test "$hardcode_minus_L" = yes; then
6904
add_dir="-L$libdir"
6905
add="-l$name"
6906
elif test "$hardcode_shlibpath_var" = yes; then
6907
case :$finalize_shlibpath: in
6908
*":$libdir:"*) ;;
6909
*) func_append finalize_shlibpath "$libdir:" ;;
6910
esac
6911
add="-l$name"
6912
elif test "$hardcode_automatic" = yes; then
6913
if test -n "$inst_prefix_dir" &&
6914
test -f "$inst_prefix_dir$libdir/$linklib" ; then
6915
add="$inst_prefix_dir$libdir/$linklib"
6916
else
6917
add="$libdir/$linklib"
6918
fi
6919
else
6920
# We cannot seem to hardcode it, guess we'll fake it.
6921
add_dir="-L$libdir"
6922
# Try looking first in the location we're being installed to.
6923
if test -n "$inst_prefix_dir"; then
6924
case $libdir in
6925
[\\/]*)
6926
func_append add_dir " -L$inst_prefix_dir$libdir"
6927
;;
6928
esac
6929
fi
6930
add="-l$name"
6931
fi
6932
6933
if test "$linkmode" = prog; then
6934
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6935
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6936
else
6937
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6938
test -n "$add" && deplibs="$add $deplibs"
6939
fi
6940
fi
6941
elif test "$linkmode" = prog; then
6942
# Here we assume that one of hardcode_direct or hardcode_minus_L
6943
# is not unsupported. This is valid on all known static and
6944
# shared platforms.
6945
if test "$hardcode_direct" != unsupported; then
6946
test -n "$old_library" && linklib="$old_library"
6947
compile_deplibs="$dir/$linklib $compile_deplibs"
6948
finalize_deplibs="$dir/$linklib $finalize_deplibs"
6949
else
6950
compile_deplibs="-l$name -L$dir $compile_deplibs"
6951
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6952
fi
6953
elif test "$build_libtool_libs" = yes; then
6954
# Not a shared library
6955
if test "$deplibs_check_method" != pass_all; then
6956
# We're trying link a shared library against a static one
6957
# but the system doesn't support it.
6958
6959
# Just print a warning and add the library to dependency_libs so
6960
# that the program can be linked against the static library.
6961
echo
6962
$ECHO "*** Warning: This system can not link to static lib archive $lib."
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."
6966
if test "$module" = yes; then
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."
6970
if test -z "$global_symbol_pipe"; then
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."
6976
fi
6977
if test "$build_old_libs" = no; then
6978
build_libtool_libs=module
6979
build_old_libs=yes
6980
else
6981
build_libtool_libs=no
6982
fi
6983
fi
6984
else
6985
deplibs="$dir/$old_library $deplibs"
6986
link_static=yes
6987
fi
6988
fi # link shared/static library?
6989
6990
if test "$linkmode" = lib; then
6991
if test -n "$dependency_libs" &&
6992
{ test "$hardcode_into_libs" != yes ||
6993
test "$build_old_libs" = yes ||
6994
test "$link_static" = yes; }; then
6995
# Extract -R from dependency_libs
6996
temp_deplibs=
6997
for libdir in $dependency_libs; do
6998
case $libdir in
6999
-R*) func_stripname '-R' '' "$libdir"
7000
temp_xrpath=$func_stripname_result
7001
case " $xrpath " in
7002
*" $temp_xrpath "*) ;;
7003
*) func_append xrpath " $temp_xrpath";;
7004
esac;;
7005
*) func_append temp_deplibs " $libdir";;
7006
esac
7007
done
7008
dependency_libs="$temp_deplibs"
7009
fi
7010
7011
func_append newlib_search_path " $absdir"
7012
# Link against this library
7013
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7014
# ... and its dependency_libs
7015
tmp_libs=
7016
for deplib in $dependency_libs; do
7017
newdependency_libs="$deplib $newdependency_libs"
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
7024
case "$tmp_libs " in
7025
*" $func_resolve_sysroot_result "*)
7026
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7027
esac
7028
fi
7029
func_append tmp_libs " $func_resolve_sysroot_result"
7030
done
7031
7032
if test "$link_all_deplibs" != no; then
7033
# Add the search paths of all dependency libraries
7034
for deplib in $dependency_libs; do
7035
path=
7036
case $deplib in
7037
-L*) path="$deplib" ;;
7038
*.la)
7039
func_resolve_sysroot "$deplib"
7040
deplib=$func_resolve_sysroot_result
7041
func_dirname "$deplib" "" "."
7042
dir=$func_dirname_result
7043
# We need an absolute path.
7044
case $dir in
7045
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7046
*)
7047
absdir=`cd "$dir" && pwd`
7048
if test -z "$absdir"; then
7049
func_warning "cannot determine absolute directory name of \`$dir'"
7050
absdir="$dir"
7051
fi
7052
;;
7053
esac
7054
if $GREP "^installed=no" $deplib > /dev/null; then
7055
case $host in
7056
*-*-darwin*)
7057
depdepl=
7058
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7059
if test -n "$deplibrary_names" ; then
7060
for tmp in $deplibrary_names ; do
7061
depdepl=$tmp
7062
done
7063
if test -f "$absdir/$objdir/$depdepl" ; then
7064
depdepl="$absdir/$objdir/$depdepl"
7065
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7066
if test -z "$darwin_install_name"; then
7067
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7068
fi
7069
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7070
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7071
path=
7072
fi
7073
fi
7074
;;
7075
*)
7076
path="-L$absdir/$objdir"
7077
;;
7078
esac
7079
else
7080
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7081
test -z "$libdir" && \
7082
func_fatal_error "\`$deplib' is not a valid libtool archive"
7083
test "$absdir" != "$libdir" && \
7084
func_warning "\`$deplib' seems to be moved"
7085
7086
path="-L$absdir"
7087
fi
7088
;;
7089
esac
7090
case " $deplibs " in
7091
*" $path "*) ;;
7092
*) deplibs="$path $deplibs" ;;
7093
esac
7094
done
7095
fi # link_all_deplibs != no
7096
fi # linkmode = lib
7097
done # for deplib in $libs
7098
if test "$pass" = link; then
7099
if test "$linkmode" = "prog"; then
7100
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7101
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7102
else
7103
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7104
fi
7105
fi
7106
dependency_libs="$newdependency_libs"
7107
if test "$pass" = dlpreopen; then
7108
# Link the dlpreopened libraries before other libraries
7109
for deplib in $save_deplibs; do
7110
deplibs="$deplib $deplibs"
7111
done
7112
fi
7113
if test "$pass" != dlopen; then
7114
if test "$pass" != conv; then
7115
# Make sure lib_search_path contains only unique directories.
7116
lib_search_path=
7117
for dir in $newlib_search_path; do
7118
case "$lib_search_path " in
7119
*" $dir "*) ;;
7120
*) func_append lib_search_path " $dir" ;;
7121
esac
7122
done
7123
newlib_search_path=
7124
fi
7125
7126
if test "$linkmode,$pass" != "prog,link"; then
7127
vars="deplibs"
7128
else
7129
vars="compile_deplibs finalize_deplibs"
7130
fi
7131
for var in $vars dependency_libs; do
7132
# Add libraries to $var in reverse order
7133
eval tmp_libs=\"\$$var\"
7134
new_libs=
7135
for deplib in $tmp_libs; do
7136
# FIXME: Pedantically, this is the right thing to do, so
7137
# that some nasty dependency loop isn't accidentally
7138
# broken:
7139
#new_libs="$deplib $new_libs"
7140
# Pragmatically, this seems to cause very few problems in
7141
# practice:
7142
case $deplib in
7143
-L*) new_libs="$deplib $new_libs" ;;
7144
-R*) ;;
7145
*)
7146
# And here is the reason: when a library appears more
7147
# than once as an explicit dependence of a library, or
7148
# is implicitly linked in more than once by the
7149
# compiler, it is considered special, and multiple
7150
# occurrences thereof are not removed. Compare this
7151
# with having the same library being listed as a
7152
# dependency of multiple other libraries: in this case,
7153
# we know (pedantically, we assume) the library does not
7154
# need to be listed more than once, so we keep only the
7155
# last copy. This is not always right, but it is rare
7156
# enough that we require users that really mean to play
7157
# such unportable linking tricks to link the library
7158
# using -Wl,-lname, so that libtool does not consider it
7159
# for duplicate removal.
7160
case " $specialdeplibs " in
7161
*" $deplib "*) new_libs="$deplib $new_libs" ;;
7162
*)
7163
case " $new_libs " in
7164
*" $deplib "*) ;;
7165
*) new_libs="$deplib $new_libs" ;;
7166
esac
7167
;;
7168
esac
7169
;;
7170
esac
7171
done
7172
tmp_libs=
7173
for deplib in $new_libs; do
7174
case $deplib in
7175
-L*)
7176
case " $tmp_libs " in
7177
*" $deplib "*) ;;
7178
*) func_append tmp_libs " $deplib" ;;
7179
esac
7180
;;
7181
*) func_append tmp_libs " $deplib" ;;
7182
esac
7183
done
7184
eval $var=\"$tmp_libs\"
7185
done # for var
7186
fi
7187
# Last step: remove runtime libs from dependency_libs
7188
# (they stay in deplibs)
7189
tmp_libs=
7190
for i in $dependency_libs ; do
7191
case " $predeps $postdeps $compiler_lib_search_path " in
7192
*" $i "*)
7193
i=""
7194
;;
7195
esac
7196
if test -n "$i" ; then
7197
func_append tmp_libs " $i"
7198
fi
7199
done
7200
dependency_libs=$tmp_libs
7201
done # for pass
7202
if test "$linkmode" = prog; then
7203
dlfiles="$newdlfiles"
7204
fi
7205
if test "$linkmode" = prog || test "$linkmode" = lib; then
7206
dlprefiles="$newdlprefiles"
7207
fi
7208
7209
case $linkmode in
7210
oldlib)
7211
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7212
func_warning "\`-dlopen' is ignored for archives"
7213
fi
7214
7215
case " $deplibs" in
7216
*\ -l* | *\ -L*)
7217
func_warning "\`-l' and \`-L' are ignored for archives" ;;
7218
esac
7219
7220
test -n "$rpath" && \
7221
func_warning "\`-rpath' is ignored for archives"
7222
7223
test -n "$xrpath" && \
7224
func_warning "\`-R' is ignored for archives"
7225
7226
test -n "$vinfo" && \
7227
func_warning "\`-version-info/-version-number' is ignored for archives"
7228
7229
test -n "$release" && \
7230
func_warning "\`-release' is ignored for archives"
7231
7232
test -n "$export_symbols$export_symbols_regex" && \
7233
func_warning "\`-export-symbols' is ignored for archives"
7234
7235
# Now set the variables for building old libraries.
7236
build_libtool_libs=no
7237
oldlibs="$output"
7238
func_append objs "$old_deplibs"
7239
;;
7240
7241
lib)
7242
# Make sure we only generate libraries of the form `libNAME.la'.
7243
case $outputname in
7244
lib*)
7245
func_stripname 'lib' '.la' "$outputname"
7246
name=$func_stripname_result
7247
eval shared_ext=\"$shrext_cmds\"
7248
eval libname=\"$libname_spec\"
7249
;;
7250
*)
7251
test "$module" = no && \
7252
func_fatal_help "libtool library \`$output' must begin with \`lib'"
7253
7254
if test "$need_lib_prefix" != no; then
7255
# Add the "lib" prefix for modules if required
7256
func_stripname '' '.la' "$outputname"
7257
name=$func_stripname_result
7258
eval shared_ext=\"$shrext_cmds\"
7259
eval libname=\"$libname_spec\"
7260
else
7261
func_stripname '' '.la' "$outputname"
7262
libname=$func_stripname_result
7263
fi
7264
;;
7265
esac
7266
7267
if test -n "$objs"; then
7268
if test "$deplibs_check_method" != pass_all; then
7269
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7270
else
7271
echo
7272
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7273
$ECHO "*** objects $objs is not portable!"
7274
func_append libobjs " $objs"
7275
fi
7276
fi
7277
7278
test "$dlself" != no && \
7279
func_warning "\`-dlopen self' is ignored for libtool libraries"
7280
7281
set dummy $rpath
7282
shift
7283
test "$#" -gt 1 && \
7284
func_warning "ignoring multiple \`-rpath's for a libtool library"
7285
7286
install_libdir="$1"
7287
7288
oldlibs=
7289
if test -z "$rpath"; then
7290
if test "$build_libtool_libs" = yes; then
7291
# Building a libtool convenience library.
7292
# Some compilers have problems with a `.al' extension so
7293
# convenience libraries should have the same extension an
7294
# archive normally would.
7295
oldlibs="$output_objdir/$libname.$libext $oldlibs"
7296
build_libtool_libs=convenience
7297
build_old_libs=yes
7298
fi
7299
7300
test -n "$vinfo" && \
7301
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7302
7303
test -n "$release" && \
7304
func_warning "\`-release' is ignored for convenience libraries"
7305
else
7306
7307
# Parse the version information argument.
7308
save_ifs="$IFS"; IFS=':'
7309
set dummy $vinfo 0 0 0
7310
shift
7311
IFS="$save_ifs"
7312
7313
test -n "$7" && \
7314
func_fatal_help "too many parameters to \`-version-info'"
7315
7316
# convert absolute version numbers to libtool ages
7317
# this retains compatibility with .la files and attempts
7318
# to make the code below a bit more comprehensible
7319
7320
case $vinfo_number in
7321
yes)
7322
number_major="$1"
7323
number_minor="$2"
7324
number_revision="$3"
7325
#
7326
# There are really only two kinds -- those that
7327
# use the current revision as the major version
7328
# and those that subtract age and use age as
7329
# a minor version. But, then there is irix
7330
# which has an extra 1 added just for fun
7331
#
7332
case $version_type in
7333
# correct linux to gnu/linux during the next big refactor
7334
darwin|linux|osf|windows|none)
7335
func_arith $number_major + $number_minor
7336
current=$func_arith_result
7337
age="$number_minor"
7338
revision="$number_revision"
7339
;;
7340
freebsd-aout|freebsd-elf|qnx|sunos)
7341
current="$number_major"
7342
revision="$number_minor"
7343
age="0"
7344
;;
7345
irix|nonstopux)
7346
func_arith $number_major + $number_minor
7347
current=$func_arith_result
7348
age="$number_minor"
7349
revision="$number_minor"
7350
lt_irix_increment=no
7351
;;
7352
esac
7353
;;
7354
no)
7355
current="$1"
7356
revision="$2"
7357
age="$3"
7358
;;
7359
esac
7360
7361
# Check that each of the things are valid numbers.
7362
case $current in
7363
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
7364
*)
7365
func_error "CURRENT \`$current' must be a nonnegative integer"
7366
func_fatal_error "\`$vinfo' is not valid version information"
7367
;;
7368
esac
7369
7370
case $revision in
7371
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
7372
*)
7373
func_error "REVISION \`$revision' must be a nonnegative integer"
7374
func_fatal_error "\`$vinfo' is not valid version information"
7375
;;
7376
esac
7377
7378
case $age in
7379
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
7380
*)
7381
func_error "AGE \`$age' must be a nonnegative integer"
7382
func_fatal_error "\`$vinfo' is not valid version information"
7383
;;
7384
esac
7385
7386
if test "$age" -gt "$current"; then
7387
func_error "AGE \`$age' is greater than the current interface number \`$current'"
7388
func_fatal_error "\`$vinfo' is not valid version information"
7389
fi
7390
7391
# Calculate the version variables.
7392
major=
7393
versuffix=
7394
verstring=
7395
case $version_type in
7396
none) ;;
7397
7398
darwin)
7399
# Like Linux, but with the current version available in
7400
# verstring for coding it into the library header
7401
func_arith $current - $age
7402
major=.$func_arith_result
7403
versuffix="$major.$age.$revision"
7404
# Darwin ld doesn't like 0 for these options...
7405
func_arith $current + 1
7406
minor_current=$func_arith_result
7407
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7408
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7409
;;
7410
7411
freebsd-aout)
7412
major=".$current"
7413
versuffix=".$current.$revision";
7414
;;
7415
7416
freebsd-elf)
7417
major=".$current"
7418
versuffix=".$current"
7419
;;
7420
7421
irix | nonstopux)
7422
if test "X$lt_irix_increment" = "Xno"; then
7423
func_arith $current - $age
7424
else
7425
func_arith $current - $age + 1
7426
fi
7427
major=$func_arith_result
7428
7429
case $version_type in
7430
nonstopux) verstring_prefix=nonstopux ;;
7431
*) verstring_prefix=sgi ;;
7432
esac
7433
verstring="$verstring_prefix$major.$revision"
7434
7435
# Add in all the interfaces that we are compatible with.
7436
loop=$revision
7437
while test "$loop" -ne 0; do
7438
func_arith $revision - $loop
7439
iface=$func_arith_result
7440
func_arith $loop - 1
7441
loop=$func_arith_result
7442
verstring="$verstring_prefix$major.$iface:$verstring"
7443
done
7444
7445
# Before this point, $major must not contain `.'.
7446
major=.$major
7447
versuffix="$major.$revision"
7448
;;
7449
7450
linux) # correct to gnu/linux during the next big refactor
7451
func_arith $current - $age
7452
major=.$func_arith_result
7453
versuffix="$major.$age.$revision"
7454
;;
7455
7456
osf)
7457
func_arith $current - $age
7458
major=.$func_arith_result
7459
versuffix=".$current.$age.$revision"
7460
verstring="$current.$age.$revision"
7461
7462
# Add in all the interfaces that we are compatible with.
7463
loop=$age
7464
while test "$loop" -ne 0; do
7465
func_arith $current - $loop
7466
iface=$func_arith_result
7467
func_arith $loop - 1
7468
loop=$func_arith_result
7469
verstring="$verstring:${iface}.0"
7470
done
7471
7472
# Make executables depend on our current version.
7473
func_append verstring ":${current}.0"
7474
;;
7475
7476
qnx)
7477
major=".$current"
7478
versuffix=".$current"
7479
;;
7480
7481
sunos)
7482
major=".$current"
7483
versuffix=".$current.$revision"
7484
;;
7485
7486
windows)
7487
# Use '-' rather than '.', since we only want one
7488
# extension on DOS 8.3 filesystems.
7489
func_arith $current - $age
7490
major=$func_arith_result
7491
versuffix="-$major"
7492
;;
7493
7494
*)
7495
func_fatal_configuration "unknown library version type \`$version_type'"
7496
;;
7497
esac
7498
7499
# Clear the version info if we defaulted, and they specified a release.
7500
if test -z "$vinfo" && test -n "$release"; then
7501
major=
7502
case $version_type in
7503
darwin)
7504
# we can't check for "0.0" in archive_cmds due to quoting
7505
# problems, so we reset it completely
7506
verstring=
7507
;;
7508
*)
7509
verstring="0.0"
7510
;;
7511
esac
7512
if test "$need_version" = no; then
7513
versuffix=
7514
else
7515
versuffix=".0.0"
7516
fi
7517
fi
7518
7519
# Remove version info from name if versioning should be avoided
7520
if test "$avoid_version" = yes && test "$need_version" = no; then
7521
major=
7522
versuffix=
7523
verstring=""
7524
fi
7525
7526
# Check to see if the archive will have undefined symbols.
7527
if test "$allow_undefined" = yes; then
7528
if test "$allow_undefined_flag" = unsupported; then
7529
func_warning "undefined symbols not allowed in $host shared libraries"
7530
build_libtool_libs=no
7531
build_old_libs=yes
7532
fi
7533
else
7534
# Don't allow undefined symbols.
7535
allow_undefined_flag="$no_undefined_flag"
7536
fi
7537
7538
fi
7539
7540
func_generate_dlsyms "$libname" "$libname" "yes"
7541
func_append libobjs " $symfileobj"
7542
test "X$libobjs" = "X " && libobjs=
7543
7544
if test "$opt_mode" != relink; then
7545
# Remove our outputs, but don't remove object files since they
7546
# may have been created when compiling PIC objects.
7547
removelist=
7548
tempremovelist=`$ECHO "$output_objdir/*"`
7549
for p in $tempremovelist; do
7550
case $p in
7551
*.$objext | *.gcno)
7552
;;
7553
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7554
if test "X$precious_files_regex" != "X"; then
7555
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7556
then
7557
continue
7558
fi
7559
fi
7560
func_append removelist " $p"
7561
;;
7562
*) ;;
7563
esac
7564
done
7565
test -n "$removelist" && \
7566
func_show_eval "${RM}r \$removelist"
7567
fi
7568
7569
# Now set the variables for building old libraries.
7570
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7571
func_append oldlibs " $output_objdir/$libname.$libext"
7572
7573
# Transform .lo files to .o files.
7574
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7575
fi
7576
7577
# Eliminate all temporary directories.
7578
#for path in $notinst_path; do
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"`
7582
#done
7583
7584
if test -n "$xrpath"; then
7585
# If the user specified any rpath flags, then add them.
7586
temp_xrpath=
7587
for libdir in $xrpath; do
7588
func_replace_sysroot "$libdir"
7589
func_append temp_xrpath " -R$func_replace_sysroot_result"
7590
case "$finalize_rpath " in
7591
*" $libdir "*) ;;
7592
*) func_append finalize_rpath " $libdir" ;;
7593
esac
7594
done
7595
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7596
dependency_libs="$temp_xrpath $dependency_libs"
7597
fi
7598
fi
7599
7600
# Make sure dlfiles contains only unique files that won't be dlpreopened
7601
old_dlfiles="$dlfiles"
7602
dlfiles=
7603
for lib in $old_dlfiles; do
7604
case " $dlprefiles $dlfiles " in
7605
*" $lib "*) ;;
7606
*) func_append dlfiles " $lib" ;;
7607
esac
7608
done
7609
7610
# Make sure dlprefiles contains only unique files
7611
old_dlprefiles="$dlprefiles"
7612
dlprefiles=
7613
for lib in $old_dlprefiles; do
7614
case "$dlprefiles " in
7615
*" $lib "*) ;;
7616
*) func_append dlprefiles " $lib" ;;
7617
esac
7618
done
7619
7620
if test "$build_libtool_libs" = yes; then
7621
if test -n "$rpath"; then
7622
case $host in
7623
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7624
# these systems don't actually have a c library (as such)!
7625
;;
7626
*-*-rhapsody* | *-*-darwin1.[012])
7627
# Rhapsody C library is in the System framework
7628
func_append deplibs " System.ltframework"
7629
;;
7630
*-*-netbsd*)
7631
# Don't link with libc until the a.out ld.so is fixed.
7632
;;
7633
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7634
# Do not include libc due to us having libc/libc_r.
7635
;;
7636
*-*-sco3.2v5* | *-*-sco5v6*)
7637
# Causes problems with __ctype
7638
;;
7639
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7640
# Compiler inserts libc in the correct place for threads to work
7641
;;
7642
*)
7643
# Add libc to deplibs on all other systems if necessary.
7644
if test "$build_libtool_need_lc" = "yes"; then
7645
func_append deplibs " -lc"
7646
fi
7647
;;
7648
esac
7649
fi
7650
7651
# Transform deplibs into only deplibs that can be linked in shared.
7652
name_save=$name
7653
libname_save=$libname
7654
release_save=$release
7655
versuffix_save=$versuffix
7656
major_save=$major
7657
# I'm not sure if I'm treating the release correctly. I think
7658
# release should show up in the -l (ie -lgmp5) so we don't want to
7659
# add it in twice. Is that correct?
7660
release=""
7661
versuffix=""
7662
major=""
7663
newdeplibs=
7664
droppeddeps=no
7665
case $deplibs_check_method in
7666
pass_all)
7667
# Don't check for shared/static. Everything works.
7668
# This might be a little naive. We might want to check
7669
# whether the library exists or not. But this is on
7670
# osf3 & osf4 and I'm not really sure... Just
7671
# implementing what was already the behavior.
7672
newdeplibs=$deplibs
7673
;;
7674
test_compile)
7675
# This code stresses the "libraries are programs" paradigm to its
7676
# limits. Maybe even breaks it. We compile a program, linking it
7677
# against the deplibs as a proxy for the library. Then we can check
7678
# whether they linked in statically or dynamically with ldd.
7679
$opt_dry_run || $RM conftest.c
7680
cat > conftest.c <<EOF
7681
int main() { return 0; }
7682
EOF
7683
$opt_dry_run || $RM conftest
7684
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7685
ldd_output=`ldd conftest`
7686
for i in $deplibs; do
7687
case $i in
7688
-l*)
7689
func_stripname -l '' "$i"
7690
name=$func_stripname_result
7691
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7692
case " $predeps $postdeps " in
7693
*" $i "*)
7694
func_append newdeplibs " $i"
7695
i=""
7696
;;
7697
esac
7698
fi
7699
if test -n "$i" ; then
7700
libname=`eval "\\$ECHO \"$libname_spec\""`
7701
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7702
set dummy $deplib_matches; shift
7703
deplib_match=$1
7704
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7705
func_append newdeplibs " $i"
7706
else
7707
droppeddeps=yes
7708
echo
7709
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
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."
7715
fi
7716
fi
7717
;;
7718
*)
7719
func_append newdeplibs " $i"
7720
;;
7721
esac
7722
done
7723
else
7724
# Error occurred in the first compile. Let's try to salvage
7725
# the situation: Compile a separate program for each library.
7726
for i in $deplibs; do
7727
case $i in
7728
-l*)
7729
func_stripname -l '' "$i"
7730
name=$func_stripname_result
7731
$opt_dry_run || $RM conftest
7732
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7733
ldd_output=`ldd conftest`
7734
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7735
case " $predeps $postdeps " in
7736
*" $i "*)
7737
func_append newdeplibs " $i"
7738
i=""
7739
;;
7740
esac
7741
fi
7742
if test -n "$i" ; then
7743
libname=`eval "\\$ECHO \"$libname_spec\""`
7744
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7745
set dummy $deplib_matches; shift
7746
deplib_match=$1
7747
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7748
func_append newdeplibs " $i"
7749
else
7750
droppeddeps=yes
7751
echo
7752
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
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."
7758
fi
7759
fi
7760
else
7761
droppeddeps=yes
7762
echo
7763
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
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."
7767
fi
7768
;;
7769
*)
7770
func_append newdeplibs " $i"
7771
;;
7772
esac
7773
done
7774
fi
7775
;;
7776
file_magic*)
7777
set dummy $deplibs_check_method; shift
7778
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7779
for a_deplib in $deplibs; do
7780
case $a_deplib in
7781
-l*)
7782
func_stripname -l '' "$a_deplib"
7783
name=$func_stripname_result
7784
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7785
case " $predeps $postdeps " in
7786
*" $a_deplib "*)
7787
func_append newdeplibs " $a_deplib"
7788
a_deplib=""
7789
;;
7790
esac
7791
fi
7792
if test -n "$a_deplib" ; then
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`
7800
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
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
7808
for potent_lib in $potential_libs; do
7809
# Follow soft links.
7810
if ls -lLd "$potent_lib" 2>/dev/null |
7811
$GREP " -> " >/dev/null; then
7812
continue
7813
fi
7814
# The statement above tries to avoid entering an
7815
# endless loop below, in case of cyclic links.
7816
# We might still enter an endless loop, since a link
7817
# loop can be closed while we follow links,
7818
# but so what?
7819
potlib="$potent_lib"
7820
while test -h "$potlib" 2>/dev/null; do
7821
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7822
case $potliblink in
7823
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7824
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7825
esac
7826
done
7827
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7828
$SED -e 10q |
7829
$EGREP "$file_magic_regex" > /dev/null; then
7830
func_append newdeplibs " $a_deplib"
7831
a_deplib=""
7832
break 2
7833
fi
7834
done
7835
done
7836
fi
7837
if test -n "$a_deplib" ; then
7838
droppeddeps=yes
7839
echo
7840
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
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"
7845
if test -z "$potlib" ; then
7846
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7847
else
7848
$ECHO "*** with $libname and none of the candidates passed a file format test"
7849
$ECHO "*** using a file magic. Last file checked: $potlib"
7850
fi
7851
fi
7852
;;
7853
*)
7854
# Add a -L argument.
7855
func_append newdeplibs " $a_deplib"
7856
;;
7857
esac
7858
done # Gone through all deplibs.
7859
;;
7860
match_pattern*)
7861
set dummy $deplibs_check_method; shift
7862
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7863
for a_deplib in $deplibs; do
7864
case $a_deplib in
7865
-l*)
7866
func_stripname -l '' "$a_deplib"
7867
name=$func_stripname_result
7868
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7869
case " $predeps $postdeps " in
7870
*" $a_deplib "*)
7871
func_append newdeplibs " $a_deplib"
7872
a_deplib=""
7873
;;
7874
esac
7875
fi
7876
if test -n "$a_deplib" ; then
7877
libname=`eval "\\$ECHO \"$libname_spec\""`
7878
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7879
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7880
for potent_lib in $potential_libs; do
7881
potlib="$potent_lib" # see symlink-check above in file_magic test
7882
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7883
$EGREP "$match_pattern_regex" > /dev/null; then
7884
func_append newdeplibs " $a_deplib"
7885
a_deplib=""
7886
break 2
7887
fi
7888
done
7889
done
7890
fi
7891
if test -n "$a_deplib" ; then
7892
droppeddeps=yes
7893
echo
7894
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
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"
7899
if test -z "$potlib" ; then
7900
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7901
else
7902
$ECHO "*** with $libname and none of the candidates passed a file format test"
7903
$ECHO "*** using a regex pattern. Last file checked: $potlib"
7904
fi
7905
fi
7906
;;
7907
*)
7908
# Add a -L argument.
7909
func_append newdeplibs " $a_deplib"
7910
;;
7911
esac
7912
done # Gone through all deplibs.
7913
;;
7914
none | unknown | *)
7915
newdeplibs=""
7916
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7917
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7918
for i in $predeps $postdeps ; do
7919
# can't use Xsed below, because $i might contain '/'
7920
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7921
done
7922
fi
7923
case $tmp_deplibs in
7924
*[!\ \ ]*)
7925
echo
7926
if test "X$deplibs_check_method" = "Xnone"; then
7927
echo "*** Warning: inter-library dependencies are not supported in this platform."
7928
else
7929
echo "*** Warning: inter-library dependencies are not known to be supported."
7930
fi
7931
echo "*** All declared inter-library dependencies are being dropped."
7932
droppeddeps=yes
7933
;;
7934
esac
7935
;;
7936
esac
7937
versuffix=$versuffix_save
7938
major=$major_save
7939
release=$release_save
7940
libname=$libname_save
7941
name=$name_save
7942
7943
case $host in
7944
*-*-rhapsody* | *-*-darwin1.[012])
7945
# On Rhapsody replace the C library with the System framework
7946
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7947
;;
7948
esac
7949
7950
if test "$droppeddeps" = yes; then
7951
if test "$module" = yes; then
7952
echo
7953
echo "*** Warning: libtool could not satisfy all declared inter-library"
7954
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7955
echo "*** a static module, that should work as long as the dlopening"
7956
echo "*** application is linked with the -dlopen flag."
7957
if test -z "$global_symbol_pipe"; then
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."
7963
fi
7964
if test "$build_old_libs" = no; then
7965
oldlibs="$output_objdir/$libname.$libext"
7966
build_libtool_libs=module
7967
build_old_libs=yes
7968
else
7969
build_libtool_libs=no
7970
fi
7971
else
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."
7975
7976
if test "$allow_undefined" = no; then
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."
7982
if test "$build_old_libs" = no; then
7983
oldlibs="$output_objdir/$libname.$libext"
7984
build_libtool_libs=module
7985
build_old_libs=yes
7986
else
7987
build_libtool_libs=no
7988
fi
7989
fi
7990
fi
7991
fi
7992
# Done checking deplibs!
7993
deplibs=$newdeplibs
7994
fi
7995
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7996
case $host in
7997
*-*-darwin*)
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'`
8001
;;
8002
esac
8003
8004
# move library search paths that coincide with paths to not yet
8005
# installed libraries to the beginning of the library search list
8006
new_libs=
8007
for path in $notinst_path; do
8008
case " $new_libs " in
8009
*" -L$path/$objdir "*) ;;
8010
*)
8011
case " $deplibs " in
8012
*" -L$path/$objdir "*)
8013
func_append new_libs " -L$path/$objdir" ;;
8014
esac
8015
;;
8016
esac
8017
done
8018
for deplib in $deplibs; do
8019
case $deplib in
8020
-L*)
8021
case " $new_libs " in
8022
*" $deplib "*) ;;
8023
*) func_append new_libs " $deplib" ;;
8024
esac
8025
;;
8026
*) func_append new_libs " $deplib" ;;
8027
esac
8028
done
8029
deplibs="$new_libs"
8030
8031
# All the library-specific variables (install_libdir is set above).
8032
library_names=
8033
old_library=
8034
dlname=
8035
8036
# Test again, we may have decided not to build it any more
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
8043
if test "$hardcode_into_libs" = yes; then
8044
# Hardcode the library paths
8045
hardcode_libdirs=
8046
dep_rpath=
8047
rpath="$finalize_rpath"
8048
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8049
for libdir in $rpath; do
8050
if test -n "$hardcode_libdir_flag_spec"; then
8051
if test -n "$hardcode_libdir_separator"; then
8052
func_replace_sysroot "$libdir"
8053
libdir=$func_replace_sysroot_result
8054
if test -z "$hardcode_libdirs"; then
8055
hardcode_libdirs="$libdir"
8056
else
8057
# Just accumulate the unique libdirs.
8058
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8059
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8060
;;
8061
*)
8062
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8063
;;
8064
esac
8065
fi
8066
else
8067
eval flag=\"$hardcode_libdir_flag_spec\"
8068
func_append dep_rpath " $flag"
8069
fi
8070
elif test -n "$runpath_var"; then
8071
case "$perm_rpath " in
8072
*" $libdir "*) ;;
8073
*) func_append perm_rpath " $libdir" ;;
8074
esac
8075
fi
8076
done
8077
# Substitute the hardcoded libdirs into the rpath.
8078
if test -n "$hardcode_libdir_separator" &&
8079
test -n "$hardcode_libdirs"; then
8080
libdir="$hardcode_libdirs"
8081
eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8082
fi
8083
if test -n "$runpath_var" && test -n "$perm_rpath"; then
8084
# We should set the runpath_var.
8085
rpath=
8086
for dir in $perm_rpath; do
8087
func_append rpath "$dir:"
8088
done
8089
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8090
fi
8091
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8092
fi
8093
8094
shlibpath="$finalize_shlibpath"
8095
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8096
if test -n "$shlibpath"; then
8097
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8098
fi
8099
8100
# Get the real and link names of the library.
8101
eval shared_ext=\"$shrext_cmds\"
8102
eval library_names=\"$library_names_spec\"
8103
set dummy $library_names
8104
shift
8105
realname="$1"
8106
shift
8107
8108
if test -n "$soname_spec"; then
8109
eval soname=\"$soname_spec\"
8110
else
8111
soname="$realname"
8112
fi
8113
if test -z "$dlname"; then
8114
dlname=$soname
8115
fi
8116
8117
lib="$output_objdir/$realname"
8118
linknames=
8119
for link
8120
do
8121
func_append linknames " $link"
8122
done
8123
8124
# Use standard objects if they are pic
8125
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8126
test "X$libobjs" = "X " && libobjs=
8127
8128
delfiles=
8129
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8130
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8131
export_symbols="$output_objdir/$libname.uexp"
8132
func_append delfiles " $export_symbols"
8133
fi
8134
8135
orig_export_symbols=
8136
case $host_os in
8137
cygwin* | mingw* | cegcc*)
8138
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8139
# exporting using user supplied symfile
8140
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8141
# and it's NOT already a .def file. Must figure out
8142
# which of the given symbols are data symbols and tag
8143
# them as such. So, trigger use of export_symbols_cmds.
8144
# export_symbols gets reassigned inside the "prepare
8145
# the list of exported symbols" if statement, so the
8146
# include_expsyms logic still works.
8147
orig_export_symbols="$export_symbols"
8148
export_symbols=
8149
always_export_symbols=yes
8150
fi
8151
fi
8152
;;
8153
esac
8154
8155
# Prepare the list of exported symbols
8156
if test -z "$export_symbols"; then
8157
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8158
func_verbose "generating symbol list for \`$libname.la'"
8159
export_symbols="$output_objdir/$libname.exp"
8160
$opt_dry_run || $RM $export_symbols
8161
cmds=$export_symbols_cmds
8162
save_ifs="$IFS"; IFS='~'
8163
for cmd1 in $cmds; do
8164
IFS="$save_ifs"
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
8202
skipped_export=false
8203
else
8204
# The command line is too long to execute in one step.
8205
func_verbose "using reloadable object file for export list..."
8206
skipped_export=:
8207
# Break out early, otherwise skipped_export may be
8208
# set to false by a later but shorter cmd.
8209
break
8210
fi
8211
done
8212
IFS="$save_ifs"
8213
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8214
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8215
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8216
fi
8217
fi
8218
fi
8219
8220
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8221
tmp_export_symbols="$export_symbols"
8222
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8223
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8224
fi
8225
8226
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8227
# The given exports_symbols file has to be filtered, so filter it.
8228
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8229
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8230
# 's' commands which not all seds can handle. GNU sed should be fine
8231
# though. Also, the filter scales superlinearly with the number of
8232
# global variables. join(1) would be nice here, but unfortunately
8233
# isn't a blessed tool.
8234
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8235
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8236
export_symbols=$output_objdir/$libname.def
8237
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8238
fi
8239
8240
tmp_deplibs=
8241
for test_deplib in $deplibs; do
8242
case " $convenience " in
8243
*" $test_deplib "*) ;;
8244
*)
8245
func_append tmp_deplibs " $test_deplib"
8246
;;
8247
esac
8248
done
8249
deplibs="$tmp_deplibs"
8250
8251
if test -n "$convenience"; then
8252
if test -n "$whole_archive_flag_spec" &&
8253
test "$compiler_needs_object" = yes &&
8254
test -z "$libobjs"; then
8255
# extract the archives, so we have objects to list.
8256
# TODO: could optimize this to just extract one archive.
8257
whole_archive_flag_spec=
8258
fi
8259
if test -n "$whole_archive_flag_spec"; then
8260
save_libobjs=$libobjs
8261
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8262
test "X$libobjs" = "X " && libobjs=
8263
else
8264
gentop="$output_objdir/${outputname}x"
8265
func_append generated " $gentop"
8266
8267
func_extract_archives $gentop $convenience
8268
func_append libobjs " $func_extract_archives_result"
8269
test "X$libobjs" = "X " && libobjs=
8270
fi
8271
fi
8272
8273
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8274
eval flag=\"$thread_safe_flag_spec\"
8275
func_append linker_flags " $flag"
8276
fi
8277
8278
# Make a backup of the uninstalled library when relinking
8279
if test "$opt_mode" = relink; then
8280
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8281
fi
8282
8283
# Do each of the archive commands.
8284
if test "$module" = yes && test -n "$module_cmds" ; then
8285
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8286
eval test_cmds=\"$module_expsym_cmds\"
8287
cmds=$module_expsym_cmds
8288
else
8289
eval test_cmds=\"$module_cmds\"
8290
cmds=$module_cmds
8291
fi
8292
else
8293
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8294
eval test_cmds=\"$archive_expsym_cmds\"
8295
cmds=$archive_expsym_cmds
8296
else
8297
eval test_cmds=\"$archive_cmds\"
8298
cmds=$archive_cmds
8299
fi
8300
fi
8301
8302
if test "X$skipped_export" != "X:" &&
8303
func_len " $test_cmds" &&
8304
len=$func_len_result &&
8305
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8306
:
8307
else
8308
# The command line is too long to link in one step, link piecewise
8309
# or, if using GNU ld and skipped_export is not :, use a linker
8310
# script.
8311
8312
# Save the value of $output and $libobjs because we want to
8313
# use them later. If we have whole_archive_flag_spec, we
8314
# want to use save_libobjs as it was before
8315
# whole_archive_flag_spec was expanded, because we can't
8316
# assume the linker understands whole_archive_flag_spec.
8317
# This may have to be revisited, in case too many
8318
# convenience libraries get linked in and end up exceeding
8319
# the spec.
8320
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8321
save_libobjs=$libobjs
8322
fi
8323
save_output=$output
8324
func_basename "$output"
8325
output_la=$func_basename_result
8326
8327
# Clear the reloadable object creation command queue and
8328
# initialize k to one.
8329
test_cmds=
8330
concat_cmds=
8331
objlist=
8332
last_robj=
8333
k=1
8334
8335
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8336
output=${output_objdir}/${output_la}.lnkscript
8337
func_verbose "creating GNU ld script: $output"
8338
echo 'INPUT (' > $output
8339
for obj in $save_libobjs
8340
do
8341
func_to_tool_file "$obj"
8342
$ECHO "$func_to_tool_file_result" >> $output
8343
done
8344
echo ')' >> $output
8345
func_append delfiles " $output"
8346
func_to_tool_file "$output"
8347
output=$func_to_tool_file_result
8348
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8349
output=${output_objdir}/${output_la}.lnk
8350
func_verbose "creating linker input file list: $output"
8351
: > $output
8352
set x $save_libobjs
8353
shift
8354
firstobj=
8355
if test "$compiler_needs_object" = yes; then
8356
firstobj="$1 "
8357
shift
8358
fi
8359
for obj
8360
do
8361
func_to_tool_file "$obj"
8362
$ECHO "$func_to_tool_file_result" >> $output
8363
done
8364
func_append delfiles " $output"
8365
func_to_tool_file "$output"
8366
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8367
else
8368
if test -n "$save_libobjs"; then
8369
func_verbose "creating reloadable object files..."
8370
output=$output_objdir/$output_la-${k}.$objext
8371
eval test_cmds=\"$reload_cmds\"
8372
func_len " $test_cmds"
8373
len0=$func_len_result
8374
len=$len0
8375
8376
# Loop over the list of objects to be linked.
8377
for obj in $save_libobjs
8378
do
8379
func_len " $obj"
8380
func_arith $len + $func_len_result
8381
len=$func_arith_result
8382
if test "X$objlist" = X ||
8383
test "$len" -lt "$max_cmd_len"; then
8384
func_append objlist " $obj"
8385
else
8386
# The command $test_cmds is almost too long, add a
8387
# command to the queue.
8388
if test "$k" -eq 1 ; then
8389
# The first file doesn't have a previous command to add.
8390
reload_objs=$objlist
8391
eval concat_cmds=\"$reload_cmds\"
8392
else
8393
# All subsequent reloadable object files will link in
8394
# the last one created.
8395
reload_objs="$objlist $last_robj"
8396
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8397
fi
8398
last_robj=$output_objdir/$output_la-${k}.$objext
8399
func_arith $k + 1
8400
k=$func_arith_result
8401
output=$output_objdir/$output_la-${k}.$objext
8402
objlist=" $obj"
8403
func_len " $last_robj"
8404
func_arith $len0 + $func_len_result
8405
len=$func_arith_result
8406
fi
8407
done
8408
# Handle the remaining objects by creating one last
8409
# reloadable object file. All subsequent reloadable object
8410
# files will link in the last one created.
8411
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8412
reload_objs="$objlist $last_robj"
8413
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8414
if test -n "$last_robj"; then
8415
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8416
fi
8417
func_append delfiles " $output"
8418
8419
else
8420
output=
8421
fi
8422
8423
if ${skipped_export-false}; then
8424
func_verbose "generating symbol list for \`$libname.la'"
8425
export_symbols="$output_objdir/$libname.exp"
8426
$opt_dry_run || $RM $export_symbols
8427
libobjs=$output
8428
# Append the command to create the export file.
8429
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8430
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8431
if test -n "$last_robj"; then
8432
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8433
fi
8434
fi
8435
8436
test -n "$save_libobjs" &&
8437
func_verbose "creating a temporary reloadable object file: $output"
8438
8439
# Loop through the commands generated above and execute them.
8440
save_ifs="$IFS"; IFS='~'
8441
for cmd in $concat_cmds; do
8442
IFS="$save_ifs"
8443
$opt_silent || {
8444
func_quote_for_expand "$cmd"
8445
eval "func_echo $func_quote_for_expand_result"
8446
}
8447
$opt_dry_run || eval "$cmd" || {
8448
lt_exit=$?
8449
8450
# Restore the uninstalled library and exit
8451
if test "$opt_mode" = relink; then
8452
( cd "$output_objdir" && \
8453
$RM "${realname}T" && \
8454
$MV "${realname}U" "$realname" )
8455
fi
8456
8457
exit $lt_exit
8458
}
8459
done
8460
IFS="$save_ifs"
8461
8462
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8463
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8464
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8465
fi
8466
fi
8467
8468
if ${skipped_export-false}; then
8469
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8470
tmp_export_symbols="$export_symbols"
8471
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8472
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8473
fi
8474
8475
if test -n "$orig_export_symbols"; then
8476
# The given exports_symbols file has to be filtered, so filter it.
8477
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8478
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8479
# 's' commands which not all seds can handle. GNU sed should be fine
8480
# though. Also, the filter scales superlinearly with the number of
8481
# global variables. join(1) would be nice here, but unfortunately
8482
# isn't a blessed tool.
8483
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8484
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8485
export_symbols=$output_objdir/$libname.def
8486
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8487
fi
8488
fi
8489
8490
libobjs=$output
8491
# Restore the value of output.
8492
output=$save_output
8493
8494
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8495
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8496
test "X$libobjs" = "X " && libobjs=
8497
fi
8498
# Expand the library linking commands again to reset the
8499
# value of $libobjs for piecewise linking.
8500
8501
# Do each of the archive commands.
8502
if test "$module" = yes && test -n "$module_cmds" ; then
8503
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8504
cmds=$module_expsym_cmds
8505
else
8506
cmds=$module_cmds
8507
fi
8508
else
8509
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8510
cmds=$archive_expsym_cmds
8511
else
8512
cmds=$archive_cmds
8513
fi
8514
fi
8515
fi
8516
8517
if test -n "$delfiles"; then
8518
# Append the command to remove temporary files to $cmds.
8519
eval cmds=\"\$cmds~\$RM $delfiles\"
8520
fi
8521
8522
# Add any objects from preloaded convenience libraries
8523
if test -n "$dlprefiles"; then
8524
gentop="$output_objdir/${outputname}x"
8525
func_append generated " $gentop"
8526
8527
func_extract_archives $gentop $dlprefiles
8528
func_append libobjs " $func_extract_archives_result"
8529
test "X$libobjs" = "X " && libobjs=
8530
fi
8531
8532
save_ifs="$IFS"; IFS='~'
8533
for cmd in $cmds; do
8534
IFS="$save_ifs"
8535
eval cmd=\"$cmd\"
8536
$opt_silent || {
8537
func_quote_for_expand "$cmd"
8538
eval "func_echo $func_quote_for_expand_result"
8539
}
8540
$opt_dry_run || eval "$cmd" || {
8541
lt_exit=$?
8542
8543
# Restore the uninstalled library and exit
8544
if test "$opt_mode" = relink; then
8545
( cd "$output_objdir" && \
8546
$RM "${realname}T" && \
8547
$MV "${realname}U" "$realname" )
8548
fi
8549
8550
exit $lt_exit
8551
}
8552
done
8553
IFS="$save_ifs"
8554
8555
# Restore the uninstalled library and exit
8556
if test "$opt_mode" = relink; then
8557
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8558
8559
if test -n "$convenience"; then
8560
if test -z "$whole_archive_flag_spec"; then
8561
func_show_eval '${RM}r "$gentop"'
8562
fi
8563
fi
8564
8565
exit $EXIT_SUCCESS
8566
fi
8567
8568
# Create links to the real library.
8569
for linkname in $linknames; do
8570
if test "$realname" != "$linkname"; then
8571
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8572
fi
8573
done
8574
8575
# If -module or -export-dynamic was specified, set the dlname.
8576
if test "$module" = yes || test "$export_dynamic" = yes; then
8577
# On all known operating systems, these are identical.
8578
dlname="$soname"
8579
fi
8580
fi
8581
;;
8582
8583
obj)
8584
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8585
func_warning "\`-dlopen' is ignored for objects"
8586
fi
8587
8588
case " $deplibs" in
8589
*\ -l* | *\ -L*)
8590
func_warning "\`-l' and \`-L' are ignored for objects" ;;
8591
esac
8592
8593
test -n "$rpath" && \
8594
func_warning "\`-rpath' is ignored for objects"
8595
8596
test -n "$xrpath" && \
8597
func_warning "\`-R' is ignored for objects"
8598
8599
test -n "$vinfo" && \
8600
func_warning "\`-version-info' is ignored for objects"
8601
8602
test -n "$release" && \
8603
func_warning "\`-release' is ignored for objects"
8604
8605
case $output in
8606
*.lo)
8607
test -n "$objs$old_deplibs" && \
8608
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8609
8610
libobj=$output
8611
func_lo2o "$libobj"
8612
obj=$func_lo2o_result
8613
;;
8614
*)
8615
libobj=
8616
obj="$output"
8617
;;
8618
esac
8619
8620
# Delete the old objects.
8621
$opt_dry_run || $RM $obj $libobj
8622
8623
# Objects from convenience libraries. This assumes
8624
# single-version convenience libraries. Whenever we create
8625
# different ones for PIC/non-PIC, this we'll have to duplicate
8626
# the extraction.
8627
reload_conv_objs=
8628
gentop=
8629
# reload_cmds runs $LD directly, so let us get rid of
8630
# -Wl from whole_archive_flag_spec and hope we can get by with
8631
# turning comma into space..
8632
wl=
8633
8634
if test -n "$convenience"; then
8635
if test -n "$whole_archive_flag_spec"; then
8636
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8637
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8638
else
8639
gentop="$output_objdir/${obj}x"
8640
func_append generated " $gentop"
8641
8642
func_extract_archives $gentop $convenience
8643
reload_conv_objs="$reload_objs $func_extract_archives_result"
8644
fi
8645
fi
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
8650
# Create the old-style object.
8651
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8652
8653
output="$obj"
8654
func_execute_cmds "$reload_cmds" 'exit $?'
8655
8656
# Exit if we aren't doing a library object file.
8657
if test -z "$libobj"; then
8658
if test -n "$gentop"; then
8659
func_show_eval '${RM}r "$gentop"'
8660
fi
8661
8662
exit $EXIT_SUCCESS
8663
fi
8664
8665
if test "$build_libtool_libs" != yes; then
8666
if test -n "$gentop"; then
8667
func_show_eval '${RM}r "$gentop"'
8668
fi
8669
8670
# Create an invalid libtool object if no PIC, so that we don't
8671
# accidentally link it into a program.
8672
# $show "echo timestamp > $libobj"
8673
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8674
exit $EXIT_SUCCESS
8675
fi
8676
8677
if test -n "$pic_flag" || test "$pic_mode" != default; then
8678
# Only do commands if we really have different PIC objects.
8679
reload_objs="$libobjs $reload_conv_objs"
8680
output="$libobj"
8681
func_execute_cmds "$reload_cmds" 'exit $?'
8682
fi
8683
8684
if test -n "$gentop"; then
8685
func_show_eval '${RM}r "$gentop"'
8686
fi
8687
8688
exit $EXIT_SUCCESS
8689
;;
8690
8691
prog)
8692
case $host in
8693
*cygwin*) func_stripname '' '.exe' "$output"
8694
output=$func_stripname_result.exe;;
8695
esac
8696
test -n "$vinfo" && \
8697
func_warning "\`-version-info' is ignored for programs"
8698
8699
test -n "$release" && \
8700
func_warning "\`-release' is ignored for programs"
8701
8702
test "$preload" = yes \
8703
&& test "$dlopen_support" = unknown \
8704
&& test "$dlopen_self" = unknown \
8705
&& test "$dlopen_self_static" = unknown && \
8706
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8707
8708
case $host in
8709
*-*-rhapsody* | *-*-darwin1.[012])
8710
# On Rhapsody replace the C library is the System framework
8711
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8712
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8713
;;
8714
esac
8715
8716
case $host in
8717
*-*-darwin*)
8718
# Don't allow lazy linking, it breaks C++ global constructors
8719
# But is supposedly fixed on 10.4 or later (yay!).
8720
if test "$tagname" = CXX ; then
8721
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8722
10.[0123])
8723
func_append compile_command " ${wl}-bind_at_load"
8724
func_append finalize_command " ${wl}-bind_at_load"
8725
;;
8726
esac
8727
fi
8728
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8729
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8731
;;
8732
esac
8733
8734
8735
# move library search paths that coincide with paths to not yet
8736
# installed libraries to the beginning of the library search list
8737
new_libs=
8738
for path in $notinst_path; do
8739
case " $new_libs " in
8740
*" -L$path/$objdir "*) ;;
8741
*)
8742
case " $compile_deplibs " in
8743
*" -L$path/$objdir "*)
8744
func_append new_libs " -L$path/$objdir" ;;
8745
esac
8746
;;
8747
esac
8748
done
8749
for deplib in $compile_deplibs; do
8750
case $deplib in
8751
-L*)
8752
case " $new_libs " in
8753
*" $deplib "*) ;;
8754
*) func_append new_libs " $deplib" ;;
8755
esac
8756
;;
8757
*) func_append new_libs " $deplib" ;;
8758
esac
8759
done
8760
compile_deplibs="$new_libs"
8761
8762
8763
func_append compile_command " $compile_deplibs"
8764
func_append finalize_command " $finalize_deplibs"
8765
8766
if test -n "$rpath$xrpath"; then
8767
# If the user specified any rpath flags, then add them.
8768
for libdir in $rpath $xrpath; do
8769
# This is the magic to use -rpath.
8770
case "$finalize_rpath " in
8771
*" $libdir "*) ;;
8772
*) func_append finalize_rpath " $libdir" ;;
8773
esac
8774
done
8775
fi
8776
8777
# Now hardcode the library paths
8778
rpath=
8779
hardcode_libdirs=
8780
for libdir in $compile_rpath $finalize_rpath; do
8781
if test -n "$hardcode_libdir_flag_spec"; then
8782
if test -n "$hardcode_libdir_separator"; then
8783
if test -z "$hardcode_libdirs"; then
8784
hardcode_libdirs="$libdir"
8785
else
8786
# Just accumulate the unique libdirs.
8787
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8788
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8789
;;
8790
*)
8791
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8792
;;
8793
esac
8794
fi
8795
else
8796
eval flag=\"$hardcode_libdir_flag_spec\"
8797
func_append rpath " $flag"
8798
fi
8799
elif test -n "$runpath_var"; then
8800
case "$perm_rpath " in
8801
*" $libdir "*) ;;
8802
*) func_append perm_rpath " $libdir" ;;
8803
esac
8804
fi
8805
case $host in
8806
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8807
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8808
case :$dllsearchpath: in
8809
*":$libdir:"*) ;;
8810
::) dllsearchpath=$libdir;;
8811
*) func_append dllsearchpath ":$libdir";;
8812
esac
8813
case :$dllsearchpath: in
8814
*":$testbindir:"*) ;;
8815
::) dllsearchpath=$testbindir;;
8816
*) func_append dllsearchpath ":$testbindir";;
8817
esac
8818
;;
8819
esac
8820
done
8821
# Substitute the hardcoded libdirs into the rpath.
8822
if test -n "$hardcode_libdir_separator" &&
8823
test -n "$hardcode_libdirs"; then
8824
libdir="$hardcode_libdirs"
8825
eval rpath=\" $hardcode_libdir_flag_spec\"
8826
fi
8827
compile_rpath="$rpath"
8828
8829
rpath=
8830
hardcode_libdirs=
8831
for libdir in $finalize_rpath; do
8832
if test -n "$hardcode_libdir_flag_spec"; then
8833
if test -n "$hardcode_libdir_separator"; then
8834
if test -z "$hardcode_libdirs"; then
8835
hardcode_libdirs="$libdir"
8836
else
8837
# Just accumulate the unique libdirs.
8838
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8839
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8840
;;
8841
*)
8842
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8843
;;
8844
esac
8845
fi
8846
else
8847
eval flag=\"$hardcode_libdir_flag_spec\"
8848
func_append rpath " $flag"
8849
fi
8850
elif test -n "$runpath_var"; then
8851
case "$finalize_perm_rpath " in
8852
*" $libdir "*) ;;
8853
*) func_append finalize_perm_rpath " $libdir" ;;
8854
esac
8855
fi
8856
done
8857
# Substitute the hardcoded libdirs into the rpath.
8858
if test -n "$hardcode_libdir_separator" &&
8859
test -n "$hardcode_libdirs"; then
8860
libdir="$hardcode_libdirs"
8861
eval rpath=\" $hardcode_libdir_flag_spec\"
8862
fi
8863
finalize_rpath="$rpath"
8864
8865
if test -n "$libobjs" && test "$build_old_libs" = yes; then
8866
# Transform all the library objects into standard objects.
8867
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8868
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8869
fi
8870
8871
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8872
8873
# template prelinking step
8874
if test -n "$prelink_cmds"; then
8875
func_execute_cmds "$prelink_cmds" 'exit $?'
8876
fi
8877
8878
wrappers_required=yes
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
;;
8884
*cygwin* | *mingw* )
8885
if test "$build_libtool_libs" != yes; then
8886
wrappers_required=no
8887
fi
8888
;;
8889
*)
8890
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8891
wrappers_required=no
8892
fi
8893
;;
8894
esac
8895
if test "$wrappers_required" = no; then
8896
# Replace the output file specification.
8897
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8898
link_command="$compile_command$compile_rpath"
8899
8900
# We have no uninstalled library dependencies, so finalize right now.
8901
exit_status=0
8902
func_show_eval "$link_command" 'exit_status=$?'
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
8910
# Delete the generated files.
8911
if test -f "$output_objdir/${outputname}S.${objext}"; then
8912
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8913
fi
8914
8915
exit $exit_status
8916
fi
8917
8918
if test -n "$compile_shlibpath$finalize_shlibpath"; then
8919
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8920
fi
8921
if test -n "$finalize_shlibpath"; then
8922
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8923
fi
8924
8925
compile_var=
8926
finalize_var=
8927
if test -n "$runpath_var"; then
8928
if test -n "$perm_rpath"; then
8929
# We should set the runpath_var.
8930
rpath=
8931
for dir in $perm_rpath; do
8932
func_append rpath "$dir:"
8933
done
8934
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8935
fi
8936
if test -n "$finalize_perm_rpath"; then
8937
# We should set the runpath_var.
8938
rpath=
8939
for dir in $finalize_perm_rpath; do
8940
func_append rpath "$dir:"
8941
done
8942
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8943
fi
8944
fi
8945
8946
if test "$no_install" = yes; then
8947
# We don't need to create a wrapper script.
8948
link_command="$compile_var$compile_command$compile_rpath"
8949
# Replace the output file specification.
8950
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8951
# Delete the old output file.
8952
$opt_dry_run || $RM $output
8953
# Link the executable and exit
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
8962
exit $EXIT_SUCCESS
8963
fi
8964
8965
if test "$hardcode_action" = relink; then
8966
# Fast installation is not supported
8967
link_command="$compile_var$compile_command$compile_rpath"
8968
relink_command="$finalize_var$finalize_command$finalize_rpath"
8969
8970
func_warning "this platform does not like uninstalled shared libraries"
8971
func_warning "\`$output' will be relinked during installation"
8972
else
8973
if test "$fast_install" != no; then
8974
link_command="$finalize_var$compile_command$finalize_rpath"
8975
if test "$fast_install" = yes; then
8976
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8977
else
8978
# fast_install is set to needless
8979
relink_command=
8980
fi
8981
else
8982
link_command="$compile_var$compile_command$compile_rpath"
8983
relink_command="$finalize_var$finalize_command$finalize_rpath"
8984
fi
8985
fi
8986
8987
# Replace the output file specification.
8988
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8989
8990
# Delete the old output files.
8991
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8992
8993
func_show_eval "$link_command" 'exit $?'
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
9001
# Now create the wrapper script.
9002
func_verbose "creating $output"
9003
9004
# Quote the relink command for shipping.
9005
if test -n "$relink_command"; then
9006
# Preserve any variables that may affect compiler behavior
9007
for var in $variables_saved_for_relink; do
9008
if eval test -z \"\${$var+set}\"; then
9009
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9010
elif eval var_value=\$$var; test -z "$var_value"; then
9011
relink_command="$var=; export $var; $relink_command"
9012
else
9013
func_quote_for_eval "$var_value"
9014
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9015
fi
9016
done
9017
relink_command="(cd `pwd`; $relink_command)"
9018
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9019
fi
9020
9021
# Only actually do things if not in dry run mode.
9022
$opt_dry_run || {
9023
# win32 will think the script is a binary if it has
9024
# a .exe suffix, so we strip it off here.
9025
case $output in
9026
*.exe) func_stripname '' '.exe' "$output"
9027
output=$func_stripname_result ;;
9028
esac
9029
# test for cygwin because mv fails w/o .exe extensions
9030
case $host in
9031
*cygwin*)
9032
exeext=.exe
9033
func_stripname '' '.exe' "$outputname"
9034
outputname=$func_stripname_result ;;
9035
*) exeext= ;;
9036
esac
9037
case $host in
9038
*cygwin* | *mingw* )
9039
func_dirname_and_basename "$output" "" "."
9040
output_name=$func_basename_result
9041
output_path=$func_dirname_result
9042
cwrappersource="$output_path/$objdir/lt-$output_name.c"
9043
cwrapper="$output_path/$output_name.exe"
9044
$RM $cwrappersource $cwrapper
9045
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9046
9047
func_emit_cwrapperexe_src > $cwrappersource
9048
9049
# The wrapper executable is built using the $host compiler,
9050
# because it contains $host paths and files. If cross-
9051
# compiling, it, like the target executable, must be
9052
# executed on the $host or under an emulation environment.
9053
$opt_dry_run || {
9054
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9055
$STRIP $cwrapper
9056
}
9057
9058
# Now, create the wrapper script for func_source use:
9059
func_ltwrapper_scriptname $cwrapper
9060
$RM $func_ltwrapper_scriptname_result
9061
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9062
$opt_dry_run || {
9063
# note: this script will not be executed, so do not chmod.
9064
if test "x$build" = "x$host" ; then
9065
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9066
else
9067
func_emit_wrapper no > $func_ltwrapper_scriptname_result
9068
fi
9069
}
9070
;;
9071
* )
9072
$RM $output
9073
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9074
9075
func_emit_wrapper no > $output
9076
chmod +x $output
9077
;;
9078
esac
9079
}
9080
exit $EXIT_SUCCESS
9081
;;
9082
esac
9083
9084
# See if we need to build an old-fashioned archive.
9085
for oldlib in $oldlibs; do
9086
9087
if test "$build_libtool_libs" = convenience; then
9088
oldobjs="$libobjs_save $symfileobj"
9089
addlibs="$convenience"
9090
build_libtool_libs=no
9091
else
9092
if test "$build_libtool_libs" = module; then
9093
oldobjs="$libobjs_save"
9094
build_libtool_libs=no
9095
else
9096
oldobjs="$old_deplibs $non_pic_objects"
9097
if test "$preload" = yes && test -f "$symfileobj"; then
9098
func_append oldobjs " $symfileobj"
9099
fi
9100
fi
9101
addlibs="$old_convenience"
9102
fi
9103
9104
if test -n "$addlibs"; then
9105
gentop="$output_objdir/${outputname}x"
9106
func_append generated " $gentop"
9107
9108
func_extract_archives $gentop $addlibs
9109
func_append oldobjs " $func_extract_archives_result"
9110
fi
9111
9112
# Do each command in the archive commands.
9113
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9114
cmds=$old_archive_from_new_cmds
9115
else
9116
9117
# Add any objects from preloaded convenience libraries
9118
if test -n "$dlprefiles"; then
9119
gentop="$output_objdir/${outputname}x"
9120
func_append generated " $gentop"
9121
9122
func_extract_archives $gentop $dlprefiles
9123
func_append oldobjs " $func_extract_archives_result"
9124
fi
9125
9126
# POSIX demands no paths to be encoded in archives. We have
9127
# to avoid creating archives with duplicate basenames if we
9128
# might have to extract them afterwards, e.g., when creating a
9129
# static archive out of a convenience library, or when linking
9130
# the entirety of a libtool archive into another (currently
9131
# not supported by libtool).
9132
if (for obj in $oldobjs
9133
do
9134
func_basename "$obj"
9135
$ECHO "$func_basename_result"
9136
done | sort | sort -uc >/dev/null 2>&1); then
9137
:
9138
else
9139
echo "copying selected object files to avoid basename conflicts..."
9140
gentop="$output_objdir/${outputname}x"
9141
func_append generated " $gentop"
9142
func_mkdir_p "$gentop"
9143
save_oldobjs=$oldobjs
9144
oldobjs=
9145
counter=1
9146
for obj in $save_oldobjs
9147
do
9148
func_basename "$obj"
9149
objbase="$func_basename_result"
9150
case " $oldobjs " in
9151
" ") oldobjs=$obj ;;
9152
*[\ /]"$objbase "*)
9153
while :; do
9154
# Make sure we don't pick an alternate name that also
9155
# overlaps.
9156
newobj=lt$counter-$objbase
9157
func_arith $counter + 1
9158
counter=$func_arith_result
9159
case " $oldobjs " in
9160
*[\ /]"$newobj "*) ;;
9161
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
9162
esac
9163
done
9164
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9165
func_append oldobjs " $gentop/$newobj"
9166
;;
9167
*) func_append oldobjs " $obj" ;;
9168
esac
9169
done
9170
fi
9171
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9172
tool_oldlib=$func_to_tool_file_result
9173
eval cmds=\"$old_archive_cmds\"
9174
9175
func_len " $cmds"
9176
len=$func_len_result
9177
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
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
9189
else
9190
# the command line is too long to link in one step, link in parts
9191
func_verbose "using piecewise archive linking..."
9192
save_RANLIB=$RANLIB
9193
RANLIB=:
9194
objlist=
9195
concat_cmds=
9196
save_oldobjs=$oldobjs
9197
oldobjs=
9198
# Is there a better way of finding the last object in the list?
9199
for obj in $save_oldobjs
9200
do
9201
last_oldobj=$obj
9202
done
9203
eval test_cmds=\"$old_archive_cmds\"
9204
func_len " $test_cmds"
9205
len0=$func_len_result
9206
len=$len0
9207
for obj in $save_oldobjs
9208
do
9209
func_len " $obj"
9210
func_arith $len + $func_len_result
9211
len=$func_arith_result
9212
func_append objlist " $obj"
9213
if test "$len" -lt "$max_cmd_len"; then
9214
:
9215
else
9216
# the above command should be used before it gets too long
9217
oldobjs=$objlist
9218
if test "$obj" = "$last_oldobj" ; then
9219
RANLIB=$save_RANLIB
9220
fi
9221
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9222
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9223
objlist=
9224
len=$len0
9225
fi
9226
done
9227
RANLIB=$save_RANLIB
9228
oldobjs=$objlist
9229
if test "X$oldobjs" = "X" ; then
9230
eval cmds=\"\$concat_cmds\"
9231
else
9232
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9233
fi
9234
fi
9235
fi
9236
func_execute_cmds "$cmds" 'exit $?'
9237
done
9238
9239
test -n "$generated" && \
9240
func_show_eval "${RM}r$generated"
9241
9242
# Now create the libtool archive.
9243
case $output in
9244
*.la)
9245
old_library=
9246
test "$build_old_libs" = yes && old_library="$libname.$libext"
9247
func_verbose "creating $output"
9248
9249
# Preserve any variables that may affect compiler behavior
9250
for var in $variables_saved_for_relink; do
9251
if eval test -z \"\${$var+set}\"; then
9252
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9253
elif eval var_value=\$$var; test -z "$var_value"; then
9254
relink_command="$var=; export $var; $relink_command"
9255
else
9256
func_quote_for_eval "$var_value"
9257
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9258
fi
9259
done
9260
# Quote the link command for shipping.
9261
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9262
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9263
if test "$hardcode_automatic" = yes ; then
9264
relink_command=
9265
fi
9266
9267
# Only create the output if not a dry run.
9268
$opt_dry_run || {
9269
for installed in no yes; do
9270
if test "$installed" = yes; then
9271
if test -z "$install_libdir"; then
9272
break
9273
fi
9274
output="$output_objdir/$outputname"i
9275
# Replace all uninstalled libtool libraries with the installed ones
9276
newdependency_libs=
9277
for deplib in $dependency_libs; do
9278
case $deplib in
9279
*.la)
9280
func_basename "$deplib"
9281
name="$func_basename_result"
9282
func_resolve_sysroot "$deplib"
9283
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9284
test -z "$libdir" && \
9285
func_fatal_error "\`$deplib' is not a valid libtool archive"
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" ;;
9299
esac
9300
done
9301
dependency_libs="$newdependency_libs"
9302
newdlfiles=
9303
9304
for lib in $dlfiles; do
9305
case $lib in
9306
*.la)
9307
func_basename "$lib"
9308
name="$func_basename_result"
9309
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310
test -z "$libdir" && \
9311
func_fatal_error "\`$lib' is not a valid libtool archive"
9312
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9313
;;
9314
*) func_append newdlfiles " $lib" ;;
9315
esac
9316
done
9317
dlfiles="$newdlfiles"
9318
newdlprefiles=
9319
for lib in $dlprefiles; do
9320
case $lib in
9321
*.la)
9322
# Only pass preopened files to the pseudo-archive (for
9323
# eventual linking with the app. that links it) if we
9324
# didn't already link the preopened objects directly into
9325
# the library:
9326
func_basename "$lib"
9327
name="$func_basename_result"
9328
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9329
test -z "$libdir" && \
9330
func_fatal_error "\`$lib' is not a valid libtool archive"
9331
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9332
;;
9333
esac
9334
done
9335
dlprefiles="$newdlprefiles"
9336
else
9337
newdlfiles=
9338
for lib in $dlfiles; do
9339
case $lib in
9340
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9341
*) abs=`pwd`"/$lib" ;;
9342
esac
9343
func_append newdlfiles " $abs"
9344
done
9345
dlfiles="$newdlfiles"
9346
newdlprefiles=
9347
for lib in $dlprefiles; do
9348
case $lib in
9349
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9350
*) abs=`pwd`"/$lib" ;;
9351
esac
9352
func_append newdlprefiles " $abs"
9353
done
9354
dlprefiles="$newdlprefiles"
9355
fi
9356
$RM $output
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.
9366
tdlname=$dlname
9367
case $host,$output,$installed,$module,$dlname in
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
;;
9379
esac
9380
$ECHO > $output "\
9381
# $outputname - a libtool library file
9382
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9383
#
9384
# Please DO NOT delete this file!
9385
# It is necessary for linking the library.
9386
9387
# The name that we can dlopen(3).
9388
dlname='$tdlname'
9389
9390
# Names of this library.
9391
library_names='$library_names'
9392
9393
# The name of the static archive.
9394
old_library='$old_library'
9395
9396
# Linker flags that can not go in dependency_libs.
9397
inherited_linker_flags='$new_inherited_linker_flags'
9398
9399
# Libraries that this one depends upon.
9400
dependency_libs='$dependency_libs'
9401
9402
# Names of additional weak libraries provided by this library
9403
weak_library_names='$weak_libs'
9404
9405
# Version information for $libname.
9406
current=$current
9407
age=$age
9408
revision=$revision
9409
9410
# Is this an already installed library?
9411
installed=$installed
9412
9413
# Should we warn about portability when linking against -modules?
9414
shouldnotlink=$module
9415
9416
# Files to dlopen/dlpreopen
9417
dlopen='$dlfiles'
9418
dlpreopen='$dlprefiles'
9419
9420
# Directory that this library needs to be installed in:
9421
libdir='$install_libdir'"
9422
if test "$installed" = no && test "$need_relink" = yes; then
9423
$ECHO >> $output "\
9424
relink_command=\"$relink_command\""
9425
fi
9426
done
9427
}
9428
9429
# Do a symbolic link so that the libtool archive can be found in
9430
# LD_LIBRARY_PATH before the program is installed.
9431
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9432
;;
9433
esac
9434
exit $EXIT_SUCCESS
9435
}
9436
9437
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9438
func_mode_link ${1+"$@"}
9439
9440
9441
# func_mode_uninstall arg...
9442
func_mode_uninstall ()
9443
{
9444
$opt_debug
9445
RM="$nonopt"
9446
files=
9447
rmforce=
9448
exit_status=0
9449
9450
# This variable tells wrapper scripts just to set variables rather
9451
# than running their programs.
9452
libtool_install_magic="$magic"
9453
9454
for arg
9455
do
9456
case $arg in
9457
-f) func_append RM " $arg"; rmforce=yes ;;
9458
-*) func_append RM " $arg" ;;
9459
*) func_append files " $arg" ;;
9460
esac
9461
done
9462
9463
test -z "$RM" && \
9464
func_fatal_help "you must specify an RM program"
9465
9466
rmdirs=
9467
9468
for file in $files; do
9469
func_dirname "$file" "" "."
9470
dir="$func_dirname_result"
9471
if test "X$dir" = X.; then
9472
odir="$objdir"
9473
else
9474
odir="$dir/$objdir"
9475
fi
9476
func_basename "$file"
9477
name="$func_basename_result"
9478
test "$opt_mode" = uninstall && odir="$dir"
9479
9480
# Remember odir for removal later, being careful to avoid duplicates
9481
if test "$opt_mode" = clean; then
9482
case " $rmdirs " in
9483
*" $odir "*) ;;
9484
*) func_append rmdirs " $odir" ;;
9485
esac
9486
fi
9487
9488
# Don't error if the file doesn't exist and rm -f was used.
9489
if { test -L "$file"; } >/dev/null 2>&1 ||
9490
{ test -h "$file"; } >/dev/null 2>&1 ||
9491
test -f "$file"; then
9492
:
9493
elif test -d "$file"; then
9494
exit_status=1
9495
continue
9496
elif test "$rmforce" = yes; then
9497
continue
9498
fi
9499
9500
rmfiles="$file"
9501
9502
case $name in
9503
*.la)
9504
# Possibly a libtool archive, so verify it.
9505
if func_lalib_p "$file"; then
9506
func_source $dir/$name
9507
9508
# Delete the libtool libraries and symlinks.
9509
for n in $library_names; do
9510
func_append rmfiles " $odir/$n"
9511
done
9512
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9513
9514
case "$opt_mode" in
9515
clean)
9516
case " $library_names " in
9517
*" $dlname "*) ;;
9518
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9519
esac
9520
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9521
;;
9522
uninstall)
9523
if test -n "$library_names"; then
9524
# Do each command in the postuninstall commands.
9525
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9526
fi
9527
9528
if test -n "$old_library"; then
9529
# Do each command in the old_postuninstall commands.
9530
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9531
fi
9532
# FIXME: should reinstall the best remaining shared library.
9533
;;
9534
esac
9535
fi
9536
;;
9537
9538
*.lo)
9539
# Possibly a libtool object, so verify it.
9540
if func_lalib_p "$file"; then
9541
9542
# Read the .lo file
9543
func_source $dir/$name
9544
9545
# Add PIC object to the list of files to remove.
9546
if test -n "$pic_object" &&
9547
test "$pic_object" != none; then
9548
func_append rmfiles " $dir/$pic_object"
9549
fi
9550
9551
# Add non-PIC object to the list of files to remove.
9552
if test -n "$non_pic_object" &&
9553
test "$non_pic_object" != none; then
9554
func_append rmfiles " $dir/$non_pic_object"
9555
fi
9556
fi
9557
;;
9558
9559
*)
9560
if test "$opt_mode" = clean ; then
9561
noexename=$name
9562
case $file in
9563
*.exe)
9564
func_stripname '' '.exe' "$file"
9565
file=$func_stripname_result
9566
func_stripname '' '.exe' "$name"
9567
noexename=$func_stripname_result
9568
# $file with .exe has already been added to rmfiles,
9569
# add $file without .exe
9570
func_append rmfiles " $file"
9571
;;
9572
esac
9573
# Do a test to see if this is a libtool program.
9574
if func_ltwrapper_p "$file"; then
9575
if func_ltwrapper_executable_p "$file"; then
9576
func_ltwrapper_scriptname "$file"
9577
relink_command=
9578
func_source $func_ltwrapper_scriptname_result
9579
func_append rmfiles " $func_ltwrapper_scriptname_result"
9580
else
9581
relink_command=
9582
func_source $dir/$noexename
9583
fi
9584
9585
# note $name still contains .exe if it was in $file originally
9586
# as does the version of $file that was added into $rmfiles
9587
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9588
if test "$fast_install" = yes && test -n "$relink_command"; then
9589
func_append rmfiles " $odir/lt-$name"
9590
fi
9591
if test "X$noexename" != "X$name" ; then
9592
func_append rmfiles " $odir/lt-${noexename}.c"
9593
fi
9594
fi
9595
fi
9596
;;
9597
esac
9598
func_show_eval "$RM $rmfiles" 'exit_status=1'
9599
done
9600
9601
# Try to remove the ${objdir}s in the directories where we deleted files
9602
for dir in $rmdirs; do
9603
if test -d "$dir"; then
9604
func_show_eval "rmdir $dir >/dev/null 2>&1"
9605
fi
9606
done
9607
9608
exit $exit_status
9609
}
9610
9611
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9612
func_mode_uninstall ${1+"$@"}
9613
9614
test -z "$opt_mode" && {
9615
help="$generic_help"
9616
func_fatal_help "you must specify a MODE"
9617
}
9618
9619
test -z "$exec_cmd" && \
9620
func_fatal_help "invalid operation mode \`$opt_mode'"
9621
9622
if test -n "$exec_cmd"; then
9623
eval exec "$exec_cmd"
9624
exit $EXIT_FAILURE
9625
fi
9626
9627
exit $exit_status
9628
9629
9630
# The TAGs below are defined such that we never get into a situation
9631
# in which we disable both kinds of libraries. Given conflicting
9632
# choices, we go for a static library, that is the most portable,
9633
# since we can't tell whether shared libraries were disabled because
9634
# the user asked for that or because the platform doesn't support
9635
# them. This is particularly important on AIX, because we don't
9636
# support having both static and shared libraries enabled at the same
9637
# time on that platform, so we default to a shared-only configuration.
9638
# If a disable-shared tag is given, we'll fallback to a static-only
9639
# configuration. But we'll never go from static-only to shared-only.
9640
9641
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9642
build_libtool_libs=no
9643
build_old_libs=yes
9644
# ### END LIBTOOL TAG CONFIG: disable-shared
9645
9646
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
9647
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9648
# ### END LIBTOOL TAG CONFIG: disable-static
9649
9650
# Local Variables:
9651
# mode:shell-script
9652
# sh-indentation:2
9653
# End:
9654
# vi:sw=2
9655
Loggerhead is a web-based interface for Breezy
Version: 2.0.1