« back to all changes in this revision
Viewing changes to ltmain.sh
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Mathieu Malaterre
- Date: 2009-11-16 18:12:42 UTC
- Revision ID: james.westby@ubuntu.com-20091116181242-mzv9p5fz9uj57xd1
Tags: upstream-0.5.3
Import upstream version 0.5.3
- files added:
- doc
- doc/book
- examples
- examples/simple
- include
- interfaces
- interfaces/R
- interfaces/R/src
- interfaces/shell
- src
- src/arpack
- src/blas
- src/f2c
- src/lapack
- tests
added
removed
ltmain.sh
1
# Generated from ltmain.m4sh.
2
3
# ltmain.sh (GNU libtool) 2.2.4
4
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5
6
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 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
# --tag=TAG use configuration variables from tag TAG
43
# -v, --verbose print informational messages (default)
44
# --version print version information
45
# -h, --help print short or long help message
46
#
47
# MODE must be one of the following:
48
#
49
# clean remove files from the build directory
50
# compile compile a source file into a libtool object
51
# execute automatically set library path, then run a program
52
# finish complete the installation of libtool libraries
53
# install install libraries or executables
54
# link create a library or an executable
55
# uninstall remove libraries from an installed directory
56
#
57
# MODE-ARGS vary depending on the MODE.
58
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
59
#
60
# When reporting a bug, please describe a test case to reproduce it and
61
# include the following information:
62
#
63
# host-triplet: $host
64
# shell: $SHELL
65
# compiler: $LTCC
66
# compiler flags: $LTCFLAGS
67
# linker: $LD (gnu? $with_gnu_ld)
68
# $progname: (GNU libtool) 2.2.4 Debian-2.2.4-0ubuntu4
69
# automake: $automake_version
70
# autoconf: $autoconf_version
71
#
72
# Report bugs to <bug-libtool@gnu.org>.
73
74
PROGRAM=ltmain.sh
75
PACKAGE=libtool
76
VERSION="2.2.4 Debian-2.2.4-0ubuntu4"
77
TIMESTAMP=""
78
package_revision=1.2976
79
80
# Be Bourne compatible
81
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
82
emulate sh
83
NULLCMD=:
84
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
85
# is contrary to our usage. Disable this feature.
86
alias -g '${1+"$@"}'='"$@"'
87
setopt NO_GLOB_SUBST
88
else
89
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
90
fi
91
BIN_SH=xpg4; export BIN_SH # for Tru64
92
DUALCASE=1; export DUALCASE # for MKS sh
93
94
# NLS nuisances: We save the old values to restore during execute mode.
95
# Only set LANG and LC_ALL to C if already set.
96
# These must not be set unconditionally because not all systems understand
97
# e.g. LANG=C (notably SCO).
98
lt_user_locale=
99
lt_safe_locale=
100
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
101
do
102
eval "if test \"\${$lt_var+set}\" = set; then
103
save_$lt_var=\$$lt_var
104
$lt_var=C
105
export $lt_var
106
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
107
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
108
fi"
109
done
110
111
$lt_unset CDPATH
112
113
114
115
116
117
: ${CP="cp -f"}
118
: ${ECHO="echo"}
119
: ${EGREP="/bin/grep -E"}
120
: ${FGREP="/bin/grep -F"}
121
: ${GREP="/bin/grep"}
122
: ${LN_S="ln -s"}
123
: ${MAKE="make"}
124
: ${MKDIR="mkdir"}
125
: ${MV="mv -f"}
126
: ${RM="rm -f"}
127
: ${SED="/bin/sed"}
128
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
129
: ${Xsed="$SED -e 1s/^X//"}
130
131
# Global variables:
132
EXIT_SUCCESS=0
133
EXIT_FAILURE=1
134
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
135
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
136
137
exit_status=$EXIT_SUCCESS
138
139
# Make sure IFS has a sensible default
140
lt_nl='
141
'
142
IFS=" $lt_nl"
143
144
dirname="s,/[^/]*$,,"
145
basename="s,^.*/,,"
146
147
# func_dirname_and_basename file append nondir_replacement
148
# perform func_basename and func_dirname in a single function
149
# call:
150
# dirname: Compute the dirname of FILE. If nonempty,
151
# add APPEND to the result, otherwise set result
152
# to NONDIR_REPLACEMENT.
153
# value returned in "$func_dirname_result"
154
# basename: Compute filename of FILE.
155
# value retuned in "$func_basename_result"
156
# Implementation must be kept synchronized with func_dirname
157
# and func_basename. For efficiency, we do not delegate to
158
# those functions but instead duplicate the functionality here.
159
func_dirname_and_basename ()
160
{
161
# Extract subdirectory from the argument.
162
func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
163
if test "X$func_dirname_result" = "X${1}"; then
164
func_dirname_result="${3}"
165
else
166
func_dirname_result="$func_dirname_result${2}"
167
fi
168
func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
169
}
170
171
# Generated shell functions inserted here.
172
173
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
174
# is ksh but when the shell is invoked as "sh" and the current value of
175
# the _XPG environment variable is not equal to 1 (one), the special
176
# positional parameter $0, within a function call, is the name of the
177
# function.
178
progpath="$0"
179
180
# The name of this program:
181
# In the unlikely event $progname began with a '-', it would play havoc with
182
# func_echo (imagine progname=-n), so we prepend ./ in that case:
183
func_dirname_and_basename "$progpath"
184
progname=$func_basename_result
185
case $progname in
186
-*) progname=./$progname ;;
187
esac
188
189
# Make sure we have an absolute path for reexecution:
190
case $progpath in
191
[\\/]*|[A-Za-z]:\\*) ;;
192
*[\\/]*)
193
progdir=$func_dirname_result
194
progdir=`cd "$progdir" && pwd`
195
progpath="$progdir/$progname"
196
;;
197
*)
198
save_IFS="$IFS"
199
IFS=:
200
for progdir in $PATH; do
201
IFS="$save_IFS"
202
test -x "$progdir/$progname" && break
203
done
204
IFS="$save_IFS"
205
test -n "$progdir" || progdir=`pwd`
206
progpath="$progdir/$progname"
207
;;
208
esac
209
210
# Sed substitution that helps us do robust quoting. It backslashifies
211
# metacharacters that are still active within double-quoted strings.
212
Xsed="${SED}"' -e 1s/^X//'
213
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
214
215
# Same as above, but do not quote variable references.
216
double_quote_subst='s/\(["`\\]\)/\\\1/g'
217
218
# Re-`\' parameter expansions in output of double_quote_subst that were
219
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
220
# in input to double_quote_subst, that '$' was protected from expansion.
221
# Since each input `\' is now two `\'s, look for any number of runs of
222
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
223
bs='\\'
224
bs2='\\\\'
225
bs4='\\\\\\\\'
226
dollar='\$'
227
sed_double_backslash="\
228
s/$bs4/&\\
229
/g
230
s/^$bs2$dollar/$bs&/
231
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
232
s/\n//g"
233
234
# Standard options:
235
opt_dry_run=false
236
opt_help=false
237
opt_quiet=false
238
opt_verbose=false
239
opt_warning=:
240
241
# func_echo arg...
242
# Echo program name prefixed message, along with the current mode
243
# name if it has been set yet.
244
func_echo ()
245
{
246
$ECHO "$progname${mode+: }$mode: $*"
247
}
248
249
# func_verbose arg...
250
# Echo program name prefixed message in verbose mode only.
251
func_verbose ()
252
{
253
$opt_verbose && func_echo ${1+"$@"}
254
255
# A bug in bash halts the script if the last line of a function
256
# fails when set -e is in force, so we need another command to
257
# work around that:
258
:
259
}
260
261
# func_error arg...
262
# Echo program name prefixed message to standard error.
263
func_error ()
264
{
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
266
}
267
268
# func_warning arg...
269
# Echo program name prefixed warning message to standard error.
270
func_warning ()
271
{
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
273
274
# bash bug again:
275
:
276
}
277
278
# func_fatal_error arg...
279
# Echo program name prefixed message to standard error, and exit.
280
func_fatal_error ()
281
{
282
func_error ${1+"$@"}
283
exit $EXIT_FAILURE
284
}
285
286
# func_fatal_help arg...
287
# Echo program name prefixed message to standard error, followed by
288
# a help hint, and exit.
289
func_fatal_help ()
290
{
291
func_error ${1+"$@"}
292
func_fatal_error "$help"
293
}
294
help="Try \`$progname --help' for more information." ## default
295
296
297
# func_grep expression filename
298
# Check whether EXPRESSION matches any line of FILENAME, without output.
299
func_grep ()
300
{
301
$GREP "$1" "$2" >/dev/null 2>&1
302
}
303
304
305
# func_mkdir_p directory-path
306
# Make sure the entire path to DIRECTORY-PATH is available.
307
func_mkdir_p ()
308
{
309
my_directory_path="$1"
310
my_dir_list=
311
312
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
313
314
# Protect directory names starting with `-'
315
case $my_directory_path in
316
-*) my_directory_path="./$my_directory_path" ;;
317
esac
318
319
# While some portion of DIR does not yet exist...
320
while test ! -d "$my_directory_path"; do
321
# ...make a list in topmost first order. Use a colon delimited
322
# list incase some portion of path contains whitespace.
323
my_dir_list="$my_directory_path:$my_dir_list"
324
325
# If the last portion added has no slash in it, the list is done
326
case $my_directory_path in */*) ;; *) break ;; esac
327
328
# ...otherwise throw away the child directory and loop
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
330
done
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
332
333
save_mkdir_p_IFS="$IFS"; IFS=':'
334
for my_dir in $my_dir_list; do
335
IFS="$save_mkdir_p_IFS"
336
# mkdir can fail with a `File exist' error if two processes
337
# try to create one of the directories concurrently. Don't
338
# stop in that case!
339
$MKDIR "$my_dir" 2>/dev/null || :
340
done
341
IFS="$save_mkdir_p_IFS"
342
343
# Bail out if we (or some other process) failed to create a directory.
344
test -d "$my_directory_path" || \
345
func_fatal_error "Failed to create \`$1'"
346
fi
347
}
348
349
350
# func_mktempdir [string]
351
# Make a temporary directory that won't clash with other running
352
# libtool processes, and avoids race conditions if possible. If
353
# given, STRING is the basename for that directory.
354
func_mktempdir ()
355
{
356
my_template="${TMPDIR-/tmp}/${1-$progname}"
357
358
if test "$opt_dry_run" = ":"; then
359
# Return a directory name, but don't create it in dry-run mode
360
my_tmpdir="${my_template}-$$"
361
else
362
363
# If mktemp works, use that first and foremost
364
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
365
366
if test ! -d "$my_tmpdir"; then
367
# Failing that, at least try and use $RANDOM to avoid a race
368
my_tmpdir="${my_template}-${RANDOM-0}$$"
369
370
save_mktempdir_umask=`umask`
371
umask 0077
372
$MKDIR "$my_tmpdir"
373
umask $save_mktempdir_umask
374
fi
375
376
# If we're not in dry-run mode, bomb out on failure
377
test -d "$my_tmpdir" || \
378
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
379
fi
380
381
$ECHO "X$my_tmpdir" | $Xsed
382
}
383
384
385
# func_quote_for_eval arg
386
# Aesthetically quote ARG to be evaled later.
387
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
388
# is double-quoted, suitable for a subsequent eval, whereas
389
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
390
# which are still active within double quotes backslashified.
391
func_quote_for_eval ()
392
{
393
case $1 in
394
*[\\\`\"\$]*)
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
396
*)
397
func_quote_for_eval_unquoted_result="$1" ;;
398
esac
399
400
case $func_quote_for_eval_unquoted_result in
401
# Double-quote args containing shell metacharacters to delay
402
# word splitting, command substitution and and variable
403
# expansion for a subsequent eval.
404
# Many Bourne shells cannot handle close brackets correctly
405
# in scan sets, so we specify it separately.
406
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
407
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
408
;;
409
*)
410
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
411
esac
412
}
413
414
415
# func_quote_for_expand arg
416
# Aesthetically quote ARG to be evaled later; same as above,
417
# but do not quote variable references.
418
func_quote_for_expand ()
419
{
420
case $1 in
421
*[\\\`\"]*)
422
my_arg=`$ECHO "X$1" | $Xsed \
423
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
424
*)
425
my_arg="$1" ;;
426
esac
427
428
case $my_arg in
429
# Double-quote args containing shell metacharacters to delay
430
# word splitting and command substitution for a subsequent eval.
431
# Many Bourne shells cannot handle close brackets correctly
432
# in scan sets, so we specify it separately.
433
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
434
my_arg="\"$my_arg\""
435
;;
436
esac
437
438
func_quote_for_expand_result="$my_arg"
439
}
440
441
442
# func_show_eval cmd [fail_exp]
443
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
444
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
445
# is given, then evaluate it.
446
func_show_eval ()
447
{
448
my_cmd="$1"
449
my_fail_exp="${2-:}"
450
451
${opt_silent-false} || {
452
func_quote_for_expand "$my_cmd"
453
eval "func_echo $func_quote_for_expand_result"
454
}
455
456
if ${opt_dry_run-false}; then :; else
457
eval "$my_cmd"
458
my_status=$?
459
if test "$my_status" -eq 0; then :; else
460
eval "(exit $my_status); $my_fail_exp"
461
fi
462
fi
463
}
464
465
466
# func_show_eval_locale cmd [fail_exp]
467
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
468
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
469
# is given, then evaluate it. Use the saved locale for evaluation.
470
func_show_eval_locale ()
471
{
472
my_cmd="$1"
473
my_fail_exp="${2-:}"
474
475
${opt_silent-false} || {
476
func_quote_for_expand "$my_cmd"
477
eval "func_echo $func_quote_for_expand_result"
478
}
479
480
if ${opt_dry_run-false}; then :; else
481
eval "$lt_user_locale
482
$my_cmd"
483
my_status=$?
484
eval "$lt_safe_locale"
485
if test "$my_status" -eq 0; then :; else
486
eval "(exit $my_status); $my_fail_exp"
487
fi
488
fi
489
}
490
491
492
493
494
495
# func_version
496
# Echo version message to standard output and exit.
497
func_version ()
498
{
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
500
s/^# //
501
s/^# *$//
502
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
503
p
504
}' < "$progpath"
505
exit $?
506
}
507
508
# func_usage
509
# Echo short help message to standard output and exit.
510
func_usage ()
511
{
512
$SED -n '/^# Usage:/,/# -h/ {
513
s/^# //
514
s/^# *$//
515
s/\$progname/'$progname'/
516
p
517
}' < "$progpath"
518
$ECHO
519
$ECHO "run \`$progname --help | more' for full usage"
520
exit $?
521
}
522
523
# func_help
524
# Echo long help message to standard output and exit.
525
func_help ()
526
{
527
$SED -n '/^# Usage:/,/# Report bugs to/ {
528
s/^# //
529
s/^# *$//
530
s*\$progname*'$progname'*
531
s*\$host*'"$host"'*
532
s*\$SHELL*'"$SHELL"'*
533
s*\$LTCC*'"$LTCC"'*
534
s*\$LTCFLAGS*'"$LTCFLAGS"'*
535
s*\$LD*'"$LD"'*
536
s/\$with_gnu_ld/'"$with_gnu_ld"'/
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
539
p
540
}' < "$progpath"
541
exit $?
542
}
543
544
# func_missing_arg argname
545
# Echo program name prefixed message to standard error and set global
546
# exit_cmd.
547
func_missing_arg ()
548
{
549
func_error "missing argument for $1"
550
exit_cmd=exit
551
}
552
553
exit_cmd=:
554
555
556
557
558
559
# Check that we have a working $ECHO.
560
if test "X$1" = X--no-reexec; then
561
# Discard the --no-reexec flag, and continue.
562
shift
563
elif test "X$1" = X--fallback-echo; then
564
# Avoid inline document here, it may be left over
565
:
566
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567
# Yippee, $ECHO works!
568
:
569
else
570
# Restart under the correct shell, and then maybe $ECHO will work.
571
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
572
fi
573
574
if test "X$1" = X--fallback-echo; then
575
# used as fallback echo
576
shift
577
cat <<EOF
578
$*
579
EOF
580
exit $EXIT_SUCCESS
581
fi
582
583
magic="%%%MAGIC variable%%%"
584
magic_exe="%%%MAGIC EXE variable%%%"
585
586
# Global variables.
587
# $mode is unset
588
nonopt=
589
execute_dlfiles=
590
preserve_args=
591
lo2o="s/\\.lo\$/.${objext}/"
592
o2lo="s/\\.${objext}\$/.lo/"
593
extracted_archives=
594
extracted_serial=0
595
596
opt_dry_run=false
597
opt_duplicate_deps=false
598
opt_silent=false
599
opt_debug=:
600
601
# If this variable is set in any of the actions, the command in it
602
# will be execed at the end. This prevents here-documents from being
603
# left over by shells.
604
exec_cmd=
605
606
# func_fatal_configuration arg...
607
# Echo program name prefixed message to standard error, followed by
608
# a configuration failure hint, and exit.
609
func_fatal_configuration ()
610
{
611
func_error ${1+"$@"}
612
func_error "See the $PACKAGE documentation for more information."
613
func_fatal_error "Fatal configuration error."
614
}
615
616
617
# func_config
618
# Display the configuration for all the tags in this script.
619
func_config ()
620
{
621
re_begincf='^# ### BEGIN LIBTOOL'
622
re_endcf='^# ### END LIBTOOL'
623
624
# Default configuration.
625
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
626
627
# Now print the configurations for the tags.
628
for tagname in $taglist; do
629
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
630
done
631
632
exit $?
633
}
634
635
# func_features
636
# Display the features supported by this script.
637
func_features ()
638
{
639
$ECHO "host: $host"
640
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
642
else
643
$ECHO "disable shared libraries"
644
fi
645
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
647
else
648
$ECHO "disable static libraries"
649
fi
650
651
exit $?
652
}
653
654
# func_enable_tag tagname
655
# Verify that TAGNAME is valid, and either flag an error and exit, or
656
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
657
# variable here.
658
func_enable_tag ()
659
{
660
# Global variable:
661
tagname="$1"
662
663
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
664
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
665
sed_extractcf="/$re_begincf/,/$re_endcf/p"
666
667
# Validate tagname.
668
case $tagname in
669
*[!-_A-Za-z0-9,/]*)
670
func_fatal_error "invalid tag name: $tagname"
671
;;
672
esac
673
674
# Don't test for the "default" C tag, as we know it's
675
# there but not specially marked.
676
case $tagname in
677
CC) ;;
678
*)
679
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
680
taglist="$taglist $tagname"
681
682
# Evaluate the configuration. Be careful to quote the path
683
# and the sed script, to avoid splitting on whitespace, but
684
# also don't use non-portable quotes within backquotes within
685
# quotes we have to do it in 2 steps:
686
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
687
eval "$extractedcf"
688
else
689
func_error "ignoring unknown tag $tagname"
690
fi
691
;;
692
esac
693
}
694
695
# Parse options once, thoroughly. This comes as soon as possible in
696
# the script to make things like `libtool --version' happen quickly.
697
{
698
699
# Shorthand for --mode=foo, only valid as the first argument
700
case $1 in
701
clean|clea|cle|cl)
702
shift; set dummy --mode clean ${1+"$@"}; shift
703
;;
704
compile|compil|compi|comp|com|co|c)
705
shift; set dummy --mode compile ${1+"$@"}; shift
706
;;
707
execute|execut|execu|exec|exe|ex|e)
708
shift; set dummy --mode execute ${1+"$@"}; shift
709
;;
710
finish|finis|fini|fin|fi|f)
711
shift; set dummy --mode finish ${1+"$@"}; shift
712
;;
713
install|instal|insta|inst|ins|in|i)
714
shift; set dummy --mode install ${1+"$@"}; shift
715
;;
716
link|lin|li|l)
717
shift; set dummy --mode link ${1+"$@"}; shift
718
;;
719
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720
shift; set dummy --mode uninstall ${1+"$@"}; shift
721
;;
722
esac
723
724
# Parse non-mode specific arguments:
725
while test "$#" -gt 0; do
726
opt="$1"
727
shift
728
729
case $opt in
730
--config) func_config ;;
731
732
--debug) preserve_args="$preserve_args $opt"
733
func_echo "enabling shell trace mode"
734
opt_debug='set -x'
735
$opt_debug
736
;;
737
738
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
739
execute_dlfiles="$execute_dlfiles $1"
740
shift
741
;;
742
743
--dry-run | -n) opt_dry_run=: ;;
744
--features) func_features ;;
745
--finish) mode="finish" ;;
746
747
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
748
case $1 in
749
# Valid mode arguments:
750
clean) ;;
751
compile) ;;
752
execute) ;;
753
finish) ;;
754
install) ;;
755
link) ;;
756
relink) ;;
757
uninstall) ;;
758
759
# Catch anything else as an error
760
*) func_error "invalid argument for $opt"
761
exit_cmd=exit
762
break
763
;;
764
esac
765
766
mode="$1"
767
shift
768
;;
769
770
--preserve-dup-deps)
771
opt_duplicate_deps=: ;;
772
773
--quiet|--silent) preserve_args="$preserve_args $opt"
774
opt_silent=:
775
;;
776
777
--verbose| -v) preserve_args="$preserve_args $opt"
778
opt_silent=false
779
;;
780
781
--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
782
preserve_args="$preserve_args $opt $1"
783
func_enable_tag "$1" # tagname is set here
784
shift
785
;;
786
787
# Separate optargs to long options:
788
-dlopen=*|--mode=*|--tag=*)
789
func_opt_split "$opt"
790
set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
791
shift
792
;;
793
794
-\?|-h) func_usage ;;
795
--help) opt_help=: ;;
796
--version) func_version ;;
797
798
-*) func_fatal_help "unrecognized option \`$opt'" ;;
799
800
*) nonopt="$opt"
801
break
802
;;
803
esac
804
done
805
806
807
case $host in
808
*cygwin* | *mingw* | *pw32*)
809
# don't eliminate duplications in $postdeps and $predeps
810
opt_duplicate_compiler_generated_deps=:
811
;;
812
*)
813
opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
814
;;
815
esac
816
817
# Having warned about all mis-specified options, bail out if
818
# anything was wrong.
819
$exit_cmd $EXIT_FAILURE
820
}
821
822
# func_check_version_match
823
# Ensure that we are using m4 macros, and libtool script from the same
824
# release of libtool.
825
func_check_version_match ()
826
{
827
if test "$package_revision" != "$macro_revision"; then
828
if test "$VERSION" != "$macro_version"; then
829
if test -z "$macro_version"; then
830
cat >&2 <<_LT_EOF
831
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
832
$progname: definition of this LT_INIT comes from an older release.
833
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
834
$progname: and run autoconf again.
835
_LT_EOF
836
else
837
cat >&2 <<_LT_EOF
838
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
839
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
840
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
841
$progname: and run autoconf again.
842
_LT_EOF
843
fi
844
else
845
cat >&2 <<_LT_EOF
846
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
847
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
848
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
849
$progname: of $PACKAGE $VERSION and run autoconf again.
850
_LT_EOF
851
fi
852
853
exit $EXIT_MISMATCH
854
fi
855
}
856
857
858
## ----------- ##
859
## Main. ##
860
## ----------- ##
861
862
$opt_help || {
863
# Sanity checks first:
864
func_check_version_match
865
866
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
867
func_fatal_configuration "not configured to build any kind of library"
868
fi
869
870
test -z "$mode" && func_fatal_error "error: you must specify a MODE."
871
872
873
# Darwin sucks
874
eval std_shrext=\"$shrext_cmds\"
875
876
877
# Only execute mode is allowed to have -dlopen flags.
878
if test -n "$execute_dlfiles" && test "$mode" != execute; then
879
func_error "unrecognized option \`-dlopen'"
880
$ECHO "$help" 1>&2
881
exit $EXIT_FAILURE
882
fi
883
884
# Change the help message to a mode-specific one.
885
generic_help="$help"
886
help="Try \`$progname --help --mode=$mode' for more information."
887
}
888
889
890
# func_lalib_p file
891
# True iff FILE is a libtool `.la' library or `.lo' object file.
892
# This function is only a basic sanity check; it will hardly flush out
893
# determined imposters.
894
func_lalib_p ()
895
{
896
$SED -e 4q "$1" 2>/dev/null \
897
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
898
}
899
900
# func_lalib_unsafe_p file
901
# True iff FILE is a libtool `.la' library or `.lo' object file.
902
# This function implements the same check as func_lalib_p without
903
# resorting to external programs. To this end, it redirects stdin and
904
# closes it afterwards, without saving the original file descriptor.
905
# As a safety measure, use it only where a negative result would be
906
# fatal anyway. Works if `file' does not exist.
907
func_lalib_unsafe_p ()
908
{
909
lalib_p=no
910
if test -r "$1" && exec 5<&0 <"$1"; then
911
for lalib_p_l in 1 2 3 4
912
do
913
read lalib_p_line
914
case "$lalib_p_line" in
915
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
916
esac
917
done
918
exec 0<&5 5<&-
919
fi
920
test "$lalib_p" = yes
921
}
922
923
# func_ltwrapper_script_p file
924
# True iff FILE is a libtool wrapper script
925
# This function is only a basic sanity check; it will hardly flush out
926
# determined imposters.
927
func_ltwrapper_script_p ()
928
{
929
func_lalib_p "$1"
930
}
931
932
# func_ltwrapper_executable_p file
933
# True iff FILE is a libtool wrapper executable
934
# This function is only a basic sanity check; it will hardly flush out
935
# determined imposters.
936
func_ltwrapper_executable_p ()
937
{
938
func_ltwrapper_exec_suffix=
939
case $1 in
940
*.exe) ;;
941
*) func_ltwrapper_exec_suffix=.exe ;;
942
esac
943
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
944
}
945
946
# func_ltwrapper_scriptname file
947
# Assumes file is an ltwrapper_executable
948
# uses $file to determine the appropriate filename for a
949
# temporary ltwrapper_script.
950
func_ltwrapper_scriptname ()
951
{
952
func_ltwrapper_scriptname_result=""
953
if func_ltwrapper_executable_p "$1"; then
954
func_dirname_and_basename "$1" "" "."
955
func_stripname '' '.exe' "$func_basename_result"
956
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
957
fi
958
}
959
960
# func_ltwrapper_p file
961
# True iff FILE is a libtool wrapper script or wrapper executable
962
# This function is only a basic sanity check; it will hardly flush out
963
# determined imposters.
964
func_ltwrapper_p ()
965
{
966
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
967
}
968
969
970
# func_execute_cmds commands fail_cmd
971
# Execute tilde-delimited COMMANDS.
972
# If FAIL_CMD is given, eval that upon failure.
973
# FAIL_CMD may read-access the current command in variable CMD!
974
func_execute_cmds ()
975
{
976
$opt_debug
977
save_ifs=$IFS; IFS='~'
978
for cmd in $1; do
979
IFS=$save_ifs
980
eval cmd=\"$cmd\"
981
func_show_eval "$cmd" "${2-:}"
982
done
983
IFS=$save_ifs
984
}
985
986
987
# func_source file
988
# Source FILE, adding directory component if necessary.
989
# Note that it is not necessary on cygwin/mingw to append a dot to
990
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
991
# behavior happens only for exec(3), not for open(2)! Also, sourcing
992
# `FILE.' does not work on cygwin managed mounts.
993
func_source ()
994
{
995
$opt_debug
996
case $1 in
997
*/* | *\\*) . "$1" ;;
998
*) . "./$1" ;;
999
esac
1000
}
1001
1002
1003
# func_infer_tag arg
1004
# Infer tagged configuration to use if any are available and
1005
# if one wasn't chosen via the "--tag" command line option.
1006
# Only attempt this if the compiler in the base compile
1007
# command doesn't match the default compiler.
1008
# arg is usually of the form 'gcc ...'
1009
func_infer_tag ()
1010
{
1011
$opt_debug
1012
if test -n "$available_tags" && test -z "$tagname"; then
1013
CC_quoted=
1014
for arg in $CC; do
1015
func_quote_for_eval "$arg"
1016
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1017
done
1018
case $@ in
1019
# Blanks in the command may have been stripped by the calling shell,
1020
# but not from the CC environment variable when configure was run.
1021
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1022
# Blanks at the start of $base_compile will cause this to fail
1023
# if we don't check for them as well.
1024
*)
1025
for z in $available_tags; do
1026
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1027
# Evaluate the configuration.
1028
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1029
CC_quoted=
1030
for arg in $CC; do
1031
# Double-quote args containing other shell metacharacters.
1032
func_quote_for_eval "$arg"
1033
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1034
done
1035
case "$@ " in
1036
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1037
# The compiler in the base compile command matches
1038
# the one in the tagged configuration.
1039
# Assume this is the tagged configuration we want.
1040
tagname=$z
1041
break
1042
;;
1043
esac
1044
fi
1045
done
1046
# If $tagname still isn't set, then no tagged configuration
1047
# was found and let the user know that the "--tag" command
1048
# line option must be used.
1049
if test -z "$tagname"; then
1050
func_echo "unable to infer tagged configuration"
1051
func_fatal_error "specify a tag with \`--tag'"
1052
# else
1053
# func_verbose "using $tagname tagged configuration"
1054
fi
1055
;;
1056
esac
1057
fi
1058
}
1059
1060
1061
1062
# func_write_libtool_object output_name pic_name nonpic_name
1063
# Create a libtool object file (analogous to a ".la" file),
1064
# but don't create it if we're doing a dry run.
1065
func_write_libtool_object ()
1066
{
1067
write_libobj=${1}
1068
if test "$build_libtool_libs" = yes; then
1069
write_lobj=\'${2}\'
1070
else
1071
write_lobj=none
1072
fi
1073
1074
if test "$build_old_libs" = yes; then
1075
write_oldobj=\'${3}\'
1076
else
1077
write_oldobj=none
1078
fi
1079
1080
$opt_dry_run || {
1081
cat >${write_libobj}T <<EOF
1082
# $write_libobj - a libtool object file
1083
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1084
#
1085
# Please DO NOT delete this file!
1086
# It is necessary for linking the library.
1087
1088
# Name of the PIC object.
1089
pic_object=$write_lobj
1090
1091
# Name of the non-PIC object
1092
non_pic_object=$write_oldobj
1093
1094
EOF
1095
$MV "${write_libobj}T" "${write_libobj}"
1096
}
1097
}
1098
1099
# func_mode_compile arg...
1100
func_mode_compile ()
1101
{
1102
$opt_debug
1103
# Get the compilation command and the source file.
1104
base_compile=
1105
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1106
suppress_opt=yes
1107
suppress_output=
1108
arg_mode=normal
1109
libobj=
1110
later=
1111
pie_flag=
1112
1113
for arg
1114
do
1115
case $arg_mode in
1116
arg )
1117
# do not "continue". Instead, add this to base_compile
1118
lastarg="$arg"
1119
arg_mode=normal
1120
;;
1121
1122
target )
1123
libobj="$arg"
1124
arg_mode=normal
1125
continue
1126
;;
1127
1128
normal )
1129
# Accept any command-line options.
1130
case $arg in
1131
-o)
1132
test -n "$libobj" && \
1133
func_fatal_error "you cannot specify \`-o' more than once"
1134
arg_mode=target
1135
continue
1136
;;
1137
1138
-pie | -fpie | -fPIE)
1139
pie_flag="$pie_flag $arg"
1140
continue
1141
;;
1142
1143
-shared | -static | -prefer-pic | -prefer-non-pic)
1144
later="$later $arg"
1145
continue
1146
;;
1147
1148
-no-suppress)
1149
suppress_opt=no
1150
continue
1151
;;
1152
1153
-Xcompiler)
1154
arg_mode=arg # the next one goes into the "base_compile" arg list
1155
continue # The current "srcfile" will either be retained or
1156
;; # replaced later. I would guess that would be a bug.
1157
1158
-Wc,*)
1159
func_stripname '-Wc,' '' "$arg"
1160
args=$func_stripname_result
1161
lastarg=
1162
save_ifs="$IFS"; IFS=','
1163
for arg in $args; do
1164
IFS="$save_ifs"
1165
func_quote_for_eval "$arg"
1166
lastarg="$lastarg $func_quote_for_eval_result"
1167
done
1168
IFS="$save_ifs"
1169
func_stripname ' ' '' "$lastarg"
1170
lastarg=$func_stripname_result
1171
1172
# Add the arguments to base_compile.
1173
base_compile="$base_compile $lastarg"
1174
continue
1175
;;
1176
1177
*)
1178
# Accept the current argument as the source file.
1179
# The previous "srcfile" becomes the current argument.
1180
#
1181
lastarg="$srcfile"
1182
srcfile="$arg"
1183
;;
1184
esac # case $arg
1185
;;
1186
esac # case $arg_mode
1187
1188
# Aesthetically quote the previous argument.
1189
func_quote_for_eval "$lastarg"
1190
base_compile="$base_compile $func_quote_for_eval_result"
1191
done # for arg
1192
1193
case $arg_mode in
1194
arg)
1195
func_fatal_error "you must specify an argument for -Xcompile"
1196
;;
1197
target)
1198
func_fatal_error "you must specify a target with \`-o'"
1199
;;
1200
*)
1201
# Get the name of the library object.
1202
test -z "$libobj" && {
1203
func_basename "$srcfile"
1204
libobj="$func_basename_result"
1205
}
1206
;;
1207
esac
1208
1209
# Recognize several different file suffixes.
1210
# If the user specifies -o file.o, it is replaced with file.lo
1211
case $libobj in
1212
*.[cCFSifmso] | \
1213
*.ada | *.adb | *.ads | *.asm | \
1214
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1215
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
1216
func_xform "$libobj"
1217
libobj=$func_xform_result
1218
;;
1219
esac
1220
1221
case $libobj in
1222
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1223
*)
1224
func_fatal_error "cannot determine name of library object from \`$libobj'"
1225
;;
1226
esac
1227
1228
func_infer_tag $base_compile
1229
1230
for arg in $later; do
1231
case $arg in
1232
-shared)
1233
test "$build_libtool_libs" != yes && \
1234
func_fatal_configuration "can not build a shared library"
1235
build_old_libs=no
1236
continue
1237
;;
1238
1239
-static)
1240
build_libtool_libs=no
1241
build_old_libs=yes
1242
continue
1243
;;
1244
1245
-prefer-pic)
1246
pic_mode=yes
1247
continue
1248
;;
1249
1250
-prefer-non-pic)
1251
pic_mode=no
1252
continue
1253
;;
1254
esac
1255
done
1256
1257
func_quote_for_eval "$libobj"
1258
test "X$libobj" != "X$func_quote_for_eval_result" \
1259
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1260
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1261
func_dirname_and_basename "$obj" "/" ""
1262
objname="$func_basename_result"
1263
xdir="$func_dirname_result"
1264
lobj=${xdir}$objdir/$objname
1265
1266
test -z "$base_compile" && \
1267
func_fatal_help "you must specify a compilation command"
1268
1269
# Delete any leftover library objects.
1270
if test "$build_old_libs" = yes; then
1271
removelist="$obj $lobj $libobj ${libobj}T"
1272
else
1273
removelist="$lobj $libobj ${libobj}T"
1274
fi
1275
1276
# On Cygwin there's no "real" PIC flag so we must build both object types
1277
case $host_os in
1278
cygwin* | mingw* | pw32* | os2*)
1279
pic_mode=default
1280
;;
1281
esac
1282
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1283
# non-PIC code in shared libraries is not supported
1284
pic_mode=default
1285
fi
1286
1287
# Calculate the filename of the output object if compiler does
1288
# not support -o with -c
1289
if test "$compiler_c_o" = no; then
1290
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1291
lockfile="$output_obj.lock"
1292
else
1293
output_obj=
1294
need_locks=no
1295
lockfile=
1296
fi
1297
1298
# Lock this critical section if it is needed
1299
# We use this script file to make the link, it avoids creating a new file
1300
if test "$need_locks" = yes; then
1301
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1302
func_echo "Waiting for $lockfile to be removed"
1303
sleep 2
1304
done
1305
elif test "$need_locks" = warn; then
1306
if test -f "$lockfile"; then
1307
$ECHO "\
1308
*** ERROR, $lockfile exists and contains:
1309
`cat $lockfile 2>/dev/null`
1310
1311
This indicates that another process is trying to use the same
1312
temporary object file, and libtool could not work around it because
1313
your compiler does not support \`-c' and \`-o' together. If you
1314
repeat this compilation, it may succeed, by chance, but you had better
1315
avoid parallel builds (make -j) in this platform, or get a better
1316
compiler."
1317
1318
$opt_dry_run || $RM $removelist
1319
exit $EXIT_FAILURE
1320
fi
1321
removelist="$removelist $output_obj"
1322
$ECHO "$srcfile" > "$lockfile"
1323
fi
1324
1325
$opt_dry_run || $RM $removelist
1326
removelist="$removelist $lockfile"
1327
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1328
1329
if test -n "$fix_srcfile_path"; then
1330
eval srcfile=\"$fix_srcfile_path\"
1331
fi
1332
func_quote_for_eval "$srcfile"
1333
qsrcfile=$func_quote_for_eval_result
1334
1335
# Only build a PIC object if we are building libtool libraries.
1336
if test "$build_libtool_libs" = yes; then
1337
# Without this assignment, base_compile gets emptied.
1338
fbsd_hideous_sh_bug=$base_compile
1339
1340
if test "$pic_mode" != no; then
1341
command="$base_compile $qsrcfile $pic_flag"
1342
else
1343
# Don't build PIC code
1344
command="$base_compile $qsrcfile"
1345
fi
1346
1347
func_mkdir_p "$xdir$objdir"
1348
1349
if test -z "$output_obj"; then
1350
# Place PIC objects in $objdir
1351
command="$command -o $lobj"
1352
fi
1353
1354
func_show_eval_locale "$command" \
1355
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1356
1357
if test "$need_locks" = warn &&
1358
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1359
$ECHO "\
1360
*** ERROR, $lockfile contains:
1361
`cat $lockfile 2>/dev/null`
1362
1363
but it should contain:
1364
$srcfile
1365
1366
This indicates that another process is trying to use the same
1367
temporary object file, and libtool could not work around it because
1368
your compiler does not support \`-c' and \`-o' together. If you
1369
repeat this compilation, it may succeed, by chance, but you had better
1370
avoid parallel builds (make -j) in this platform, or get a better
1371
compiler."
1372
1373
$opt_dry_run || $RM $removelist
1374
exit $EXIT_FAILURE
1375
fi
1376
1377
# Just move the object if needed, then go on to compile the next one
1378
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1379
func_show_eval '$MV "$output_obj" "$lobj"' \
1380
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1381
fi
1382
1383
# Allow error messages only from the first compilation.
1384
if test "$suppress_opt" = yes; then
1385
suppress_output=' >/dev/null 2>&1'
1386
fi
1387
fi
1388
1389
# Only build a position-dependent object if we build old libraries.
1390
if test "$build_old_libs" = yes; then
1391
if test "$pic_mode" != yes; then
1392
# Don't build PIC code
1393
command="$base_compile $qsrcfile$pie_flag"
1394
else
1395
command="$base_compile $qsrcfile $pic_flag"
1396
fi
1397
if test "$compiler_c_o" = yes; then
1398
command="$command -o $obj"
1399
fi
1400
1401
# Suppress compiler output if we already did a PIC compilation.
1402
command="$command$suppress_output"
1403
func_show_eval_locale "$command" \
1404
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1405
1406
if test "$need_locks" = warn &&
1407
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1408
$ECHO "\
1409
*** ERROR, $lockfile contains:
1410
`cat $lockfile 2>/dev/null`
1411
1412
but it should contain:
1413
$srcfile
1414
1415
This indicates that another process is trying to use the same
1416
temporary object file, and libtool could not work around it because
1417
your compiler does not support \`-c' and \`-o' together. If you
1418
repeat this compilation, it may succeed, by chance, but you had better
1419
avoid parallel builds (make -j) in this platform, or get a better
1420
compiler."
1421
1422
$opt_dry_run || $RM $removelist
1423
exit $EXIT_FAILURE
1424
fi
1425
1426
# Just move the object if needed
1427
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1428
func_show_eval '$MV "$output_obj" "$obj"' \
1429
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1430
fi
1431
fi
1432
1433
$opt_dry_run || {
1434
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1435
1436
# Unlock the critical section if it was locked
1437
if test "$need_locks" != no; then
1438
removelist=$lockfile
1439
$RM "$lockfile"
1440
fi
1441
}
1442
1443
exit $EXIT_SUCCESS
1444
}
1445
1446
$opt_help || {
1447
test "$mode" = compile && func_mode_compile ${1+"$@"}
1448
}
1449
1450
func_mode_help ()
1451
{
1452
# We need to display help for each of the modes.
1453
case $mode in
1454
"")
1455
# Generic help is extracted from the usage comments
1456
# at the start of this file.
1457
func_help
1458
;;
1459
1460
clean)
1461
$ECHO \
1462
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1463
1464
Remove files from the build directory.
1465
1466
RM is the name of the program to use to delete files associated with each FILE
1467
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1468
to RM.
1469
1470
If FILE is a libtool library, object or program, all the files associated
1471
with it are deleted. Otherwise, only FILE itself is deleted using RM."
1472
;;
1473
1474
compile)
1475
$ECHO \
1476
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1477
1478
Compile a source file into a libtool library object.
1479
1480
This mode accepts the following additional options:
1481
1482
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1483
-no-suppress do not suppress compiler output for multiple passes
1484
-prefer-pic try to building PIC objects only
1485
-prefer-non-pic try to building non-PIC objects only
1486
-shared do not build a \`.o' file suitable for static linking
1487
-static only build a \`.o' file suitable for static linking
1488
1489
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1490
from the given SOURCEFILE.
1491
1492
The output file name is determined by removing the directory component from
1493
SOURCEFILE, then substituting the C source code suffix \`.c' with the
1494
library object suffix, \`.lo'."
1495
;;
1496
1497
execute)
1498
$ECHO \
1499
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1500
1501
Automatically set library path, then run a program.
1502
1503
This mode accepts the following additional options:
1504
1505
-dlopen FILE add the directory containing FILE to the library path
1506
1507
This mode sets the library path environment variable according to \`-dlopen'
1508
flags.
1509
1510
If any of the ARGS are libtool executable wrappers, then they are translated
1511
into their corresponding uninstalled binary, and any of their required library
1512
directories are added to the library path.
1513
1514
Then, COMMAND is executed, with ARGS as arguments."
1515
;;
1516
1517
finish)
1518
$ECHO \
1519
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1520
1521
Complete the installation of libtool libraries.
1522
1523
Each LIBDIR is a directory that contains libtool libraries.
1524
1525
The commands that this mode executes may require superuser privileges. Use
1526
the \`--dry-run' option if you just want to see what would be executed."
1527
;;
1528
1529
install)
1530
$ECHO \
1531
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1532
1533
Install executables or libraries.
1534
1535
INSTALL-COMMAND is the installation command. The first component should be
1536
either the \`install' or \`cp' program.
1537
1538
The following components of INSTALL-COMMAND are treated specially:
1539
1540
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1541
1542
The rest of the components are interpreted as arguments to that command (only
1543
BSD-compatible install options are recognized)."
1544
;;
1545
1546
link)
1547
$ECHO \
1548
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1549
1550
Link object files or libraries together to form another library, or to
1551
create an executable program.
1552
1553
LINK-COMMAND is a command using the C compiler that you would use to create
1554
a program from several object files.
1555
1556
The following components of LINK-COMMAND are treated specially:
1557
1558
-all-static do not do any dynamic linking at all
1559
-avoid-version do not add a version suffix if possible
1560
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1561
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1562
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1563
-export-symbols SYMFILE
1564
try to export only the symbols listed in SYMFILE
1565
-export-symbols-regex REGEX
1566
try to export only the symbols matching REGEX
1567
-LLIBDIR search LIBDIR for required installed libraries
1568
-lNAME OUTPUT-FILE requires the installed library libNAME
1569
-module build a library that can dlopened
1570
-no-fast-install disable the fast-install mode
1571
-no-install link a not-installable executable
1572
-no-undefined declare that a library does not refer to external symbols
1573
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1574
-objectlist FILE Use a list of object files found in FILE to specify objects
1575
-precious-files-regex REGEX
1576
don't remove output files matching REGEX
1577
-release RELEASE specify package release information
1578
-rpath LIBDIR the created library will eventually be installed in LIBDIR
1579
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1580
-shared only do dynamic linking of libtool libraries
1581
-shrext SUFFIX override the standard shared library file extension
1582
-static do not do any dynamic linking of uninstalled libtool libraries
1583
-static-libtool-libs
1584
do not do any dynamic linking of libtool libraries
1585
-version-info CURRENT[:REVISION[:AGE]]
1586
specify library version info [each variable defaults to 0]
1587
-weak LIBNAME declare that the target provides the LIBNAME interface
1588
1589
All other options (arguments beginning with \`-') are ignored.
1590
1591
Every other argument is treated as a filename. Files ending in \`.la' are
1592
treated as uninstalled libtool libraries, other files are standard or library
1593
object files.
1594
1595
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1596
only library objects (\`.lo' files) may be specified, and \`-rpath' is
1597
required, except when creating a convenience library.
1598
1599
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1600
using \`ar' and \`ranlib', or on Windows using \`lib'.
1601
1602
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1603
is created, otherwise an executable program is created."
1604
;;
1605
1606
uninstall)
1607
$ECHO \
1608
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1609
1610
Remove libraries from an installation directory.
1611
1612
RM is the name of the program to use to delete files associated with each FILE
1613
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1614
to RM.
1615
1616
If FILE is a libtool library, all the files associated with it are deleted.
1617
Otherwise, only FILE itself is deleted using RM."
1618
;;
1619
1620
*)
1621
func_fatal_help "invalid operation mode \`$mode'"
1622
;;
1623
esac
1624
1625
$ECHO
1626
$ECHO "Try \`$progname --help' for more information about other modes."
1627
1628
exit $?
1629
}
1630
1631
# Now that we've collected a possible --mode arg, show help if necessary
1632
$opt_help && func_mode_help
1633
1634
1635
# func_mode_execute arg...
1636
func_mode_execute ()
1637
{
1638
$opt_debug
1639
# The first argument is the command name.
1640
cmd="$nonopt"
1641
test -z "$cmd" && \
1642
func_fatal_help "you must specify a COMMAND"
1643
1644
# Handle -dlopen flags immediately.
1645
for file in $execute_dlfiles; do
1646
test -f "$file" \
1647
|| func_fatal_help "\`$file' is not a file"
1648
1649
dir=
1650
case $file in
1651
*.la)
1652
# Check to see that this really is a libtool archive.
1653
func_lalib_unsafe_p "$file" \
1654
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1655
1656
# Read the libtool library.
1657
dlname=
1658
library_names=
1659
func_source "$file"
1660
1661
# Skip this library if it cannot be dlopened.
1662
if test -z "$dlname"; then
1663
# Warn if it was a shared library.
1664
test -n "$library_names" && \
1665
func_warning "\`$file' was not linked with \`-export-dynamic'"
1666
continue
1667
fi
1668
1669
func_dirname "$file" "" "."
1670
dir="$func_dirname_result"
1671
1672
if test -f "$dir/$objdir/$dlname"; then
1673
dir="$dir/$objdir"
1674
else
1675
if test ! -f "$dir/$dlname"; then
1676
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1677
fi
1678
fi
1679
;;
1680
1681
*.lo)
1682
# Just add the directory containing the .lo file.
1683
func_dirname "$file" "" "."
1684
dir="$func_dirname_result"
1685
;;
1686
1687
*)
1688
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1689
continue
1690
;;
1691
esac
1692
1693
# Get the absolute pathname.
1694
absdir=`cd "$dir" && pwd`
1695
test -n "$absdir" && dir="$absdir"
1696
1697
# Now add the directory to shlibpath_var.
1698
if eval "test -z \"\$$shlibpath_var\""; then
1699
eval "$shlibpath_var=\"\$dir\""
1700
else
1701
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1702
fi
1703
done
1704
1705
# This variable tells wrapper scripts just to set shlibpath_var
1706
# rather than running their programs.
1707
libtool_execute_magic="$magic"
1708
1709
# Check if any of the arguments is a wrapper script.
1710
args=
1711
for file
1712
do
1713
case $file in
1714
-*) ;;
1715
*)
1716
# Do a test to see if this is really a libtool program.
1717
if func_ltwrapper_script_p "$file"; then
1718
func_source "$file"
1719
# Transform arg to wrapped name.
1720
file="$progdir/$program"
1721
elif func_ltwrapper_executable_p "$file"; then
1722
func_ltwrapper_scriptname "$file"
1723
func_source "$func_ltwrapper_scriptname_result"
1724
# Transform arg to wrapped name.
1725
file="$progdir/$program"
1726
fi
1727
;;
1728
esac
1729
# Quote arguments (to preserve shell metacharacters).
1730
func_quote_for_eval "$file"
1731
args="$args $func_quote_for_eval_result"
1732
done
1733
1734
if test "X$opt_dry_run" = Xfalse; then
1735
if test -n "$shlibpath_var"; then
1736
# Export the shlibpath_var.
1737
eval "export $shlibpath_var"
1738
fi
1739
1740
# Restore saved environment variables
1741
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1742
do
1743
eval "if test \"\${save_$lt_var+set}\" = set; then
1744
$lt_var=\$save_$lt_var; export $lt_var
1745
else
1746
$lt_unset $lt_var
1747
fi"
1748
done
1749
1750
# Now prepare to actually exec the command.
1751
exec_cmd="\$cmd$args"
1752
else
1753
# Display what would be done.
1754
if test -n "$shlibpath_var"; then
1755
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1756
$ECHO "export $shlibpath_var"
1757
fi
1758
$ECHO "$cmd$args"
1759
exit $EXIT_SUCCESS
1760
fi
1761
}
1762
1763
test "$mode" = execute && func_mode_execute ${1+"$@"}
1764
1765
1766
# func_mode_finish arg...
1767
func_mode_finish ()
1768
{
1769
$opt_debug
1770
libdirs="$nonopt"
1771
admincmds=
1772
1773
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1774
for dir
1775
do
1776
libdirs="$libdirs $dir"
1777
done
1778
1779
for libdir in $libdirs; do
1780
if test -n "$finish_cmds"; then
1781
# Do each command in the finish commands.
1782
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1783
'"$cmd"'"'
1784
fi
1785
if test -n "$finish_eval"; then
1786
# Do the single finish_eval.
1787
eval cmds=\"$finish_eval\"
1788
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
1789
$cmds"
1790
fi
1791
done
1792
fi
1793
1794
# Exit here if they wanted silent mode.
1795
$opt_silent && exit $EXIT_SUCCESS
1796
1797
$ECHO "X----------------------------------------------------------------------" | $Xsed
1798
$ECHO "Libraries have been installed in:"
1799
for libdir in $libdirs; do
1800
$ECHO " $libdir"
1801
done
1802
$ECHO
1803
$ECHO "If you ever happen to want to link against installed libraries"
1804
$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1805
$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1806
$ECHO "flag during linking and do at least one of the following:"
1807
if test -n "$shlibpath_var"; then
1808
$ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
1809
$ECHO " during execution"
1810
fi
1811
if test -n "$runpath_var"; then
1812
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1813
$ECHO " during linking"
1814
fi
1815
if test -n "$hardcode_libdir_flag_spec"; then
1816
libdir=LIBDIR
1817
eval flag=\"$hardcode_libdir_flag_spec\"
1818
1819
$ECHO " - use the \`$flag' linker flag"
1820
fi
1821
if test -n "$admincmds"; then
1822
$ECHO " - have your system administrator run these commands:$admincmds"
1823
fi
1824
if test -f /etc/ld.so.conf; then
1825
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1826
fi
1827
$ECHO
1828
1829
$ECHO "See any operating system documentation about shared libraries for"
1830
case $host in
1831
solaris2.[6789]|solaris2.1[0-9])
1832
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1833
$ECHO "pages."
1834
;;
1835
*)
1836
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1837
;;
1838
esac
1839
$ECHO "X----------------------------------------------------------------------" | $Xsed
1840
exit $EXIT_SUCCESS
1841
}
1842
1843
test "$mode" = finish && func_mode_finish ${1+"$@"}
1844
1845
1846
# func_mode_install arg...
1847
func_mode_install ()
1848
{
1849
$opt_debug
1850
# There may be an optional sh(1) argument at the beginning of
1851
# install_prog (especially on Windows NT).
1852
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1853
# Allow the use of GNU shtool's install command.
1854
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1855
# Aesthetically quote it.
1856
func_quote_for_eval "$nonopt"
1857
install_prog="$func_quote_for_eval_result "
1858
arg=$1
1859
shift
1860
else
1861
install_prog=
1862
arg=$nonopt
1863
fi
1864
1865
# The real first argument should be the name of the installation program.
1866
# Aesthetically quote it.
1867
func_quote_for_eval "$arg"
1868
install_prog="$install_prog$func_quote_for_eval_result"
1869
1870
# We need to accept at least all the BSD install flags.
1871
dest=
1872
files=
1873
opts=
1874
prev=
1875
install_type=
1876
isdir=no
1877
stripme=
1878
for arg
1879
do
1880
if test -n "$dest"; then
1881
files="$files $dest"
1882
dest=$arg
1883
continue
1884
fi
1885
1886
case $arg in
1887
-d) isdir=yes ;;
1888
-f)
1889
case " $install_prog " in
1890
*[\\\ /]cp\ *) ;;
1891
*) prev=$arg ;;
1892
esac
1893
;;
1894
-g | -m | -o)
1895
prev=$arg
1896
;;
1897
-s)
1898
stripme=" -s"
1899
continue
1900
;;
1901
-*)
1902
;;
1903
*)
1904
# If the previous option needed an argument, then skip it.
1905
if test -n "$prev"; then
1906
prev=
1907
else
1908
dest=$arg
1909
continue
1910
fi
1911
;;
1912
esac
1913
1914
# Aesthetically quote the argument.
1915
func_quote_for_eval "$arg"
1916
install_prog="$install_prog $func_quote_for_eval_result"
1917
done
1918
1919
test -z "$install_prog" && \
1920
func_fatal_help "you must specify an install program"
1921
1922
test -n "$prev" && \
1923
func_fatal_help "the \`$prev' option requires an argument"
1924
1925
if test -z "$files"; then
1926
if test -z "$dest"; then
1927
func_fatal_help "no file or destination specified"
1928
else
1929
func_fatal_help "you must specify a destination"
1930
fi
1931
fi
1932
1933
# Strip any trailing slash from the destination.
1934
func_stripname '' '/' "$dest"
1935
dest=$func_stripname_result
1936
1937
# Check to see that the destination is a directory.
1938
test -d "$dest" && isdir=yes
1939
if test "$isdir" = yes; then
1940
destdir="$dest"
1941
destname=
1942
else
1943
func_dirname_and_basename "$dest" "" "."
1944
destdir="$func_dirname_result"
1945
destname="$func_basename_result"
1946
1947
# Not a directory, so check to see that there is only one file specified.
1948
set dummy $files; shift
1949
test "$#" -gt 1 && \
1950
func_fatal_help "\`$dest' is not a directory"
1951
fi
1952
case $destdir in
1953
[\\/]* | [A-Za-z]:[\\/]*) ;;
1954
*)
1955
for file in $files; do
1956
case $file in
1957
*.lo) ;;
1958
*)
1959
func_fatal_help "\`$destdir' must be an absolute directory name"
1960
;;
1961
esac
1962
done
1963
;;
1964
esac
1965
1966
# This variable tells wrapper scripts just to set variables rather
1967
# than running their programs.
1968
libtool_install_magic="$magic"
1969
1970
staticlibs=
1971
future_libdirs=
1972
current_libdirs=
1973
for file in $files; do
1974
1975
# Do each installation.
1976
case $file in
1977
*.$libext)
1978
# Do the static libraries later.
1979
staticlibs="$staticlibs $file"
1980
;;
1981
1982
*.la)
1983
# Check to see that this really is a libtool archive.
1984
func_lalib_unsafe_p "$file" \
1985
|| func_fatal_help "\`$file' is not a valid libtool archive"
1986
1987
library_names=
1988
old_library=
1989
relink_command=
1990
func_source "$file"
1991
1992
# Add the libdir to current_libdirs if it is the destination.
1993
if test "X$destdir" = "X$libdir"; then
1994
case "$current_libdirs " in
1995
*" $libdir "*) ;;
1996
*) current_libdirs="$current_libdirs $libdir" ;;
1997
esac
1998
else
1999
# Note the libdir as a future libdir.
2000
case "$future_libdirs " in
2001
*" $libdir "*) ;;
2002
*) future_libdirs="$future_libdirs $libdir" ;;
2003
esac
2004
fi
2005
2006
func_dirname "$file" "/" ""
2007
dir="$func_dirname_result"
2008
dir="$dir$objdir"
2009
2010
if test -n "$relink_command"; then
2011
# Determine the prefix the user has applied to our future dir.
2012
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2013
2014
# Don't allow the user to place us outside of our expected
2015
# location b/c this prevents finding dependent libraries that
2016
# are installed to the same prefix.
2017
# At present, this check doesn't affect windows .dll's that
2018
# are installed into $libdir/../bin (currently, that works fine)
2019
# but it's something to keep an eye on.
2020
test "$inst_prefix_dir" = "$destdir" && \
2021
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2022
2023
if test -n "$inst_prefix_dir"; then
2024
# Stick the inst_prefix_dir data into the link command.
2025
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2026
else
2027
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2028
fi
2029
2030
func_warning "relinking \`$file'"
2031
func_show_eval "$relink_command" \
2032
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2033
fi
2034
2035
# See the names of the shared library.
2036
set dummy $library_names; shift
2037
if test -n "$1"; then
2038
realname="$1"
2039
shift
2040
2041
srcname="$realname"
2042
test -n "$relink_command" && srcname="$realname"T
2043
2044
# Install the shared library and build the symlinks.
2045
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2046
'exit $?'
2047
tstripme="$stripme"
2048
case $host_os in
2049
cygwin* | mingw* | pw32*)
2050
case $realname in
2051
*.dll.a)
2052
tstripme=""
2053
;;
2054
esac
2055
;;
2056
esac
2057
if test -n "$tstripme" && test -n "$striplib"; then
2058
func_show_eval "$striplib $destdir/$realname" 'exit $?'
2059
fi
2060
2061
if test "$#" -gt 0; then
2062
# Delete the old symlinks, and create new ones.
2063
# Try `ln -sf' first, because the `ln' binary might depend on
2064
# the symlink we replace! Solaris /bin/ln does not understand -f,
2065
# so we also need to try rm && ln -s.
2066
for linkname
2067
do
2068
test "$linkname" != "$realname" \
2069
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2070
done
2071
fi
2072
2073
# Do each command in the postinstall commands.
2074
lib="$destdir/$realname"
2075
func_execute_cmds "$postinstall_cmds" 'exit $?'
2076
fi
2077
2078
# Install the pseudo-library for information purposes.
2079
func_basename "$file"
2080
name="$func_basename_result"
2081
instname="$dir/$name"i
2082
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2083
2084
# Maybe install the static library, too.
2085
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2086
;;
2087
2088
*.lo)
2089
# Install (i.e. copy) a libtool object.
2090
2091
# Figure out destination file name, if it wasn't already specified.
2092
if test -n "$destname"; then
2093
destfile="$destdir/$destname"
2094
else
2095
func_basename "$file"
2096
destfile="$func_basename_result"
2097
destfile="$destdir/$destfile"
2098
fi
2099
2100
# Deduce the name of the destination old-style object file.
2101
case $destfile in
2102
*.lo)
2103
func_lo2o "$destfile"
2104
staticdest=$func_lo2o_result
2105
;;
2106
*.$objext)
2107
staticdest="$destfile"
2108
destfile=
2109
;;
2110
*)
2111
func_fatal_help "cannot copy a libtool object to \`$destfile'"
2112
;;
2113
esac
2114
2115
# Install the libtool object if requested.
2116
test -n "$destfile" && \
2117
func_show_eval "$install_prog $file $destfile" 'exit $?'
2118
2119
# Install the old object if enabled.
2120
if test "$build_old_libs" = yes; then
2121
# Deduce the name of the old-style object file.
2122
func_lo2o "$file"
2123
staticobj=$func_lo2o_result
2124
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2125
fi
2126
exit $EXIT_SUCCESS
2127
;;
2128
2129
*)
2130
# Figure out destination file name, if it wasn't already specified.
2131
if test -n "$destname"; then
2132
destfile="$destdir/$destname"
2133
else
2134
func_basename "$file"
2135
destfile="$func_basename_result"
2136
destfile="$destdir/$destfile"
2137
fi
2138
2139
# If the file is missing, and there is a .exe on the end, strip it
2140
# because it is most likely a libtool script we actually want to
2141
# install
2142
stripped_ext=""
2143
case $file in
2144
*.exe)
2145
if test ! -f "$file"; then
2146
func_stripname '' '.exe' "$file"
2147
file=$func_stripname_result
2148
stripped_ext=".exe"
2149
fi
2150
;;
2151
esac
2152
2153
# Do a test to see if this is really a libtool program.
2154
case $host in
2155
*cygwin*|*mingw*)
2156
if func_ltwrapper_executable_p "$file"; then
2157
func_ltwrapper_scriptname "$file"
2158
wrapper=$func_ltwrapper_scriptname_result
2159
else
2160
func_stripname '' '.exe' "$file"
2161
wrapper=$func_stripname_result
2162
fi
2163
;;
2164
*)
2165
wrapper=$file
2166
;;
2167
esac
2168
if func_ltwrapper_script_p "$wrapper"; then
2169
notinst_deplibs=
2170
relink_command=
2171
2172
func_source "$wrapper"
2173
2174
# Check the variables that should have been set.
2175
test -z "$generated_by_libtool_version" && \
2176
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2177
2178
finalize=yes
2179
for lib in $notinst_deplibs; do
2180
# Check to see that each library is installed.
2181
libdir=
2182
if test -f "$lib"; then
2183
func_source "$lib"
2184
fi
2185
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2186
if test -n "$libdir" && test ! -f "$libfile"; then
2187
func_warning "\`$lib' has not been installed in \`$libdir'"
2188
finalize=no
2189
fi
2190
done
2191
2192
relink_command=
2193
func_source "$wrapper"
2194
2195
outputname=
2196
if test "$fast_install" = no && test -n "$relink_command"; then
2197
$opt_dry_run || {
2198
if test "$finalize" = yes; then
2199
tmpdir=`func_mktempdir`
2200
func_basename "$file$stripped_ext"
2201
file="$func_basename_result"
2202
outputname="$tmpdir/$file"
2203
# Replace the output file specification.
2204
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2205
2206
$opt_silent || {
2207
func_quote_for_expand "$relink_command"
2208
eval "func_echo $func_quote_for_expand_result"
2209
}
2210
if eval "$relink_command"; then :
2211
else
2212
func_error "error: relink \`$file' with the above command before installing it"
2213
$opt_dry_run || ${RM}r "$tmpdir"
2214
continue
2215
fi
2216
file="$outputname"
2217
else
2218
func_warning "cannot relink \`$file'"
2219
fi
2220
}
2221
else
2222
# Install the binary that we compiled earlier.
2223
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2224
fi
2225
fi
2226
2227
# remove .exe since cygwin /usr/bin/install will append another
2228
# one anyway
2229
case $install_prog,$host in
2230
*/usr/bin/install*,*cygwin*)
2231
case $file:$destfile in
2232
*.exe:*.exe)
2233
# this is ok
2234
;;
2235
*.exe:*)
2236
destfile=$destfile.exe
2237
;;
2238
*:*.exe)
2239
func_stripname '' '.exe' "$destfile"
2240
destfile=$func_stripname_result
2241
;;
2242
esac
2243
;;
2244
esac
2245
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2246
$opt_dry_run || if test -n "$outputname"; then
2247
${RM}r "$tmpdir"
2248
fi
2249
;;
2250
esac
2251
done
2252
2253
for file in $staticlibs; do
2254
func_basename "$file"
2255
name="$func_basename_result"
2256
2257
# Set up the ranlib parameters.
2258
oldlib="$destdir/$name"
2259
2260
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2261
2262
if test -n "$stripme" && test -n "$old_striplib"; then
2263
func_show_eval "$old_striplib $oldlib" 'exit $?'
2264
fi
2265
2266
# Do each command in the postinstall commands.
2267
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2268
done
2269
2270
test -n "$future_libdirs" && \
2271
func_warning "remember to run \`$progname --finish$future_libdirs'"
2272
2273
if test -n "$current_libdirs"; then
2274
# Maybe just do a dry run.
2275
$opt_dry_run && current_libdirs=" -n$current_libdirs"
2276
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2277
else
2278
exit $EXIT_SUCCESS
2279
fi
2280
}
2281
2282
test "$mode" = install && func_mode_install ${1+"$@"}
2283
2284
2285
# func_generate_dlsyms outputname originator pic_p
2286
# Extract symbols from dlprefiles and create ${outputname}S.o with
2287
# a dlpreopen symbol table.
2288
func_generate_dlsyms ()
2289
{
2290
$opt_debug
2291
my_outputname="$1"
2292
my_originator="$2"
2293
my_pic_p="${3-no}"
2294
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2295
my_dlsyms=
2296
2297
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2298
if test -n "$NM" && test -n "$global_symbol_pipe"; then
2299
my_dlsyms="${my_outputname}S.c"
2300
else
2301
func_error "not configured to extract global symbols from dlpreopened files"
2302
fi
2303
fi
2304
2305
if test -n "$my_dlsyms"; then
2306
case $my_dlsyms in
2307
"") ;;
2308
*.c)
2309
# Discover the nlist of each of the dlfiles.
2310
nlist="$output_objdir/${my_outputname}.nm"
2311
2312
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2313
2314
# Parse the name list into a source file.
2315
func_verbose "creating $output_objdir/$my_dlsyms"
2316
2317
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2318
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2319
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2320
2321
#ifdef __cplusplus
2322
extern \"C\" {
2323
#endif
2324
2325
/* External symbol declarations for the compiler. */\
2326
"
2327
2328
if test "$dlself" = yes; then
2329
func_verbose "generating symbol list for \`$output'"
2330
2331
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2332
2333
# Add our own program objects to the symbol list.
2334
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2335
for progfile in $progfiles; do
2336
func_verbose "extracting global C symbols from \`$progfile'"
2337
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2338
done
2339
2340
if test -n "$exclude_expsyms"; then
2341
$opt_dry_run || {
2342
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2343
eval '$MV "$nlist"T "$nlist"'
2344
}
2345
fi
2346
2347
if test -n "$export_symbols_regex"; then
2348
$opt_dry_run || {
2349
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2350
eval '$MV "$nlist"T "$nlist"'
2351
}
2352
fi
2353
2354
# Prepare the list of exported symbols
2355
if test -z "$export_symbols"; then
2356
export_symbols="$output_objdir/$outputname.exp"
2357
$opt_dry_run || {
2358
$RM $export_symbols
2359
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2360
case $host in
2361
*cygwin* | *mingw* )
2362
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2363
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2364
;;
2365
esac
2366
}
2367
else
2368
$opt_dry_run || {
2369
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2370
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2371
eval '$MV "$nlist"T "$nlist"'
2372
case $host in
2373
*cygwin | *mingw* )
2374
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2375
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2376
;;
2377
esac
2378
}
2379
fi
2380
fi
2381
2382
for dlprefile in $dlprefiles; do
2383
func_verbose "extracting global C symbols from \`$dlprefile'"
2384
func_basename "$dlprefile"
2385
name="$func_basename_result"
2386
$opt_dry_run || {
2387
eval '$ECHO ": $name " >> "$nlist"'
2388
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2389
}
2390
done
2391
2392
$opt_dry_run || {
2393
# Make sure we have at least an empty file.
2394
test -f "$nlist" || : > "$nlist"
2395
2396
if test -n "$exclude_expsyms"; then
2397
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2398
$MV "$nlist"T "$nlist"
2399
fi
2400
2401
# Try sorting and uniquifying the output.
2402
if $GREP -v "^: " < "$nlist" |
2403
if sort -k 3 </dev/null >/dev/null 2>&1; then
2404
sort -k 3
2405
else
2406
sort +2
2407
fi |
2408
uniq > "$nlist"S; then
2409
:
2410
else
2411
$GREP -v "^: " < "$nlist" > "$nlist"S
2412
fi
2413
2414
if test -f "$nlist"S; then
2415
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2416
else
2417
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2418
fi
2419
2420
$ECHO >> "$output_objdir/$my_dlsyms" "\
2421
2422
/* The mapping between symbol names and symbols. */
2423
typedef struct {
2424
const char *name;
2425
void *address;
2426
} lt_dlsymlist;
2427
"
2428
case $host in
2429
*cygwin* | *mingw* )
2430
$ECHO >> "$output_objdir/$my_dlsyms" "\
2431
/* DATA imports from DLLs on WIN32 con't be const, because
2432
runtime relocations are performed -- see ld's documentation
2433
on pseudo-relocs. */"
2434
lt_dlsym_const= ;;
2435
*osf5*)
2436
echo >> "$output_objdir/$my_dlsyms" "\
2437
/* This system does not cope well with relocations in const data */"
2438
lt_dlsym_const= ;;
2439
*)
2440
lt_dlsym_const=const ;;
2441
esac
2442
2443
$ECHO >> "$output_objdir/$my_dlsyms" "\
2444
extern $lt_dlsym_const lt_dlsymlist
2445
lt_${my_prefix}_LTX_preloaded_symbols[];
2446
$lt_dlsym_const lt_dlsymlist
2447
lt_${my_prefix}_LTX_preloaded_symbols[] =
2448
{\
2449
{ \"$my_originator\", (void *) 0 },"
2450
2451
case $need_lib_prefix in
2452
no)
2453
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2454
;;
2455
*)
2456
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2457
;;
2458
esac
2459
$ECHO >> "$output_objdir/$my_dlsyms" "\
2460
{0, (void *) 0}
2461
};
2462
2463
/* This works around a problem in FreeBSD linker */
2464
#ifdef FREEBSD_WORKAROUND
2465
static const void *lt_preloaded_setup() {
2466
return lt_${my_prefix}_LTX_preloaded_symbols;
2467
}
2468
#endif
2469
2470
#ifdef __cplusplus
2471
}
2472
#endif\
2473
"
2474
} # !$opt_dry_run
2475
2476
pic_flag_for_symtable=
2477
case "$compile_command " in
2478
*" -static "*) ;;
2479
*)
2480
case $host in
2481
# compiling the symbol table file with pic_flag works around
2482
# a FreeBSD bug that causes programs to crash when -lm is
2483
# linked before any other PIC object. But we must not use
2484
# pic_flag when linking with -static. The problem exists in
2485
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2486
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2487
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2488
*-*-hpux*)
2489
pic_flag_for_symtable=" $pic_flag" ;;
2490
*)
2491
if test "X$my_pic_p" != Xno; then
2492
pic_flag_for_symtable=" $pic_flag"
2493
fi
2494
;;
2495
esac
2496
;;
2497
esac
2498
symtab_cflags=
2499
for arg in $LTCFLAGS; do
2500
case $arg in
2501
-pie | -fpie | -fPIE) ;;
2502
*) symtab_cflags="$symtab_cflags $arg" ;;
2503
esac
2504
done
2505
2506
# Now compile the dynamic symbol file.
2507
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2508
2509
# Clean up the generated files.
2510
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2511
2512
# Transform the symbol file into the correct name.
2513
symfileobj="$output_objdir/${my_outputname}S.$objext"
2514
case $host in
2515
*cygwin* | *mingw* )
2516
if test -f "$output_objdir/$my_outputname.def"; then
2517
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2518
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519
else
2520
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2521
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522
fi
2523
;;
2524
*)
2525
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2526
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527
;;
2528
esac
2529
;;
2530
*)
2531
func_fatal_error "unknown suffix for \`$my_dlsyms'"
2532
;;
2533
esac
2534
else
2535
# We keep going just in case the user didn't refer to
2536
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2537
# really was required.
2538
2539
# Nullify the symbol file.
2540
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2541
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2542
fi
2543
}
2544
2545
# func_win32_libid arg
2546
# return the library type of file 'arg'
2547
#
2548
# Need a lot of goo to handle *both* DLLs and import libs
2549
# Has to be a shell function in order to 'eat' the argument
2550
# that is supplied when $file_magic_command is called.
2551
func_win32_libid ()
2552
{
2553
$opt_debug
2554
win32_libid_type="unknown"
2555
win32_fileres=`file -L $1 2>/dev/null`
2556
case $win32_fileres in
2557
*ar\ archive\ import\ library*) # definitely import
2558
win32_libid_type="x86 archive import"
2559
;;
2560
*ar\ archive*) # could be an import, or static
2561
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2562
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2563
win32_nmres=`eval $NM -f posix -A $1 |
2564
$SED -n -e '
2565
1,100{
2566
/ I /{
2567
s,.*,import,
2568
p
2569
q
2570
}
2571
}'`
2572
case $win32_nmres in
2573
import*) win32_libid_type="x86 archive import";;
2574
*) win32_libid_type="x86 archive static";;
2575
esac
2576
fi
2577
;;
2578
*DLL*)
2579
win32_libid_type="x86 DLL"
2580
;;
2581
*executable*) # but shell scripts are "executable" too...
2582
case $win32_fileres in
2583
*MS\ Windows\ PE\ Intel*)
2584
win32_libid_type="x86 DLL"
2585
;;
2586
esac
2587
;;
2588
esac
2589
$ECHO "$win32_libid_type"
2590
}
2591
2592
2593
2594
# func_extract_an_archive dir oldlib
2595
func_extract_an_archive ()
2596
{
2597
$opt_debug
2598
f_ex_an_ar_dir="$1"; shift
2599
f_ex_an_ar_oldlib="$1"
2600
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2601
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2602
:
2603
else
2604
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2605
fi
2606
}
2607
2608
2609
# func_extract_archives gentop oldlib ...
2610
func_extract_archives ()
2611
{
2612
$opt_debug
2613
my_gentop="$1"; shift
2614
my_oldlibs=${1+"$@"}
2615
my_oldobjs=""
2616
my_xlib=""
2617
my_xabs=""
2618
my_xdir=""
2619
2620
for my_xlib in $my_oldlibs; do
2621
# Extract the objects.
2622
case $my_xlib in
2623
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2624
*) my_xabs=`pwd`"/$my_xlib" ;;
2625
esac
2626
func_basename "$my_xlib"
2627
my_xlib="$func_basename_result"
2628
my_xlib_u=$my_xlib
2629
while :; do
2630
case " $extracted_archives " in
2631
*" $my_xlib_u "*)
2632
func_arith $extracted_serial + 1
2633
extracted_serial=$func_arith_result
2634
my_xlib_u=lt$extracted_serial-$my_xlib ;;
2635
*) break ;;
2636
esac
2637
done
2638
extracted_archives="$extracted_archives $my_xlib_u"
2639
my_xdir="$my_gentop/$my_xlib_u"
2640
2641
func_mkdir_p "$my_xdir"
2642
2643
case $host in
2644
*-darwin*)
2645
func_verbose "Extracting $my_xabs"
2646
# Do not bother doing anything if just a dry run
2647
$opt_dry_run || {
2648
darwin_orig_dir=`pwd`
2649
cd $my_xdir || exit $?
2650
darwin_archive=$my_xabs
2651
darwin_curdir=`pwd`
2652
darwin_base_archive=`basename "$darwin_archive"`
2653
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2654
if test -n "$darwin_arches"; then
2655
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2656
darwin_arch=
2657
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2658
for darwin_arch in $darwin_arches ; do
2659
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2660
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2661
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2662
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2663
cd "$darwin_curdir"
2664
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2665
done # $darwin_arches
2666
## Okay now we've a bunch of thin objects, gotta fatten them up :)
2667
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2668
darwin_file=
2669
darwin_files=
2670
for darwin_file in $darwin_filelist; do
2671
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2672
$LIPO -create -output "$darwin_file" $darwin_files
2673
done # $darwin_filelist
2674
$RM -rf unfat-$$
2675
cd "$darwin_orig_dir"
2676
else
2677
cd $darwin_orig_dir
2678
func_extract_an_archive "$my_xdir" "$my_xabs"
2679
fi # $darwin_arches
2680
} # !$opt_dry_run
2681
;;
2682
*)
2683
func_extract_an_archive "$my_xdir" "$my_xabs"
2684
;;
2685
esac
2686
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2687
done
2688
2689
func_extract_archives_result="$my_oldobjs"
2690
}
2691
2692
2693
2694
# func_emit_wrapper arg
2695
#
2696
# emit a libtool wrapper script on stdout
2697
# don't directly open a file because we may want to
2698
# incorporate the script contents within a cygwin/mingw
2699
# wrapper executable. Must ONLY be called from within
2700
# func_mode_link because it depends on a number of variable
2701
# set therein.
2702
#
2703
# arg is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2704
# variable will take. If 'yes', then the emitted script
2705
# will assume that the directory in which it is stored is
2706
# the '.lib' directory. This is a cygwin/mingw-specific
2707
# behavior.
2708
func_emit_wrapper ()
2709
{
2710
func_emit_wrapper_arg1=no
2711
if test -n "$1" ; then
2712
func_emit_wrapper_arg1=$1
2713
fi
2714
2715
$ECHO "\
2716
#! $SHELL
2717
2718
# $output - temporary wrapper script for $objdir/$outputname
2719
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2720
#
2721
# The $output program cannot be directly executed until all the libtool
2722
# libraries that it depends on are installed.
2723
#
2724
# This wrapper script should never be moved out of the build directory.
2725
# If it is, it will not operate correctly.
2726
2727
# Sed substitution that helps us do robust quoting. It backslashifies
2728
# metacharacters that are still active within double-quoted strings.
2729
Xsed='${SED} -e 1s/^X//'
2730
sed_quote_subst='$sed_quote_subst'
2731
2732
# Be Bourne compatible
2733
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2734
emulate sh
2735
NULLCMD=:
2736
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2737
# is contrary to our usage. Disable this feature.
2738
alias -g '\${1+\"\$@\"}'='\"\$@\"'
2739
setopt NO_GLOB_SUBST
2740
else
2741
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2742
fi
2743
BIN_SH=xpg4; export BIN_SH # for Tru64
2744
DUALCASE=1; export DUALCASE # for MKS sh
2745
2746
# The HP-UX ksh and POSIX shell print the target directory to stdout
2747
# if CDPATH is set.
2748
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2749
2750
relink_command=\"$relink_command\"
2751
2752
# This environment variable determines our operation mode.
2753
if test \"\$libtool_install_magic\" = \"$magic\"; then
2754
# install mode needs the following variables:
2755
generated_by_libtool_version='$macro_version'
2756
notinst_deplibs='$notinst_deplibs'
2757
else
2758
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2759
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2760
ECHO=\"$qecho\"
2761
file=\"\$0\"
2762
# Make sure echo works.
2763
if test \"X\$1\" = X--no-reexec; then
2764
# Discard the --no-reexec flag, and continue.
2765
shift
2766
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2767
# Yippee, \$ECHO works!
2768
:
2769
else
2770
# Restart under the correct shell, and then maybe \$ECHO will work.
2771
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2772
fi
2773
fi\
2774
"
2775
$ECHO "\
2776
2777
# Find the directory that this script lives in.
2778
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2779
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2780
2781
# Follow symbolic links until we get to the real thisdir.
2782
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2783
while test -n \"\$file\"; do
2784
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2785
2786
# If there was a directory component, then change thisdir.
2787
if test \"x\$destdir\" != \"x\$file\"; then
2788
case \"\$destdir\" in
2789
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2790
*) thisdir=\"\$thisdir/\$destdir\" ;;
2791
esac
2792
fi
2793
2794
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2795
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2796
done
2797
2798
# Usually 'no', except on cygwin/mingw when embedded into
2799
# the cwrapper.
2800
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
2801
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2802
# special case for '.'
2803
if test \"\$thisdir\" = \".\"; then
2804
thisdir=\`pwd\`
2805
fi
2806
# remove .libs from thisdir
2807
case \"\$thisdir\" in
2808
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2809
$objdir ) thisdir=. ;;
2810
esac
2811
fi
2812
2813
# Try to get the absolute directory name.
2814
absdir=\`cd \"\$thisdir\" && pwd\`
2815
test -n \"\$absdir\" && thisdir=\"\$absdir\"
2816
"
2817
2818
if test "$fast_install" = yes; then
2819
$ECHO "\
2820
program=lt-'$outputname'$exeext
2821
progdir=\"\$thisdir/$objdir\"
2822
2823
if test ! -f \"\$progdir/\$program\" ||
2824
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2825
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2826
2827
file=\"\$\$-\$program\"
2828
2829
if test ! -d \"\$progdir\"; then
2830
$MKDIR \"\$progdir\"
2831
else
2832
$RM \"\$progdir/\$file\"
2833
fi"
2834
2835
$ECHO "\
2836
2837
# relink executable if necessary
2838
if test -n \"\$relink_command\"; then
2839
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2840
else
2841
$ECHO \"\$relink_command_output\" >&2
2842
$RM \"\$progdir/\$file\"
2843
exit 1
2844
fi
2845
fi
2846
2847
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2848
{ $RM \"\$progdir/\$program\";
2849
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2850
$RM \"\$progdir/\$file\"
2851
fi"
2852
else
2853
$ECHO "\
2854
program='$outputname'
2855
progdir=\"\$thisdir/$objdir\"
2856
"
2857
fi
2858
2859
$ECHO "\
2860
2861
if test -f \"\$progdir/\$program\"; then"
2862
2863
# Export our shlibpath_var if we have one.
2864
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2865
$ECHO "\
2866
# Add our own library path to $shlibpath_var
2867
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2868
2869
# Some systems cannot cope with colon-terminated $shlibpath_var
2870
# The second colon is a workaround for a bug in BeOS R4 sed
2871
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2872
2873
export $shlibpath_var
2874
"
2875
fi
2876
2877
# fixup the dll searchpath if we need to.
2878
if test -n "$dllsearchpath"; then
2879
$ECHO "\
2880
# Add the dll search path components to the executable PATH
2881
PATH=$dllsearchpath:\$PATH
2882
"
2883
fi
2884
2885
$ECHO "\
2886
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2887
# Run the actual program with our arguments.
2888
"
2889
case $host in
2890
# Backslashes separate directories on plain windows
2891
*-*-mingw | *-*-os2*)
2892
$ECHO "\
2893
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2894
"
2895
;;
2896
2897
*)
2898
$ECHO "\
2899
exec \"\$progdir/\$program\" \${1+\"\$@\"}
2900
"
2901
;;
2902
esac
2903
$ECHO "\
2904
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2905
exit 1
2906
fi
2907
else
2908
# The program doesn't exist.
2909
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2910
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2911
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2912
exit 1
2913
fi
2914
fi\
2915
"
2916
}
2917
# end: func_emit_wrapper
2918
2919
# func_emit_cwrapperexe_src
2920
# emit the source code for a wrapper executable on stdout
2921
# Must ONLY be called from within func_mode_link because
2922
# it depends on a number of variable set therein.
2923
func_emit_cwrapperexe_src ()
2924
{
2925
cat <<EOF
2926
2927
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
2928
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2929
2930
The $output program cannot be directly executed until all the libtool
2931
libraries that it depends on are installed.
2932
2933
This wrapper executable should never be moved out of the build directory.
2934
If it is, it will not operate correctly.
2935
2936
Currently, it simply execs the wrapper *script* "$SHELL $output",
2937
but could eventually absorb all of the scripts functionality and
2938
exec $objdir/$outputname directly.
2939
*/
2940
EOF
2941
cat <<"EOF"
2942
#include <stdio.h>
2943
#include <stdlib.h>
2944
#ifdef _MSC_VER
2945
# include <direct.h>
2946
# include <process.h>
2947
# include <io.h>
2948
# define setmode _setmode
2949
#else
2950
# include <unistd.h>
2951
# include <stdint.h>
2952
# ifdef __CYGWIN__
2953
# include <io.h>
2954
# endif
2955
#endif
2956
#include <malloc.h>
2957
#include <stdarg.h>
2958
#include <assert.h>
2959
#include <string.h>
2960
#include <ctype.h>
2961
#include <errno.h>
2962
#include <fcntl.h>
2963
#include <sys/stat.h>
2964
2965
#if defined(PATH_MAX)
2966
# define LT_PATHMAX PATH_MAX
2967
#elif defined(MAXPATHLEN)
2968
# define LT_PATHMAX MAXPATHLEN
2969
#else
2970
# define LT_PATHMAX 1024
2971
#endif
2972
2973
#ifndef S_IXOTH
2974
# define S_IXOTH 0
2975
#endif
2976
#ifndef S_IXGRP
2977
# define S_IXGRP 0
2978
#endif
2979
2980
#ifdef _MSC_VER
2981
# define S_IXUSR _S_IEXEC
2982
# define stat _stat
2983
# ifndef _INTPTR_T_DEFINED
2984
# define intptr_t int
2985
# endif
2986
#endif
2987
2988
#ifndef DIR_SEPARATOR
2989
# define DIR_SEPARATOR '/'
2990
# define PATH_SEPARATOR ':'
2991
#endif
2992
2993
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
2994
defined (__OS2__)
2995
# define HAVE_DOS_BASED_FILE_SYSTEM
2996
# define FOPEN_WB "wb"
2997
# ifndef DIR_SEPARATOR_2
2998
# define DIR_SEPARATOR_2 '\\'
2999
# endif
3000
# ifndef PATH_SEPARATOR_2
3001
# define PATH_SEPARATOR_2 ';'
3002
# endif
3003
#endif
3004
3005
#ifndef DIR_SEPARATOR_2
3006
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3007
#else /* DIR_SEPARATOR_2 */
3008
# define IS_DIR_SEPARATOR(ch) \
3009
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3010
#endif /* DIR_SEPARATOR_2 */
3011
3012
#ifndef PATH_SEPARATOR_2
3013
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3014
#else /* PATH_SEPARATOR_2 */
3015
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3016
#endif /* PATH_SEPARATOR_2 */
3017
3018
#ifdef __CYGWIN__
3019
# define FOPEN_WB "wb"
3020
#endif
3021
3022
#ifndef FOPEN_WB
3023
# define FOPEN_WB "w"
3024
#endif
3025
#ifndef _O_BINARY
3026
# define _O_BINARY 0
3027
#endif
3028
3029
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3030
#define XFREE(stale) do { \
3031
if (stale) { free ((void *) stale); stale = 0; } \
3032
} while (0)
3033
3034
#undef LTWRAPPER_DEBUGPRINTF
3035
#if defined DEBUGWRAPPER
3036
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3037
static void
3038
ltwrapper_debugprintf (const char *fmt, ...)
3039
{
3040
va_list args;
3041
va_start (args, fmt);
3042
(void) vfprintf (stderr, fmt, args);
3043
va_end (args);
3044
}
3045
#else
3046
# define LTWRAPPER_DEBUGPRINTF(args)
3047
#endif
3048
3049
const char *program_name = NULL;
3050
3051
void *xmalloc (size_t num);
3052
char *xstrdup (const char *string);
3053
const char *base_name (const char *name);
3054
char *find_executable (const char *wrapper);
3055
char *chase_symlinks (const char *pathspec);
3056
int make_executable (const char *path);
3057
int check_executable (const char *path);
3058
char *strendzap (char *str, const char *pat);
3059
void lt_fatal (const char *message, ...);
3060
3061
static const char *script_text =
3062
EOF
3063
3064
func_emit_wrapper yes |
3065
$SED -e 's/\([\\"]\)/\\\1/g' \
3066
-e 's/^/ "/' -e 's/$/\\n"/'
3067
echo ";"
3068
3069
cat <<EOF
3070
const char * MAGIC_EXE = "$magic_exe";
3071
3072
int
3073
main (int argc, char *argv[])
3074
{
3075
char **newargz;
3076
char *tmp_pathspec;
3077
char *actual_cwrapper_path;
3078
char *shwrapper_name;
3079
intptr_t rval = 127;
3080
FILE *shwrapper;
3081
3082
const char *dumpscript_opt = "--lt-dump-script";
3083
int i;
3084
3085
program_name = (char *) xstrdup (base_name (argv[0]));
3086
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3087
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3088
3089
/* very simple arg parsing; don't want to rely on getopt */
3090
for (i = 1; i < argc; i++)
3091
{
3092
if (strcmp (argv[i], dumpscript_opt) == 0)
3093
{
3094
EOF
3095
case "$host" in
3096
*mingw* | *cygwin* )
3097
# make stdout use "unix" line endings
3098
echo " setmode(1,_O_BINARY);"
3099
;;
3100
esac
3101
3102
cat <<EOF
3103
printf ("%s", script_text);
3104
return 0;
3105
}
3106
}
3107
3108
newargz = XMALLOC (char *, argc + 2);
3109
EOF
3110
3111
if test -n "$TARGETSHELL" ; then
3112
# no path translation at all
3113
lt_newargv0=$TARGETSHELL
3114
else
3115
case "$host" in
3116
*mingw* )
3117
# awkward: cmd appends spaces to result
3118
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3119
lt_newargv0=`( cmd //c echo $SHELL | $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo $SHELL`
3120
case $lt_newargv0 in
3121
*.exe | *.EXE) ;;
3122
*) lt_newargv0=$lt_newargv0.exe ;;
3123
esac
3124
;;
3125
* ) lt_newargv0=$SHELL ;;
3126
esac
3127
fi
3128
3129
cat <<EOF
3130
newargz[0] = (char *) xstrdup ("$lt_newargv0");
3131
EOF
3132
3133
cat <<"EOF"
3134
tmp_pathspec = find_executable (argv[0]);
3135
if (tmp_pathspec == NULL)
3136
lt_fatal ("Couldn't find %s", argv[0]);
3137
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3138
tmp_pathspec));
3139
3140
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3141
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3142
actual_cwrapper_path));
3143
XFREE (tmp_pathspec);
3144
3145
shwrapper_name = (char *) xstrdup (base_name (actual_cwrapper_path));
3146
strendzap (actual_cwrapper_path, shwrapper_name);
3147
3148
/* shwrapper_name transforms */
3149
strendzap (shwrapper_name, ".exe");
3150
tmp_pathspec = XMALLOC (char, (strlen (shwrapper_name) +
3151
strlen ("_ltshwrapperTMP") + 1));
3152
strcpy (tmp_pathspec, shwrapper_name);
3153
strcat (tmp_pathspec, "_ltshwrapperTMP");
3154
XFREE (shwrapper_name);
3155
shwrapper_name = tmp_pathspec;
3156
tmp_pathspec = 0;
3157
LTWRAPPER_DEBUGPRINTF (("(main) libtool shell wrapper name: %s\n",
3158
shwrapper_name));
3159
EOF
3160
3161
cat <<EOF
3162
newargz[1] =
3163
XMALLOC (char, (strlen (actual_cwrapper_path) +
3164
strlen ("$objdir") + 1 + strlen (shwrapper_name) + 1));
3165
strcpy (newargz[1], actual_cwrapper_path);
3166
strcat (newargz[1], "$objdir");
3167
strcat (newargz[1], "/");
3168
strcat (newargz[1], shwrapper_name);
3169
EOF
3170
3171
3172
case $host_os in
3173
mingw*)
3174
cat <<"EOF"
3175
{
3176
char* p;
3177
while ((p = strchr (newargz[1], '\\')) != NULL)
3178
{
3179
*p = '/';
3180
}
3181
}
3182
EOF
3183
;;
3184
esac
3185
3186
cat <<"EOF"
3187
XFREE (shwrapper_name);
3188
XFREE (actual_cwrapper_path);
3189
3190
/* always write in binary mode */
3191
if ((shwrapper = fopen (newargz[1], FOPEN_WB)) == 0)
3192
{
3193
lt_fatal ("Could not open %s for writing", newargz[1]);
3194
}
3195
fprintf (shwrapper, "%s", script_text);
3196
fclose (shwrapper);
3197
3198
make_executable (newargz[1]);
3199
3200
for (i = 1; i < argc; i++)
3201
newargz[i + 1] = xstrdup (argv[i]);
3202
newargz[argc + 1] = NULL;
3203
3204
for (i = 0; i < argc + 1; i++)
3205
{
3206
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, newargz[i]));
3207
}
3208
3209
EOF
3210
3211
case $host_os in
3212
mingw*)
3213
cat <<EOF
3214
/* execv doesn't actually work on mingw as expected on unix */
3215
rval = _spawnv (_P_WAIT, "$lt_newargv0", (const char * const *) newargz);
3216
if (rval == -1)
3217
{
3218
/* failed to start process */
3219
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"$lt_newargv0\": errno = %d\n", errno));
3220
return 127;
3221
}
3222
return rval;
3223
}
3224
EOF
3225
;;
3226
*)
3227
cat <<EOF
3228
execv ("$lt_newargv0", newargz);
3229
return rval; /* =127, but avoids unused variable warning */
3230
}
3231
EOF
3232
;;
3233
esac
3234
3235
cat <<"EOF"
3236
3237
void *
3238
xmalloc (size_t num)
3239
{
3240
void *p = (void *) malloc (num);
3241
if (!p)
3242
lt_fatal ("Memory exhausted");
3243
3244
return p;
3245
}
3246
3247
char *
3248
xstrdup (const char *string)
3249
{
3250
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3251
string) : NULL;
3252
}
3253
3254
const char *
3255
base_name (const char *name)
3256
{
3257
const char *base;
3258
3259
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3260
/* Skip over the disk name in MSDOS pathnames. */
3261
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3262
name += 2;
3263
#endif
3264
3265
for (base = name; *name; name++)
3266
if (IS_DIR_SEPARATOR (*name))
3267
base = name + 1;
3268
return base;
3269
}
3270
3271
int
3272
check_executable (const char *path)
3273
{
3274
struct stat st;
3275
3276
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3277
path ? (*path ? path : "EMPTY!") : "NULL!"));
3278
if ((!path) || (!*path))
3279
return 0;
3280
3281
if ((stat (path, &st) >= 0)
3282
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3283
return 1;
3284
else
3285
return 0;
3286
}
3287
3288
int
3289
make_executable (const char *path)
3290
{
3291
int rval = 0;
3292
struct stat st;
3293
3294
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3295
path ? (*path ? path : "EMPTY!") : "NULL!"));
3296
if ((!path) || (!*path))
3297
return 0;
3298
3299
if (stat (path, &st) >= 0)
3300
{
3301
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3302
}
3303
return rval;
3304
}
3305
3306
/* Searches for the full path of the wrapper. Returns
3307
newly allocated full path name if found, NULL otherwise
3308
Does not chase symlinks, even on platforms that support them.
3309
*/
3310
char *
3311
find_executable (const char *wrapper)
3312
{
3313
int has_slash = 0;
3314
const char *p;
3315
const char *p_next;
3316
/* static buffer for getcwd */
3317
char tmp[LT_PATHMAX + 1];
3318
int tmp_len;
3319
char *concat_name;
3320
3321
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3322
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3323
3324
if ((wrapper == NULL) || (*wrapper == '\0'))
3325
return NULL;
3326
3327
/* Absolute path? */
3328
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3329
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3330
{
3331
concat_name = xstrdup (wrapper);
3332
if (check_executable (concat_name))
3333
return concat_name;
3334
XFREE (concat_name);
3335
}
3336
else
3337
{
3338
#endif
3339
if (IS_DIR_SEPARATOR (wrapper[0]))
3340
{
3341
concat_name = xstrdup (wrapper);
3342
if (check_executable (concat_name))
3343
return concat_name;
3344
XFREE (concat_name);
3345
}
3346
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3347
}
3348
#endif
3349
3350
for (p = wrapper; *p; p++)
3351
if (*p == '/')
3352
{
3353
has_slash = 1;
3354
break;
3355
}
3356
if (!has_slash)
3357
{
3358
/* no slashes; search PATH */
3359
const char *path = getenv ("PATH");
3360
if (path != NULL)
3361
{
3362
for (p = path; *p; p = p_next)
3363
{
3364
const char *q;
3365
size_t p_len;
3366
for (q = p; *q; q++)
3367
if (IS_PATH_SEPARATOR (*q))
3368
break;
3369
p_len = q - p;
3370
p_next = (*q == '\0' ? q : q + 1);
3371
if (p_len == 0)
3372
{
3373
/* empty path: current directory */
3374
if (getcwd (tmp, LT_PATHMAX) == NULL)
3375
lt_fatal ("getcwd failed");
3376
tmp_len = strlen (tmp);
3377
concat_name =
3378
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3379
memcpy (concat_name, tmp, tmp_len);
3380
concat_name[tmp_len] = '/';
3381
strcpy (concat_name + tmp_len + 1, wrapper);
3382
}
3383
else
3384
{
3385
concat_name =
3386
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3387
memcpy (concat_name, p, p_len);
3388
concat_name[p_len] = '/';
3389
strcpy (concat_name + p_len + 1, wrapper);
3390
}
3391
if (check_executable (concat_name))
3392
return concat_name;
3393
XFREE (concat_name);
3394
}
3395
}
3396
/* not found in PATH; assume curdir */
3397
}
3398
/* Relative path | not found in path: prepend cwd */
3399
if (getcwd (tmp, LT_PATHMAX) == NULL)
3400
lt_fatal ("getcwd failed");
3401
tmp_len = strlen (tmp);
3402
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3403
memcpy (concat_name, tmp, tmp_len);
3404
concat_name[tmp_len] = '/';
3405
strcpy (concat_name + tmp_len + 1, wrapper);
3406
3407
if (check_executable (concat_name))
3408
return concat_name;
3409
XFREE (concat_name);
3410
return NULL;
3411
}
3412
3413
char *
3414
chase_symlinks (const char *pathspec)
3415
{
3416
#ifndef S_ISLNK
3417
return xstrdup (pathspec);
3418
#else
3419
char buf[LT_PATHMAX];
3420
struct stat s;
3421
char *tmp_pathspec = xstrdup (pathspec);
3422
char *p;
3423
int has_symlinks = 0;
3424
while (strlen (tmp_pathspec) && !has_symlinks)
3425
{
3426
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3427
tmp_pathspec));
3428
if (lstat (tmp_pathspec, &s) == 0)
3429
{
3430
if (S_ISLNK (s.st_mode) != 0)
3431
{
3432
has_symlinks = 1;
3433
break;
3434
}
3435
3436
/* search backwards for last DIR_SEPARATOR */
3437
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3438
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3439
p--;
3440
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3441
{
3442
/* no more DIR_SEPARATORS left */
3443
break;
3444
}
3445
*p = '\0';
3446
}
3447
else
3448
{
3449
char *errstr = strerror (errno);
3450
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3451
}
3452
}
3453
XFREE (tmp_pathspec);
3454
3455
if (!has_symlinks)
3456
{
3457
return xstrdup (pathspec);
3458
}
3459
3460
tmp_pathspec = realpath (pathspec, buf);
3461
if (tmp_pathspec == 0)
3462
{
3463
lt_fatal ("Could not follow symlinks for %s", pathspec);
3464
}
3465
return xstrdup (tmp_pathspec);
3466
#endif
3467
}
3468
3469
char *
3470
strendzap (char *str, const char *pat)
3471
{
3472
size_t len, patlen;
3473
3474
assert (str != NULL);
3475
assert (pat != NULL);
3476
3477
len = strlen (str);
3478
patlen = strlen (pat);
3479
3480
if (patlen <= len)
3481
{
3482
str += len - patlen;
3483
if (strcmp (str, pat) == 0)
3484
*str = '\0';
3485
}
3486
return str;
3487
}
3488
3489
static void
3490
lt_error_core (int exit_status, const char *mode,
3491
const char *message, va_list ap)
3492
{
3493
fprintf (stderr, "%s: %s: ", program_name, mode);
3494
vfprintf (stderr, message, ap);
3495
fprintf (stderr, ".\n");
3496
3497
if (exit_status >= 0)
3498
exit (exit_status);
3499
}
3500
3501
void
3502
lt_fatal (const char *message, ...)
3503
{
3504
va_list ap;
3505
va_start (ap, message);
3506
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3507
va_end (ap);
3508
}
3509
EOF
3510
}
3511
# end: func_emit_cwrapperexe_src
3512
3513
# func_mode_link arg...
3514
func_mode_link ()
3515
{
3516
$opt_debug
3517
case $host in
3518
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3519
# It is impossible to link a dll without this setting, and
3520
# we shouldn't force the makefile maintainer to figure out
3521
# which system we are compiling for in order to pass an extra
3522
# flag for every libtool invocation.
3523
# allow_undefined=no
3524
3525
# FIXME: Unfortunately, there are problems with the above when trying
3526
# to make a dll which has undefined symbols, in which case not
3527
# even a static library is built. For now, we need to specify
3528
# -no-undefined on the libtool link line when we can be certain
3529
# that all symbols are satisfied, otherwise we get a static library.
3530
allow_undefined=yes
3531
;;
3532
*)
3533
allow_undefined=yes
3534
;;
3535
esac
3536
libtool_args=$nonopt
3537
base_compile="$nonopt $@"
3538
compile_command=$nonopt
3539
finalize_command=$nonopt
3540
3541
compile_rpath=
3542
finalize_rpath=
3543
compile_shlibpath=
3544
finalize_shlibpath=
3545
convenience=
3546
old_convenience=
3547
deplibs=
3548
old_deplibs=
3549
compiler_flags=
3550
linker_flags=
3551
dllsearchpath=
3552
lib_search_path=`pwd`
3553
inst_prefix_dir=
3554
new_inherited_linker_flags=
3555
3556
avoid_version=no
3557
dlfiles=
3558
dlprefiles=
3559
dlself=no
3560
export_dynamic=no
3561
export_symbols=
3562
export_symbols_regex=
3563
generated=
3564
libobjs=
3565
ltlibs=
3566
module=no
3567
no_install=no
3568
objs=
3569
non_pic_objects=
3570
precious_files_regex=
3571
prefer_static_libs=no
3572
preload=no
3573
prev=
3574
prevarg=
3575
release=
3576
rpath=
3577
xrpath=
3578
perm_rpath=
3579
temp_rpath=
3580
thread_safe=no
3581
vinfo=
3582
vinfo_number=no
3583
weak_libs=
3584
single_module="${wl}-single_module"
3585
func_infer_tag $base_compile
3586
3587
# We need to know -static, to get the right output filenames.
3588
for arg
3589
do
3590
case $arg in
3591
-shared)
3592
test "$build_libtool_libs" != yes && \
3593
func_fatal_configuration "can not build a shared library"
3594
build_old_libs=no
3595
break
3596
;;
3597
-all-static | -static | -static-libtool-libs)
3598
case $arg in
3599
-all-static)
3600
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
3601
func_warning "complete static linking is impossible in this configuration"
3602
fi
3603
if test -n "$link_static_flag"; then
3604
dlopen_self=$dlopen_self_static
3605
fi
3606
prefer_static_libs=yes
3607
;;
3608
-static)
3609
if test -z "$pic_flag" && test -n "$link_static_flag"; then
3610
dlopen_self=$dlopen_self_static
3611
fi
3612
prefer_static_libs=built
3613
;;
3614
-static-libtool-libs)
3615
if test -z "$pic_flag" && test -n "$link_static_flag"; then
3616
dlopen_self=$dlopen_self_static
3617
fi
3618
prefer_static_libs=yes
3619
;;
3620
esac
3621
build_libtool_libs=no
3622
build_old_libs=yes
3623
break
3624
;;
3625
esac
3626
done
3627
3628
# See if our shared archives depend on static archives.
3629
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
3630
3631
# Go through the arguments, transforming them on the way.
3632
while test "$#" -gt 0; do
3633
arg="$1"
3634
shift
3635
func_quote_for_eval "$arg"
3636
qarg=$func_quote_for_eval_unquoted_result
3637
func_append libtool_args " $func_quote_for_eval_result"
3638
3639
# If the previous option needs an argument, assign it.
3640
if test -n "$prev"; then
3641
case $prev in
3642
output)
3643
func_append compile_command " @OUTPUT@"
3644
func_append finalize_command " @OUTPUT@"
3645
;;
3646
esac
3647
3648
case $prev in
3649
dlfiles|dlprefiles)
3650
if test "$preload" = no; then
3651
# Add the symbol object into the linking commands.
3652
func_append compile_command " @SYMFILE@"
3653
func_append finalize_command " @SYMFILE@"
3654
preload=yes
3655
fi
3656
case $arg in
3657
*.la | *.lo) ;; # We handle these cases below.
3658
force)
3659
if test "$dlself" = no; then
3660
dlself=needless
3661
export_dynamic=yes
3662
fi
3663
prev=
3664
continue
3665
;;
3666
self)
3667
if test "$prev" = dlprefiles; then
3668
dlself=yes
3669
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
3670
dlself=yes
3671
else
3672
dlself=needless
3673
export_dynamic=yes
3674
fi
3675
prev=
3676
continue
3677
;;
3678
*)
3679
if test "$prev" = dlfiles; then
3680
dlfiles="$dlfiles $arg"
3681
else
3682
dlprefiles="$dlprefiles $arg"
3683
fi
3684
prev=
3685
continue
3686
;;
3687
esac
3688
;;
3689
expsyms)
3690
export_symbols="$arg"
3691
test -f "$arg" \
3692
|| func_fatal_error "symbol file \`$arg' does not exist"
3693
prev=
3694
continue
3695
;;
3696
expsyms_regex)
3697
export_symbols_regex="$arg"
3698
prev=
3699
continue
3700
;;
3701
framework)
3702
case $host in
3703
*-*-darwin*)
3704
case "$deplibs " in
3705
*" $qarg.ltframework "*) ;;
3706
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
3707
;;
3708
esac
3709
;;
3710
esac
3711
prev=
3712
continue
3713
;;
3714
inst_prefix)
3715
inst_prefix_dir="$arg"
3716
prev=
3717
continue
3718
;;
3719
objectlist)
3720
if test -f "$arg"; then
3721
save_arg=$arg
3722
moreargs=
3723
for fil in `cat "$save_arg"`
3724
do
3725
# moreargs="$moreargs $fil"
3726
arg=$fil
3727
# A libtool-controlled object.
3728
3729
# Check to see that this really is a libtool object.
3730
if func_lalib_unsafe_p "$arg"; then
3731
pic_object=
3732
non_pic_object=
3733
3734
# Read the .lo file
3735
func_source "$arg"
3736
3737
if test -z "$pic_object" ||
3738
test -z "$non_pic_object" ||
3739
test "$pic_object" = none &&
3740
test "$non_pic_object" = none; then
3741
func_fatal_error "cannot find name of object for \`$arg'"
3742
fi
3743
3744
# Extract subdirectory from the argument.
3745
func_dirname "$arg" "/" ""
3746
xdir="$func_dirname_result"
3747
3748
if test "$pic_object" != none; then
3749
# Prepend the subdirectory the object is found in.
3750
pic_object="$xdir$pic_object"
3751
3752
if test "$prev" = dlfiles; then
3753
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
3754
dlfiles="$dlfiles $pic_object"
3755
prev=
3756
continue
3757
else
3758
# If libtool objects are unsupported, then we need to preload.
3759
prev=dlprefiles
3760
fi
3761
fi
3762
3763
# CHECK ME: I think I busted this. -Ossama
3764
if test "$prev" = dlprefiles; then
3765
# Preload the old-style object.
3766
dlprefiles="$dlprefiles $pic_object"
3767
prev=
3768
fi
3769
3770
# A PIC object.
3771
func_append libobjs " $pic_object"
3772
arg="$pic_object"
3773
fi
3774
3775
# Non-PIC object.
3776
if test "$non_pic_object" != none; then
3777
# Prepend the subdirectory the object is found in.
3778
non_pic_object="$xdir$non_pic_object"
3779
3780
# A standard non-PIC object
3781
func_append non_pic_objects " $non_pic_object"
3782
if test -z "$pic_object" || test "$pic_object" = none ; then
3783
arg="$non_pic_object"
3784
fi
3785
else
3786
# If the PIC object exists, use it instead.
3787
# $xdir was prepended to $pic_object above.
3788
non_pic_object="$pic_object"
3789
func_append non_pic_objects " $non_pic_object"
3790
fi
3791
else
3792
# Only an error if not doing a dry-run.
3793
if $opt_dry_run; then
3794
# Extract subdirectory from the argument.
3795
func_dirname "$arg" "/" ""
3796
xdir="$func_dirname_result"
3797
3798
func_lo2o "$arg"
3799
pic_object=$xdir$objdir/$func_lo2o_result
3800
non_pic_object=$xdir$func_lo2o_result
3801
func_append libobjs " $pic_object"
3802
func_append non_pic_objects " $non_pic_object"
3803
else
3804
func_fatal_error "\`$arg' is not a valid libtool object"
3805
fi
3806
fi
3807
done
3808
else
3809
func_fatal_error "link input file \`$arg' does not exist"
3810
fi
3811
arg=$save_arg
3812
prev=
3813
continue
3814
;;
3815
precious_regex)
3816
precious_files_regex="$arg"
3817
prev=
3818
continue
3819
;;
3820
release)
3821
release="-$arg"
3822
prev=
3823
continue
3824
;;
3825
rpath | xrpath)
3826
# We need an absolute path.
3827
case $arg in
3828
[\\/]* | [A-Za-z]:[\\/]*) ;;
3829
*)
3830
func_fatal_error "only absolute run-paths are allowed"
3831
;;
3832
esac
3833
if test "$prev" = rpath; then
3834
case "$rpath " in
3835
*" $arg "*) ;;
3836
*) rpath="$rpath $arg" ;;
3837
esac
3838
else
3839
case "$xrpath " in
3840
*" $arg "*) ;;
3841
*) xrpath="$xrpath $arg" ;;
3842
esac
3843
fi
3844
prev=
3845
continue
3846
;;
3847
shrext)
3848
shrext_cmds="$arg"
3849
prev=
3850
continue
3851
;;
3852
weak)
3853
weak_libs="$weak_libs $arg"
3854
prev=
3855
continue
3856
;;
3857
xcclinker)
3858
linker_flags="$linker_flags $qarg"
3859
compiler_flags="$compiler_flags $qarg"
3860
prev=
3861
func_append compile_command " $qarg"
3862
func_append finalize_command " $qarg"
3863
continue
3864
;;
3865
xcompiler)
3866
compiler_flags="$compiler_flags $qarg"
3867
prev=
3868
func_append compile_command " $qarg"
3869
func_append finalize_command " $qarg"
3870
continue
3871
;;
3872
xlinker)
3873
linker_flags="$linker_flags $qarg"
3874
compiler_flags="$compiler_flags $wl$qarg"
3875
prev=
3876
func_append compile_command " $wl$qarg"
3877
func_append finalize_command " $wl$qarg"
3878
continue
3879
;;
3880
*)
3881
eval "$prev=\"\$arg\""
3882
prev=
3883
continue
3884
;;
3885
esac
3886
fi # test -n "$prev"
3887
3888
prevarg="$arg"
3889
3890
case $arg in
3891
-all-static)
3892
if test -n "$link_static_flag"; then
3893
# See comment for -static flag below, for more details.
3894
func_append compile_command " $link_static_flag"
3895
func_append finalize_command " $link_static_flag"
3896
fi
3897
continue
3898
;;
3899
3900
-allow-undefined)
3901
# FIXME: remove this flag sometime in the future.
3902
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
3903
;;
3904
3905
-avoid-version)
3906
avoid_version=yes
3907
continue
3908
;;
3909
3910
-dlopen)
3911
prev=dlfiles
3912
continue
3913
;;
3914
3915
-dlpreopen)
3916
prev=dlprefiles
3917
continue
3918
;;
3919
3920
-export-dynamic)
3921
export_dynamic=yes
3922
continue
3923
;;
3924
3925
-export-symbols | -export-symbols-regex)
3926
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3927
func_fatal_error "more than one -exported-symbols argument is not allowed"
3928
fi
3929
if test "X$arg" = "X-export-symbols"; then
3930
prev=expsyms
3931
else
3932
prev=expsyms_regex
3933
fi
3934
continue
3935
;;
3936
3937
-framework)
3938
prev=framework
3939
continue
3940
;;
3941
3942
-inst-prefix-dir)
3943
prev=inst_prefix
3944
continue
3945
;;
3946
3947
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
3948
# so, if we see these flags be careful not to treat them like -L
3949
-L[A-Z][A-Z]*:*)
3950
case $with_gcc/$host in
3951
no/*-*-irix* | /*-*-irix*)
3952
func_append compile_command " $arg"
3953
func_append finalize_command " $arg"
3954
;;
3955
esac
3956
continue
3957
;;
3958
3959
-L*)
3960
func_stripname '-L' '' "$arg"
3961
dir=$func_stripname_result
3962
# We need an absolute path.
3963
case $dir in
3964
[\\/]* | [A-Za-z]:[\\/]*) ;;
3965
*)
3966
absdir=`cd "$dir" && pwd`
3967
test -z "$absdir" && \
3968
func_fatal_error "cannot determine absolute directory name of \`$dir'"
3969
dir="$absdir"
3970
;;
3971
esac
3972
case "$deplibs " in
3973
*" -L$dir "*) ;;
3974
*)
3975
deplibs="$deplibs -L$dir"
3976
lib_search_path="$lib_search_path $dir"
3977
;;
3978
esac
3979
case $host in
3980
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3981
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
3982
case :$dllsearchpath: in
3983
*":$dir:"*) ;;
3984
*) dllsearchpath="$dllsearchpath:$dir";;
3985
esac
3986
case :$dllsearchpath: in
3987
*":$testbindir:"*) ;;
3988
*) dllsearchpath="$dllsearchpath:$testbindir";;
3989
esac
3990
;;
3991
esac
3992
continue
3993
;;
3994
3995
-l*)
3996
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
3997
case $host in
3998
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
3999
# These systems don't actually have a C or math library (as such)
4000
continue
4001
;;
4002
*-*-os2*)
4003
# These systems don't actually have a C library (as such)
4004
test "X$arg" = "X-lc" && continue
4005
;;
4006
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4007
# Do not include libc due to us having libc/libc_r.
4008
test "X$arg" = "X-lc" && continue
4009
;;
4010
*-*-rhapsody* | *-*-darwin1.[012])
4011
# Rhapsody C and math libraries are in the System framework
4012
deplibs="$deplibs System.ltframework"
4013
continue
4014
;;
4015
*-*-sco3.2v5* | *-*-sco5v6*)
4016
# Causes problems with __ctype
4017
test "X$arg" = "X-lc" && continue
4018
;;
4019
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4020
# Compiler inserts libc in the correct place for threads to work
4021
test "X$arg" = "X-lc" && continue
4022
;;
4023
esac
4024
elif test "X$arg" = "X-lc_r"; then
4025
case $host in
4026
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4027
# Do not include libc_r directly, use -pthread flag.
4028
continue
4029
;;
4030
esac
4031
fi
4032
deplibs="$deplibs $arg"
4033
continue
4034
;;
4035
4036
-module)
4037
module=yes
4038
continue
4039
;;
4040
4041
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4042
# classes, name mangling, and exception handling.
4043
# Darwin uses the -arch flag to determine output architecture.
4044
-model|-arch|-isysroot)
4045
compiler_flags="$compiler_flags $arg"
4046
func_append compile_command " $arg"
4047
func_append finalize_command " $arg"
4048
prev=xcompiler
4049
continue
4050
;;
4051
4052
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4053
compiler_flags="$compiler_flags $arg"
4054
func_append compile_command " $arg"
4055
func_append finalize_command " $arg"
4056
case "$new_inherited_linker_flags " in
4057
*" $arg "*) ;;
4058
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4059
esac
4060
continue
4061
;;
4062
4063
-multi_module)
4064
single_module="${wl}-multi_module"
4065
continue
4066
;;
4067
4068
-no-fast-install)
4069
fast_install=no
4070
continue
4071
;;
4072
4073
-no-install)
4074
case $host in
4075
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
4076
# The PATH hackery in wrapper scripts is required on Windows
4077
# and Darwin in order for the loader to find any dlls it needs.
4078
func_warning "\`-no-install' is ignored for $host"
4079
func_warning "assuming \`-no-fast-install' instead"
4080
fast_install=no
4081
;;
4082
*) no_install=yes ;;
4083
esac
4084
continue
4085
;;
4086
4087
-no-undefined)
4088
allow_undefined=no
4089
continue
4090
;;
4091
4092
-objectlist)
4093
prev=objectlist
4094
continue
4095
;;
4096
4097
-o) prev=output ;;
4098
4099
-precious-files-regex)
4100
prev=precious_regex
4101
continue
4102
;;
4103
4104
-release)
4105
prev=release
4106
continue
4107
;;
4108
4109
-rpath)
4110
prev=rpath
4111
continue
4112
;;
4113
4114
-R)
4115
prev=xrpath
4116
continue
4117
;;
4118
4119
-R*)
4120
func_stripname '-R' '' "$arg"
4121
dir=$func_stripname_result
4122
# We need an absolute path.
4123
case $dir in
4124
[\\/]* | [A-Za-z]:[\\/]*) ;;
4125
*)
4126
func_fatal_error "only absolute run-paths are allowed"
4127
;;
4128
esac
4129
case "$xrpath " in
4130
*" $dir "*) ;;
4131
*) xrpath="$xrpath $dir" ;;
4132
esac
4133
continue
4134
;;
4135
4136
-shared)
4137
# The effects of -shared are defined in a previous loop.
4138
continue
4139
;;
4140
4141
-shrext)
4142
prev=shrext
4143
continue
4144
;;
4145
4146
-static | -static-libtool-libs)
4147
# The effects of -static are defined in a previous loop.
4148
# We used to do the same as -all-static on platforms that
4149
# didn't have a PIC flag, but the assumption that the effects
4150
# would be equivalent was wrong. It would break on at least
4151
# Digital Unix and AIX.
4152
continue
4153
;;
4154
4155
-thread-safe)
4156
thread_safe=yes
4157
continue
4158
;;
4159
4160
-version-info)
4161
prev=vinfo
4162
continue
4163
;;
4164
4165
-version-number)
4166
prev=vinfo
4167
vinfo_number=yes
4168
continue
4169
;;
4170
4171
-weak)
4172
prev=weak
4173
continue
4174
;;
4175
4176
-Wc,*)
4177
func_stripname '-Wc,' '' "$arg"
4178
args=$func_stripname_result
4179
arg=
4180
save_ifs="$IFS"; IFS=','
4181
for flag in $args; do
4182
IFS="$save_ifs"
4183
func_quote_for_eval "$flag"
4184
arg="$arg $wl$func_quote_for_eval_result"
4185
compiler_flags="$compiler_flags $func_quote_for_eval_result"
4186
done
4187
IFS="$save_ifs"
4188
func_stripname ' ' '' "$arg"
4189
arg=$func_stripname_result
4190
;;
4191
4192
-Wl,*)
4193
func_stripname '-Wl,' '' "$arg"
4194
args=$func_stripname_result
4195
arg=
4196
save_ifs="$IFS"; IFS=','
4197
for flag in $args; do
4198
IFS="$save_ifs"
4199
func_quote_for_eval "$flag"
4200
arg="$arg $wl$func_quote_for_eval_result"
4201
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4202
linker_flags="$linker_flags $func_quote_for_eval_result"
4203
done
4204
IFS="$save_ifs"
4205
func_stripname ' ' '' "$arg"
4206
arg=$func_stripname_result
4207
;;
4208
4209
-Xcompiler)
4210
prev=xcompiler
4211
continue
4212
;;
4213
4214
-Xlinker)
4215
prev=xlinker
4216
continue
4217
;;
4218
4219
-XCClinker)
4220
prev=xcclinker
4221
continue
4222
;;
4223
4224
# -msg_* for osf cc
4225
-msg_*)
4226
func_quote_for_eval "$arg"
4227
arg="$func_quote_for_eval_result"
4228
;;
4229
4230
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4231
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4232
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4233
# +DA*, +DD* enable 64-bit mode on the HP compiler
4234
# -q* pass through compiler args for the IBM compiler
4235
# -m*, -t[45]*, -txscale* pass through architecture-specific
4236
# compiler args for GCC
4237
# -F/path gives path to uninstalled frameworks, gcc on darwin
4238
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4239
# @file GCC response files
4240
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4241
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4242
func_quote_for_eval "$arg"
4243
arg="$func_quote_for_eval_result"
4244
func_append compile_command " $arg"
4245
func_append finalize_command " $arg"
4246
compiler_flags="$compiler_flags $arg"
4247
continue
4248
;;
4249
4250
# Some other compiler flag.
4251
-* | +*)
4252
func_quote_for_eval "$arg"
4253
arg="$func_quote_for_eval_result"
4254
;;
4255
4256
*.$objext)
4257
# A standard object.
4258
objs="$objs $arg"
4259
;;
4260
4261
*.lo)
4262
# A libtool-controlled object.
4263
4264
# Check to see that this really is a libtool object.
4265
if func_lalib_unsafe_p "$arg"; then
4266
pic_object=
4267
non_pic_object=
4268
4269
# Read the .lo file
4270
func_source "$arg"
4271
4272
if test -z "$pic_object" ||
4273
test -z "$non_pic_object" ||
4274
test "$pic_object" = none &&
4275
test "$non_pic_object" = none; then
4276
func_fatal_error "cannot find name of object for \`$arg'"
4277
fi
4278
4279
# Extract subdirectory from the argument.
4280
func_dirname "$arg" "/" ""
4281
xdir="$func_dirname_result"
4282
4283
if test "$pic_object" != none; then
4284
# Prepend the subdirectory the object is found in.
4285
pic_object="$xdir$pic_object"
4286
4287
if test "$prev" = dlfiles; then
4288
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4289
dlfiles="$dlfiles $pic_object"
4290
prev=
4291
continue
4292
else
4293
# If libtool objects are unsupported, then we need to preload.
4294
prev=dlprefiles
4295
fi
4296
fi
4297
4298
# CHECK ME: I think I busted this. -Ossama
4299
if test "$prev" = dlprefiles; then
4300
# Preload the old-style object.
4301
dlprefiles="$dlprefiles $pic_object"
4302
prev=
4303
fi
4304
4305
# A PIC object.
4306
func_append libobjs " $pic_object"
4307
arg="$pic_object"
4308
fi
4309
4310
# Non-PIC object.
4311
if test "$non_pic_object" != none; then
4312
# Prepend the subdirectory the object is found in.
4313
non_pic_object="$xdir$non_pic_object"
4314
4315
# A standard non-PIC object
4316
func_append non_pic_objects " $non_pic_object"
4317
if test -z "$pic_object" || test "$pic_object" = none ; then
4318
arg="$non_pic_object"
4319
fi
4320
else
4321
# If the PIC object exists, use it instead.
4322
# $xdir was prepended to $pic_object above.
4323
non_pic_object="$pic_object"
4324
func_append non_pic_objects " $non_pic_object"
4325
fi
4326
else
4327
# Only an error if not doing a dry-run.
4328
if $opt_dry_run; then
4329
# Extract subdirectory from the argument.
4330
func_dirname "$arg" "/" ""
4331
xdir="$func_dirname_result"
4332
4333
func_lo2o "$arg"
4334
pic_object=$xdir$objdir/$func_lo2o_result
4335
non_pic_object=$xdir$func_lo2o_result
4336
func_append libobjs " $pic_object"
4337
func_append non_pic_objects " $non_pic_object"
4338
else
4339
func_fatal_error "\`$arg' is not a valid libtool object"
4340
fi
4341
fi
4342
;;
4343
4344
*.$libext)
4345
# An archive.
4346
deplibs="$deplibs $arg"
4347
old_deplibs="$old_deplibs $arg"
4348
continue
4349
;;
4350
4351
*.la)
4352
# A libtool-controlled library.
4353
4354
if test "$prev" = dlfiles; then
4355
# This library was specified with -dlopen.
4356
dlfiles="$dlfiles $arg"
4357
prev=
4358
elif test "$prev" = dlprefiles; then
4359
# The library was specified with -dlpreopen.
4360
dlprefiles="$dlprefiles $arg"
4361
prev=
4362
else
4363
deplibs="$deplibs $arg"
4364
fi
4365
continue
4366
;;
4367
4368
# Some other compiler argument.
4369
*)
4370
# Unknown arguments in both finalize_command and compile_command need
4371
# to be aesthetically quoted because they are evaled later.
4372
func_quote_for_eval "$arg"
4373
arg="$func_quote_for_eval_result"
4374
;;
4375
esac # arg
4376
4377
# Now actually substitute the argument into the commands.
4378
if test -n "$arg"; then
4379
func_append compile_command " $arg"
4380
func_append finalize_command " $arg"
4381
fi
4382
done # argument parsing loop
4383
4384
test -n "$prev" && \
4385
func_fatal_help "the \`$prevarg' option requires an argument"
4386
4387
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4388
eval arg=\"$export_dynamic_flag_spec\"
4389
func_append compile_command " $arg"
4390
func_append finalize_command " $arg"
4391
fi
4392
4393
oldlibs=
4394
# calculate the name of the file, without its directory
4395
func_basename "$output"
4396
outputname="$func_basename_result"
4397
libobjs_save="$libobjs"
4398
4399
if test -n "$shlibpath_var"; then
4400
# get the directories listed in $shlibpath_var
4401
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4402
else
4403
shlib_search_path=
4404
fi
4405
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4406
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4407
4408
func_dirname "$output" "/" ""
4409
output_objdir="$func_dirname_result$objdir"
4410
# Create the object directory.
4411
func_mkdir_p "$output_objdir"
4412
4413
# Determine the type of output
4414
case $output in
4415
"")
4416
func_fatal_help "you must specify an output file"
4417
;;
4418
*.$libext) linkmode=oldlib ;;
4419
*.lo | *.$objext) linkmode=obj ;;
4420
*.la) linkmode=lib ;;
4421
*) linkmode=prog ;; # Anything else should be a program.
4422
esac
4423
4424
specialdeplibs=
4425
4426
libs=
4427
# Find all interdependent deplibs by searching for libraries
4428
# that are linked more than once (e.g. -la -lb -la)
4429
for deplib in $deplibs; do
4430
if $opt_duplicate_deps ; then
4431
case "$libs " in
4432
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4433
esac
4434
fi
4435
libs="$libs $deplib"
4436
done
4437
4438
if test "$linkmode" = lib; then
4439
libs="$predeps $libs $compiler_lib_search_path $postdeps"
4440
4441
# Compute libraries that are listed more than once in $predeps
4442
# $postdeps and mark them as special (i.e., whose duplicates are
4443
# not to be eliminated).
4444
pre_post_deps=
4445
if $opt_duplicate_compiler_generated_deps; then
4446
for pre_post_dep in $predeps $postdeps; do
4447
case "$pre_post_deps " in
4448
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4449
esac
4450
pre_post_deps="$pre_post_deps $pre_post_dep"
4451
done
4452
fi
4453
pre_post_deps=
4454
fi
4455
4456
deplibs=
4457
newdependency_libs=
4458
newlib_search_path=
4459
need_relink=no # whether we're linking any uninstalled libtool libraries
4460
notinst_deplibs= # not-installed libtool libraries
4461
notinst_path= # paths that contain not-installed libtool libraries
4462
4463
case $linkmode in
4464
lib)
4465
passes="conv dlpreopen link"
4466
for file in $dlfiles $dlprefiles; do
4467
case $file in
4468
*.la) ;;
4469
*)
4470
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
4471
;;
4472
esac
4473
done
4474
;;
4475
prog)
4476
compile_deplibs=
4477
finalize_deplibs=
4478
alldeplibs=no
4479
newdlfiles=
4480
newdlprefiles=
4481
passes="conv scan dlopen dlpreopen link"
4482
;;
4483
*) passes="conv"
4484
;;
4485
esac
4486
4487
for pass in $passes; do
4488
# The preopen pass in lib mode reverses $deplibs; put it back here
4489
# so that -L comes before libs that need it for instance...
4490
if test "$linkmode,$pass" = "lib,link"; then
4491
## FIXME: Find the place where the list is rebuilt in the wrong
4492
## order, and fix it there properly
4493
tmp_deplibs=
4494
for deplib in $deplibs; do
4495
tmp_deplibs="$deplib $tmp_deplibs"
4496
done
4497
deplibs="$tmp_deplibs"
4498
fi
4499
4500
if test "$linkmode,$pass" = "lib,link" ||
4501
test "$linkmode,$pass" = "prog,scan"; then
4502
libs="$deplibs"
4503
deplibs=
4504
fi
4505
if test "$linkmode" = prog; then
4506
case $pass in
4507
dlopen) libs="$dlfiles" ;;
4508
dlpreopen) libs="$dlprefiles" ;;
4509
link)
4510
libs="$deplibs %DEPLIBS%"
4511
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
4512
;;
4513
esac
4514
fi
4515
if test "$linkmode,$pass" = "lib,dlpreopen"; then
4516
# Collect and forward deplibs of preopened libtool libs
4517
for lib in $dlprefiles; do
4518
# Ignore non-libtool-libs
4519
dependency_libs=
4520
case $lib in
4521
*.la) func_source "$lib" ;;
4522
esac
4523
4524
# Collect preopened libtool deplibs, except any this library
4525
# has declared as weak libs
4526
for deplib in $dependency_libs; do
4527
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
4528
case " $weak_libs " in
4529
*" $deplib_base "*) ;;
4530
*) deplibs="$deplibs $deplib" ;;
4531
esac
4532
done
4533
done
4534
libs="$dlprefiles"
4535
fi
4536
if test "$pass" = dlopen; then
4537
# Collect dlpreopened libraries
4538
save_deplibs="$deplibs"
4539
deplibs=
4540
fi
4541
4542
for deplib in $libs; do
4543
lib=
4544
found=no
4545
case $deplib in
4546
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4547
if test "$linkmode,$pass" = "prog,link"; then
4548
compile_deplibs="$deplib $compile_deplibs"
4549
finalize_deplibs="$deplib $finalize_deplibs"
4550
else
4551
compiler_flags="$compiler_flags $deplib"
4552
if test "$linkmode" = lib ; then
4553
case "$new_inherited_linker_flags " in
4554
*" $deplib "*) ;;
4555
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4556
esac
4557
fi
4558
fi
4559
continue
4560
;;
4561
-l*)
4562
if test "$linkmode" != lib && test "$linkmode" != prog; then
4563
func_warning "\`-l' is ignored for archives/objects"
4564
continue
4565
fi
4566
func_stripname '-l' '' "$deplib"
4567
name=$func_stripname_result
4568
if test "$linkmode" = lib; then
4569
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
4570
else
4571
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
4572
fi
4573
for searchdir in $searchdirs; do
4574
for search_ext in .la $std_shrext .so .a; do
4575
# Search the libtool library
4576
lib="$searchdir/lib${name}${search_ext}"
4577
if test -f "$lib"; then
4578
if test "$search_ext" = ".la"; then
4579
found=yes
4580
else
4581
found=no
4582
fi
4583
break 2
4584
fi
4585
done
4586
done
4587
if test "$found" != yes; then
4588
# deplib doesn't seem to be a libtool library
4589
if test "$linkmode,$pass" = "prog,link"; then
4590
compile_deplibs="$deplib $compile_deplibs"
4591
finalize_deplibs="$deplib $finalize_deplibs"
4592
else
4593
deplibs="$deplib $deplibs"
4594
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4595
fi
4596
continue
4597
else # deplib is a libtool library
4598
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
4599
# We need to do some special things here, and not later.
4600
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
4601
case " $predeps $postdeps " in
4602
*" $deplib "*)
4603
if func_lalib_p "$lib"; then
4604
library_names=
4605
old_library=
4606
func_source "$lib"
4607
for l in $old_library $library_names; do
4608
ll="$l"
4609
done
4610
if test "X$ll" = "X$old_library" ; then # only static version available
4611
found=no
4612
func_dirname "$lib" "" "."
4613
ladir="$func_dirname_result"
4614
lib=$ladir/$old_library
4615
if test "$linkmode,$pass" = "prog,link"; then
4616
compile_deplibs="$deplib $compile_deplibs"
4617
finalize_deplibs="$deplib $finalize_deplibs"
4618
else
4619
deplibs="$deplib $deplibs"
4620
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4621
fi
4622
continue
4623
fi
4624
fi
4625
;;
4626
*) ;;
4627
esac
4628
fi
4629
fi
4630
;; # -l
4631
*.ltframework)
4632
if test "$linkmode,$pass" = "prog,link"; then
4633
compile_deplibs="$deplib $compile_deplibs"
4634
finalize_deplibs="$deplib $finalize_deplibs"
4635
else
4636
deplibs="$deplib $deplibs"
4637
if test "$linkmode" = lib ; then
4638
case "$new_inherited_linker_flags " in
4639
*" $deplib "*) ;;
4640
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4641
esac
4642
fi
4643
fi
4644
continue
4645
;;
4646
-L*)
4647
case $linkmode in
4648
lib)
4649
deplibs="$deplib $deplibs"
4650
test "$pass" = conv && continue
4651
newdependency_libs="$deplib $newdependency_libs"
4652
func_stripname '-L' '' "$deplib"
4653
newlib_search_path="$newlib_search_path $func_stripname_result"
4654
;;
4655
prog)
4656
if test "$pass" = conv; then
4657
deplibs="$deplib $deplibs"
4658
continue
4659
fi
4660
if test "$pass" = scan; then
4661
deplibs="$deplib $deplibs"
4662
else
4663
compile_deplibs="$deplib $compile_deplibs"
4664
finalize_deplibs="$deplib $finalize_deplibs"
4665
fi
4666
func_stripname '-L' '' "$deplib"
4667
newlib_search_path="$newlib_search_path $func_stripname_result"
4668
;;
4669
*)
4670
func_warning "\`-L' is ignored for archives/objects"
4671
;;
4672
esac # linkmode
4673
continue
4674
;; # -L
4675
-R*)
4676
if test "$pass" = link; then
4677
func_stripname '-R' '' "$deplib"
4678
dir=$func_stripname_result
4679
# Make sure the xrpath contains only unique directories.
4680
case "$xrpath " in
4681
*" $dir "*) ;;
4682
*) xrpath="$xrpath $dir" ;;
4683
esac
4684
fi
4685
deplibs="$deplib $deplibs"
4686
continue
4687
;;
4688
*.la) lib="$deplib" ;;
4689
*.$libext)
4690
if test "$pass" = conv; then
4691
deplibs="$deplib $deplibs"
4692
continue
4693
fi
4694
case $linkmode in
4695
lib)
4696
# Linking convenience modules into shared libraries is allowed,
4697
# but linking other static libraries is non-portable.
4698
case " $dlpreconveniencelibs " in
4699
*" $deplib "*) ;;
4700
*)
4701
valid_a_lib=no
4702
case $deplibs_check_method in
4703
match_pattern*)
4704
set dummy $deplibs_check_method; shift
4705
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
4706
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
4707
| $EGREP "$match_pattern_regex" > /dev/null; then
4708
valid_a_lib=yes
4709
fi
4710
;;
4711
pass_all)
4712
valid_a_lib=yes
4713
;;
4714
esac
4715
if test "$valid_a_lib" != yes; then
4716
$ECHO
4717
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
4718
$ECHO "*** I have the capability to make that library automatically link in when"
4719
$ECHO "*** you link to this library. But I can only do this if you have a"
4720
$ECHO "*** shared version of the library, which you do not appear to have"
4721
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
4722
$ECHO "*** that it is just a static archive that I should not use here."
4723
else
4724
$ECHO
4725
$ECHO "*** Warning: Linking the shared library $output against the"
4726
$ECHO "*** static library $deplib is not portable!"
4727
deplibs="$deplib $deplibs"
4728
fi
4729
;;
4730
esac
4731
continue
4732
;;
4733
prog)
4734
if test "$pass" != link; then
4735
deplibs="$deplib $deplibs"
4736
else
4737
compile_deplibs="$deplib $compile_deplibs"
4738
finalize_deplibs="$deplib $finalize_deplibs"
4739
fi
4740
continue
4741
;;
4742
esac # linkmode
4743
;; # *.$libext
4744
*.lo | *.$objext)
4745
if test "$pass" = conv; then
4746
deplibs="$deplib $deplibs"
4747
elif test "$linkmode" = prog; then
4748
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
4749
# If there is no dlopen support or we're linking statically,
4750
# we need to preload.
4751
newdlprefiles="$newdlprefiles $deplib"
4752
compile_deplibs="$deplib $compile_deplibs"
4753
finalize_deplibs="$deplib $finalize_deplibs"
4754
else
4755
newdlfiles="$newdlfiles $deplib"
4756
fi
4757
fi
4758
continue
4759
;;
4760
%DEPLIBS%)
4761
alldeplibs=yes
4762
continue
4763
;;
4764
esac # case $deplib
4765
4766
if test "$found" = yes || test -f "$lib"; then :
4767
else
4768
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
4769
fi
4770
4771
# Check to see that this really is a libtool archive.
4772
func_lalib_unsafe_p "$lib" \
4773
|| func_fatal_error "\`$lib' is not a valid libtool archive"
4774
4775
func_dirname "$lib" "" "."
4776
ladir="$func_dirname_result"
4777
4778
dlname=
4779
dlopen=
4780
dlpreopen=
4781
libdir=
4782
library_names=
4783
old_library=
4784
inherited_linker_flags=
4785
# If the library was installed with an old release of libtool,
4786
# it will not redefine variables installed, or shouldnotlink
4787
installed=yes
4788
shouldnotlink=no
4789
avoidtemprpath=
4790
4791
4792
# Read the .la file
4793
func_source "$lib"
4794
4795
# Convert "-framework foo" to "foo.ltframework"
4796
if test -n "$inherited_linker_flags"; then
4797
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
4798
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
4799
case " $new_inherited_linker_flags " in
4800
*" $tmp_inherited_linker_flag "*) ;;
4801
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
4802
esac
4803
done
4804
fi
4805
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
4806
if test "$linkmode,$pass" = "lib,link" ||
4807
test "$linkmode,$pass" = "prog,scan" ||
4808
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
4809
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
4810
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
4811
fi
4812
4813
if test "$pass" = conv; then
4814
# Only check for convenience libraries
4815
deplibs="$lib $deplibs"
4816
if test -z "$libdir"; then
4817
if test -z "$old_library"; then
4818
func_fatal_error "cannot find name of link library for \`$lib'"
4819
fi
4820
# It is a libtool convenience library, so add in its objects.
4821
convenience="$convenience $ladir/$objdir/$old_library"
4822
old_convenience="$old_convenience $ladir/$objdir/$old_library"
4823
elif test "$linkmode" != prog && test "$linkmode" != lib; then
4824
func_fatal_error "\`$lib' is not a convenience library"
4825
fi
4826
tmp_libs=
4827
for deplib in $dependency_libs; do
4828
deplibs="$deplib $deplibs"
4829
if $opt_duplicate_deps ; then
4830
case "$tmp_libs " in
4831
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4832
esac
4833
fi
4834
tmp_libs="$tmp_libs $deplib"
4835
done
4836
continue
4837
fi # $pass = conv
4838
4839
4840
# Get the name of the library we link against.
4841
linklib=
4842
for l in $old_library $library_names; do
4843
linklib="$l"
4844
done
4845
if test -z "$linklib"; then
4846
func_fatal_error "cannot find name of link library for \`$lib'"
4847
fi
4848
4849
# This library was specified with -dlopen.
4850
if test "$pass" = dlopen; then
4851
if test -z "$libdir"; then
4852
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
4853
fi
4854
if test -z "$dlname" ||
4855
test "$dlopen_support" != yes ||
4856
test "$build_libtool_libs" = no; then
4857
# If there is no dlname, no dlopen support or we're linking
4858
# statically, we need to preload. We also need to preload any
4859
# dependent libraries so libltdl's deplib preloader doesn't
4860
# bomb out in the load deplibs phase.
4861
dlprefiles="$dlprefiles $lib $dependency_libs"
4862
else
4863
newdlfiles="$newdlfiles $lib"
4864
fi
4865
continue
4866
fi # $pass = dlopen
4867
4868
# We need an absolute path.
4869
case $ladir in
4870
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
4871
*)
4872
abs_ladir=`cd "$ladir" && pwd`
4873
if test -z "$abs_ladir"; then
4874
func_warning "cannot determine absolute directory name of \`$ladir'"
4875
func_warning "passing it literally to the linker, although it might fail"
4876
abs_ladir="$ladir"
4877
fi
4878
;;
4879
esac
4880
func_basename "$lib"
4881
laname="$func_basename_result"
4882
4883
# Find the relevant object directory and library name.
4884
if test "X$installed" = Xyes; then
4885
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4886
func_warning "library \`$lib' was moved."
4887
dir="$ladir"
4888
absdir="$abs_ladir"
4889
libdir="$abs_ladir"
4890
else
4891
dir="$libdir"
4892
absdir="$libdir"
4893
fi
4894
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
4895
else
4896
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4897
dir="$ladir"
4898
absdir="$abs_ladir"
4899
# Remove this search path later
4900
notinst_path="$notinst_path $abs_ladir"
4901
else
4902
dir="$ladir/$objdir"
4903
absdir="$abs_ladir/$objdir"
4904
# Remove this search path later
4905
notinst_path="$notinst_path $abs_ladir"
4906
fi
4907
fi # $installed = yes
4908
func_stripname 'lib' '.la' "$laname"
4909
name=$func_stripname_result
4910
4911
# This library was specified with -dlpreopen.
4912
if test "$pass" = dlpreopen; then
4913
if test -z "$libdir" && test "$linkmode" = prog; then
4914
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
4915
fi
4916
# Prefer using a static library (so that no silly _DYNAMIC symbols
4917
# are required to link).
4918
if test -n "$old_library"; then
4919
newdlprefiles="$newdlprefiles $dir/$old_library"
4920
# Keep a list of preopened convenience libraries to check
4921
# that they are being used correctly in the link pass.
4922
test -z "$libdir" && \
4923
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
4924
# Otherwise, use the dlname, so that lt_dlopen finds it.
4925
elif test -n "$dlname"; then
4926
newdlprefiles="$newdlprefiles $dir/$dlname"
4927
else
4928
newdlprefiles="$newdlprefiles $dir/$linklib"
4929
fi
4930
fi # $pass = dlpreopen
4931
4932
if test -z "$libdir"; then
4933
# Link the convenience library
4934
if test "$linkmode" = lib; then
4935
deplibs="$dir/$old_library $deplibs"
4936
elif test "$linkmode,$pass" = "prog,link"; then
4937
compile_deplibs="$dir/$old_library $compile_deplibs"
4938
finalize_deplibs="$dir/$old_library $finalize_deplibs"
4939
else
4940
deplibs="$lib $deplibs" # used for prog,scan pass
4941
fi
4942
continue
4943
fi
4944
4945
4946
if test "$linkmode" = prog && test "$pass" != link; then
4947
newlib_search_path="$newlib_search_path $ladir"
4948
deplibs="$lib $deplibs"
4949
4950
linkalldeplibs=no
4951
if test "$link_all_deplibs" != no || test -z "$library_names" ||
4952
test "$build_libtool_libs" = no; then
4953
linkalldeplibs=yes
4954
fi
4955
4956
tmp_libs=
4957
for deplib in $dependency_libs; do
4958
case $deplib in
4959
-L*) func_stripname '-L' '' "$deplib"
4960
newlib_search_path="$newlib_search_path $func_stripname_result"
4961
;;
4962
esac
4963
# Need to link against all dependency_libs?
4964
if test "$linkalldeplibs" = yes; then
4965
deplibs="$deplib $deplibs"
4966
else
4967
# Need to hardcode shared library paths
4968
# or/and link against static libraries
4969
newdependency_libs="$deplib $newdependency_libs"
4970
fi
4971
if $opt_duplicate_deps ; then
4972
case "$tmp_libs " in
4973
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4974
esac
4975
fi
4976
tmp_libs="$tmp_libs $deplib"
4977
done # for deplib
4978
continue
4979
fi # $linkmode = prog...
4980
4981
if test "$linkmode,$pass" = "prog,link"; then
4982
if test -n "$library_names" &&
4983
{ { test "$prefer_static_libs" = no ||
4984
test "$prefer_static_libs,$installed" = "built,yes"; } ||
4985
test -z "$old_library"; }; then
4986
# We need to hardcode the library path
4987
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
4988
# Make sure the rpath contains only unique directories.
4989
case "$temp_rpath:" in
4990
*"$absdir:"*) ;;
4991
*) temp_rpath="$temp_rpath$absdir:" ;;
4992
esac
4993
fi
4994
4995
# Hardcode the library path.
4996
# Skip directories that are in the system default run-time
4997
# search path.
4998
case " $sys_lib_dlsearch_path " in
4999
*" $absdir "*) ;;
5000
*)
5001
case "$compile_rpath " in
5002
*" $absdir "*) ;;
5003
*) compile_rpath="$compile_rpath $absdir"
5004
esac
5005
;;
5006
esac
5007
case " $sys_lib_dlsearch_path " in
5008
*" $libdir "*) ;;
5009
*)
5010
case "$finalize_rpath " in
5011
*" $libdir "*) ;;
5012
*) finalize_rpath="$finalize_rpath $libdir"
5013
esac
5014
;;
5015
esac
5016
fi # $linkmode,$pass = prog,link...
5017
5018
if test "$alldeplibs" = yes &&
5019
{ test "$deplibs_check_method" = pass_all ||
5020
{ test "$build_libtool_libs" = yes &&
5021
test -n "$library_names"; }; }; then
5022
# We only need to search for static libraries
5023
continue
5024
fi
5025
fi
5026
5027
link_static=no # Whether the deplib will be linked statically
5028
use_static_libs=$prefer_static_libs
5029
if test "$use_static_libs" = built && test "$installed" = yes; then
5030
use_static_libs=no
5031
fi
5032
if test -n "$library_names" &&
5033
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
5034
case $host in
5035
*cygwin* | *mingw*)
5036
# No point in relinking DLLs because paths are not encoded
5037
notinst_deplibs="$notinst_deplibs $lib"
5038
need_relink=no
5039
;;
5040
*)
5041
if test "$installed" = no; then
5042
notinst_deplibs="$notinst_deplibs $lib"
5043
need_relink=yes
5044
fi
5045
;;
5046
esac
5047
# This is a shared library
5048
5049
# Warn about portability, can't link against -module's on some
5050
# systems (darwin). Don't bleat about dlopened modules though!
5051
dlopenmodule=""
5052
for dlpremoduletest in $dlprefiles; do
5053
if test "X$dlpremoduletest" = "X$lib"; then
5054
dlopenmodule="$dlpremoduletest"
5055
break
5056
fi
5057
done
5058
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5059
$ECHO
5060
if test "$linkmode" = prog; then
5061
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5062
else
5063
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5064
fi
5065
$ECHO "*** $linklib is not portable!"
5066
fi
5067
if test "$linkmode" = lib &&
5068
test "$hardcode_into_libs" = yes; then
5069
# Hardcode the library path.
5070
# Skip directories that are in the system default run-time
5071
# search path.
5072
case " $sys_lib_dlsearch_path " in
5073
*" $absdir "*) ;;
5074
*)
5075
case "$compile_rpath " in
5076
*" $absdir "*) ;;
5077
*) compile_rpath="$compile_rpath $absdir"
5078
esac
5079
;;
5080
esac
5081
case " $sys_lib_dlsearch_path " in
5082
*" $libdir "*) ;;
5083
*)
5084
case "$finalize_rpath " in
5085
*" $libdir "*) ;;
5086
*) finalize_rpath="$finalize_rpath $libdir"
5087
esac
5088
;;
5089
esac
5090
fi
5091
5092
if test -n "$old_archive_from_expsyms_cmds"; then
5093
# figure out the soname
5094
set dummy $library_names
5095
shift
5096
realname="$1"
5097
shift
5098
libname=`eval "\\$ECHO \"$libname_spec\""`
5099
# use dlname if we got it. it's perfectly good, no?
5100
if test -n "$dlname"; then
5101
soname="$dlname"
5102
elif test -n "$soname_spec"; then
5103
# bleh windows
5104
case $host in
5105
*cygwin* | mingw*)
5106
func_arith $current - $age
5107
major=$func_arith_result
5108
versuffix="-$major"
5109
;;
5110
esac
5111
eval soname=\"$soname_spec\"
5112
else
5113
soname="$realname"
5114
fi
5115
5116
# Make a new name for the extract_expsyms_cmds to use
5117
soroot="$soname"
5118
func_basename "$soroot"
5119
soname="$func_basename_result"
5120
func_stripname 'lib' '.dll' "$soname"
5121
newlib=libimp-$func_stripname_result.a
5122
5123
# If the library has no export list, then create one now
5124
if test -f "$output_objdir/$soname-def"; then :
5125
else
5126
func_verbose "extracting exported symbol list from \`$soname'"
5127
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5128
fi
5129
5130
# Create $newlib
5131
if test -f "$output_objdir/$newlib"; then :; else
5132
func_verbose "generating import library for \`$soname'"
5133
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5134
fi
5135
# make sure the library variables are pointing to the new library
5136
dir=$output_objdir
5137
linklib=$newlib
5138
fi # test -n "$old_archive_from_expsyms_cmds"
5139
5140
if test "$linkmode" = prog || test "$mode" != relink; then
5141
add_shlibpath=
5142
add_dir=
5143
add=
5144
lib_linked=yes
5145
case $hardcode_action in
5146
immediate | unsupported)
5147
if test "$hardcode_direct" = no; then
5148
add="$dir/$linklib"
5149
case $host in
5150
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5151
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
5152
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5153
*-*-unixware7*) add_dir="-L$dir" ;;
5154
*-*-darwin* )
5155
# if the lib is a (non-dlopened) module then we can not
5156
# link against it, someone is ignoring the earlier warnings
5157
if /usr/bin/file -L $add 2> /dev/null |
5158
$GREP ": [^:]* bundle" >/dev/null ; then
5159
if test "X$dlopenmodule" != "X$lib"; then
5160
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5161
if test -z "$old_library" ; then
5162
$ECHO
5163
$ECHO "*** And there doesn't seem to be a static archive available"
5164
$ECHO "*** The link will probably fail, sorry"
5165
else
5166
add="$dir/$old_library"
5167
fi
5168
elif test -n "$old_library"; then
5169
add="$dir/$old_library"
5170
fi
5171
fi
5172
esac
5173
elif test "$hardcode_minus_L" = no; then
5174
case $host in
5175
*-*-sunos*) add_shlibpath="$dir" ;;
5176
esac
5177
add_dir="-L$dir"
5178
add="-l$name"
5179
elif test "$hardcode_shlibpath_var" = no; then
5180
add_shlibpath="$dir"
5181
add="-l$name"
5182
else
5183
lib_linked=no
5184
fi
5185
;;
5186
relink)
5187
if test "$hardcode_direct" = yes &&
5188
test "$hardcode_direct_absolute" = no; then
5189
add="$dir/$linklib"
5190
elif test "$hardcode_minus_L" = yes; then
5191
add_dir="-L$dir"
5192
# Try looking first in the location we're being installed to.
5193
if test -n "$inst_prefix_dir"; then
5194
case $libdir in
5195
[\\/]*)
5196
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5197
;;
5198
esac
5199
fi
5200
add="-l$name"
5201
elif test "$hardcode_shlibpath_var" = yes; then
5202
add_shlibpath="$dir"
5203
add="-l$name"
5204
else
5205
lib_linked=no
5206
fi
5207
;;
5208
*) lib_linked=no ;;
5209
esac
5210
5211
if test "$lib_linked" != yes; then
5212
func_fatal_configuration "unsupported hardcode properties"
5213
fi
5214
5215
if test -n "$add_shlibpath"; then
5216
case :$compile_shlibpath: in
5217
*":$add_shlibpath:"*) ;;
5218
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5219
esac
5220
fi
5221
if test "$linkmode" = prog; then
5222
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5223
test -n "$add" && compile_deplibs="$add $compile_deplibs"
5224
else
5225
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5226
test -n "$add" && deplibs="$add $deplibs"
5227
if test "$hardcode_direct" != yes &&
5228
test "$hardcode_minus_L" != yes &&
5229
test "$hardcode_shlibpath_var" = yes; then
5230
case :$finalize_shlibpath: in
5231
*":$libdir:"*) ;;
5232
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5233
esac
5234
fi
5235
fi
5236
fi
5237
5238
if test "$linkmode" = prog || test "$mode" = relink; then
5239
add_shlibpath=
5240
add_dir=
5241
add=
5242
# Finalize command for both is simple: just hardcode it.
5243
if test "$hardcode_direct" = yes &&
5244
test "$hardcode_direct_absolute" = no; then
5245
add="$libdir/$linklib"
5246
elif test "$hardcode_minus_L" = yes; then
5247
add_dir="-L$libdir"
5248
add="-l$name"
5249
elif test "$hardcode_shlibpath_var" = yes; then
5250
case :$finalize_shlibpath: in
5251
*":$libdir:"*) ;;
5252
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5253
esac
5254
add="-l$name"
5255
elif test "$hardcode_automatic" = yes; then
5256
if test -n "$inst_prefix_dir" &&
5257
test -f "$inst_prefix_dir$libdir/$linklib" ; then
5258
add="$inst_prefix_dir$libdir/$linklib"
5259
else
5260
add="$libdir/$linklib"
5261
fi
5262
else
5263
# We cannot seem to hardcode it, guess we'll fake it.
5264
add_dir="-L$libdir"
5265
# Try looking first in the location we're being installed to.
5266
if test -n "$inst_prefix_dir"; then
5267
case $libdir in
5268
[\\/]*)
5269
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5270
;;
5271
esac
5272
fi
5273
add="-l$name"
5274
fi
5275
5276
if test "$linkmode" = prog; then
5277
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5278
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5279
else
5280
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5281
test -n "$add" && deplibs="$add $deplibs"
5282
fi
5283
fi
5284
elif test "$linkmode" = prog; then
5285
# Here we assume that one of hardcode_direct or hardcode_minus_L
5286
# is not unsupported. This is valid on all known static and
5287
# shared platforms.
5288
if test "$hardcode_direct" != unsupported; then
5289
test -n "$old_library" && linklib="$old_library"
5290
compile_deplibs="$dir/$linklib $compile_deplibs"
5291
finalize_deplibs="$dir/$linklib $finalize_deplibs"
5292
else
5293
compile_deplibs="-l$name -L$dir $compile_deplibs"
5294
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5295
fi
5296
elif test "$build_libtool_libs" = yes; then
5297
# Not a shared library
5298
if test "$deplibs_check_method" != pass_all; then
5299
# We're trying link a shared library against a static one
5300
# but the system doesn't support it.
5301
5302
# Just print a warning and add the library to dependency_libs so
5303
# that the program can be linked against the static library.
5304
$ECHO
5305
$ECHO "*** Warning: This system can not link to static lib archive $lib."
5306
$ECHO "*** I have the capability to make that library automatically link in when"
5307
$ECHO "*** you link to this library. But I can only do this if you have a"
5308
$ECHO "*** shared version of the library, which you do not appear to have."
5309
if test "$module" = yes; then
5310
$ECHO "*** But as you try to build a module library, libtool will still create "
5311
$ECHO "*** a static module, that should work as long as the dlopening application"
5312
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5313
if test -z "$global_symbol_pipe"; then
5314
$ECHO
5315
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5316
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5317
$ECHO "*** not find such a program. So, this module is probably useless."
5318
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5319
fi
5320
if test "$build_old_libs" = no; then
5321
build_libtool_libs=module
5322
build_old_libs=yes
5323
else
5324
build_libtool_libs=no
5325
fi
5326
fi
5327
else
5328
deplibs="$dir/$old_library $deplibs"
5329
link_static=yes
5330
fi
5331
fi # link shared/static library?
5332
5333
if test "$linkmode" = lib; then
5334
if test -n "$dependency_libs" &&
5335
{ test "$hardcode_into_libs" != yes ||
5336
test "$build_old_libs" = yes ||
5337
test "$link_static" = yes; }; then
5338
# Extract -R from dependency_libs
5339
temp_deplibs=
5340
for libdir in $dependency_libs; do
5341
case $libdir in
5342
-R*) func_stripname '-R' '' "$libdir"
5343
temp_xrpath=$func_stripname_result
5344
case " $xrpath " in
5345
*" $temp_xrpath "*) ;;
5346
*) xrpath="$xrpath $temp_xrpath";;
5347
esac;;
5348
*) temp_deplibs="$temp_deplibs $libdir";;
5349
esac
5350
done
5351
dependency_libs="$temp_deplibs"
5352
fi
5353
5354
newlib_search_path="$newlib_search_path $absdir"
5355
# Link against this library
5356
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5357
# ... and its dependency_libs
5358
tmp_libs=
5359
for deplib in $dependency_libs; do
5360
newdependency_libs="$deplib $newdependency_libs"
5361
if $opt_duplicate_deps ; then
5362
case "$tmp_libs " in
5363
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5364
esac
5365
fi
5366
tmp_libs="$tmp_libs $deplib"
5367
done
5368
5369
if test "$link_all_deplibs" != no; then
5370
# Add the search paths of all dependency libraries
5371
for deplib in $dependency_libs; do
5372
case $deplib in
5373
-L*) path="$deplib" ;;
5374
*.la)
5375
func_dirname "$deplib" "" "."
5376
dir="$func_dirname_result"
5377
# We need an absolute path.
5378
case $dir in
5379
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5380
*)
5381
absdir=`cd "$dir" && pwd`
5382
if test -z "$absdir"; then
5383
func_warning "cannot determine absolute directory name of \`$dir'"
5384
absdir="$dir"
5385
fi
5386
;;
5387
esac
5388
if $GREP "^installed=no" $deplib > /dev/null; then
5389
case $host in
5390
*-*-darwin*)
5391
depdepl=
5392
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5393
if test -n "$deplibrary_names" ; then
5394
for tmp in $deplibrary_names ; do
5395
depdepl=$tmp
5396
done
5397
if test -f "$absdir/$objdir/$depdepl" ; then
5398
depdepl="$absdir/$objdir/$depdepl"
5399
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5400
if test -z "$darwin_install_name"; then
5401
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5402
fi
5403
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5404
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5405
path=
5406
fi
5407
fi
5408
;;
5409
*)
5410
path="-L$absdir/$objdir"
5411
;;
5412
esac
5413
else
5414
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5415
test -z "$libdir" && \
5416
func_fatal_error "\`$deplib' is not a valid libtool archive"
5417
test "$absdir" != "$libdir" && \
5418
func_warning "\`$deplib' seems to be moved"
5419
5420
path="-L$absdir"
5421
fi
5422
;;
5423
esac
5424
case " $deplibs " in
5425
*" $path "*) ;;
5426
*) deplibs="$path $deplibs" ;;
5427
esac
5428
done
5429
fi # link_all_deplibs != no
5430
fi # linkmode = lib
5431
done # for deplib in $libs
5432
if test "$pass" = link; then
5433
if test "$linkmode" = "prog"; then
5434
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5435
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5436
else
5437
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5438
fi
5439
fi
5440
dependency_libs="$newdependency_libs"
5441
if test "$pass" = dlpreopen; then
5442
# Link the dlpreopened libraries before other libraries
5443
for deplib in $save_deplibs; do
5444
deplibs="$deplib $deplibs"
5445
done
5446
fi
5447
if test "$pass" != dlopen; then
5448
if test "$pass" != conv; then
5449
# Make sure lib_search_path contains only unique directories.
5450
lib_search_path=
5451
for dir in $newlib_search_path; do
5452
case "$lib_search_path " in
5453
*" $dir "*) ;;
5454
*) lib_search_path="$lib_search_path $dir" ;;
5455
esac
5456
done
5457
newlib_search_path=
5458
fi
5459
5460
if test "$linkmode,$pass" != "prog,link"; then
5461
vars="deplibs"
5462
else
5463
vars="compile_deplibs finalize_deplibs"
5464
fi
5465
for var in $vars dependency_libs; do
5466
# Add libraries to $var in reverse order
5467
eval tmp_libs=\"\$$var\"
5468
new_libs=
5469
for deplib in $tmp_libs; do
5470
# FIXME: Pedantically, this is the right thing to do, so
5471
# that some nasty dependency loop isn't accidentally
5472
# broken:
5473
#new_libs="$deplib $new_libs"
5474
# Pragmatically, this seems to cause very few problems in
5475
# practice:
5476
case $deplib in
5477
-L*) new_libs="$deplib $new_libs" ;;
5478
-R*) ;;
5479
*)
5480
# And here is the reason: when a library appears more
5481
# than once as an explicit dependence of a library, or
5482
# is implicitly linked in more than once by the
5483
# compiler, it is considered special, and multiple
5484
# occurrences thereof are not removed. Compare this
5485
# with having the same library being listed as a
5486
# dependency of multiple other libraries: in this case,
5487
# we know (pedantically, we assume) the library does not
5488
# need to be listed more than once, so we keep only the
5489
# last copy. This is not always right, but it is rare
5490
# enough that we require users that really mean to play
5491
# such unportable linking tricks to link the library
5492
# using -Wl,-lname, so that libtool does not consider it
5493
# for duplicate removal.
5494
case " $specialdeplibs " in
5495
*" $deplib "*) new_libs="$deplib $new_libs" ;;
5496
*)
5497
case " $new_libs " in
5498
*" $deplib "*) ;;
5499
*) new_libs="$deplib $new_libs" ;;
5500
esac
5501
;;
5502
esac
5503
;;
5504
esac
5505
done
5506
tmp_libs=
5507
for deplib in $new_libs; do
5508
case $deplib in
5509
-L*)
5510
case " $tmp_libs " in
5511
*" $deplib "*) ;;
5512
*) tmp_libs="$tmp_libs $deplib" ;;
5513
esac
5514
;;
5515
*) tmp_libs="$tmp_libs $deplib" ;;
5516
esac
5517
done
5518
eval $var=\"$tmp_libs\"
5519
done # for var
5520
fi
5521
# Last step: remove runtime libs from dependency_libs
5522
# (they stay in deplibs)
5523
tmp_libs=
5524
for i in $dependency_libs ; do
5525
case " $predeps $postdeps $compiler_lib_search_path " in
5526
*" $i "*)
5527
i=""
5528
;;
5529
esac
5530
if test -n "$i" ; then
5531
tmp_libs="$tmp_libs $i"
5532
fi
5533
done
5534
dependency_libs=$tmp_libs
5535
done # for pass
5536
if test "$linkmode" = prog; then
5537
dlfiles="$newdlfiles"
5538
fi
5539
if test "$linkmode" = prog || test "$linkmode" = lib; then
5540
dlprefiles="$newdlprefiles"
5541
fi
5542
5543
case $linkmode in
5544
oldlib)
5545
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
5546
func_warning "\`-dlopen' is ignored for archives"
5547
fi
5548
5549
case " $deplibs" in
5550
*\ -l* | *\ -L*)
5551
func_warning "\`-l' and \`-L' are ignored for archives" ;;
5552
esac
5553
5554
test -n "$rpath" && \
5555
func_warning "\`-rpath' is ignored for archives"
5556
5557
test -n "$xrpath" && \
5558
func_warning "\`-R' is ignored for archives"
5559
5560
test -n "$vinfo" && \
5561
func_warning "\`-version-info/-version-number' is ignored for archives"
5562
5563
test -n "$release" && \
5564
func_warning "\`-release' is ignored for archives"
5565
5566
test -n "$export_symbols$export_symbols_regex" && \
5567
func_warning "\`-export-symbols' is ignored for archives"
5568
5569
# Now set the variables for building old libraries.
5570
build_libtool_libs=no
5571
oldlibs="$output"
5572
objs="$objs$old_deplibs"
5573
;;
5574
5575
lib)
5576
# Make sure we only generate libraries of the form `libNAME.la'.
5577
case $outputname in
5578
lib*)
5579
func_stripname 'lib' '.la' "$outputname"
5580
name=$func_stripname_result
5581
eval shared_ext=\"$shrext_cmds\"
5582
eval libname=\"$libname_spec\"
5583
;;
5584
*)
5585
test "$module" = no && \
5586
func_fatal_help "libtool library \`$output' must begin with \`lib'"
5587
5588
if test "$need_lib_prefix" != no; then
5589
# Add the "lib" prefix for modules if required
5590
func_stripname '' '.la' "$outputname"
5591
name=$func_stripname_result
5592
eval shared_ext=\"$shrext_cmds\"
5593
eval libname=\"$libname_spec\"
5594
else
5595
func_stripname '' '.la' "$outputname"
5596
libname=$func_stripname_result
5597
fi
5598
;;
5599
esac
5600
5601
if test -n "$objs"; then
5602
if test "$deplibs_check_method" != pass_all; then
5603
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
5604
else
5605
$ECHO
5606
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
5607
$ECHO "*** objects $objs is not portable!"
5608
libobjs="$libobjs $objs"
5609
fi
5610
fi
5611
5612
test "$dlself" != no && \
5613
func_warning "\`-dlopen self' is ignored for libtool libraries"
5614
5615
set dummy $rpath
5616
shift
5617
test "$#" -gt 1 && \
5618
func_warning "ignoring multiple \`-rpath's for a libtool library"
5619
5620
install_libdir="$1"
5621
5622
oldlibs=
5623
if test -z "$rpath"; then
5624
if test "$build_libtool_libs" = yes; then
5625
# Building a libtool convenience library.
5626
# Some compilers have problems with a `.al' extension so
5627
# convenience libraries should have the same extension an
5628
# archive normally would.
5629
oldlibs="$output_objdir/$libname.$libext $oldlibs"
5630
build_libtool_libs=convenience
5631
build_old_libs=yes
5632
fi
5633
5634
test -n "$vinfo" && \
5635
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
5636
5637
test -n "$release" && \
5638
func_warning "\`-release' is ignored for convenience libraries"
5639
else
5640
5641
# Parse the version information argument.
5642
save_ifs="$IFS"; IFS=':'
5643
set dummy $vinfo 0 0 0
5644
shift
5645
IFS="$save_ifs"
5646
5647
test -n "$7" && \
5648
func_fatal_help "too many parameters to \`-version-info'"
5649
5650
# convert absolute version numbers to libtool ages
5651
# this retains compatibility with .la files and attempts
5652
# to make the code below a bit more comprehensible
5653
5654
case $vinfo_number in
5655
yes)
5656
number_major="$1"
5657
number_minor="$2"
5658
number_revision="$3"
5659
#
5660
# There are really only two kinds -- those that
5661
# use the current revision as the major version
5662
# and those that subtract age and use age as
5663
# a minor version. But, then there is irix
5664
# which has an extra 1 added just for fun
5665
#
5666
case $version_type in
5667
darwin|linux|osf|windows|none)
5668
func_arith $number_major + $number_minor
5669
current=$func_arith_result
5670
age="$number_minor"
5671
revision="$number_revision"
5672
;;
5673
freebsd-aout|freebsd-elf|sunos)
5674
current="$number_major"
5675
revision="$number_minor"
5676
age="0"
5677
;;
5678
irix|nonstopux)
5679
func_arith $number_major + $number_minor
5680
current=$func_arith_result
5681
age="$number_minor"
5682
revision="$number_minor"
5683
lt_irix_increment=no
5684
;;
5685
*)
5686
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
5687
;;
5688
esac
5689
;;
5690
no)
5691
current="$1"
5692
revision="$2"
5693
age="$3"
5694
;;
5695
esac
5696
5697
# Check that each of the things are valid numbers.
5698
case $current in
5699
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]) ;;
5700
*)
5701
func_error "CURRENT \`$current' must be a nonnegative integer"
5702
func_fatal_error "\`$vinfo' is not valid version information"
5703
;;
5704
esac
5705
5706
case $revision in
5707
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]) ;;
5708
*)
5709
func_error "REVISION \`$revision' must be a nonnegative integer"
5710
func_fatal_error "\`$vinfo' is not valid version information"
5711
;;
5712
esac
5713
5714
case $age in
5715
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]) ;;
5716
*)
5717
func_error "AGE \`$age' must be a nonnegative integer"
5718
func_fatal_error "\`$vinfo' is not valid version information"
5719
;;
5720
esac
5721
5722
if test "$age" -gt "$current"; then
5723
func_error "AGE \`$age' is greater than the current interface number \`$current'"
5724
func_fatal_error "\`$vinfo' is not valid version information"
5725
fi
5726
5727
# Calculate the version variables.
5728
major=
5729
versuffix=
5730
verstring=
5731
case $version_type in
5732
none) ;;
5733
5734
darwin)
5735
# Like Linux, but with the current version available in
5736
# verstring for coding it into the library header
5737
func_arith $current - $age
5738
major=.$func_arith_result
5739
versuffix="$major.$age.$revision"
5740
# Darwin ld doesn't like 0 for these options...
5741
func_arith $current + 1
5742
minor_current=$func_arith_result
5743
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
5744
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
5745
;;
5746
5747
freebsd-aout)
5748
major=".$current"
5749
versuffix=".$current.$revision";
5750
;;
5751
5752
freebsd-elf)
5753
major=".$current"
5754
versuffix=".$current"
5755
;;
5756
5757
irix | nonstopux)
5758
if test "X$lt_irix_increment" = "Xno"; then
5759
func_arith $current - $age
5760
else
5761
func_arith $current - $age + 1
5762
fi
5763
major=$func_arith_result
5764
5765
case $version_type in
5766
nonstopux) verstring_prefix=nonstopux ;;
5767
*) verstring_prefix=sgi ;;
5768
esac
5769
verstring="$verstring_prefix$major.$revision"
5770
5771
# Add in all the interfaces that we are compatible with.
5772
loop=$revision
5773
while test "$loop" -ne 0; do
5774
func_arith $revision - $loop
5775
iface=$func_arith_result
5776
func_arith $loop - 1
5777
loop=$func_arith_result
5778
verstring="$verstring_prefix$major.$iface:$verstring"
5779
done
5780
5781
# Before this point, $major must not contain `.'.
5782
major=.$major
5783
versuffix="$major.$revision"
5784
;;
5785
5786
linux)
5787
func_arith $current - $age
5788
major=.$func_arith_result
5789
versuffix="$major.$age.$revision"
5790
;;
5791
5792
osf)
5793
func_arith $current - $age
5794
major=.$func_arith_result
5795
versuffix=".$current.$age.$revision"
5796
verstring="$current.$age.$revision"
5797
5798
# Add in all the interfaces that we are compatible with.
5799
loop=$age
5800
while test "$loop" -ne 0; do
5801
func_arith $current - $loop
5802
iface=$func_arith_result
5803
func_arith $loop - 1
5804
loop=$func_arith_result
5805
verstring="$verstring:${iface}.0"
5806
done
5807
5808
# Make executables depend on our current version.
5809
verstring="$verstring:${current}.0"
5810
;;
5811
5812
qnx)
5813
major=".$current"
5814
versuffix=".$current"
5815
;;
5816
5817
sunos)
5818
major=".$current"
5819
versuffix=".$current.$revision"
5820
;;
5821
5822
windows)
5823
# Use '-' rather than '.', since we only want one
5824
# extension on DOS 8.3 filesystems.
5825
func_arith $current - $age
5826
major=$func_arith_result
5827
versuffix="-$major"
5828
;;
5829
5830
*)
5831
func_fatal_configuration "unknown library version type \`$version_type'"
5832
;;
5833
esac
5834
5835
# Clear the version info if we defaulted, and they specified a release.
5836
if test -z "$vinfo" && test -n "$release"; then
5837
major=
5838
case $version_type in
5839
darwin)
5840
# we can't check for "0.0" in archive_cmds due to quoting
5841
# problems, so we reset it completely
5842
verstring=
5843
;;
5844
*)
5845
verstring="0.0"
5846
;;
5847
esac
5848
if test "$need_version" = no; then
5849
versuffix=
5850
else
5851
versuffix=".0.0"
5852
fi
5853
fi
5854
5855
# Remove version info from name if versioning should be avoided
5856
if test "$avoid_version" = yes && test "$need_version" = no; then
5857
major=
5858
versuffix=
5859
verstring=""
5860
fi
5861
5862
# Check to see if the archive will have undefined symbols.
5863
if test "$allow_undefined" = yes; then
5864
if test "$allow_undefined_flag" = unsupported; then
5865
func_warning "undefined symbols not allowed in $host shared libraries"
5866
build_libtool_libs=no
5867
build_old_libs=yes
5868
fi
5869
else
5870
# Don't allow undefined symbols.
5871
allow_undefined_flag="$no_undefined_flag"
5872
fi
5873
5874
fi
5875
5876
func_generate_dlsyms "$libname" "$libname" "yes"
5877
libobjs="$libobjs $symfileobj"
5878
test "X$libobjs" = "X " && libobjs=
5879
5880
if test "$mode" != relink; then
5881
# Remove our outputs, but don't remove object files since they
5882
# may have been created when compiling PIC objects.
5883
removelist=
5884
tempremovelist=`$ECHO "$output_objdir/*"`
5885
for p in $tempremovelist; do
5886
case $p in
5887
*.$objext)
5888
;;
5889
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
5890
if test "X$precious_files_regex" != "X"; then
5891
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
5892
then
5893
continue
5894
fi
5895
fi
5896
removelist="$removelist $p"
5897
;;
5898
*) ;;
5899
esac
5900
done
5901
test -n "$removelist" && \
5902
func_show_eval "${RM}r \$removelist"
5903
fi
5904
5905
# Now set the variables for building old libraries.
5906
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
5907
oldlibs="$oldlibs $output_objdir/$libname.$libext"
5908
5909
# Transform .lo files to .o files.
5910
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
5911
fi
5912
5913
# Eliminate all temporary directories.
5914
#for path in $notinst_path; do
5915
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
5916
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
5917
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
5918
#done
5919
5920
if test -n "$xrpath"; then
5921
# If the user specified any rpath flags, then add them.
5922
temp_xrpath=
5923
for libdir in $xrpath; do
5924
temp_xrpath="$temp_xrpath -R$libdir"
5925
case "$finalize_rpath " in
5926
*" $libdir "*) ;;
5927
*) finalize_rpath="$finalize_rpath $libdir" ;;
5928
esac
5929
done
5930
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
5931
dependency_libs="$temp_xrpath $dependency_libs"
5932
fi
5933
fi
5934
5935
# Make sure dlfiles contains only unique files that won't be dlpreopened
5936
old_dlfiles="$dlfiles"
5937
dlfiles=
5938
for lib in $old_dlfiles; do
5939
case " $dlprefiles $dlfiles " in
5940
*" $lib "*) ;;
5941
*) dlfiles="$dlfiles $lib" ;;
5942
esac
5943
done
5944
5945
# Make sure dlprefiles contains only unique files
5946
old_dlprefiles="$dlprefiles"
5947
dlprefiles=
5948
for lib in $old_dlprefiles; do
5949
case "$dlprefiles " in
5950
*" $lib "*) ;;
5951
*) dlprefiles="$dlprefiles $lib" ;;
5952
esac
5953
done
5954
5955
if test "$build_libtool_libs" = yes; then
5956
if test -n "$rpath"; then
5957
case $host in
5958
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
5959
# these systems don't actually have a c library (as such)!
5960
;;
5961
*-*-rhapsody* | *-*-darwin1.[012])
5962
# Rhapsody C library is in the System framework
5963
deplibs="$deplibs System.ltframework"
5964
;;
5965
*-*-netbsd*)
5966
# Don't link with libc until the a.out ld.so is fixed.
5967
;;
5968
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5969
# Do not include libc due to us having libc/libc_r.
5970
;;
5971
*-*-sco3.2v5* | *-*-sco5v6*)
5972
# Causes problems with __ctype
5973
;;
5974
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5975
# Compiler inserts libc in the correct place for threads to work
5976
;;
5977
*)
5978
# Add libc to deplibs on all other systems if necessary.
5979
if test "$build_libtool_need_lc" = "yes"; then
5980
deplibs="$deplibs -lc"
5981
fi
5982
;;
5983
esac
5984
fi
5985
5986
# Transform deplibs into only deplibs that can be linked in shared.
5987
name_save=$name
5988
libname_save=$libname
5989
release_save=$release
5990
versuffix_save=$versuffix
5991
major_save=$major
5992
# I'm not sure if I'm treating the release correctly. I think
5993
# release should show up in the -l (ie -lgmp5) so we don't want to
5994
# add it in twice. Is that correct?
5995
release=""
5996
versuffix=""
5997
major=""
5998
newdeplibs=
5999
droppeddeps=no
6000
case $deplibs_check_method in
6001
pass_all)
6002
# Don't check for shared/static. Everything works.
6003
# This might be a little naive. We might want to check
6004
# whether the library exists or not. But this is on
6005
# osf3 & osf4 and I'm not really sure... Just
6006
# implementing what was already the behavior.
6007
newdeplibs=$deplibs
6008
;;
6009
test_compile)
6010
# This code stresses the "libraries are programs" paradigm to its
6011
# limits. Maybe even breaks it. We compile a program, linking it
6012
# against the deplibs as a proxy for the library. Then we can check
6013
# whether they linked in statically or dynamically with ldd.
6014
$opt_dry_run || $RM conftest.c
6015
cat > conftest.c <<EOF
6016
int main() { return 0; }
6017
EOF
6018
$opt_dry_run || $RM conftest
6019
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6020
ldd_output=`ldd conftest`
6021
for i in $deplibs; do
6022
case $i in
6023
-l*)
6024
func_stripname -l '' "$i"
6025
name=$func_stripname_result
6026
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6027
case " $predeps $postdeps " in
6028
*" $i "*)
6029
newdeplibs="$newdeplibs $i"
6030
i=""
6031
;;
6032
esac
6033
fi
6034
if test -n "$i" ; then
6035
libname=`eval "\\$ECHO \"$libname_spec\""`
6036
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6037
set dummy $deplib_matches; shift
6038
deplib_match=$1
6039
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6040
newdeplibs="$newdeplibs $i"
6041
else
6042
droppeddeps=yes
6043
$ECHO
6044
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6045
$ECHO "*** I have the capability to make that library automatically link in when"
6046
$ECHO "*** you link to this library. But I can only do this if you have a"
6047
$ECHO "*** shared version of the library, which I believe you do not have"
6048
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6049
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6050
fi
6051
fi
6052
;;
6053
*)
6054
newdeplibs="$newdeplibs $i"
6055
;;
6056
esac
6057
done
6058
else
6059
# Error occurred in the first compile. Let's try to salvage
6060
# the situation: Compile a separate program for each library.
6061
for i in $deplibs; do
6062
case $i in
6063
-l*)
6064
func_stripname -l '' "$i"
6065
name=$func_stripname_result
6066
$opt_dry_run || $RM conftest
6067
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6068
ldd_output=`ldd conftest`
6069
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6070
case " $predeps $postdeps " in
6071
*" $i "*)
6072
newdeplibs="$newdeplibs $i"
6073
i=""
6074
;;
6075
esac
6076
fi
6077
if test -n "$i" ; then
6078
libname=`eval "\\$ECHO \"$libname_spec\""`
6079
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6080
set dummy $deplib_matches; shift
6081
deplib_match=$1
6082
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6083
newdeplibs="$newdeplibs $i"
6084
else
6085
droppeddeps=yes
6086
$ECHO
6087
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6088
$ECHO "*** I have the capability to make that library automatically link in when"
6089
$ECHO "*** you link to this library. But I can only do this if you have a"
6090
$ECHO "*** shared version of the library, which you do not appear to have"
6091
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6092
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6093
fi
6094
fi
6095
else
6096
droppeddeps=yes
6097
$ECHO
6098
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6099
$ECHO "*** make it link in! You will probably need to install it or some"
6100
$ECHO "*** library that it depends on before this library will be fully"
6101
$ECHO "*** functional. Installing it before continuing would be even better."
6102
fi
6103
;;
6104
*)
6105
newdeplibs="$newdeplibs $i"
6106
;;
6107
esac
6108
done
6109
fi
6110
;;
6111
file_magic*)
6112
set dummy $deplibs_check_method; shift
6113
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6114
for a_deplib in $deplibs; do
6115
case $a_deplib in
6116
-l*)
6117
func_stripname -l '' "$a_deplib"
6118
name=$func_stripname_result
6119
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6120
case " $predeps $postdeps " in
6121
*" $a_deplib "*)
6122
newdeplibs="$newdeplibs $a_deplib"
6123
a_deplib=""
6124
;;
6125
esac
6126
fi
6127
if test -n "$a_deplib" ; then
6128
libname=`eval "\\$ECHO \"$libname_spec\""`
6129
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6130
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6131
for potent_lib in $potential_libs; do
6132
# Follow soft links.
6133
if ls -lLd "$potent_lib" 2>/dev/null |
6134
$GREP " -> " >/dev/null; then
6135
continue
6136
fi
6137
# The statement above tries to avoid entering an
6138
# endless loop below, in case of cyclic links.
6139
# We might still enter an endless loop, since a link
6140
# loop can be closed while we follow links,
6141
# but so what?
6142
potlib="$potent_lib"
6143
while test -h "$potlib" 2>/dev/null; do
6144
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6145
case $potliblink in
6146
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6147
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6148
esac
6149
done
6150
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6151
$SED -e 10q |
6152
$EGREP "$file_magic_regex" > /dev/null; then
6153
newdeplibs="$newdeplibs $a_deplib"
6154
a_deplib=""
6155
break 2
6156
fi
6157
done
6158
done
6159
fi
6160
if test -n "$a_deplib" ; then
6161
droppeddeps=yes
6162
$ECHO
6163
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6164
$ECHO "*** I have the capability to make that library automatically link in when"
6165
$ECHO "*** you link to this library. But I can only do this if you have a"
6166
$ECHO "*** shared version of the library, which you do not appear to have"
6167
$ECHO "*** because I did check the linker path looking for a file starting"
6168
if test -z "$potlib" ; then
6169
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6170
else
6171
$ECHO "*** with $libname and none of the candidates passed a file format test"
6172
$ECHO "*** using a file magic. Last file checked: $potlib"
6173
fi
6174
fi
6175
;;
6176
*)
6177
# Add a -L argument.
6178
newdeplibs="$newdeplibs $a_deplib"
6179
;;
6180
esac
6181
done # Gone through all deplibs.
6182
;;
6183
match_pattern*)
6184
set dummy $deplibs_check_method; shift
6185
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6186
for a_deplib in $deplibs; do
6187
case $a_deplib in
6188
-l*)
6189
func_stripname -l '' "$a_deplib"
6190
name=$func_stripname_result
6191
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6192
case " $predeps $postdeps " in
6193
*" $a_deplib "*)
6194
newdeplibs="$newdeplibs $a_deplib"
6195
a_deplib=""
6196
;;
6197
esac
6198
fi
6199
if test -n "$a_deplib" ; then
6200
libname=`eval "\\$ECHO \"$libname_spec\""`
6201
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6202
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6203
for potent_lib in $potential_libs; do
6204
potlib="$potent_lib" # see symlink-check above in file_magic test
6205
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6206
$EGREP "$match_pattern_regex" > /dev/null; then
6207
newdeplibs="$newdeplibs $a_deplib"
6208
a_deplib=""
6209
break 2
6210
fi
6211
done
6212
done
6213
fi
6214
if test -n "$a_deplib" ; then
6215
droppeddeps=yes
6216
$ECHO
6217
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6218
$ECHO "*** I have the capability to make that library automatically link in when"
6219
$ECHO "*** you link to this library. But I can only do this if you have a"
6220
$ECHO "*** shared version of the library, which you do not appear to have"
6221
$ECHO "*** because I did check the linker path looking for a file starting"
6222
if test -z "$potlib" ; then
6223
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6224
else
6225
$ECHO "*** with $libname and none of the candidates passed a file format test"
6226
$ECHO "*** using a regex pattern. Last file checked: $potlib"
6227
fi
6228
fi
6229
;;
6230
*)
6231
# Add a -L argument.
6232
newdeplibs="$newdeplibs $a_deplib"
6233
;;
6234
esac
6235
done # Gone through all deplibs.
6236
;;
6237
none | unknown | *)
6238
newdeplibs=""
6239
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6240
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6241
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6242
for i in $predeps $postdeps ; do
6243
# can't use Xsed below, because $i might contain '/'
6244
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6245
done
6246
fi
6247
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6248
$GREP . >/dev/null; then
6249
$ECHO
6250
if test "X$deplibs_check_method" = "Xnone"; then
6251
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6252
else
6253
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
6254
fi
6255
$ECHO "*** All declared inter-library dependencies are being dropped."
6256
droppeddeps=yes
6257
fi
6258
;;
6259
esac
6260
versuffix=$versuffix_save
6261
major=$major_save
6262
release=$release_save
6263
libname=$libname_save
6264
name=$name_save
6265
6266
case $host in
6267
*-*-rhapsody* | *-*-darwin1.[012])
6268
# On Rhapsody replace the C library with the System framework
6269
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6270
;;
6271
esac
6272
6273
if test "$droppeddeps" = yes; then
6274
if test "$module" = yes; then
6275
$ECHO
6276
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6277
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6278
$ECHO "*** a static module, that should work as long as the dlopening"
6279
$ECHO "*** application is linked with the -dlopen flag."
6280
if test -z "$global_symbol_pipe"; then
6281
$ECHO
6282
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6283
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6284
$ECHO "*** not find such a program. So, this module is probably useless."
6285
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6286
fi
6287
if test "$build_old_libs" = no; then
6288
oldlibs="$output_objdir/$libname.$libext"
6289
build_libtool_libs=module
6290
build_old_libs=yes
6291
else
6292
build_libtool_libs=no
6293
fi
6294
else
6295
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6296
$ECHO "*** automatically added whenever a program is linked with this library"
6297
$ECHO "*** or is declared to -dlopen it."
6298
6299
if test "$allow_undefined" = no; then
6300
$ECHO
6301
$ECHO "*** Since this library must not contain undefined symbols,"
6302
$ECHO "*** because either the platform does not support them or"
6303
$ECHO "*** it was explicitly requested with -no-undefined,"
6304
$ECHO "*** libtool will only create a static version of it."
6305
if test "$build_old_libs" = no; then
6306
oldlibs="$output_objdir/$libname.$libext"
6307
build_libtool_libs=module
6308
build_old_libs=yes
6309
else
6310
build_libtool_libs=no
6311
fi
6312
fi
6313
fi
6314
fi
6315
# Done checking deplibs!
6316
deplibs=$newdeplibs
6317
fi
6318
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6319
case $host in
6320
*-*-darwin*)
6321
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6322
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6323
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6324
;;
6325
esac
6326
6327
# move library search paths that coincide with paths to not yet
6328
# installed libraries to the beginning of the library search list
6329
new_libs=
6330
for path in $notinst_path; do
6331
case " $new_libs " in
6332
*" -L$path/$objdir "*) ;;
6333
*)
6334
case " $deplibs " in
6335
*" -L$path/$objdir "*)
6336
new_libs="$new_libs -L$path/$objdir" ;;
6337
esac
6338
;;
6339
esac
6340
done
6341
for deplib in $deplibs; do
6342
case $deplib in
6343
-L*)
6344
case " $new_libs " in
6345
*" $deplib "*) ;;
6346
*) new_libs="$new_libs $deplib" ;;
6347
esac
6348
;;
6349
*) new_libs="$new_libs $deplib" ;;
6350
esac
6351
done
6352
deplibs="$new_libs"
6353
6354
# All the library-specific variables (install_libdir is set above).
6355
library_names=
6356
old_library=
6357
dlname=
6358
6359
# Test again, we may have decided not to build it any more
6360
if test "$build_libtool_libs" = yes; then
6361
if test "$hardcode_into_libs" = yes; then
6362
# Hardcode the library paths
6363
hardcode_libdirs=
6364
dep_rpath=
6365
rpath="$finalize_rpath"
6366
test "$mode" != relink && rpath="$compile_rpath$rpath"
6367
for libdir in $rpath; do
6368
if test -n "$hardcode_libdir_flag_spec"; then
6369
if test -n "$hardcode_libdir_separator"; then
6370
if test -z "$hardcode_libdirs"; then
6371
hardcode_libdirs="$libdir"
6372
else
6373
# Just accumulate the unique libdirs.
6374
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6375
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6376
;;
6377
*)
6378
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6379
;;
6380
esac
6381
fi
6382
else
6383
eval flag=\"$hardcode_libdir_flag_spec\"
6384
dep_rpath="$dep_rpath $flag"
6385
fi
6386
elif test -n "$runpath_var"; then
6387
case "$perm_rpath " in
6388
*" $libdir "*) ;;
6389
*) perm_rpath="$perm_rpath $libdir" ;;
6390
esac
6391
fi
6392
done
6393
# Substitute the hardcoded libdirs into the rpath.
6394
if test -n "$hardcode_libdir_separator" &&
6395
test -n "$hardcode_libdirs"; then
6396
libdir="$hardcode_libdirs"
6397
if test -n "$hardcode_libdir_flag_spec_ld"; then
6398
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6399
else
6400
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6401
fi
6402
fi
6403
if test -n "$runpath_var" && test -n "$perm_rpath"; then
6404
# We should set the runpath_var.
6405
rpath=
6406
for dir in $perm_rpath; do
6407
rpath="$rpath$dir:"
6408
done
6409
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6410
fi
6411
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6412
fi
6413
6414
shlibpath="$finalize_shlibpath"
6415
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6416
if test -n "$shlibpath"; then
6417
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6418
fi
6419
6420
# Get the real and link names of the library.
6421
eval shared_ext=\"$shrext_cmds\"
6422
eval library_names=\"$library_names_spec\"
6423
set dummy $library_names
6424
shift
6425
realname="$1"
6426
shift
6427
6428
if test -n "$soname_spec"; then
6429
eval soname=\"$soname_spec\"
6430
else
6431
soname="$realname"
6432
fi
6433
if test -z "$dlname"; then
6434
dlname=$soname
6435
fi
6436
6437
lib="$output_objdir/$realname"
6438
linknames=
6439
for link
6440
do
6441
linknames="$linknames $link"
6442
done
6443
6444
# Use standard objects if they are pic
6445
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6446
test "X$libobjs" = "X " && libobjs=
6447
6448
delfiles=
6449
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6450
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6451
export_symbols="$output_objdir/$libname.uexp"
6452
delfiles="$delfiles $export_symbols"
6453
fi
6454
6455
orig_export_symbols=
6456
case $host_os in
6457
cygwin* | mingw*)
6458
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6459
# exporting using user supplied symfile
6460
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6461
# and it's NOT already a .def file. Must figure out
6462
# which of the given symbols are data symbols and tag
6463
# them as such. So, trigger use of export_symbols_cmds.
6464
# export_symbols gets reassigned inside the "prepare
6465
# the list of exported symbols" if statement, so the
6466
# include_expsyms logic still works.
6467
orig_export_symbols="$export_symbols"
6468
export_symbols=
6469
always_export_symbols=yes
6470
fi
6471
fi
6472
;;
6473
esac
6474
6475
# Prepare the list of exported symbols
6476
if test -z "$export_symbols"; then
6477
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6478
func_verbose "generating symbol list for \`$libname.la'"
6479
export_symbols="$output_objdir/$libname.exp"
6480
$opt_dry_run || $RM $export_symbols
6481
cmds=$export_symbols_cmds
6482
save_ifs="$IFS"; IFS='~'
6483
for cmd in $cmds; do
6484
IFS="$save_ifs"
6485
eval cmd=\"$cmd\"
6486
func_len " $cmd"
6487
len=$func_len_result
6488
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6489
func_show_eval "$cmd" 'exit $?'
6490
skipped_export=false
6491
else
6492
# The command line is too long to execute in one step.
6493
func_verbose "using reloadable object file for export list..."
6494
skipped_export=:
6495
# Break out early, otherwise skipped_export may be
6496
# set to false by a later but shorter cmd.
6497
break
6498
fi
6499
done
6500
IFS="$save_ifs"
6501
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
6502
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6503
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6504
fi
6505
fi
6506
fi
6507
6508
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6509
tmp_export_symbols="$export_symbols"
6510
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6511
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6512
fi
6513
6514
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
6515
# The given exports_symbols file has to be filtered, so filter it.
6516
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6517
# FIXME: $output_objdir/$libname.filter potentially contains lots of
6518
# 's' commands which not all seds can handle. GNU sed should be fine
6519
# though. Also, the filter scales superlinearly with the number of
6520
# global variables. join(1) would be nice here, but unfortunately
6521
# isn't a blessed tool.
6522
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6523
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6524
export_symbols=$output_objdir/$libname.def
6525
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6526
fi
6527
6528
tmp_deplibs=
6529
for test_deplib in $deplibs; do
6530
case " $convenience " in
6531
*" $test_deplib "*) ;;
6532
*)
6533
tmp_deplibs="$tmp_deplibs $test_deplib"
6534
;;
6535
esac
6536
done
6537
deplibs="$tmp_deplibs"
6538
6539
if test -n "$convenience"; then
6540
if test -n "$whole_archive_flag_spec" &&
6541
test "$compiler_needs_object" = yes &&
6542
test -z "$libobjs"; then
6543
# extract the archives, so we have objects to list.
6544
# TODO: could optimize this to just extract one archive.
6545
whole_archive_flag_spec=
6546
fi
6547
if test -n "$whole_archive_flag_spec"; then
6548
save_libobjs=$libobjs
6549
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6550
test "X$libobjs" = "X " && libobjs=
6551
else
6552
gentop="$output_objdir/${outputname}x"
6553
generated="$generated $gentop"
6554
6555
func_extract_archives $gentop $convenience
6556
libobjs="$libobjs $func_extract_archives_result"
6557
test "X$libobjs" = "X " && libobjs=
6558
fi
6559
fi
6560
6561
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
6562
eval flag=\"$thread_safe_flag_spec\"
6563
linker_flags="$linker_flags $flag"
6564
fi
6565
6566
# Make a backup of the uninstalled library when relinking
6567
if test "$mode" = relink; then
6568
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
6569
fi
6570
6571
# Do each of the archive commands.
6572
if test "$module" = yes && test -n "$module_cmds" ; then
6573
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6574
eval test_cmds=\"$module_expsym_cmds\"
6575
cmds=$module_expsym_cmds
6576
else
6577
eval test_cmds=\"$module_cmds\"
6578
cmds=$module_cmds
6579
fi
6580
else
6581
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6582
eval test_cmds=\"$archive_expsym_cmds\"
6583
cmds=$archive_expsym_cmds
6584
else
6585
eval test_cmds=\"$archive_cmds\"
6586
cmds=$archive_cmds
6587
fi
6588
fi
6589
6590
if test "X$skipped_export" != "X:" &&
6591
func_len " $test_cmds" &&
6592
len=$func_len_result &&
6593
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6594
:
6595
else
6596
# The command line is too long to link in one step, link piecewise
6597
# or, if using GNU ld and skipped_export is not :, use a linker
6598
# script.
6599
6600
# Save the value of $output and $libobjs because we want to
6601
# use them later. If we have whole_archive_flag_spec, we
6602
# want to use save_libobjs as it was before
6603
# whole_archive_flag_spec was expanded, because we can't
6604
# assume the linker understands whole_archive_flag_spec.
6605
# This may have to be revisited, in case too many
6606
# convenience libraries get linked in and end up exceeding
6607
# the spec.
6608
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
6609
save_libobjs=$libobjs
6610
fi
6611
save_output=$output
6612
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
6613
6614
# Clear the reloadable object creation command queue and
6615
# initialize k to one.
6616
test_cmds=
6617
concat_cmds=
6618
objlist=
6619
last_robj=
6620
k=1
6621
6622
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
6623
output=${output_objdir}/${output_la}.lnkscript
6624
func_verbose "creating GNU ld script: $output"
6625
$ECHO 'INPUT (' > $output
6626
for obj in $save_libobjs
6627
do
6628
$ECHO "$obj" >> $output
6629
done
6630
$ECHO ')' >> $output
6631
delfiles="$delfiles $output"
6632
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
6633
output=${output_objdir}/${output_la}.lnk
6634
func_verbose "creating linker input file list: $output"
6635
: > $output
6636
set x $save_libobjs
6637
shift
6638
firstobj=
6639
if test "$compiler_needs_object" = yes; then
6640
firstobj="$1 "
6641
shift
6642
fi
6643
for obj
6644
do
6645
$ECHO "$obj" >> $output
6646
done
6647
delfiles="$delfiles $output"
6648
output=$firstobj\"$file_list_spec$output\"
6649
else
6650
if test -n "$save_libobjs"; then
6651
func_verbose "creating reloadable object files..."
6652
output=$output_objdir/$output_la-${k}.$objext
6653
eval test_cmds=\"$reload_cmds\"
6654
func_len " $test_cmds"
6655
len0=$func_len_result
6656
len=$len0
6657
6658
# Loop over the list of objects to be linked.
6659
for obj in $save_libobjs
6660
do
6661
func_len " $obj"
6662
func_arith $len + $func_len_result
6663
len=$func_arith_result
6664
if test "X$objlist" = X ||
6665
test "$len" -lt "$max_cmd_len"; then
6666
func_append objlist " $obj"
6667
else
6668
# The command $test_cmds is almost too long, add a
6669
# command to the queue.
6670
if test "$k" -eq 1 ; then
6671
# The first file doesn't have a previous command to add.
6672
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
6673
else
6674
# All subsequent reloadable object files will link in
6675
# the last one created.
6676
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
6677
fi
6678
last_robj=$output_objdir/$output_la-${k}.$objext
6679
func_arith $k + 1
6680
k=$func_arith_result
6681
output=$output_objdir/$output_la-${k}.$objext
6682
objlist=$obj
6683
func_len " $last_robj"
6684
func_arith $len0 + $func_len_result
6685
len=$func_arith_result
6686
fi
6687
done
6688
# Handle the remaining objects by creating one last
6689
# reloadable object file. All subsequent reloadable object
6690
# files will link in the last one created.
6691
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6692
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
6693
if test -n "$last_robj"; then
6694
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
6695
fi
6696
delfiles="$delfiles $output"
6697
6698
else
6699
output=
6700
fi
6701
6702
if ${skipped_export-false}; then
6703
func_verbose "generating symbol list for \`$libname.la'"
6704
export_symbols="$output_objdir/$libname.exp"
6705
$opt_dry_run || $RM $export_symbols
6706
libobjs=$output
6707
# Append the command to create the export file.
6708
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6709
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
6710
if test -n "$last_robj"; then
6711
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
6712
fi
6713
fi
6714
6715
test -n "$save_libobjs" &&
6716
func_verbose "creating a temporary reloadable object file: $output"
6717
6718
# Loop through the commands generated above and execute them.
6719
save_ifs="$IFS"; IFS='~'
6720
for cmd in $concat_cmds; do
6721
IFS="$save_ifs"
6722
$opt_silent || {
6723
func_quote_for_expand "$cmd"
6724
eval "func_echo $func_quote_for_expand_result"
6725
}
6726
$opt_dry_run || eval "$cmd" || {
6727
lt_exit=$?
6728
6729
# Restore the uninstalled library and exit
6730
if test "$mode" = relink; then
6731
( cd "$output_objdir" && \
6732
$RM "${realname}T" && \
6733
$MV "${realname}U" "$realname" )
6734
fi
6735
6736
exit $lt_exit
6737
}
6738
done
6739
IFS="$save_ifs"
6740
6741
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
6742
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6743
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6744
fi
6745
fi
6746
6747
if ${skipped_export-false}; then
6748
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6749
tmp_export_symbols="$export_symbols"
6750
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6751
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6752
fi
6753
6754
if test -n "$orig_export_symbols"; then
6755
# The given exports_symbols file has to be filtered, so filter it.
6756
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6757
# FIXME: $output_objdir/$libname.filter potentially contains lots of
6758
# 's' commands which not all seds can handle. GNU sed should be fine
6759
# though. Also, the filter scales superlinearly with the number of
6760
# global variables. join(1) would be nice here, but unfortunately
6761
# isn't a blessed tool.
6762
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6763
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6764
export_symbols=$output_objdir/$libname.def
6765
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6766
fi
6767
fi
6768
6769
libobjs=$output
6770
# Restore the value of output.
6771
output=$save_output
6772
6773
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
6774
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6775
test "X$libobjs" = "X " && libobjs=
6776
fi
6777
# Expand the library linking commands again to reset the
6778
# value of $libobjs for piecewise linking.
6779
6780
# Do each of the archive commands.
6781
if test "$module" = yes && test -n "$module_cmds" ; then
6782
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6783
cmds=$module_expsym_cmds
6784
else
6785
cmds=$module_cmds
6786
fi
6787
else
6788
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6789
cmds=$archive_expsym_cmds
6790
else
6791
cmds=$archive_cmds
6792
fi
6793
fi
6794
fi
6795
6796
if test -n "$delfiles"; then
6797
# Append the command to remove temporary files to $cmds.
6798
eval cmds=\"\$cmds~\$RM $delfiles\"
6799
fi
6800
6801
# Add any objects from preloaded convenience libraries
6802
if test -n "$dlprefiles"; then
6803
gentop="$output_objdir/${outputname}x"
6804
generated="$generated $gentop"
6805
6806
func_extract_archives $gentop $dlprefiles
6807
libobjs="$libobjs $func_extract_archives_result"
6808
test "X$libobjs" = "X " && libobjs=
6809
fi
6810
6811
save_ifs="$IFS"; IFS='~'
6812
for cmd in $cmds; do
6813
IFS="$save_ifs"
6814
eval cmd=\"$cmd\"
6815
$opt_silent || {
6816
func_quote_for_expand "$cmd"
6817
eval "func_echo $func_quote_for_expand_result"
6818
}
6819
$opt_dry_run || eval "$cmd" || {
6820
lt_exit=$?
6821
6822
# Restore the uninstalled library and exit
6823
if test "$mode" = relink; then
6824
( cd "$output_objdir" && \
6825
$RM "${realname}T" && \
6826
$MV "${realname}U" "$realname" )
6827
fi
6828
6829
exit $lt_exit
6830
}
6831
done
6832
IFS="$save_ifs"
6833
6834
# Restore the uninstalled library and exit
6835
if test "$mode" = relink; then
6836
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
6837
6838
if test -n "$convenience"; then
6839
if test -z "$whole_archive_flag_spec"; then
6840
func_show_eval '${RM}r "$gentop"'
6841
fi
6842
fi
6843
6844
exit $EXIT_SUCCESS
6845
fi
6846
6847
# Create links to the real library.
6848
for linkname in $linknames; do
6849
if test "$realname" != "$linkname"; then
6850
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
6851
fi
6852
done
6853
6854
# If -module or -export-dynamic was specified, set the dlname.
6855
if test "$module" = yes || test "$export_dynamic" = yes; then
6856
# On all known operating systems, these are identical.
6857
dlname="$soname"
6858
fi
6859
fi
6860
;;
6861
6862
obj)
6863
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6864
func_warning "\`-dlopen' is ignored for objects"
6865
fi
6866
6867
case " $deplibs" in
6868
*\ -l* | *\ -L*)
6869
func_warning "\`-l' and \`-L' are ignored for objects" ;;
6870
esac
6871
6872
test -n "$rpath" && \
6873
func_warning "\`-rpath' is ignored for objects"
6874
6875
test -n "$xrpath" && \
6876
func_warning "\`-R' is ignored for objects"
6877
6878
test -n "$vinfo" && \
6879
func_warning "\`-version-info' is ignored for objects"
6880
6881
test -n "$release" && \
6882
func_warning "\`-release' is ignored for objects"
6883
6884
case $output in
6885
*.lo)
6886
test -n "$objs$old_deplibs" && \
6887
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
6888
6889
libobj=$output
6890
func_lo2o "$libobj"
6891
obj=$func_lo2o_result
6892
;;
6893
*)
6894
libobj=
6895
obj="$output"
6896
;;
6897
esac
6898
6899
# Delete the old objects.
6900
$opt_dry_run || $RM $obj $libobj
6901
6902
# Objects from convenience libraries. This assumes
6903
# single-version convenience libraries. Whenever we create
6904
# different ones for PIC/non-PIC, this we'll have to duplicate
6905
# the extraction.
6906
reload_conv_objs=
6907
gentop=
6908
# reload_cmds runs $LD directly, so let us get rid of
6909
# -Wl from whole_archive_flag_spec and hope we can get by with
6910
# turning comma into space..
6911
wl=
6912
6913
if test -n "$convenience"; then
6914
if test -n "$whole_archive_flag_spec"; then
6915
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
6916
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
6917
else
6918
gentop="$output_objdir/${obj}x"
6919
generated="$generated $gentop"
6920
6921
func_extract_archives $gentop $convenience
6922
reload_conv_objs="$reload_objs $func_extract_archives_result"
6923
fi
6924
fi
6925
6926
# Create the old-style object.
6927
reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
6928
6929
output="$obj"
6930
func_execute_cmds "$reload_cmds" 'exit $?'
6931
6932
# Exit if we aren't doing a library object file.
6933
if test -z "$libobj"; then
6934
if test -n "$gentop"; then
6935
func_show_eval '${RM}r "$gentop"'
6936
fi
6937
6938
exit $EXIT_SUCCESS
6939
fi
6940
6941
if test "$build_libtool_libs" != yes; then
6942
if test -n "$gentop"; then
6943
func_show_eval '${RM}r "$gentop"'
6944
fi
6945
6946
# Create an invalid libtool object if no PIC, so that we don't
6947
# accidentally link it into a program.
6948
# $show "echo timestamp > $libobj"
6949
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
6950
exit $EXIT_SUCCESS
6951
fi
6952
6953
if test -n "$pic_flag" || test "$pic_mode" != default; then
6954
# Only do commands if we really have different PIC objects.
6955
reload_objs="$libobjs $reload_conv_objs"
6956
output="$libobj"
6957
func_execute_cmds "$reload_cmds" 'exit $?'
6958
fi
6959
6960
if test -n "$gentop"; then
6961
func_show_eval '${RM}r "$gentop"'
6962
fi
6963
6964
exit $EXIT_SUCCESS
6965
;;
6966
6967
prog)
6968
case $host in
6969
*cygwin*) func_stripname '' '.exe' "$output"
6970
output=$func_stripname_result.exe;;
6971
esac
6972
test -n "$vinfo" && \
6973
func_warning "\`-version-info' is ignored for programs"
6974
6975
test -n "$release" && \
6976
func_warning "\`-release' is ignored for programs"
6977
6978
test "$preload" = yes \
6979
&& test "$dlopen_support" = unknown \
6980
&& test "$dlopen_self" = unknown \
6981
&& test "$dlopen_self_static" = unknown && \
6982
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
6983
6984
case $host in
6985
*-*-rhapsody* | *-*-darwin1.[012])
6986
# On Rhapsody replace the C library is the System framework
6987
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6988
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6989
;;
6990
esac
6991
6992
case $host in
6993
*-*-darwin*)
6994
# Don't allow lazy linking, it breaks C++ global constructors
6995
# But is supposedly fixed on 10.4 or later (yay!).
6996
if test "$tagname" = CXX ; then
6997
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
6998
10.[0123])
6999
compile_command="$compile_command ${wl}-bind_at_load"
7000
finalize_command="$finalize_command ${wl}-bind_at_load"
7001
;;
7002
esac
7003
fi
7004
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7005
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7006
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7007
;;
7008
esac
7009
7010
7011
# move library search paths that coincide with paths to not yet
7012
# installed libraries to the beginning of the library search list
7013
new_libs=
7014
for path in $notinst_path; do
7015
case " $new_libs " in
7016
*" -L$path/$objdir "*) ;;
7017
*)
7018
case " $compile_deplibs " in
7019
*" -L$path/$objdir "*)
7020
new_libs="$new_libs -L$path/$objdir" ;;
7021
esac
7022
;;
7023
esac
7024
done
7025
for deplib in $compile_deplibs; do
7026
case $deplib in
7027
-L*)
7028
case " $new_libs " in
7029
*" $deplib "*) ;;
7030
*) new_libs="$new_libs $deplib" ;;
7031
esac
7032
;;
7033
*) new_libs="$new_libs $deplib" ;;
7034
esac
7035
done
7036
compile_deplibs="$new_libs"
7037
7038
7039
compile_command="$compile_command $compile_deplibs"
7040
finalize_command="$finalize_command $finalize_deplibs"
7041
7042
if test -n "$rpath$xrpath"; then
7043
# If the user specified any rpath flags, then add them.
7044
for libdir in $rpath $xrpath; do
7045
# This is the magic to use -rpath.
7046
case "$finalize_rpath " in
7047
*" $libdir "*) ;;
7048
*) finalize_rpath="$finalize_rpath $libdir" ;;
7049
esac
7050
done
7051
fi
7052
7053
# Now hardcode the library paths
7054
rpath=
7055
hardcode_libdirs=
7056
for libdir in $compile_rpath $finalize_rpath; do
7057
if test -n "$hardcode_libdir_flag_spec"; then
7058
if test -n "$hardcode_libdir_separator"; then
7059
if test -z "$hardcode_libdirs"; then
7060
hardcode_libdirs="$libdir"
7061
else
7062
# Just accumulate the unique libdirs.
7063
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7064
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7065
;;
7066
*)
7067
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7068
;;
7069
esac
7070
fi
7071
else
7072
eval flag=\"$hardcode_libdir_flag_spec\"
7073
rpath="$rpath $flag"
7074
fi
7075
elif test -n "$runpath_var"; then
7076
case "$perm_rpath " in
7077
*" $libdir "*) ;;
7078
*) perm_rpath="$perm_rpath $libdir" ;;
7079
esac
7080
fi
7081
case $host in
7082
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
7083
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7084
case :$dllsearchpath: in
7085
*":$libdir:"*) ;;
7086
*) dllsearchpath="$dllsearchpath:$libdir";;
7087
esac
7088
case :$dllsearchpath: in
7089
*":$testbindir:"*) ;;
7090
*) dllsearchpath="$dllsearchpath:$testbindir";;
7091
esac
7092
;;
7093
esac
7094
done
7095
# Substitute the hardcoded libdirs into the rpath.
7096
if test -n "$hardcode_libdir_separator" &&
7097
test -n "$hardcode_libdirs"; then
7098
libdir="$hardcode_libdirs"
7099
eval rpath=\" $hardcode_libdir_flag_spec\"
7100
fi
7101
compile_rpath="$rpath"
7102
7103
rpath=
7104
hardcode_libdirs=
7105
for libdir in $finalize_rpath; do
7106
if test -n "$hardcode_libdir_flag_spec"; then
7107
if test -n "$hardcode_libdir_separator"; then
7108
if test -z "$hardcode_libdirs"; then
7109
hardcode_libdirs="$libdir"
7110
else
7111
# Just accumulate the unique libdirs.
7112
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7113
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7114
;;
7115
*)
7116
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7117
;;
7118
esac
7119
fi
7120
else
7121
eval flag=\"$hardcode_libdir_flag_spec\"
7122
rpath="$rpath $flag"
7123
fi
7124
elif test -n "$runpath_var"; then
7125
case "$finalize_perm_rpath " in
7126
*" $libdir "*) ;;
7127
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7128
esac
7129
fi
7130
done
7131
# Substitute the hardcoded libdirs into the rpath.
7132
if test -n "$hardcode_libdir_separator" &&
7133
test -n "$hardcode_libdirs"; then
7134
libdir="$hardcode_libdirs"
7135
eval rpath=\" $hardcode_libdir_flag_spec\"
7136
fi
7137
finalize_rpath="$rpath"
7138
7139
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7140
# Transform all the library objects into standard objects.
7141
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7142
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7143
fi
7144
7145
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7146
7147
# template prelinking step
7148
if test -n "$prelink_cmds"; then
7149
func_execute_cmds "$prelink_cmds" 'exit $?'
7150
fi
7151
7152
wrappers_required=yes
7153
case $host in
7154
*cygwin* | *mingw* )
7155
if test "$build_libtool_libs" != yes; then
7156
wrappers_required=no
7157
fi
7158
;;
7159
*)
7160
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7161
wrappers_required=no
7162
fi
7163
;;
7164
esac
7165
if test "$wrappers_required" = no; then
7166
# Replace the output file specification.
7167
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7168
link_command="$compile_command$compile_rpath"
7169
7170
# We have no uninstalled library dependencies, so finalize right now.
7171
exit_status=0
7172
func_show_eval "$link_command" 'exit_status=$?'
7173
7174
# Delete the generated files.
7175
if test -f "$output_objdir/${outputname}S.${objext}"; then
7176
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7177
fi
7178
7179
exit $exit_status
7180
fi
7181
7182
if test -n "$compile_shlibpath$finalize_shlibpath"; then
7183
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7184
fi
7185
if test -n "$finalize_shlibpath"; then
7186
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7187
fi
7188
7189
compile_var=
7190
finalize_var=
7191
if test -n "$runpath_var"; then
7192
if test -n "$perm_rpath"; then
7193
# We should set the runpath_var.
7194
rpath=
7195
for dir in $perm_rpath; do
7196
rpath="$rpath$dir:"
7197
done
7198
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7199
fi
7200
if test -n "$finalize_perm_rpath"; then
7201
# We should set the runpath_var.
7202
rpath=
7203
for dir in $finalize_perm_rpath; do
7204
rpath="$rpath$dir:"
7205
done
7206
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7207
fi
7208
fi
7209
7210
if test "$no_install" = yes; then
7211
# We don't need to create a wrapper script.
7212
link_command="$compile_var$compile_command$compile_rpath"
7213
# Replace the output file specification.
7214
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7215
# Delete the old output file.
7216
$opt_dry_run || $RM $output
7217
# Link the executable and exit
7218
func_show_eval "$link_command" 'exit $?'
7219
exit $EXIT_SUCCESS
7220
fi
7221
7222
if test "$hardcode_action" = relink; then
7223
# Fast installation is not supported
7224
link_command="$compile_var$compile_command$compile_rpath"
7225
relink_command="$finalize_var$finalize_command$finalize_rpath"
7226
7227
func_warning "this platform does not like uninstalled shared libraries"
7228
func_warning "\`$output' will be relinked during installation"
7229
else
7230
if test "$fast_install" != no; then
7231
link_command="$finalize_var$compile_command$finalize_rpath"
7232
if test "$fast_install" = yes; then
7233
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7234
else
7235
# fast_install is set to needless
7236
relink_command=
7237
fi
7238
else
7239
link_command="$compile_var$compile_command$compile_rpath"
7240
relink_command="$finalize_var$finalize_command$finalize_rpath"
7241
fi
7242
fi
7243
7244
# Replace the output file specification.
7245
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7246
7247
# Delete the old output files.
7248
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7249
7250
func_show_eval "$link_command" 'exit $?'
7251
7252
# Now create the wrapper script.
7253
func_verbose "creating $output"
7254
7255
# Quote the relink command for shipping.
7256
if test -n "$relink_command"; then
7257
# Preserve any variables that may affect compiler behavior
7258
for var in $variables_saved_for_relink; do
7259
if eval test -z \"\${$var+set}\"; then
7260
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7261
elif eval var_value=\$$var; test -z "$var_value"; then
7262
relink_command="$var=; export $var; $relink_command"
7263
else
7264
func_quote_for_eval "$var_value"
7265
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7266
fi
7267
done
7268
relink_command="(cd `pwd`; $relink_command)"
7269
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7270
fi
7271
7272
# Quote $ECHO for shipping.
7273
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7274
case $progpath in
7275
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7276
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7277
esac
7278
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7279
else
7280
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7281
fi
7282
7283
# Only actually do things if not in dry run mode.
7284
$opt_dry_run || {
7285
# win32 will think the script is a binary if it has
7286
# a .exe suffix, so we strip it off here.
7287
case $output in
7288
*.exe) func_stripname '' '.exe' "$output"
7289
output=$func_stripname_result ;;
7290
esac
7291
# test for cygwin because mv fails w/o .exe extensions
7292
case $host in
7293
*cygwin*)
7294
exeext=.exe
7295
func_stripname '' '.exe' "$outputname"
7296
outputname=$func_stripname_result ;;
7297
*) exeext= ;;
7298
esac
7299
case $host in
7300
*cygwin* | *mingw* )
7301
func_dirname_and_basename "$output" "" "."
7302
output_name=$func_basename_result
7303
output_path=$func_dirname_result
7304
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7305
cwrapper="$output_path/$output_name.exe"
7306
$RM $cwrappersource $cwrapper
7307
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7308
7309
func_emit_cwrapperexe_src > $cwrappersource
7310
7311
# we should really use a build-platform specific compiler
7312
# here, but OTOH, the wrappers (shell script and this C one)
7313
# are only useful if you want to execute the "real" binary.
7314
# Since the "real" binary is built for $host, then this
7315
# wrapper might as well be built for $host, too.
7316
$opt_dry_run || {
7317
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7318
$STRIP $cwrapper
7319
}
7320
7321
# Now, create the wrapper script for func_source use:
7322
func_ltwrapper_scriptname $cwrapper
7323
$RM $func_ltwrapper_scriptname_result
7324
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7325
$opt_dry_run || {
7326
# note: this script will not be executed, so do not chmod.
7327
if test "x$build" = "x$host" ; then
7328
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7329
else
7330
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7331
fi
7332
}
7333
;;
7334
* )
7335
$RM $output
7336
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7337
7338
func_emit_wrapper no > $output
7339
chmod +x $output
7340
;;
7341
esac
7342
}
7343
exit $EXIT_SUCCESS
7344
;;
7345
esac
7346
7347
# See if we need to build an old-fashioned archive.
7348
for oldlib in $oldlibs; do
7349
7350
if test "$build_libtool_libs" = convenience; then
7351
oldobjs="$libobjs_save $symfileobj"
7352
addlibs="$convenience"
7353
build_libtool_libs=no
7354
else
7355
if test "$build_libtool_libs" = module; then
7356
oldobjs="$libobjs_save"
7357
build_libtool_libs=no
7358
else
7359
oldobjs="$old_deplibs $non_pic_objects"
7360
if test "$preload" = yes && test -f "$symfileobj"; then
7361
oldobjs="$oldobjs $symfileobj"
7362
fi
7363
fi
7364
addlibs="$old_convenience"
7365
fi
7366
7367
if test -n "$addlibs"; then
7368
gentop="$output_objdir/${outputname}x"
7369
generated="$generated $gentop"
7370
7371
func_extract_archives $gentop $addlibs
7372
oldobjs="$oldobjs $func_extract_archives_result"
7373
fi
7374
7375
# Do each command in the archive commands.
7376
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7377
cmds=$old_archive_from_new_cmds
7378
else
7379
7380
# Add any objects from preloaded convenience libraries
7381
if test -n "$dlprefiles"; then
7382
gentop="$output_objdir/${outputname}x"
7383
generated="$generated $gentop"
7384
7385
func_extract_archives $gentop $dlprefiles
7386
oldobjs="$oldobjs $func_extract_archives_result"
7387
fi
7388
7389
# POSIX demands no paths to be encoded in archives. We have
7390
# to avoid creating archives with duplicate basenames if we
7391
# might have to extract them afterwards, e.g., when creating a
7392
# static archive out of a convenience library, or when linking
7393
# the entirety of a libtool archive into another (currently
7394
# not supported by libtool).
7395
if (for obj in $oldobjs
7396
do
7397
func_basename "$obj"
7398
$ECHO "$func_basename_result"
7399
done | sort | sort -uc >/dev/null 2>&1); then
7400
:
7401
else
7402
$ECHO "copying selected object files to avoid basename conflicts..."
7403
gentop="$output_objdir/${outputname}x"
7404
generated="$generated $gentop"
7405
func_mkdir_p "$gentop"
7406
save_oldobjs=$oldobjs
7407
oldobjs=
7408
counter=1
7409
for obj in $save_oldobjs
7410
do
7411
func_basename "$obj"
7412
objbase="$func_basename_result"
7413
case " $oldobjs " in
7414
" ") oldobjs=$obj ;;
7415
*[\ /]"$objbase "*)
7416
while :; do
7417
# Make sure we don't pick an alternate name that also
7418
# overlaps.
7419
newobj=lt$counter-$objbase
7420
func_arith $counter + 1
7421
counter=$func_arith_result
7422
case " $oldobjs " in
7423
*[\ /]"$newobj "*) ;;
7424
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
7425
esac
7426
done
7427
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7428
oldobjs="$oldobjs $gentop/$newobj"
7429
;;
7430
*) oldobjs="$oldobjs $obj" ;;
7431
esac
7432
done
7433
fi
7434
eval cmds=\"$old_archive_cmds\"
7435
7436
func_len " $cmds"
7437
len=$func_len_result
7438
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7439
cmds=$old_archive_cmds
7440
else
7441
# the command line is too long to link in one step, link in parts
7442
func_verbose "using piecewise archive linking..."
7443
save_RANLIB=$RANLIB
7444
RANLIB=:
7445
objlist=
7446
concat_cmds=
7447
save_oldobjs=$oldobjs
7448
oldobjs=
7449
# Is there a better way of finding the last object in the list?
7450
for obj in $save_oldobjs
7451
do
7452
last_oldobj=$obj
7453
done
7454
eval test_cmds=\"$old_archive_cmds\"
7455
func_len " $test_cmds"
7456
len0=$func_len_result
7457
len=$len0
7458
for obj in $save_oldobjs
7459
do
7460
func_len " $obj"
7461
func_arith $len + $func_len_result
7462
len=$func_arith_result
7463
func_append objlist " $obj"
7464
if test "$len" -lt "$max_cmd_len"; then
7465
:
7466
else
7467
# the above command should be used before it gets too long
7468
oldobjs=$objlist
7469
if test "$obj" = "$last_oldobj" ; then
7470
RANLIB=$save_RANLIB
7471
fi
7472
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7473
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
7474
objlist=
7475
len=$len0
7476
fi
7477
done
7478
RANLIB=$save_RANLIB
7479
oldobjs=$objlist
7480
if test "X$oldobjs" = "X" ; then
7481
eval cmds=\"\$concat_cmds\"
7482
else
7483
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
7484
fi
7485
fi
7486
fi
7487
func_execute_cmds "$cmds" 'exit $?'
7488
done
7489
7490
test -n "$generated" && \
7491
func_show_eval "${RM}r$generated"
7492
7493
# Now create the libtool archive.
7494
case $output in
7495
*.la)
7496
old_library=
7497
test "$build_old_libs" = yes && old_library="$libname.$libext"
7498
func_verbose "creating $output"
7499
7500
# Preserve any variables that may affect compiler behavior
7501
for var in $variables_saved_for_relink; do
7502
if eval test -z \"\${$var+set}\"; then
7503
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7504
elif eval var_value=\$$var; test -z "$var_value"; then
7505
relink_command="$var=; export $var; $relink_command"
7506
else
7507
func_quote_for_eval "$var_value"
7508
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7509
fi
7510
done
7511
# Quote the link command for shipping.
7512
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
7513
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7514
if test "$hardcode_automatic" = yes ; then
7515
relink_command=
7516
fi
7517
7518
# Only create the output if not a dry run.
7519
$opt_dry_run || {
7520
for installed in no yes; do
7521
if test "$installed" = yes; then
7522
if test -z "$install_libdir"; then
7523
break
7524
fi
7525
output="$output_objdir/$outputname"i
7526
# Replace all uninstalled libtool libraries with the installed ones
7527
newdependency_libs=
7528
for deplib in $dependency_libs; do
7529
case $deplib in
7530
*.la)
7531
func_basename "$deplib"
7532
name="$func_basename_result"
7533
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7534
test -z "$libdir" && \
7535
func_fatal_error "\`$deplib' is not a valid libtool archive"
7536
newdependency_libs="$newdependency_libs $libdir/$name"
7537
;;
7538
*) newdependency_libs="$newdependency_libs $deplib" ;;
7539
esac
7540
done
7541
dependency_libs="$newdependency_libs"
7542
newdlfiles=
7543
7544
for lib in $dlfiles; do
7545
case $lib in
7546
*.la)
7547
func_basename "$lib"
7548
name="$func_basename_result"
7549
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7550
test -z "$libdir" && \
7551
func_fatal_error "\`$lib' is not a valid libtool archive"
7552
newdlfiles="$newdlfiles $libdir/$name"
7553
;;
7554
*) newdlfiles="$newdlfiles $lib" ;;
7555
esac
7556
done
7557
dlfiles="$newdlfiles"
7558
newdlprefiles=
7559
for lib in $dlprefiles; do
7560
case $lib in
7561
*.la)
7562
# Only pass preopened files to the pseudo-archive (for
7563
# eventual linking with the app. that links it) if we
7564
# didn't already link the preopened objects directly into
7565
# the library:
7566
func_basename "$lib"
7567
name="$func_basename_result"
7568
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7569
test -z "$libdir" && \
7570
func_fatal_error "\`$lib' is not a valid libtool archive"
7571
newdlprefiles="$newdlprefiles $libdir/$name"
7572
;;
7573
esac
7574
done
7575
dlprefiles="$newdlprefiles"
7576
else
7577
newdlfiles=
7578
for lib in $dlfiles; do
7579
case $lib in
7580
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7581
*) abs=`pwd`"/$lib" ;;
7582
esac
7583
newdlfiles="$newdlfiles $abs"
7584
done
7585
dlfiles="$newdlfiles"
7586
newdlprefiles=
7587
for lib in $dlprefiles; do
7588
case $lib in
7589
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7590
*) abs=`pwd`"/$lib" ;;
7591
esac
7592
newdlprefiles="$newdlprefiles $abs"
7593
done
7594
dlprefiles="$newdlprefiles"
7595
fi
7596
$RM $output
7597
# place dlname in correct position for cygwin
7598
tdlname=$dlname
7599
case $host,$output,$installed,$module,$dlname in
7600
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
7601
esac
7602
$ECHO > $output "\
7603
# $outputname - a libtool library file
7604
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
7605
#
7606
# Please DO NOT delete this file!
7607
# It is necessary for linking the library.
7608
7609
# The name that we can dlopen(3).
7610
dlname='$tdlname'
7611
7612
# Names of this library.
7613
library_names='$library_names'
7614
7615
# The name of the static archive.
7616
old_library='$old_library'
7617
7618
# Linker flags that can not go in dependency_libs.
7619
inherited_linker_flags='$new_inherited_linker_flags'
7620
7621
# Libraries that this one depends upon.
7622
dependency_libs='$dependency_libs'
7623
7624
# Names of additional weak libraries provided by this library
7625
weak_library_names='$weak_libs'
7626
7627
# Version information for $libname.
7628
current=$current
7629
age=$age
7630
revision=$revision
7631
7632
# Is this an already installed library?
7633
installed=$installed
7634
7635
# Should we warn about portability when linking against -modules?
7636
shouldnotlink=$module
7637
7638
# Files to dlopen/dlpreopen
7639
dlopen='$dlfiles'
7640
dlpreopen='$dlprefiles'
7641
7642
# Directory that this library needs to be installed in:
7643
libdir='$install_libdir'"
7644
if test "$installed" = no && test "$need_relink" = yes; then
7645
$ECHO >> $output "\
7646
relink_command=\"$relink_command\""
7647
fi
7648
done
7649
}
7650
7651
# Do a symbolic link so that the libtool archive can be found in
7652
# LD_LIBRARY_PATH before the program is installed.
7653
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
7654
;;
7655
esac
7656
exit $EXIT_SUCCESS
7657
}
7658
7659
{ test "$mode" = link || test "$mode" = relink; } &&
7660
func_mode_link ${1+"$@"}
7661
7662
7663
# func_mode_uninstall arg...
7664
func_mode_uninstall ()
7665
{
7666
$opt_debug
7667
RM="$nonopt"
7668
files=
7669
rmforce=
7670
exit_status=0
7671
7672
# This variable tells wrapper scripts just to set variables rather
7673
# than running their programs.
7674
libtool_install_magic="$magic"
7675
7676
for arg
7677
do
7678
case $arg in
7679
-f) RM="$RM $arg"; rmforce=yes ;;
7680
-*) RM="$RM $arg" ;;
7681
*) files="$files $arg" ;;
7682
esac
7683
done
7684
7685
test -z "$RM" && \
7686
func_fatal_help "you must specify an RM program"
7687
7688
rmdirs=
7689
7690
origobjdir="$objdir"
7691
for file in $files; do
7692
func_dirname "$file" "" "."
7693
dir="$func_dirname_result"
7694
if test "X$dir" = X.; then
7695
objdir="$origobjdir"
7696
else
7697
objdir="$dir/$origobjdir"
7698
fi
7699
func_basename "$file"
7700
name="$func_basename_result"
7701
test "$mode" = uninstall && objdir="$dir"
7702
7703
# Remember objdir for removal later, being careful to avoid duplicates
7704
if test "$mode" = clean; then
7705
case " $rmdirs " in
7706
*" $objdir "*) ;;
7707
*) rmdirs="$rmdirs $objdir" ;;
7708
esac
7709
fi
7710
7711
# Don't error if the file doesn't exist and rm -f was used.
7712
if { test -L "$file"; } >/dev/null 2>&1 ||
7713
{ test -h "$file"; } >/dev/null 2>&1 ||
7714
test -f "$file"; then
7715
:
7716
elif test -d "$file"; then
7717
exit_status=1
7718
continue
7719
elif test "$rmforce" = yes; then
7720
continue
7721
fi
7722
7723
rmfiles="$file"
7724
7725
case $name in
7726
*.la)
7727
# Possibly a libtool archive, so verify it.
7728
if func_lalib_p "$file"; then
7729
func_source $dir/$name
7730
7731
# Delete the libtool libraries and symlinks.
7732
for n in $library_names; do
7733
rmfiles="$rmfiles $objdir/$n"
7734
done
7735
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
7736
7737
case "$mode" in
7738
clean)
7739
case " $library_names " in
7740
# " " in the beginning catches empty $dlname
7741
*" $dlname "*) ;;
7742
*) rmfiles="$rmfiles $objdir/$dlname" ;;
7743
esac
7744
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
7745
;;
7746
uninstall)
7747
if test -n "$library_names"; then
7748
# Do each command in the postuninstall commands.
7749
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7750
fi
7751
7752
if test -n "$old_library"; then
7753
# Do each command in the old_postuninstall commands.
7754
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7755
fi
7756
# FIXME: should reinstall the best remaining shared library.
7757
;;
7758
esac
7759
fi
7760
;;
7761
7762
*.lo)
7763
# Possibly a libtool object, so verify it.
7764
if func_lalib_p "$file"; then
7765
7766
# Read the .lo file
7767
func_source $dir/$name
7768
7769
# Add PIC object to the list of files to remove.
7770
if test -n "$pic_object" &&
7771
test "$pic_object" != none; then
7772
rmfiles="$rmfiles $dir/$pic_object"
7773
fi
7774
7775
# Add non-PIC object to the list of files to remove.
7776
if test -n "$non_pic_object" &&
7777
test "$non_pic_object" != none; then
7778
rmfiles="$rmfiles $dir/$non_pic_object"
7779
fi
7780
fi
7781
;;
7782
7783
*)
7784
if test "$mode" = clean ; then
7785
noexename=$name
7786
case $file in
7787
*.exe)
7788
func_stripname '' '.exe' "$file"
7789
file=$func_stripname_result
7790
func_stripname '' '.exe' "$name"
7791
noexename=$func_stripname_result
7792
# $file with .exe has already been added to rmfiles,
7793
# add $file without .exe
7794
rmfiles="$rmfiles $file"
7795
;;
7796
esac
7797
# Do a test to see if this is a libtool program.
7798
if func_ltwrapper_p "$file"; then
7799
if func_ltwrapper_executable_p "$file"; then
7800
func_ltwrapper_scriptname "$file"
7801
relink_command=
7802
func_source $func_ltwrapper_scriptname_result
7803
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
7804
else
7805
relink_command=
7806
func_source $dir/$noexename
7807
fi
7808
7809
# note $name still contains .exe if it was in $file originally
7810
# as does the version of $file that was added into $rmfiles
7811
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
7812
if test "$fast_install" = yes && test -n "$relink_command"; then
7813
rmfiles="$rmfiles $objdir/lt-$name"
7814
fi
7815
if test "X$noexename" != "X$name" ; then
7816
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
7817
fi
7818
fi
7819
fi
7820
;;
7821
esac
7822
func_show_eval "$RM $rmfiles" 'exit_status=1'
7823
done
7824
objdir="$origobjdir"
7825
7826
# Try to remove the ${objdir}s in the directories where we deleted files
7827
for dir in $rmdirs; do
7828
if test -d "$dir"; then
7829
func_show_eval "rmdir $dir >/dev/null 2>&1"
7830
fi
7831
done
7832
7833
exit $exit_status
7834
}
7835
7836
{ test "$mode" = uninstall || test "$mode" = clean; } &&
7837
func_mode_uninstall ${1+"$@"}
7838
7839
test -z "$mode" && {
7840
help="$generic_help"
7841
func_fatal_help "you must specify a MODE"
7842
}
7843
7844
test -z "$exec_cmd" && \
7845
func_fatal_help "invalid operation mode \`$mode'"
7846
7847
if test -n "$exec_cmd"; then
7848
eval exec "$exec_cmd"
7849
exit $EXIT_FAILURE
7850
fi
7851
7852
exit $exit_status
7853
7854
7855
# The TAGs below are defined such that we never get into a situation
7856
# in which we disable both kinds of libraries. Given conflicting
7857
# choices, we go for a static library, that is the most portable,
7858
# since we can't tell whether shared libraries were disabled because
7859
# the user asked for that or because the platform doesn't support
7860
# them. This is particularly important on AIX, because we don't
7861
# support having both static and shared libraries enabled at the same
7862
# time on that platform, so we default to a shared-only configuration.
7863
# If a disable-shared tag is given, we'll fallback to a static-only
7864
# configuration. But we'll never go from static-only to shared-only.
7865
7866
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
7867
build_libtool_libs=no
7868
build_old_libs=yes
7869
# ### END LIBTOOL TAG CONFIG: disable-shared
7870
7871
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
7872
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
7873
# ### END LIBTOOL TAG CONFIG: disable-static
7874
7875
# Local Variables:
7876
# mode:shell-script
7877
# sh-indentation:2
7878
# End:
7879
# vi:sw=2
7880
Loggerhead is a web-based interface for Breezy
Version: 2.0.1