daily update
[binutils/dougsmingw.git] / ltmain.sh
blobcba8b4c7a565df5b89934ad2820d28f9bc553138
1 # Generated from ltmain.m4sh.
3 # libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
4 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
6 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
7 # 2007, 2008, 2009 Free Software Foundation, Inc.
8 # This is free software; see the source for copying conditions. There is NO
9 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 # GNU Libtool is free software; you can redistribute it and/or modify
12 # it under the terms of the GNU General Public License as published by
13 # the Free Software Foundation; either version 2 of the License, or
14 # (at your option) any later version.
16 # As a special exception to the GNU General Public License,
17 # if you distribute this file as part of a program or library that
18 # is built using GNU Libtool, you may include this file under the
19 # same distribution terms that you use for the rest of that program.
21 # GNU Libtool is distributed in the hope that it will be useful, but
22 # WITHOUT ANY WARRANTY; without even the implied warranty of
23 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 # General Public License for more details.
26 # You should have received a copy of the GNU General Public License
27 # along with GNU Libtool; see the file COPYING. If not, a copy
28 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
29 # or obtained by writing to the Free Software Foundation, Inc.,
30 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
32 # Usage: $progname [OPTION]... [MODE-ARG]...
34 # Provide generalized library-building support services.
36 # --config show all configuration variables
37 # --debug enable verbose shell tracing
38 # -n, --dry-run display commands without modifying any files
39 # --features display basic configuration information and exit
40 # --mode=MODE use operation mode MODE
41 # --no-finish let install mode avoid finish commands
42 # --preserve-dup-deps don't remove duplicate dependency libraries
43 # --quiet, --silent don't print informational messages
44 # --no-quiet, --no-silent
45 # print informational messages (default)
46 # --tag=TAG use configuration variables from tag TAG
47 # -v, --verbose print more informational messages than default
48 # --no-verbose don't print the extra informational messages
49 # --version print version information
50 # -h, --help, --help-all print short, long, or detailed help message
52 # MODE must be one of the following:
54 # clean remove files from the build directory
55 # compile compile a source file into a libtool object
56 # execute automatically set library path, then run a program
57 # finish complete the installation of libtool libraries
58 # install install libraries or executables
59 # link create a library or an executable
60 # uninstall remove libraries from an installed directory
62 # MODE-ARGS vary depending on the MODE. When passed as first option,
63 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
64 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
66 # When reporting a bug, please describe a test case to reproduce it and
67 # include the following information:
69 # host-triplet: $host
70 # shell: $SHELL
71 # compiler: $LTCC
72 # compiler flags: $LTCFLAGS
73 # linker: $LD (gnu? $with_gnu_ld)
74 # $progname: (GNU libtool 1.3134 2009-11-29) 2.2.7a
75 # automake: $automake_version
76 # autoconf: $autoconf_version
78 # Report bugs to <bug-libtool@gnu.org>.
80 PROGRAM=libtool
81 PACKAGE=libtool
82 VERSION=2.2.7a
83 TIMESTAMP=" 1.3134 2009-11-29"
84 package_revision=1.3134
86 # Be Bourne compatible
87 if 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
94 else
95 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97 BIN_SH=xpg4; export BIN_SH # for Tru64
98 DUALCASE=1; export DUALCASE # for MKS sh
100 # A function that is used when there is no print builtin or printf.
101 func_fallback_echo ()
103 eval 'cat <<_LTECHO_EOF
105 _LTECHO_EOF'
108 # NLS nuisances: We save the old values to restore during execute mode.
109 # Only set LANG and LC_ALL to C if already set.
110 # These must not be set unconditionally because not all systems understand
111 # e.g. LANG=C (notably SCO).
112 lt_user_locale=
113 lt_safe_locale=
114 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
116 eval "if test \"\${$lt_var+set}\" = set; then
117 save_$lt_var=\$$lt_var
118 $lt_var=C
119 export $lt_var
120 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
121 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
123 done
125 $lt_unset CDPATH
133 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
134 # is ksh but when the shell is invoked as "sh" and the current value of
135 # the _XPG environment variable is not equal to 1 (one), the special
136 # positional parameter $0, within a function call, is the name of the
137 # function.
138 progpath="$0"
142 : ${CP="cp -f"}
143 : ${ECHO=$as_echo}
144 : ${EGREP="/bin/grep -E"}
145 : ${FGREP="/bin/grep -F"}
146 : ${GREP="/bin/grep"}
147 : ${LN_S="ln -s"}
148 : ${MAKE="make"}
149 : ${MKDIR="mkdir"}
150 : ${MV="mv -f"}
151 : ${RM="rm -f"}
152 : ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"}
153 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
154 : ${Xsed="$SED -e 1s/^X//"}
156 # Global variables:
157 EXIT_SUCCESS=0
158 EXIT_FAILURE=1
159 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
160 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
162 exit_status=$EXIT_SUCCESS
164 # Make sure IFS has a sensible default
165 lt_nl='
167 IFS=" $lt_nl"
169 dirname="s,/[^/]*$,,"
170 basename="s,^.*/,,"
172 # func_dirname_and_basename file append nondir_replacement
173 # perform func_basename and func_dirname in a single function
174 # call:
175 # dirname: Compute the dirname of FILE. If nonempty,
176 # add APPEND to the result, otherwise set result
177 # to NONDIR_REPLACEMENT.
178 # value returned in "$func_dirname_result"
179 # basename: Compute filename of FILE.
180 # value retuned in "$func_basename_result"
181 # Implementation must be kept synchronized with func_dirname
182 # and func_basename. For efficiency, we do not delegate to
183 # those functions but instead duplicate the functionality here.
184 func_dirname_and_basename ()
186 # Extract subdirectory from the argument.
187 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
188 if test "X$func_dirname_result" = "X${1}"; then
189 func_dirname_result="${3}"
190 else
191 func_dirname_result="$func_dirname_result${2}"
193 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
196 # Generated shell functions inserted here.
198 # These SED scripts presuppose an absolute path with a trailing slash.
199 pathcar='s,^/\([^/]*\).*$,\1,'
200 pathcdr='s,^/[^/]*,,'
201 removedotparts=':dotsl
202 s@/\./@/@g
203 t dotsl
204 s,/\.$,/,'
205 collapseslashes='s@/\{1,\}@/@g'
206 finalslash='s,/*$,/,'
208 # func_normal_abspath PATH
209 # Remove doubled-up and trailing slashes, "." path components,
210 # and cancel out any ".." path components in PATH after making
211 # it an absolute path.
212 # value returned in "$func_normal_abspath_result"
213 func_normal_abspath ()
215 # Start from root dir and reassemble the path.
216 func_normal_abspath_result=
217 func_normal_abspath_tpath=$1
218 func_normal_abspath_altnamespace=
219 case $func_normal_abspath_tpath in
221 # Empty path, that just means $cwd.
222 func_stripname '' '/' "`pwd`"
223 func_normal_abspath_result=$func_stripname_result
224 return
226 # The next three entries are used to spot a run of precisely
227 # two leading slashes without using negated character classes;
228 # we take advantage of case's first-match behaviour.
229 ///*)
230 # Unusual form of absolute path, do nothing.
232 //*)
233 # Not necessarily an ordinary path; POSIX reserves leading '//'
234 # and for example Cygwin uses it to access remote file shares
235 # over CIFS/SMB, so we conserve a leading double slash if found.
236 func_normal_abspath_altnamespace=/
239 # Absolute path, do nothing.
242 # Relative path, prepend $cwd.
243 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
245 esac
246 # Cancel out all the simple stuff to save iterations. We also want
247 # the path to end with a slash for ease of parsing, so make sure
248 # there is one (and only one) here.
249 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
250 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
251 while :; do
252 # Processed it all yet?
253 if test "$func_normal_abspath_tpath" = / ; then
254 # If we ascended to the root using ".." the result may be empty now.
255 if test -z "$func_normal_abspath_result" ; then
256 func_normal_abspath_result=/
258 break
260 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
261 -e "$pathcar"`
262 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
263 -e "$pathcdr"`
264 # Figure out what to do with it
265 case $func_normal_abspath_tcomponent in
267 # Trailing empty path component, ignore it.
270 # Parent dir; strip last assembled component from result.
271 func_dirname "$func_normal_abspath_result"
272 func_normal_abspath_result=$func_dirname_result
275 # Actual path component, append it.
276 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
278 esac
279 done
280 # Restore leading double-slash if one was found on entry.
281 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
284 # func_relative_path SRCDIR DSTDIR
285 # generates a relative path from SRCDIR to DSTDIR, with a trailing
286 # slash if non-empty, suitable for immediately appending a filename
287 # without needing to append a separator.
288 # value returned in "$func_relative_path_result"
289 func_relative_path ()
291 func_relative_path_result=
292 func_normal_abspath "$1"
293 func_relative_path_tlibdir=$func_normal_abspath_result
294 func_normal_abspath "$2"
295 func_relative_path_tbindir=$func_normal_abspath_result
297 # Ascend the tree starting from libdir
298 while :; do
299 # check if we have found a prefix of bindir
300 case $func_relative_path_tbindir in
301 $func_relative_path_tlibdir)
302 # found an exact match
303 func_relative_path_tcancelled=
304 break
306 $func_relative_path_tlibdir*)
307 # found a matching prefix
308 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
309 func_relative_path_tcancelled=$func_stripname_result
310 if test -z "$func_relative_path_result"; then
311 func_relative_path_result=.
313 break
316 func_dirname $func_relative_path_tlibdir
317 func_relative_path_tlibdir=${func_dirname_result}
318 if test "x$func_relative_path_tlibdir" = x ; then
319 # Have to descend all the way to the root!
320 func_relative_path_result=../$func_relative_path_result
321 func_relative_path_tcancelled=$func_relative_path_tbindir
322 break
324 func_relative_path_result=../$func_relative_path_result
326 esac
327 done
329 # Now calculate path; take care to avoid doubling-up slashes.
330 func_stripname '' '/' "$func_relative_path_result"
331 func_relative_path_result=$func_stripname_result
332 func_stripname '/' '/' "$func_relative_path_tcancelled"
333 if test "x$func_stripname_result" != x ; then
334 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
337 # Normalisation. If bindir is libdir, return empty string,
338 # else relative path ending with a slash; either way, target
339 # file name can be directly appended.
340 if test ! -z "$func_relative_path_result"; then
341 func_stripname './' '' "$func_relative_path_result/"
342 func_relative_path_result=$func_stripname_result
346 # The name of this program:
347 func_dirname_and_basename "$progpath"
348 progname=$func_basename_result
350 # Make sure we have an absolute path for reexecution:
351 case $progpath in
352 [\\/]*|[A-Za-z]:\\*) ;;
353 *[\\/]*)
354 progdir=$func_dirname_result
355 progdir=`cd "$progdir" && pwd`
356 progpath="$progdir/$progname"
359 save_IFS="$IFS"
360 IFS=:
361 for progdir in $PATH; do
362 IFS="$save_IFS"
363 test -x "$progdir/$progname" && break
364 done
365 IFS="$save_IFS"
366 test -n "$progdir" || progdir=`pwd`
367 progpath="$progdir/$progname"
369 esac
371 # Sed substitution that helps us do robust quoting. It backslashifies
372 # metacharacters that are still active within double-quoted strings.
373 Xsed="${SED}"' -e 1s/^X//'
374 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
376 # Same as above, but do not quote variable references.
377 double_quote_subst='s/\(["`\\]\)/\\\1/g'
379 # Re-`\' parameter expansions in output of double_quote_subst that were
380 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
381 # in input to double_quote_subst, that '$' was protected from expansion.
382 # Since each input `\' is now two `\'s, look for any number of runs of
383 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
384 bs='\\'
385 bs2='\\\\'
386 bs4='\\\\\\\\'
387 dollar='\$'
388 sed_double_backslash="\
389 s/$bs4/&\\
391 s/^$bs2$dollar/$bs&/
392 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
393 s/\n//g"
395 # Standard options:
396 opt_dry_run=false
397 opt_help=false
398 opt_quiet=false
399 opt_verbose=false
400 opt_warning=:
402 # func_echo arg...
403 # Echo program name prefixed message, along with the current mode
404 # name if it has been set yet.
405 func_echo ()
407 $ECHO "$progname${mode+: }$mode: $*"
410 # func_verbose arg...
411 # Echo program name prefixed message in verbose mode only.
412 func_verbose ()
414 $opt_verbose && func_echo ${1+"$@"}
416 # A bug in bash halts the script if the last line of a function
417 # fails when set -e is in force, so we need another command to
418 # work around that:
422 # func_echo_all arg...
423 # Invoke $ECHO with all args, space-separated.
424 func_echo_all ()
426 $ECHO "$*"
429 # func_error arg...
430 # Echo program name prefixed message to standard error.
431 func_error ()
433 $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
436 # func_warning arg...
437 # Echo program name prefixed warning message to standard error.
438 func_warning ()
440 $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
442 # bash bug again:
446 # func_fatal_error arg...
447 # Echo program name prefixed message to standard error, and exit.
448 func_fatal_error ()
450 func_error ${1+"$@"}
451 exit $EXIT_FAILURE
454 # func_fatal_help arg...
455 # Echo program name prefixed message to standard error, followed by
456 # a help hint, and exit.
457 func_fatal_help ()
459 func_error ${1+"$@"}
460 func_fatal_error "$help"
462 help="Try \`$progname --help' for more information." ## default
465 # func_grep expression filename
466 # Check whether EXPRESSION matches any line of FILENAME, without output.
467 func_grep ()
469 $GREP "$1" "$2" >/dev/null 2>&1
473 # func_mkdir_p directory-path
474 # Make sure the entire path to DIRECTORY-PATH is available.
475 func_mkdir_p ()
477 my_directory_path="$1"
478 my_dir_list=
480 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
482 # Protect directory names starting with `-'
483 case $my_directory_path in
484 -*) my_directory_path="./$my_directory_path" ;;
485 esac
487 # While some portion of DIR does not yet exist...
488 while test ! -d "$my_directory_path"; do
489 # ...make a list in topmost first order. Use a colon delimited
490 # list incase some portion of path contains whitespace.
491 my_dir_list="$my_directory_path:$my_dir_list"
493 # If the last portion added has no slash in it, the list is done
494 case $my_directory_path in */*) ;; *) break ;; esac
496 # ...otherwise throw away the child directory and loop
497 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
498 done
499 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
501 save_mkdir_p_IFS="$IFS"; IFS=':'
502 for my_dir in $my_dir_list; do
503 IFS="$save_mkdir_p_IFS"
504 # mkdir can fail with a `File exist' error if two processes
505 # try to create one of the directories concurrently. Don't
506 # stop in that case!
507 $MKDIR "$my_dir" 2>/dev/null || :
508 done
509 IFS="$save_mkdir_p_IFS"
511 # Bail out if we (or some other process) failed to create a directory.
512 test -d "$my_directory_path" || \
513 func_fatal_error "Failed to create \`$1'"
518 # func_mktempdir [string]
519 # Make a temporary directory that won't clash with other running
520 # libtool processes, and avoids race conditions if possible. If
521 # given, STRING is the basename for that directory.
522 func_mktempdir ()
524 my_template="${TMPDIR-/tmp}/${1-$progname}"
526 if test "$opt_dry_run" = ":"; then
527 # Return a directory name, but don't create it in dry-run mode
528 my_tmpdir="${my_template}-$$"
529 else
531 # If mktemp works, use that first and foremost
532 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
534 if test ! -d "$my_tmpdir"; then
535 # Failing that, at least try and use $RANDOM to avoid a race
536 my_tmpdir="${my_template}-${RANDOM-0}$$"
538 save_mktempdir_umask=`umask`
539 umask 0077
540 $MKDIR "$my_tmpdir"
541 umask $save_mktempdir_umask
544 # If we're not in dry-run mode, bomb out on failure
545 test -d "$my_tmpdir" || \
546 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
549 $ECHO "$my_tmpdir"
553 # func_quote_for_eval arg
554 # Aesthetically quote ARG to be evaled later.
555 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
556 # is double-quoted, suitable for a subsequent eval, whereas
557 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
558 # which are still active within double quotes backslashified.
559 func_quote_for_eval ()
561 case $1 in
562 *[\\\`\"\$]*)
563 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
565 func_quote_for_eval_unquoted_result="$1" ;;
566 esac
568 case $func_quote_for_eval_unquoted_result in
569 # Double-quote args containing shell metacharacters to delay
570 # word splitting, command substitution and and variable
571 # expansion for a subsequent eval.
572 # Many Bourne shells cannot handle close brackets correctly
573 # in scan sets, so we specify it separately.
574 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
575 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
578 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
579 esac
583 # func_quote_for_expand arg
584 # Aesthetically quote ARG to be evaled later; same as above,
585 # but do not quote variable references.
586 func_quote_for_expand ()
588 case $1 in
589 *[\\\`\"]*)
590 my_arg=`$ECHO "$1" | $SED \
591 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
593 my_arg="$1" ;;
594 esac
596 case $my_arg in
597 # Double-quote args containing shell metacharacters to delay
598 # word splitting and command substitution for a subsequent eval.
599 # Many Bourne shells cannot handle close brackets correctly
600 # in scan sets, so we specify it separately.
601 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
602 my_arg="\"$my_arg\""
604 esac
606 func_quote_for_expand_result="$my_arg"
610 # func_show_eval cmd [fail_exp]
611 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
612 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
613 # is given, then evaluate it.
614 func_show_eval ()
616 my_cmd="$1"
617 my_fail_exp="${2-:}"
619 ${opt_silent-false} || {
620 func_quote_for_expand "$my_cmd"
621 eval "func_echo $func_quote_for_expand_result"
624 if ${opt_dry_run-false}; then :; else
625 eval "$my_cmd"
626 my_status=$?
627 if test "$my_status" -eq 0; then :; else
628 eval "(exit $my_status); $my_fail_exp"
634 # func_show_eval_locale cmd [fail_exp]
635 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
636 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
637 # is given, then evaluate it. Use the saved locale for evaluation.
638 func_show_eval_locale ()
640 my_cmd="$1"
641 my_fail_exp="${2-:}"
643 ${opt_silent-false} || {
644 func_quote_for_expand "$my_cmd"
645 eval "func_echo $func_quote_for_expand_result"
648 if ${opt_dry_run-false}; then :; else
649 eval "$lt_user_locale
650 $my_cmd"
651 my_status=$?
652 eval "$lt_safe_locale"
653 if test "$my_status" -eq 0; then :; else
654 eval "(exit $my_status); $my_fail_exp"
663 # func_version
664 # Echo version message to standard output and exit.
665 func_version ()
667 $SED -n '/(C)/!b go
668 :more
669 /\./!{
671 s/\n# //
672 b more
675 /^# '$PROGRAM' (GNU /,/# warranty; / {
676 s/^# //
677 s/^# *$//
678 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
680 }' < "$progpath"
681 exit $?
684 # func_usage
685 # Echo short help message to standard output and exit.
686 func_usage ()
688 $SED -n '/^# Usage:/,/^# *-h/ {
689 s/^# //
690 s/^# *$//
691 s/\$progname/'$progname'/
693 }' < "$progpath"
694 echo
695 $ECHO "run \`$progname --help | more' for full usage"
696 exit $?
699 # func_help [NOEXIT]
700 # Echo long help message to standard output and exit,
701 # unless 'noexit' is passed as argument.
702 func_help ()
704 $SED -n '/^# Usage:/,/# Report bugs to/ {
705 s/^# //
706 s/^# *$//
707 s*\$progname*'$progname'*
708 s*\$host*'"$host"'*
709 s*\$SHELL*'"$SHELL"'*
710 s*\$LTCC*'"$LTCC"'*
711 s*\$LTCFLAGS*'"$LTCFLAGS"'*
712 s*\$LD*'"$LD"'*
713 s/\$with_gnu_ld/'"$with_gnu_ld"'/
714 s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
715 s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
717 }' < "$progpath"
718 ret=$?
719 if test -z "$1"; then
720 exit $ret
724 # func_missing_arg argname
725 # Echo program name prefixed message to standard error and set global
726 # exit_cmd.
727 func_missing_arg ()
729 func_error "missing argument for $1"
730 exit_cmd=exit
733 exit_cmd=:
740 magic="%%%MAGIC variable%%%"
741 magic_exe="%%%MAGIC EXE variable%%%"
743 # Global variables.
744 # $mode is unset
745 nonopt=
746 execute_dlfiles=
747 preserve_args=
748 lo2o="s/\\.lo\$/.${objext}/"
749 o2lo="s/\\.${objext}\$/.lo/"
750 extracted_archives=
751 extracted_serial=0
753 opt_dry_run=false
754 opt_finish=:
755 opt_duplicate_deps=false
756 opt_silent=false
757 opt_debug=:
759 # If this variable is set in any of the actions, the command in it
760 # will be execed at the end. This prevents here-documents from being
761 # left over by shells.
762 exec_cmd=
764 # func_fatal_configuration arg...
765 # Echo program name prefixed message to standard error, followed by
766 # a configuration failure hint, and exit.
767 func_fatal_configuration ()
769 func_error ${1+"$@"}
770 func_error "See the $PACKAGE documentation for more information."
771 func_fatal_error "Fatal configuration error."
775 # func_config
776 # Display the configuration for all the tags in this script.
777 func_config ()
779 re_begincf='^# ### BEGIN LIBTOOL'
780 re_endcf='^# ### END LIBTOOL'
782 # Default configuration.
783 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
785 # Now print the configurations for the tags.
786 for tagname in $taglist; do
787 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
788 done
790 exit $?
793 # func_features
794 # Display the features supported by this script.
795 func_features ()
797 echo "host: $host"
798 if test "$build_libtool_libs" = yes; then
799 echo "enable shared libraries"
800 else
801 echo "disable shared libraries"
803 if test "$build_old_libs" = yes; then
804 echo "enable static libraries"
805 else
806 echo "disable static libraries"
809 exit $?
812 # func_enable_tag tagname
813 # Verify that TAGNAME is valid, and either flag an error and exit, or
814 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
815 # variable here.
816 func_enable_tag ()
818 # Global variable:
819 tagname="$1"
821 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
822 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
823 sed_extractcf="/$re_begincf/,/$re_endcf/p"
825 # Validate tagname.
826 case $tagname in
827 *[!-_A-Za-z0-9,/]*)
828 func_fatal_error "invalid tag name: $tagname"
830 esac
832 # Don't test for the "default" C tag, as we know it's
833 # there but not specially marked.
834 case $tagname in
835 CC) ;;
837 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
838 taglist="$taglist $tagname"
840 # Evaluate the configuration. Be careful to quote the path
841 # and the sed script, to avoid splitting on whitespace, but
842 # also don't use non-portable quotes within backquotes within
843 # quotes we have to do it in 2 steps:
844 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
845 eval "$extractedcf"
846 else
847 func_error "ignoring unknown tag $tagname"
850 esac
853 # Parse options once, thoroughly. This comes as soon as possible in
854 # the script to make things like `libtool --version' happen quickly.
857 # Shorthand for --mode=foo, only valid as the first argument
858 case $1 in
859 clean|clea|cle|cl)
860 shift; set dummy --mode clean ${1+"$@"}; shift
862 compile|compil|compi|comp|com|co|c)
863 shift; set dummy --mode compile ${1+"$@"}; shift
865 execute|execut|execu|exec|exe|ex|e)
866 shift; set dummy --mode execute ${1+"$@"}; shift
868 finish|finis|fini|fin|fi|f)
869 shift; set dummy --mode finish ${1+"$@"}; shift
871 install|instal|insta|inst|ins|in|i)
872 shift; set dummy --mode install ${1+"$@"}; shift
874 link|lin|li|l)
875 shift; set dummy --mode link ${1+"$@"}; shift
877 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
878 shift; set dummy --mode uninstall ${1+"$@"}; shift
880 esac
882 # Parse non-mode specific arguments:
883 while test "$#" -gt 0; do
884 opt="$1"
885 shift
887 case $opt in
888 --config) func_config ;;
890 --debug) preserve_args="$preserve_args $opt"
891 func_echo "enabling shell trace mode"
892 opt_debug='set -x'
893 $opt_debug
896 -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
897 execute_dlfiles="$execute_dlfiles $1"
898 shift
901 --dry-run | -n) opt_dry_run=: ;;
902 --features) func_features ;;
903 --finish) mode="finish" ;;
904 --no-finish) opt_finish=false ;;
906 --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
907 case $1 in
908 # Valid mode arguments:
909 clean) ;;
910 compile) ;;
911 execute) ;;
912 finish) ;;
913 install) ;;
914 link) ;;
915 relink) ;;
916 uninstall) ;;
918 # Catch anything else as an error
919 *) func_error "invalid argument for $opt"
920 exit_cmd=exit
921 break
923 esac
925 mode="$1"
926 shift
929 --preserve-dup-deps)
930 opt_duplicate_deps=: ;;
932 --quiet|--silent) preserve_args="$preserve_args $opt"
933 opt_silent=:
934 opt_verbose=false
937 --no-quiet|--no-silent)
938 preserve_args="$preserve_args $opt"
939 opt_silent=false
942 --verbose| -v) preserve_args="$preserve_args $opt"
943 opt_silent=false
944 opt_verbose=:
947 --no-verbose) preserve_args="$preserve_args $opt"
948 opt_verbose=false
951 --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
952 preserve_args="$preserve_args $opt $1"
953 func_enable_tag "$1" # tagname is set here
954 shift
957 # Separate optargs to long options:
958 -dlopen=*|--mode=*|--tag=*)
959 func_opt_split "$opt"
960 set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
961 shift
964 -\?|-h) func_usage ;;
965 --help) opt_help=: ;;
966 --help-all) opt_help=': help-all' ;;
967 --version) func_version ;;
969 -*) func_fatal_help "unrecognized option \`$opt'" ;;
971 *) nonopt="$opt"
972 break
974 esac
975 done
978 case $host in
979 *cygwin* | *mingw* | *pw32* | *cegcc*)
980 # don't eliminate duplications in $postdeps and $predeps
981 opt_duplicate_compiler_generated_deps=:
984 opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
986 esac
988 # Having warned about all mis-specified options, bail out if
989 # anything was wrong.
990 $exit_cmd $EXIT_FAILURE
993 # func_check_version_match
994 # Ensure that we are using m4 macros, and libtool script from the same
995 # release of libtool.
996 func_check_version_match ()
998 if test "$package_revision" != "$macro_revision"; then
999 if test "$VERSION" != "$macro_version"; then
1000 if test -z "$macro_version"; then
1001 cat >&2 <<_LT_EOF
1002 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1003 $progname: definition of this LT_INIT comes from an older release.
1004 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1005 $progname: and run autoconf again.
1006 _LT_EOF
1007 else
1008 cat >&2 <<_LT_EOF
1009 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1010 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1011 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1012 $progname: and run autoconf again.
1013 _LT_EOF
1015 else
1016 cat >&2 <<_LT_EOF
1017 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1018 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1019 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1020 $progname: of $PACKAGE $VERSION and run autoconf again.
1021 _LT_EOF
1024 exit $EXIT_MISMATCH
1029 ## ----------- ##
1030 ## Main. ##
1031 ## ----------- ##
1033 $opt_help || {
1034 # Sanity checks first:
1035 func_check_version_match
1037 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1038 func_fatal_configuration "not configured to build any kind of library"
1041 test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1044 # Darwin sucks
1045 eval "std_shrext=\"$shrext_cmds\""
1048 # Only execute mode is allowed to have -dlopen flags.
1049 if test -n "$execute_dlfiles" && test "$mode" != execute; then
1050 func_error "unrecognized option \`-dlopen'"
1051 $ECHO "$help" 1>&2
1052 exit $EXIT_FAILURE
1055 # Change the help message to a mode-specific one.
1056 generic_help="$help"
1057 help="Try \`$progname --help --mode=$mode' for more information."
1061 # func_lalib_p file
1062 # True iff FILE is a libtool `.la' library or `.lo' object file.
1063 # This function is only a basic sanity check; it will hardly flush out
1064 # determined imposters.
1065 func_lalib_p ()
1067 test -f "$1" &&
1068 $SED -e 4q "$1" 2>/dev/null \
1069 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1072 # func_lalib_unsafe_p file
1073 # True iff FILE is a libtool `.la' library or `.lo' object file.
1074 # This function implements the same check as func_lalib_p without
1075 # resorting to external programs. To this end, it redirects stdin and
1076 # closes it afterwards, without saving the original file descriptor.
1077 # As a safety measure, use it only where a negative result would be
1078 # fatal anyway. Works if `file' does not exist.
1079 func_lalib_unsafe_p ()
1081 lalib_p=no
1082 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1083 for lalib_p_l in 1 2 3 4
1085 read lalib_p_line
1086 case "$lalib_p_line" in
1087 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1088 esac
1089 done
1090 exec 0<&5 5<&-
1092 test "$lalib_p" = yes
1095 # func_ltwrapper_script_p file
1096 # True iff FILE is a libtool wrapper script
1097 # This function is only a basic sanity check; it will hardly flush out
1098 # determined imposters.
1099 func_ltwrapper_script_p ()
1101 func_lalib_p "$1"
1104 # func_ltwrapper_executable_p file
1105 # True iff FILE is a libtool wrapper executable
1106 # This function is only a basic sanity check; it will hardly flush out
1107 # determined imposters.
1108 func_ltwrapper_executable_p ()
1110 func_ltwrapper_exec_suffix=
1111 case $1 in
1112 *.exe) ;;
1113 *) func_ltwrapper_exec_suffix=.exe ;;
1114 esac
1115 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1118 # func_ltwrapper_scriptname file
1119 # Assumes file is an ltwrapper_executable
1120 # uses $file to determine the appropriate filename for a
1121 # temporary ltwrapper_script.
1122 func_ltwrapper_scriptname ()
1124 func_ltwrapper_scriptname_result=""
1125 if func_ltwrapper_executable_p "$1"; then
1126 func_dirname_and_basename "$1" "" "."
1127 func_stripname '' '.exe' "$func_basename_result"
1128 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1132 # func_ltwrapper_p file
1133 # True iff FILE is a libtool wrapper script or wrapper executable
1134 # This function is only a basic sanity check; it will hardly flush out
1135 # determined imposters.
1136 func_ltwrapper_p ()
1138 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1142 # func_execute_cmds commands fail_cmd
1143 # Execute tilde-delimited COMMANDS.
1144 # If FAIL_CMD is given, eval that upon failure.
1145 # FAIL_CMD may read-access the current command in variable CMD!
1146 func_execute_cmds ()
1148 $opt_debug
1149 save_ifs=$IFS; IFS='~'
1150 for cmd in $1; do
1151 IFS=$save_ifs
1152 eval "cmd=\"$cmd\""
1153 func_show_eval "$cmd" "${2-:}"
1154 done
1155 IFS=$save_ifs
1159 # func_source file
1160 # Source FILE, adding directory component if necessary.
1161 # Note that it is not necessary on cygwin/mingw to append a dot to
1162 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1163 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1164 # `FILE.' does not work on cygwin managed mounts.
1165 func_source ()
1167 $opt_debug
1168 case $1 in
1169 */* | *\\*) . "$1" ;;
1170 *) . "./$1" ;;
1171 esac
1175 # func_infer_tag arg
1176 # Infer tagged configuration to use if any are available and
1177 # if one wasn't chosen via the "--tag" command line option.
1178 # Only attempt this if the compiler in the base compile
1179 # command doesn't match the default compiler.
1180 # arg is usually of the form 'gcc ...'
1181 func_infer_tag ()
1183 $opt_debug
1184 if test -n "$available_tags" && test -z "$tagname"; then
1185 CC_quoted=
1186 for arg in $CC; do
1187 func_quote_for_eval "$arg"
1188 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1189 done
1190 CC_expanded=`func_echo_all $CC`
1191 CC_quoted_expanded=`func_echo_all $CC_quoted`
1192 case $@ in
1193 # Blanks in the command may have been stripped by the calling shell,
1194 # but not from the CC environment variable when configure was run.
1195 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1196 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1197 # Blanks at the start of $base_compile will cause this to fail
1198 # if we don't check for them as well.
1200 for z in $available_tags; do
1201 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1202 # Evaluate the configuration.
1203 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1204 CC_quoted=
1205 for arg in $CC; do
1206 # Double-quote args containing other shell metacharacters.
1207 func_quote_for_eval "$arg"
1208 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1209 done
1210 CC_expanded=`func_echo_all $CC`
1211 CC_quoted_expanded=`func_echo_all $CC_quoted`
1212 case "$@ " in
1213 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1214 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1215 # The compiler in the base compile command matches
1216 # the one in the tagged configuration.
1217 # Assume this is the tagged configuration we want.
1218 tagname=$z
1219 break
1221 esac
1223 done
1224 # If $tagname still isn't set, then no tagged configuration
1225 # was found and let the user know that the "--tag" command
1226 # line option must be used.
1227 if test -z "$tagname"; then
1228 func_echo "unable to infer tagged configuration"
1229 func_fatal_error "specify a tag with \`--tag'"
1230 # else
1231 # func_verbose "using $tagname tagged configuration"
1234 esac
1240 # func_write_libtool_object output_name pic_name nonpic_name
1241 # Create a libtool object file (analogous to a ".la" file),
1242 # but don't create it if we're doing a dry run.
1243 func_write_libtool_object ()
1245 write_libobj=${1}
1246 if test "$build_libtool_libs" = yes; then
1247 write_lobj=\'${2}\'
1248 else
1249 write_lobj=none
1252 if test "$build_old_libs" = yes; then
1253 write_oldobj=\'${3}\'
1254 else
1255 write_oldobj=none
1258 $opt_dry_run || {
1259 cat >${write_libobj}T <<EOF
1260 # $write_libobj - a libtool object file
1261 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1263 # Please DO NOT delete this file!
1264 # It is necessary for linking the library.
1266 # Name of the PIC object.
1267 pic_object=$write_lobj
1269 # Name of the non-PIC object
1270 non_pic_object=$write_oldobj
1273 $MV "${write_libobj}T" "${write_libobj}"
1277 # func_mode_compile arg...
1278 func_mode_compile ()
1280 $opt_debug
1281 # Get the compilation command and the source file.
1282 base_compile=
1283 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1284 suppress_opt=yes
1285 suppress_output=
1286 arg_mode=normal
1287 libobj=
1288 later=
1289 pie_flag=
1291 for arg
1293 case $arg_mode in
1294 arg )
1295 # do not "continue". Instead, add this to base_compile
1296 lastarg="$arg"
1297 arg_mode=normal
1300 target )
1301 libobj="$arg"
1302 arg_mode=normal
1303 continue
1306 normal )
1307 # Accept any command-line options.
1308 case $arg in
1310 test -n "$libobj" && \
1311 func_fatal_error "you cannot specify \`-o' more than once"
1312 arg_mode=target
1313 continue
1316 -pie | -fpie | -fPIE)
1317 pie_flag="$pie_flag $arg"
1318 continue
1321 -shared | -static | -prefer-pic | -prefer-non-pic)
1322 later="$later $arg"
1323 continue
1326 -no-suppress)
1327 suppress_opt=no
1328 continue
1331 -Xcompiler)
1332 arg_mode=arg # the next one goes into the "base_compile" arg list
1333 continue # The current "srcfile" will either be retained or
1334 ;; # replaced later. I would guess that would be a bug.
1336 -Wc,*)
1337 func_stripname '-Wc,' '' "$arg"
1338 args=$func_stripname_result
1339 lastarg=
1340 save_ifs="$IFS"; IFS=','
1341 for arg in $args; do
1342 IFS="$save_ifs"
1343 func_quote_for_eval "$arg"
1344 lastarg="$lastarg $func_quote_for_eval_result"
1345 done
1346 IFS="$save_ifs"
1347 func_stripname ' ' '' "$lastarg"
1348 lastarg=$func_stripname_result
1350 # Add the arguments to base_compile.
1351 base_compile="$base_compile $lastarg"
1352 continue
1356 # Accept the current argument as the source file.
1357 # The previous "srcfile" becomes the current argument.
1359 lastarg="$srcfile"
1360 srcfile="$arg"
1362 esac # case $arg
1364 esac # case $arg_mode
1366 # Aesthetically quote the previous argument.
1367 func_quote_for_eval "$lastarg"
1368 base_compile="$base_compile $func_quote_for_eval_result"
1369 done # for arg
1371 case $arg_mode in
1372 arg)
1373 func_fatal_error "you must specify an argument for -Xcompile"
1375 target)
1376 func_fatal_error "you must specify a target with \`-o'"
1379 # Get the name of the library object.
1380 test -z "$libobj" && {
1381 func_basename "$srcfile"
1382 libobj="$func_basename_result"
1385 esac
1387 # Recognize several different file suffixes.
1388 # If the user specifies -o file.o, it is replaced with file.lo
1389 case $libobj in
1390 *.[cCFSifmso] | \
1391 *.ada | *.adb | *.ads | *.asm | \
1392 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1393 *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1394 func_xform "$libobj"
1395 libobj=$func_xform_result
1397 esac
1399 case $libobj in
1400 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1402 func_fatal_error "cannot determine name of library object from \`$libobj'"
1404 esac
1406 func_infer_tag $base_compile
1408 for arg in $later; do
1409 case $arg in
1410 -shared)
1411 test "$build_libtool_libs" != yes && \
1412 func_fatal_configuration "can not build a shared library"
1413 build_old_libs=no
1414 continue
1417 -static)
1418 build_libtool_libs=no
1419 build_old_libs=yes
1420 continue
1423 -prefer-pic)
1424 pic_mode=yes
1425 continue
1428 -prefer-non-pic)
1429 pic_mode=no
1430 continue
1432 esac
1433 done
1435 func_quote_for_eval "$libobj"
1436 test "X$libobj" != "X$func_quote_for_eval_result" \
1437 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1438 && func_warning "libobj name \`$libobj' may not contain shell special characters."
1439 func_dirname_and_basename "$obj" "/" ""
1440 objname="$func_basename_result"
1441 xdir="$func_dirname_result"
1442 lobj=${xdir}$objdir/$objname
1444 test -z "$base_compile" && \
1445 func_fatal_help "you must specify a compilation command"
1447 # Delete any leftover library objects.
1448 if test "$build_old_libs" = yes; then
1449 removelist="$obj $lobj $libobj ${libobj}T"
1450 else
1451 removelist="$lobj $libobj ${libobj}T"
1454 # On Cygwin there's no "real" PIC flag so we must build both object types
1455 case $host_os in
1456 cygwin* | mingw* | pw32* | os2* | cegcc*)
1457 pic_mode=default
1459 esac
1460 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1461 # non-PIC code in shared libraries is not supported
1462 pic_mode=default
1465 # Calculate the filename of the output object if compiler does
1466 # not support -o with -c
1467 if test "$compiler_c_o" = no; then
1468 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1469 lockfile="$output_obj.lock"
1470 else
1471 output_obj=
1472 need_locks=no
1473 lockfile=
1476 # Lock this critical section if it is needed
1477 # We use this script file to make the link, it avoids creating a new file
1478 if test "$need_locks" = yes; then
1479 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1480 func_echo "Waiting for $lockfile to be removed"
1481 sleep 2
1482 done
1483 elif test "$need_locks" = warn; then
1484 if test -f "$lockfile"; then
1485 $ECHO "\
1486 *** ERROR, $lockfile exists and contains:
1487 `cat $lockfile 2>/dev/null`
1489 This indicates that another process is trying to use the same
1490 temporary object file, and libtool could not work around it because
1491 your compiler does not support \`-c' and \`-o' together. If you
1492 repeat this compilation, it may succeed, by chance, but you had better
1493 avoid parallel builds (make -j) in this platform, or get a better
1494 compiler."
1496 $opt_dry_run || $RM $removelist
1497 exit $EXIT_FAILURE
1499 removelist="$removelist $output_obj"
1500 $ECHO "$srcfile" > "$lockfile"
1503 $opt_dry_run || $RM $removelist
1504 removelist="$removelist $lockfile"
1505 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1507 if test -n "$fix_srcfile_path"; then
1508 eval "srcfile=\"$fix_srcfile_path\""
1510 func_quote_for_eval "$srcfile"
1511 qsrcfile=$func_quote_for_eval_result
1513 # Only build a PIC object if we are building libtool libraries.
1514 if test "$build_libtool_libs" = yes; then
1515 # Without this assignment, base_compile gets emptied.
1516 fbsd_hideous_sh_bug=$base_compile
1518 if test "$pic_mode" != no; then
1519 command="$base_compile $qsrcfile $pic_flag"
1520 else
1521 # Don't build PIC code
1522 command="$base_compile $qsrcfile"
1525 func_mkdir_p "$xdir$objdir"
1527 if test -z "$output_obj"; then
1528 # Place PIC objects in $objdir
1529 command="$command -o $lobj"
1532 func_show_eval_locale "$command" \
1533 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1535 if test "$need_locks" = warn &&
1536 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1537 $ECHO "\
1538 *** ERROR, $lockfile contains:
1539 `cat $lockfile 2>/dev/null`
1541 but it should contain:
1542 $srcfile
1544 This indicates that another process is trying to use the same
1545 temporary object file, and libtool could not work around it because
1546 your compiler does not support \`-c' and \`-o' together. If you
1547 repeat this compilation, it may succeed, by chance, but you had better
1548 avoid parallel builds (make -j) in this platform, or get a better
1549 compiler."
1551 $opt_dry_run || $RM $removelist
1552 exit $EXIT_FAILURE
1555 # Just move the object if needed, then go on to compile the next one
1556 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1557 func_show_eval '$MV "$output_obj" "$lobj"' \
1558 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1561 # Allow error messages only from the first compilation.
1562 if test "$suppress_opt" = yes; then
1563 suppress_output=' >/dev/null 2>&1'
1567 # Only build a position-dependent object if we build old libraries.
1568 if test "$build_old_libs" = yes; then
1569 if test "$pic_mode" != yes; then
1570 # Don't build PIC code
1571 command="$base_compile $qsrcfile$pie_flag"
1572 else
1573 command="$base_compile $qsrcfile $pic_flag"
1575 if test "$compiler_c_o" = yes; then
1576 command="$command -o $obj"
1579 # Suppress compiler output if we already did a PIC compilation.
1580 command="$command$suppress_output"
1581 func_show_eval_locale "$command" \
1582 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1584 if test "$need_locks" = warn &&
1585 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1586 $ECHO "\
1587 *** ERROR, $lockfile contains:
1588 `cat $lockfile 2>/dev/null`
1590 but it should contain:
1591 $srcfile
1593 This indicates that another process is trying to use the same
1594 temporary object file, and libtool could not work around it because
1595 your compiler does not support \`-c' and \`-o' together. If you
1596 repeat this compilation, it may succeed, by chance, but you had better
1597 avoid parallel builds (make -j) in this platform, or get a better
1598 compiler."
1600 $opt_dry_run || $RM $removelist
1601 exit $EXIT_FAILURE
1604 # Just move the object if needed
1605 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1606 func_show_eval '$MV "$output_obj" "$obj"' \
1607 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1611 $opt_dry_run || {
1612 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1614 # Unlock the critical section if it was locked
1615 if test "$need_locks" != no; then
1616 removelist=$lockfile
1617 $RM "$lockfile"
1621 exit $EXIT_SUCCESS
1624 $opt_help || {
1625 test "$mode" = compile && func_mode_compile ${1+"$@"}
1628 func_mode_help ()
1630 # We need to display help for each of the modes.
1631 case $mode in
1633 # Generic help is extracted from the usage comments
1634 # at the start of this file.
1635 func_help
1638 clean)
1639 $ECHO \
1640 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1642 Remove files from the build directory.
1644 RM is the name of the program to use to delete files associated with each FILE
1645 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1646 to RM.
1648 If FILE is a libtool library, object or program, all the files associated
1649 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1652 compile)
1653 $ECHO \
1654 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1656 Compile a source file into a libtool library object.
1658 This mode accepts the following additional options:
1660 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
1661 -no-suppress do not suppress compiler output for multiple passes
1662 -prefer-pic try to building PIC objects only
1663 -prefer-non-pic try to building non-PIC objects only
1664 -shared do not build a \`.o' file suitable for static linking
1665 -static only build a \`.o' file suitable for static linking
1666 -Wc,FLAG pass FLAG directly to the compiler
1668 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1669 from the given SOURCEFILE.
1671 The output file name is determined by removing the directory component from
1672 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1673 library object suffix, \`.lo'."
1676 execute)
1677 $ECHO \
1678 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1680 Automatically set library path, then run a program.
1682 This mode accepts the following additional options:
1684 -dlopen FILE add the directory containing FILE to the library path
1686 This mode sets the library path environment variable according to \`-dlopen'
1687 flags.
1689 If any of the ARGS are libtool executable wrappers, then they are translated
1690 into their corresponding uninstalled binary, and any of their required library
1691 directories are added to the library path.
1693 Then, COMMAND is executed, with ARGS as arguments."
1696 finish)
1697 $ECHO \
1698 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1700 Complete the installation of libtool libraries.
1702 Each LIBDIR is a directory that contains libtool libraries.
1704 The commands that this mode executes may require superuser privileges. Use
1705 the \`--dry-run' option if you just want to see what would be executed."
1708 install)
1709 $ECHO \
1710 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1712 Install executables or libraries.
1714 INSTALL-COMMAND is the installation command. The first component should be
1715 either the \`install' or \`cp' program.
1717 The following components of INSTALL-COMMAND are treated specially:
1719 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1721 The rest of the components are interpreted as arguments to that command (only
1722 BSD-compatible install options are recognized)."
1725 link)
1726 $ECHO \
1727 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1729 Link object files or libraries together to form another library, or to
1730 create an executable program.
1732 LINK-COMMAND is a command using the C compiler that you would use to create
1733 a program from several object files.
1735 The following components of LINK-COMMAND are treated specially:
1737 -all-static do not do any dynamic linking at all
1738 -avoid-version do not add a version suffix if possible
1739 -bindir BINDIR specify path to binaries directory (for systems where
1740 libraries must be found in the PATH setting at runtime)
1741 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1742 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1743 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1744 -export-symbols SYMFILE
1745 try to export only the symbols listed in SYMFILE
1746 -export-symbols-regex REGEX
1747 try to export only the symbols matching REGEX
1748 -LLIBDIR search LIBDIR for required installed libraries
1749 -lNAME OUTPUT-FILE requires the installed library libNAME
1750 -module build a library that can dlopened
1751 -no-fast-install disable the fast-install mode
1752 -no-install link a not-installable executable
1753 -no-undefined declare that a library does not refer to external symbols
1754 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1755 -objectlist FILE Use a list of object files found in FILE to specify objects
1756 -precious-files-regex REGEX
1757 don't remove output files matching REGEX
1758 -release RELEASE specify package release information
1759 -rpath LIBDIR the created library will eventually be installed in LIBDIR
1760 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1761 -shared only do dynamic linking of libtool libraries
1762 -shrext SUFFIX override the standard shared library file extension
1763 -static do not do any dynamic linking of uninstalled libtool libraries
1764 -static-libtool-libs
1765 do not do any dynamic linking of libtool libraries
1766 -version-info CURRENT[:REVISION[:AGE]]
1767 specify library version info [each variable defaults to 0]
1768 -weak LIBNAME declare that the target provides the LIBNAME interface
1769 -Wc,FLAG
1770 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
1771 -Wl,FLAG
1772 -Xlinker FLAG pass linker-specific FLAG directly to the linker
1773 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
1775 All other options (arguments beginning with \`-') are ignored.
1777 Every other argument is treated as a filename. Files ending in \`.la' are
1778 treated as uninstalled libtool libraries, other files are standard or library
1779 object files.
1781 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1782 only library objects (\`.lo' files) may be specified, and \`-rpath' is
1783 required, except when creating a convenience library.
1785 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1786 using \`ar' and \`ranlib', or on Windows using \`lib'.
1788 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1789 is created, otherwise an executable program is created."
1792 uninstall)
1793 $ECHO \
1794 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1796 Remove libraries from an installation directory.
1798 RM is the name of the program to use to delete files associated with each FILE
1799 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1800 to RM.
1802 If FILE is a libtool library, all the files associated with it are deleted.
1803 Otherwise, only FILE itself is deleted using RM."
1807 func_fatal_help "invalid operation mode \`$mode'"
1809 esac
1811 echo
1812 $ECHO "Try \`$progname --help' for more information about other modes."
1815 # Now that we've collected a possible --mode arg, show help if necessary
1816 if $opt_help; then
1817 if test "$opt_help" = :; then
1818 func_mode_help
1819 else
1821 func_help noexit
1822 for mode in compile link execute install finish uninstall clean; do
1823 func_mode_help
1824 done
1825 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
1827 func_help noexit
1828 for mode in compile link execute install finish uninstall clean; do
1829 echo
1830 func_mode_help
1831 done
1833 sed '1d
1834 /^When reporting/,/^Report/{
1839 /information about other modes/d
1840 /more detailed .*MODE/d
1841 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
1843 exit $?
1847 # func_mode_execute arg...
1848 func_mode_execute ()
1850 $opt_debug
1851 # The first argument is the command name.
1852 cmd="$nonopt"
1853 test -z "$cmd" && \
1854 func_fatal_help "you must specify a COMMAND"
1856 # Handle -dlopen flags immediately.
1857 for file in $execute_dlfiles; do
1858 test -f "$file" \
1859 || func_fatal_help "\`$file' is not a file"
1861 dir=
1862 case $file in
1863 *.la)
1864 # Check to see that this really is a libtool archive.
1865 func_lalib_unsafe_p "$file" \
1866 || func_fatal_help "\`$lib' is not a valid libtool archive"
1868 # Read the libtool library.
1869 dlname=
1870 library_names=
1871 func_source "$file"
1873 # Skip this library if it cannot be dlopened.
1874 if test -z "$dlname"; then
1875 # Warn if it was a shared library.
1876 test -n "$library_names" && \
1877 func_warning "\`$file' was not linked with \`-export-dynamic'"
1878 continue
1881 func_dirname "$file" "" "."
1882 dir="$func_dirname_result"
1884 if test -f "$dir/$objdir/$dlname"; then
1885 dir="$dir/$objdir"
1886 else
1887 if test ! -f "$dir/$dlname"; then
1888 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1893 *.lo)
1894 # Just add the directory containing the .lo file.
1895 func_dirname "$file" "" "."
1896 dir="$func_dirname_result"
1900 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1901 continue
1903 esac
1905 # Get the absolute pathname.
1906 absdir=`cd "$dir" && pwd`
1907 test -n "$absdir" && dir="$absdir"
1909 # Now add the directory to shlibpath_var.
1910 if eval test -z \"\$$shlibpath_var\"; then
1911 eval $shlibpath_var=\$dir
1912 else
1913 eval $shlibpath_var=\$dir:\$$shlibpath_var
1915 done
1917 # This variable tells wrapper scripts just to set shlibpath_var
1918 # rather than running their programs.
1919 libtool_execute_magic="$magic"
1921 # Check if any of the arguments is a wrapper script.
1922 args=
1923 for file
1925 case $file in
1926 -* | *.la | *.lo ) ;;
1928 # Do a test to see if this is really a libtool program.
1929 if func_ltwrapper_script_p "$file"; then
1930 func_source "$file"
1931 # Transform arg to wrapped name.
1932 file="$progdir/$program"
1933 elif func_ltwrapper_executable_p "$file"; then
1934 func_ltwrapper_scriptname "$file"
1935 func_source "$func_ltwrapper_scriptname_result"
1936 # Transform arg to wrapped name.
1937 file="$progdir/$program"
1940 esac
1941 # Quote arguments (to preserve shell metacharacters).
1942 func_quote_for_eval "$file"
1943 args="$args $func_quote_for_eval_result"
1944 done
1946 if test "X$opt_dry_run" = Xfalse; then
1947 if test -n "$shlibpath_var"; then
1948 # Export the shlibpath_var.
1949 eval "export $shlibpath_var"
1952 # Restore saved environment variables
1953 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1955 eval "if test \"\${save_$lt_var+set}\" = set; then
1956 $lt_var=\$save_$lt_var; export $lt_var
1957 else
1958 $lt_unset $lt_var
1960 done
1962 # Now prepare to actually exec the command.
1963 exec_cmd="\$cmd$args"
1964 else
1965 # Display what would be done.
1966 if test -n "$shlibpath_var"; then
1967 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1968 echo "export $shlibpath_var"
1970 $ECHO "$cmd$args"
1971 exit $EXIT_SUCCESS
1975 test "$mode" = execute && func_mode_execute ${1+"$@"}
1978 # func_mode_finish arg...
1979 func_mode_finish ()
1981 $opt_debug
1982 libdirs="$nonopt"
1983 admincmds=
1985 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1986 for dir
1988 libdirs="$libdirs $dir"
1989 done
1991 for libdir in $libdirs; do
1992 if test -n "$finish_cmds"; then
1993 # Do each command in the finish commands.
1994 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1995 '"$cmd"'"'
1997 if test -n "$finish_eval"; then
1998 # Do the single finish_eval.
1999 eval cmds=\"$finish_eval\"
2000 $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2001 $cmds"
2003 done
2006 # Exit here if they wanted silent mode.
2007 $opt_silent && exit $EXIT_SUCCESS
2009 echo "----------------------------------------------------------------------"
2010 echo "Libraries have been installed in:"
2011 for libdir in $libdirs; do
2012 $ECHO " $libdir"
2013 done
2014 echo
2015 echo "If you ever happen to want to link against installed libraries"
2016 echo "in a given directory, LIBDIR, you must either use libtool, and"
2017 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2018 echo "flag during linking and do at least one of the following:"
2019 if test -n "$shlibpath_var"; then
2020 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2021 echo " during execution"
2023 if test -n "$runpath_var"; then
2024 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2025 echo " during linking"
2027 if test -n "$hardcode_libdir_flag_spec"; then
2028 libdir=LIBDIR
2029 eval "flag=\"$hardcode_libdir_flag_spec\""
2031 $ECHO " - use the \`$flag' linker flag"
2033 if test -n "$admincmds"; then
2034 $ECHO " - have your system administrator run these commands:$admincmds"
2036 if test -f /etc/ld.so.conf; then
2037 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2039 echo
2041 echo "See any operating system documentation about shared libraries for"
2042 case $host in
2043 solaris2.[6789]|solaris2.1[0-9])
2044 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2045 echo "pages."
2048 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2050 esac
2051 echo "----------------------------------------------------------------------"
2052 exit $EXIT_SUCCESS
2055 test "$mode" = finish && func_mode_finish ${1+"$@"}
2058 # func_mode_install arg...
2059 func_mode_install ()
2061 $opt_debug
2062 # There may be an optional sh(1) argument at the beginning of
2063 # install_prog (especially on Windows NT).
2064 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2065 # Allow the use of GNU shtool's install command.
2066 case $nonopt in *shtool*) :;; *) false;; esac; then
2067 # Aesthetically quote it.
2068 func_quote_for_eval "$nonopt"
2069 install_prog="$func_quote_for_eval_result "
2070 arg=$1
2071 shift
2072 else
2073 install_prog=
2074 arg=$nonopt
2077 # The real first argument should be the name of the installation program.
2078 # Aesthetically quote it.
2079 func_quote_for_eval "$arg"
2080 install_prog="$install_prog$func_quote_for_eval_result"
2081 install_shared_prog=$install_prog
2082 case " $install_prog " in
2083 *[\\\ /]cp\ *) install_cp=: ;;
2084 *) install_cp=false ;;
2085 esac
2087 # We need to accept at least all the BSD install flags.
2088 dest=
2089 files=
2090 opts=
2091 prev=
2092 install_type=
2093 isdir=no
2094 stripme=
2095 no_mode=:
2096 for arg
2098 arg2=
2099 if test -n "$dest"; then
2100 files="$files $dest"
2101 dest=$arg
2102 continue
2105 case $arg in
2106 -d) isdir=yes ;;
2108 if $install_cp; then :; else
2109 prev=$arg
2112 -g | -m | -o)
2113 prev=$arg
2116 stripme=" -s"
2117 continue
2122 # If the previous option needed an argument, then skip it.
2123 if test -n "$prev"; then
2124 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2125 arg2=$install_override_mode
2126 no_mode=false
2128 prev=
2129 else
2130 dest=$arg
2131 continue
2134 esac
2136 # Aesthetically quote the argument.
2137 func_quote_for_eval "$arg"
2138 install_prog="$install_prog $func_quote_for_eval_result"
2139 if test -n "$arg2"; then
2140 func_quote_for_eval "$arg2"
2142 install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2143 done
2145 test -z "$install_prog" && \
2146 func_fatal_help "you must specify an install program"
2148 test -n "$prev" && \
2149 func_fatal_help "the \`$prev' option requires an argument"
2151 if test -n "$install_override_mode" && $no_mode; then
2152 if $install_cp; then :; else
2153 func_quote_for_eval "$install_override_mode"
2154 install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2158 if test -z "$files"; then
2159 if test -z "$dest"; then
2160 func_fatal_help "no file or destination specified"
2161 else
2162 func_fatal_help "you must specify a destination"
2166 # Strip any trailing slash from the destination.
2167 func_stripname '' '/' "$dest"
2168 dest=$func_stripname_result
2170 # Check to see that the destination is a directory.
2171 test -d "$dest" && isdir=yes
2172 if test "$isdir" = yes; then
2173 destdir="$dest"
2174 destname=
2175 else
2176 func_dirname_and_basename "$dest" "" "."
2177 destdir="$func_dirname_result"
2178 destname="$func_basename_result"
2180 # Not a directory, so check to see that there is only one file specified.
2181 set dummy $files; shift
2182 test "$#" -gt 1 && \
2183 func_fatal_help "\`$dest' is not a directory"
2185 case $destdir in
2186 [\\/]* | [A-Za-z]:[\\/]*) ;;
2188 for file in $files; do
2189 case $file in
2190 *.lo) ;;
2192 func_fatal_help "\`$destdir' must be an absolute directory name"
2194 esac
2195 done
2197 esac
2199 # This variable tells wrapper scripts just to set variables rather
2200 # than running their programs.
2201 libtool_install_magic="$magic"
2203 staticlibs=
2204 future_libdirs=
2205 current_libdirs=
2206 for file in $files; do
2208 # Do each installation.
2209 case $file in
2210 *.$libext)
2211 # Do the static libraries later.
2212 staticlibs="$staticlibs $file"
2215 *.la)
2216 # Check to see that this really is a libtool archive.
2217 func_lalib_unsafe_p "$file" \
2218 || func_fatal_help "\`$file' is not a valid libtool archive"
2220 library_names=
2221 old_library=
2222 relink_command=
2223 func_source "$file"
2225 # Add the libdir to current_libdirs if it is the destination.
2226 if test "X$destdir" = "X$libdir"; then
2227 case "$current_libdirs " in
2228 *" $libdir "*) ;;
2229 *) current_libdirs="$current_libdirs $libdir" ;;
2230 esac
2231 else
2232 # Note the libdir as a future libdir.
2233 case "$future_libdirs " in
2234 *" $libdir "*) ;;
2235 *) future_libdirs="$future_libdirs $libdir" ;;
2236 esac
2239 func_dirname "$file" "/" ""
2240 dir="$func_dirname_result"
2241 dir="$dir$objdir"
2243 if test -n "$relink_command"; then
2244 # Determine the prefix the user has applied to our future dir.
2245 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2247 # Don't allow the user to place us outside of our expected
2248 # location b/c this prevents finding dependent libraries that
2249 # are installed to the same prefix.
2250 # At present, this check doesn't affect windows .dll's that
2251 # are installed into $libdir/../bin (currently, that works fine)
2252 # but it's something to keep an eye on.
2253 test "$inst_prefix_dir" = "$destdir" && \
2254 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2256 if test -n "$inst_prefix_dir"; then
2257 # Stick the inst_prefix_dir data into the link command.
2258 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2259 else
2260 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2263 func_warning "relinking \`$file'"
2264 func_show_eval "$relink_command" \
2265 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2268 # See the names of the shared library.
2269 set dummy $library_names; shift
2270 if test -n "$1"; then
2271 realname="$1"
2272 shift
2274 srcname="$realname"
2275 test -n "$relink_command" && srcname="$realname"T
2277 # Install the shared library and build the symlinks.
2278 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2279 'exit $?'
2280 tstripme="$stripme"
2281 case $host_os in
2282 cygwin* | mingw* | pw32* | cegcc*)
2283 case $realname in
2284 *.dll.a)
2285 tstripme=""
2287 esac
2289 esac
2290 if test -n "$tstripme" && test -n "$striplib"; then
2291 func_show_eval "$striplib $destdir/$realname" 'exit $?'
2294 if test "$#" -gt 0; then
2295 # Delete the old symlinks, and create new ones.
2296 # Try `ln -sf' first, because the `ln' binary might depend on
2297 # the symlink we replace! Solaris /bin/ln does not understand -f,
2298 # so we also need to try rm && ln -s.
2299 for linkname
2301 test "$linkname" != "$realname" \
2302 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2303 done
2306 # Do each command in the postinstall commands.
2307 lib="$destdir/$realname"
2308 func_execute_cmds "$postinstall_cmds" 'exit $?'
2311 # Install the pseudo-library for information purposes.
2312 func_basename "$file"
2313 name="$func_basename_result"
2314 instname="$dir/$name"i
2315 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2317 # Maybe install the static library, too.
2318 test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2321 *.lo)
2322 # Install (i.e. copy) a libtool object.
2324 # Figure out destination file name, if it wasn't already specified.
2325 if test -n "$destname"; then
2326 destfile="$destdir/$destname"
2327 else
2328 func_basename "$file"
2329 destfile="$func_basename_result"
2330 destfile="$destdir/$destfile"
2333 # Deduce the name of the destination old-style object file.
2334 case $destfile in
2335 *.lo)
2336 func_lo2o "$destfile"
2337 staticdest=$func_lo2o_result
2339 *.$objext)
2340 staticdest="$destfile"
2341 destfile=
2344 func_fatal_help "cannot copy a libtool object to \`$destfile'"
2346 esac
2348 # Install the libtool object if requested.
2349 test -n "$destfile" && \
2350 func_show_eval "$install_prog $file $destfile" 'exit $?'
2352 # Install the old object if enabled.
2353 if test "$build_old_libs" = yes; then
2354 # Deduce the name of the old-style object file.
2355 func_lo2o "$file"
2356 staticobj=$func_lo2o_result
2357 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2359 exit $EXIT_SUCCESS
2363 # Figure out destination file name, if it wasn't already specified.
2364 if test -n "$destname"; then
2365 destfile="$destdir/$destname"
2366 else
2367 func_basename "$file"
2368 destfile="$func_basename_result"
2369 destfile="$destdir/$destfile"
2372 # If the file is missing, and there is a .exe on the end, strip it
2373 # because it is most likely a libtool script we actually want to
2374 # install
2375 stripped_ext=""
2376 case $file in
2377 *.exe)
2378 if test ! -f "$file"; then
2379 func_stripname '' '.exe' "$file"
2380 file=$func_stripname_result
2381 stripped_ext=".exe"
2384 esac
2386 # Do a test to see if this is really a libtool program.
2387 case $host in
2388 *cygwin* | *mingw*)
2389 if func_ltwrapper_executable_p "$file"; then
2390 func_ltwrapper_scriptname "$file"
2391 wrapper=$func_ltwrapper_scriptname_result
2392 else
2393 func_stripname '' '.exe' "$file"
2394 wrapper=$func_stripname_result
2398 wrapper=$file
2400 esac
2401 if func_ltwrapper_script_p "$wrapper"; then
2402 notinst_deplibs=
2403 relink_command=
2405 func_source "$wrapper"
2407 # Check the variables that should have been set.
2408 test -z "$generated_by_libtool_version" && \
2409 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2411 finalize=yes
2412 for lib in $notinst_deplibs; do
2413 # Check to see that each library is installed.
2414 libdir=
2415 if test -f "$lib"; then
2416 func_source "$lib"
2418 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2419 if test -n "$libdir" && test ! -f "$libfile"; then
2420 func_warning "\`$lib' has not been installed in \`$libdir'"
2421 finalize=no
2423 done
2425 relink_command=
2426 func_source "$wrapper"
2428 outputname=
2429 if test "$fast_install" = no && test -n "$relink_command"; then
2430 $opt_dry_run || {
2431 if test "$finalize" = yes; then
2432 tmpdir=`func_mktempdir`
2433 func_basename "$file$stripped_ext"
2434 file="$func_basename_result"
2435 outputname="$tmpdir/$file"
2436 # Replace the output file specification.
2437 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2439 $opt_silent || {
2440 func_quote_for_expand "$relink_command"
2441 eval "func_echo $func_quote_for_expand_result"
2443 if eval "$relink_command"; then :
2444 else
2445 func_error "error: relink \`$file' with the above command before installing it"
2446 $opt_dry_run || ${RM}r "$tmpdir"
2447 continue
2449 file="$outputname"
2450 else
2451 func_warning "cannot relink \`$file'"
2454 else
2455 # Install the binary that we compiled earlier.
2456 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2460 # remove .exe since cygwin /usr/bin/install will append another
2461 # one anyway
2462 case $install_prog,$host in
2463 */usr/bin/install*,*cygwin*)
2464 case $file:$destfile in
2465 *.exe:*.exe)
2466 # this is ok
2468 *.exe:*)
2469 destfile=$destfile.exe
2471 *:*.exe)
2472 func_stripname '' '.exe' "$destfile"
2473 destfile=$func_stripname_result
2475 esac
2477 esac
2478 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2479 $opt_dry_run || if test -n "$outputname"; then
2480 ${RM}r "$tmpdir"
2483 esac
2484 done
2486 for file in $staticlibs; do
2487 func_basename "$file"
2488 name="$func_basename_result"
2490 # Set up the ranlib parameters.
2491 oldlib="$destdir/$name"
2493 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2495 if test -n "$stripme" && test -n "$old_striplib"; then
2496 func_show_eval "$old_striplib $oldlib" 'exit $?'
2499 # Do each command in the postinstall commands.
2500 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2501 done
2503 test -n "$future_libdirs" && \
2504 func_warning "remember to run \`$progname --finish$future_libdirs'"
2506 if test -n "$current_libdirs" && $opt_finish; then
2507 # Maybe just do a dry run.
2508 $opt_dry_run && current_libdirs=" -n$current_libdirs"
2509 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2510 else
2511 exit $EXIT_SUCCESS
2515 test "$mode" = install && func_mode_install ${1+"$@"}
2518 # func_generate_dlsyms outputname originator pic_p
2519 # Extract symbols from dlprefiles and create ${outputname}S.o with
2520 # a dlpreopen symbol table.
2521 func_generate_dlsyms ()
2523 $opt_debug
2524 my_outputname="$1"
2525 my_originator="$2"
2526 my_pic_p="${3-no}"
2527 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2528 my_dlsyms=
2530 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2531 if test -n "$NM" && test -n "$global_symbol_pipe"; then
2532 my_dlsyms="${my_outputname}S.c"
2533 else
2534 func_error "not configured to extract global symbols from dlpreopened files"
2538 if test -n "$my_dlsyms"; then
2539 case $my_dlsyms in
2540 "") ;;
2541 *.c)
2542 # Discover the nlist of each of the dlfiles.
2543 nlist="$output_objdir/${my_outputname}.nm"
2545 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2547 # Parse the name list into a source file.
2548 func_verbose "creating $output_objdir/$my_dlsyms"
2550 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2551 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2552 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2554 #ifdef __cplusplus
2555 extern \"C\" {
2556 #endif
2558 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
2559 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2560 #endif
2562 /* External symbol declarations for the compiler. */\
2565 if test "$dlself" = yes; then
2566 func_verbose "generating symbol list for \`$output'"
2568 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2570 # Add our own program objects to the symbol list.
2571 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2572 for progfile in $progfiles; do
2573 func_verbose "extracting global C symbols from \`$progfile'"
2574 $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2575 done
2577 if test -n "$exclude_expsyms"; then
2578 $opt_dry_run || {
2579 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2580 $MV "$nlist"T "$nlist"
2584 if test -n "$export_symbols_regex"; then
2585 $opt_dry_run || {
2586 $EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T
2587 $MV "$nlist"T "$nlist"
2591 # Prepare the list of exported symbols
2592 if test -z "$export_symbols"; then
2593 export_symbols="$output_objdir/$outputname.exp"
2594 $opt_dry_run || {
2595 $RM $export_symbols
2596 ${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' < "$nlist" > "$export_symbols"
2597 case $host in
2598 *cygwin* | *mingw* | *cegcc* )
2599 echo EXPORTS > "$output_objdir/$outputname.def"
2600 cat "$export_symbols" >> "$output_objdir/$outputname.def"
2602 esac
2604 else
2605 $opt_dry_run || {
2606 ${SED} -e 's/\([].[*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp"
2607 $GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T
2608 $MV "$nlist"T "$nlist"
2609 case $host in
2610 *cygwin* | *mingw* | *cegcc* )
2611 echo EXPORTS > "$output_objdir/$outputname.def"
2612 cat "$nlist" >> "$output_objdir/$outputname.def"
2614 esac
2619 for dlprefile in $dlprefiles; do
2620 func_verbose "extracting global C symbols from \`$dlprefile'"
2621 func_basename "$dlprefile"
2622 name="$func_basename_result"
2623 $opt_dry_run || {
2624 $ECHO ": $name " >> "$nlist"
2625 eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2627 done
2629 $opt_dry_run || {
2630 # Make sure we have at least an empty file.
2631 test -f "$nlist" || : > "$nlist"
2633 if test -n "$exclude_expsyms"; then
2634 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2635 $MV "$nlist"T "$nlist"
2638 # Try sorting and uniquifying the output.
2639 if $GREP -v "^: " < "$nlist" |
2640 if sort -k 3 </dev/null >/dev/null 2>&1; then
2641 sort -k 3
2642 else
2643 sort +2
2644 fi |
2645 uniq > "$nlist"S; then
2647 else
2648 $GREP -v "^: " < "$nlist" > "$nlist"S
2651 if test -f "$nlist"S; then
2652 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2653 else
2654 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2657 echo >> "$output_objdir/$my_dlsyms" "\
2659 /* The mapping between symbol names and symbols. */
2660 typedef struct {
2661 const char *name;
2662 void *address;
2663 } lt_dlsymlist;
2665 case $host in
2666 *cygwin* | *mingw* | *cegcc* )
2667 echo >> "$output_objdir/$my_dlsyms" "\
2668 /* DATA imports from DLLs on WIN32 con't be const, because
2669 runtime relocations are performed -- see ld's documentation
2670 on pseudo-relocs. */"
2671 lt_dlsym_const= ;;
2672 *osf5*)
2673 echo >> "$output_objdir/$my_dlsyms" "\
2674 /* This system does not cope well with relocations in const data */"
2675 lt_dlsym_const= ;;
2677 lt_dlsym_const=const ;;
2678 esac
2680 echo >> "$output_objdir/$my_dlsyms" "\
2681 extern $lt_dlsym_const lt_dlsymlist
2682 lt_${my_prefix}_LTX_preloaded_symbols[];
2683 $lt_dlsym_const lt_dlsymlist
2684 lt_${my_prefix}_LTX_preloaded_symbols[] =
2686 { \"$my_originator\", (void *) 0 },"
2688 case $need_lib_prefix in
2690 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2693 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2695 esac
2696 echo >> "$output_objdir/$my_dlsyms" "\
2697 {0, (void *) 0}
2700 /* This works around a problem in FreeBSD linker */
2701 #ifdef FREEBSD_WORKAROUND
2702 static const void *lt_preloaded_setup() {
2703 return lt_${my_prefix}_LTX_preloaded_symbols;
2705 #endif
2707 #ifdef __cplusplus
2709 #endif\
2711 } # !$opt_dry_run
2713 pic_flag_for_symtable=
2714 case "$compile_command " in
2715 *" -static "*) ;;
2717 case $host in
2718 # compiling the symbol table file with pic_flag works around
2719 # a FreeBSD bug that causes programs to crash when -lm is
2720 # linked before any other PIC object. But we must not use
2721 # pic_flag when linking with -static. The problem exists in
2722 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2723 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2724 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2725 *-*-hpux*)
2726 pic_flag_for_symtable=" $pic_flag" ;;
2728 if test "X$my_pic_p" != Xno; then
2729 pic_flag_for_symtable=" $pic_flag"
2732 esac
2734 esac
2735 symtab_cflags=
2736 for arg in $LTCFLAGS; do
2737 case $arg in
2738 -pie | -fpie | -fPIE) ;;
2739 *) symtab_cflags="$symtab_cflags $arg" ;;
2740 esac
2741 done
2743 # Now compile the dynamic symbol file.
2744 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2746 # Clean up the generated files.
2747 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2749 # Transform the symbol file into the correct name.
2750 symfileobj="$output_objdir/${my_outputname}S.$objext"
2751 case $host in
2752 *cygwin* | *mingw* | *cegcc* )
2753 if test -f "$output_objdir/$my_outputname.def"; then
2754 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2755 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2756 else
2757 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2758 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2762 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2763 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2765 esac
2768 func_fatal_error "unknown suffix for \`$my_dlsyms'"
2770 esac
2771 else
2772 # We keep going just in case the user didn't refer to
2773 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2774 # really was required.
2776 # Nullify the symbol file.
2777 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
2778 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2782 # func_win32_libid arg
2783 # return the library type of file 'arg'
2785 # Need a lot of goo to handle *both* DLLs and import libs
2786 # Has to be a shell function in order to 'eat' the argument
2787 # that is supplied when $file_magic_command is called.
2788 # Despite the name, also deal with 64 bit binaries.
2789 func_win32_libid ()
2791 $opt_debug
2792 win32_libid_type="unknown"
2793 win32_fileres=`file -L $1 2>/dev/null`
2794 case $win32_fileres in
2795 *ar\ archive\ import\ library*) # definitely import
2796 win32_libid_type="x86 archive import"
2798 *ar\ archive*) # could be an import, or static
2799 if $OBJDUMP -f "$1" | $SED -e '10q' 2>/dev/null |
2800 $EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
2801 win32_nmres=`$NM -f posix -A "$1" |
2802 $SED -n -e '
2803 1,100{
2804 / I /{
2805 s,.*,import,
2810 case $win32_nmres in
2811 import*) win32_libid_type="x86 archive import";;
2812 *) win32_libid_type="x86 archive static";;
2813 esac
2816 *DLL*)
2817 win32_libid_type="x86 DLL"
2819 *executable*) # but shell scripts are "executable" too...
2820 case $win32_fileres in
2821 *MS\ Windows\ PE\ Intel*)
2822 win32_libid_type="x86 DLL"
2824 esac
2826 esac
2827 $ECHO "$win32_libid_type"
2832 # func_extract_an_archive dir oldlib
2833 func_extract_an_archive ()
2835 $opt_debug
2836 f_ex_an_ar_dir="$1"; shift
2837 f_ex_an_ar_oldlib="$1"
2838 if test "$lock_old_archive_extraction" = yes; then
2839 lockfile=$f_ex_an_ar_oldlib.lock
2840 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2841 func_echo "Waiting for $lockfile to be removed"
2842 sleep 2
2843 done
2845 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2846 'stat=$?; rm -f "$lockfile"; exit $stat'
2847 if test "$lock_old_archive_extraction" = yes; then
2848 $opt_dry_run || rm -f "$lockfile"
2850 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2852 else
2853 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2858 # func_extract_archives gentop oldlib ...
2859 func_extract_archives ()
2861 $opt_debug
2862 my_gentop="$1"; shift
2863 my_oldlibs=${1+"$@"}
2864 my_oldobjs=""
2865 my_xlib=""
2866 my_xabs=""
2867 my_xdir=""
2869 for my_xlib in $my_oldlibs; do
2870 # Extract the objects.
2871 case $my_xlib in
2872 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2873 *) my_xabs=`pwd`"/$my_xlib" ;;
2874 esac
2875 func_basename "$my_xlib"
2876 my_xlib="$func_basename_result"
2877 my_xlib_u=$my_xlib
2878 while :; do
2879 case " $extracted_archives " in
2880 *" $my_xlib_u "*)
2881 func_arith $extracted_serial + 1
2882 extracted_serial=$func_arith_result
2883 my_xlib_u=lt$extracted_serial-$my_xlib ;;
2884 *) break ;;
2885 esac
2886 done
2887 extracted_archives="$extracted_archives $my_xlib_u"
2888 my_xdir="$my_gentop/$my_xlib_u"
2890 func_mkdir_p "$my_xdir"
2892 case $host in
2893 *-darwin*)
2894 func_verbose "Extracting $my_xabs"
2895 # Do not bother doing anything if just a dry run
2896 $opt_dry_run || {
2897 darwin_orig_dir=`pwd`
2898 cd $my_xdir || exit $?
2899 darwin_archive=$my_xabs
2900 darwin_curdir=`pwd`
2901 darwin_base_archive=`basename "$darwin_archive"`
2902 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2903 if test -n "$darwin_arches"; then
2904 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2905 darwin_arch=
2906 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2907 for darwin_arch in $darwin_arches ; do
2908 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2909 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2910 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2911 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2912 cd "$darwin_curdir"
2913 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2914 done # $darwin_arches
2915 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2916 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2917 darwin_file=
2918 darwin_files=
2919 for darwin_file in $darwin_filelist; do
2920 darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2921 $LIPO -create -output "$darwin_file" $darwin_files
2922 done # $darwin_filelist
2923 $RM -rf unfat-$$
2924 cd "$darwin_orig_dir"
2925 else
2926 cd $darwin_orig_dir
2927 func_extract_an_archive "$my_xdir" "$my_xabs"
2928 fi # $darwin_arches
2929 } # !$opt_dry_run
2932 func_extract_an_archive "$my_xdir" "$my_xabs"
2934 esac
2935 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2936 done
2938 func_extract_archives_result="$my_oldobjs"
2942 # func_emit_wrapper [arg=no]
2944 # Emit a libtool wrapper script on stdout.
2945 # Don't directly open a file because we may want to
2946 # incorporate the script contents within a cygwin/mingw
2947 # wrapper executable. Must ONLY be called from within
2948 # func_mode_link because it depends on a number of variables
2949 # set therein.
2951 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2952 # variable will take. If 'yes', then the emitted script
2953 # will assume that the directory in which it is stored is
2954 # the $objdir directory. This is a cygwin/mingw-specific
2955 # behavior.
2956 func_emit_wrapper ()
2958 func_emit_wrapper_arg1=${1-no}
2960 $ECHO "\
2961 #! $SHELL
2963 # $output - temporary wrapper script for $objdir/$outputname
2964 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2966 # The $output program cannot be directly executed until all the libtool
2967 # libraries that it depends on are installed.
2969 # This wrapper script should never be moved out of the build directory.
2970 # If it is, it will not operate correctly.
2972 # Sed substitution that helps us do robust quoting. It backslashifies
2973 # metacharacters that are still active within double-quoted strings.
2974 sed_quote_subst='$sed_quote_subst'
2976 # Be Bourne compatible
2977 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2978 emulate sh
2979 NULLCMD=:
2980 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2981 # is contrary to our usage. Disable this feature.
2982 alias -g '\${1+\"\$@\"}'='\"\$@\"'
2983 setopt NO_GLOB_SUBST
2984 else
2985 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2987 BIN_SH=xpg4; export BIN_SH # for Tru64
2988 DUALCASE=1; export DUALCASE # for MKS sh
2990 # The HP-UX ksh and POSIX shell print the target directory to stdout
2991 # if CDPATH is set.
2992 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2994 relink_command=\"$relink_command\"
2996 # This environment variable determines our operation mode.
2997 if test \"\$libtool_install_magic\" = \"$magic\"; then
2998 # install mode needs the following variables:
2999 generated_by_libtool_version='$macro_version'
3000 notinst_deplibs='$notinst_deplibs'
3001 else
3002 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3003 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3004 file=\"\$0\""
3006 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3007 $ECHO "\
3009 # A function that is used when there is no print builtin or printf.
3010 func_fallback_echo ()
3012 eval 'cat <<_LTECHO_EOF
3014 _LTECHO_EOF'
3016 ECHO=\"$qECHO\"
3019 # Find the directory that this script lives in.
3020 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3021 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3023 # Follow symbolic links until we get to the real thisdir.
3024 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3025 while test -n \"\$file\"; do
3026 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3028 # If there was a directory component, then change thisdir.
3029 if test \"x\$destdir\" != \"x\$file\"; then
3030 case \"\$destdir\" in
3031 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3032 *) thisdir=\"\$thisdir/\$destdir\" ;;
3033 esac
3036 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3037 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3038 done
3040 # Usually 'no', except on cygwin/mingw when embedded into
3041 # the cwrapper.
3042 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3043 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3044 # special case for '.'
3045 if test \"\$thisdir\" = \".\"; then
3046 thisdir=\`pwd\`
3048 # remove .libs from thisdir
3049 case \"\$thisdir\" in
3050 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3051 $objdir ) thisdir=. ;;
3052 esac
3055 # Try to get the absolute directory name.
3056 absdir=\`cd \"\$thisdir\" && pwd\`
3057 test -n \"\$absdir\" && thisdir=\"\$absdir\"
3060 if test "$fast_install" = yes; then
3061 $ECHO "\
3062 program=lt-'$outputname'$exeext
3063 progdir=\"\$thisdir/$objdir\"
3065 if test ! -f \"\$progdir/\$program\" ||
3066 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3067 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3069 file=\"\$\$-\$program\"
3071 if test ! -d \"\$progdir\"; then
3072 $MKDIR \"\$progdir\"
3073 else
3074 $RM \"\$progdir/\$file\"
3077 $ECHO "\
3079 # relink executable if necessary
3080 if test -n \"\$relink_command\"; then
3081 if relink_command_output=\`eval \"\$relink_command\" 2>&1\`; then :
3082 else
3083 $ECHO \"\$relink_command_output\" >&2
3084 $RM \"\$progdir/\$file\"
3085 exit 1
3089 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3090 { $RM \"\$progdir/\$program\";
3091 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3092 $RM \"\$progdir/\$file\"
3094 else
3095 $ECHO "\
3096 program='$outputname'
3097 progdir=\"\$thisdir/$objdir\"
3101 $ECHO "\
3103 if test -f \"\$progdir/\$program\"; then"
3105 # Export our shlibpath_var if we have one.
3106 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3107 $ECHO "\
3108 # Add our own library path to $shlibpath_var
3109 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3111 # Some systems cannot cope with colon-terminated $shlibpath_var
3112 # The second colon is a workaround for a bug in BeOS R4 sed
3113 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3115 export $shlibpath_var
3119 # fixup the dll searchpath if we need to.
3120 if test -n "$dllsearchpath"; then
3121 $ECHO "\
3122 # Add the dll search path components to the executable PATH
3123 PATH=$dllsearchpath:\$PATH
3127 $ECHO "\
3128 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3129 # Run the actual program with our arguments.
3131 case $host in
3132 # Backslashes separate directories on plain windows
3133 *-*-mingw | *-*-os2* | *-cegcc*)
3134 $ECHO "\
3135 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3140 $ECHO "\
3141 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3144 esac
3145 $ECHO "\
3146 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3147 exit 1
3149 else
3150 # The program doesn't exist.
3151 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3152 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3153 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3154 exit 1
3161 # func_to_host_path arg
3163 # Convert paths to host format when used with build tools.
3164 # Intended for use with "native" mingw (where libtool itself
3165 # is running under the msys shell), or in the following cross-
3166 # build environments:
3167 # $build $host
3168 # mingw (msys) mingw [e.g. native]
3169 # cygwin mingw
3170 # *nix + wine mingw
3171 # where wine is equipped with the `winepath' executable.
3172 # In the native mingw case, the (msys) shell automatically
3173 # converts paths for any non-msys applications it launches,
3174 # but that facility isn't available from inside the cwrapper.
3175 # Similar accommodations are necessary for $host mingw and
3176 # $build cygwin. Calling this function does no harm for other
3177 # $host/$build combinations not listed above.
3179 # ARG is the path (on $build) that should be converted to
3180 # the proper representation for $host. The result is stored
3181 # in $func_to_host_path_result.
3182 func_to_host_path ()
3184 func_to_host_path_result="$1"
3185 if test -n "$1"; then
3186 case $host in
3187 *mingw* )
3188 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3189 case $build in
3190 *mingw* ) # actually, msys
3191 # awkward: cmd appends spaces to result
3192 func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3193 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3195 *cygwin* )
3196 func_to_host_path_result=`cygpath -w "$1" |
3197 $SED -e "$lt_sed_naive_backslashify"`
3200 # Unfortunately, winepath does not exit with a non-zero
3201 # error code, so we are forced to check the contents of
3202 # stdout. On the other hand, if the command is not
3203 # found, the shell will set an exit code of 127 and print
3204 # *an error message* to stdout. So we must check for both
3205 # error code of zero AND non-empty stdout, which explains
3206 # the odd construction:
3207 func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3208 if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3209 func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3210 $SED -e "$lt_sed_naive_backslashify"`
3211 else
3212 # Allow warning below.
3213 func_to_host_path_result=
3216 esac
3217 if test -z "$func_to_host_path_result" ; then
3218 func_error "Could not determine host path corresponding to"
3219 func_error " \`$1'"
3220 func_error "Continuing, but uninstalled executables may not work."
3221 # Fallback:
3222 func_to_host_path_result="$1"
3225 esac
3228 # end: func_to_host_path
3230 # func_to_host_pathlist arg
3232 # Convert pathlists to host format when used with build tools.
3233 # See func_to_host_path(), above. This function supports the
3234 # following $build/$host combinations (but does no harm for
3235 # combinations not listed here):
3236 # $build $host
3237 # mingw (msys) mingw [e.g. native]
3238 # cygwin mingw
3239 # *nix + wine mingw
3241 # Path separators are also converted from $build format to
3242 # $host format. If ARG begins or ends with a path separator
3243 # character, it is preserved (but converted to $host format)
3244 # on output.
3246 # ARG is a pathlist (on $build) that should be converted to
3247 # the proper representation on $host. The result is stored
3248 # in $func_to_host_pathlist_result.
3249 func_to_host_pathlist ()
3251 func_to_host_pathlist_result="$1"
3252 if test -n "$1"; then
3253 case $host in
3254 *mingw* )
3255 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3256 # Remove leading and trailing path separator characters from
3257 # ARG. msys behavior is inconsistent here, cygpath turns them
3258 # into '.;' and ';.', and winepath ignores them completely.
3259 func_stripname : : "$1"
3260 func_to_host_pathlist_tmp1=$func_stripname_result
3261 case $build in
3262 *mingw* ) # Actually, msys.
3263 # Awkward: cmd appends spaces to result.
3264 func_to_host_pathlist_result=`
3265 ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
3266 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3268 *cygwin* )
3269 func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
3270 $SED -e "$lt_sed_naive_backslashify"`
3273 # unfortunately, winepath doesn't convert pathlists
3274 func_to_host_pathlist_result=""
3275 func_to_host_pathlist_oldIFS=$IFS
3276 IFS=:
3277 for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3278 IFS=$func_to_host_pathlist_oldIFS
3279 if test -n "$func_to_host_pathlist_f" ; then
3280 func_to_host_path "$func_to_host_pathlist_f"
3281 if test -n "$func_to_host_path_result" ; then
3282 if test -z "$func_to_host_pathlist_result" ; then
3283 func_to_host_pathlist_result="$func_to_host_path_result"
3284 else
3285 func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3289 done
3290 IFS=$func_to_host_pathlist_oldIFS
3292 esac
3293 if test -z "$func_to_host_pathlist_result"; then
3294 func_error "Could not determine the host path(s) corresponding to"
3295 func_error " \`$1'"
3296 func_error "Continuing, but uninstalled executables may not work."
3297 # Fallback. This may break if $1 contains DOS-style drive
3298 # specifications. The fix is not to complicate the expression
3299 # below, but for the user to provide a working wine installation
3300 # with winepath so that path translation in the cross-to-mingw
3301 # case works properly.
3302 lt_replace_pathsep_nix_to_dos="s|:|;|g"
3303 func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3304 $SED -e "$lt_replace_pathsep_nix_to_dos"`
3306 # Now, add the leading and trailing path separators back
3307 case "$1" in
3308 :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3310 esac
3311 case "$1" in
3312 *: ) func_append func_to_host_pathlist_result ";"
3314 esac
3316 esac
3319 # end: func_to_host_pathlist
3321 # func_emit_cwrapperexe_src
3322 # emit the source code for a wrapper executable on stdout
3323 # Must ONLY be called from within func_mode_link because
3324 # it depends on a number of variable set therein.
3325 func_emit_cwrapperexe_src ()
3327 cat <<EOF
3329 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3330 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3332 The $output program cannot be directly executed until all the libtool
3333 libraries that it depends on are installed.
3335 This wrapper executable should never be moved out of the build directory.
3336 If it is, it will not operate correctly.
3338 Currently, it simply execs the wrapper *script* "$SHELL $output",
3339 but could eventually absorb all of the scripts functionality and
3340 exec $objdir/$outputname directly.
3343 cat <<"EOF"
3344 #ifdef _MSC_VER
3345 # define _CRT_SECURE_NO_DEPRECATE 1
3346 #endif
3347 #include <stdio.h>
3348 #include <stdlib.h>
3349 #ifdef _MSC_VER
3350 # include <direct.h>
3351 # include <process.h>
3352 # include <io.h>
3353 #else
3354 # include <unistd.h>
3355 # include <stdint.h>
3356 # ifdef __CYGWIN__
3357 # include <io.h>
3358 # endif
3359 #endif
3360 #include <malloc.h>
3361 #include <stdarg.h>
3362 #include <assert.h>
3363 #include <string.h>
3364 #include <ctype.h>
3365 #include <errno.h>
3366 #include <fcntl.h>
3367 #include <sys/stat.h>
3369 /* declarations of non-ANSI functions */
3370 #if defined(__MINGW32__)
3371 # ifdef __STRICT_ANSI__
3372 int _putenv (const char *);
3373 # endif
3374 #elif defined(__CYGWIN__)
3375 # ifdef __STRICT_ANSI__
3376 char *realpath (const char *, char *);
3377 int putenv (char *);
3378 int setenv (const char *, const char *, int);
3379 # endif
3380 /* #elif defined (other platforms) ... */
3381 #endif
3383 /* portability defines, excluding path handling macros */
3384 #if defined(_MSC_VER)
3385 # define setmode _setmode
3386 # define stat _stat
3387 # define chmod _chmod
3388 # define getcwd _getcwd
3389 # define putenv _putenv
3390 # define S_IXUSR _S_IEXEC
3391 # ifndef _INTPTR_T_DEFINED
3392 # define _INTPTR_T_DEFINED
3393 # define intptr_t int
3394 # endif
3395 #elif defined(__MINGW32__)
3396 # define setmode _setmode
3397 # define stat _stat
3398 # define chmod _chmod
3399 # define getcwd _getcwd
3400 # define putenv _putenv
3401 #elif defined(__CYGWIN__)
3402 # define HAVE_SETENV
3403 # define FOPEN_WB "wb"
3404 /* #elif defined (other platforms) ... */
3405 #endif
3407 #if defined(PATH_MAX)
3408 # define LT_PATHMAX PATH_MAX
3409 #elif defined(MAXPATHLEN)
3410 # define LT_PATHMAX MAXPATHLEN
3411 #else
3412 # define LT_PATHMAX 1024
3413 #endif
3415 #ifndef S_IXOTH
3416 # define S_IXOTH 0
3417 #endif
3418 #ifndef S_IXGRP
3419 # define S_IXGRP 0
3420 #endif
3422 /* path handling portability macros */
3423 #ifndef DIR_SEPARATOR
3424 # define DIR_SEPARATOR '/'
3425 # define PATH_SEPARATOR ':'
3426 #endif
3428 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3429 defined (__OS2__)
3430 # define HAVE_DOS_BASED_FILE_SYSTEM
3431 # define FOPEN_WB "wb"
3432 # ifndef DIR_SEPARATOR_2
3433 # define DIR_SEPARATOR_2 '\\'
3434 # endif
3435 # ifndef PATH_SEPARATOR_2
3436 # define PATH_SEPARATOR_2 ';'
3437 # endif
3438 #endif
3440 #ifndef DIR_SEPARATOR_2
3441 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3442 #else /* DIR_SEPARATOR_2 */
3443 # define IS_DIR_SEPARATOR(ch) \
3444 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3445 #endif /* DIR_SEPARATOR_2 */
3447 #ifndef PATH_SEPARATOR_2
3448 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3449 #else /* PATH_SEPARATOR_2 */
3450 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3451 #endif /* PATH_SEPARATOR_2 */
3453 #ifndef FOPEN_WB
3454 # define FOPEN_WB "w"
3455 #endif
3456 #ifndef _O_BINARY
3457 # define _O_BINARY 0
3458 #endif
3460 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3461 #define XFREE(stale) do { \
3462 if (stale) { free ((void *) stale); stale = 0; } \
3463 } while (0)
3465 #undef LTWRAPPER_DEBUGPRINTF
3466 #if defined LT_DEBUGWRAPPER
3467 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3468 static void
3469 ltwrapper_debugprintf (const char *fmt, ...)
3471 va_list args;
3472 va_start (args, fmt);
3473 (void) vfprintf (stderr, fmt, args);
3474 va_end (args);
3476 #else
3477 # define LTWRAPPER_DEBUGPRINTF(args)
3478 #endif
3480 const char *program_name = NULL;
3482 void *xmalloc (size_t num);
3483 char *xstrdup (const char *string);
3484 const char *base_name (const char *name);
3485 char *find_executable (const char *wrapper);
3486 char *chase_symlinks (const char *pathspec);
3487 int make_executable (const char *path);
3488 int check_executable (const char *path);
3489 char *strendzap (char *str, const char *pat);
3490 void lt_fatal (const char *message, ...);
3491 void lt_setenv (const char *name, const char *value);
3492 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3493 void lt_update_exe_path (const char *name, const char *value);
3494 void lt_update_lib_path (const char *name, const char *value);
3495 char **prepare_spawn (char **argv);
3496 void lt_dump_script (FILE *f);
3499 cat <<EOF
3500 const char * MAGIC_EXE = "$magic_exe";
3501 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3504 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3505 func_to_host_pathlist "$temp_rpath"
3506 cat <<EOF
3507 const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3509 else
3510 cat <<"EOF"
3511 const char * LIB_PATH_VALUE = "";
3515 if test -n "$dllsearchpath"; then
3516 func_to_host_pathlist "$dllsearchpath:"
3517 cat <<EOF
3518 const char * EXE_PATH_VARNAME = "PATH";
3519 const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3521 else
3522 cat <<"EOF"
3523 const char * EXE_PATH_VARNAME = "";
3524 const char * EXE_PATH_VALUE = "";
3528 if test "$fast_install" = yes; then
3529 cat <<EOF
3530 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3532 else
3533 cat <<EOF
3534 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3539 cat <<"EOF"
3541 #define LTWRAPPER_OPTION_PREFIX "--lt-"
3542 #define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3544 static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3545 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3547 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3550 main (int argc, char *argv[])
3552 char **newargz;
3553 int newargc;
3554 char *tmp_pathspec;
3555 char *actual_cwrapper_path;
3556 char *actual_cwrapper_name;
3557 char *target_name;
3558 char *lt_argv_zero;
3559 intptr_t rval = 127;
3561 int i;
3563 program_name = (char *) xstrdup (base_name (argv[0]));
3564 LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3565 LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3567 /* very simple arg parsing; don't want to rely on getopt */
3568 for (i = 1; i < argc; i++)
3570 if (strcmp (argv[i], dumpscript_opt) == 0)
3573 case "$host" in
3574 *mingw* | *cygwin* )
3575 # make stdout use "unix" line endings
3576 echo " setmode(1,_O_BINARY);"
3578 esac
3580 cat <<"EOF"
3581 lt_dump_script (stdout);
3582 return 0;
3586 newargz = XMALLOC (char *, argc + 1);
3587 tmp_pathspec = find_executable (argv[0]);
3588 if (tmp_pathspec == NULL)
3589 lt_fatal ("Couldn't find %s", argv[0]);
3590 LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3591 tmp_pathspec));
3593 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3594 LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3595 actual_cwrapper_path));
3596 XFREE (tmp_pathspec);
3598 actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3599 strendzap (actual_cwrapper_path, actual_cwrapper_name);
3601 /* wrapper name transforms */
3602 strendzap (actual_cwrapper_name, ".exe");
3603 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3604 XFREE (actual_cwrapper_name);
3605 actual_cwrapper_name = tmp_pathspec;
3606 tmp_pathspec = 0;
3608 /* target_name transforms -- use actual target program name; might have lt- prefix */
3609 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3610 strendzap (target_name, ".exe");
3611 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3612 XFREE (target_name);
3613 target_name = tmp_pathspec;
3614 tmp_pathspec = 0;
3616 LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3617 target_name));
3620 cat <<EOF
3621 newargz[0] =
3622 XMALLOC (char, (strlen (actual_cwrapper_path) +
3623 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3624 strcpy (newargz[0], actual_cwrapper_path);
3625 strcat (newargz[0], "$objdir");
3626 strcat (newargz[0], "/");
3629 cat <<"EOF"
3630 /* stop here, and copy so we don't have to do this twice */
3631 tmp_pathspec = xstrdup (newargz[0]);
3633 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3634 strcat (newargz[0], actual_cwrapper_name);
3636 /* DO want the lt- prefix here if it exists, so use target_name */
3637 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3638 XFREE (tmp_pathspec);
3639 tmp_pathspec = NULL;
3642 case $host_os in
3643 mingw*)
3644 cat <<"EOF"
3646 char* p;
3647 while ((p = strchr (newargz[0], '\\')) != NULL)
3649 *p = '/';
3651 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3653 *p = '/';
3658 esac
3660 cat <<"EOF"
3661 XFREE (target_name);
3662 XFREE (actual_cwrapper_path);
3663 XFREE (actual_cwrapper_name);
3665 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3666 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3667 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3668 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3670 newargc=0;
3671 for (i = 1; i < argc; i++)
3673 if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3675 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3676 namespace, but it is not one of the ones we know about and
3677 have already dealt with, above (inluding dump-script), then
3678 report an error. Otherwise, targets might begin to believe
3679 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3680 namespace. The first time any user complains about this, we'll
3681 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3682 or a configure.ac-settable value.
3684 lt_fatal ("Unrecognized option in %s namespace: '%s'",
3685 ltwrapper_option_prefix, argv[i]);
3687 /* otherwise ... */
3688 newargz[++newargc] = xstrdup (argv[i]);
3690 newargz[++newargc] = NULL;
3692 LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3693 for (i = 0; i < newargc; i++)
3695 LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3700 case $host_os in
3701 mingw*)
3702 cat <<"EOF"
3703 /* execv doesn't actually work on mingw as expected on unix */
3704 newargz = prepare_spawn (newargz);
3705 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3706 if (rval == -1)
3708 /* failed to start process */
3709 LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3710 return 127;
3712 return rval;
3716 cat <<"EOF"
3717 execv (lt_argv_zero, newargz);
3718 return rval; /* =127, but avoids unused variable warning */
3721 esac
3723 cat <<"EOF"
3726 void *
3727 xmalloc (size_t num)
3729 void *p = (void *) malloc (num);
3730 if (!p)
3731 lt_fatal ("Memory exhausted");
3733 return p;
3736 char *
3737 xstrdup (const char *string)
3739 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3740 string) : NULL;
3743 const char *
3744 base_name (const char *name)
3746 const char *base;
3748 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3749 /* Skip over the disk name in MSDOS pathnames. */
3750 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3751 name += 2;
3752 #endif
3754 for (base = name; *name; name++)
3755 if (IS_DIR_SEPARATOR (*name))
3756 base = name + 1;
3757 return base;
3761 check_executable (const char *path)
3763 struct stat st;
3765 LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3766 path ? (*path ? path : "EMPTY!") : "NULL!"));
3767 if ((!path) || (!*path))
3768 return 0;
3770 if ((stat (path, &st) >= 0)
3771 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3772 return 1;
3773 else
3774 return 0;
3778 make_executable (const char *path)
3780 int rval = 0;
3781 struct stat st;
3783 LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3784 path ? (*path ? path : "EMPTY!") : "NULL!"));
3785 if ((!path) || (!*path))
3786 return 0;
3788 if (stat (path, &st) >= 0)
3790 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3792 return rval;
3795 /* Searches for the full path of the wrapper. Returns
3796 newly allocated full path name if found, NULL otherwise
3797 Does not chase symlinks, even on platforms that support them.
3799 char *
3800 find_executable (const char *wrapper)
3802 int has_slash = 0;
3803 const char *p;
3804 const char *p_next;
3805 /* static buffer for getcwd */
3806 char tmp[LT_PATHMAX + 1];
3807 int tmp_len;
3808 char *concat_name;
3810 LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3811 wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3813 if ((wrapper == NULL) || (*wrapper == '\0'))
3814 return NULL;
3816 /* Absolute path? */
3817 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3818 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3820 concat_name = xstrdup (wrapper);
3821 if (check_executable (concat_name))
3822 return concat_name;
3823 XFREE (concat_name);
3825 else
3827 #endif
3828 if (IS_DIR_SEPARATOR (wrapper[0]))
3830 concat_name = xstrdup (wrapper);
3831 if (check_executable (concat_name))
3832 return concat_name;
3833 XFREE (concat_name);
3835 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3837 #endif
3839 for (p = wrapper; *p; p++)
3840 if (*p == '/')
3842 has_slash = 1;
3843 break;
3845 if (!has_slash)
3847 /* no slashes; search PATH */
3848 const char *path = getenv ("PATH");
3849 if (path != NULL)
3851 for (p = path; *p; p = p_next)
3853 const char *q;
3854 size_t p_len;
3855 for (q = p; *q; q++)
3856 if (IS_PATH_SEPARATOR (*q))
3857 break;
3858 p_len = q - p;
3859 p_next = (*q == '\0' ? q : q + 1);
3860 if (p_len == 0)
3862 /* empty path: current directory */
3863 if (getcwd (tmp, LT_PATHMAX) == NULL)
3864 lt_fatal ("getcwd failed");
3865 tmp_len = strlen (tmp);
3866 concat_name =
3867 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3868 memcpy (concat_name, tmp, tmp_len);
3869 concat_name[tmp_len] = '/';
3870 strcpy (concat_name + tmp_len + 1, wrapper);
3872 else
3874 concat_name =
3875 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3876 memcpy (concat_name, p, p_len);
3877 concat_name[p_len] = '/';
3878 strcpy (concat_name + p_len + 1, wrapper);
3880 if (check_executable (concat_name))
3881 return concat_name;
3882 XFREE (concat_name);
3885 /* not found in PATH; assume curdir */
3887 /* Relative path | not found in path: prepend cwd */
3888 if (getcwd (tmp, LT_PATHMAX) == NULL)
3889 lt_fatal ("getcwd failed");
3890 tmp_len = strlen (tmp);
3891 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3892 memcpy (concat_name, tmp, tmp_len);
3893 concat_name[tmp_len] = '/';
3894 strcpy (concat_name + tmp_len + 1, wrapper);
3896 if (check_executable (concat_name))
3897 return concat_name;
3898 XFREE (concat_name);
3899 return NULL;
3902 char *
3903 chase_symlinks (const char *pathspec)
3905 #ifndef S_ISLNK
3906 return xstrdup (pathspec);
3907 #else
3908 char buf[LT_PATHMAX];
3909 struct stat s;
3910 char *tmp_pathspec = xstrdup (pathspec);
3911 char *p;
3912 int has_symlinks = 0;
3913 while (strlen (tmp_pathspec) && !has_symlinks)
3915 LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3916 tmp_pathspec));
3917 if (lstat (tmp_pathspec, &s) == 0)
3919 if (S_ISLNK (s.st_mode) != 0)
3921 has_symlinks = 1;
3922 break;
3925 /* search backwards for last DIR_SEPARATOR */
3926 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3927 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3928 p--;
3929 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3931 /* no more DIR_SEPARATORS left */
3932 break;
3934 *p = '\0';
3936 else
3938 char *errstr = strerror (errno);
3939 lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3942 XFREE (tmp_pathspec);
3944 if (!has_symlinks)
3946 return xstrdup (pathspec);
3949 tmp_pathspec = realpath (pathspec, buf);
3950 if (tmp_pathspec == 0)
3952 lt_fatal ("Could not follow symlinks for %s", pathspec);
3954 return xstrdup (tmp_pathspec);
3955 #endif
3958 char *
3959 strendzap (char *str, const char *pat)
3961 size_t len, patlen;
3963 assert (str != NULL);
3964 assert (pat != NULL);
3966 len = strlen (str);
3967 patlen = strlen (pat);
3969 if (patlen <= len)
3971 str += len - patlen;
3972 if (strcmp (str, pat) == 0)
3973 *str = '\0';
3975 return str;
3978 static void
3979 lt_error_core (int exit_status, const char *mode,
3980 const char *message, va_list ap)
3982 fprintf (stderr, "%s: %s: ", program_name, mode);
3983 vfprintf (stderr, message, ap);
3984 fprintf (stderr, ".\n");
3986 if (exit_status >= 0)
3987 exit (exit_status);
3990 void
3991 lt_fatal (const char *message, ...)
3993 va_list ap;
3994 va_start (ap, message);
3995 lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3996 va_end (ap);
3999 void
4000 lt_setenv (const char *name, const char *value)
4002 LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4003 (name ? name : "<NULL>"),
4004 (value ? value : "<NULL>")));
4006 #ifdef HAVE_SETENV
4007 /* always make a copy, for consistency with !HAVE_SETENV */
4008 char *str = xstrdup (value);
4009 setenv (name, str, 1);
4010 #else
4011 int len = strlen (name) + 1 + strlen (value) + 1;
4012 char *str = XMALLOC (char, len);
4013 sprintf (str, "%s=%s", name, value);
4014 if (putenv (str) != EXIT_SUCCESS)
4016 XFREE (str);
4018 #endif
4022 char *
4023 lt_extend_str (const char *orig_value, const char *add, int to_end)
4025 char *new_value;
4026 if (orig_value && *orig_value)
4028 int orig_value_len = strlen (orig_value);
4029 int add_len = strlen (add);
4030 new_value = XMALLOC (char, add_len + orig_value_len + 1);
4031 if (to_end)
4033 strcpy (new_value, orig_value);
4034 strcpy (new_value + orig_value_len, add);
4036 else
4038 strcpy (new_value, add);
4039 strcpy (new_value + add_len, orig_value);
4042 else
4044 new_value = xstrdup (add);
4046 return new_value;
4049 void
4050 lt_update_exe_path (const char *name, const char *value)
4052 LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4053 (name ? name : "<NULL>"),
4054 (value ? value : "<NULL>")));
4056 if (name && *name && value && *value)
4058 char *new_value = lt_extend_str (getenv (name), value, 0);
4059 /* some systems can't cope with a ':'-terminated path #' */
4060 int len = strlen (new_value);
4061 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4063 new_value[len-1] = '\0';
4065 lt_setenv (name, new_value);
4066 XFREE (new_value);
4070 void
4071 lt_update_lib_path (const char *name, const char *value)
4073 LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4074 (name ? name : "<NULL>"),
4075 (value ? value : "<NULL>")));
4077 if (name && *name && value && *value)
4079 char *new_value = lt_extend_str (getenv (name), value, 0);
4080 lt_setenv (name, new_value);
4081 XFREE (new_value);
4086 case $host_os in
4087 mingw*)
4088 cat <<"EOF"
4090 /* Prepares an argument vector before calling spawn().
4091 Note that spawn() does not by itself call the command interpreter
4092 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4093 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4094 GetVersionEx(&v);
4095 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4096 }) ? "cmd.exe" : "command.com").
4097 Instead it simply concatenates the arguments, separated by ' ', and calls
4098 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4099 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4100 special way:
4101 - Space and tab are interpreted as delimiters. They are not treated as
4102 delimiters if they are surrounded by double quotes: "...".
4103 - Unescaped double quotes are removed from the input. Their only effect is
4104 that within double quotes, space and tab are treated like normal
4105 characters.
4106 - Backslashes not followed by double quotes are not special.
4107 - But 2*n+1 backslashes followed by a double quote become
4108 n backslashes followed by a double quote (n >= 0):
4109 \" -> "
4110 \\\" -> \"
4111 \\\\\" -> \\"
4113 #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"
4114 #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"
4115 char **
4116 prepare_spawn (char **argv)
4118 size_t argc;
4119 char **new_argv;
4120 size_t i;
4122 /* Count number of arguments. */
4123 for (argc = 0; argv[argc] != NULL; argc++)
4126 /* Allocate new argument vector. */
4127 new_argv = XMALLOC (char *, argc + 1);
4129 /* Put quoted arguments into the new argument vector. */
4130 for (i = 0; i < argc; i++)
4132 const char *string = argv[i];
4134 if (string[0] == '\0')
4135 new_argv[i] = xstrdup ("\"\"");
4136 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4138 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4139 size_t length;
4140 unsigned int backslashes;
4141 const char *s;
4142 char *quoted_string;
4143 char *p;
4145 length = 0;
4146 backslashes = 0;
4147 if (quote_around)
4148 length++;
4149 for (s = string; *s != '\0'; s++)
4151 char c = *s;
4152 if (c == '"')
4153 length += backslashes + 1;
4154 length++;
4155 if (c == '\\')
4156 backslashes++;
4157 else
4158 backslashes = 0;
4160 if (quote_around)
4161 length += backslashes + 1;
4163 quoted_string = XMALLOC (char, length + 1);
4165 p = quoted_string;
4166 backslashes = 0;
4167 if (quote_around)
4168 *p++ = '"';
4169 for (s = string; *s != '\0'; s++)
4171 char c = *s;
4172 if (c == '"')
4174 unsigned int j;
4175 for (j = backslashes + 1; j > 0; j--)
4176 *p++ = '\\';
4178 *p++ = c;
4179 if (c == '\\')
4180 backslashes++;
4181 else
4182 backslashes = 0;
4184 if (quote_around)
4186 unsigned int j;
4187 for (j = backslashes; j > 0; j--)
4188 *p++ = '\\';
4189 *p++ = '"';
4191 *p = '\0';
4193 new_argv[i] = quoted_string;
4195 else
4196 new_argv[i] = (char *) string;
4198 new_argv[argc] = NULL;
4200 return new_argv;
4204 esac
4206 cat <<"EOF"
4207 void lt_dump_script (FILE* f)
4210 func_emit_wrapper yes |
4211 $SED -e 's/\([\\"]\)/\\\1/g' \
4212 -e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
4214 cat <<"EOF"
4218 # end: func_emit_cwrapperexe_src
4220 # func_win32_import_lib_p ARG
4221 # True if ARG is an import lib, as indicated by $file_magic_cmd
4222 func_win32_import_lib_p ()
4224 $opt_debug
4225 case `eval "$file_magic_cmd \"\$1\" 2>/dev/null" | $SED -e 10q` in
4226 *import*) : ;;
4227 *) false ;;
4228 esac
4231 # func_mode_link arg...
4232 func_mode_link ()
4234 $opt_debug
4235 case $host in
4236 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4237 # It is impossible to link a dll without this setting, and
4238 # we shouldn't force the makefile maintainer to figure out
4239 # which system we are compiling for in order to pass an extra
4240 # flag for every libtool invocation.
4241 # allow_undefined=no
4243 # FIXME: Unfortunately, there are problems with the above when trying
4244 # to make a dll which has undefined symbols, in which case not
4245 # even a static library is built. For now, we need to specify
4246 # -no-undefined on the libtool link line when we can be certain
4247 # that all symbols are satisfied, otherwise we get a static library.
4248 allow_undefined=yes
4251 allow_undefined=yes
4253 esac
4254 libtool_args=$nonopt
4255 base_compile="$nonopt $@"
4256 compile_command=$nonopt
4257 finalize_command=$nonopt
4259 compile_rpath=
4260 finalize_rpath=
4261 compile_shlibpath=
4262 finalize_shlibpath=
4263 convenience=
4264 old_convenience=
4265 deplibs=
4266 old_deplibs=
4267 compiler_flags=
4268 linker_flags=
4269 dllsearchpath=
4270 lib_search_path=`pwd`
4271 inst_prefix_dir=
4272 new_inherited_linker_flags=
4274 avoid_version=no
4275 bindir=
4276 dlfiles=
4277 dlprefiles=
4278 dlself=no
4279 export_dynamic=no
4280 export_symbols=
4281 export_symbols_regex=
4282 generated=
4283 libobjs=
4284 ltlibs=
4285 module=no
4286 no_install=no
4287 objs=
4288 non_pic_objects=
4289 precious_files_regex=
4290 prefer_static_libs=no
4291 preload=no
4292 prev=
4293 prevarg=
4294 release=
4295 rpath=
4296 xrpath=
4297 perm_rpath=
4298 temp_rpath=
4299 thread_safe=no
4300 vinfo=
4301 vinfo_number=no
4302 weak_libs=
4303 single_module="${wl}-single_module"
4304 func_infer_tag $base_compile
4306 # We need to know -static, to get the right output filenames.
4307 for arg
4309 case $arg in
4310 -shared)
4311 test "$build_libtool_libs" != yes && \
4312 func_fatal_configuration "can not build a shared library"
4313 build_old_libs=no
4314 break
4316 -all-static | -static | -static-libtool-libs)
4317 case $arg in
4318 -all-static)
4319 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4320 func_warning "complete static linking is impossible in this configuration"
4322 if test -n "$link_static_flag"; then
4323 dlopen_self=$dlopen_self_static
4325 prefer_static_libs=yes
4327 -static)
4328 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4329 dlopen_self=$dlopen_self_static
4331 prefer_static_libs=built
4333 -static-libtool-libs)
4334 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4335 dlopen_self=$dlopen_self_static
4337 prefer_static_libs=yes
4339 esac
4340 build_libtool_libs=no
4341 build_old_libs=yes
4342 break
4344 esac
4345 done
4347 # See if our shared archives depend on static archives.
4348 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4350 # Go through the arguments, transforming them on the way.
4351 while test "$#" -gt 0; do
4352 arg="$1"
4353 shift
4354 func_quote_for_eval "$arg"
4355 qarg=$func_quote_for_eval_unquoted_result
4356 func_append libtool_args " $func_quote_for_eval_result"
4358 # If the previous option needs an argument, assign it.
4359 if test -n "$prev"; then
4360 case $prev in
4361 output)
4362 func_append compile_command " @OUTPUT@"
4363 func_append finalize_command " @OUTPUT@"
4365 esac
4367 case $prev in
4368 bindir)
4369 bindir="$arg"
4370 prev=
4371 continue
4373 dlfiles|dlprefiles)
4374 if test "$preload" = no; then
4375 # Add the symbol object into the linking commands.
4376 func_append compile_command " @SYMFILE@"
4377 func_append finalize_command " @SYMFILE@"
4378 preload=yes
4380 case $arg in
4381 *.la | *.lo) ;; # We handle these cases below.
4382 force)
4383 if test "$dlself" = no; then
4384 dlself=needless
4385 export_dynamic=yes
4387 prev=
4388 continue
4390 self)
4391 if test "$prev" = dlprefiles; then
4392 dlself=yes
4393 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4394 dlself=yes
4395 else
4396 dlself=needless
4397 export_dynamic=yes
4399 prev=
4400 continue
4403 if test "$prev" = dlfiles; then
4404 dlfiles="$dlfiles $arg"
4405 else
4406 dlprefiles="$dlprefiles $arg"
4408 prev=
4409 continue
4411 esac
4413 expsyms)
4414 export_symbols="$arg"
4415 test -f "$arg" \
4416 || func_fatal_error "symbol file \`$arg' does not exist"
4417 prev=
4418 continue
4420 expsyms_regex)
4421 export_symbols_regex="$arg"
4422 prev=
4423 continue
4425 framework)
4426 case $host in
4427 *-*-darwin*)
4428 case "$deplibs " in
4429 *" $qarg.ltframework "*) ;;
4430 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4432 esac
4434 esac
4435 prev=
4436 continue
4438 inst_prefix)
4439 inst_prefix_dir="$arg"
4440 prev=
4441 continue
4443 objectlist)
4444 if test -f "$arg"; then
4445 save_arg=$arg
4446 moreargs=
4447 for fil in `cat "$save_arg"`
4449 # moreargs="$moreargs $fil"
4450 arg=$fil
4451 # A libtool-controlled object.
4453 # Check to see that this really is a libtool object.
4454 if func_lalib_unsafe_p "$arg"; then
4455 pic_object=
4456 non_pic_object=
4458 # Read the .lo file
4459 func_source "$arg"
4461 if test -z "$pic_object" ||
4462 test -z "$non_pic_object" ||
4463 test "$pic_object" = none &&
4464 test "$non_pic_object" = none; then
4465 func_fatal_error "cannot find name of object for \`$arg'"
4468 # Extract subdirectory from the argument.
4469 func_dirname "$arg" "/" ""
4470 xdir="$func_dirname_result"
4472 if test "$pic_object" != none; then
4473 # Prepend the subdirectory the object is found in.
4474 pic_object="$xdir$pic_object"
4476 if test "$prev" = dlfiles; then
4477 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4478 dlfiles="$dlfiles $pic_object"
4479 prev=
4480 continue
4481 else
4482 # If libtool objects are unsupported, then we need to preload.
4483 prev=dlprefiles
4487 # CHECK ME: I think I busted this. -Ossama
4488 if test "$prev" = dlprefiles; then
4489 # Preload the old-style object.
4490 dlprefiles="$dlprefiles $pic_object"
4491 prev=
4494 # A PIC object.
4495 func_append libobjs " $pic_object"
4496 arg="$pic_object"
4499 # Non-PIC object.
4500 if test "$non_pic_object" != none; then
4501 # Prepend the subdirectory the object is found in.
4502 non_pic_object="$xdir$non_pic_object"
4504 # A standard non-PIC object
4505 func_append non_pic_objects " $non_pic_object"
4506 if test -z "$pic_object" || test "$pic_object" = none ; then
4507 arg="$non_pic_object"
4509 else
4510 # If the PIC object exists, use it instead.
4511 # $xdir was prepended to $pic_object above.
4512 non_pic_object="$pic_object"
4513 func_append non_pic_objects " $non_pic_object"
4515 else
4516 # Only an error if not doing a dry-run.
4517 if $opt_dry_run; then
4518 # Extract subdirectory from the argument.
4519 func_dirname "$arg" "/" ""
4520 xdir="$func_dirname_result"
4522 func_lo2o "$arg"
4523 pic_object=$xdir$objdir/$func_lo2o_result
4524 non_pic_object=$xdir$func_lo2o_result
4525 func_append libobjs " $pic_object"
4526 func_append non_pic_objects " $non_pic_object"
4527 else
4528 func_fatal_error "\`$arg' is not a valid libtool object"
4531 done
4532 else
4533 func_fatal_error "link input file \`$arg' does not exist"
4535 arg=$save_arg
4536 prev=
4537 continue
4539 precious_regex)
4540 precious_files_regex="$arg"
4541 prev=
4542 continue
4544 release)
4545 release="-$arg"
4546 prev=
4547 continue
4549 rpath | xrpath)
4550 # We need an absolute path.
4551 case $arg in
4552 [\\/]* | [A-Za-z]:[\\/]*) ;;
4554 func_fatal_error "only absolute run-paths are allowed"
4556 esac
4557 if test "$prev" = rpath; then
4558 case "$rpath " in
4559 *" $arg "*) ;;
4560 *) rpath="$rpath $arg" ;;
4561 esac
4562 else
4563 case "$xrpath " in
4564 *" $arg "*) ;;
4565 *) xrpath="$xrpath $arg" ;;
4566 esac
4568 prev=
4569 continue
4571 shrext)
4572 shrext_cmds="$arg"
4573 prev=
4574 continue
4576 weak)
4577 weak_libs="$weak_libs $arg"
4578 prev=
4579 continue
4581 xcclinker)
4582 linker_flags="$linker_flags $qarg"
4583 compiler_flags="$compiler_flags $qarg"
4584 prev=
4585 func_append compile_command " $qarg"
4586 func_append finalize_command " $qarg"
4587 continue
4589 xcompiler)
4590 compiler_flags="$compiler_flags $qarg"
4591 prev=
4592 func_append compile_command " $qarg"
4593 func_append finalize_command " $qarg"
4594 continue
4596 xlinker)
4597 linker_flags="$linker_flags $qarg"
4598 compiler_flags="$compiler_flags $wl$qarg"
4599 prev=
4600 func_append compile_command " $wl$qarg"
4601 func_append finalize_command " $wl$qarg"
4602 continue
4605 eval "$prev=\"\$arg\""
4606 prev=
4607 continue
4609 esac
4610 fi # test -n "$prev"
4612 prevarg="$arg"
4614 case $arg in
4615 -all-static)
4616 if test -n "$link_static_flag"; then
4617 # See comment for -static flag below, for more details.
4618 func_append compile_command " $link_static_flag"
4619 func_append finalize_command " $link_static_flag"
4621 continue
4624 -allow-undefined)
4625 # FIXME: remove this flag sometime in the future.
4626 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4629 -avoid-version)
4630 avoid_version=yes
4631 continue
4634 -bindir)
4635 prev=bindir
4636 continue
4639 -dlopen)
4640 prev=dlfiles
4641 continue
4644 -dlpreopen)
4645 prev=dlprefiles
4646 continue
4649 -export-dynamic)
4650 export_dynamic=yes
4651 continue
4654 -export-symbols | -export-symbols-regex)
4655 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4656 func_fatal_error "more than one -exported-symbols argument is not allowed"
4658 if test "X$arg" = "X-export-symbols"; then
4659 prev=expsyms
4660 else
4661 prev=expsyms_regex
4663 continue
4666 -framework)
4667 prev=framework
4668 continue
4671 -inst-prefix-dir)
4672 prev=inst_prefix
4673 continue
4676 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4677 # so, if we see these flags be careful not to treat them like -L
4678 -L[A-Z][A-Z]*:*)
4679 case $with_gcc/$host in
4680 no/*-*-irix* | /*-*-irix*)
4681 func_append compile_command " $arg"
4682 func_append finalize_command " $arg"
4684 esac
4685 continue
4688 -L*)
4689 func_stripname '-L' '' "$arg"
4690 dir=$func_stripname_result
4691 if test -z "$dir"; then
4692 if test "$#" -gt 0; then
4693 func_fatal_error "require no space between \`-L' and \`$1'"
4694 else
4695 func_fatal_error "need path for \`-L' option"
4698 # We need an absolute path.
4699 case $dir in
4700 [\\/]* | [A-Za-z]:[\\/]*) ;;
4702 absdir=`cd "$dir" && pwd`
4703 test -z "$absdir" && \
4704 func_fatal_error "cannot determine absolute directory name of \`$dir'"
4705 dir="$absdir"
4707 esac
4708 case "$deplibs " in
4709 *" -L$dir "*) ;;
4711 deplibs="$deplibs -L$dir"
4712 lib_search_path="$lib_search_path $dir"
4714 esac
4715 case $host in
4716 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4717 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4718 case :$dllsearchpath: in
4719 *":$dir:"*) ;;
4720 ::) dllsearchpath=$dir;;
4721 *) dllsearchpath="$dllsearchpath:$dir";;
4722 esac
4723 case :$dllsearchpath: in
4724 *":$testbindir:"*) ;;
4725 ::) dllsearchpath=$testbindir;;
4726 *) dllsearchpath="$dllsearchpath:$testbindir";;
4727 esac
4729 esac
4730 continue
4733 -l*)
4734 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4735 case $host in
4736 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4737 # These systems don't actually have a C or math library (as such)
4738 continue
4740 *-*-os2*)
4741 # These systems don't actually have a C library (as such)
4742 test "X$arg" = "X-lc" && continue
4744 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4745 # Do not include libc due to us having libc/libc_r.
4746 test "X$arg" = "X-lc" && continue
4748 *-*-rhapsody* | *-*-darwin1.[012])
4749 # Rhapsody C and math libraries are in the System framework
4750 deplibs="$deplibs System.ltframework"
4751 continue
4753 *-*-sco3.2v5* | *-*-sco5v6*)
4754 # Causes problems with __ctype
4755 test "X$arg" = "X-lc" && continue
4757 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4758 # Compiler inserts libc in the correct place for threads to work
4759 test "X$arg" = "X-lc" && continue
4761 *-*-linux*)
4762 test "X$arg" = "X-lc" && continue
4764 esac
4765 elif test "X$arg" = "X-lc_r"; then
4766 case $host in
4767 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4768 # Do not include libc_r directly, use -pthread flag.
4769 continue
4771 esac
4773 deplibs="$deplibs $arg"
4774 continue
4777 -module)
4778 module=yes
4779 continue
4782 # Tru64 UNIX uses -model [arg] to determine the layout of C++
4783 # classes, name mangling, and exception handling.
4784 # Darwin uses the -arch flag to determine output architecture.
4785 -model|-arch|-isysroot)
4786 compiler_flags="$compiler_flags $arg"
4787 func_append compile_command " $arg"
4788 func_append finalize_command " $arg"
4789 prev=xcompiler
4790 continue
4793 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4794 compiler_flags="$compiler_flags $arg"
4795 func_append compile_command " $arg"
4796 func_append finalize_command " $arg"
4797 case "$new_inherited_linker_flags " in
4798 *" $arg "*) ;;
4799 * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4800 esac
4801 continue
4804 -multi_module)
4805 single_module="${wl}-multi_module"
4806 continue
4809 -no-fast-install)
4810 fast_install=no
4811 continue
4814 -no-install)
4815 case $host in
4816 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4817 # The PATH hackery in wrapper scripts is required on Windows
4818 # and Darwin in order for the loader to find any dlls it needs.
4819 func_warning "\`-no-install' is ignored for $host"
4820 func_warning "assuming \`-no-fast-install' instead"
4821 fast_install=no
4823 *) no_install=yes ;;
4824 esac
4825 continue
4828 -no-undefined)
4829 allow_undefined=no
4830 continue
4833 -objectlist)
4834 prev=objectlist
4835 continue
4838 -o) prev=output ;;
4840 -precious-files-regex)
4841 prev=precious_regex
4842 continue
4845 -release)
4846 prev=release
4847 continue
4850 -rpath)
4851 prev=rpath
4852 continue
4856 prev=xrpath
4857 continue
4860 -R*)
4861 func_stripname '-R' '' "$arg"
4862 dir=$func_stripname_result
4863 # We need an absolute path.
4864 case $dir in
4865 [\\/]* | [A-Za-z]:[\\/]*) ;;
4867 func_fatal_error "only absolute run-paths are allowed"
4869 esac
4870 case "$xrpath " in
4871 *" $dir "*) ;;
4872 *) xrpath="$xrpath $dir" ;;
4873 esac
4874 continue
4877 -shared)
4878 # The effects of -shared are defined in a previous loop.
4879 continue
4882 -shrext)
4883 prev=shrext
4884 continue
4887 -static | -static-libtool-libs)
4888 # The effects of -static are defined in a previous loop.
4889 # We used to do the same as -all-static on platforms that
4890 # didn't have a PIC flag, but the assumption that the effects
4891 # would be equivalent was wrong. It would break on at least
4892 # Digital Unix and AIX.
4893 continue
4896 -thread-safe)
4897 thread_safe=yes
4898 continue
4901 -version-info)
4902 prev=vinfo
4903 continue
4906 -version-number)
4907 prev=vinfo
4908 vinfo_number=yes
4909 continue
4912 -weak)
4913 prev=weak
4914 continue
4917 -Wc,*)
4918 func_stripname '-Wc,' '' "$arg"
4919 args=$func_stripname_result
4920 arg=
4921 save_ifs="$IFS"; IFS=','
4922 for flag in $args; do
4923 IFS="$save_ifs"
4924 func_quote_for_eval "$flag"
4925 arg="$arg $func_quote_for_eval_result"
4926 compiler_flags="$compiler_flags $func_quote_for_eval_result"
4927 done
4928 IFS="$save_ifs"
4929 func_stripname ' ' '' "$arg"
4930 arg=$func_stripname_result
4933 -Wl,*)
4934 func_stripname '-Wl,' '' "$arg"
4935 args=$func_stripname_result
4936 arg=
4937 save_ifs="$IFS"; IFS=','
4938 for flag in $args; do
4939 IFS="$save_ifs"
4940 func_quote_for_eval "$flag"
4941 arg="$arg $wl$func_quote_for_eval_result"
4942 compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4943 linker_flags="$linker_flags $func_quote_for_eval_result"
4944 done
4945 IFS="$save_ifs"
4946 func_stripname ' ' '' "$arg"
4947 arg=$func_stripname_result
4950 -Xcompiler)
4951 prev=xcompiler
4952 continue
4955 -Xlinker)
4956 prev=xlinker
4957 continue
4960 -XCClinker)
4961 prev=xcclinker
4962 continue
4965 # -msg_* for osf cc
4966 -msg_*)
4967 func_quote_for_eval "$arg"
4968 arg="$func_quote_for_eval_result"
4971 # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4972 # -r[0-9][0-9]* specifies the processor on the SGI compiler
4973 # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4974 # +DA*, +DD* enable 64-bit mode on the HP compiler
4975 # -q* pass through compiler args for the IBM compiler
4976 # -m*, -t[45]*, -txscale* pass through architecture-specific
4977 # compiler args for GCC
4978 # -F/path gives path to uninstalled frameworks, gcc on darwin
4979 # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4980 # @file GCC response files
4981 # -tp=* Portland pgcc target processor selection
4982 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4983 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
4984 func_quote_for_eval "$arg"
4985 arg="$func_quote_for_eval_result"
4986 func_append compile_command " $arg"
4987 func_append finalize_command " $arg"
4988 compiler_flags="$compiler_flags $arg"
4989 continue
4992 # Some other compiler flag.
4993 -* | +*)
4994 func_quote_for_eval "$arg"
4995 arg="$func_quote_for_eval_result"
4998 *.$objext)
4999 # A standard object.
5000 objs="$objs $arg"
5003 *.lo)
5004 # A libtool-controlled object.
5006 # Check to see that this really is a libtool object.
5007 if func_lalib_unsafe_p "$arg"; then
5008 pic_object=
5009 non_pic_object=
5011 # Read the .lo file
5012 func_source "$arg"
5014 if test -z "$pic_object" ||
5015 test -z "$non_pic_object" ||
5016 test "$pic_object" = none &&
5017 test "$non_pic_object" = none; then
5018 func_fatal_error "cannot find name of object for \`$arg'"
5021 # Extract subdirectory from the argument.
5022 func_dirname "$arg" "/" ""
5023 xdir="$func_dirname_result"
5025 if test "$pic_object" != none; then
5026 # Prepend the subdirectory the object is found in.
5027 pic_object="$xdir$pic_object"
5029 if test "$prev" = dlfiles; then
5030 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5031 dlfiles="$dlfiles $pic_object"
5032 prev=
5033 continue
5034 else
5035 # If libtool objects are unsupported, then we need to preload.
5036 prev=dlprefiles
5040 # CHECK ME: I think I busted this. -Ossama
5041 if test "$prev" = dlprefiles; then
5042 # Preload the old-style object.
5043 dlprefiles="$dlprefiles $pic_object"
5044 prev=
5047 # A PIC object.
5048 func_append libobjs " $pic_object"
5049 arg="$pic_object"
5052 # Non-PIC object.
5053 if test "$non_pic_object" != none; then
5054 # Prepend the subdirectory the object is found in.
5055 non_pic_object="$xdir$non_pic_object"
5057 # A standard non-PIC object
5058 func_append non_pic_objects " $non_pic_object"
5059 if test -z "$pic_object" || test "$pic_object" = none ; then
5060 arg="$non_pic_object"
5062 else
5063 # If the PIC object exists, use it instead.
5064 # $xdir was prepended to $pic_object above.
5065 non_pic_object="$pic_object"
5066 func_append non_pic_objects " $non_pic_object"
5068 else
5069 # Only an error if not doing a dry-run.
5070 if $opt_dry_run; then
5071 # Extract subdirectory from the argument.
5072 func_dirname "$arg" "/" ""
5073 xdir="$func_dirname_result"
5075 func_lo2o "$arg"
5076 pic_object=$xdir$objdir/$func_lo2o_result
5077 non_pic_object=$xdir$func_lo2o_result
5078 func_append libobjs " $pic_object"
5079 func_append non_pic_objects " $non_pic_object"
5080 else
5081 func_fatal_error "\`$arg' is not a valid libtool object"
5086 *.$libext)
5087 # An archive.
5088 deplibs="$deplibs $arg"
5089 old_deplibs="$old_deplibs $arg"
5090 continue
5093 *.la)
5094 # A libtool-controlled library.
5096 if test "$prev" = dlfiles; then
5097 # This library was specified with -dlopen.
5098 dlfiles="$dlfiles $arg"
5099 prev=
5100 elif test "$prev" = dlprefiles; then
5101 # The library was specified with -dlpreopen.
5102 dlprefiles="$dlprefiles $arg"
5103 prev=
5104 else
5105 deplibs="$deplibs $arg"
5107 continue
5110 # Some other compiler argument.
5112 # Unknown arguments in both finalize_command and compile_command need
5113 # to be aesthetically quoted because they are evaled later.
5114 func_quote_for_eval "$arg"
5115 arg="$func_quote_for_eval_result"
5117 esac # arg
5119 # Now actually substitute the argument into the commands.
5120 if test -n "$arg"; then
5121 func_append compile_command " $arg"
5122 func_append finalize_command " $arg"
5124 done # argument parsing loop
5126 test -n "$prev" && \
5127 func_fatal_help "the \`$prevarg' option requires an argument"
5129 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5130 eval "arg=\"$export_dynamic_flag_spec\""
5131 func_append compile_command " $arg"
5132 func_append finalize_command " $arg"
5135 oldlibs=
5136 # calculate the name of the file, without its directory
5137 func_basename "$output"
5138 outputname="$func_basename_result"
5139 libobjs_save="$libobjs"
5141 if test -n "$shlibpath_var"; then
5142 # get the directories listed in $shlibpath_var
5143 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5144 else
5145 shlib_search_path=
5147 eval "sys_lib_search_path=\"$sys_lib_search_path_spec\""
5148 eval "sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\""
5150 func_dirname "$output" "/" ""
5151 output_objdir="$func_dirname_result$objdir"
5152 # Create the object directory.
5153 func_mkdir_p "$output_objdir"
5155 # Determine the type of output
5156 case $output in
5158 func_fatal_help "you must specify an output file"
5160 *.$libext) linkmode=oldlib ;;
5161 *.lo | *.$objext) linkmode=obj ;;
5162 *.la) linkmode=lib ;;
5163 *) linkmode=prog ;; # Anything else should be a program.
5164 esac
5166 specialdeplibs=
5168 libs=
5169 # Find all interdependent deplibs by searching for libraries
5170 # that are linked more than once (e.g. -la -lb -la)
5171 for deplib in $deplibs; do
5172 if $opt_duplicate_deps ; then
5173 case "$libs " in
5174 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5175 esac
5177 libs="$libs $deplib"
5178 done
5180 if test "$linkmode" = lib; then
5181 libs="$predeps $libs $compiler_lib_search_path $postdeps"
5183 # Compute libraries that are listed more than once in $predeps
5184 # $postdeps and mark them as special (i.e., whose duplicates are
5185 # not to be eliminated).
5186 pre_post_deps=
5187 if $opt_duplicate_compiler_generated_deps; then
5188 for pre_post_dep in $predeps $postdeps; do
5189 case "$pre_post_deps " in
5190 *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5191 esac
5192 pre_post_deps="$pre_post_deps $pre_post_dep"
5193 done
5195 pre_post_deps=
5198 deplibs=
5199 newdependency_libs=
5200 newlib_search_path=
5201 need_relink=no # whether we're linking any uninstalled libtool libraries
5202 notinst_deplibs= # not-installed libtool libraries
5203 notinst_path= # paths that contain not-installed libtool libraries
5205 case $linkmode in
5206 lib)
5207 passes="conv dlpreopen link"
5208 for file in $dlfiles $dlprefiles; do
5209 case $file in
5210 *.la) ;;
5212 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5214 esac
5215 done
5217 prog)
5218 compile_deplibs=
5219 finalize_deplibs=
5220 alldeplibs=no
5221 newdlfiles=
5222 newdlprefiles=
5223 passes="conv scan dlopen dlpreopen link"
5225 *) passes="conv"
5227 esac
5229 for pass in $passes; do
5230 # The preopen pass in lib mode reverses $deplibs; put it back here
5231 # so that -L comes before libs that need it for instance...
5232 if test "$linkmode,$pass" = "lib,link"; then
5233 ## FIXME: Find the place where the list is rebuilt in the wrong
5234 ## order, and fix it there properly
5235 tmp_deplibs=
5236 for deplib in $deplibs; do
5237 tmp_deplibs="$deplib $tmp_deplibs"
5238 done
5239 deplibs="$tmp_deplibs"
5242 if test "$linkmode,$pass" = "lib,link" ||
5243 test "$linkmode,$pass" = "prog,scan"; then
5244 libs="$deplibs"
5245 deplibs=
5247 if test "$linkmode" = prog; then
5248 case $pass in
5249 dlopen) libs="$dlfiles" ;;
5250 dlpreopen) libs="$dlprefiles" ;;
5251 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5252 esac
5254 if test "$linkmode,$pass" = "lib,dlpreopen"; then
5255 # Collect and forward deplibs of preopened libtool libs
5256 for lib in $dlprefiles; do
5257 # Ignore non-libtool-libs
5258 dependency_libs=
5259 case $lib in
5260 *.la) func_source "$lib" ;;
5261 esac
5263 # Collect preopened libtool deplibs, except any this library
5264 # has declared as weak libs
5265 for deplib in $dependency_libs; do
5266 func_basename "$deplib"
5267 deplib_base=$func_basename_result
5268 case " $weak_libs " in
5269 *" $deplib_base "*) ;;
5270 *) deplibs="$deplibs $deplib" ;;
5271 esac
5272 done
5273 done
5274 libs="$dlprefiles"
5276 if test "$pass" = dlopen; then
5277 # Collect dlpreopened libraries
5278 save_deplibs="$deplibs"
5279 deplibs=
5282 for deplib in $libs; do
5283 lib=
5284 found=no
5285 case $deplib in
5286 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5287 if test "$linkmode,$pass" = "prog,link"; then
5288 compile_deplibs="$deplib $compile_deplibs"
5289 finalize_deplibs="$deplib $finalize_deplibs"
5290 else
5291 compiler_flags="$compiler_flags $deplib"
5292 if test "$linkmode" = lib ; then
5293 case "$new_inherited_linker_flags " in
5294 *" $deplib "*) ;;
5295 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5296 esac
5299 continue
5301 -l*)
5302 if test "$linkmode" != lib && test "$linkmode" != prog; then
5303 func_warning "\`-l' is ignored for archives/objects"
5304 continue
5306 func_stripname '-l' '' "$deplib"
5307 name=$func_stripname_result
5308 if test "$linkmode" = lib; then
5309 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5310 else
5311 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5313 for searchdir in $searchdirs; do
5314 for search_ext in .la $std_shrext .so .a; do
5315 # Search the libtool library
5316 lib="$searchdir/lib${name}${search_ext}"
5317 if test -f "$lib"; then
5318 if test "$search_ext" = ".la"; then
5319 found=yes
5320 else
5321 found=no
5323 break 2
5325 done
5326 done
5327 if test "$found" != yes; then
5328 # deplib doesn't seem to be a libtool library
5329 if test "$linkmode,$pass" = "prog,link"; then
5330 compile_deplibs="$deplib $compile_deplibs"
5331 finalize_deplibs="$deplib $finalize_deplibs"
5332 else
5333 deplibs="$deplib $deplibs"
5334 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5336 continue
5337 else # deplib is a libtool library
5338 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5339 # We need to do some special things here, and not later.
5340 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5341 case " $predeps $postdeps " in
5342 *" $deplib "*)
5343 if func_lalib_p "$lib"; then
5344 library_names=
5345 old_library=
5346 func_source "$lib"
5347 for l in $old_library $library_names; do
5348 ll="$l"
5349 done
5350 if test "X$ll" = "X$old_library" ; then # only static version available
5351 found=no
5352 func_dirname "$lib" "" "."
5353 ladir="$func_dirname_result"
5354 lib=$ladir/$old_library
5355 if test "$linkmode,$pass" = "prog,link"; then
5356 compile_deplibs="$deplib $compile_deplibs"
5357 finalize_deplibs="$deplib $finalize_deplibs"
5358 else
5359 deplibs="$deplib $deplibs"
5360 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5362 continue
5366 *) ;;
5367 esac
5370 ;; # -l
5371 *.ltframework)
5372 if test "$linkmode,$pass" = "prog,link"; then
5373 compile_deplibs="$deplib $compile_deplibs"
5374 finalize_deplibs="$deplib $finalize_deplibs"
5375 else
5376 deplibs="$deplib $deplibs"
5377 if test "$linkmode" = lib ; then
5378 case "$new_inherited_linker_flags " in
5379 *" $deplib "*) ;;
5380 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5381 esac
5384 continue
5386 -L*)
5387 case $linkmode in
5388 lib)
5389 deplibs="$deplib $deplibs"
5390 test "$pass" = conv && continue
5391 newdependency_libs="$deplib $newdependency_libs"
5392 func_stripname '-L' '' "$deplib"
5393 newlib_search_path="$newlib_search_path $func_stripname_result"
5395 prog)
5396 if test "$pass" = conv; then
5397 deplibs="$deplib $deplibs"
5398 continue
5400 if test "$pass" = scan; then
5401 deplibs="$deplib $deplibs"
5402 else
5403 compile_deplibs="$deplib $compile_deplibs"
5404 finalize_deplibs="$deplib $finalize_deplibs"
5406 func_stripname '-L' '' "$deplib"
5407 newlib_search_path="$newlib_search_path $func_stripname_result"
5410 func_warning "\`-L' is ignored for archives/objects"
5412 esac # linkmode
5413 continue
5414 ;; # -L
5415 -R*)
5416 if test "$pass" = link; then
5417 func_stripname '-R' '' "$deplib"
5418 dir=$func_stripname_result
5419 # Make sure the xrpath contains only unique directories.
5420 case "$xrpath " in
5421 *" $dir "*) ;;
5422 *) xrpath="$xrpath $dir" ;;
5423 esac
5425 deplibs="$deplib $deplibs"
5426 continue
5428 *.la) lib="$deplib" ;;
5429 *.$libext)
5430 if test "$pass" = conv; then
5431 deplibs="$deplib $deplibs"
5432 continue
5434 case $linkmode in
5435 lib)
5436 # Linking convenience modules into shared libraries is allowed,
5437 # but linking other static libraries is non-portable.
5438 case " $dlpreconveniencelibs " in
5439 *" $deplib "*) ;;
5441 valid_a_lib=no
5442 case $deplibs_check_method in
5443 match_pattern*)
5444 set dummy $deplibs_check_method; shift
5445 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5446 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5447 | $EGREP "$match_pattern_regex" > /dev/null; then
5448 valid_a_lib=yes
5451 pass_all)
5452 valid_a_lib=yes
5454 esac
5455 if test "$valid_a_lib" != yes; then
5456 echo
5457 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5458 echo "*** I have the capability to make that library automatically link in when"
5459 echo "*** you link to this library. But I can only do this if you have a"
5460 echo "*** shared version of the library, which you do not appear to have"
5461 echo "*** because the file extensions .$libext of this argument makes me believe"
5462 echo "*** that it is just a static archive that I should not use here."
5463 else
5464 echo
5465 $ECHO "*** Warning: Linking the shared library $output against the"
5466 $ECHO "*** static library $deplib is not portable!"
5467 deplibs="$deplib $deplibs"
5470 esac
5471 continue
5473 prog)
5474 if test "$pass" != link; then
5475 deplibs="$deplib $deplibs"
5476 else
5477 compile_deplibs="$deplib $compile_deplibs"
5478 finalize_deplibs="$deplib $finalize_deplibs"
5480 continue
5482 esac # linkmode
5483 ;; # *.$libext
5484 *.lo | *.$objext)
5485 if test "$pass" = conv; then
5486 deplibs="$deplib $deplibs"
5487 elif test "$linkmode" = prog; then
5488 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5489 # If there is no dlopen support or we're linking statically,
5490 # we need to preload.
5491 newdlprefiles="$newdlprefiles $deplib"
5492 compile_deplibs="$deplib $compile_deplibs"
5493 finalize_deplibs="$deplib $finalize_deplibs"
5494 else
5495 newdlfiles="$newdlfiles $deplib"
5498 continue
5500 %DEPLIBS%)
5501 alldeplibs=yes
5502 continue
5504 esac # case $deplib
5506 if test "$found" = yes || test -f "$lib"; then :
5507 else
5508 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5511 # Check to see that this really is a libtool archive.
5512 func_lalib_unsafe_p "$lib" \
5513 || func_fatal_error "\`$lib' is not a valid libtool archive"
5515 func_dirname "$lib" "" "."
5516 ladir="$func_dirname_result"
5518 dlname=
5519 dlopen=
5520 dlpreopen=
5521 libdir=
5522 library_names=
5523 old_library=
5524 inherited_linker_flags=
5525 # If the library was installed with an old release of libtool,
5526 # it will not redefine variables installed, or shouldnotlink
5527 installed=yes
5528 shouldnotlink=no
5529 avoidtemprpath=
5532 # Read the .la file
5533 func_source "$lib"
5535 # Convert "-framework foo" to "foo.ltframework"
5536 if test -n "$inherited_linker_flags"; then
5537 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5538 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5539 case " $new_inherited_linker_flags " in
5540 *" $tmp_inherited_linker_flag "*) ;;
5541 *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5542 esac
5543 done
5545 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5546 if test "$linkmode,$pass" = "lib,link" ||
5547 test "$linkmode,$pass" = "prog,scan" ||
5548 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5549 test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5550 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5553 if test "$pass" = conv; then
5554 # Only check for convenience libraries
5555 deplibs="$lib $deplibs"
5556 if test -z "$libdir"; then
5557 if test -z "$old_library"; then
5558 func_fatal_error "cannot find name of link library for \`$lib'"
5560 # It is a libtool convenience library, so add in its objects.
5561 convenience="$convenience $ladir/$objdir/$old_library"
5562 old_convenience="$old_convenience $ladir/$objdir/$old_library"
5563 elif test "$linkmode" != prog && test "$linkmode" != lib; then
5564 func_fatal_error "\`$lib' is not a convenience library"
5566 tmp_libs=
5567 for deplib in $dependency_libs; do
5568 deplibs="$deplib $deplibs"
5569 if $opt_duplicate_deps ; then
5570 case "$tmp_libs " in
5571 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5572 esac
5574 tmp_libs="$tmp_libs $deplib"
5575 done
5576 continue
5577 fi # $pass = conv
5580 # Get the name of the library we link against.
5581 linklib=
5582 for l in $old_library $library_names; do
5583 linklib="$l"
5584 done
5585 if test -z "$linklib"; then
5586 func_fatal_error "cannot find name of link library for \`$lib'"
5589 # This library was specified with -dlopen.
5590 if test "$pass" = dlopen; then
5591 if test -z "$libdir"; then
5592 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5594 if test -z "$dlname" ||
5595 test "$dlopen_support" != yes ||
5596 test "$build_libtool_libs" = no; then
5597 # If there is no dlname, no dlopen support or we're linking
5598 # statically, we need to preload. We also need to preload any
5599 # dependent libraries so libltdl's deplib preloader doesn't
5600 # bomb out in the load deplibs phase.
5601 dlprefiles="$dlprefiles $lib $dependency_libs"
5602 else
5603 newdlfiles="$newdlfiles $lib"
5605 continue
5606 fi # $pass = dlopen
5608 # We need an absolute path.
5609 case $ladir in
5610 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5612 abs_ladir=`cd "$ladir" && pwd`
5613 if test -z "$abs_ladir"; then
5614 func_warning "cannot determine absolute directory name of \`$ladir'"
5615 func_warning "passing it literally to the linker, although it might fail"
5616 abs_ladir="$ladir"
5619 esac
5620 func_basename "$lib"
5621 laname="$func_basename_result"
5623 # Find the relevant object directory and library name.
5624 if test "X$installed" = Xyes; then
5625 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5626 func_warning "library \`$lib' was moved."
5627 dir="$ladir"
5628 absdir="$abs_ladir"
5629 libdir="$abs_ladir"
5630 else
5631 dir="$libdir"
5632 absdir="$libdir"
5634 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5635 else
5636 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5637 dir="$ladir"
5638 absdir="$abs_ladir"
5639 # Remove this search path later
5640 notinst_path="$notinst_path $abs_ladir"
5641 else
5642 dir="$ladir/$objdir"
5643 absdir="$abs_ladir/$objdir"
5644 # Remove this search path later
5645 notinst_path="$notinst_path $abs_ladir"
5647 fi # $installed = yes
5648 func_stripname 'lib' '.la' "$laname"
5649 name=$func_stripname_result
5651 # This library was specified with -dlpreopen.
5652 if test "$pass" = dlpreopen; then
5653 if test -z "$libdir" && test "$linkmode" = prog; then
5654 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5656 # Prefer using a static library (so that no silly _DYNAMIC symbols
5657 # are required to link).
5658 if test -n "$old_library"; then
5659 newdlprefiles="$newdlprefiles $dir/$old_library"
5660 # Keep a list of preopened convenience libraries to check
5661 # that they are being used correctly in the link pass.
5662 test -z "$libdir" && \
5663 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5664 # Otherwise, use the dlname, so that lt_dlopen finds it.
5665 elif test -n "$dlname"; then
5666 newdlprefiles="$newdlprefiles $dir/$dlname"
5667 else
5668 newdlprefiles="$newdlprefiles $dir/$linklib"
5670 fi # $pass = dlpreopen
5672 if test -z "$libdir"; then
5673 # Link the convenience library
5674 if test "$linkmode" = lib; then
5675 deplibs="$dir/$old_library $deplibs"
5676 elif test "$linkmode,$pass" = "prog,link"; then
5677 compile_deplibs="$dir/$old_library $compile_deplibs"
5678 finalize_deplibs="$dir/$old_library $finalize_deplibs"
5679 else
5680 deplibs="$lib $deplibs" # used for prog,scan pass
5682 continue
5686 if test "$linkmode" = prog && test "$pass" != link; then
5687 newlib_search_path="$newlib_search_path $ladir"
5688 deplibs="$lib $deplibs"
5690 linkalldeplibs=no
5691 if test "$link_all_deplibs" != no || test -z "$library_names" ||
5692 test "$build_libtool_libs" = no; then
5693 linkalldeplibs=yes
5696 tmp_libs=
5697 for deplib in $dependency_libs; do
5698 case $deplib in
5699 -L*) func_stripname '-L' '' "$deplib"
5700 newlib_search_path="$newlib_search_path $func_stripname_result"
5702 esac
5703 # Need to link against all dependency_libs?
5704 if test "$linkalldeplibs" = yes; then
5705 deplibs="$deplib $deplibs"
5706 else
5707 # Need to hardcode shared library paths
5708 # or/and link against static libraries
5709 newdependency_libs="$deplib $newdependency_libs"
5711 if $opt_duplicate_deps ; then
5712 case "$tmp_libs " in
5713 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5714 esac
5716 tmp_libs="$tmp_libs $deplib"
5717 done # for deplib
5718 continue
5719 fi # $linkmode = prog...
5721 if test "$linkmode,$pass" = "prog,link"; then
5722 if test -n "$library_names" &&
5723 { { test "$prefer_static_libs" = no ||
5724 test "$prefer_static_libs,$installed" = "built,yes"; } ||
5725 test -z "$old_library"; }; then
5726 # We need to hardcode the library path
5727 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5728 # Make sure the rpath contains only unique directories.
5729 case "$temp_rpath:" in
5730 *"$absdir:"*) ;;
5731 *) temp_rpath="$temp_rpath$absdir:" ;;
5732 esac
5735 # Hardcode the library path.
5736 # Skip directories that are in the system default run-time
5737 # search path.
5738 case " $sys_lib_dlsearch_path " in
5739 *" $absdir "*) ;;
5741 case "$compile_rpath " in
5742 *" $absdir "*) ;;
5743 *) compile_rpath="$compile_rpath $absdir"
5744 esac
5746 esac
5747 case " $sys_lib_dlsearch_path " in
5748 *" $libdir "*) ;;
5750 case "$finalize_rpath " in
5751 *" $libdir "*) ;;
5752 *) finalize_rpath="$finalize_rpath $libdir"
5753 esac
5755 esac
5756 fi # $linkmode,$pass = prog,link...
5758 if test "$alldeplibs" = yes &&
5759 { test "$deplibs_check_method" = pass_all ||
5760 { test "$build_libtool_libs" = yes &&
5761 test -n "$library_names"; }; }; then
5762 # We only need to search for static libraries
5763 continue
5767 link_static=no # Whether the deplib will be linked statically
5768 use_static_libs=$prefer_static_libs
5769 if test "$use_static_libs" = built && test "$installed" = yes; then
5770 use_static_libs=no
5772 if test -n "$library_names" &&
5773 { test "$use_static_libs" = no || test -z "$old_library"; }; then
5774 case $host in
5775 *cygwin* | *mingw* | *cegcc*)
5776 # No point in relinking DLLs because paths are not encoded
5777 notinst_deplibs="$notinst_deplibs $lib"
5778 need_relink=no
5781 if test "$installed" = no; then
5782 notinst_deplibs="$notinst_deplibs $lib"
5783 need_relink=yes
5786 esac
5787 # This is a shared library
5789 # Warn about portability, can't link against -module's on some
5790 # systems (darwin). Don't bleat about dlopened modules though!
5791 dlopenmodule=""
5792 for dlpremoduletest in $dlprefiles; do
5793 if test "X$dlpremoduletest" = "X$lib"; then
5794 dlopenmodule="$dlpremoduletest"
5795 break
5797 done
5798 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5799 echo
5800 if test "$linkmode" = prog; then
5801 $ECHO "*** Warning: Linking the executable $output against the loadable module"
5802 else
5803 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5805 $ECHO "*** $linklib is not portable!"
5807 if test "$linkmode" = lib &&
5808 test "$hardcode_into_libs" = yes; then
5809 # Hardcode the library path.
5810 # Skip directories that are in the system default run-time
5811 # search path.
5812 case " $sys_lib_dlsearch_path " in
5813 *" $absdir "*) ;;
5815 case "$compile_rpath " in
5816 *" $absdir "*) ;;
5817 *) compile_rpath="$compile_rpath $absdir"
5818 esac
5820 esac
5821 case " $sys_lib_dlsearch_path " in
5822 *" $libdir "*) ;;
5824 case "$finalize_rpath " in
5825 *" $libdir "*) ;;
5826 *) finalize_rpath="$finalize_rpath $libdir"
5827 esac
5829 esac
5832 if test -n "$old_archive_from_expsyms_cmds"; then
5833 # figure out the soname
5834 set dummy $library_names
5835 shift
5836 realname="$1"
5837 shift
5838 eval "libname=\"$libname_spec\""
5839 # use dlname if we got it. it's perfectly good, no?
5840 if test -n "$dlname"; then
5841 soname="$dlname"
5842 elif test -n "$soname_spec"; then
5843 # bleh windows
5844 case $host in
5845 *cygwin* | mingw* | *cegcc*)
5846 func_arith $current - $age
5847 major=$func_arith_result
5848 versuffix="-$major"
5850 esac
5851 eval "soname=\"$soname_spec\""
5852 else
5853 soname="$realname"
5856 # Make a new name for the extract_expsyms_cmds to use
5857 soroot="$soname"
5858 func_basename "$soroot"
5859 soname="$func_basename_result"
5860 func_stripname 'lib' '.dll' "$soname"
5861 newlib=libimp-$func_stripname_result.a
5863 # If the library has no export list, then create one now
5864 if test -f "$output_objdir/$soname-def"; then :
5865 else
5866 func_verbose "extracting exported symbol list from \`$soname'"
5867 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5870 # Create $newlib
5871 if test -f "$output_objdir/$newlib"; then :; else
5872 func_verbose "generating import library for \`$soname'"
5873 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5875 # make sure the library variables are pointing to the new library
5876 dir=$output_objdir
5877 linklib=$newlib
5878 fi # test -n "$old_archive_from_expsyms_cmds"
5880 if test "$linkmode" = prog || test "$mode" != relink; then
5881 add_shlibpath=
5882 add_dir=
5883 add=
5884 lib_linked=yes
5885 case $hardcode_action in
5886 immediate | unsupported)
5887 if test "$hardcode_direct" = no; then
5888 add="$dir/$linklib"
5889 case $host in
5890 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5891 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5892 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5893 *-*-unixware7*) add_dir="-L$dir" ;;
5894 *-*-darwin* )
5895 # if the lib is a (non-dlopened) module then we can not
5896 # link against it, someone is ignoring the earlier warnings
5897 if /usr/bin/file -L $add 2> /dev/null |
5898 $GREP ": [^:]* bundle" >/dev/null ; then
5899 if test "X$dlopenmodule" != "X$lib"; then
5900 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5901 if test -z "$old_library" ; then
5902 echo
5903 echo "*** And there doesn't seem to be a static archive available"
5904 echo "*** The link will probably fail, sorry"
5905 else
5906 add="$dir/$old_library"
5908 elif test -n "$old_library"; then
5909 add="$dir/$old_library"
5912 esac
5913 elif test "$hardcode_minus_L" = no; then
5914 case $host in
5915 *-*-sunos*) add_shlibpath="$dir" ;;
5916 esac
5917 add_dir="-L$dir"
5918 add="-l$name"
5919 elif test "$hardcode_shlibpath_var" = no; then
5920 add_shlibpath="$dir"
5921 add="-l$name"
5922 else
5923 lib_linked=no
5926 relink)
5927 if test "$hardcode_direct" = yes &&
5928 test "$hardcode_direct_absolute" = no; then
5929 add="$dir/$linklib"
5930 elif test "$hardcode_minus_L" = yes; then
5931 add_dir="-L$dir"
5932 # Try looking first in the location we're being installed to.
5933 if test -n "$inst_prefix_dir"; then
5934 case $libdir in
5935 [\\/]*)
5936 add_dir="$add_dir -L$inst_prefix_dir$libdir"
5938 esac
5940 add="-l$name"
5941 elif test "$hardcode_shlibpath_var" = yes; then
5942 add_shlibpath="$dir"
5943 add="-l$name"
5944 else
5945 lib_linked=no
5948 *) lib_linked=no ;;
5949 esac
5951 if test "$lib_linked" != yes; then
5952 func_fatal_configuration "unsupported hardcode properties"
5955 if test -n "$add_shlibpath"; then
5956 case :$compile_shlibpath: in
5957 *":$add_shlibpath:"*) ;;
5958 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5959 esac
5961 if test "$linkmode" = prog; then
5962 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5963 test -n "$add" && compile_deplibs="$add $compile_deplibs"
5964 else
5965 test -n "$add_dir" && deplibs="$add_dir $deplibs"
5966 test -n "$add" && deplibs="$add $deplibs"
5967 if test "$hardcode_direct" != yes &&
5968 test "$hardcode_minus_L" != yes &&
5969 test "$hardcode_shlibpath_var" = yes; then
5970 case :$finalize_shlibpath: in
5971 *":$libdir:"*) ;;
5972 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5973 esac
5978 if test "$linkmode" = prog || test "$mode" = relink; then
5979 add_shlibpath=
5980 add_dir=
5981 add=
5982 # Finalize command for both is simple: just hardcode it.
5983 if test "$hardcode_direct" = yes &&
5984 test "$hardcode_direct_absolute" = no; then
5985 add="$libdir/$linklib"
5986 elif test "$hardcode_minus_L" = yes; then
5987 add_dir="-L$libdir"
5988 add="-l$name"
5989 elif test "$hardcode_shlibpath_var" = yes; then
5990 case :$finalize_shlibpath: in
5991 *":$libdir:"*) ;;
5992 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5993 esac
5994 add="-l$name"
5995 elif test "$hardcode_automatic" = yes; then
5996 if test -n "$inst_prefix_dir" &&
5997 test -f "$inst_prefix_dir$libdir/$linklib" ; then
5998 add="$inst_prefix_dir$libdir/$linklib"
5999 else
6000 add="$libdir/$linklib"
6002 else
6003 # We cannot seem to hardcode it, guess we'll fake it.
6004 add_dir="-L$libdir"
6005 # Try looking first in the location we're being installed to.
6006 if test -n "$inst_prefix_dir"; then
6007 case $libdir in
6008 [\\/]*)
6009 add_dir="$add_dir -L$inst_prefix_dir$libdir"
6011 esac
6013 add="-l$name"
6016 if test "$linkmode" = prog; then
6017 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6018 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6019 else
6020 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6021 test -n "$add" && deplibs="$add $deplibs"
6024 elif test "$linkmode" = prog; then
6025 # Here we assume that one of hardcode_direct or hardcode_minus_L
6026 # is not unsupported. This is valid on all known static and
6027 # shared platforms.
6028 if test "$hardcode_direct" != unsupported; then
6029 test -n "$old_library" && linklib="$old_library"
6030 compile_deplibs="$dir/$linklib $compile_deplibs"
6031 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6032 else
6033 compile_deplibs="-l$name -L$dir $compile_deplibs"
6034 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6036 elif test "$build_libtool_libs" = yes; then
6037 # Not a shared library
6038 if test "$deplibs_check_method" != pass_all; then
6039 # We're trying link a shared library against a static one
6040 # but the system doesn't support it.
6042 # Just print a warning and add the library to dependency_libs so
6043 # that the program can be linked against the static library.
6044 echo
6045 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6046 echo "*** I have the capability to make that library automatically link in when"
6047 echo "*** you link to this library. But I can only do this if you have a"
6048 echo "*** shared version of the library, which you do not appear to have."
6049 if test "$module" = yes; then
6050 echo "*** But as you try to build a module library, libtool will still create "
6051 echo "*** a static module, that should work as long as the dlopening application"
6052 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6053 if test -z "$global_symbol_pipe"; then
6054 echo
6055 echo "*** However, this would only work if libtool was able to extract symbol"
6056 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6057 echo "*** not find such a program. So, this module is probably useless."
6058 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6060 if test "$build_old_libs" = no; then
6061 build_libtool_libs=module
6062 build_old_libs=yes
6063 else
6064 build_libtool_libs=no
6067 else
6068 deplibs="$dir/$old_library $deplibs"
6069 link_static=yes
6071 fi # link shared/static library?
6073 if test "$linkmode" = lib; then
6074 if test -n "$dependency_libs" &&
6075 { test "$hardcode_into_libs" != yes ||
6076 test "$build_old_libs" = yes ||
6077 test "$link_static" = yes; }; then
6078 # Extract -R from dependency_libs
6079 temp_deplibs=
6080 for libdir in $dependency_libs; do
6081 case $libdir in
6082 -R*) func_stripname '-R' '' "$libdir"
6083 temp_xrpath=$func_stripname_result
6084 case " $xrpath " in
6085 *" $temp_xrpath "*) ;;
6086 *) xrpath="$xrpath $temp_xrpath";;
6087 esac;;
6088 *) temp_deplibs="$temp_deplibs $libdir";;
6089 esac
6090 done
6091 dependency_libs="$temp_deplibs"
6094 newlib_search_path="$newlib_search_path $absdir"
6095 # Link against this library
6096 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6097 # ... and its dependency_libs
6098 tmp_libs=
6099 for deplib in $dependency_libs; do
6100 newdependency_libs="$deplib $newdependency_libs"
6101 if $opt_duplicate_deps ; then
6102 case "$tmp_libs " in
6103 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6104 esac
6106 tmp_libs="$tmp_libs $deplib"
6107 done
6109 if test "$link_all_deplibs" != no; then
6110 # Add the search paths of all dependency libraries
6111 for deplib in $dependency_libs; do
6112 path=
6113 case $deplib in
6114 -L*) path="$deplib" ;;
6115 *.la)
6116 func_dirname "$deplib" "" "."
6117 dir="$func_dirname_result"
6118 # We need an absolute path.
6119 case $dir in
6120 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6122 absdir=`cd "$dir" && pwd`
6123 if test -z "$absdir"; then
6124 func_warning "cannot determine absolute directory name of \`$dir'"
6125 absdir="$dir"
6128 esac
6129 if $GREP "^installed=no" $deplib > /dev/null; then
6130 case $host in
6131 *-*-darwin*)
6132 depdepl=
6133 deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6134 if test -n "$deplibrary_names" ; then
6135 for tmp in $deplibrary_names ; do
6136 depdepl=$tmp
6137 done
6138 if test -f "$absdir/$objdir/$depdepl" ; then
6139 depdepl="$absdir/$objdir/$depdepl"
6140 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6141 if test -z "$darwin_install_name"; then
6142 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6144 compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6145 linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6146 path=
6151 path="-L$absdir/$objdir"
6153 esac
6154 else
6155 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6156 test -z "$libdir" && \
6157 func_fatal_error "\`$deplib' is not a valid libtool archive"
6158 test "$absdir" != "$libdir" && \
6159 func_warning "\`$deplib' seems to be moved"
6161 path="-L$absdir"
6164 esac
6165 case " $deplibs " in
6166 *" $path "*) ;;
6167 *) deplibs="$path $deplibs" ;;
6168 esac
6169 done
6170 fi # link_all_deplibs != no
6171 fi # linkmode = lib
6172 done # for deplib in $libs
6173 if test "$pass" = link; then
6174 if test "$linkmode" = "prog"; then
6175 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6176 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6177 else
6178 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6181 dependency_libs="$newdependency_libs"
6182 if test "$pass" = dlpreopen; then
6183 # Link the dlpreopened libraries before other libraries
6184 for deplib in $save_deplibs; do
6185 deplibs="$deplib $deplibs"
6186 done
6188 if test "$pass" != dlopen; then
6189 if test "$pass" != conv; then
6190 # Make sure lib_search_path contains only unique directories.
6191 lib_search_path=
6192 for dir in $newlib_search_path; do
6193 case "$lib_search_path " in
6194 *" $dir "*) ;;
6195 *) lib_search_path="$lib_search_path $dir" ;;
6196 esac
6197 done
6198 newlib_search_path=
6201 if test "$linkmode,$pass" != "prog,link"; then
6202 vars="deplibs"
6203 else
6204 vars="compile_deplibs finalize_deplibs"
6206 for var in $vars dependency_libs; do
6207 # Add libraries to $var in reverse order
6208 eval tmp_libs=\$$var
6209 new_libs=
6210 for deplib in $tmp_libs; do
6211 # FIXME: Pedantically, this is the right thing to do, so
6212 # that some nasty dependency loop isn't accidentally
6213 # broken:
6214 #new_libs="$deplib $new_libs"
6215 # Pragmatically, this seems to cause very few problems in
6216 # practice:
6217 case $deplib in
6218 -L*) new_libs="$deplib $new_libs" ;;
6219 -R*) ;;
6221 # And here is the reason: when a library appears more
6222 # than once as an explicit dependence of a library, or
6223 # is implicitly linked in more than once by the
6224 # compiler, it is considered special, and multiple
6225 # occurrences thereof are not removed. Compare this
6226 # with having the same library being listed as a
6227 # dependency of multiple other libraries: in this case,
6228 # we know (pedantically, we assume) the library does not
6229 # need to be listed more than once, so we keep only the
6230 # last copy. This is not always right, but it is rare
6231 # enough that we require users that really mean to play
6232 # such unportable linking tricks to link the library
6233 # using -Wl,-lname, so that libtool does not consider it
6234 # for duplicate removal.
6235 case " $specialdeplibs " in
6236 *" $deplib "*) new_libs="$deplib $new_libs" ;;
6238 case " $new_libs " in
6239 *" $deplib "*) ;;
6240 *) new_libs="$deplib $new_libs" ;;
6241 esac
6243 esac
6245 esac
6246 done
6247 tmp_libs=
6248 for deplib in $new_libs; do
6249 case $deplib in
6250 -L*)
6251 case " $tmp_libs " in
6252 *" $deplib "*) ;;
6253 *) tmp_libs="$tmp_libs $deplib" ;;
6254 esac
6256 *) tmp_libs="$tmp_libs $deplib" ;;
6257 esac
6258 done
6259 eval $var=\$tmp_libs
6260 done # for var
6262 # Last step: remove runtime libs from dependency_libs
6263 # (they stay in deplibs)
6264 tmp_libs=
6265 for i in $dependency_libs ; do
6266 case " $predeps $postdeps $compiler_lib_search_path " in
6267 *" $i "*)
6268 i=""
6270 esac
6271 if test -n "$i" ; then
6272 tmp_libs="$tmp_libs $i"
6274 done
6275 dependency_libs=$tmp_libs
6276 done # for pass
6277 if test "$linkmode" = prog; then
6278 dlfiles="$newdlfiles"
6280 if test "$linkmode" = prog || test "$linkmode" = lib; then
6281 dlprefiles="$newdlprefiles"
6284 case $linkmode in
6285 oldlib)
6286 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6287 func_warning "\`-dlopen' is ignored for archives"
6290 case " $deplibs" in
6291 *\ -l* | *\ -L*)
6292 func_warning "\`-l' and \`-L' are ignored for archives" ;;
6293 esac
6295 test -n "$rpath" && \
6296 func_warning "\`-rpath' is ignored for archives"
6298 test -n "$xrpath" && \
6299 func_warning "\`-R' is ignored for archives"
6301 test -n "$vinfo" && \
6302 func_warning "\`-version-info/-version-number' is ignored for archives"
6304 test -n "$release" && \
6305 func_warning "\`-release' is ignored for archives"
6307 test -n "$export_symbols$export_symbols_regex" && \
6308 func_warning "\`-export-symbols' is ignored for archives"
6310 # Now set the variables for building old libraries.
6311 build_libtool_libs=no
6312 oldlibs="$output"
6313 objs="$objs$old_deplibs"
6316 lib)
6317 # Make sure we only generate libraries of the form `libNAME.la'.
6318 case $outputname in
6319 lib*)
6320 func_stripname 'lib' '.la' "$outputname"
6321 name=$func_stripname_result
6322 eval "shared_ext=\"$shrext_cmds\""
6323 eval "libname=\"$libname_spec\""
6326 test "$module" = no && \
6327 func_fatal_help "libtool library \`$output' must begin with \`lib'"
6329 if test "$need_lib_prefix" != no; then
6330 # Add the "lib" prefix for modules if required
6331 func_stripname '' '.la' "$outputname"
6332 name=$func_stripname_result
6333 eval "shared_ext=\"$shrext_cmds\""
6334 eval "libname=\"$libname_spec\""
6335 else
6336 func_stripname '' '.la' "$outputname"
6337 libname=$func_stripname_result
6340 esac
6342 if test -n "$objs"; then
6343 if test "$deplibs_check_method" != pass_all; then
6344 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6345 else
6346 echo
6347 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6348 $ECHO "*** objects $objs is not portable!"
6349 libobjs="$libobjs $objs"
6353 test "$dlself" != no && \
6354 func_warning "\`-dlopen self' is ignored for libtool libraries"
6356 set dummy $rpath
6357 shift
6358 test "$#" -gt 1 && \
6359 func_warning "ignoring multiple \`-rpath's for a libtool library"
6361 install_libdir="$1"
6363 oldlibs=
6364 if test -z "$rpath"; then
6365 if test "$build_libtool_libs" = yes; then
6366 # Building a libtool convenience library.
6367 # Some compilers have problems with a `.al' extension so
6368 # convenience libraries should have the same extension an
6369 # archive normally would.
6370 oldlibs="$output_objdir/$libname.$libext $oldlibs"
6371 build_libtool_libs=convenience
6372 build_old_libs=yes
6375 test -n "$vinfo" && \
6376 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6378 test -n "$release" && \
6379 func_warning "\`-release' is ignored for convenience libraries"
6380 else
6382 # Parse the version information argument.
6383 save_ifs="$IFS"; IFS=':'
6384 set dummy $vinfo 0 0 0
6385 shift
6386 IFS="$save_ifs"
6388 test -n "$7" && \
6389 func_fatal_help "too many parameters to \`-version-info'"
6391 # convert absolute version numbers to libtool ages
6392 # this retains compatibility with .la files and attempts
6393 # to make the code below a bit more comprehensible
6395 case $vinfo_number in
6396 yes)
6397 number_major="$1"
6398 number_minor="$2"
6399 number_revision="$3"
6401 # There are really only two kinds -- those that
6402 # use the current revision as the major version
6403 # and those that subtract age and use age as
6404 # a minor version. But, then there is irix
6405 # which has an extra 1 added just for fun
6407 case $version_type in
6408 darwin|linux|osf|windows|none)
6409 func_arith $number_major + $number_minor
6410 current=$func_arith_result
6411 age="$number_minor"
6412 revision="$number_revision"
6414 freebsd-aout|freebsd-elf|qnx|sunos)
6415 current="$number_major"
6416 revision="$number_minor"
6417 age="0"
6419 irix|nonstopux)
6420 func_arith $number_major + $number_minor
6421 current=$func_arith_result
6422 age="$number_minor"
6423 revision="$number_minor"
6424 lt_irix_increment=no
6426 esac
6429 current="$1"
6430 revision="$2"
6431 age="$3"
6433 esac
6435 # Check that each of the things are valid numbers.
6436 case $current in
6437 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]) ;;
6439 func_error "CURRENT \`$current' must be a nonnegative integer"
6440 func_fatal_error "\`$vinfo' is not valid version information"
6442 esac
6444 case $revision in
6445 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]) ;;
6447 func_error "REVISION \`$revision' must be a nonnegative integer"
6448 func_fatal_error "\`$vinfo' is not valid version information"
6450 esac
6452 case $age in
6453 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]) ;;
6455 func_error "AGE \`$age' must be a nonnegative integer"
6456 func_fatal_error "\`$vinfo' is not valid version information"
6458 esac
6460 if test "$age" -gt "$current"; then
6461 func_error "AGE \`$age' is greater than the current interface number \`$current'"
6462 func_fatal_error "\`$vinfo' is not valid version information"
6465 # Calculate the version variables.
6466 major=
6467 versuffix=
6468 verstring=
6469 case $version_type in
6470 none) ;;
6472 darwin)
6473 # Like Linux, but with the current version available in
6474 # verstring for coding it into the library header
6475 func_arith $current - $age
6476 major=.$func_arith_result
6477 versuffix="$major.$age.$revision"
6478 # Darwin ld doesn't like 0 for these options...
6479 func_arith $current + 1
6480 minor_current=$func_arith_result
6481 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6482 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6485 freebsd-aout)
6486 major=".$current"
6487 versuffix=".$current.$revision";
6490 freebsd-elf)
6491 major=".$current"
6492 versuffix=".$current"
6495 irix | nonstopux)
6496 if test "X$lt_irix_increment" = "Xno"; then
6497 func_arith $current - $age
6498 else
6499 func_arith $current - $age + 1
6501 major=$func_arith_result
6503 case $version_type in
6504 nonstopux) verstring_prefix=nonstopux ;;
6505 *) verstring_prefix=sgi ;;
6506 esac
6507 verstring="$verstring_prefix$major.$revision"
6509 # Add in all the interfaces that we are compatible with.
6510 loop=$revision
6511 while test "$loop" -ne 0; do
6512 func_arith $revision - $loop
6513 iface=$func_arith_result
6514 func_arith $loop - 1
6515 loop=$func_arith_result
6516 verstring="$verstring_prefix$major.$iface:$verstring"
6517 done
6519 # Before this point, $major must not contain `.'.
6520 major=.$major
6521 versuffix="$major.$revision"
6524 linux)
6525 func_arith $current - $age
6526 major=.$func_arith_result
6527 versuffix="$major.$age.$revision"
6530 osf)
6531 func_arith $current - $age
6532 major=.$func_arith_result
6533 versuffix=".$current.$age.$revision"
6534 verstring="$current.$age.$revision"
6536 # Add in all the interfaces that we are compatible with.
6537 loop=$age
6538 while test "$loop" -ne 0; do
6539 func_arith $current - $loop
6540 iface=$func_arith_result
6541 func_arith $loop - 1
6542 loop=$func_arith_result
6543 verstring="$verstring:${iface}.0"
6544 done
6546 # Make executables depend on our current version.
6547 verstring="$verstring:${current}.0"
6550 qnx)
6551 major=".$current"
6552 versuffix=".$current"
6555 sunos)
6556 major=".$current"
6557 versuffix=".$current.$revision"
6560 windows)
6561 # Use '-' rather than '.', since we only want one
6562 # extension on DOS 8.3 filesystems.
6563 func_arith $current - $age
6564 major=$func_arith_result
6565 versuffix="-$major"
6569 func_fatal_configuration "unknown library version type \`$version_type'"
6571 esac
6573 # Clear the version info if we defaulted, and they specified a release.
6574 if test -z "$vinfo" && test -n "$release"; then
6575 major=
6576 case $version_type in
6577 darwin)
6578 # we can't check for "0.0" in archive_cmds due to quoting
6579 # problems, so we reset it completely
6580 verstring=
6583 verstring="0.0"
6585 esac
6586 if test "$need_version" = no; then
6587 versuffix=
6588 else
6589 versuffix=".0.0"
6593 # Remove version info from name if versioning should be avoided
6594 if test "$avoid_version" = yes && test "$need_version" = no; then
6595 major=
6596 versuffix=
6597 verstring=""
6600 # Check to see if the archive will have undefined symbols.
6601 if test "$allow_undefined" = yes; then
6602 if test "$allow_undefined_flag" = unsupported; then
6603 func_warning "undefined symbols not allowed in $host shared libraries"
6604 build_libtool_libs=no
6605 build_old_libs=yes
6607 else
6608 # Don't allow undefined symbols.
6609 allow_undefined_flag="$no_undefined_flag"
6614 func_generate_dlsyms "$libname" "$libname" "yes"
6615 libobjs="$libobjs $symfileobj"
6616 test "X$libobjs" = "X " && libobjs=
6618 if test "$mode" != relink; then
6619 # Remove our outputs, but don't remove object files since they
6620 # may have been created when compiling PIC objects.
6621 removelist=
6622 tempremovelist=`$ECHO "$output_objdir/*"`
6623 for p in $tempremovelist; do
6624 case $p in
6625 *.$objext | *.gcno)
6627 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6628 if test "X$precious_files_regex" != "X"; then
6629 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6630 then
6631 continue
6634 removelist="$removelist $p"
6636 *) ;;
6637 esac
6638 done
6639 test -n "$removelist" && \
6640 func_show_eval "${RM}r \$removelist"
6643 # Now set the variables for building old libraries.
6644 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6645 oldlibs="$oldlibs $output_objdir/$libname.$libext"
6647 # Transform .lo files to .o files.
6648 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6651 # Eliminate all temporary directories.
6652 #for path in $notinst_path; do
6653 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
6654 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
6655 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6656 #done
6658 if test -n "$xrpath"; then
6659 # If the user specified any rpath flags, then add them.
6660 temp_xrpath=
6661 for libdir in $xrpath; do
6662 temp_xrpath="$temp_xrpath -R$libdir"
6663 case "$finalize_rpath " in
6664 *" $libdir "*) ;;
6665 *) finalize_rpath="$finalize_rpath $libdir" ;;
6666 esac
6667 done
6668 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6669 dependency_libs="$temp_xrpath $dependency_libs"
6673 # Make sure dlfiles contains only unique files that won't be dlpreopened
6674 old_dlfiles="$dlfiles"
6675 dlfiles=
6676 for lib in $old_dlfiles; do
6677 case " $dlprefiles $dlfiles " in
6678 *" $lib "*) ;;
6679 *) dlfiles="$dlfiles $lib" ;;
6680 esac
6681 done
6683 # Make sure dlprefiles contains only unique files
6684 old_dlprefiles="$dlprefiles"
6685 dlprefiles=
6686 for lib in $old_dlprefiles; do
6687 case "$dlprefiles " in
6688 *" $lib "*) ;;
6689 *) dlprefiles="$dlprefiles $lib" ;;
6690 esac
6691 done
6693 if test "$build_libtool_libs" = yes; then
6694 if test -n "$rpath"; then
6695 case $host in
6696 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
6697 # these systems don't actually have a c library (as such)!
6699 *-*-rhapsody* | *-*-darwin1.[012])
6700 # Rhapsody C library is in the System framework
6701 deplibs="$deplibs System.ltframework"
6703 *-*-netbsd*)
6704 # Don't link with libc until the a.out ld.so is fixed.
6706 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6707 # Do not include libc due to us having libc/libc_r.
6709 *-*-sco3.2v5* | *-*-sco5v6*)
6710 # Causes problems with __ctype
6712 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6713 # Compiler inserts libc in the correct place for threads to work
6716 # Add libc to deplibs on all other systems if necessary.
6717 if test "$build_libtool_need_lc" = "yes"; then
6718 deplibs="$deplibs -lc"
6721 esac
6724 # Transform deplibs into only deplibs that can be linked in shared.
6725 name_save=$name
6726 libname_save=$libname
6727 release_save=$release
6728 versuffix_save=$versuffix
6729 major_save=$major
6730 # I'm not sure if I'm treating the release correctly. I think
6731 # release should show up in the -l (ie -lgmp5) so we don't want to
6732 # add it in twice. Is that correct?
6733 release=""
6734 versuffix=""
6735 major=""
6736 newdeplibs=
6737 droppeddeps=no
6738 case $deplibs_check_method in
6739 pass_all)
6740 # Don't check for shared/static. Everything works.
6741 # This might be a little naive. We might want to check
6742 # whether the library exists or not. But this is on
6743 # osf3 & osf4 and I'm not really sure... Just
6744 # implementing what was already the behavior.
6745 newdeplibs=$deplibs
6747 test_compile)
6748 # This code stresses the "libraries are programs" paradigm to its
6749 # limits. Maybe even breaks it. We compile a program, linking it
6750 # against the deplibs as a proxy for the library. Then we can check
6751 # whether they linked in statically or dynamically with ldd.
6752 $opt_dry_run || $RM conftest.c
6753 cat > conftest.c <<EOF
6754 int main() { return 0; }
6756 $opt_dry_run || $RM conftest
6757 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6758 ldd_output=`ldd conftest`
6759 for i in $deplibs; do
6760 case $i in
6761 -l*)
6762 func_stripname -l '' "$i"
6763 name=$func_stripname_result
6764 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6765 case " $predeps $postdeps " in
6766 *" $i "*)
6767 newdeplibs="$newdeplibs $i"
6768 i=""
6770 esac
6772 if test -n "$i" ; then
6773 eval "libname=\"$libname_spec\""
6774 eval "deplib_matches=\"$library_names_spec\""
6775 set dummy $deplib_matches; shift
6776 deplib_match=$1
6777 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6778 newdeplibs="$newdeplibs $i"
6779 else
6780 droppeddeps=yes
6781 echo
6782 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6783 echo "*** I have the capability to make that library automatically link in when"
6784 echo "*** you link to this library. But I can only do this if you have a"
6785 echo "*** shared version of the library, which I believe you do not have"
6786 echo "*** because a test_compile did reveal that the linker did not use it for"
6787 echo "*** its dynamic dependency list that programs get resolved with at runtime."
6792 newdeplibs="$newdeplibs $i"
6794 esac
6795 done
6796 else
6797 # Error occurred in the first compile. Let's try to salvage
6798 # the situation: Compile a separate program for each library.
6799 for i in $deplibs; do
6800 case $i in
6801 -l*)
6802 func_stripname -l '' "$i"
6803 name=$func_stripname_result
6804 $opt_dry_run || $RM conftest
6805 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6806 ldd_output=`ldd conftest`
6807 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6808 case " $predeps $postdeps " in
6809 *" $i "*)
6810 newdeplibs="$newdeplibs $i"
6811 i=""
6813 esac
6815 if test -n "$i" ; then
6816 eval "libname=\"$libname_spec\""
6817 eval "deplib_matches=\"$library_names_spec\""
6818 set dummy $deplib_matches; shift
6819 deplib_match=$1
6820 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6821 newdeplibs="$newdeplibs $i"
6822 else
6823 droppeddeps=yes
6824 echo
6825 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6826 echo "*** I have the capability to make that library automatically link in when"
6827 echo "*** you link to this library. But I can only do this if you have a"
6828 echo "*** shared version of the library, which you do not appear to have"
6829 echo "*** because a test_compile did reveal that the linker did not use this one"
6830 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6833 else
6834 droppeddeps=yes
6835 echo
6836 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6837 echo "*** make it link in! You will probably need to install it or some"
6838 echo "*** library that it depends on before this library will be fully"
6839 echo "*** functional. Installing it before continuing would be even better."
6843 newdeplibs="$newdeplibs $i"
6845 esac
6846 done
6849 file_magic*)
6850 set dummy $deplibs_check_method; shift
6851 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6852 for a_deplib in $deplibs; do
6853 case $a_deplib in
6854 -l*)
6855 func_stripname -l '' "$a_deplib"
6856 name=$func_stripname_result
6857 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6858 case " $predeps $postdeps " in
6859 *" $a_deplib "*)
6860 newdeplibs="$newdeplibs $a_deplib"
6861 a_deplib=""
6863 esac
6865 if test -n "$a_deplib" ; then
6866 eval "libname=\"$libname_spec\""
6867 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6868 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6869 for potent_lib in $potential_libs; do
6870 # Follow soft links.
6871 if ls -lLd "$potent_lib" 2>/dev/null |
6872 $GREP " -> " >/dev/null; then
6873 continue
6875 # The statement above tries to avoid entering an
6876 # endless loop below, in case of cyclic links.
6877 # We might still enter an endless loop, since a link
6878 # loop can be closed while we follow links,
6879 # but so what?
6880 potlib="$potent_lib"
6881 while test -h "$potlib" 2>/dev/null; do
6882 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6883 case $potliblink in
6884 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6885 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
6886 esac
6887 done
6888 if eval "$file_magic_cmd \"\$potlib\"" 2>/dev/null |
6889 $SED -e 10q |
6890 $EGREP "$file_magic_regex" > /dev/null; then
6891 newdeplibs="$newdeplibs $a_deplib"
6892 a_deplib=""
6893 break 2
6895 done
6896 done
6898 if test -n "$a_deplib" ; then
6899 droppeddeps=yes
6900 echo
6901 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6902 echo "*** I have the capability to make that library automatically link in when"
6903 echo "*** you link to this library. But I can only do this if you have a"
6904 echo "*** shared version of the library, which you do not appear to have"
6905 echo "*** because I did check the linker path looking for a file starting"
6906 if test -z "$potlib" ; then
6907 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6908 else
6909 $ECHO "*** with $libname and none of the candidates passed a file format test"
6910 $ECHO "*** using a file magic. Last file checked: $potlib"
6915 # Add a -L argument.
6916 newdeplibs="$newdeplibs $a_deplib"
6918 esac
6919 done # Gone through all deplibs.
6921 match_pattern*)
6922 set dummy $deplibs_check_method; shift
6923 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6924 for a_deplib in $deplibs; do
6925 case $a_deplib in
6926 -l*)
6927 func_stripname -l '' "$a_deplib"
6928 name=$func_stripname_result
6929 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6930 case " $predeps $postdeps " in
6931 *" $a_deplib "*)
6932 newdeplibs="$newdeplibs $a_deplib"
6933 a_deplib=""
6935 esac
6937 if test -n "$a_deplib" ; then
6938 eval "libname=\"$libname_spec\""
6939 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6940 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6941 for potent_lib in $potential_libs; do
6942 potlib="$potent_lib" # see symlink-check above in file_magic test
6943 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
6944 $EGREP "$match_pattern_regex" > /dev/null; then
6945 newdeplibs="$newdeplibs $a_deplib"
6946 a_deplib=""
6947 break 2
6949 done
6950 done
6952 if test -n "$a_deplib" ; then
6953 droppeddeps=yes
6954 echo
6955 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6956 echo "*** I have the capability to make that library automatically link in when"
6957 echo "*** you link to this library. But I can only do this if you have a"
6958 echo "*** shared version of the library, which you do not appear to have"
6959 echo "*** because I did check the linker path looking for a file starting"
6960 if test -z "$potlib" ; then
6961 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6962 else
6963 $ECHO "*** with $libname and none of the candidates passed a file format test"
6964 $ECHO "*** using a regex pattern. Last file checked: $potlib"
6969 # Add a -L argument.
6970 newdeplibs="$newdeplibs $a_deplib"
6972 esac
6973 done # Gone through all deplibs.
6975 none | unknown | *)
6976 newdeplibs=""
6977 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6978 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6979 for i in $predeps $postdeps ; do
6980 # can't use Xsed below, because $i might contain '/'
6981 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
6982 done
6984 case $tmp_deplibs in
6985 *[!\ \ ]*)
6986 echo
6987 if test "X$deplibs_check_method" = "Xnone"; then
6988 echo "*** Warning: inter-library dependencies are not supported in this platform."
6989 else
6990 echo "*** Warning: inter-library dependencies are not known to be supported."
6992 echo "*** All declared inter-library dependencies are being dropped."
6993 droppeddeps=yes
6995 esac
6997 esac
6998 versuffix=$versuffix_save
6999 major=$major_save
7000 release=$release_save
7001 libname=$libname_save
7002 name=$name_save
7004 case $host in
7005 *-*-rhapsody* | *-*-darwin1.[012])
7006 # On Rhapsody replace the C library with the System framework
7007 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7009 esac
7011 if test "$droppeddeps" = yes; then
7012 if test "$module" = yes; then
7013 echo
7014 echo "*** Warning: libtool could not satisfy all declared inter-library"
7015 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7016 echo "*** a static module, that should work as long as the dlopening"
7017 echo "*** application is linked with the -dlopen flag."
7018 if test -z "$global_symbol_pipe"; then
7019 echo
7020 echo "*** However, this would only work if libtool was able to extract symbol"
7021 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7022 echo "*** not find such a program. So, this module is probably useless."
7023 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7025 if test "$build_old_libs" = no; then
7026 oldlibs="$output_objdir/$libname.$libext"
7027 build_libtool_libs=module
7028 build_old_libs=yes
7029 else
7030 build_libtool_libs=no
7032 else
7033 echo "*** The inter-library dependencies that have been dropped here will be"
7034 echo "*** automatically added whenever a program is linked with this library"
7035 echo "*** or is declared to -dlopen it."
7037 if test "$allow_undefined" = no; then
7038 echo
7039 echo "*** Since this library must not contain undefined symbols,"
7040 echo "*** because either the platform does not support them or"
7041 echo "*** it was explicitly requested with -no-undefined,"
7042 echo "*** libtool will only create a static version of it."
7043 if test "$build_old_libs" = no; then
7044 oldlibs="$output_objdir/$libname.$libext"
7045 build_libtool_libs=module
7046 build_old_libs=yes
7047 else
7048 build_libtool_libs=no
7053 # Done checking deplibs!
7054 deplibs=$newdeplibs
7056 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7057 case $host in
7058 *-*-darwin*)
7059 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7060 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7061 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7063 esac
7065 # move library search paths that coincide with paths to not yet
7066 # installed libraries to the beginning of the library search list
7067 new_libs=
7068 for path in $notinst_path; do
7069 case " $new_libs " in
7070 *" -L$path/$objdir "*) ;;
7072 case " $deplibs " in
7073 *" -L$path/$objdir "*)
7074 new_libs="$new_libs -L$path/$objdir" ;;
7075 esac
7077 esac
7078 done
7079 for deplib in $deplibs; do
7080 case $deplib in
7081 -L*)
7082 case " $new_libs " in
7083 *" $deplib "*) ;;
7084 *) new_libs="$new_libs $deplib" ;;
7085 esac
7087 *) new_libs="$new_libs $deplib" ;;
7088 esac
7089 done
7090 deplibs="$new_libs"
7092 # All the library-specific variables (install_libdir is set above).
7093 library_names=
7094 old_library=
7095 dlname=
7097 # Test again, we may have decided not to build it any more
7098 if test "$build_libtool_libs" = yes; then
7099 if test "$hardcode_into_libs" = yes; then
7100 # Hardcode the library paths
7101 hardcode_libdirs=
7102 dep_rpath=
7103 rpath="$finalize_rpath"
7104 test "$mode" != relink && rpath="$compile_rpath$rpath"
7105 for libdir in $rpath; do
7106 if test -n "$hardcode_libdir_flag_spec"; then
7107 if test -n "$hardcode_libdir_separator"; then
7108 if test -z "$hardcode_libdirs"; then
7109 hardcode_libdirs="$libdir"
7110 else
7111 # Just accumulate the unique libdirs.
7112 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7113 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7116 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7118 esac
7120 else
7121 eval "flag=\"$hardcode_libdir_flag_spec\""
7122 dep_rpath="$dep_rpath $flag"
7124 elif test -n "$runpath_var"; then
7125 case "$perm_rpath " in
7126 *" $libdir "*) ;;
7127 *) perm_rpath="$perm_rpath $libdir" ;;
7128 esac
7130 done
7131 # Substitute the hardcoded libdirs into the rpath.
7132 if test -n "$hardcode_libdir_separator" &&
7133 test -n "$hardcode_libdirs"; then
7134 libdir="$hardcode_libdirs"
7135 if test -n "$hardcode_libdir_flag_spec_ld"; then
7136 eval "dep_rpath=\"$hardcode_libdir_flag_spec_ld\""
7137 else
7138 eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
7141 if test -n "$runpath_var" && test -n "$perm_rpath"; then
7142 # We should set the runpath_var.
7143 rpath=
7144 for dir in $perm_rpath; do
7145 rpath="$rpath$dir:"
7146 done
7147 eval $runpath_var=\$rpath\$$runpath_var
7148 export $runpath_var
7150 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7153 shlibpath="$finalize_shlibpath"
7154 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7155 if test -n "$shlibpath"; then
7156 eval $shlibpath_var=\$shlibpath\$$shlibpath_var
7157 export $shlibpath_var
7160 # Get the real and link names of the library.
7161 eval "shared_ext=\"$shrext_cmds\""
7162 eval "library_names=\"$library_names_spec\""
7163 set dummy $library_names
7164 shift
7165 realname="$1"
7166 shift
7168 if test -n "$soname_spec"; then
7169 eval "soname=\"$soname_spec\""
7170 else
7171 soname="$realname"
7173 if test -z "$dlname"; then
7174 dlname=$soname
7177 lib="$output_objdir/$realname"
7178 linknames=
7179 for link
7181 linknames="$linknames $link"
7182 done
7184 # Use standard objects if they are pic
7185 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
7186 test "X$libobjs" = "X " && libobjs=
7188 delfiles=
7189 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7190 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7191 export_symbols="$output_objdir/$libname.uexp"
7192 delfiles="$delfiles $export_symbols"
7195 orig_export_symbols=
7196 case $host_os in
7197 cygwin* | mingw* | cegcc*)
7198 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7199 # exporting using user supplied symfile
7200 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7201 # and it's NOT already a .def file. Must figure out
7202 # which of the given symbols are data symbols and tag
7203 # them as such. So, trigger use of export_symbols_cmds.
7204 # export_symbols gets reassigned inside the "prepare
7205 # the list of exported symbols" if statement, so the
7206 # include_expsyms logic still works.
7207 orig_export_symbols="$export_symbols"
7208 export_symbols=
7209 always_export_symbols=yes
7213 esac
7215 # Prepare the list of exported symbols
7216 if test -z "$export_symbols"; then
7217 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7218 func_verbose "generating symbol list for \`$libname.la'"
7219 export_symbols="$output_objdir/$libname.exp"
7220 $opt_dry_run || $RM $export_symbols
7221 cmds=$export_symbols_cmds
7222 save_ifs="$IFS"; IFS='~'
7223 for cmd in $cmds; do
7224 IFS="$save_ifs"
7225 eval "cmd=\"$cmd\""
7226 func_len " $cmd"
7227 len=$func_len_result
7228 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7229 func_show_eval "$cmd" 'exit $?'
7230 skipped_export=false
7231 else
7232 # The command line is too long to execute in one step.
7233 func_verbose "using reloadable object file for export list..."
7234 skipped_export=:
7235 # Break out early, otherwise skipped_export may be
7236 # set to false by a later but shorter cmd.
7237 break
7239 done
7240 IFS="$save_ifs"
7241 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7242 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7243 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7248 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7249 tmp_export_symbols="$export_symbols"
7250 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7251 $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
7254 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7255 # The given exports_symbols file has to be filtered, so filter it.
7256 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7257 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7258 # 's' commands which not all seds can handle. GNU sed should be fine
7259 # though. Also, the filter scales superlinearly with the number of
7260 # global variables. join(1) would be nice here, but unfortunately
7261 # isn't a blessed tool.
7262 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7263 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7264 export_symbols=$output_objdir/$libname.def
7265 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7268 tmp_deplibs=
7269 for test_deplib in $deplibs; do
7270 case " $convenience " in
7271 *" $test_deplib "*) ;;
7273 tmp_deplibs="$tmp_deplibs $test_deplib"
7275 esac
7276 done
7277 deplibs="$tmp_deplibs"
7279 if test -n "$convenience"; then
7280 if test -n "$whole_archive_flag_spec" &&
7281 test "$compiler_needs_object" = yes &&
7282 test -z "$libobjs"; then
7283 # extract the archives, so we have objects to list.
7284 # TODO: could optimize this to just extract one archive.
7285 whole_archive_flag_spec=
7287 if test -n "$whole_archive_flag_spec"; then
7288 save_libobjs=$libobjs
7289 eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7290 test "X$libobjs" = "X " && libobjs=
7291 else
7292 gentop="$output_objdir/${outputname}x"
7293 generated="$generated $gentop"
7295 func_extract_archives $gentop $convenience
7296 libobjs="$libobjs $func_extract_archives_result"
7297 test "X$libobjs" = "X " && libobjs=
7301 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7302 eval "flag=\"$thread_safe_flag_spec\""
7303 linker_flags="$linker_flags $flag"
7306 # Make a backup of the uninstalled library when relinking
7307 if test "$mode" = relink; then
7308 $opt_dry_run || (cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U) || exit $?
7311 # Do each of the archive commands.
7312 if test "$module" = yes && test -n "$module_cmds" ; then
7313 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7314 eval "test_cmds=\"$module_expsym_cmds\""
7315 cmds=$module_expsym_cmds
7316 else
7317 eval "test_cmds=\"$module_cmds\""
7318 cmds=$module_cmds
7320 else
7321 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7322 eval "test_cmds=\"$archive_expsym_cmds\""
7323 cmds=$archive_expsym_cmds
7324 else
7325 eval "test_cmds=\"$archive_cmds\""
7326 cmds=$archive_cmds
7330 if test "X$skipped_export" != "X:" &&
7331 func_len " $test_cmds" &&
7332 len=$func_len_result &&
7333 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7335 else
7336 # The command line is too long to link in one step, link piecewise
7337 # or, if using GNU ld and skipped_export is not :, use a linker
7338 # script.
7340 # Save the value of $output and $libobjs because we want to
7341 # use them later. If we have whole_archive_flag_spec, we
7342 # want to use save_libobjs as it was before
7343 # whole_archive_flag_spec was expanded, because we can't
7344 # assume the linker understands whole_archive_flag_spec.
7345 # This may have to be revisited, in case too many
7346 # convenience libraries get linked in and end up exceeding
7347 # the spec.
7348 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7349 save_libobjs=$libobjs
7351 save_output=$output
7352 func_basename "$output"
7353 output_la=$func_basename_result
7355 # Clear the reloadable object creation command queue and
7356 # initialize k to one.
7357 test_cmds=
7358 concat_cmds=
7359 objlist=
7360 last_robj=
7363 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7364 output=${output_objdir}/${output_la}.lnkscript
7365 func_verbose "creating GNU ld script: $output"
7366 echo 'INPUT (' > $output
7367 for obj in $save_libobjs
7369 $ECHO "$obj" >> $output
7370 done
7371 echo ')' >> $output
7372 delfiles="$delfiles $output"
7373 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7374 output=${output_objdir}/${output_la}.lnk
7375 func_verbose "creating linker input file list: $output"
7376 : > $output
7377 set x $save_libobjs
7378 shift
7379 firstobj=
7380 if test "$compiler_needs_object" = yes; then
7381 firstobj="$1 "
7382 shift
7384 for obj
7386 $ECHO "$obj" >> $output
7387 done
7388 delfiles="$delfiles $output"
7389 output=$firstobj\"$file_list_spec$output\"
7390 else
7391 if test -n "$save_libobjs"; then
7392 func_verbose "creating reloadable object files..."
7393 output=$output_objdir/$output_la-${k}.$objext
7394 eval "test_cmds=\"$reload_cmds\""
7395 func_len " $test_cmds"
7396 len0=$func_len_result
7397 len=$len0
7399 # Loop over the list of objects to be linked.
7400 for obj in $save_libobjs
7402 func_len " $obj"
7403 func_arith $len + $func_len_result
7404 len=$func_arith_result
7405 if test "X$objlist" = X ||
7406 test "$len" -lt "$max_cmd_len"; then
7407 func_append objlist " $obj"
7408 else
7409 # The command $test_cmds is almost too long, add a
7410 # command to the queue.
7411 if test "$k" -eq 1 ; then
7412 # The first file doesn't have a previous command to add.
7413 reload_objs=$objlist
7414 eval "concat_cmds=\"$reload_cmds\""
7415 else
7416 # All subsequent reloadable object files will link in
7417 # the last one created.
7418 reload_objs="$objlist $last_robj"
7419 eval "concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\""
7421 last_robj=$output_objdir/$output_la-${k}.$objext
7422 func_arith $k + 1
7423 k=$func_arith_result
7424 output=$output_objdir/$output_la-${k}.$objext
7425 objlist=" $obj"
7426 func_len " $last_robj"
7427 func_arith $len0 + $func_len_result
7428 len=$func_arith_result
7430 done
7431 # Handle the remaining objects by creating one last
7432 # reloadable object file. All subsequent reloadable object
7433 # files will link in the last one created.
7434 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7435 reload_objs="$objlist $last_robj"
7436 eval "concat_cmds=\"\${concat_cmds}$reload_cmds\""
7437 if test -n "$last_robj"; then
7438 eval "concat_cmds=\"\${concat_cmds}~\$RM $last_robj\""
7440 delfiles="$delfiles $output"
7442 else
7443 output=
7446 if ${skipped_export-false}; then
7447 func_verbose "generating symbol list for \`$libname.la'"
7448 export_symbols="$output_objdir/$libname.exp"
7449 $opt_dry_run || $RM $export_symbols
7450 libobjs=$output
7451 # Append the command to create the export file.
7452 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7453 eval "concat_cmds=\"\$concat_cmds$export_symbols_cmds\""
7454 if test -n "$last_robj"; then
7455 eval "concat_cmds=\"\$concat_cmds~\$RM $last_robj\""
7459 test -n "$save_libobjs" &&
7460 func_verbose "creating a temporary reloadable object file: $output"
7462 # Loop through the commands generated above and execute them.
7463 save_ifs="$IFS"; IFS='~'
7464 for cmd in $concat_cmds; do
7465 IFS="$save_ifs"
7466 $opt_silent || {
7467 func_quote_for_expand "$cmd"
7468 eval "func_echo $func_quote_for_expand_result"
7470 $opt_dry_run || eval "$cmd" || {
7471 lt_exit=$?
7473 # Restore the uninstalled library and exit
7474 if test "$mode" = relink; then
7475 ( cd "$output_objdir" && \
7476 $RM "${realname}T" && \
7477 $MV "${realname}U" "$realname" )
7480 exit $lt_exit
7482 done
7483 IFS="$save_ifs"
7485 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7486 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7487 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7491 if ${skipped_export-false}; then
7492 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7493 tmp_export_symbols="$export_symbols"
7494 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7495 $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
7498 if test -n "$orig_export_symbols"; then
7499 # The given exports_symbols file has to be filtered, so filter it.
7500 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7501 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7502 # 's' commands which not all seds can handle. GNU sed should be fine
7503 # though. Also, the filter scales superlinearly with the number of
7504 # global variables. join(1) would be nice here, but unfortunately
7505 # isn't a blessed tool.
7506 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7507 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7508 export_symbols=$output_objdir/$libname.def
7509 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7513 libobjs=$output
7514 # Restore the value of output.
7515 output=$save_output
7517 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7518 eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7519 test "X$libobjs" = "X " && libobjs=
7521 # Expand the library linking commands again to reset the
7522 # value of $libobjs for piecewise linking.
7524 # Do each of the archive commands.
7525 if test "$module" = yes && test -n "$module_cmds" ; then
7526 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7527 cmds=$module_expsym_cmds
7528 else
7529 cmds=$module_cmds
7531 else
7532 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7533 cmds=$archive_expsym_cmds
7534 else
7535 cmds=$archive_cmds
7540 if test -n "$delfiles"; then
7541 # Append the command to remove temporary files to $cmds.
7542 eval "cmds=\"\$cmds~\$RM $delfiles\""
7545 # Add any objects from preloaded convenience libraries
7546 if test -n "$dlprefiles"; then
7547 gentop="$output_objdir/${outputname}x"
7548 generated="$generated $gentop"
7550 func_extract_archives $gentop $dlprefiles
7551 libobjs="$libobjs $func_extract_archives_result"
7552 test "X$libobjs" = "X " && libobjs=
7555 save_ifs="$IFS"; IFS='~'
7556 for cmd in $cmds; do
7557 IFS="$save_ifs"
7558 eval "cmd=\"$cmd\""
7559 $opt_silent || {
7560 func_quote_for_expand "$cmd"
7561 eval "func_echo $func_quote_for_expand_result"
7563 $opt_dry_run || eval "$cmd" || {
7564 lt_exit=$?
7566 # Restore the uninstalled library and exit
7567 if test "$mode" = relink; then
7568 ( cd "$output_objdir" && \
7569 $RM "${realname}T" && \
7570 $MV "${realname}U" "$realname" )
7573 exit $lt_exit
7575 done
7576 IFS="$save_ifs"
7578 # Restore the uninstalled library and exit
7579 if test "$mode" = relink; then
7580 $opt_dry_run || (cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname) || exit $?
7582 if test -n "$convenience"; then
7583 if test -z "$whole_archive_flag_spec"; then
7584 func_show_eval '${RM}r "$gentop"'
7588 exit $EXIT_SUCCESS
7591 # Create links to the real library.
7592 for linkname in $linknames; do
7593 if test "$realname" != "$linkname"; then
7594 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7596 done
7598 # If -module or -export-dynamic was specified, set the dlname.
7599 if test "$module" = yes || test "$export_dynamic" = yes; then
7600 # On all known operating systems, these are identical.
7601 dlname="$soname"
7606 obj)
7607 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7608 func_warning "\`-dlopen' is ignored for objects"
7611 case " $deplibs" in
7612 *\ -l* | *\ -L*)
7613 func_warning "\`-l' and \`-L' are ignored for objects" ;;
7614 esac
7616 test -n "$rpath" && \
7617 func_warning "\`-rpath' is ignored for objects"
7619 test -n "$xrpath" && \
7620 func_warning "\`-R' is ignored for objects"
7622 test -n "$vinfo" && \
7623 func_warning "\`-version-info' is ignored for objects"
7625 test -n "$release" && \
7626 func_warning "\`-release' is ignored for objects"
7628 case $output in
7629 *.lo)
7630 test -n "$objs$old_deplibs" && \
7631 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7633 libobj=$output
7634 func_lo2o "$libobj"
7635 obj=$func_lo2o_result
7638 libobj=
7639 obj="$output"
7641 esac
7643 # Delete the old objects.
7644 $opt_dry_run || $RM $obj $libobj
7646 # Objects from convenience libraries. This assumes
7647 # single-version convenience libraries. Whenever we create
7648 # different ones for PIC/non-PIC, this we'll have to duplicate
7649 # the extraction.
7650 reload_conv_objs=
7651 gentop=
7652 # reload_cmds runs $LD directly, so let us get rid of
7653 # -Wl from whole_archive_flag_spec and hope we can get by with
7654 # turning comma into space..
7657 if test -n "$convenience"; then
7658 if test -n "$whole_archive_flag_spec"; then
7659 eval "tmp_whole_archive_flags=\"$whole_archive_flag_spec\""
7660 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
7661 else
7662 gentop="$output_objdir/${obj}x"
7663 generated="$generated $gentop"
7665 func_extract_archives $gentop $convenience
7666 reload_conv_objs="$reload_objs $func_extract_archives_result"
7670 # Create the old-style object.
7671 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7673 output="$obj"
7674 func_execute_cmds "$reload_cmds" 'exit $?'
7676 # Exit if we aren't doing a library object file.
7677 if test -z "$libobj"; then
7678 if test -n "$gentop"; then
7679 func_show_eval '${RM}r "$gentop"'
7682 exit $EXIT_SUCCESS
7685 if test "$build_libtool_libs" != yes; then
7686 if test -n "$gentop"; then
7687 func_show_eval '${RM}r "$gentop"'
7690 # Create an invalid libtool object if no PIC, so that we don't
7691 # accidentally link it into a program.
7692 # $show "echo timestamp > $libobj"
7693 # $opt_dry_run || echo timestamp > $libobj || exit $?
7694 exit $EXIT_SUCCESS
7697 if test -n "$pic_flag" || test "$pic_mode" != default; then
7698 # Only do commands if we really have different PIC objects.
7699 reload_objs="$libobjs $reload_conv_objs"
7700 output="$libobj"
7701 func_execute_cmds "$reload_cmds" 'exit $?'
7704 if test -n "$gentop"; then
7705 func_show_eval '${RM}r "$gentop"'
7708 exit $EXIT_SUCCESS
7711 prog)
7712 case $host in
7713 *cygwin*) func_stripname '' '.exe' "$output"
7714 output=$func_stripname_result.exe;;
7715 esac
7716 test -n "$vinfo" && \
7717 func_warning "\`-version-info' is ignored for programs"
7719 test -n "$release" && \
7720 func_warning "\`-release' is ignored for programs"
7722 test "$preload" = yes \
7723 && test "$dlopen_support" = unknown \
7724 && test "$dlopen_self" = unknown \
7725 && test "$dlopen_self_static" = unknown && \
7726 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7728 case $host in
7729 *-*-rhapsody* | *-*-darwin1.[012])
7730 # On Rhapsody replace the C library is the System framework
7731 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
7732 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
7734 esac
7736 case $host in
7737 *-*-darwin*)
7738 # Don't allow lazy linking, it breaks C++ global constructors
7739 # But is supposedly fixed on 10.4 or later (yay!).
7740 if test "$tagname" = CXX ; then
7741 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7742 10.[0123])
7743 compile_command="$compile_command ${wl}-bind_at_load"
7744 finalize_command="$finalize_command ${wl}-bind_at_load"
7746 esac
7748 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7749 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7750 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7752 esac
7755 # move library search paths that coincide with paths to not yet
7756 # installed libraries to the beginning of the library search list
7757 new_libs=
7758 for path in $notinst_path; do
7759 case " $new_libs " in
7760 *" -L$path/$objdir "*) ;;
7762 case " $compile_deplibs " in
7763 *" -L$path/$objdir "*)
7764 new_libs="$new_libs -L$path/$objdir" ;;
7765 esac
7767 esac
7768 done
7769 for deplib in $compile_deplibs; do
7770 case $deplib in
7771 -L*)
7772 case " $new_libs " in
7773 *" $deplib "*) ;;
7774 *) new_libs="$new_libs $deplib" ;;
7775 esac
7777 *) new_libs="$new_libs $deplib" ;;
7778 esac
7779 done
7780 compile_deplibs="$new_libs"
7783 compile_command="$compile_command $compile_deplibs"
7784 finalize_command="$finalize_command $finalize_deplibs"
7786 if test -n "$rpath$xrpath"; then
7787 # If the user specified any rpath flags, then add them.
7788 for libdir in $rpath $xrpath; do
7789 # This is the magic to use -rpath.
7790 case "$finalize_rpath " in
7791 *" $libdir "*) ;;
7792 *) finalize_rpath="$finalize_rpath $libdir" ;;
7793 esac
7794 done
7797 # Now hardcode the library paths
7798 rpath=
7799 hardcode_libdirs=
7800 for libdir in $compile_rpath $finalize_rpath; do
7801 if test -n "$hardcode_libdir_flag_spec"; then
7802 if test -n "$hardcode_libdir_separator"; then
7803 if test -z "$hardcode_libdirs"; then
7804 hardcode_libdirs="$libdir"
7805 else
7806 # Just accumulate the unique libdirs.
7807 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7808 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7811 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7813 esac
7815 else
7816 eval "flag=\"$hardcode_libdir_flag_spec\""
7817 rpath="$rpath $flag"
7819 elif test -n "$runpath_var"; then
7820 case "$perm_rpath " in
7821 *" $libdir "*) ;;
7822 *) perm_rpath="$perm_rpath $libdir" ;;
7823 esac
7825 case $host in
7826 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7827 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7828 case :$dllsearchpath: in
7829 *":$libdir:"*) ;;
7830 ::) dllsearchpath=$libdir;;
7831 *) dllsearchpath="$dllsearchpath:$libdir";;
7832 esac
7833 case :$dllsearchpath: in
7834 *":$testbindir:"*) ;;
7835 ::) dllsearchpath=$testbindir;;
7836 *) dllsearchpath="$dllsearchpath:$testbindir";;
7837 esac
7839 esac
7840 done
7841 # Substitute the hardcoded libdirs into the rpath.
7842 if test -n "$hardcode_libdir_separator" &&
7843 test -n "$hardcode_libdirs"; then
7844 libdir="$hardcode_libdirs"
7845 eval "rpath=\" $hardcode_libdir_flag_spec\""
7847 compile_rpath="$rpath"
7849 rpath=
7850 hardcode_libdirs=
7851 for libdir in $finalize_rpath; do
7852 if test -n "$hardcode_libdir_flag_spec"; then
7853 if test -n "$hardcode_libdir_separator"; then
7854 if test -z "$hardcode_libdirs"; then
7855 hardcode_libdirs="$libdir"
7856 else
7857 # Just accumulate the unique libdirs.
7858 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7859 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7862 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7864 esac
7866 else
7867 eval "flag=\"$hardcode_libdir_flag_spec\""
7868 rpath="$rpath $flag"
7870 elif test -n "$runpath_var"; then
7871 case "$finalize_perm_rpath " in
7872 *" $libdir "*) ;;
7873 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7874 esac
7876 done
7877 # Substitute the hardcoded libdirs into the rpath.
7878 if test -n "$hardcode_libdir_separator" &&
7879 test -n "$hardcode_libdirs"; then
7880 libdir="$hardcode_libdirs"
7881 eval "rpath=\" $hardcode_libdir_flag_spec\""
7883 finalize_rpath="$rpath"
7885 if test -n "$libobjs" && test "$build_old_libs" = yes; then
7886 # Transform all the library objects into standard objects.
7887 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7888 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7891 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7893 # template prelinking step
7894 if test -n "$prelink_cmds"; then
7895 func_execute_cmds "$prelink_cmds" 'exit $?'
7898 wrappers_required=yes
7899 case $host in
7900 *cegcc* | *mingw32ce*)
7901 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
7902 wrappers_required=no
7904 *cygwin* | *mingw* )
7905 if test "$build_libtool_libs" != yes; then
7906 wrappers_required=no
7910 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7911 wrappers_required=no
7914 esac
7915 if test "$wrappers_required" = no; then
7916 # Replace the output file specification.
7917 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7918 link_command="$compile_command$compile_rpath"
7920 # We have no uninstalled library dependencies, so finalize right now.
7921 exit_status=0
7922 func_show_eval "$link_command" 'exit_status=$?'
7924 # Delete the generated files.
7925 if test -f "$output_objdir/${outputname}S.${objext}"; then
7926 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7929 exit $exit_status
7932 if test -n "$compile_shlibpath$finalize_shlibpath"; then
7933 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7935 if test -n "$finalize_shlibpath"; then
7936 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7939 compile_var=
7940 finalize_var=
7941 if test -n "$runpath_var"; then
7942 if test -n "$perm_rpath"; then
7943 # We should set the runpath_var.
7944 rpath=
7945 for dir in $perm_rpath; do
7946 rpath="$rpath$dir:"
7947 done
7948 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7950 if test -n "$finalize_perm_rpath"; then
7951 # We should set the runpath_var.
7952 rpath=
7953 for dir in $finalize_perm_rpath; do
7954 rpath="$rpath$dir:"
7955 done
7956 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7960 if test "$no_install" = yes; then
7961 # We don't need to create a wrapper script.
7962 link_command="$compile_var$compile_command$compile_rpath"
7963 # Replace the output file specification.
7964 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7965 # Delete the old output file.
7966 $opt_dry_run || $RM $output
7967 # Link the executable and exit
7968 func_show_eval "$link_command" 'exit $?'
7969 exit $EXIT_SUCCESS
7972 if test "$hardcode_action" = relink; then
7973 # Fast installation is not supported
7974 link_command="$compile_var$compile_command$compile_rpath"
7975 relink_command="$finalize_var$finalize_command$finalize_rpath"
7977 func_warning "this platform does not like uninstalled shared libraries"
7978 func_warning "\`$output' will be relinked during installation"
7979 else
7980 if test "$fast_install" != no; then
7981 link_command="$finalize_var$compile_command$finalize_rpath"
7982 if test "$fast_install" = yes; then
7983 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7984 else
7985 # fast_install is set to needless
7986 relink_command=
7988 else
7989 link_command="$compile_var$compile_command$compile_rpath"
7990 relink_command="$finalize_var$finalize_command$finalize_rpath"
7994 # Replace the output file specification.
7995 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7997 # Delete the old output files.
7998 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8000 func_show_eval "$link_command" 'exit $?'
8002 # Now create the wrapper script.
8003 func_verbose "creating $output"
8005 # Quote the relink command for shipping.
8006 if test -n "$relink_command"; then
8007 # Preserve any variables that may affect compiler behavior
8008 for var in $variables_saved_for_relink; do
8009 if eval test -z \"\${$var+set}\"; then
8010 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8011 elif eval var_value=\$$var; test -z "$var_value"; then
8012 relink_command="$var=; export $var; $relink_command"
8013 else
8014 func_quote_for_eval "$var_value"
8015 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8017 done
8018 relink_command="(cd `pwd`; $relink_command)"
8019 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8022 # Only actually do things if not in dry run mode.
8023 $opt_dry_run || {
8024 # win32 will think the script is a binary if it has
8025 # a .exe suffix, so we strip it off here.
8026 case $output in
8027 *.exe) func_stripname '' '.exe' "$output"
8028 output=$func_stripname_result ;;
8029 esac
8030 # test for cygwin because mv fails w/o .exe extensions
8031 case $host in
8032 *cygwin*)
8033 exeext=.exe
8034 func_stripname '' '.exe' "$outputname"
8035 outputname=$func_stripname_result ;;
8036 *) exeext= ;;
8037 esac
8038 case $host in
8039 *cygwin* | *mingw* )
8040 func_dirname_and_basename "$output" "" "."
8041 output_name=$func_basename_result
8042 output_path=$func_dirname_result
8043 cwrappersource="$output_path/$objdir/lt-$output_name.c"
8044 cwrapper="$output_path/$output_name.exe"
8045 $RM $cwrappersource $cwrapper
8046 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8048 func_emit_cwrapperexe_src > $cwrappersource
8050 # The wrapper executable is built using the $host compiler,
8051 # because it contains $host paths and files. If cross-
8052 # compiling, it, like the target executable, must be
8053 # executed on the $host or under an emulation environment.
8054 $opt_dry_run || {
8055 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8056 $STRIP $cwrapper
8059 # Now, create the wrapper script for func_source use:
8060 func_ltwrapper_scriptname $cwrapper
8061 $RM $func_ltwrapper_scriptname_result
8062 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8063 $opt_dry_run || {
8064 # note: this script will not be executed, so do not chmod.
8065 if test "x$build" = "x$host" ; then
8066 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8067 else
8068 func_emit_wrapper no > $func_ltwrapper_scriptname_result
8073 $RM $output
8074 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8076 func_emit_wrapper no > $output
8077 chmod +x $output
8079 esac
8081 exit $EXIT_SUCCESS
8083 esac
8085 # See if we need to build an old-fashioned archive.
8086 for oldlib in $oldlibs; do
8088 if test "$build_libtool_libs" = convenience; then
8089 oldobjs="$libobjs_save $symfileobj"
8090 addlibs="$convenience"
8091 build_libtool_libs=no
8092 else
8093 if test "$build_libtool_libs" = module; then
8094 oldobjs="$libobjs_save"
8095 build_libtool_libs=no
8096 else
8097 oldobjs="$old_deplibs $non_pic_objects"
8098 if test "$preload" = yes && test -f "$symfileobj"; then
8099 oldobjs="$oldobjs $symfileobj"
8102 addlibs="$old_convenience"
8105 if test -n "$addlibs"; then
8106 gentop="$output_objdir/${outputname}x"
8107 generated="$generated $gentop"
8109 func_extract_archives $gentop $addlibs
8110 oldobjs="$oldobjs $func_extract_archives_result"
8113 # Do each command in the archive commands.
8114 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8115 cmds=$old_archive_from_new_cmds
8116 else
8118 # Add any objects from preloaded convenience libraries
8119 if test -n "$dlprefiles"; then
8120 gentop="$output_objdir/${outputname}x"
8121 generated="$generated $gentop"
8123 func_extract_archives $gentop $dlprefiles
8124 oldobjs="$oldobjs $func_extract_archives_result"
8127 # POSIX demands no paths to be encoded in archives. We have
8128 # to avoid creating archives with duplicate basenames if we
8129 # might have to extract them afterwards, e.g., when creating a
8130 # static archive out of a convenience library, or when linking
8131 # the entirety of a libtool archive into another (currently
8132 # not supported by libtool).
8133 if (for obj in $oldobjs
8135 func_basename "$obj"
8136 $ECHO "$func_basename_result"
8137 done | sort | sort -uc >/dev/null 2>&1); then
8139 else
8140 echo "copying selected object files to avoid basename conflicts..."
8141 gentop="$output_objdir/${outputname}x"
8142 generated="$generated $gentop"
8143 func_mkdir_p "$gentop"
8144 save_oldobjs=$oldobjs
8145 oldobjs=
8146 counter=1
8147 for obj in $save_oldobjs
8149 func_basename "$obj"
8150 objbase="$func_basename_result"
8151 case " $oldobjs " in
8152 " ") oldobjs=$obj ;;
8153 *[\ /]"$objbase "*)
8154 while :; do
8155 # Make sure we don't pick an alternate name that also
8156 # overlaps.
8157 newobj=lt$counter-$objbase
8158 func_arith $counter + 1
8159 counter=$func_arith_result
8160 case " $oldobjs " in
8161 *[\ /]"$newobj "*) ;;
8162 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
8163 esac
8164 done
8165 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8166 oldobjs="$oldobjs $gentop/$newobj"
8168 *) oldobjs="$oldobjs $obj" ;;
8169 esac
8170 done
8172 eval "cmds=\"$old_archive_cmds\""
8174 func_len " $cmds"
8175 len=$func_len_result
8176 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8177 cmds=$old_archive_cmds
8178 else
8179 # the command line is too long to link in one step, link in parts
8180 func_verbose "using piecewise archive linking..."
8181 save_RANLIB=$RANLIB
8182 RANLIB=:
8183 objlist=
8184 concat_cmds=
8185 save_oldobjs=$oldobjs
8186 oldobjs=
8187 # Is there a better way of finding the last object in the list?
8188 for obj in $save_oldobjs
8190 last_oldobj=$obj
8191 done
8192 eval "test_cmds=\"$old_archive_cmds\""
8193 func_len " $test_cmds"
8194 len0=$func_len_result
8195 len=$len0
8196 for obj in $save_oldobjs
8198 func_len " $obj"
8199 func_arith $len + $func_len_result
8200 len=$func_arith_result
8201 func_append objlist " $obj"
8202 if test "$len" -lt "$max_cmd_len"; then
8204 else
8205 # the above command should be used before it gets too long
8206 oldobjs=$objlist
8207 if test "$obj" = "$last_oldobj" ; then
8208 RANLIB=$save_RANLIB
8210 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8211 eval "concat_cmds=\"\${concat_cmds}$old_archive_cmds\""
8212 objlist=
8213 len=$len0
8215 done
8216 RANLIB=$save_RANLIB
8217 oldobjs=$objlist
8218 if test "X$oldobjs" = "X" ; then
8219 eval "cmds=\"\$concat_cmds\""
8220 else
8221 eval "cmds=\"\$concat_cmds~\$old_archive_cmds\""
8225 func_execute_cmds "$cmds" 'exit $?'
8226 done
8228 test -n "$generated" && \
8229 func_show_eval "${RM}r$generated"
8231 # Now create the libtool archive.
8232 case $output in
8233 *.la)
8234 old_library=
8235 test "$build_old_libs" = yes && old_library="$libname.$libext"
8236 func_verbose "creating $output"
8238 # Preserve any variables that may affect compiler behavior
8239 for var in $variables_saved_for_relink; do
8240 if eval test -z \"\${$var+set}\"; then
8241 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8242 elif eval var_value=\$$var; test -z "$var_value"; then
8243 relink_command="$var=; export $var; $relink_command"
8244 else
8245 func_quote_for_eval "$var_value"
8246 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8248 done
8249 # Quote the link command for shipping.
8250 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8251 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8252 if test "$hardcode_automatic" = yes ; then
8253 relink_command=
8256 # Only create the output if not a dry run.
8257 $opt_dry_run || {
8258 for installed in no yes; do
8259 if test "$installed" = yes; then
8260 if test -z "$install_libdir"; then
8261 break
8263 output="$output_objdir/$outputname"i
8264 # Replace all uninstalled libtool libraries with the installed ones
8265 newdependency_libs=
8266 for deplib in $dependency_libs; do
8267 case $deplib in
8268 *.la)
8269 func_basename "$deplib"
8270 name="$func_basename_result"
8271 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8272 test -z "$libdir" && \
8273 func_fatal_error "\`$deplib' is not a valid libtool archive"
8274 newdependency_libs="$newdependency_libs $libdir/$name"
8276 *) newdependency_libs="$newdependency_libs $deplib" ;;
8277 esac
8278 done
8279 dependency_libs="$newdependency_libs"
8280 newdlfiles=
8282 for lib in $dlfiles; do
8283 case $lib in
8284 *.la)
8285 func_basename "$lib"
8286 name="$func_basename_result"
8287 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8288 test -z "$libdir" && \
8289 func_fatal_error "\`$lib' is not a valid libtool archive"
8290 newdlfiles="$newdlfiles $libdir/$name"
8292 *) newdlfiles="$newdlfiles $lib" ;;
8293 esac
8294 done
8295 dlfiles="$newdlfiles"
8296 newdlprefiles=
8297 for lib in $dlprefiles; do
8298 case $lib in
8299 *.la)
8300 # Only pass preopened files to the pseudo-archive (for
8301 # eventual linking with the app. that links it) if we
8302 # didn't already link the preopened objects directly into
8303 # the library:
8304 func_basename "$lib"
8305 name="$func_basename_result"
8306 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8307 test -z "$libdir" && \
8308 func_fatal_error "\`$lib' is not a valid libtool archive"
8309 newdlprefiles="$newdlprefiles $libdir/$name"
8311 esac
8312 done
8313 dlprefiles="$newdlprefiles"
8314 else
8315 newdlfiles=
8316 for lib in $dlfiles; do
8317 case $lib in
8318 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8319 *) abs=`pwd`"/$lib" ;;
8320 esac
8321 newdlfiles="$newdlfiles $abs"
8322 done
8323 dlfiles="$newdlfiles"
8324 newdlprefiles=
8325 for lib in $dlprefiles; do
8326 case $lib in
8327 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8328 *) abs=`pwd`"/$lib" ;;
8329 esac
8330 newdlprefiles="$newdlprefiles $abs"
8331 done
8332 dlprefiles="$newdlprefiles"
8334 $RM $output
8335 # place dlname in correct position for cygwin
8336 # In fact, it would be nice if we could use this code for all target
8337 # systems that can't hard-code library paths into their executables
8338 # and that have no shared library path variable independent of PATH,
8339 # but it turns out we can't easily determine that from inspecting
8340 # libtool variables, so we have to hard-code the OSs to which it
8341 # applies here; at the moment, that means platforms that use the PE
8342 # object format with DLL files. See the long comment at the top of
8343 # tests/bindir.at for full details.
8344 tdlname=$dlname
8345 case $host,$output,$installed,$module,$dlname in
8346 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
8347 # If a -bindir argument was supplied, place the dll there.
8348 if test "x$bindir" != x ;
8349 then
8350 func_relative_path "$install_libdir" "$bindir"
8351 tdlname=$func_relative_path_result$dlname
8352 else
8353 # Otherwise fall back on heuristic.
8354 tdlname=../bin/$dlname
8357 esac
8358 $ECHO > $output "\
8359 # $outputname - a libtool library file
8360 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8362 # Please DO NOT delete this file!
8363 # It is necessary for linking the library.
8365 # The name that we can dlopen(3).
8366 dlname='$tdlname'
8368 # Names of this library.
8369 library_names='$library_names'
8371 # The name of the static archive.
8372 old_library='$old_library'
8374 # Linker flags that can not go in dependency_libs.
8375 inherited_linker_flags='$new_inherited_linker_flags'
8377 # Libraries that this one depends upon.
8378 dependency_libs='$dependency_libs'
8380 # Names of additional weak libraries provided by this library
8381 weak_library_names='$weak_libs'
8383 # Version information for $libname.
8384 current=$current
8385 age=$age
8386 revision=$revision
8388 # Is this an already installed library?
8389 installed=$installed
8391 # Should we warn about portability when linking against -modules?
8392 shouldnotlink=$module
8394 # Files to dlopen/dlpreopen
8395 dlopen='$dlfiles'
8396 dlpreopen='$dlprefiles'
8398 # Directory that this library needs to be installed in:
8399 libdir='$install_libdir'"
8400 if test "$installed" = no && test "$need_relink" = yes; then
8401 $ECHO >> $output "\
8402 relink_command=\"$relink_command\""
8404 done
8407 # Do a symbolic link so that the libtool archive can be found in
8408 # LD_LIBRARY_PATH before the program is installed.
8409 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8411 esac
8412 exit $EXIT_SUCCESS
8415 { test "$mode" = link || test "$mode" = relink; } &&
8416 func_mode_link ${1+"$@"}
8419 # func_mode_uninstall arg...
8420 func_mode_uninstall ()
8422 $opt_debug
8423 RM="$nonopt"
8424 files=
8425 rmforce=
8426 exit_status=0
8428 # This variable tells wrapper scripts just to set variables rather
8429 # than running their programs.
8430 libtool_install_magic="$magic"
8432 for arg
8434 case $arg in
8435 -f) RM="$RM $arg"; rmforce=yes ;;
8436 -*) RM="$RM $arg" ;;
8437 *) files="$files $arg" ;;
8438 esac
8439 done
8441 test -z "$RM" && \
8442 func_fatal_help "you must specify an RM program"
8444 rmdirs=
8446 origobjdir="$objdir"
8447 for file in $files; do
8448 func_dirname "$file" "" "."
8449 dir="$func_dirname_result"
8450 if test "X$dir" = X.; then
8451 objdir="$origobjdir"
8452 else
8453 objdir="$dir/$origobjdir"
8455 func_basename "$file"
8456 name="$func_basename_result"
8457 test "$mode" = uninstall && objdir="$dir"
8459 # Remember objdir for removal later, being careful to avoid duplicates
8460 if test "$mode" = clean; then
8461 case " $rmdirs " in
8462 *" $objdir "*) ;;
8463 *) rmdirs="$rmdirs $objdir" ;;
8464 esac
8467 # Don't error if the file doesn't exist and rm -f was used.
8468 if { test -L "$file"; } >/dev/null 2>&1 ||
8469 { test -h "$file"; } >/dev/null 2>&1 ||
8470 test -f "$file"; then
8472 elif test -d "$file"; then
8473 exit_status=1
8474 continue
8475 elif test "$rmforce" = yes; then
8476 continue
8479 rmfiles="$file"
8481 case $name in
8482 *.la)
8483 # Possibly a libtool archive, so verify it.
8484 if func_lalib_p "$file"; then
8485 func_source $dir/$name
8487 # Delete the libtool libraries and symlinks.
8488 for n in $library_names; do
8489 rmfiles="$rmfiles $objdir/$n"
8490 done
8491 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8493 case "$mode" in
8494 clean)
8495 case " $library_names " in
8496 # " " in the beginning catches empty $dlname
8497 *" $dlname "*) ;;
8498 *) rmfiles="$rmfiles $objdir/$dlname" ;;
8499 esac
8500 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8502 uninstall)
8503 if test -n "$library_names"; then
8504 # Do each command in the postuninstall commands.
8505 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8508 if test -n "$old_library"; then
8509 # Do each command in the old_postuninstall commands.
8510 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8512 # FIXME: should reinstall the best remaining shared library.
8514 esac
8518 *.lo)
8519 # Possibly a libtool object, so verify it.
8520 if func_lalib_p "$file"; then
8522 # Read the .lo file
8523 func_source $dir/$name
8525 # Add PIC object to the list of files to remove.
8526 if test -n "$pic_object" &&
8527 test "$pic_object" != none; then
8528 rmfiles="$rmfiles $dir/$pic_object"
8531 # Add non-PIC object to the list of files to remove.
8532 if test -n "$non_pic_object" &&
8533 test "$non_pic_object" != none; then
8534 rmfiles="$rmfiles $dir/$non_pic_object"
8540 if test "$mode" = clean ; then
8541 noexename=$name
8542 case $file in
8543 *.exe)
8544 func_stripname '' '.exe' "$file"
8545 file=$func_stripname_result
8546 func_stripname '' '.exe' "$name"
8547 noexename=$func_stripname_result
8548 # $file with .exe has already been added to rmfiles,
8549 # add $file without .exe
8550 rmfiles="$rmfiles $file"
8552 esac
8553 # Do a test to see if this is a libtool program.
8554 if func_ltwrapper_p "$file"; then
8555 if func_ltwrapper_executable_p "$file"; then
8556 func_ltwrapper_scriptname "$file"
8557 relink_command=
8558 func_source $func_ltwrapper_scriptname_result
8559 rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8560 else
8561 relink_command=
8562 func_source $dir/$noexename
8565 # note $name still contains .exe if it was in $file originally
8566 # as does the version of $file that was added into $rmfiles
8567 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8568 if test "$fast_install" = yes && test -n "$relink_command"; then
8569 rmfiles="$rmfiles $objdir/lt-$name"
8571 if test "X$noexename" != "X$name" ; then
8572 rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8577 esac
8578 func_show_eval "$RM $rmfiles" 'exit_status=1'
8579 done
8580 objdir="$origobjdir"
8582 # Try to remove the ${objdir}s in the directories where we deleted files
8583 for dir in $rmdirs; do
8584 if test -d "$dir"; then
8585 func_show_eval "rmdir $dir >/dev/null 2>&1"
8587 done
8589 exit $exit_status
8592 { test "$mode" = uninstall || test "$mode" = clean; } &&
8593 func_mode_uninstall ${1+"$@"}
8595 test -z "$mode" && {
8596 help="$generic_help"
8597 func_fatal_help "you must specify a MODE"
8600 test -z "$exec_cmd" && \
8601 func_fatal_help "invalid operation mode \`$mode'"
8603 if test -n "$exec_cmd"; then
8604 eval exec "$exec_cmd"
8605 exit $EXIT_FAILURE
8608 exit $exit_status
8611 # The TAGs below are defined such that we never get into a situation
8612 # in which we disable both kinds of libraries. Given conflicting
8613 # choices, we go for a static library, that is the most portable,
8614 # since we can't tell whether shared libraries were disabled because
8615 # the user asked for that or because the platform doesn't support
8616 # them. This is particularly important on AIX, because we don't
8617 # support having both static and shared libraries enabled at the same
8618 # time on that platform, so we default to a shared-only configuration.
8619 # If a disable-shared tag is given, we'll fallback to a static-only
8620 # configuration. But we'll never go from static-only to shared-only.
8622 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8623 build_libtool_libs=no
8624 build_old_libs=yes
8625 # ### END LIBTOOL TAG CONFIG: disable-shared
8627 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8628 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8629 # ### END LIBTOOL TAG CONFIG: disable-static
8631 # Local Variables:
8632 # mode:shell-script
8633 # sh-indentation:2
8634 # End:
8635 # vi:sw=2