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