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