VirtualBox

source: vbox/trunk/src/libs/libvorbis-1.3.7/ltmain.sh@ 103131

Last change on this file since 103131 was 96468, checked in by vboxsync, 2 years ago

libs/libvorbis-1.3.7: Re-exporting, hopefully this time everything is there. bugref:10275

  • Property svn:eol-style set to LF
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
File size: 319.6 KB
Line 
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 Debian-2.4.6-14"
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='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=2015-10-07.11; # 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 _G_rc_run_hooks=false
1534
1535 case " $hookable_fns " in
1536 *" $1 "*) ;;
1537 *) func_fatal_error "'$1' does not support hook funcions.n" ;;
1538 esac
1539
1540 eval _G_hook_fns=\$$1_hooks; shift
1541
1542 for _G_hook in $_G_hook_fns; do
1543 if eval $_G_hook '"$@"'; then
1544 # store returned options list back into positional
1545 # parameters for next 'cmd' execution.
1546 eval _G_hook_result=\$${_G_hook}_result
1547 eval set dummy "$_G_hook_result"; shift
1548 _G_rc_run_hooks=:
1549 fi
1550 done
1551
1552 $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
1553}
1554
1555
1556
1557## --------------- ##
1558## Option parsing. ##
1559## --------------- ##
1560
1561# In order to add your own option parsing hooks, you must accept the
1562# full positional parameter list in your hook function, you may remove/edit
1563# any options that you action, and then pass back the remaining unprocessed
1564# options in '<hooked_function_name>_result', escaped suitably for
1565# 'eval'. In this case you also must return $EXIT_SUCCESS to let the
1566# hook's caller know that it should pay attention to
1567# '<hooked_function_name>_result'. Returning $EXIT_FAILURE signalizes that
1568# arguments are left untouched by the hook and therefore caller will ignore the
1569# result variable.
1570#
1571# Like this:
1572#
1573# my_options_prep ()
1574# {
1575# $debug_cmd
1576#
1577# # Extend the existing usage message.
1578# usage_message=$usage_message'
1579# -s, --silent don'\''t print informational messages
1580# '
1581# # No change in '$@' (ignored completely by this hook). There is
1582# # no need to do the equivalent (but slower) action:
1583# # func_quote_for_eval ${1+"$@"}
1584# # my_options_prep_result=$func_quote_for_eval_result
1585# false
1586# }
1587# func_add_hook func_options_prep my_options_prep
1588#
1589#
1590# my_silent_option ()
1591# {
1592# $debug_cmd
1593#
1594# args_changed=false
1595#
1596# # Note that for efficiency, we parse as many options as we can
1597# # recognise in a loop before passing the remainder back to the
1598# # caller on the first unrecognised argument we encounter.
1599# while test $# -gt 0; do
1600# opt=$1; shift
1601# case $opt in
1602# --silent|-s) opt_silent=:
1603# args_changed=:
1604# ;;
1605# # Separate non-argument short options:
1606# -s*) func_split_short_opt "$_G_opt"
1607# set dummy "$func_split_short_opt_name" \
1608# "-$func_split_short_opt_arg" ${1+"$@"}
1609# shift
1610# args_changed=:
1611# ;;
1612# *) # Make sure the first unrecognised option "$_G_opt"
1613# # is added back to "$@", we could need that later
1614# # if $args_changed is true.
1615# set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
1616# esac
1617# done
1618#
1619# if $args_changed; then
1620# func_quote_for_eval ${1+"$@"}
1621# my_silent_option_result=$func_quote_for_eval_result
1622# fi
1623#
1624# $args_changed
1625# }
1626# func_add_hook func_parse_options my_silent_option
1627#
1628#
1629# my_option_validation ()
1630# {
1631# $debug_cmd
1632#
1633# $opt_silent && $opt_verbose && func_fatal_help "\
1634# '--silent' and '--verbose' options are mutually exclusive."
1635#
1636# false
1637# }
1638# func_add_hook func_validate_options my_option_validation
1639#
1640# You'll also need to manually amend $usage_message to reflect the extra
1641# options you parse. It's preferable to append if you can, so that
1642# multiple option parsing hooks can be added safely.
1643
1644
1645# func_options_finish [ARG]...
1646# ----------------------------
1647# Finishing the option parse loop (call 'func_options' hooks ATM).
1648func_options_finish ()
1649{
1650 $debug_cmd
1651
1652 _G_func_options_finish_exit=false
1653 if func_run_hooks func_options ${1+"$@"}; then
1654 func_options_finish_result=$func_run_hooks_result
1655 _G_func_options_finish_exit=:
1656 fi
1657
1658 $_G_func_options_finish_exit
1659}
1660
1661
1662# func_options [ARG]...
1663# ---------------------
1664# All the functions called inside func_options are hookable. See the
1665# individual implementations for details.
1666func_hookable func_options
1667func_options ()
1668{
1669 $debug_cmd
1670
1671 _G_rc_options=false
1672
1673 for my_func in options_prep parse_options validate_options options_finish
1674 do
1675 if eval func_$my_func '${1+"$@"}'; then
1676 eval _G_res_var='$'"func_${my_func}_result"
1677 eval set dummy "$_G_res_var" ; shift
1678 _G_rc_options=:
1679 fi
1680 done
1681
1682 # Save modified positional parameters for caller. As a top-level
1683 # options-parser function we always need to set the 'func_options_result'
1684 # variable (regardless the $_G_rc_options value).
1685 if $_G_rc_options; then
1686 func_options_result=$_G_res_var
1687 else
1688 func_quote_for_eval ${1+"$@"}
1689 func_options_result=$func_quote_for_eval_result
1690 fi
1691
1692 $_G_rc_options
1693}
1694
1695
1696# func_options_prep [ARG]...
1697# --------------------------
1698# All initialisations required before starting the option parse loop.
1699# Note that when calling hook functions, we pass through the list of
1700# positional parameters. If a hook function modifies that list, and
1701# needs to propagate that back to rest of this script, then the complete
1702# modified list must be put in 'func_run_hooks_result' before
1703# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
1704func_hookable func_options_prep
1705func_options_prep ()
1706{
1707 $debug_cmd
1708
1709 # Option defaults:
1710 opt_verbose=false
1711 opt_warning_types=
1712
1713 _G_rc_options_prep=false
1714 if func_run_hooks func_options_prep ${1+"$@"}; then
1715 _G_rc_options_prep=:
1716 # save modified positional parameters for caller
1717 func_options_prep_result=$func_run_hooks_result
1718 fi
1719
1720 $_G_rc_options_prep
1721}
1722
1723
1724# func_parse_options [ARG]...
1725# ---------------------------
1726# The main option parsing loop.
1727func_hookable func_parse_options
1728func_parse_options ()
1729{
1730 $debug_cmd
1731
1732 func_parse_options_result=
1733
1734 _G_rc_parse_options=false
1735 # this just eases exit handling
1736 while test $# -gt 0; do
1737 # Defer to hook functions for initial option parsing, so they
1738 # get priority in the event of reusing an option name.
1739 if func_run_hooks func_parse_options ${1+"$@"}; then
1740 eval set dummy "$func_run_hooks_result"; shift
1741 _G_rc_parse_options=:
1742 fi
1743
1744 # Break out of the loop if we already parsed every option.
1745 test $# -gt 0 || break
1746
1747 _G_match_parse_options=:
1748 _G_opt=$1
1749 shift
1750 case $_G_opt in
1751 --debug|-x) debug_cmd='set -x'
1752 func_echo "enabling shell trace mode"
1753 $debug_cmd
1754 ;;
1755
1756 --no-warnings|--no-warning|--no-warn)
1757 set dummy --warnings none ${1+"$@"}
1758 shift
1759 ;;
1760
1761 --warnings|--warning|-W)
1762 if test $# = 0 && func_missing_arg $_G_opt; then
1763 _G_rc_parse_options=:
1764 break
1765 fi
1766 case " $warning_categories $1" in
1767 *" $1 "*)
1768 # trailing space prevents matching last $1 above
1769 func_append_uniq opt_warning_types " $1"
1770 ;;
1771 *all)
1772 opt_warning_types=$warning_categories
1773 ;;
1774 *none)
1775 opt_warning_types=none
1776 warning_func=:
1777 ;;
1778 *error)
1779 opt_warning_types=$warning_categories
1780 warning_func=func_fatal_error
1781 ;;
1782 *)
1783 func_fatal_error \
1784 "unsupported warning category: '$1'"
1785 ;;
1786 esac
1787 shift
1788 ;;
1789
1790 --verbose|-v) opt_verbose=: ;;
1791 --version) func_version ;;
1792 -\?|-h) func_usage ;;
1793 --help) func_help ;;
1794
1795 # Separate optargs to long options (plugins may need this):
1796 --*=*) func_split_equals "$_G_opt"
1797 set dummy "$func_split_equals_lhs" \
1798 "$func_split_equals_rhs" ${1+"$@"}
1799 shift
1800 ;;
1801
1802 # Separate optargs to short options:
1803 -W*)
1804 func_split_short_opt "$_G_opt"
1805 set dummy "$func_split_short_opt_name" \
1806 "$func_split_short_opt_arg" ${1+"$@"}
1807 shift
1808 ;;
1809
1810 # Separate non-argument short options:
1811 -\?*|-h*|-v*|-x*)
1812 func_split_short_opt "$_G_opt"
1813 set dummy "$func_split_short_opt_name" \
1814 "-$func_split_short_opt_arg" ${1+"$@"}
1815 shift
1816 ;;
1817
1818 --) _G_rc_parse_options=: ; break ;;
1819 -*) func_fatal_help "unrecognised option: '$_G_opt'" ;;
1820 *) set dummy "$_G_opt" ${1+"$@"}; shift
1821 _G_match_parse_options=false
1822 break
1823 ;;
1824 esac
1825
1826 $_G_match_parse_options && _G_rc_parse_options=:
1827 done
1828
1829
1830 if $_G_rc_parse_options; then
1831 # save modified positional parameters for caller
1832 func_quote_for_eval ${1+"$@"}
1833 func_parse_options_result=$func_quote_for_eval_result
1834 fi
1835
1836 $_G_rc_parse_options
1837}
1838
1839
1840# func_validate_options [ARG]...
1841# ------------------------------
1842# Perform any sanity checks on option settings and/or unconsumed
1843# arguments.
1844func_hookable func_validate_options
1845func_validate_options ()
1846{
1847 $debug_cmd
1848
1849 _G_rc_validate_options=false
1850
1851 # Display all warnings if -W was not given.
1852 test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
1853
1854 if func_run_hooks func_validate_options ${1+"$@"}; then
1855 # save modified positional parameters for caller
1856 func_validate_options_result=$func_run_hooks_result
1857 _G_rc_validate_options=:
1858 fi
1859
1860 # Bail if the options were screwed!
1861 $exit_cmd $EXIT_FAILURE
1862
1863 $_G_rc_validate_options
1864}
1865
1866
1867
1868## ----------------- ##
1869## Helper functions. ##
1870## ----------------- ##
1871
1872# This section contains the helper functions used by the rest of the
1873# hookable option parser framework in ascii-betical order.
1874
1875
1876# func_fatal_help ARG...
1877# ----------------------
1878# Echo program name prefixed message to standard error, followed by
1879# a help hint, and exit.
1880func_fatal_help ()
1881{
1882 $debug_cmd
1883
1884 eval \$ECHO \""Usage: $usage"\"
1885 eval \$ECHO \""$fatal_help"\"
1886 func_error ${1+"$@"}
1887 exit $EXIT_FAILURE
1888}
1889
1890
1891# func_help
1892# ---------
1893# Echo long help message to standard output and exit.
1894func_help ()
1895{
1896 $debug_cmd
1897
1898 func_usage_message
1899 $ECHO "$long_help_message"
1900 exit 0
1901}
1902
1903
1904# func_missing_arg ARGNAME
1905# ------------------------
1906# Echo program name prefixed message to standard error and set global
1907# exit_cmd.
1908func_missing_arg ()
1909{
1910 $debug_cmd
1911
1912 func_error "Missing argument for '$1'."
1913 exit_cmd=exit
1914}
1915
1916
1917# func_split_equals STRING
1918# ------------------------
1919# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
1920# splitting STRING at the '=' sign.
1921test -z "$_G_HAVE_XSI_OPS" \
1922 && (eval 'x=a/b/c;
1923 test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
1924 && _G_HAVE_XSI_OPS=yes
1925
1926if test yes = "$_G_HAVE_XSI_OPS"
1927then
1928 # This is an XSI compatible shell, allowing a faster implementation...
1929 eval 'func_split_equals ()
1930 {
1931 $debug_cmd
1932
1933 func_split_equals_lhs=${1%%=*}
1934 func_split_equals_rhs=${1#*=}
1935 test "x$func_split_equals_lhs" = "x$1" \
1936 && func_split_equals_rhs=
1937 }'
1938else
1939 # ...otherwise fall back to using expr, which is often a shell builtin.
1940 func_split_equals ()
1941 {
1942 $debug_cmd
1943
1944 func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
1945 func_split_equals_rhs=
1946 test "x$func_split_equals_lhs" = "x$1" \
1947 || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
1948 }
1949fi #func_split_equals
1950
1951
1952# func_split_short_opt SHORTOPT
1953# -----------------------------
1954# Set func_split_short_opt_name and func_split_short_opt_arg shell
1955# variables after splitting SHORTOPT after the 2nd character.
1956if test yes = "$_G_HAVE_XSI_OPS"
1957then
1958 # This is an XSI compatible shell, allowing a faster implementation...
1959 eval 'func_split_short_opt ()
1960 {
1961 $debug_cmd
1962
1963 func_split_short_opt_arg=${1#??}
1964 func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
1965 }'
1966else
1967 # ...otherwise fall back to using expr, which is often a shell builtin.
1968 func_split_short_opt ()
1969 {
1970 $debug_cmd
1971
1972 func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
1973 func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
1974 }
1975fi #func_split_short_opt
1976
1977
1978# func_usage
1979# ----------
1980# Echo short help message to standard output and exit.
1981func_usage ()
1982{
1983 $debug_cmd
1984
1985 func_usage_message
1986 $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
1987 exit 0
1988}
1989
1990
1991# func_usage_message
1992# ------------------
1993# Echo short help message to standard output.
1994func_usage_message ()
1995{
1996 $debug_cmd
1997
1998 eval \$ECHO \""Usage: $usage"\"
1999 echo
2000 $SED -n 's|^# ||
2001 /^Written by/{
2002 x;p;x
2003 }
2004 h
2005 /^Written by/q' < "$progpath"
2006 echo
2007 eval \$ECHO \""$usage_message"\"
2008}
2009
2010
2011# func_version
2012# ------------
2013# Echo version message to standard output and exit.
2014func_version ()
2015{
2016 $debug_cmd
2017
2018 printf '%s\n' "$progname $scriptversion"
2019 $SED -n '
2020 /(C)/!b go
2021 :more
2022 /\./!{
2023 N
2024 s|\n# | |
2025 b more
2026 }
2027 :go
2028 /^# Written by /,/# warranty; / {
2029 s|^# ||
2030 s|^# *$||
2031 s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
2032 p
2033 }
2034 /^# Written by / {
2035 s|^# ||
2036 p
2037 }
2038 /^warranty; /q' < "$progpath"
2039
2040 exit $?
2041}
2042
2043
2044# Local variables:
2045# mode: shell-script
2046# sh-indentation: 2
2047# eval: (add-hook 'before-save-hook 'time-stamp)
2048# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
2049# time-stamp-time-zone: "UTC"
2050# End:
2051
2052# Set a version string.
2053scriptversion='(GNU libtool) 2.4.6'
2054
2055
2056# func_echo ARG...
2057# ----------------
2058# Libtool also displays the current mode in messages, so override
2059# funclib.sh func_echo with this custom definition.
2060func_echo ()
2061{
2062 $debug_cmd
2063
2064 _G_message=$*
2065
2066 func_echo_IFS=$IFS
2067 IFS=$nl
2068 for _G_line in $_G_message; do
2069 IFS=$func_echo_IFS
2070 $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
2071 done
2072 IFS=$func_echo_IFS
2073}
2074
2075
2076# func_warning ARG...
2077# -------------------
2078# Libtool warnings are not categorized, so override funclib.sh
2079# func_warning with this simpler definition.
2080func_warning ()
2081{
2082 $debug_cmd
2083
2084 $warning_func ${1+"$@"}
2085}
2086
2087
2088## ---------------- ##
2089## Options parsing. ##
2090## ---------------- ##
2091
2092# Hook in the functions to make sure our own options are parsed during
2093# the option parsing loop.
2094
2095usage='$progpath [OPTION]... [MODE-ARG]...'
2096
2097# Short help message in response to '-h'.
2098usage_message="Options:
2099 --config show all configuration variables
2100 --debug enable verbose shell tracing
2101 -n, --dry-run display commands without modifying any files
2102 --features display basic configuration information and exit
2103 --mode=MODE use operation mode MODE
2104 --no-warnings equivalent to '-Wnone'
2105 --preserve-dup-deps don't remove duplicate dependency libraries
2106 --quiet, --silent don't print informational messages
2107 --tag=TAG use configuration variables from tag TAG
2108 -v, --verbose print more informational messages than default
2109 --version print version information
2110 -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all]
2111 -h, --help, --help-all print short, long, or detailed help message
2112"
2113
2114# Additional text appended to 'usage_message' in response to '--help'.
2115func_help ()
2116{
2117 $debug_cmd
2118
2119 func_usage_message
2120 $ECHO "$long_help_message
2121
2122MODE must be one of the following:
2123
2124 clean remove files from the build directory
2125 compile compile a source file into a libtool object
2126 execute automatically set library path, then run a program
2127 finish complete the installation of libtool libraries
2128 install install libraries or executables
2129 link create a library or an executable
2130 uninstall remove libraries from an installed directory
2131
2132MODE-ARGS vary depending on the MODE. When passed as first option,
2133'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
2134Try '$progname --help --mode=MODE' for a more detailed description of MODE.
2135
2136When reporting a bug, please describe a test case to reproduce it and
2137include the following information:
2138
2139 host-triplet: $host
2140 shell: $SHELL
2141 compiler: $LTCC
2142 compiler flags: $LTCFLAGS
2143 linker: $LD (gnu? $with_gnu_ld)
2144 version: $progname $scriptversion Debian-2.4.6-14
2145 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
2146 autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q`
2147
2148Report bugs to <bug-libtool@gnu.org>.
2149GNU libtool home page: <http://www.gnu.org/s/libtool/>.
2150General help using GNU software: <http://www.gnu.org/gethelp/>."
2151 exit 0
2152}
2153
2154
2155# func_lo2o OBJECT-NAME
2156# ---------------------
2157# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
2158# object suffix.
2159
2160lo2o=s/\\.lo\$/.$objext/
2161o2lo=s/\\.$objext\$/.lo/
2162
2163if test yes = "$_G_HAVE_XSI_OPS"; then
2164 eval 'func_lo2o ()
2165 {
2166 case $1 in
2167 *.lo) func_lo2o_result=${1%.lo}.$objext ;;
2168 * ) func_lo2o_result=$1 ;;
2169 esac
2170 }'
2171
2172 # func_xform LIBOBJ-OR-SOURCE
2173 # ---------------------------
2174 # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
2175 # suffix to a '.lo' libtool-object suffix.
2176 eval 'func_xform ()
2177 {
2178 func_xform_result=${1%.*}.lo
2179 }'
2180else
2181 # ...otherwise fall back to using sed.
2182 func_lo2o ()
2183 {
2184 func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
2185 }
2186
2187 func_xform ()
2188 {
2189 func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
2190 }
2191fi
2192
2193
2194# func_fatal_configuration ARG...
2195# -------------------------------
2196# Echo program name prefixed message to standard error, followed by
2197# a configuration failure hint, and exit.
2198func_fatal_configuration ()
2199{
2200 func__fatal_error ${1+"$@"} \
2201 "See the $PACKAGE documentation for more information." \
2202 "Fatal configuration error."
2203}
2204
2205
2206# func_config
2207# -----------
2208# Display the configuration for all the tags in this script.
2209func_config ()
2210{
2211 re_begincf='^# ### BEGIN LIBTOOL'
2212 re_endcf='^# ### END LIBTOOL'
2213
2214 # Default configuration.
2215 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
2216
2217 # Now print the configurations for the tags.
2218 for tagname in $taglist; do
2219 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
2220 done
2221
2222 exit $?
2223}
2224
2225
2226# func_features
2227# -------------
2228# Display the features supported by this script.
2229func_features ()
2230{
2231 echo "host: $host"
2232 if test yes = "$build_libtool_libs"; then
2233 echo "enable shared libraries"
2234 else
2235 echo "disable shared libraries"
2236 fi
2237 if test yes = "$build_old_libs"; then
2238 echo "enable static libraries"
2239 else
2240 echo "disable static libraries"
2241 fi
2242
2243 exit $?
2244}
2245
2246
2247# func_enable_tag TAGNAME
2248# -----------------------
2249# Verify that TAGNAME is valid, and either flag an error and exit, or
2250# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
2251# variable here.
2252func_enable_tag ()
2253{
2254 # Global variable:
2255 tagname=$1
2256
2257 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
2258 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
2259 sed_extractcf=/$re_begincf/,/$re_endcf/p
2260
2261 # Validate tagname.
2262 case $tagname in
2263 *[!-_A-Za-z0-9,/]*)
2264 func_fatal_error "invalid tag name: $tagname"
2265 ;;
2266 esac
2267
2268 # Don't test for the "default" C tag, as we know it's
2269 # there but not specially marked.
2270 case $tagname in
2271 CC) ;;
2272 *)
2273 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
2274 taglist="$taglist $tagname"
2275
2276 # Evaluate the configuration. Be careful to quote the path
2277 # and the sed script, to avoid splitting on whitespace, but
2278 # also don't use non-portable quotes within backquotes within
2279 # quotes we have to do it in 2 steps:
2280 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
2281 eval "$extractedcf"
2282 else
2283 func_error "ignoring unknown tag $tagname"
2284 fi
2285 ;;
2286 esac
2287}
2288
2289
2290# func_check_version_match
2291# ------------------------
2292# Ensure that we are using m4 macros, and libtool script from the same
2293# release of libtool.
2294func_check_version_match ()
2295{
2296 if test "$package_revision" != "$macro_revision"; then
2297 if test "$VERSION" != "$macro_version"; then
2298 if test -z "$macro_version"; then
2299 cat >&2 <<_LT_EOF
2300$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2301$progname: definition of this LT_INIT comes from an older release.
2302$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2303$progname: and run autoconf again.
2304_LT_EOF
2305 else
2306 cat >&2 <<_LT_EOF
2307$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2308$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
2309$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2310$progname: and run autoconf again.
2311_LT_EOF
2312 fi
2313 else
2314 cat >&2 <<_LT_EOF
2315$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
2316$progname: but the definition of this LT_INIT comes from revision $macro_revision.
2317$progname: You should recreate aclocal.m4 with macros from revision $package_revision
2318$progname: of $PACKAGE $VERSION and run autoconf again.
2319_LT_EOF
2320 fi
2321
2322 exit $EXIT_MISMATCH
2323 fi
2324}
2325
2326
2327# libtool_options_prep [ARG]...
2328# -----------------------------
2329# Preparation for options parsed by libtool.
2330libtool_options_prep ()
2331{
2332 $debug_mode
2333
2334 # Option defaults:
2335 opt_config=false
2336 opt_dlopen=
2337 opt_dry_run=false
2338 opt_help=false
2339 opt_mode=
2340 opt_preserve_dup_deps=false
2341 opt_quiet=false
2342
2343 nonopt=
2344 preserve_args=
2345
2346 _G_rc_lt_options_prep=:
2347
2348 # Shorthand for --mode=foo, only valid as the first argument
2349 case $1 in
2350 clean|clea|cle|cl)
2351 shift; set dummy --mode clean ${1+"$@"}; shift
2352 ;;
2353 compile|compil|compi|comp|com|co|c)
2354 shift; set dummy --mode compile ${1+"$@"}; shift
2355 ;;
2356 execute|execut|execu|exec|exe|ex|e)
2357 shift; set dummy --mode execute ${1+"$@"}; shift
2358 ;;
2359 finish|finis|fini|fin|fi|f)
2360 shift; set dummy --mode finish ${1+"$@"}; shift
2361 ;;
2362 install|instal|insta|inst|ins|in|i)
2363 shift; set dummy --mode install ${1+"$@"}; shift
2364 ;;
2365 link|lin|li|l)
2366 shift; set dummy --mode link ${1+"$@"}; shift
2367 ;;
2368 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
2369 shift; set dummy --mode uninstall ${1+"$@"}; shift
2370 ;;
2371 *)
2372 _G_rc_lt_options_prep=false
2373 ;;
2374 esac
2375
2376 if $_G_rc_lt_options_prep; then
2377 # Pass back the list of options.
2378 func_quote_for_eval ${1+"$@"}
2379 libtool_options_prep_result=$func_quote_for_eval_result
2380 fi
2381
2382 $_G_rc_lt_options_prep
2383}
2384func_add_hook func_options_prep libtool_options_prep
2385
2386
2387# libtool_parse_options [ARG]...
2388# ---------------------------------
2389# Provide handling for libtool specific options.
2390libtool_parse_options ()
2391{
2392 $debug_cmd
2393
2394 _G_rc_lt_parse_options=false
2395
2396 # Perform our own loop to consume as many options as possible in
2397 # each iteration.
2398 while test $# -gt 0; do
2399 _G_match_lt_parse_options=:
2400 _G_opt=$1
2401 shift
2402 case $_G_opt in
2403 --dry-run|--dryrun|-n)
2404 opt_dry_run=:
2405 ;;
2406
2407 --config) func_config ;;
2408
2409 --dlopen|-dlopen)
2410 opt_dlopen="${opt_dlopen+$opt_dlopen
2411}$1"
2412 shift
2413 ;;
2414
2415 --preserve-dup-deps)
2416 opt_preserve_dup_deps=: ;;
2417
2418 --features) func_features ;;
2419
2420 --finish) set dummy --mode finish ${1+"$@"}; shift ;;
2421
2422 --help) opt_help=: ;;
2423
2424 --help-all) opt_help=': help-all' ;;
2425
2426 --mode) test $# = 0 && func_missing_arg $_G_opt && break
2427 opt_mode=$1
2428 case $1 in
2429 # Valid mode arguments:
2430 clean|compile|execute|finish|install|link|relink|uninstall) ;;
2431
2432 # Catch anything else as an error
2433 *) func_error "invalid argument for $_G_opt"
2434 exit_cmd=exit
2435 break
2436 ;;
2437 esac
2438 shift
2439 ;;
2440
2441 --no-silent|--no-quiet)
2442 opt_quiet=false
2443 func_append preserve_args " $_G_opt"
2444 ;;
2445
2446 --no-warnings|--no-warning|--no-warn)
2447 opt_warning=false
2448 func_append preserve_args " $_G_opt"
2449 ;;
2450
2451 --no-verbose)
2452 opt_verbose=false
2453 func_append preserve_args " $_G_opt"
2454 ;;
2455
2456 --silent|--quiet)
2457 opt_quiet=:
2458 opt_verbose=false
2459 func_append preserve_args " $_G_opt"
2460 ;;
2461
2462 --tag) test $# = 0 && func_missing_arg $_G_opt && break
2463 opt_tag=$1
2464 func_append preserve_args " $_G_opt $1"
2465 func_enable_tag "$1"
2466 shift
2467 ;;
2468
2469 --verbose|-v) opt_quiet=false
2470 opt_verbose=:
2471 func_append preserve_args " $_G_opt"
2472 ;;
2473
2474 # An option not handled by this hook function:
2475 *) set dummy "$_G_opt" ${1+"$@"} ; shift
2476 _G_match_lt_parse_options=false
2477 break
2478 ;;
2479 esac
2480 $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
2481 done
2482
2483 if $_G_rc_lt_parse_options; then
2484 # save modified positional parameters for caller
2485 func_quote_for_eval ${1+"$@"}
2486 libtool_parse_options_result=$func_quote_for_eval_result
2487 fi
2488
2489 $_G_rc_lt_parse_options
2490}
2491func_add_hook func_parse_options libtool_parse_options
2492
2493
2494
2495# libtool_validate_options [ARG]...
2496# ---------------------------------
2497# Perform any sanity checks on option settings and/or unconsumed
2498# arguments.
2499libtool_validate_options ()
2500{
2501 # save first non-option argument
2502 if test 0 -lt $#; then
2503 nonopt=$1
2504 shift
2505 fi
2506
2507 # preserve --debug
2508 test : = "$debug_cmd" || func_append preserve_args " --debug"
2509
2510 case $host in
2511 # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
2512 # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
2513 *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
2514 # don't eliminate duplications in $postdeps and $predeps
2515 opt_duplicate_compiler_generated_deps=:
2516 ;;
2517 *)
2518 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
2519 ;;
2520 esac
2521
2522 $opt_help || {
2523 # Sanity checks first:
2524 func_check_version_match
2525
2526 test yes != "$build_libtool_libs" \
2527 && test yes != "$build_old_libs" \
2528 && func_fatal_configuration "not configured to build any kind of library"
2529
2530 # Darwin sucks
2531 eval std_shrext=\"$shrext_cmds\"
2532
2533 # Only execute mode is allowed to have -dlopen flags.
2534 if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
2535 func_error "unrecognized option '-dlopen'"
2536 $ECHO "$help" 1>&2
2537 exit $EXIT_FAILURE
2538 fi
2539
2540 # Change the help message to a mode-specific one.
2541 generic_help=$help
2542 help="Try '$progname --help --mode=$opt_mode' for more information."
2543 }
2544
2545 # Pass back the unparsed argument list
2546 func_quote_for_eval ${1+"$@"}
2547 libtool_validate_options_result=$func_quote_for_eval_result
2548}
2549func_add_hook func_validate_options libtool_validate_options
2550
2551
2552# Process options as early as possible so that --help and --version
2553# can return quickly.
2554func_options ${1+"$@"}
2555eval set dummy "$func_options_result"; shift
2556
2557
2558
2559## ----------- ##
2560## Main. ##
2561## ----------- ##
2562
2563magic='%%%MAGIC variable%%%'
2564magic_exe='%%%MAGIC EXE variable%%%'
2565
2566# Global variables.
2567extracted_archives=
2568extracted_serial=0
2569
2570# If this variable is set in any of the actions, the command in it
2571# will be execed at the end. This prevents here-documents from being
2572# left over by shells.
2573exec_cmd=
2574
2575
2576# A function that is used when there is no print builtin or printf.
2577func_fallback_echo ()
2578{
2579 eval 'cat <<_LTECHO_EOF
2580$1
2581_LTECHO_EOF'
2582}
2583
2584# func_generated_by_libtool
2585# True iff stdin has been generated by Libtool. This function is only
2586# a basic sanity check; it will hardly flush out determined imposters.
2587func_generated_by_libtool_p ()
2588{
2589 $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
2590}
2591
2592# func_lalib_p file
2593# True iff FILE is a libtool '.la' library or '.lo' object file.
2594# This function is only a basic sanity check; it will hardly flush out
2595# determined imposters.
2596func_lalib_p ()
2597{
2598 test -f "$1" &&
2599 $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
2600}
2601
2602# func_lalib_unsafe_p file
2603# True iff FILE is a libtool '.la' library or '.lo' object file.
2604# This function implements the same check as func_lalib_p without
2605# resorting to external programs. To this end, it redirects stdin and
2606# closes it afterwards, without saving the original file descriptor.
2607# As a safety measure, use it only where a negative result would be
2608# fatal anyway. Works if 'file' does not exist.
2609func_lalib_unsafe_p ()
2610{
2611 lalib_p=no
2612 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
2613 for lalib_p_l in 1 2 3 4
2614 do
2615 read lalib_p_line
2616 case $lalib_p_line in
2617 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
2618 esac
2619 done
2620 exec 0<&5 5<&-
2621 fi
2622 test yes = "$lalib_p"
2623}
2624
2625# func_ltwrapper_script_p file
2626# True iff FILE is a libtool wrapper script
2627# This function is only a basic sanity check; it will hardly flush out
2628# determined imposters.
2629func_ltwrapper_script_p ()
2630{
2631 test -f "$1" &&
2632 $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
2633}
2634
2635# func_ltwrapper_executable_p file
2636# True iff FILE is a libtool wrapper executable
2637# This function is only a basic sanity check; it will hardly flush out
2638# determined imposters.
2639func_ltwrapper_executable_p ()
2640{
2641 func_ltwrapper_exec_suffix=
2642 case $1 in
2643 *.exe) ;;
2644 *) func_ltwrapper_exec_suffix=.exe ;;
2645 esac
2646 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
2647}
2648
2649# func_ltwrapper_scriptname file
2650# Assumes file is an ltwrapper_executable
2651# uses $file to determine the appropriate filename for a
2652# temporary ltwrapper_script.
2653func_ltwrapper_scriptname ()
2654{
2655 func_dirname_and_basename "$1" "" "."
2656 func_stripname '' '.exe' "$func_basename_result"
2657 func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
2658}
2659
2660# func_ltwrapper_p file
2661# True iff FILE is a libtool wrapper script or wrapper executable
2662# This function is only a basic sanity check; it will hardly flush out
2663# determined imposters.
2664func_ltwrapper_p ()
2665{
2666 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
2667}
2668
2669
2670# func_execute_cmds commands fail_cmd
2671# Execute tilde-delimited COMMANDS.
2672# If FAIL_CMD is given, eval that upon failure.
2673# FAIL_CMD may read-access the current command in variable CMD!
2674func_execute_cmds ()
2675{
2676 $debug_cmd
2677
2678 save_ifs=$IFS; IFS='~'
2679 for cmd in $1; do
2680 IFS=$sp$nl
2681 eval cmd=\"$cmd\"
2682 IFS=$save_ifs
2683 func_show_eval "$cmd" "${2-:}"
2684 done
2685 IFS=$save_ifs
2686}
2687
2688
2689# func_source file
2690# Source FILE, adding directory component if necessary.
2691# Note that it is not necessary on cygwin/mingw to append a dot to
2692# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
2693# behavior happens only for exec(3), not for open(2)! Also, sourcing
2694# 'FILE.' does not work on cygwin managed mounts.
2695func_source ()
2696{
2697 $debug_cmd
2698
2699 case $1 in
2700 */* | *\\*) . "$1" ;;
2701 *) . "./$1" ;;
2702 esac
2703}
2704
2705
2706# func_resolve_sysroot PATH
2707# Replace a leading = in PATH with a sysroot. Store the result into
2708# func_resolve_sysroot_result
2709func_resolve_sysroot ()
2710{
2711 func_resolve_sysroot_result=$1
2712 case $func_resolve_sysroot_result in
2713 =*)
2714 func_stripname '=' '' "$func_resolve_sysroot_result"
2715 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
2716 ;;
2717 esac
2718}
2719
2720# func_replace_sysroot PATH
2721# If PATH begins with the sysroot, replace it with = and
2722# store the result into func_replace_sysroot_result.
2723func_replace_sysroot ()
2724{
2725 case $lt_sysroot:$1 in
2726 ?*:"$lt_sysroot"*)
2727 func_stripname "$lt_sysroot" '' "$1"
2728 func_replace_sysroot_result='='$func_stripname_result
2729 ;;
2730 *)
2731 # Including no sysroot.
2732 func_replace_sysroot_result=$1
2733 ;;
2734 esac
2735}
2736
2737# func_infer_tag arg
2738# Infer tagged configuration to use if any are available and
2739# if one wasn't chosen via the "--tag" command line option.
2740# Only attempt this if the compiler in the base compile
2741# command doesn't match the default compiler.
2742# arg is usually of the form 'gcc ...'
2743func_infer_tag ()
2744{
2745 $debug_cmd
2746
2747 if test -n "$available_tags" && test -z "$tagname"; then
2748 CC_quoted=
2749 for arg in $CC; do
2750 func_append_quoted CC_quoted "$arg"
2751 done
2752 CC_expanded=`func_echo_all $CC`
2753 CC_quoted_expanded=`func_echo_all $CC_quoted`
2754 case $@ in
2755 # Blanks in the command may have been stripped by the calling shell,
2756 # but not from the CC environment variable when configure was run.
2757 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2758 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
2759 # Blanks at the start of $base_compile will cause this to fail
2760 # if we don't check for them as well.
2761 *)
2762 for z in $available_tags; do
2763 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
2764 # Evaluate the configuration.
2765 eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
2766 CC_quoted=
2767 for arg in $CC; do
2768 # Double-quote args containing other shell metacharacters.
2769 func_append_quoted CC_quoted "$arg"
2770 done
2771 CC_expanded=`func_echo_all $CC`
2772 CC_quoted_expanded=`func_echo_all $CC_quoted`
2773 case "$@ " in
2774 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2775 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
2776 # The compiler in the base compile command matches
2777 # the one in the tagged configuration.
2778 # Assume this is the tagged configuration we want.
2779 tagname=$z
2780 break
2781 ;;
2782 esac
2783 fi
2784 done
2785 # If $tagname still isn't set, then no tagged configuration
2786 # was found and let the user know that the "--tag" command
2787 # line option must be used.
2788 if test -z "$tagname"; then
2789 func_echo "unable to infer tagged configuration"
2790 func_fatal_error "specify a tag with '--tag'"
2791# else
2792# func_verbose "using $tagname tagged configuration"
2793 fi
2794 ;;
2795 esac
2796 fi
2797}
2798
2799
2800
2801# func_write_libtool_object output_name pic_name nonpic_name
2802# Create a libtool object file (analogous to a ".la" file),
2803# but don't create it if we're doing a dry run.
2804func_write_libtool_object ()
2805{
2806 write_libobj=$1
2807 if test yes = "$build_libtool_libs"; then
2808 write_lobj=\'$2\'
2809 else
2810 write_lobj=none
2811 fi
2812
2813 if test yes = "$build_old_libs"; then
2814 write_oldobj=\'$3\'
2815 else
2816 write_oldobj=none
2817 fi
2818
2819 $opt_dry_run || {
2820 cat >${write_libobj}T <<EOF
2821# $write_libobj - a libtool object file
2822# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
2823#
2824# Please DO NOT delete this file!
2825# It is necessary for linking the library.
2826
2827# Name of the PIC object.
2828pic_object=$write_lobj
2829
2830# Name of the non-PIC object
2831non_pic_object=$write_oldobj
2832
2833EOF
2834 $MV "${write_libobj}T" "$write_libobj"
2835 }
2836}
2837
2838
2839##################################################
2840# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
2841##################################################
2842
2843# func_convert_core_file_wine_to_w32 ARG
2844# Helper function used by file name conversion functions when $build is *nix,
2845# and $host is mingw, cygwin, or some other w32 environment. Relies on a
2846# correctly configured wine environment available, with the winepath program
2847# in $build's $PATH.
2848#
2849# ARG is the $build file name to be converted to w32 format.
2850# Result is available in $func_convert_core_file_wine_to_w32_result, and will
2851# be empty on error (or when ARG is empty)
2852func_convert_core_file_wine_to_w32 ()
2853{
2854 $debug_cmd
2855
2856 func_convert_core_file_wine_to_w32_result=$1
2857 if test -n "$1"; then
2858 # Unfortunately, winepath does not exit with a non-zero error code, so we
2859 # are forced to check the contents of stdout. On the other hand, if the
2860 # command is not found, the shell will set an exit code of 127 and print
2861 # *an error message* to stdout. So we must check for both error code of
2862 # zero AND non-empty stdout, which explains the odd construction:
2863 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
2864 if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
2865 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
2866 $SED -e "$sed_naive_backslashify"`
2867 else
2868 func_convert_core_file_wine_to_w32_result=
2869 fi
2870 fi
2871}
2872# end: func_convert_core_file_wine_to_w32
2873
2874
2875# func_convert_core_path_wine_to_w32 ARG
2876# Helper function used by path conversion functions when $build is *nix, and
2877# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
2878# configured wine environment available, with the winepath program in $build's
2879# $PATH. Assumes ARG has no leading or trailing path separator characters.
2880#
2881# ARG is path to be converted from $build format to win32.
2882# Result is available in $func_convert_core_path_wine_to_w32_result.
2883# Unconvertible file (directory) names in ARG are skipped; if no directory names
2884# are convertible, then the result may be empty.
2885func_convert_core_path_wine_to_w32 ()
2886{
2887 $debug_cmd
2888
2889 # unfortunately, winepath doesn't convert paths, only file names
2890 func_convert_core_path_wine_to_w32_result=
2891 if test -n "$1"; then
2892 oldIFS=$IFS
2893 IFS=:
2894 for func_convert_core_path_wine_to_w32_f in $1; do
2895 IFS=$oldIFS
2896 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
2897 if test -n "$func_convert_core_file_wine_to_w32_result"; then
2898 if test -z "$func_convert_core_path_wine_to_w32_result"; then
2899 func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
2900 else
2901 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
2902 fi
2903 fi
2904 done
2905 IFS=$oldIFS
2906 fi
2907}
2908# end: func_convert_core_path_wine_to_w32
2909
2910
2911# func_cygpath ARGS...
2912# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
2913# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
2914# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
2915# (2), returns the Cygwin file name or path in func_cygpath_result (input
2916# file name or path is assumed to be in w32 format, as previously converted
2917# from $build's *nix or MSYS format). In case (3), returns the w32 file name
2918# or path in func_cygpath_result (input file name or path is assumed to be in
2919# Cygwin format). Returns an empty string on error.
2920#
2921# ARGS are passed to cygpath, with the last one being the file name or path to
2922# be converted.
2923#
2924# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
2925# environment variable; do not put it in $PATH.
2926func_cygpath ()
2927{
2928 $debug_cmd
2929
2930 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
2931 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
2932 if test "$?" -ne 0; then
2933 # on failure, ensure result is empty
2934 func_cygpath_result=
2935 fi
2936 else
2937 func_cygpath_result=
2938 func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
2939 fi
2940}
2941#end: func_cygpath
2942
2943
2944# func_convert_core_msys_to_w32 ARG
2945# Convert file name or path ARG from MSYS format to w32 format. Return
2946# result in func_convert_core_msys_to_w32_result.
2947func_convert_core_msys_to_w32 ()
2948{
2949 $debug_cmd
2950
2951 # awkward: cmd appends spaces to result
2952 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
2953 $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
2954}
2955#end: func_convert_core_msys_to_w32
2956
2957
2958# func_convert_file_check ARG1 ARG2
2959# Verify that ARG1 (a file name in $build format) was converted to $host
2960# format in ARG2. Otherwise, emit an error message, but continue (resetting
2961# func_to_host_file_result to ARG1).
2962func_convert_file_check ()
2963{
2964 $debug_cmd
2965
2966 if test -z "$2" && test -n "$1"; then
2967 func_error "Could not determine host file name corresponding to"
2968 func_error " '$1'"
2969 func_error "Continuing, but uninstalled executables may not work."
2970 # Fallback:
2971 func_to_host_file_result=$1
2972 fi
2973}
2974# end func_convert_file_check
2975
2976
2977# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
2978# Verify that FROM_PATH (a path in $build format) was converted to $host
2979# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
2980# func_to_host_file_result to a simplistic fallback value (see below).
2981func_convert_path_check ()
2982{
2983 $debug_cmd
2984
2985 if test -z "$4" && test -n "$3"; then
2986 func_error "Could not determine the host path corresponding to"
2987 func_error " '$3'"
2988 func_error "Continuing, but uninstalled executables may not work."
2989 # Fallback. This is a deliberately simplistic "conversion" and
2990 # should not be "improved". See libtool.info.
2991 if test "x$1" != "x$2"; then
2992 lt_replace_pathsep_chars="s|$1|$2|g"
2993 func_to_host_path_result=`echo "$3" |
2994 $SED -e "$lt_replace_pathsep_chars"`
2995 else
2996 func_to_host_path_result=$3
2997 fi
2998 fi
2999}
3000# end func_convert_path_check
3001
3002
3003# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
3004# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
3005# and appending REPL if ORIG matches BACKPAT.
3006func_convert_path_front_back_pathsep ()
3007{
3008 $debug_cmd
3009
3010 case $4 in
3011 $1 ) func_to_host_path_result=$3$func_to_host_path_result
3012 ;;
3013 esac
3014 case $4 in
3015 $2 ) func_append func_to_host_path_result "$3"
3016 ;;
3017 esac
3018}
3019# end func_convert_path_front_back_pathsep
3020
3021
3022##################################################
3023# $build to $host FILE NAME CONVERSION FUNCTIONS #
3024##################################################
3025# invoked via '$to_host_file_cmd ARG'
3026#
3027# In each case, ARG is the path to be converted from $build to $host format.
3028# Result will be available in $func_to_host_file_result.
3029
3030
3031# func_to_host_file ARG
3032# Converts the file name ARG from $build format to $host format. Return result
3033# in func_to_host_file_result.
3034func_to_host_file ()
3035{
3036 $debug_cmd
3037
3038 $to_host_file_cmd "$1"
3039}
3040# end func_to_host_file
3041
3042
3043# func_to_tool_file ARG LAZY
3044# converts the file name ARG from $build format to toolchain format. Return
3045# result in func_to_tool_file_result. If the conversion in use is listed
3046# in (the comma separated) LAZY, no conversion takes place.
3047func_to_tool_file ()
3048{
3049 $debug_cmd
3050
3051 case ,$2, in
3052 *,"$to_tool_file_cmd",*)
3053 func_to_tool_file_result=$1
3054 ;;
3055 *)
3056 $to_tool_file_cmd "$1"
3057 func_to_tool_file_result=$func_to_host_file_result
3058 ;;
3059 esac
3060}
3061# end func_to_tool_file
3062
3063
3064# func_convert_file_noop ARG
3065# Copy ARG to func_to_host_file_result.
3066func_convert_file_noop ()
3067{
3068 func_to_host_file_result=$1
3069}
3070# end func_convert_file_noop
3071
3072
3073# func_convert_file_msys_to_w32 ARG
3074# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
3075# conversion to w32 is not available inside the cwrapper. Returns result in
3076# func_to_host_file_result.
3077func_convert_file_msys_to_w32 ()
3078{
3079 $debug_cmd
3080
3081 func_to_host_file_result=$1
3082 if test -n "$1"; then
3083 func_convert_core_msys_to_w32 "$1"
3084 func_to_host_file_result=$func_convert_core_msys_to_w32_result
3085 fi
3086 func_convert_file_check "$1" "$func_to_host_file_result"
3087}
3088# end func_convert_file_msys_to_w32
3089
3090
3091# func_convert_file_cygwin_to_w32 ARG
3092# Convert file name ARG from Cygwin to w32 format. Returns result in
3093# func_to_host_file_result.
3094func_convert_file_cygwin_to_w32 ()
3095{
3096 $debug_cmd
3097
3098 func_to_host_file_result=$1
3099 if test -n "$1"; then
3100 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
3101 # LT_CYGPATH in this case.
3102 func_to_host_file_result=`cygpath -m "$1"`
3103 fi
3104 func_convert_file_check "$1" "$func_to_host_file_result"
3105}
3106# end func_convert_file_cygwin_to_w32
3107
3108
3109# func_convert_file_nix_to_w32 ARG
3110# Convert file name ARG from *nix to w32 format. Requires a wine environment
3111# and a working winepath. Returns result in func_to_host_file_result.
3112func_convert_file_nix_to_w32 ()
3113{
3114 $debug_cmd
3115
3116 func_to_host_file_result=$1
3117 if test -n "$1"; then
3118 func_convert_core_file_wine_to_w32 "$1"
3119 func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
3120 fi
3121 func_convert_file_check "$1" "$func_to_host_file_result"
3122}
3123# end func_convert_file_nix_to_w32
3124
3125
3126# func_convert_file_msys_to_cygwin ARG
3127# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3128# Returns result in func_to_host_file_result.
3129func_convert_file_msys_to_cygwin ()
3130{
3131 $debug_cmd
3132
3133 func_to_host_file_result=$1
3134 if test -n "$1"; then
3135 func_convert_core_msys_to_w32 "$1"
3136 func_cygpath -u "$func_convert_core_msys_to_w32_result"
3137 func_to_host_file_result=$func_cygpath_result
3138 fi
3139 func_convert_file_check "$1" "$func_to_host_file_result"
3140}
3141# end func_convert_file_msys_to_cygwin
3142
3143
3144# func_convert_file_nix_to_cygwin ARG
3145# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
3146# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
3147# in func_to_host_file_result.
3148func_convert_file_nix_to_cygwin ()
3149{
3150 $debug_cmd
3151
3152 func_to_host_file_result=$1
3153 if test -n "$1"; then
3154 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
3155 func_convert_core_file_wine_to_w32 "$1"
3156 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
3157 func_to_host_file_result=$func_cygpath_result
3158 fi
3159 func_convert_file_check "$1" "$func_to_host_file_result"
3160}
3161# end func_convert_file_nix_to_cygwin
3162
3163
3164#############################################
3165# $build to $host PATH CONVERSION FUNCTIONS #
3166#############################################
3167# invoked via '$to_host_path_cmd ARG'
3168#
3169# In each case, ARG is the path to be converted from $build to $host format.
3170# The result will be available in $func_to_host_path_result.
3171#
3172# Path separators are also converted from $build format to $host format. If
3173# ARG begins or ends with a path separator character, it is preserved (but
3174# converted to $host format) on output.
3175#
3176# All path conversion functions are named using the following convention:
3177# file name conversion function : func_convert_file_X_to_Y ()
3178# path conversion function : func_convert_path_X_to_Y ()
3179# where, for any given $build/$host combination the 'X_to_Y' value is the
3180# same. If conversion functions are added for new $build/$host combinations,
3181# the two new functions must follow this pattern, or func_init_to_host_path_cmd
3182# will break.
3183
3184
3185# func_init_to_host_path_cmd
3186# Ensures that function "pointer" variable $to_host_path_cmd is set to the
3187# appropriate value, based on the value of $to_host_file_cmd.
3188to_host_path_cmd=
3189func_init_to_host_path_cmd ()
3190{
3191 $debug_cmd
3192
3193 if test -z "$to_host_path_cmd"; then
3194 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
3195 to_host_path_cmd=func_convert_path_$func_stripname_result
3196 fi
3197}
3198
3199
3200# func_to_host_path ARG
3201# Converts the path ARG from $build format to $host format. Return result
3202# in func_to_host_path_result.
3203func_to_host_path ()
3204{
3205 $debug_cmd
3206
3207 func_init_to_host_path_cmd
3208 $to_host_path_cmd "$1"
3209}
3210# end func_to_host_path
3211
3212
3213# func_convert_path_noop ARG
3214# Copy ARG to func_to_host_path_result.
3215func_convert_path_noop ()
3216{
3217 func_to_host_path_result=$1
3218}
3219# end func_convert_path_noop
3220
3221
3222# func_convert_path_msys_to_w32 ARG
3223# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
3224# conversion to w32 is not available inside the cwrapper. Returns result in
3225# func_to_host_path_result.
3226func_convert_path_msys_to_w32 ()
3227{
3228 $debug_cmd
3229
3230 func_to_host_path_result=$1
3231 if test -n "$1"; then
3232 # Remove leading and trailing path separator characters from ARG. MSYS
3233 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
3234 # and winepath ignores them completely.
3235 func_stripname : : "$1"
3236 func_to_host_path_tmp1=$func_stripname_result
3237 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3238 func_to_host_path_result=$func_convert_core_msys_to_w32_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_msys_to_w32
3245
3246
3247# func_convert_path_cygwin_to_w32 ARG
3248# Convert path ARG from Cygwin to w32 format. Returns result in
3249# func_to_host_file_result.
3250func_convert_path_cygwin_to_w32 ()
3251{
3252 $debug_cmd
3253
3254 func_to_host_path_result=$1
3255 if test -n "$1"; then
3256 # See func_convert_path_msys_to_w32:
3257 func_stripname : : "$1"
3258 func_to_host_path_tmp1=$func_stripname_result
3259 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
3260 func_convert_path_check : ";" \
3261 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3262 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3263 fi
3264}
3265# end func_convert_path_cygwin_to_w32
3266
3267
3268# func_convert_path_nix_to_w32 ARG
3269# Convert path ARG from *nix to w32 format. Requires a wine environment and
3270# a working winepath. Returns result in func_to_host_file_result.
3271func_convert_path_nix_to_w32 ()
3272{
3273 $debug_cmd
3274
3275 func_to_host_path_result=$1
3276 if test -n "$1"; then
3277 # See func_convert_path_msys_to_w32:
3278 func_stripname : : "$1"
3279 func_to_host_path_tmp1=$func_stripname_result
3280 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3281 func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
3282 func_convert_path_check : ";" \
3283 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3284 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3285 fi
3286}
3287# end func_convert_path_nix_to_w32
3288
3289
3290# func_convert_path_msys_to_cygwin ARG
3291# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3292# Returns result in func_to_host_file_result.
3293func_convert_path_msys_to_cygwin ()
3294{
3295 $debug_cmd
3296
3297 func_to_host_path_result=$1
3298 if test -n "$1"; then
3299 # See func_convert_path_msys_to_w32:
3300 func_stripname : : "$1"
3301 func_to_host_path_tmp1=$func_stripname_result
3302 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3303 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
3304 func_to_host_path_result=$func_cygpath_result
3305 func_convert_path_check : : \
3306 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3307 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3308 fi
3309}
3310# end func_convert_path_msys_to_cygwin
3311
3312
3313# func_convert_path_nix_to_cygwin ARG
3314# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
3315# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
3316# func_to_host_file_result.
3317func_convert_path_nix_to_cygwin ()
3318{
3319 $debug_cmd
3320
3321 func_to_host_path_result=$1
3322 if test -n "$1"; then
3323 # Remove leading and trailing path separator characters from
3324 # ARG. msys behavior is inconsistent here, cygpath turns them
3325 # into '.;' and ';.', and winepath ignores them completely.
3326 func_stripname : : "$1"
3327 func_to_host_path_tmp1=$func_stripname_result
3328 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3329 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
3330 func_to_host_path_result=$func_cygpath_result
3331 func_convert_path_check : : \
3332 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3333 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3334 fi
3335}
3336# end func_convert_path_nix_to_cygwin
3337
3338
3339# func_dll_def_p FILE
3340# True iff FILE is a Windows DLL '.def' file.
3341# Keep in sync with _LT_DLL_DEF_P in libtool.m4
3342func_dll_def_p ()
3343{
3344 $debug_cmd
3345
3346 func_dll_def_p_tmp=`$SED -n \
3347 -e 's/^[ ]*//' \
3348 -e '/^\(;.*\)*$/d' \
3349 -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \
3350 -e q \
3351 "$1"`
3352 test DEF = "$func_dll_def_p_tmp"
3353}
3354
3355
3356# func_mode_compile arg...
3357func_mode_compile ()
3358{
3359 $debug_cmd
3360
3361 # Get the compilation command and the source file.
3362 base_compile=
3363 srcfile=$nonopt # always keep a non-empty value in "srcfile"
3364 suppress_opt=yes
3365 suppress_output=
3366 arg_mode=normal
3367 libobj=
3368 later=
3369 pie_flag=
3370
3371 for arg
3372 do
3373 case $arg_mode in
3374 arg )
3375 # do not "continue". Instead, add this to base_compile
3376 lastarg=$arg
3377 arg_mode=normal
3378 ;;
3379
3380 target )
3381 libobj=$arg
3382 arg_mode=normal
3383 continue
3384 ;;
3385
3386 normal )
3387 # Accept any command-line options.
3388 case $arg in
3389 -o)
3390 test -n "$libobj" && \
3391 func_fatal_error "you cannot specify '-o' more than once"
3392 arg_mode=target
3393 continue
3394 ;;
3395
3396 -pie | -fpie | -fPIE)
3397 func_append pie_flag " $arg"
3398 continue
3399 ;;
3400
3401 -shared | -static | -prefer-pic | -prefer-non-pic)
3402 func_append later " $arg"
3403 continue
3404 ;;
3405
3406 -no-suppress)
3407 suppress_opt=no
3408 continue
3409 ;;
3410
3411 -Xcompiler)
3412 arg_mode=arg # the next one goes into the "base_compile" arg list
3413 continue # The current "srcfile" will either be retained or
3414 ;; # replaced later. I would guess that would be a bug.
3415
3416 -Wc,*)
3417 func_stripname '-Wc,' '' "$arg"
3418 args=$func_stripname_result
3419 lastarg=
3420 save_ifs=$IFS; IFS=,
3421 for arg in $args; do
3422 IFS=$save_ifs
3423 func_append_quoted lastarg "$arg"
3424 done
3425 IFS=$save_ifs
3426 func_stripname ' ' '' "$lastarg"
3427 lastarg=$func_stripname_result
3428
3429 # Add the arguments to base_compile.
3430 func_append base_compile " $lastarg"
3431 continue
3432 ;;
3433
3434 *)
3435 # Accept the current argument as the source file.
3436 # The previous "srcfile" becomes the current argument.
3437 #
3438 lastarg=$srcfile
3439 srcfile=$arg
3440 ;;
3441 esac # case $arg
3442 ;;
3443 esac # case $arg_mode
3444
3445 # Aesthetically quote the previous argument.
3446 func_append_quoted base_compile "$lastarg"
3447 done # for arg
3448
3449 case $arg_mode in
3450 arg)
3451 func_fatal_error "you must specify an argument for -Xcompile"
3452 ;;
3453 target)
3454 func_fatal_error "you must specify a target with '-o'"
3455 ;;
3456 *)
3457 # Get the name of the library object.
3458 test -z "$libobj" && {
3459 func_basename "$srcfile"
3460 libobj=$func_basename_result
3461 }
3462 ;;
3463 esac
3464
3465 # Recognize several different file suffixes.
3466 # If the user specifies -o file.o, it is replaced with file.lo
3467 case $libobj in
3468 *.[cCFSifmso] | \
3469 *.ada | *.adb | *.ads | *.asm | \
3470 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
3471 *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
3472 func_xform "$libobj"
3473 libobj=$func_xform_result
3474 ;;
3475 esac
3476
3477 case $libobj in
3478 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
3479 *)
3480 func_fatal_error "cannot determine name of library object from '$libobj'"
3481 ;;
3482 esac
3483
3484 func_infer_tag $base_compile
3485
3486 for arg in $later; do
3487 case $arg in
3488 -shared)
3489 test yes = "$build_libtool_libs" \
3490 || func_fatal_configuration "cannot build a shared library"
3491 build_old_libs=no
3492 continue
3493 ;;
3494
3495 -static)
3496 build_libtool_libs=no
3497 build_old_libs=yes
3498 continue
3499 ;;
3500
3501 -prefer-pic)
3502 pic_mode=yes
3503 continue
3504 ;;
3505
3506 -prefer-non-pic)
3507 pic_mode=no
3508 continue
3509 ;;
3510 esac
3511 done
3512
3513 func_quote_for_eval "$libobj"
3514 test "X$libobj" != "X$func_quote_for_eval_result" \
3515 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
3516 && func_warning "libobj name '$libobj' may not contain shell special characters."
3517 func_dirname_and_basename "$obj" "/" ""
3518 objname=$func_basename_result
3519 xdir=$func_dirname_result
3520 lobj=$xdir$objdir/$objname
3521
3522 test -z "$base_compile" && \
3523 func_fatal_help "you must specify a compilation command"
3524
3525 # Delete any leftover library objects.
3526 if test yes = "$build_old_libs"; then
3527 removelist="$obj $lobj $libobj ${libobj}T"
3528 else
3529 removelist="$lobj $libobj ${libobj}T"
3530 fi
3531
3532 # On Cygwin there's no "real" PIC flag so we must build both object types
3533 case $host_os in
3534 cygwin* | mingw* | pw32* | os2* | cegcc*)
3535 pic_mode=default
3536 ;;
3537 esac
3538 if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
3539 # non-PIC code in shared libraries is not supported
3540 pic_mode=default
3541 fi
3542
3543 # Calculate the filename of the output object if compiler does
3544 # not support -o with -c
3545 if test no = "$compiler_c_o"; then
3546 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
3547 lockfile=$output_obj.lock
3548 else
3549 output_obj=
3550 need_locks=no
3551 lockfile=
3552 fi
3553
3554 # Lock this critical section if it is needed
3555 # We use this script file to make the link, it avoids creating a new file
3556 if test yes = "$need_locks"; then
3557 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3558 func_echo "Waiting for $lockfile to be removed"
3559 sleep 2
3560 done
3561 elif test warn = "$need_locks"; then
3562 if test -f "$lockfile"; then
3563 $ECHO "\
3564*** ERROR, $lockfile exists and contains:
3565`cat $lockfile 2>/dev/null`
3566
3567This indicates that another process is trying to use the same
3568temporary object file, and libtool could not work around it because
3569your compiler does not support '-c' and '-o' together. If you
3570repeat this compilation, it may succeed, by chance, but you had better
3571avoid parallel builds (make -j) in this platform, or get a better
3572compiler."
3573
3574 $opt_dry_run || $RM $removelist
3575 exit $EXIT_FAILURE
3576 fi
3577 func_append removelist " $output_obj"
3578 $ECHO "$srcfile" > "$lockfile"
3579 fi
3580
3581 $opt_dry_run || $RM $removelist
3582 func_append removelist " $lockfile"
3583 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
3584
3585 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
3586 srcfile=$func_to_tool_file_result
3587 func_quote_for_eval "$srcfile"
3588 qsrcfile=$func_quote_for_eval_result
3589
3590 # Only build a PIC object if we are building libtool libraries.
3591 if test yes = "$build_libtool_libs"; then
3592 # Without this assignment, base_compile gets emptied.
3593 fbsd_hideous_sh_bug=$base_compile
3594
3595 if test no != "$pic_mode"; then
3596 command="$base_compile $qsrcfile $pic_flag"
3597 else
3598 # Don't build PIC code
3599 command="$base_compile $qsrcfile"
3600 fi
3601
3602 func_mkdir_p "$xdir$objdir"
3603
3604 if test -z "$output_obj"; then
3605 # Place PIC objects in $objdir
3606 func_append command " -o $lobj"
3607 fi
3608
3609 func_show_eval_locale "$command" \
3610 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
3611
3612 if test warn = "$need_locks" &&
3613 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3614 $ECHO "\
3615*** ERROR, $lockfile contains:
3616`cat $lockfile 2>/dev/null`
3617
3618but it should contain:
3619$srcfile
3620
3621This indicates that another process is trying to use the same
3622temporary object file, and libtool could not work around it because
3623your compiler does not support '-c' and '-o' together. If you
3624repeat this compilation, it may succeed, by chance, but you had better
3625avoid parallel builds (make -j) in this platform, or get a better
3626compiler."
3627
3628 $opt_dry_run || $RM $removelist
3629 exit $EXIT_FAILURE
3630 fi
3631
3632 # Just move the object if needed, then go on to compile the next one
3633 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
3634 func_show_eval '$MV "$output_obj" "$lobj"' \
3635 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3636 fi
3637
3638 # Allow error messages only from the first compilation.
3639 if test yes = "$suppress_opt"; then
3640 suppress_output=' >/dev/null 2>&1'
3641 fi
3642 fi
3643
3644 # Only build a position-dependent object if we build old libraries.
3645 if test yes = "$build_old_libs"; then
3646 if test yes != "$pic_mode"; then
3647 # Don't build PIC code
3648 command="$base_compile $qsrcfile$pie_flag"
3649 else
3650 command="$base_compile $qsrcfile $pic_flag"
3651 fi
3652 if test yes = "$compiler_c_o"; then
3653 func_append command " -o $obj"
3654 fi
3655
3656 # Suppress compiler output if we already did a PIC compilation.
3657 func_append command "$suppress_output"
3658 func_show_eval_locale "$command" \
3659 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
3660
3661 if test warn = "$need_locks" &&
3662 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3663 $ECHO "\
3664*** ERROR, $lockfile contains:
3665`cat $lockfile 2>/dev/null`
3666
3667but it should contain:
3668$srcfile
3669
3670This indicates that another process is trying to use the same
3671temporary object file, and libtool could not work around it because
3672your compiler does not support '-c' and '-o' together. If you
3673repeat this compilation, it may succeed, by chance, but you had better
3674avoid parallel builds (make -j) in this platform, or get a better
3675compiler."
3676
3677 $opt_dry_run || $RM $removelist
3678 exit $EXIT_FAILURE
3679 fi
3680
3681 # Just move the object if needed
3682 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
3683 func_show_eval '$MV "$output_obj" "$obj"' \
3684 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3685 fi
3686 fi
3687
3688 $opt_dry_run || {
3689 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
3690
3691 # Unlock the critical section if it was locked
3692 if test no != "$need_locks"; then
3693 removelist=$lockfile
3694 $RM "$lockfile"
3695 fi
3696 }
3697
3698 exit $EXIT_SUCCESS
3699}
3700
3701$opt_help || {
3702 test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
3703}
3704
3705func_mode_help ()
3706{
3707 # We need to display help for each of the modes.
3708 case $opt_mode in
3709 "")
3710 # Generic help is extracted from the usage comments
3711 # at the start of this file.
3712 func_help
3713 ;;
3714
3715 clean)
3716 $ECHO \
3717"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
3718
3719Remove files from the build directory.
3720
3721RM is the name of the program to use to delete files associated with each FILE
3722(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
3723to RM.
3724
3725If FILE is a libtool library, object or program, all the files associated
3726with it are deleted. Otherwise, only FILE itself is deleted using RM."
3727 ;;
3728
3729 compile)
3730 $ECHO \
3731"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
3732
3733Compile a source file into a libtool library object.
3734
3735This mode accepts the following additional options:
3736
3737 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
3738 -no-suppress do not suppress compiler output for multiple passes
3739 -prefer-pic try to build PIC objects only
3740 -prefer-non-pic try to build non-PIC objects only
3741 -shared do not build a '.o' file suitable for static linking
3742 -static only build a '.o' file suitable for static linking
3743 -Wc,FLAG pass FLAG directly to the compiler
3744
3745COMPILE-COMMAND is a command to be used in creating a 'standard' object file
3746from the given SOURCEFILE.
3747
3748The output file name is determined by removing the directory component from
3749SOURCEFILE, then substituting the C source code suffix '.c' with the
3750library object suffix, '.lo'."
3751 ;;
3752
3753 execute)
3754 $ECHO \
3755"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
3756
3757Automatically set library path, then run a program.
3758
3759This mode accepts the following additional options:
3760
3761 -dlopen FILE add the directory containing FILE to the library path
3762
3763This mode sets the library path environment variable according to '-dlopen'
3764flags.
3765
3766If any of the ARGS are libtool executable wrappers, then they are translated
3767into their corresponding uninstalled binary, and any of their required library
3768directories are added to the library path.
3769
3770Then, COMMAND is executed, with ARGS as arguments."
3771 ;;
3772
3773 finish)
3774 $ECHO \
3775"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
3776
3777Complete the installation of libtool libraries.
3778
3779Each LIBDIR is a directory that contains libtool libraries.
3780
3781The commands that this mode executes may require superuser privileges. Use
3782the '--dry-run' option if you just want to see what would be executed."
3783 ;;
3784
3785 install)
3786 $ECHO \
3787"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
3788
3789Install executables or libraries.
3790
3791INSTALL-COMMAND is the installation command. The first component should be
3792either the 'install' or 'cp' program.
3793
3794The following components of INSTALL-COMMAND are treated specially:
3795
3796 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
3797
3798The rest of the components are interpreted as arguments to that command (only
3799BSD-compatible install options are recognized)."
3800 ;;
3801
3802 link)
3803 $ECHO \
3804"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
3805
3806Link object files or libraries together to form another library, or to
3807create an executable program.
3808
3809LINK-COMMAND is a command using the C compiler that you would use to create
3810a program from several object files.
3811
3812The following components of LINK-COMMAND are treated specially:
3813
3814 -all-static do not do any dynamic linking at all
3815 -avoid-version do not add a version suffix if possible
3816 -bindir BINDIR specify path to binaries directory (for systems where
3817 libraries must be found in the PATH setting at runtime)
3818 -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime
3819 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
3820 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
3821 -export-symbols SYMFILE
3822 try to export only the symbols listed in SYMFILE
3823 -export-symbols-regex REGEX
3824 try to export only the symbols matching REGEX
3825 -LLIBDIR search LIBDIR for required installed libraries
3826 -lNAME OUTPUT-FILE requires the installed library libNAME
3827 -module build a library that can dlopened
3828 -no-fast-install disable the fast-install mode
3829 -no-install link a not-installable executable
3830 -no-undefined declare that a library does not refer to external symbols
3831 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
3832 -objectlist FILE use a list of object files found in FILE to specify objects
3833 -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes)
3834 -precious-files-regex REGEX
3835 don't remove output files matching REGEX
3836 -release RELEASE specify package release information
3837 -rpath LIBDIR the created library will eventually be installed in LIBDIR
3838 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
3839 -shared only do dynamic linking of libtool libraries
3840 -shrext SUFFIX override the standard shared library file extension
3841 -static do not do any dynamic linking of uninstalled libtool libraries
3842 -static-libtool-libs
3843 do not do any dynamic linking of libtool libraries
3844 -version-info CURRENT[:REVISION[:AGE]]
3845 specify library version info [each variable defaults to 0]
3846 -weak LIBNAME declare that the target provides the LIBNAME interface
3847 -Wc,FLAG
3848 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
3849 -Wl,FLAG
3850 -Xlinker FLAG pass linker-specific FLAG directly to the linker
3851 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
3852
3853All other options (arguments beginning with '-') are ignored.
3854
3855Every other argument is treated as a filename. Files ending in '.la' are
3856treated as uninstalled libtool libraries, other files are standard or library
3857object files.
3858
3859If the OUTPUT-FILE ends in '.la', then a libtool library is created,
3860only library objects ('.lo' files) may be specified, and '-rpath' is
3861required, except when creating a convenience library.
3862
3863If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
3864using 'ar' and 'ranlib', or on Windows using 'lib'.
3865
3866If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
3867is created, otherwise an executable program is created."
3868 ;;
3869
3870 uninstall)
3871 $ECHO \
3872"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
3873
3874Remove libraries from an installation directory.
3875
3876RM is the name of the program to use to delete files associated with each FILE
3877(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
3878to RM.
3879
3880If FILE is a libtool library, all the files associated with it are deleted.
3881Otherwise, only FILE itself is deleted using RM."
3882 ;;
3883
3884 *)
3885 func_fatal_help "invalid operation mode '$opt_mode'"
3886 ;;
3887 esac
3888
3889 echo
3890 $ECHO "Try '$progname --help' for more information about other modes."
3891}
3892
3893# Now that we've collected a possible --mode arg, show help if necessary
3894if $opt_help; then
3895 if test : = "$opt_help"; then
3896 func_mode_help
3897 else
3898 {
3899 func_help noexit
3900 for opt_mode in compile link execute install finish uninstall clean; do
3901 func_mode_help
3902 done
3903 } | $SED -n '1p; 2,$s/^Usage:/ or: /p'
3904 {
3905 func_help noexit
3906 for opt_mode in compile link execute install finish uninstall clean; do
3907 echo
3908 func_mode_help
3909 done
3910 } |
3911 $SED '1d
3912 /^When reporting/,/^Report/{
3913 H
3914 d
3915 }
3916 $x
3917 /information about other modes/d
3918 /more detailed .*MODE/d
3919 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
3920 fi
3921 exit $?
3922fi
3923
3924
3925# func_mode_execute arg...
3926func_mode_execute ()
3927{
3928 $debug_cmd
3929
3930 # The first argument is the command name.
3931 cmd=$nonopt
3932 test -z "$cmd" && \
3933 func_fatal_help "you must specify a COMMAND"
3934
3935 # Handle -dlopen flags immediately.
3936 for file in $opt_dlopen; do
3937 test -f "$file" \
3938 || func_fatal_help "'$file' is not a file"
3939
3940 dir=
3941 case $file in
3942 *.la)
3943 func_resolve_sysroot "$file"
3944 file=$func_resolve_sysroot_result
3945
3946 # Check to see that this really is a libtool archive.
3947 func_lalib_unsafe_p "$file" \
3948 || func_fatal_help "'$lib' is not a valid libtool archive"
3949
3950 # Read the libtool library.
3951 dlname=
3952 library_names=
3953 func_source "$file"
3954
3955 # Skip this library if it cannot be dlopened.
3956 if test -z "$dlname"; then
3957 # Warn if it was a shared library.
3958 test -n "$library_names" && \
3959 func_warning "'$file' was not linked with '-export-dynamic'"
3960 continue
3961 fi
3962
3963 func_dirname "$file" "" "."
3964 dir=$func_dirname_result
3965
3966 if test -f "$dir/$objdir/$dlname"; then
3967 func_append dir "/$objdir"
3968 else
3969 if test ! -f "$dir/$dlname"; then
3970 func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
3971 fi
3972 fi
3973 ;;
3974
3975 *.lo)
3976 # Just add the directory containing the .lo file.
3977 func_dirname "$file" "" "."
3978 dir=$func_dirname_result
3979 ;;
3980
3981 *)
3982 func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
3983 continue
3984 ;;
3985 esac
3986
3987 # Get the absolute pathname.
3988 absdir=`cd "$dir" && pwd`
3989 test -n "$absdir" && dir=$absdir
3990
3991 # Now add the directory to shlibpath_var.
3992 if eval "test -z \"\$$shlibpath_var\""; then
3993 eval "$shlibpath_var=\"\$dir\""
3994 else
3995 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
3996 fi
3997 done
3998
3999 # This variable tells wrapper scripts just to set shlibpath_var
4000 # rather than running their programs.
4001 libtool_execute_magic=$magic
4002
4003 # Check if any of the arguments is a wrapper script.
4004 args=
4005 for file
4006 do
4007 case $file in
4008 -* | *.la | *.lo ) ;;
4009 *)
4010 # Do a test to see if this is really a libtool program.
4011 if func_ltwrapper_script_p "$file"; then
4012 func_source "$file"
4013 # Transform arg to wrapped name.
4014 file=$progdir/$program
4015 elif func_ltwrapper_executable_p "$file"; then
4016 func_ltwrapper_scriptname "$file"
4017 func_source "$func_ltwrapper_scriptname_result"
4018 # Transform arg to wrapped name.
4019 file=$progdir/$program
4020 fi
4021 ;;
4022 esac
4023 # Quote arguments (to preserve shell metacharacters).
4024 func_append_quoted args "$file"
4025 done
4026
4027 if $opt_dry_run; then
4028 # Display what would be done.
4029 if test -n "$shlibpath_var"; then
4030 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
4031 echo "export $shlibpath_var"
4032 fi
4033 $ECHO "$cmd$args"
4034 exit $EXIT_SUCCESS
4035 else
4036 if test -n "$shlibpath_var"; then
4037 # Export the shlibpath_var.
4038 eval "export $shlibpath_var"
4039 fi
4040
4041 # Restore saved environment variables
4042 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
4043 do
4044 eval "if test \"\${save_$lt_var+set}\" = set; then
4045 $lt_var=\$save_$lt_var; export $lt_var
4046 else
4047 $lt_unset $lt_var
4048 fi"
4049 done
4050
4051 # Now prepare to actually exec the command.
4052 exec_cmd=\$cmd$args
4053 fi
4054}
4055
4056test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
4057
4058
4059# func_mode_finish arg...
4060func_mode_finish ()
4061{
4062 $debug_cmd
4063
4064 libs=
4065 libdirs=
4066 admincmds=
4067
4068 for opt in "$nonopt" ${1+"$@"}
4069 do
4070 if test -d "$opt"; then
4071 func_append libdirs " $opt"
4072
4073 elif test -f "$opt"; then
4074 if func_lalib_unsafe_p "$opt"; then
4075 func_append libs " $opt"
4076 else
4077 func_warning "'$opt' is not a valid libtool archive"
4078 fi
4079
4080 else
4081 func_fatal_error "invalid argument '$opt'"
4082 fi
4083 done
4084
4085 if test -n "$libs"; then
4086 if test -n "$lt_sysroot"; then
4087 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
4088 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
4089 else
4090 sysroot_cmd=
4091 fi
4092
4093 # Remove sysroot references
4094 if $opt_dry_run; then
4095 for lib in $libs; do
4096 echo "removing references to $lt_sysroot and '=' prefixes from $lib"
4097 done
4098 else
4099 tmpdir=`func_mktempdir`
4100 for lib in $libs; do
4101 $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
4102 > $tmpdir/tmp-la
4103 mv -f $tmpdir/tmp-la $lib
4104 done
4105 ${RM}r "$tmpdir"
4106 fi
4107 fi
4108
4109 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4110 for libdir in $libdirs; do
4111 if test -n "$finish_cmds"; then
4112 # Do each command in the finish commands.
4113 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
4114'"$cmd"'"'
4115 fi
4116 if test -n "$finish_eval"; then
4117 # Do the single finish_eval.
4118 eval cmds=\"$finish_eval\"
4119 $opt_dry_run || eval "$cmds" || func_append admincmds "
4120 $cmds"
4121 fi
4122 done
4123 fi
4124
4125 # Exit here if they wanted silent mode.
4126 $opt_quiet && exit $EXIT_SUCCESS
4127
4128 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4129 echo "----------------------------------------------------------------------"
4130 echo "Libraries have been installed in:"
4131 for libdir in $libdirs; do
4132 $ECHO " $libdir"
4133 done
4134 echo
4135 echo "If you ever happen to want to link against installed libraries"
4136 echo "in a given directory, LIBDIR, you must either use libtool, and"
4137 echo "specify the full pathname of the library, or use the '-LLIBDIR'"
4138 echo "flag during linking and do at least one of the following:"
4139 if test -n "$shlibpath_var"; then
4140 echo " - add LIBDIR to the '$shlibpath_var' environment variable"
4141 echo " during execution"
4142 fi
4143 if test -n "$runpath_var"; then
4144 echo " - add LIBDIR to the '$runpath_var' environment variable"
4145 echo " during linking"
4146 fi
4147 if test -n "$hardcode_libdir_flag_spec"; then
4148 libdir=LIBDIR
4149 eval flag=\"$hardcode_libdir_flag_spec\"
4150
4151 $ECHO " - use the '$flag' linker flag"
4152 fi
4153 if test -n "$admincmds"; then
4154 $ECHO " - have your system administrator run these commands:$admincmds"
4155 fi
4156 if test -f /etc/ld.so.conf; then
4157 echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
4158 fi
4159 echo
4160
4161 echo "See any operating system documentation about shared libraries for"
4162 case $host in
4163 solaris2.[6789]|solaris2.1[0-9])
4164 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
4165 echo "pages."
4166 ;;
4167 *)
4168 echo "more information, such as the ld(1) and ld.so(8) manual pages."
4169 ;;
4170 esac
4171 echo "----------------------------------------------------------------------"
4172 fi
4173 exit $EXIT_SUCCESS
4174}
4175
4176test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
4177
4178
4179# func_mode_install arg...
4180func_mode_install ()
4181{
4182 $debug_cmd
4183
4184 # There may be an optional sh(1) argument at the beginning of
4185 # install_prog (especially on Windows NT).
4186 if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
4187 # Allow the use of GNU shtool's install command.
4188 case $nonopt in *shtool*) :;; *) false;; esac
4189 then
4190 # Aesthetically quote it.
4191 func_quote_for_eval "$nonopt"
4192 install_prog="$func_quote_for_eval_result "
4193 arg=$1
4194 shift
4195 else
4196 install_prog=
4197 arg=$nonopt
4198 fi
4199
4200 # The real first argument should be the name of the installation program.
4201 # Aesthetically quote it.
4202 func_quote_for_eval "$arg"
4203 func_append install_prog "$func_quote_for_eval_result"
4204 install_shared_prog=$install_prog
4205 case " $install_prog " in
4206 *[\\\ /]cp\ *) install_cp=: ;;
4207 *) install_cp=false ;;
4208 esac
4209
4210 # We need to accept at least all the BSD install flags.
4211 dest=
4212 files=
4213 opts=
4214 prev=
4215 install_type=
4216 isdir=false
4217 stripme=
4218 no_mode=:
4219 for arg
4220 do
4221 arg2=
4222 if test -n "$dest"; then
4223 func_append files " $dest"
4224 dest=$arg
4225 continue
4226 fi
4227
4228 case $arg in
4229 -d) isdir=: ;;
4230 -f)
4231 if $install_cp; then :; else
4232 prev=$arg
4233 fi
4234 ;;
4235 -g | -m | -o)
4236 prev=$arg
4237 ;;
4238 -s)
4239 stripme=" -s"
4240 continue
4241 ;;
4242 -*)
4243 ;;
4244 *)
4245 # If the previous option needed an argument, then skip it.
4246 if test -n "$prev"; then
4247 if test X-m = "X$prev" && test -n "$install_override_mode"; then
4248 arg2=$install_override_mode
4249 no_mode=false
4250 fi
4251 prev=
4252 else
4253 dest=$arg
4254 continue
4255 fi
4256 ;;
4257 esac
4258
4259 # Aesthetically quote the argument.
4260 func_quote_for_eval "$arg"
4261 func_append install_prog " $func_quote_for_eval_result"
4262 if test -n "$arg2"; then
4263 func_quote_for_eval "$arg2"
4264 fi
4265 func_append install_shared_prog " $func_quote_for_eval_result"
4266 done
4267
4268 test -z "$install_prog" && \
4269 func_fatal_help "you must specify an install program"
4270
4271 test -n "$prev" && \
4272 func_fatal_help "the '$prev' option requires an argument"
4273
4274 if test -n "$install_override_mode" && $no_mode; then
4275 if $install_cp; then :; else
4276 func_quote_for_eval "$install_override_mode"
4277 func_append install_shared_prog " -m $func_quote_for_eval_result"
4278 fi
4279 fi
4280
4281 if test -z "$files"; then
4282 if test -z "$dest"; then
4283 func_fatal_help "no file or destination specified"
4284 else
4285 func_fatal_help "you must specify a destination"
4286 fi
4287 fi
4288
4289 # Strip any trailing slash from the destination.
4290 func_stripname '' '/' "$dest"
4291 dest=$func_stripname_result
4292
4293 # Check to see that the destination is a directory.
4294 test -d "$dest" && isdir=:
4295 if $isdir; then
4296 destdir=$dest
4297 destname=
4298 else
4299 func_dirname_and_basename "$dest" "" "."
4300 destdir=$func_dirname_result
4301 destname=$func_basename_result
4302
4303 # Not a directory, so check to see that there is only one file specified.
4304 set dummy $files; shift
4305 test "$#" -gt 1 && \
4306 func_fatal_help "'$dest' is not a directory"
4307 fi
4308 case $destdir in
4309 [\\/]* | [A-Za-z]:[\\/]*) ;;
4310 *)
4311 for file in $files; do
4312 case $file in
4313 *.lo) ;;
4314 *)
4315 func_fatal_help "'$destdir' must be an absolute directory name"
4316 ;;
4317 esac
4318 done
4319 ;;
4320 esac
4321
4322 # This variable tells wrapper scripts just to set variables rather
4323 # than running their programs.
4324 libtool_install_magic=$magic
4325
4326 staticlibs=
4327 future_libdirs=
4328 current_libdirs=
4329 for file in $files; do
4330
4331 # Do each installation.
4332 case $file in
4333 *.$libext)
4334 # Do the static libraries later.
4335 func_append staticlibs " $file"
4336 ;;
4337
4338 *.la)
4339 func_resolve_sysroot "$file"
4340 file=$func_resolve_sysroot_result
4341
4342 # Check to see that this really is a libtool archive.
4343 func_lalib_unsafe_p "$file" \
4344 || func_fatal_help "'$file' is not a valid libtool archive"
4345
4346 library_names=
4347 old_library=
4348 relink_command=
4349 func_source "$file"
4350
4351 # Add the libdir to current_libdirs if it is the destination.
4352 if test "X$destdir" = "X$libdir"; then
4353 case "$current_libdirs " in
4354 *" $libdir "*) ;;
4355 *) func_append current_libdirs " $libdir" ;;
4356 esac
4357 else
4358 # Note the libdir as a future libdir.
4359 case "$future_libdirs " in
4360 *" $libdir "*) ;;
4361 *) func_append future_libdirs " $libdir" ;;
4362 esac
4363 fi
4364
4365 func_dirname "$file" "/" ""
4366 dir=$func_dirname_result
4367 func_append dir "$objdir"
4368
4369 if test -n "$relink_command"; then
4370 # Determine the prefix the user has applied to our future dir.
4371 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
4372
4373 # Don't allow the user to place us outside of our expected
4374 # location b/c this prevents finding dependent libraries that
4375 # are installed to the same prefix.
4376 # At present, this check doesn't affect windows .dll's that
4377 # are installed into $libdir/../bin (currently, that works fine)
4378 # but it's something to keep an eye on.
4379 test "$inst_prefix_dir" = "$destdir" && \
4380 func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
4381
4382 if test -n "$inst_prefix_dir"; then
4383 # Stick the inst_prefix_dir data into the link command.
4384 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
4385 else
4386 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
4387 fi
4388
4389 func_warning "relinking '$file'"
4390 func_show_eval "$relink_command" \
4391 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
4392 fi
4393
4394 # See the names of the shared library.
4395 set dummy $library_names; shift
4396 if test -n "$1"; then
4397 realname=$1
4398 shift
4399
4400 srcname=$realname
4401 test -n "$relink_command" && srcname=${realname}T
4402
4403 # Install the shared library and build the symlinks.
4404 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
4405 'exit $?'
4406 tstripme=$stripme
4407 case $host_os in
4408 cygwin* | mingw* | pw32* | cegcc*)
4409 case $realname in
4410 *.dll.a)
4411 tstripme=
4412 ;;
4413 esac
4414 ;;
4415 os2*)
4416 case $realname in
4417 *_dll.a)
4418 tstripme=
4419 ;;
4420 esac
4421 ;;
4422 esac
4423 if test -n "$tstripme" && test -n "$striplib"; then
4424 func_show_eval "$striplib $destdir/$realname" 'exit $?'
4425 fi
4426
4427 if test "$#" -gt 0; then
4428 # Delete the old symlinks, and create new ones.
4429 # Try 'ln -sf' first, because the 'ln' binary might depend on
4430 # the symlink we replace! Solaris /bin/ln does not understand -f,
4431 # so we also need to try rm && ln -s.
4432 for linkname
4433 do
4434 test "$linkname" != "$realname" \
4435 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
4436 done
4437 fi
4438
4439 # Do each command in the postinstall commands.
4440 lib=$destdir/$realname
4441 func_execute_cmds "$postinstall_cmds" 'exit $?'
4442 fi
4443
4444 # Install the pseudo-library for information purposes.
4445 func_basename "$file"
4446 name=$func_basename_result
4447 instname=$dir/${name}i
4448 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
4449
4450 # Maybe install the static library, too.
4451 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
4452 ;;
4453
4454 *.lo)
4455 # Install (i.e. copy) a libtool object.
4456
4457 # Figure out destination file name, if it wasn't already specified.
4458 if test -n "$destname"; then
4459 destfile=$destdir/$destname
4460 else
4461 func_basename "$file"
4462 destfile=$func_basename_result
4463 destfile=$destdir/$destfile
4464 fi
4465
4466 # Deduce the name of the destination old-style object file.
4467 case $destfile in
4468 *.lo)
4469 func_lo2o "$destfile"
4470 staticdest=$func_lo2o_result
4471 ;;
4472 *.$objext)
4473 staticdest=$destfile
4474 destfile=
4475 ;;
4476 *)
4477 func_fatal_help "cannot copy a libtool object to '$destfile'"
4478 ;;
4479 esac
4480
4481 # Install the libtool object if requested.
4482 test -n "$destfile" && \
4483 func_show_eval "$install_prog $file $destfile" 'exit $?'
4484
4485 # Install the old object if enabled.
4486 if test yes = "$build_old_libs"; then
4487 # Deduce the name of the old-style object file.
4488 func_lo2o "$file"
4489 staticobj=$func_lo2o_result
4490 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
4491 fi
4492 exit $EXIT_SUCCESS
4493 ;;
4494
4495 *)
4496 # Figure out destination file name, if it wasn't already specified.
4497 if test -n "$destname"; then
4498 destfile=$destdir/$destname
4499 else
4500 func_basename "$file"
4501 destfile=$func_basename_result
4502 destfile=$destdir/$destfile
4503 fi
4504
4505 # If the file is missing, and there is a .exe on the end, strip it
4506 # because it is most likely a libtool script we actually want to
4507 # install
4508 stripped_ext=
4509 case $file in
4510 *.exe)
4511 if test ! -f "$file"; then
4512 func_stripname '' '.exe' "$file"
4513 file=$func_stripname_result
4514 stripped_ext=.exe
4515 fi
4516 ;;
4517 esac
4518
4519 # Do a test to see if this is really a libtool program.
4520 case $host in
4521 *cygwin* | *mingw*)
4522 if func_ltwrapper_executable_p "$file"; then
4523 func_ltwrapper_scriptname "$file"
4524 wrapper=$func_ltwrapper_scriptname_result
4525 else
4526 func_stripname '' '.exe' "$file"
4527 wrapper=$func_stripname_result
4528 fi
4529 ;;
4530 *)
4531 wrapper=$file
4532 ;;
4533 esac
4534 if func_ltwrapper_script_p "$wrapper"; then
4535 notinst_deplibs=
4536 relink_command=
4537
4538 func_source "$wrapper"
4539
4540 # Check the variables that should have been set.
4541 test -z "$generated_by_libtool_version" && \
4542 func_fatal_error "invalid libtool wrapper script '$wrapper'"
4543
4544 finalize=:
4545 for lib in $notinst_deplibs; do
4546 # Check to see that each library is installed.
4547 libdir=
4548 if test -f "$lib"; then
4549 func_source "$lib"
4550 fi
4551 libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
4552 if test -n "$libdir" && test ! -f "$libfile"; then
4553 func_warning "'$lib' has not been installed in '$libdir'"
4554 finalize=false
4555 fi
4556 done
4557
4558 relink_command=
4559 func_source "$wrapper"
4560
4561 outputname=
4562 if test no = "$fast_install" && test -n "$relink_command"; then
4563 $opt_dry_run || {
4564 if $finalize; then
4565 tmpdir=`func_mktempdir`
4566 func_basename "$file$stripped_ext"
4567 file=$func_basename_result
4568 outputname=$tmpdir/$file
4569 # Replace the output file specification.
4570 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
4571
4572 $opt_quiet || {
4573 func_quote_for_expand "$relink_command"
4574 eval "func_echo $func_quote_for_expand_result"
4575 }
4576 if eval "$relink_command"; then :
4577 else
4578 func_error "error: relink '$file' with the above command before installing it"
4579 $opt_dry_run || ${RM}r "$tmpdir"
4580 continue
4581 fi
4582 file=$outputname
4583 else
4584 func_warning "cannot relink '$file'"
4585 fi
4586 }
4587 else
4588 # Install the binary that we compiled earlier.
4589 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
4590 fi
4591 fi
4592
4593 # remove .exe since cygwin /usr/bin/install will append another
4594 # one anyway
4595 case $install_prog,$host in
4596 */usr/bin/install*,*cygwin*)
4597 case $file:$destfile in
4598 *.exe:*.exe)
4599 # this is ok
4600 ;;
4601 *.exe:*)
4602 destfile=$destfile.exe
4603 ;;
4604 *:*.exe)
4605 func_stripname '' '.exe' "$destfile"
4606 destfile=$func_stripname_result
4607 ;;
4608 esac
4609 ;;
4610 esac
4611 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
4612 $opt_dry_run || if test -n "$outputname"; then
4613 ${RM}r "$tmpdir"
4614 fi
4615 ;;
4616 esac
4617 done
4618
4619 for file in $staticlibs; do
4620 func_basename "$file"
4621 name=$func_basename_result
4622
4623 # Set up the ranlib parameters.
4624 oldlib=$destdir/$name
4625 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
4626 tool_oldlib=$func_to_tool_file_result
4627
4628 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
4629
4630 if test -n "$stripme" && test -n "$old_striplib"; then
4631 func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
4632 fi
4633
4634 # Do each command in the postinstall commands.
4635 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
4636 done
4637
4638 test -n "$future_libdirs" && \
4639 func_warning "remember to run '$progname --finish$future_libdirs'"
4640
4641 if test -n "$current_libdirs"; then
4642 # Maybe just do a dry run.
4643 $opt_dry_run && current_libdirs=" -n$current_libdirs"
4644 exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
4645 else
4646 exit $EXIT_SUCCESS
4647 fi
4648}
4649
4650test install = "$opt_mode" && func_mode_install ${1+"$@"}
4651
4652
4653# func_generate_dlsyms outputname originator pic_p
4654# Extract symbols from dlprefiles and create ${outputname}S.o with
4655# a dlpreopen symbol table.
4656func_generate_dlsyms ()
4657{
4658 $debug_cmd
4659
4660 my_outputname=$1
4661 my_originator=$2
4662 my_pic_p=${3-false}
4663 my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
4664 my_dlsyms=
4665
4666 if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
4667 if test -n "$NM" && test -n "$global_symbol_pipe"; then
4668 my_dlsyms=${my_outputname}S.c
4669 else
4670 func_error "not configured to extract global symbols from dlpreopened files"
4671 fi
4672 fi
4673
4674 if test -n "$my_dlsyms"; then
4675 case $my_dlsyms in
4676 "") ;;
4677 *.c)
4678 # Discover the nlist of each of the dlfiles.
4679 nlist=$output_objdir/$my_outputname.nm
4680
4681 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
4682
4683 # Parse the name list into a source file.
4684 func_verbose "creating $output_objdir/$my_dlsyms"
4685
4686 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
4687/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
4688/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
4689
4690#ifdef __cplusplus
4691extern \"C\" {
4692#endif
4693
4694#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
4695#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
4696#endif
4697
4698/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
4699#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
4700/* DATA imports from DLLs on WIN32 can't be const, because runtime
4701 relocations are performed -- see ld's documentation on pseudo-relocs. */
4702# define LT_DLSYM_CONST
4703#elif defined __osf__
4704/* This system does not cope well with relocations in const data. */
4705# define LT_DLSYM_CONST
4706#else
4707# define LT_DLSYM_CONST const
4708#endif
4709
4710#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
4711
4712/* External symbol declarations for the compiler. */\
4713"
4714
4715 if test yes = "$dlself"; then
4716 func_verbose "generating symbol list for '$output'"
4717
4718 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
4719
4720 # Add our own program objects to the symbol list.
4721 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
4722 for progfile in $progfiles; do
4723 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
4724 func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
4725 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
4726 done
4727
4728 if test -n "$exclude_expsyms"; then
4729 $opt_dry_run || {
4730 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4731 eval '$MV "$nlist"T "$nlist"'
4732 }
4733 fi
4734
4735 if test -n "$export_symbols_regex"; then
4736 $opt_dry_run || {
4737 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4738 eval '$MV "$nlist"T "$nlist"'
4739 }
4740 fi
4741
4742 # Prepare the list of exported symbols
4743 if test -z "$export_symbols"; then
4744 export_symbols=$output_objdir/$outputname.exp
4745 $opt_dry_run || {
4746 $RM $export_symbols
4747 eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4748 case $host in
4749 *cygwin* | *mingw* | *cegcc* )
4750 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4751 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4752 ;;
4753 esac
4754 }
4755 else
4756 $opt_dry_run || {
4757 eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4758 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4759 eval '$MV "$nlist"T "$nlist"'
4760 case $host in
4761 *cygwin* | *mingw* | *cegcc* )
4762 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4763 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4764 ;;
4765 esac
4766 }
4767 fi
4768 fi
4769
4770 for dlprefile in $dlprefiles; do
4771 func_verbose "extracting global C symbols from '$dlprefile'"
4772 func_basename "$dlprefile"
4773 name=$func_basename_result
4774 case $host in
4775 *cygwin* | *mingw* | *cegcc* )
4776 # if an import library, we need to obtain dlname
4777 if func_win32_import_lib_p "$dlprefile"; then
4778 func_tr_sh "$dlprefile"
4779 eval "curr_lafile=\$libfile_$func_tr_sh_result"
4780 dlprefile_dlbasename=
4781 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
4782 # Use subshell, to avoid clobbering current variable values
4783 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
4784 if test -n "$dlprefile_dlname"; then
4785 func_basename "$dlprefile_dlname"
4786 dlprefile_dlbasename=$func_basename_result
4787 else
4788 # no lafile. user explicitly requested -dlpreopen <import library>.
4789 $sharedlib_from_linklib_cmd "$dlprefile"
4790 dlprefile_dlbasename=$sharedlib_from_linklib_result
4791 fi
4792 fi
4793 $opt_dry_run || {
4794 if test -n "$dlprefile_dlbasename"; then
4795 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
4796 else
4797 func_warning "Could not compute DLL name from $name"
4798 eval '$ECHO ": $name " >> "$nlist"'
4799 fi
4800 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4801 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
4802 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
4803 }
4804 else # not an import lib
4805 $opt_dry_run || {
4806 eval '$ECHO ": $name " >> "$nlist"'
4807 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4808 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4809 }
4810 fi
4811 ;;
4812 *)
4813 $opt_dry_run || {
4814 eval '$ECHO ": $name " >> "$nlist"'
4815 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4816 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4817 }
4818 ;;
4819 esac
4820 done
4821
4822 $opt_dry_run || {
4823 # Make sure we have at least an empty file.
4824 test -f "$nlist" || : > "$nlist"
4825
4826 if test -n "$exclude_expsyms"; then
4827 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4828 $MV "$nlist"T "$nlist"
4829 fi
4830
4831 # Try sorting and uniquifying the output.
4832 if $GREP -v "^: " < "$nlist" |
4833 if sort -k 3 </dev/null >/dev/null 2>&1; then
4834 sort -k 3
4835 else
4836 sort +2
4837 fi |
4838 uniq > "$nlist"S; then
4839 :
4840 else
4841 $GREP -v "^: " < "$nlist" > "$nlist"S
4842 fi
4843
4844 if test -f "$nlist"S; then
4845 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
4846 else
4847 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
4848 fi
4849
4850 func_show_eval '$RM "${nlist}I"'
4851 if test -n "$global_symbol_to_import"; then
4852 eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
4853 fi
4854
4855 echo >> "$output_objdir/$my_dlsyms" "\
4856
4857/* The mapping between symbol names and symbols. */
4858typedef struct {
4859 const char *name;
4860 void *address;
4861} lt_dlsymlist;
4862extern LT_DLSYM_CONST lt_dlsymlist
4863lt_${my_prefix}_LTX_preloaded_symbols[];\
4864"
4865
4866 if test -s "$nlist"I; then
4867 echo >> "$output_objdir/$my_dlsyms" "\
4868static void lt_syminit(void)
4869{
4870 LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
4871 for (; symbol->name; ++symbol)
4872 {"
4873 $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
4874 echo >> "$output_objdir/$my_dlsyms" "\
4875 }
4876}"
4877 fi
4878 echo >> "$output_objdir/$my_dlsyms" "\
4879LT_DLSYM_CONST lt_dlsymlist
4880lt_${my_prefix}_LTX_preloaded_symbols[] =
4881{ {\"$my_originator\", (void *) 0},"
4882
4883 if test -s "$nlist"I; then
4884 echo >> "$output_objdir/$my_dlsyms" "\
4885 {\"@INIT@\", (void *) &lt_syminit},"
4886 fi
4887
4888 case $need_lib_prefix in
4889 no)
4890 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
4891 ;;
4892 *)
4893 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
4894 ;;
4895 esac
4896 echo >> "$output_objdir/$my_dlsyms" "\
4897 {0, (void *) 0}
4898};
4899
4900/* This works around a problem in FreeBSD linker */
4901#ifdef FREEBSD_WORKAROUND
4902static const void *lt_preloaded_setup() {
4903 return lt_${my_prefix}_LTX_preloaded_symbols;
4904}
4905#endif
4906
4907#ifdef __cplusplus
4908}
4909#endif\
4910"
4911 } # !$opt_dry_run
4912
4913 pic_flag_for_symtable=
4914 case "$compile_command " in
4915 *" -static "*) ;;
4916 *)
4917 case $host in
4918 # compiling the symbol table file with pic_flag works around
4919 # a FreeBSD bug that causes programs to crash when -lm is
4920 # linked before any other PIC object. But we must not use
4921 # pic_flag when linking with -static. The problem exists in
4922 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4923 *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4924 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
4925 *-*-hpux*)
4926 pic_flag_for_symtable=" $pic_flag" ;;
4927 *)
4928 $my_pic_p && pic_flag_for_symtable=" $pic_flag"
4929 ;;
4930 esac
4931 ;;
4932 esac
4933 symtab_cflags=
4934 for arg in $LTCFLAGS; do
4935 case $arg in
4936 -pie | -fpie | -fPIE) ;;
4937 *) func_append symtab_cflags " $arg" ;;
4938 esac
4939 done
4940
4941 # Now compile the dynamic symbol file.
4942 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
4943
4944 # Clean up the generated files.
4945 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
4946
4947 # Transform the symbol file into the correct name.
4948 symfileobj=$output_objdir/${my_outputname}S.$objext
4949 case $host in
4950 *cygwin* | *mingw* | *cegcc* )
4951 if test -f "$output_objdir/$my_outputname.def"; then
4952 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
4953 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
4954 else
4955 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
4956 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
4957 fi
4958 ;;
4959 *)
4960 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
4961 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
4962 ;;
4963 esac
4964 ;;
4965 *)
4966 func_fatal_error "unknown suffix for '$my_dlsyms'"
4967 ;;
4968 esac
4969 else
4970 # We keep going just in case the user didn't refer to
4971 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
4972 # really was required.
4973
4974 # Nullify the symbol file.
4975 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
4976 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
4977 fi
4978}
4979
4980# func_cygming_gnu_implib_p ARG
4981# This predicate returns with zero status (TRUE) if
4982# ARG is a GNU/binutils-style import library. Returns
4983# with nonzero status (FALSE) otherwise.
4984func_cygming_gnu_implib_p ()
4985{
4986 $debug_cmd
4987
4988 func_to_tool_file "$1" func_convert_file_msys_to_w32
4989 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)$'`
4990 test -n "$func_cygming_gnu_implib_tmp"
4991}
4992
4993# func_cygming_ms_implib_p ARG
4994# This predicate returns with zero status (TRUE) if
4995# ARG is an MS-style import library. Returns
4996# with nonzero status (FALSE) otherwise.
4997func_cygming_ms_implib_p ()
4998{
4999 $debug_cmd
5000
5001 func_to_tool_file "$1" func_convert_file_msys_to_w32
5002 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
5003 test -n "$func_cygming_ms_implib_tmp"
5004}
5005
5006# func_win32_libid arg
5007# return the library type of file 'arg'
5008#
5009# Need a lot of goo to handle *both* DLLs and import libs
5010# Has to be a shell function in order to 'eat' the argument
5011# that is supplied when $file_magic_command is called.
5012# Despite the name, also deal with 64 bit binaries.
5013func_win32_libid ()
5014{
5015 $debug_cmd
5016
5017 win32_libid_type=unknown
5018 win32_fileres=`file -L $1 2>/dev/null`
5019 case $win32_fileres in
5020 *ar\ archive\ import\ library*) # definitely import
5021 win32_libid_type="x86 archive import"
5022 ;;
5023 *ar\ archive*) # could be an import, or static
5024 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
5025 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
5026 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
5027 case $nm_interface in
5028 "MS dumpbin")
5029 if func_cygming_ms_implib_p "$1" ||
5030 func_cygming_gnu_implib_p "$1"
5031 then
5032 win32_nmres=import
5033 else
5034 win32_nmres=
5035 fi
5036 ;;
5037 *)
5038 func_to_tool_file "$1" func_convert_file_msys_to_w32
5039 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
5040 $SED -n -e '
5041 1,100{
5042 / I /{
5043 s|.*|import|
5044 p
5045 q
5046 }
5047 }'`
5048 ;;
5049 esac
5050 case $win32_nmres in
5051 import*) win32_libid_type="x86 archive import";;
5052 *) win32_libid_type="x86 archive static";;
5053 esac
5054 fi
5055 ;;
5056 *DLL*)
5057 win32_libid_type="x86 DLL"
5058 ;;
5059 *executable*) # but shell scripts are "executable" too...
5060 case $win32_fileres in
5061 *MS\ Windows\ PE\ Intel*)
5062 win32_libid_type="x86 DLL"
5063 ;;
5064 esac
5065 ;;
5066 esac
5067 $ECHO "$win32_libid_type"
5068}
5069
5070# func_cygming_dll_for_implib ARG
5071#
5072# Platform-specific function to extract the
5073# name of the DLL associated with the specified
5074# import library ARG.
5075# Invoked by eval'ing the libtool variable
5076# $sharedlib_from_linklib_cmd
5077# Result is available in the variable
5078# $sharedlib_from_linklib_result
5079func_cygming_dll_for_implib ()
5080{
5081 $debug_cmd
5082
5083 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
5084}
5085
5086# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
5087#
5088# The is the core of a fallback implementation of a
5089# platform-specific function to extract the name of the
5090# DLL associated with the specified import library LIBNAME.
5091#
5092# SECTION_NAME is either .idata$6 or .idata$7, depending
5093# on the platform and compiler that created the implib.
5094#
5095# Echos the name of the DLL associated with the
5096# specified import library.
5097func_cygming_dll_for_implib_fallback_core ()
5098{
5099 $debug_cmd
5100
5101 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
5102 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
5103 $SED '/^Contents of section '"$match_literal"':/{
5104 # Place marker at beginning of archive member dllname section
5105 s/.*/====MARK====/
5106 p
5107 d
5108 }
5109 # These lines can sometimes be longer than 43 characters, but
5110 # are always uninteresting
5111 /:[ ]*file format pe[i]\{,1\}-/d
5112 /^In archive [^:]*:/d
5113 # Ensure marker is printed
5114 /^====MARK====/p
5115 # Remove all lines with less than 43 characters
5116 /^.\{43\}/!d
5117 # From remaining lines, remove first 43 characters
5118 s/^.\{43\}//' |
5119 $SED -n '
5120 # Join marker and all lines until next marker into a single line
5121 /^====MARK====/ b para
5122 H
5123 $ b para
5124 b
5125 :para
5126 x
5127 s/\n//g
5128 # Remove the marker
5129 s/^====MARK====//
5130 # Remove trailing dots and whitespace
5131 s/[\. \t]*$//
5132 # Print
5133 /./p' |
5134 # we now have a list, one entry per line, of the stringified
5135 # contents of the appropriate section of all members of the
5136 # archive that possess that section. Heuristic: eliminate
5137 # all those that have a first or second character that is
5138 # a '.' (that is, objdump's representation of an unprintable
5139 # character.) This should work for all archives with less than
5140 # 0x302f exports -- but will fail for DLLs whose name actually
5141 # begins with a literal '.' or a single character followed by
5142 # a '.'.
5143 #
5144 # Of those that remain, print the first one.
5145 $SED -e '/^\./d;/^.\./d;q'
5146}
5147
5148# func_cygming_dll_for_implib_fallback ARG
5149# Platform-specific function to extract the
5150# name of the DLL associated with the specified
5151# import library ARG.
5152#
5153# This fallback implementation is for use when $DLLTOOL
5154# does not support the --identify-strict option.
5155# Invoked by eval'ing the libtool variable
5156# $sharedlib_from_linklib_cmd
5157# Result is available in the variable
5158# $sharedlib_from_linklib_result
5159func_cygming_dll_for_implib_fallback ()
5160{
5161 $debug_cmd
5162
5163 if func_cygming_gnu_implib_p "$1"; then
5164 # binutils import library
5165 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
5166 elif func_cygming_ms_implib_p "$1"; then
5167 # ms-generated import library
5168 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
5169 else
5170 # unknown
5171 sharedlib_from_linklib_result=
5172 fi
5173}
5174
5175
5176# func_extract_an_archive dir oldlib
5177func_extract_an_archive ()
5178{
5179 $debug_cmd
5180
5181 f_ex_an_ar_dir=$1; shift
5182 f_ex_an_ar_oldlib=$1
5183 if test yes = "$lock_old_archive_extraction"; then
5184 lockfile=$f_ex_an_ar_oldlib.lock
5185 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
5186 func_echo "Waiting for $lockfile to be removed"
5187 sleep 2
5188 done
5189 fi
5190 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
5191 'stat=$?; rm -f "$lockfile"; exit $stat'
5192 if test yes = "$lock_old_archive_extraction"; then
5193 $opt_dry_run || rm -f "$lockfile"
5194 fi
5195 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
5196 :
5197 else
5198 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
5199 fi
5200}
5201
5202
5203# func_extract_archives gentop oldlib ...
5204func_extract_archives ()
5205{
5206 $debug_cmd
5207
5208 my_gentop=$1; shift
5209 my_oldlibs=${1+"$@"}
5210 my_oldobjs=
5211 my_xlib=
5212 my_xabs=
5213 my_xdir=
5214
5215 for my_xlib in $my_oldlibs; do
5216 # Extract the objects.
5217 case $my_xlib in
5218 [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
5219 *) my_xabs=`pwd`"/$my_xlib" ;;
5220 esac
5221 func_basename "$my_xlib"
5222 my_xlib=$func_basename_result
5223 my_xlib_u=$my_xlib
5224 while :; do
5225 case " $extracted_archives " in
5226 *" $my_xlib_u "*)
5227 func_arith $extracted_serial + 1
5228 extracted_serial=$func_arith_result
5229 my_xlib_u=lt$extracted_serial-$my_xlib ;;
5230 *) break ;;
5231 esac
5232 done
5233 extracted_archives="$extracted_archives $my_xlib_u"
5234 my_xdir=$my_gentop/$my_xlib_u
5235
5236 func_mkdir_p "$my_xdir"
5237
5238 case $host in
5239 *-darwin*)
5240 func_verbose "Extracting $my_xabs"
5241 # Do not bother doing anything if just a dry run
5242 $opt_dry_run || {
5243 darwin_orig_dir=`pwd`
5244 cd $my_xdir || exit $?
5245 darwin_archive=$my_xabs
5246 darwin_curdir=`pwd`
5247 func_basename "$darwin_archive"
5248 darwin_base_archive=$func_basename_result
5249 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
5250 if test -n "$darwin_arches"; then
5251 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
5252 darwin_arch=
5253 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
5254 for darwin_arch in $darwin_arches; do
5255 func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
5256 $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
5257 cd "unfat-$$/$darwin_base_archive-$darwin_arch"
5258 func_extract_an_archive "`pwd`" "$darwin_base_archive"
5259 cd "$darwin_curdir"
5260 $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
5261 done # $darwin_arches
5262 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
5263 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
5264 darwin_file=
5265 darwin_files=
5266 for darwin_file in $darwin_filelist; do
5267 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
5268 $LIPO -create -output "$darwin_file" $darwin_files
5269 done # $darwin_filelist
5270 $RM -rf unfat-$$
5271 cd "$darwin_orig_dir"
5272 else
5273 cd $darwin_orig_dir
5274 func_extract_an_archive "$my_xdir" "$my_xabs"
5275 fi # $darwin_arches
5276 } # !$opt_dry_run
5277 ;;
5278 *)
5279 func_extract_an_archive "$my_xdir" "$my_xabs"
5280 ;;
5281 esac
5282 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
5283 done
5284
5285 func_extract_archives_result=$my_oldobjs
5286}
5287
5288
5289# func_emit_wrapper [arg=no]
5290#
5291# Emit a libtool wrapper script on stdout.
5292# Don't directly open a file because we may want to
5293# incorporate the script contents within a cygwin/mingw
5294# wrapper executable. Must ONLY be called from within
5295# func_mode_link because it depends on a number of variables
5296# set therein.
5297#
5298# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
5299# variable will take. If 'yes', then the emitted script
5300# will assume that the directory where it is stored is
5301# the $objdir directory. This is a cygwin/mingw-specific
5302# behavior.
5303func_emit_wrapper ()
5304{
5305 func_emit_wrapper_arg1=${1-no}
5306
5307 $ECHO "\
5308#! $SHELL
5309
5310# $output - temporary wrapper script for $objdir/$outputname
5311# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5312#
5313# The $output program cannot be directly executed until all the libtool
5314# libraries that it depends on are installed.
5315#
5316# This wrapper script should never be moved out of the build directory.
5317# If it is, it will not operate correctly.
5318
5319# Sed substitution that helps us do robust quoting. It backslashifies
5320# metacharacters that are still active within double-quoted strings.
5321sed_quote_subst='$sed_quote_subst'
5322
5323# Be Bourne compatible
5324if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5325 emulate sh
5326 NULLCMD=:
5327 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5328 # is contrary to our usage. Disable this feature.
5329 alias -g '\${1+\"\$@\"}'='\"\$@\"'
5330 setopt NO_GLOB_SUBST
5331else
5332 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5333fi
5334BIN_SH=xpg4; export BIN_SH # for Tru64
5335DUALCASE=1; export DUALCASE # for MKS sh
5336
5337# The HP-UX ksh and POSIX shell print the target directory to stdout
5338# if CDPATH is set.
5339(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5340
5341relink_command=\"$relink_command\"
5342
5343# This environment variable determines our operation mode.
5344if test \"\$libtool_install_magic\" = \"$magic\"; then
5345 # install mode needs the following variables:
5346 generated_by_libtool_version='$macro_version'
5347 notinst_deplibs='$notinst_deplibs'
5348else
5349 # When we are sourced in execute mode, \$file and \$ECHO are already set.
5350 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5351 file=\"\$0\""
5352
5353 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
5354 $ECHO "\
5355
5356# A function that is used when there is no print builtin or printf.
5357func_fallback_echo ()
5358{
5359 eval 'cat <<_LTECHO_EOF
5360\$1
5361_LTECHO_EOF'
5362}
5363 ECHO=\"$qECHO\"
5364 fi
5365
5366# Very basic option parsing. These options are (a) specific to
5367# the libtool wrapper, (b) are identical between the wrapper
5368# /script/ and the wrapper /executable/ that is used only on
5369# windows platforms, and (c) all begin with the string "--lt-"
5370# (application programs are unlikely to have options that match
5371# this pattern).
5372#
5373# There are only two supported options: --lt-debug and
5374# --lt-dump-script. There is, deliberately, no --lt-help.
5375#
5376# The first argument to this parsing function should be the
5377# script's $0 value, followed by "$@".
5378lt_option_debug=
5379func_parse_lt_options ()
5380{
5381 lt_script_arg0=\$0
5382 shift
5383 for lt_opt
5384 do
5385 case \"\$lt_opt\" in
5386 --lt-debug) lt_option_debug=1 ;;
5387 --lt-dump-script)
5388 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
5389 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
5390 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
5391 cat \"\$lt_dump_D/\$lt_dump_F\"
5392 exit 0
5393 ;;
5394 --lt-*)
5395 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
5396 exit 1
5397 ;;
5398 esac
5399 done
5400
5401 # Print the debug banner immediately:
5402 if test -n \"\$lt_option_debug\"; then
5403 echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
5404 fi
5405}
5406
5407# Used when --lt-debug. Prints its arguments to stdout
5408# (redirection is the responsibility of the caller)
5409func_lt_dump_args ()
5410{
5411 lt_dump_args_N=1;
5412 for lt_arg
5413 do
5414 \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
5415 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
5416 done
5417}
5418
5419# Core function for launching the target application
5420func_exec_program_core ()
5421{
5422"
5423 case $host in
5424 # Backslashes separate directories on plain windows
5425 *-*-mingw | *-*-os2* | *-cegcc*)
5426 $ECHO "\
5427 if test -n \"\$lt_option_debug\"; then
5428 \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
5429 func_lt_dump_args \${1+\"\$@\"} 1>&2
5430 fi
5431 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5432"
5433 ;;
5434
5435 *)
5436 $ECHO "\
5437 if test -n \"\$lt_option_debug\"; then
5438 \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
5439 func_lt_dump_args \${1+\"\$@\"} 1>&2
5440 fi
5441 exec \"\$progdir/\$program\" \${1+\"\$@\"}
5442"
5443 ;;
5444 esac
5445 $ECHO "\
5446 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
5447 exit 1
5448}
5449
5450# A function to encapsulate launching the target application
5451# Strips options in the --lt-* namespace from \$@ and
5452# launches target application with the remaining arguments.
5453func_exec_program ()
5454{
5455 case \" \$* \" in
5456 *\\ --lt-*)
5457 for lt_wr_arg
5458 do
5459 case \$lt_wr_arg in
5460 --lt-*) ;;
5461 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
5462 esac
5463 shift
5464 done ;;
5465 esac
5466 func_exec_program_core \${1+\"\$@\"}
5467}
5468
5469 # Parse options
5470 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
5471
5472 # Find the directory that this script lives in.
5473 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
5474 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5475
5476 # Follow symbolic links until we get to the real thisdir.
5477 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
5478 while test -n \"\$file\"; do
5479 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
5480
5481 # If there was a directory component, then change thisdir.
5482 if test \"x\$destdir\" != \"x\$file\"; then
5483 case \"\$destdir\" in
5484 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5485 *) thisdir=\"\$thisdir/\$destdir\" ;;
5486 esac
5487 fi
5488
5489 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
5490 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
5491 done
5492
5493 # Usually 'no', except on cygwin/mingw when embedded into
5494 # the cwrapper.
5495 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
5496 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
5497 # special case for '.'
5498 if test \"\$thisdir\" = \".\"; then
5499 thisdir=\`pwd\`
5500 fi
5501 # remove .libs from thisdir
5502 case \"\$thisdir\" in
5503 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
5504 $objdir ) thisdir=. ;;
5505 esac
5506 fi
5507
5508 # Try to get the absolute directory name.
5509 absdir=\`cd \"\$thisdir\" && pwd\`
5510 test -n \"\$absdir\" && thisdir=\"\$absdir\"
5511"
5512
5513 if test yes = "$fast_install"; then
5514 $ECHO "\
5515 program=lt-'$outputname'$exeext
5516 progdir=\"\$thisdir/$objdir\"
5517
5518 if test ! -f \"\$progdir/\$program\" ||
5519 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
5520 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5521
5522 file=\"\$\$-\$program\"
5523
5524 if test ! -d \"\$progdir\"; then
5525 $MKDIR \"\$progdir\"
5526 else
5527 $RM \"\$progdir/\$file\"
5528 fi"
5529
5530 $ECHO "\
5531
5532 # relink executable if necessary
5533 if test -n \"\$relink_command\"; then
5534 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5535 else
5536 \$ECHO \"\$relink_command_output\" >&2
5537 $RM \"\$progdir/\$file\"
5538 exit 1
5539 fi
5540 fi
5541
5542 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5543 { $RM \"\$progdir/\$program\";
5544 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5545 $RM \"\$progdir/\$file\"
5546 fi"
5547 else
5548 $ECHO "\
5549 program='$outputname'
5550 progdir=\"\$thisdir/$objdir\"
5551"
5552 fi
5553
5554 $ECHO "\
5555
5556 if test -f \"\$progdir/\$program\"; then"
5557
5558 # fixup the dll searchpath if we need to.
5559 #
5560 # Fix the DLL searchpath if we need to. Do this before prepending
5561 # to shlibpath, because on Windows, both are PATH and uninstalled
5562 # libraries must come first.
5563 if test -n "$dllsearchpath"; then
5564 $ECHO "\
5565 # Add the dll search path components to the executable PATH
5566 PATH=$dllsearchpath:\$PATH
5567"
5568 fi
5569
5570 # Export our shlibpath_var if we have one.
5571 if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5572 $ECHO "\
5573 # Add our own library path to $shlibpath_var
5574 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5575
5576 # Some systems cannot cope with colon-terminated $shlibpath_var
5577 # The second colon is a workaround for a bug in BeOS R4 sed
5578 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
5579
5580 export $shlibpath_var
5581"
5582 fi
5583
5584 $ECHO "\
5585 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5586 # Run the actual program with our arguments.
5587 func_exec_program \${1+\"\$@\"}
5588 fi
5589 else
5590 # The program doesn't exist.
5591 \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
5592 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
5593 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
5594 exit 1
5595 fi
5596fi\
5597"
5598}
5599
5600
5601# func_emit_cwrapperexe_src
5602# emit the source code for a wrapper executable on stdout
5603# Must ONLY be called from within func_mode_link because
5604# it depends on a number of variable set therein.
5605func_emit_cwrapperexe_src ()
5606{
5607 cat <<EOF
5608
5609/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
5610 Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5611
5612 The $output program cannot be directly executed until all the libtool
5613 libraries that it depends on are installed.
5614
5615 This wrapper executable should never be moved out of the build directory.
5616 If it is, it will not operate correctly.
5617*/
5618EOF
5619 cat <<"EOF"
5620#ifdef _MSC_VER
5621# define _CRT_SECURE_NO_DEPRECATE 1
5622#endif
5623#include <stdio.h>
5624#include <stdlib.h>
5625#ifdef _MSC_VER
5626# include <direct.h>
5627# include <process.h>
5628# include <io.h>
5629#else
5630# include <unistd.h>
5631# include <stdint.h>
5632# ifdef __CYGWIN__
5633# include <io.h>
5634# endif
5635#endif
5636#include <malloc.h>
5637#include <stdarg.h>
5638#include <assert.h>
5639#include <string.h>
5640#include <ctype.h>
5641#include <errno.h>
5642#include <fcntl.h>
5643#include <sys/stat.h>
5644
5645#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
5646
5647/* declarations of non-ANSI functions */
5648#if defined __MINGW32__
5649# ifdef __STRICT_ANSI__
5650int _putenv (const char *);
5651# endif
5652#elif defined __CYGWIN__
5653# ifdef __STRICT_ANSI__
5654char *realpath (const char *, char *);
5655int putenv (char *);
5656int setenv (const char *, const char *, int);
5657# endif
5658/* #elif defined other_platform || defined ... */
5659#endif
5660
5661/* portability defines, excluding path handling macros */
5662#if defined _MSC_VER
5663# define setmode _setmode
5664# define stat _stat
5665# define chmod _chmod
5666# define getcwd _getcwd
5667# define putenv _putenv
5668# define S_IXUSR _S_IEXEC
5669#elif defined __MINGW32__
5670# define setmode _setmode
5671# define stat _stat
5672# define chmod _chmod
5673# define getcwd _getcwd
5674# define putenv _putenv
5675#elif defined __CYGWIN__
5676# define HAVE_SETENV
5677# define FOPEN_WB "wb"
5678/* #elif defined other platforms ... */
5679#endif
5680
5681#if defined PATH_MAX
5682# define LT_PATHMAX PATH_MAX
5683#elif defined MAXPATHLEN
5684# define LT_PATHMAX MAXPATHLEN
5685#else
5686# define LT_PATHMAX 1024
5687#endif
5688
5689#ifndef S_IXOTH
5690# define S_IXOTH 0
5691#endif
5692#ifndef S_IXGRP
5693# define S_IXGRP 0
5694#endif
5695
5696/* path handling portability macros */
5697#ifndef DIR_SEPARATOR
5698# define DIR_SEPARATOR '/'
5699# define PATH_SEPARATOR ':'
5700#endif
5701
5702#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
5703 defined __OS2__
5704# define HAVE_DOS_BASED_FILE_SYSTEM
5705# define FOPEN_WB "wb"
5706# ifndef DIR_SEPARATOR_2
5707# define DIR_SEPARATOR_2 '\\'
5708# endif
5709# ifndef PATH_SEPARATOR_2
5710# define PATH_SEPARATOR_2 ';'
5711# endif
5712#endif
5713
5714#ifndef DIR_SEPARATOR_2
5715# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5716#else /* DIR_SEPARATOR_2 */
5717# define IS_DIR_SEPARATOR(ch) \
5718 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
5719#endif /* DIR_SEPARATOR_2 */
5720
5721#ifndef PATH_SEPARATOR_2
5722# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5723#else /* PATH_SEPARATOR_2 */
5724# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5725#endif /* PATH_SEPARATOR_2 */
5726
5727#ifndef FOPEN_WB
5728# define FOPEN_WB "w"
5729#endif
5730#ifndef _O_BINARY
5731# define _O_BINARY 0
5732#endif
5733
5734#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5735#define XFREE(stale) do { \
5736 if (stale) { free (stale); stale = 0; } \
5737} while (0)
5738
5739#if defined LT_DEBUGWRAPPER
5740static int lt_debug = 1;
5741#else
5742static int lt_debug = 0;
5743#endif
5744
5745const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
5746
5747void *xmalloc (size_t num);
5748char *xstrdup (const char *string);
5749const char *base_name (const char *name);
5750char *find_executable (const char *wrapper);
5751char *chase_symlinks (const char *pathspec);
5752int make_executable (const char *path);
5753int check_executable (const char *path);
5754char *strendzap (char *str, const char *pat);
5755void lt_debugprintf (const char *file, int line, const char *fmt, ...);
5756void lt_fatal (const char *file, int line, const char *message, ...);
5757static const char *nonnull (const char *s);
5758static const char *nonempty (const char *s);
5759void lt_setenv (const char *name, const char *value);
5760char *lt_extend_str (const char *orig_value, const char *add, int to_end);
5761void lt_update_exe_path (const char *name, const char *value);
5762void lt_update_lib_path (const char *name, const char *value);
5763char **prepare_spawn (char **argv);
5764void lt_dump_script (FILE *f);
5765EOF
5766
5767 cat <<EOF
5768#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
5769# define externally_visible volatile
5770#else
5771# define externally_visible __attribute__((externally_visible)) volatile
5772#endif
5773externally_visible const char * MAGIC_EXE = "$magic_exe";
5774const char * LIB_PATH_VARNAME = "$shlibpath_var";
5775EOF
5776
5777 if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5778 func_to_host_path "$temp_rpath"
5779 cat <<EOF
5780const char * LIB_PATH_VALUE = "$func_to_host_path_result";
5781EOF
5782 else
5783 cat <<"EOF"
5784const char * LIB_PATH_VALUE = "";
5785EOF
5786 fi
5787
5788 if test -n "$dllsearchpath"; then
5789 func_to_host_path "$dllsearchpath:"
5790 cat <<EOF
5791const char * EXE_PATH_VARNAME = "PATH";
5792const char * EXE_PATH_VALUE = "$func_to_host_path_result";
5793EOF
5794 else
5795 cat <<"EOF"
5796const char * EXE_PATH_VARNAME = "";
5797const char * EXE_PATH_VALUE = "";
5798EOF
5799 fi
5800
5801 if test yes = "$fast_install"; then
5802 cat <<EOF
5803const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
5804EOF
5805 else
5806 cat <<EOF
5807const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
5808EOF
5809 fi
5810
5811
5812 cat <<"EOF"
5813
5814#define LTWRAPPER_OPTION_PREFIX "--lt-"
5815
5816static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
5817static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
5818static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
5819
5820int
5821main (int argc, char *argv[])
5822{
5823 char **newargz;
5824 int newargc;
5825 char *tmp_pathspec;
5826 char *actual_cwrapper_path;
5827 char *actual_cwrapper_name;
5828 char *target_name;
5829 char *lt_argv_zero;
5830 int rval = 127;
5831
5832 int i;
5833
5834 program_name = (char *) xstrdup (base_name (argv[0]));
5835 newargz = XMALLOC (char *, (size_t) argc + 1);
5836
5837 /* very simple arg parsing; don't want to rely on getopt
5838 * also, copy all non cwrapper options to newargz, except
5839 * argz[0], which is handled differently
5840 */
5841 newargc=0;
5842 for (i = 1; i < argc; i++)
5843 {
5844 if (STREQ (argv[i], dumpscript_opt))
5845 {
5846EOF
5847 case $host in
5848 *mingw* | *cygwin* )
5849 # make stdout use "unix" line endings
5850 echo " setmode(1,_O_BINARY);"
5851 ;;
5852 esac
5853
5854 cat <<"EOF"
5855 lt_dump_script (stdout);
5856 return 0;
5857 }
5858 if (STREQ (argv[i], debug_opt))
5859 {
5860 lt_debug = 1;
5861 continue;
5862 }
5863 if (STREQ (argv[i], ltwrapper_option_prefix))
5864 {
5865 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
5866 namespace, but it is not one of the ones we know about and
5867 have already dealt with, above (inluding dump-script), then
5868 report an error. Otherwise, targets might begin to believe
5869 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
5870 namespace. The first time any user complains about this, we'll
5871 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
5872 or a configure.ac-settable value.
5873 */
5874 lt_fatal (__FILE__, __LINE__,
5875 "unrecognized %s option: '%s'",
5876 ltwrapper_option_prefix, argv[i]);
5877 }
5878 /* otherwise ... */
5879 newargz[++newargc] = xstrdup (argv[i]);
5880 }
5881 newargz[++newargc] = NULL;
5882
5883EOF
5884 cat <<EOF
5885 /* The GNU banner must be the first non-error debug message */
5886 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
5887EOF
5888 cat <<"EOF"
5889 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
5890 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
5891
5892 tmp_pathspec = find_executable (argv[0]);
5893 if (tmp_pathspec == NULL)
5894 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
5895 lt_debugprintf (__FILE__, __LINE__,
5896 "(main) found exe (before symlink chase) at: %s\n",
5897 tmp_pathspec);
5898
5899 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
5900 lt_debugprintf (__FILE__, __LINE__,
5901 "(main) found exe (after symlink chase) at: %s\n",
5902 actual_cwrapper_path);
5903 XFREE (tmp_pathspec);
5904
5905 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
5906 strendzap (actual_cwrapper_path, actual_cwrapper_name);
5907
5908 /* wrapper name transforms */
5909 strendzap (actual_cwrapper_name, ".exe");
5910 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
5911 XFREE (actual_cwrapper_name);
5912 actual_cwrapper_name = tmp_pathspec;
5913 tmp_pathspec = 0;
5914
5915 /* target_name transforms -- use actual target program name; might have lt- prefix */
5916 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
5917 strendzap (target_name, ".exe");
5918 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
5919 XFREE (target_name);
5920 target_name = tmp_pathspec;
5921 tmp_pathspec = 0;
5922
5923 lt_debugprintf (__FILE__, __LINE__,
5924 "(main) libtool target name: %s\n",
5925 target_name);
5926EOF
5927
5928 cat <<EOF
5929 newargz[0] =
5930 XMALLOC (char, (strlen (actual_cwrapper_path) +
5931 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
5932 strcpy (newargz[0], actual_cwrapper_path);
5933 strcat (newargz[0], "$objdir");
5934 strcat (newargz[0], "/");
5935EOF
5936
5937 cat <<"EOF"
5938 /* stop here, and copy so we don't have to do this twice */
5939 tmp_pathspec = xstrdup (newargz[0]);
5940
5941 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
5942 strcat (newargz[0], actual_cwrapper_name);
5943
5944 /* DO want the lt- prefix here if it exists, so use target_name */
5945 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
5946 XFREE (tmp_pathspec);
5947 tmp_pathspec = NULL;
5948EOF
5949
5950 case $host_os in
5951 mingw*)
5952 cat <<"EOF"
5953 {
5954 char* p;
5955 while ((p = strchr (newargz[0], '\\')) != NULL)
5956 {
5957 *p = '/';
5958 }
5959 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
5960 {
5961 *p = '/';
5962 }
5963 }
5964EOF
5965 ;;
5966 esac
5967
5968 cat <<"EOF"
5969 XFREE (target_name);
5970 XFREE (actual_cwrapper_path);
5971 XFREE (actual_cwrapper_name);
5972
5973 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
5974 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
5975 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
5976 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
5977 because on Windows, both *_VARNAMEs are PATH but uninstalled
5978 libraries must come first. */
5979 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
5980 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
5981
5982 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
5983 nonnull (lt_argv_zero));
5984 for (i = 0; i < newargc; i++)
5985 {
5986 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
5987 i, nonnull (newargz[i]));
5988 }
5989
5990EOF
5991
5992 case $host_os in
5993 mingw*)
5994 cat <<"EOF"
5995 /* execv doesn't actually work on mingw as expected on unix */
5996 newargz = prepare_spawn (newargz);
5997 rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
5998 if (rval == -1)
5999 {
6000 /* failed to start process */
6001 lt_debugprintf (__FILE__, __LINE__,
6002 "(main) failed to launch target \"%s\": %s\n",
6003 lt_argv_zero, nonnull (strerror (errno)));
6004 return 127;
6005 }
6006 return rval;
6007EOF
6008 ;;
6009 *)
6010 cat <<"EOF"
6011 execv (lt_argv_zero, newargz);
6012 return rval; /* =127, but avoids unused variable warning */
6013EOF
6014 ;;
6015 esac
6016
6017 cat <<"EOF"
6018}
6019
6020void *
6021xmalloc (size_t num)
6022{
6023 void *p = (void *) malloc (num);
6024 if (!p)
6025 lt_fatal (__FILE__, __LINE__, "memory exhausted");
6026
6027 return p;
6028}
6029
6030char *
6031xstrdup (const char *string)
6032{
6033 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
6034 string) : NULL;
6035}
6036
6037const char *
6038base_name (const char *name)
6039{
6040 const char *base;
6041
6042#if defined HAVE_DOS_BASED_FILE_SYSTEM
6043 /* Skip over the disk name in MSDOS pathnames. */
6044 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
6045 name += 2;
6046#endif
6047
6048 for (base = name; *name; name++)
6049 if (IS_DIR_SEPARATOR (*name))
6050 base = name + 1;
6051 return base;
6052}
6053
6054int
6055check_executable (const char *path)
6056{
6057 struct stat st;
6058
6059 lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
6060 nonempty (path));
6061 if ((!path) || (!*path))
6062 return 0;
6063
6064 if ((stat (path, &st) >= 0)
6065 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
6066 return 1;
6067 else
6068 return 0;
6069}
6070
6071int
6072make_executable (const char *path)
6073{
6074 int rval = 0;
6075 struct stat st;
6076
6077 lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
6078 nonempty (path));
6079 if ((!path) || (!*path))
6080 return 0;
6081
6082 if (stat (path, &st) >= 0)
6083 {
6084 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
6085 }
6086 return rval;
6087}
6088
6089/* Searches for the full path of the wrapper. Returns
6090 newly allocated full path name if found, NULL otherwise
6091 Does not chase symlinks, even on platforms that support them.
6092*/
6093char *
6094find_executable (const char *wrapper)
6095{
6096 int has_slash = 0;
6097 const char *p;
6098 const char *p_next;
6099 /* static buffer for getcwd */
6100 char tmp[LT_PATHMAX + 1];
6101 size_t tmp_len;
6102 char *concat_name;
6103
6104 lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
6105 nonempty (wrapper));
6106
6107 if ((wrapper == NULL) || (*wrapper == '\0'))
6108 return NULL;
6109
6110 /* Absolute path? */
6111#if defined HAVE_DOS_BASED_FILE_SYSTEM
6112 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
6113 {
6114 concat_name = xstrdup (wrapper);
6115 if (check_executable (concat_name))
6116 return concat_name;
6117 XFREE (concat_name);
6118 }
6119 else
6120 {
6121#endif
6122 if (IS_DIR_SEPARATOR (wrapper[0]))
6123 {
6124 concat_name = xstrdup (wrapper);
6125 if (check_executable (concat_name))
6126 return concat_name;
6127 XFREE (concat_name);
6128 }
6129#if defined HAVE_DOS_BASED_FILE_SYSTEM
6130 }
6131#endif
6132
6133 for (p = wrapper; *p; p++)
6134 if (*p == '/')
6135 {
6136 has_slash = 1;
6137 break;
6138 }
6139 if (!has_slash)
6140 {
6141 /* no slashes; search PATH */
6142 const char *path = getenv ("PATH");
6143 if (path != NULL)
6144 {
6145 for (p = path; *p; p = p_next)
6146 {
6147 const char *q;
6148 size_t p_len;
6149 for (q = p; *q; q++)
6150 if (IS_PATH_SEPARATOR (*q))
6151 break;
6152 p_len = (size_t) (q - p);
6153 p_next = (*q == '\0' ? q : q + 1);
6154 if (p_len == 0)
6155 {
6156 /* empty path: current directory */
6157 if (getcwd (tmp, LT_PATHMAX) == NULL)
6158 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6159 nonnull (strerror (errno)));
6160 tmp_len = strlen (tmp);
6161 concat_name =
6162 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6163 memcpy (concat_name, tmp, tmp_len);
6164 concat_name[tmp_len] = '/';
6165 strcpy (concat_name + tmp_len + 1, wrapper);
6166 }
6167 else
6168 {
6169 concat_name =
6170 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
6171 memcpy (concat_name, p, p_len);
6172 concat_name[p_len] = '/';
6173 strcpy (concat_name + p_len + 1, wrapper);
6174 }
6175 if (check_executable (concat_name))
6176 return concat_name;
6177 XFREE (concat_name);
6178 }
6179 }
6180 /* not found in PATH; assume curdir */
6181 }
6182 /* Relative path | not found in path: prepend cwd */
6183 if (getcwd (tmp, LT_PATHMAX) == NULL)
6184 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6185 nonnull (strerror (errno)));
6186 tmp_len = strlen (tmp);
6187 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6188 memcpy (concat_name, tmp, tmp_len);
6189 concat_name[tmp_len] = '/';
6190 strcpy (concat_name + tmp_len + 1, wrapper);
6191
6192 if (check_executable (concat_name))
6193 return concat_name;
6194 XFREE (concat_name);
6195 return NULL;
6196}
6197
6198char *
6199chase_symlinks (const char *pathspec)
6200{
6201#ifndef S_ISLNK
6202 return xstrdup (pathspec);
6203#else
6204 char buf[LT_PATHMAX];
6205 struct stat s;
6206 char *tmp_pathspec = xstrdup (pathspec);
6207 char *p;
6208 int has_symlinks = 0;
6209 while (strlen (tmp_pathspec) && !has_symlinks)
6210 {
6211 lt_debugprintf (__FILE__, __LINE__,
6212 "checking path component for symlinks: %s\n",
6213 tmp_pathspec);
6214 if (lstat (tmp_pathspec, &s) == 0)
6215 {
6216 if (S_ISLNK (s.st_mode) != 0)
6217 {
6218 has_symlinks = 1;
6219 break;
6220 }
6221
6222 /* search backwards for last DIR_SEPARATOR */
6223 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
6224 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6225 p--;
6226 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6227 {
6228 /* no more DIR_SEPARATORS left */
6229 break;
6230 }
6231 *p = '\0';
6232 }
6233 else
6234 {
6235 lt_fatal (__FILE__, __LINE__,
6236 "error accessing file \"%s\": %s",
6237 tmp_pathspec, nonnull (strerror (errno)));
6238 }
6239 }
6240 XFREE (tmp_pathspec);
6241
6242 if (!has_symlinks)
6243 {
6244 return xstrdup (pathspec);
6245 }
6246
6247 tmp_pathspec = realpath (pathspec, buf);
6248 if (tmp_pathspec == 0)
6249 {
6250 lt_fatal (__FILE__, __LINE__,
6251 "could not follow symlinks for %s", pathspec);
6252 }
6253 return xstrdup (tmp_pathspec);
6254#endif
6255}
6256
6257char *
6258strendzap (char *str, const char *pat)
6259{
6260 size_t len, patlen;
6261
6262 assert (str != NULL);
6263 assert (pat != NULL);
6264
6265 len = strlen (str);
6266 patlen = strlen (pat);
6267
6268 if (patlen <= len)
6269 {
6270 str += len - patlen;
6271 if (STREQ (str, pat))
6272 *str = '\0';
6273 }
6274 return str;
6275}
6276
6277void
6278lt_debugprintf (const char *file, int line, const char *fmt, ...)
6279{
6280 va_list args;
6281 if (lt_debug)
6282 {
6283 (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
6284 va_start (args, fmt);
6285 (void) vfprintf (stderr, fmt, args);
6286 va_end (args);
6287 }
6288}
6289
6290static void
6291lt_error_core (int exit_status, const char *file,
6292 int line, const char *mode,
6293 const char *message, va_list ap)
6294{
6295 fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
6296 vfprintf (stderr, message, ap);
6297 fprintf (stderr, ".\n");
6298
6299 if (exit_status >= 0)
6300 exit (exit_status);
6301}
6302
6303void
6304lt_fatal (const char *file, int line, const char *message, ...)
6305{
6306 va_list ap;
6307 va_start (ap, message);
6308 lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
6309 va_end (ap);
6310}
6311
6312static const char *
6313nonnull (const char *s)
6314{
6315 return s ? s : "(null)";
6316}
6317
6318static const char *
6319nonempty (const char *s)
6320{
6321 return (s && !*s) ? "(empty)" : nonnull (s);
6322}
6323
6324void
6325lt_setenv (const char *name, const char *value)
6326{
6327 lt_debugprintf (__FILE__, __LINE__,
6328 "(lt_setenv) setting '%s' to '%s'\n",
6329 nonnull (name), nonnull (value));
6330 {
6331#ifdef HAVE_SETENV
6332 /* always make a copy, for consistency with !HAVE_SETENV */
6333 char *str = xstrdup (value);
6334 setenv (name, str, 1);
6335#else
6336 size_t len = strlen (name) + 1 + strlen (value) + 1;
6337 char *str = XMALLOC (char, len);
6338 sprintf (str, "%s=%s", name, value);
6339 if (putenv (str) != EXIT_SUCCESS)
6340 {
6341 XFREE (str);
6342 }
6343#endif
6344 }
6345}
6346
6347char *
6348lt_extend_str (const char *orig_value, const char *add, int to_end)
6349{
6350 char *new_value;
6351 if (orig_value && *orig_value)
6352 {
6353 size_t orig_value_len = strlen (orig_value);
6354 size_t add_len = strlen (add);
6355 new_value = XMALLOC (char, add_len + orig_value_len + 1);
6356 if (to_end)
6357 {
6358 strcpy (new_value, orig_value);
6359 strcpy (new_value + orig_value_len, add);
6360 }
6361 else
6362 {
6363 strcpy (new_value, add);
6364 strcpy (new_value + add_len, orig_value);
6365 }
6366 }
6367 else
6368 {
6369 new_value = xstrdup (add);
6370 }
6371 return new_value;
6372}
6373
6374void
6375lt_update_exe_path (const char *name, const char *value)
6376{
6377 lt_debugprintf (__FILE__, __LINE__,
6378 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
6379 nonnull (name), nonnull (value));
6380
6381 if (name && *name && value && *value)
6382 {
6383 char *new_value = lt_extend_str (getenv (name), value, 0);
6384 /* some systems can't cope with a ':'-terminated path #' */
6385 size_t len = strlen (new_value);
6386 while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
6387 {
6388 new_value[--len] = '\0';
6389 }
6390 lt_setenv (name, new_value);
6391 XFREE (new_value);
6392 }
6393}
6394
6395void
6396lt_update_lib_path (const char *name, const char *value)
6397{
6398 lt_debugprintf (__FILE__, __LINE__,
6399 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
6400 nonnull (name), nonnull (value));
6401
6402 if (name && *name && value && *value)
6403 {
6404 char *new_value = lt_extend_str (getenv (name), value, 0);
6405 lt_setenv (name, new_value);
6406 XFREE (new_value);
6407 }
6408}
6409
6410EOF
6411 case $host_os in
6412 mingw*)
6413 cat <<"EOF"
6414
6415/* Prepares an argument vector before calling spawn().
6416 Note that spawn() does not by itself call the command interpreter
6417 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
6418 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
6419 GetVersionEx(&v);
6420 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
6421 }) ? "cmd.exe" : "command.com").
6422 Instead it simply concatenates the arguments, separated by ' ', and calls
6423 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
6424 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
6425 special way:
6426 - Space and tab are interpreted as delimiters. They are not treated as
6427 delimiters if they are surrounded by double quotes: "...".
6428 - Unescaped double quotes are removed from the input. Their only effect is
6429 that within double quotes, space and tab are treated like normal
6430 characters.
6431 - Backslashes not followed by double quotes are not special.
6432 - But 2*n+1 backslashes followed by a double quote become
6433 n backslashes followed by a double quote (n >= 0):
6434 \" -> "
6435 \\\" -> \"
6436 \\\\\" -> \\"
6437 */
6438#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"
6439#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"
6440char **
6441prepare_spawn (char **argv)
6442{
6443 size_t argc;
6444 char **new_argv;
6445 size_t i;
6446
6447 /* Count number of arguments. */
6448 for (argc = 0; argv[argc] != NULL; argc++)
6449 ;
6450
6451 /* Allocate new argument vector. */
6452 new_argv = XMALLOC (char *, argc + 1);
6453
6454 /* Put quoted arguments into the new argument vector. */
6455 for (i = 0; i < argc; i++)
6456 {
6457 const char *string = argv[i];
6458
6459 if (string[0] == '\0')
6460 new_argv[i] = xstrdup ("\"\"");
6461 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
6462 {
6463 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
6464 size_t length;
6465 unsigned int backslashes;
6466 const char *s;
6467 char *quoted_string;
6468 char *p;
6469
6470 length = 0;
6471 backslashes = 0;
6472 if (quote_around)
6473 length++;
6474 for (s = string; *s != '\0'; s++)
6475 {
6476 char c = *s;
6477 if (c == '"')
6478 length += backslashes + 1;
6479 length++;
6480 if (c == '\\')
6481 backslashes++;
6482 else
6483 backslashes = 0;
6484 }
6485 if (quote_around)
6486 length += backslashes + 1;
6487
6488 quoted_string = XMALLOC (char, length + 1);
6489
6490 p = quoted_string;
6491 backslashes = 0;
6492 if (quote_around)
6493 *p++ = '"';
6494 for (s = string; *s != '\0'; s++)
6495 {
6496 char c = *s;
6497 if (c == '"')
6498 {
6499 unsigned int j;
6500 for (j = backslashes + 1; j > 0; j--)
6501 *p++ = '\\';
6502 }
6503 *p++ = c;
6504 if (c == '\\')
6505 backslashes++;
6506 else
6507 backslashes = 0;
6508 }
6509 if (quote_around)
6510 {
6511 unsigned int j;
6512 for (j = backslashes; j > 0; j--)
6513 *p++ = '\\';
6514 *p++ = '"';
6515 }
6516 *p = '\0';
6517
6518 new_argv[i] = quoted_string;
6519 }
6520 else
6521 new_argv[i] = (char *) string;
6522 }
6523 new_argv[argc] = NULL;
6524
6525 return new_argv;
6526}
6527EOF
6528 ;;
6529 esac
6530
6531 cat <<"EOF"
6532void lt_dump_script (FILE* f)
6533{
6534EOF
6535 func_emit_wrapper yes |
6536 $SED -n -e '
6537s/^\(.\{79\}\)\(..*\)/\1\
6538\2/
6539h
6540s/\([\\"]\)/\\\1/g
6541s/$/\\n/
6542s/\([^\n]*\).*/ fputs ("\1", f);/p
6543g
6544D'
6545 cat <<"EOF"
6546}
6547EOF
6548}
6549# end: func_emit_cwrapperexe_src
6550
6551# func_win32_import_lib_p ARG
6552# True if ARG is an import lib, as indicated by $file_magic_cmd
6553func_win32_import_lib_p ()
6554{
6555 $debug_cmd
6556
6557 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
6558 *import*) : ;;
6559 *) false ;;
6560 esac
6561}
6562
6563# func_suncc_cstd_abi
6564# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
6565# Several compiler flags select an ABI that is incompatible with the
6566# Cstd library. Avoid specifying it if any are in CXXFLAGS.
6567func_suncc_cstd_abi ()
6568{
6569 $debug_cmd
6570
6571 case " $compile_command " in
6572 *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
6573 suncc_use_cstd_abi=no
6574 ;;
6575 *)
6576 suncc_use_cstd_abi=yes
6577 ;;
6578 esac
6579}
6580
6581# func_mode_link arg...
6582func_mode_link ()
6583{
6584 $debug_cmd
6585
6586 case $host in
6587 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
6588 # It is impossible to link a dll without this setting, and
6589 # we shouldn't force the makefile maintainer to figure out
6590 # what system we are compiling for in order to pass an extra
6591 # flag for every libtool invocation.
6592 # allow_undefined=no
6593
6594 # FIXME: Unfortunately, there are problems with the above when trying
6595 # to make a dll that has undefined symbols, in which case not
6596 # even a static library is built. For now, we need to specify
6597 # -no-undefined on the libtool link line when we can be certain
6598 # that all symbols are satisfied, otherwise we get a static library.
6599 allow_undefined=yes
6600 ;;
6601 *)
6602 allow_undefined=yes
6603 ;;
6604 esac
6605 libtool_args=$nonopt
6606 base_compile="$nonopt $@"
6607 compile_command=$nonopt
6608 finalize_command=$nonopt
6609
6610 compile_rpath=
6611 finalize_rpath=
6612 compile_shlibpath=
6613 finalize_shlibpath=
6614 convenience=
6615 old_convenience=
6616 deplibs=
6617 old_deplibs=
6618 compiler_flags=
6619 linker_flags=
6620 dllsearchpath=
6621 lib_search_path=`pwd`
6622 inst_prefix_dir=
6623 new_inherited_linker_flags=
6624
6625 avoid_version=no
6626 bindir=
6627 dlfiles=
6628 dlprefiles=
6629 dlself=no
6630 export_dynamic=no
6631 export_symbols=
6632 export_symbols_regex=
6633 generated=
6634 libobjs=
6635 ltlibs=
6636 module=no
6637 no_install=no
6638 objs=
6639 os2dllname=
6640 non_pic_objects=
6641 precious_files_regex=
6642 prefer_static_libs=no
6643 preload=false
6644 prev=
6645 prevarg=
6646 release=
6647 rpath=
6648 xrpath=
6649 perm_rpath=
6650 temp_rpath=
6651 thread_safe=no
6652 vinfo=
6653 vinfo_number=no
6654 weak_libs=
6655 single_module=$wl-single_module
6656 func_infer_tag $base_compile
6657
6658 # We need to know -static, to get the right output filenames.
6659 for arg
6660 do
6661 case $arg in
6662 -shared)
6663 test yes != "$build_libtool_libs" \
6664 && func_fatal_configuration "cannot build a shared library"
6665 build_old_libs=no
6666 break
6667 ;;
6668 -all-static | -static | -static-libtool-libs)
6669 case $arg in
6670 -all-static)
6671 if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
6672 func_warning "complete static linking is impossible in this configuration"
6673 fi
6674 if test -n "$link_static_flag"; then
6675 dlopen_self=$dlopen_self_static
6676 fi
6677 prefer_static_libs=yes
6678 ;;
6679 -static)
6680 if test -z "$pic_flag" && test -n "$link_static_flag"; then
6681 dlopen_self=$dlopen_self_static
6682 fi
6683 prefer_static_libs=built
6684 ;;
6685 -static-libtool-libs)
6686 if test -z "$pic_flag" && test -n "$link_static_flag"; then
6687 dlopen_self=$dlopen_self_static
6688 fi
6689 prefer_static_libs=yes
6690 ;;
6691 esac
6692 build_libtool_libs=no
6693 build_old_libs=yes
6694 break
6695 ;;
6696 esac
6697 done
6698
6699 # See if our shared archives depend on static archives.
6700 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
6701
6702 # Go through the arguments, transforming them on the way.
6703 while test "$#" -gt 0; do
6704 arg=$1
6705 shift
6706 func_quote_for_eval "$arg"
6707 qarg=$func_quote_for_eval_unquoted_result
6708 func_append libtool_args " $func_quote_for_eval_result"
6709
6710 # If the previous option needs an argument, assign it.
6711 if test -n "$prev"; then
6712 case $prev in
6713 output)
6714 func_append compile_command " @OUTPUT@"
6715 func_append finalize_command " @OUTPUT@"
6716 ;;
6717 esac
6718
6719 case $prev in
6720 bindir)
6721 bindir=$arg
6722 prev=
6723 continue
6724 ;;
6725 dlfiles|dlprefiles)
6726 $preload || {
6727 # Add the symbol object into the linking commands.
6728 func_append compile_command " @SYMFILE@"
6729 func_append finalize_command " @SYMFILE@"
6730 preload=:
6731 }
6732 case $arg in
6733 *.la | *.lo) ;; # We handle these cases below.
6734 force)
6735 if test no = "$dlself"; then
6736 dlself=needless
6737 export_dynamic=yes
6738 fi
6739 prev=
6740 continue
6741 ;;
6742 self)
6743 if test dlprefiles = "$prev"; then
6744 dlself=yes
6745 elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
6746 dlself=yes
6747 else
6748 dlself=needless
6749 export_dynamic=yes
6750 fi
6751 prev=
6752 continue
6753 ;;
6754 *)
6755 if test dlfiles = "$prev"; then
6756 func_append dlfiles " $arg"
6757 else
6758 func_append dlprefiles " $arg"
6759 fi
6760 prev=
6761 continue
6762 ;;
6763 esac
6764 ;;
6765 expsyms)
6766 export_symbols=$arg
6767 test -f "$arg" \
6768 || func_fatal_error "symbol file '$arg' does not exist"
6769 prev=
6770 continue
6771 ;;
6772 expsyms_regex)
6773 export_symbols_regex=$arg
6774 prev=
6775 continue
6776 ;;
6777 framework)
6778 case $host in
6779 *-*-darwin*)
6780 case "$deplibs " in
6781 *" $qarg.ltframework "*) ;;
6782 *) func_append deplibs " $qarg.ltframework" # this is fixed later
6783 ;;
6784 esac
6785 ;;
6786 esac
6787 prev=
6788 continue
6789 ;;
6790 inst_prefix)
6791 inst_prefix_dir=$arg
6792 prev=
6793 continue
6794 ;;
6795 mllvm)
6796 # Clang does not use LLVM to link, so we can simply discard any
6797 # '-mllvm $arg' options when doing the link step.
6798 prev=
6799 continue
6800 ;;
6801 objectlist)
6802 if test -f "$arg"; then
6803 save_arg=$arg
6804 moreargs=
6805 for fil in `cat "$save_arg"`
6806 do
6807# func_append moreargs " $fil"
6808 arg=$fil
6809 # A libtool-controlled object.
6810
6811 # Check to see that this really is a libtool object.
6812 if func_lalib_unsafe_p "$arg"; then
6813 pic_object=
6814 non_pic_object=
6815
6816 # Read the .lo file
6817 func_source "$arg"
6818
6819 if test -z "$pic_object" ||
6820 test -z "$non_pic_object" ||
6821 test none = "$pic_object" &&
6822 test none = "$non_pic_object"; then
6823 func_fatal_error "cannot find name of object for '$arg'"
6824 fi
6825
6826 # Extract subdirectory from the argument.
6827 func_dirname "$arg" "/" ""
6828 xdir=$func_dirname_result
6829
6830 if test none != "$pic_object"; then
6831 # Prepend the subdirectory the object is found in.
6832 pic_object=$xdir$pic_object
6833
6834 if test dlfiles = "$prev"; then
6835 if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
6836 func_append dlfiles " $pic_object"
6837 prev=
6838 continue
6839 else
6840 # If libtool objects are unsupported, then we need to preload.
6841 prev=dlprefiles
6842 fi
6843 fi
6844
6845 # CHECK ME: I think I busted this. -Ossama
6846 if test dlprefiles = "$prev"; then
6847 # Preload the old-style object.
6848 func_append dlprefiles " $pic_object"
6849 prev=
6850 fi
6851
6852 # A PIC object.
6853 func_append libobjs " $pic_object"
6854 arg=$pic_object
6855 fi
6856
6857 # Non-PIC object.
6858 if test none != "$non_pic_object"; then
6859 # Prepend the subdirectory the object is found in.
6860 non_pic_object=$xdir$non_pic_object
6861
6862 # A standard non-PIC object
6863 func_append non_pic_objects " $non_pic_object"
6864 if test -z "$pic_object" || test none = "$pic_object"; then
6865 arg=$non_pic_object
6866 fi
6867 else
6868 # If the PIC object exists, use it instead.
6869 # $xdir was prepended to $pic_object above.
6870 non_pic_object=$pic_object
6871 func_append non_pic_objects " $non_pic_object"
6872 fi
6873 else
6874 # Only an error if not doing a dry-run.
6875 if $opt_dry_run; then
6876 # Extract subdirectory from the argument.
6877 func_dirname "$arg" "/" ""
6878 xdir=$func_dirname_result
6879
6880 func_lo2o "$arg"
6881 pic_object=$xdir$objdir/$func_lo2o_result
6882 non_pic_object=$xdir$func_lo2o_result
6883 func_append libobjs " $pic_object"
6884 func_append non_pic_objects " $non_pic_object"
6885 else
6886 func_fatal_error "'$arg' is not a valid libtool object"
6887 fi
6888 fi
6889 done
6890 else
6891 func_fatal_error "link input file '$arg' does not exist"
6892 fi
6893 arg=$save_arg
6894 prev=
6895 continue
6896 ;;
6897 os2dllname)
6898 os2dllname=$arg
6899 prev=
6900 continue
6901 ;;
6902 precious_regex)
6903 precious_files_regex=$arg
6904 prev=
6905 continue
6906 ;;
6907 release)
6908 release=-$arg
6909 prev=
6910 continue
6911 ;;
6912 rpath | xrpath)
6913 # We need an absolute path.
6914 case $arg in
6915 [\\/]* | [A-Za-z]:[\\/]*) ;;
6916 *)
6917 func_fatal_error "only absolute run-paths are allowed"
6918 ;;
6919 esac
6920 if test rpath = "$prev"; then
6921 case "$rpath " in
6922 *" $arg "*) ;;
6923 *) func_append rpath " $arg" ;;
6924 esac
6925 else
6926 case "$xrpath " in
6927 *" $arg "*) ;;
6928 *) func_append xrpath " $arg" ;;
6929 esac
6930 fi
6931 prev=
6932 continue
6933 ;;
6934 shrext)
6935 shrext_cmds=$arg
6936 prev=
6937 continue
6938 ;;
6939 weak)
6940 func_append weak_libs " $arg"
6941 prev=
6942 continue
6943 ;;
6944 xcclinker)
6945 func_append linker_flags " $qarg"
6946 func_append compiler_flags " $qarg"
6947 prev=
6948 func_append compile_command " $qarg"
6949 func_append finalize_command " $qarg"
6950 continue
6951 ;;
6952 xcompiler)
6953 func_append compiler_flags " $qarg"
6954 prev=
6955 func_append compile_command " $qarg"
6956 func_append finalize_command " $qarg"
6957 continue
6958 ;;
6959 xlinker)
6960 func_append linker_flags " $qarg"
6961 func_append compiler_flags " $wl$qarg"
6962 prev=
6963 func_append compile_command " $wl$qarg"
6964 func_append finalize_command " $wl$qarg"
6965 continue
6966 ;;
6967 *)
6968 eval "$prev=\"\$arg\""
6969 prev=
6970 continue
6971 ;;
6972 esac
6973 fi # test -n "$prev"
6974
6975 prevarg=$arg
6976
6977 case $arg in
6978 -all-static)
6979 if test -n "$link_static_flag"; then
6980 # See comment for -static flag below, for more details.
6981 func_append compile_command " $link_static_flag"
6982 func_append finalize_command " $link_static_flag"
6983 fi
6984 continue
6985 ;;
6986
6987 -allow-undefined)
6988 # FIXME: remove this flag sometime in the future.
6989 func_fatal_error "'-allow-undefined' must not be used because it is the default"
6990 ;;
6991
6992 -avoid-version)
6993 avoid_version=yes
6994 continue
6995 ;;
6996
6997 -bindir)
6998 prev=bindir
6999 continue
7000 ;;
7001
7002 -dlopen)
7003 prev=dlfiles
7004 continue
7005 ;;
7006
7007 -dlpreopen)
7008 prev=dlprefiles
7009 continue
7010 ;;
7011
7012 -export-dynamic)
7013 export_dynamic=yes
7014 continue
7015 ;;
7016
7017 -export-symbols | -export-symbols-regex)
7018 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
7019 func_fatal_error "more than one -exported-symbols argument is not allowed"
7020 fi
7021 if test X-export-symbols = "X$arg"; then
7022 prev=expsyms
7023 else
7024 prev=expsyms_regex
7025 fi
7026 continue
7027 ;;
7028
7029 -framework)
7030 prev=framework
7031 continue
7032 ;;
7033
7034 -inst-prefix-dir)
7035 prev=inst_prefix
7036 continue
7037 ;;
7038
7039 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
7040 # so, if we see these flags be careful not to treat them like -L
7041 -L[A-Z][A-Z]*:*)
7042 case $with_gcc/$host in
7043 no/*-*-irix* | /*-*-irix*)
7044 func_append compile_command " $arg"
7045 func_append finalize_command " $arg"
7046 ;;
7047 esac
7048 continue
7049 ;;
7050
7051 -L*)
7052 func_stripname "-L" '' "$arg"
7053 if test -z "$func_stripname_result"; then
7054 if test "$#" -gt 0; then
7055 func_fatal_error "require no space between '-L' and '$1'"
7056 else
7057 func_fatal_error "need path for '-L' option"
7058 fi
7059 fi
7060 func_resolve_sysroot "$func_stripname_result"
7061 dir=$func_resolve_sysroot_result
7062 # We need an absolute path.
7063 case $dir in
7064 [\\/]* | [A-Za-z]:[\\/]*) ;;
7065 *)
7066 absdir=`cd "$dir" && pwd`
7067 test -z "$absdir" && \
7068 func_fatal_error "cannot determine absolute directory name of '$dir'"
7069 dir=$absdir
7070 ;;
7071 esac
7072 case "$deplibs " in
7073 *" -L$dir "* | *" $arg "*)
7074 # Will only happen for absolute or sysroot arguments
7075 ;;
7076 *)
7077 # Preserve sysroot, but never include relative directories
7078 case $dir in
7079 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
7080 *) func_append deplibs " -L$dir" ;;
7081 esac
7082 func_append lib_search_path " $dir"
7083 ;;
7084 esac
7085 case $host in
7086 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7087 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
7088 case :$dllsearchpath: in
7089 *":$dir:"*) ;;
7090 ::) dllsearchpath=$dir;;
7091 *) func_append dllsearchpath ":$dir";;
7092 esac
7093 case :$dllsearchpath: in
7094 *":$testbindir:"*) ;;
7095 ::) dllsearchpath=$testbindir;;
7096 *) func_append dllsearchpath ":$testbindir";;
7097 esac
7098 ;;
7099 esac
7100 continue
7101 ;;
7102
7103 -l*)
7104 if test X-lc = "X$arg" || test X-lm = "X$arg"; then
7105 case $host in
7106 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
7107 # These systems don't actually have a C or math library (as such)
7108 continue
7109 ;;
7110 *-*-os2*)
7111 # These systems don't actually have a C library (as such)
7112 test X-lc = "X$arg" && continue
7113 ;;
7114 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
7115 # Do not include libc due to us having libc/libc_r.
7116 test X-lc = "X$arg" && continue
7117 ;;
7118 *-*-rhapsody* | *-*-darwin1.[012])
7119 # Rhapsody C and math libraries are in the System framework
7120 func_append deplibs " System.ltframework"
7121 continue
7122 ;;
7123 *-*-sco3.2v5* | *-*-sco5v6*)
7124 # Causes problems with __ctype
7125 test X-lc = "X$arg" && continue
7126 ;;
7127 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7128 # Compiler inserts libc in the correct place for threads to work
7129 test X-lc = "X$arg" && continue
7130 ;;
7131 esac
7132 elif test X-lc_r = "X$arg"; then
7133 case $host in
7134 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
7135 # Do not include libc_r directly, use -pthread flag.
7136 continue
7137 ;;
7138 esac
7139 fi
7140 func_append deplibs " $arg"
7141 continue
7142 ;;
7143
7144 -mllvm)
7145 prev=mllvm
7146 continue
7147 ;;
7148
7149 -module)
7150 module=yes
7151 continue
7152 ;;
7153
7154 # Tru64 UNIX uses -model [arg] to determine the layout of C++
7155 # classes, name mangling, and exception handling.
7156 # Darwin uses the -arch flag to determine output architecture.
7157 -model|-arch|-isysroot|--sysroot)
7158 func_append compiler_flags " $arg"
7159 func_append compile_command " $arg"
7160 func_append finalize_command " $arg"
7161 prev=xcompiler
7162 continue
7163 ;;
7164
7165 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
7166 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7167 func_append compiler_flags " $arg"
7168 func_append compile_command " $arg"
7169 func_append finalize_command " $arg"
7170 case "$new_inherited_linker_flags " in
7171 *" $arg "*) ;;
7172 * ) func_append new_inherited_linker_flags " $arg" ;;
7173 esac
7174 continue
7175 ;;
7176
7177 -multi_module)
7178 single_module=$wl-multi_module
7179 continue
7180 ;;
7181
7182 -no-fast-install)
7183 fast_install=no
7184 continue
7185 ;;
7186
7187 -no-install)
7188 case $host in
7189 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
7190 # The PATH hackery in wrapper scripts is required on Windows
7191 # and Darwin in order for the loader to find any dlls it needs.
7192 func_warning "'-no-install' is ignored for $host"
7193 func_warning "assuming '-no-fast-install' instead"
7194 fast_install=no
7195 ;;
7196 *) no_install=yes ;;
7197 esac
7198 continue
7199 ;;
7200
7201 -no-undefined)
7202 allow_undefined=no
7203 continue
7204 ;;
7205
7206 -objectlist)
7207 prev=objectlist
7208 continue
7209 ;;
7210
7211 -os2dllname)
7212 prev=os2dllname
7213 continue
7214 ;;
7215
7216 -o) prev=output ;;
7217
7218 -precious-files-regex)
7219 prev=precious_regex
7220 continue
7221 ;;
7222
7223 -release)
7224 prev=release
7225 continue
7226 ;;
7227
7228 -rpath)
7229 prev=rpath
7230 continue
7231 ;;
7232
7233 -R)
7234 prev=xrpath
7235 continue
7236 ;;
7237
7238 -R*)
7239 func_stripname '-R' '' "$arg"
7240 dir=$func_stripname_result
7241 # We need an absolute path.
7242 case $dir in
7243 [\\/]* | [A-Za-z]:[\\/]*) ;;
7244 =*)
7245 func_stripname '=' '' "$dir"
7246 dir=$lt_sysroot$func_stripname_result
7247 ;;
7248 *)
7249 func_fatal_error "only absolute run-paths are allowed"
7250 ;;
7251 esac
7252 case "$xrpath " in
7253 *" $dir "*) ;;
7254 *) func_append xrpath " $dir" ;;
7255 esac
7256 continue
7257 ;;
7258
7259 -shared)
7260 # The effects of -shared are defined in a previous loop.
7261 continue
7262 ;;
7263
7264 -shrext)
7265 prev=shrext
7266 continue
7267 ;;
7268
7269 -static | -static-libtool-libs)
7270 # The effects of -static are defined in a previous loop.
7271 # We used to do the same as -all-static on platforms that
7272 # didn't have a PIC flag, but the assumption that the effects
7273 # would be equivalent was wrong. It would break on at least
7274 # Digital Unix and AIX.
7275 continue
7276 ;;
7277
7278 -thread-safe)
7279 thread_safe=yes
7280 continue
7281 ;;
7282
7283 -version-info)
7284 prev=vinfo
7285 continue
7286 ;;
7287
7288 -version-number)
7289 prev=vinfo
7290 vinfo_number=yes
7291 continue
7292 ;;
7293
7294 -weak)
7295 prev=weak
7296 continue
7297 ;;
7298
7299 -Wc,*)
7300 func_stripname '-Wc,' '' "$arg"
7301 args=$func_stripname_result
7302 arg=
7303 save_ifs=$IFS; IFS=,
7304 for flag in $args; do
7305 IFS=$save_ifs
7306 func_quote_for_eval "$flag"
7307 func_append arg " $func_quote_for_eval_result"
7308 func_append compiler_flags " $func_quote_for_eval_result"
7309 done
7310 IFS=$save_ifs
7311 func_stripname ' ' '' "$arg"
7312 arg=$func_stripname_result
7313 ;;
7314
7315 -Wl,*)
7316 func_stripname '-Wl,' '' "$arg"
7317 args=$func_stripname_result
7318 arg=
7319 save_ifs=$IFS; IFS=,
7320 for flag in $args; do
7321 IFS=$save_ifs
7322 func_quote_for_eval "$flag"
7323 func_append arg " $wl$func_quote_for_eval_result"
7324 func_append compiler_flags " $wl$func_quote_for_eval_result"
7325 func_append linker_flags " $func_quote_for_eval_result"
7326 done
7327 IFS=$save_ifs
7328 func_stripname ' ' '' "$arg"
7329 arg=$func_stripname_result
7330 ;;
7331
7332 -Xcompiler)
7333 prev=xcompiler
7334 continue
7335 ;;
7336
7337 -Xlinker)
7338 prev=xlinker
7339 continue
7340 ;;
7341
7342 -XCClinker)
7343 prev=xcclinker
7344 continue
7345 ;;
7346
7347 # -msg_* for osf cc
7348 -msg_*)
7349 func_quote_for_eval "$arg"
7350 arg=$func_quote_for_eval_result
7351 ;;
7352
7353 # Flags to be passed through unchanged, with rationale:
7354 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
7355 # -r[0-9][0-9]* specify processor for the SGI compiler
7356 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
7357 # +DA*, +DD* enable 64-bit mode for the HP compiler
7358 # -q* compiler args for the IBM compiler
7359 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
7360 # -F/path path to uninstalled frameworks, gcc on darwin
7361 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
7362 # -fstack-protector* stack protector flags for GCC
7363 # @file GCC response files
7364 # -tp=* Portland pgcc target processor selection
7365 # --sysroot=* for sysroot support
7366 # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
7367 # -specs=* GCC specs files
7368 # -stdlib=* select c++ std lib with clang
7369 # -fsanitize=* Clang/GCC memory and address sanitizer
7370 # -fuse-ld=* Linker select flags for GCC
7371 # -static-* direct GCC to link specific libraries statically
7372 # -fcilkplus Cilk Plus language extension features for C/C++
7373 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
7374 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
7375 -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
7376 -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
7377 func_quote_for_eval "$arg"
7378 arg=$func_quote_for_eval_result
7379 func_append compile_command " $arg"
7380 func_append finalize_command " $arg"
7381 func_append compiler_flags " $arg"
7382 continue
7383 ;;
7384
7385 -Z*)
7386 if test os2 = "`expr $host : '.*\(os2\)'`"; then
7387 # OS/2 uses -Zxxx to specify OS/2-specific options
7388 compiler_flags="$compiler_flags $arg"
7389 func_append compile_command " $arg"
7390 func_append finalize_command " $arg"
7391 case $arg in
7392 -Zlinker | -Zstack)
7393 prev=xcompiler
7394 ;;
7395 esac
7396 continue
7397 else
7398 # Otherwise treat like 'Some other compiler flag' below
7399 func_quote_for_eval "$arg"
7400 arg=$func_quote_for_eval_result
7401 fi
7402 ;;
7403
7404 # Some other compiler flag.
7405 -* | +*)
7406 func_quote_for_eval "$arg"
7407 arg=$func_quote_for_eval_result
7408 ;;
7409
7410 *.$objext)
7411 # A standard object.
7412 func_append objs " $arg"
7413 ;;
7414
7415 *.lo)
7416 # A libtool-controlled object.
7417
7418 # Check to see that this really is a libtool object.
7419 if func_lalib_unsafe_p "$arg"; then
7420 pic_object=
7421 non_pic_object=
7422
7423 # Read the .lo file
7424 func_source "$arg"
7425
7426 if test -z "$pic_object" ||
7427 test -z "$non_pic_object" ||
7428 test none = "$pic_object" &&
7429 test none = "$non_pic_object"; then
7430 func_fatal_error "cannot find name of object for '$arg'"
7431 fi
7432
7433 # Extract subdirectory from the argument.
7434 func_dirname "$arg" "/" ""
7435 xdir=$func_dirname_result
7436
7437 test none = "$pic_object" || {
7438 # Prepend the subdirectory the object is found in.
7439 pic_object=$xdir$pic_object
7440
7441 if test dlfiles = "$prev"; then
7442 if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7443 func_append dlfiles " $pic_object"
7444 prev=
7445 continue
7446 else
7447 # If libtool objects are unsupported, then we need to preload.
7448 prev=dlprefiles
7449 fi
7450 fi
7451
7452 # CHECK ME: I think I busted this. -Ossama
7453 if test dlprefiles = "$prev"; then
7454 # Preload the old-style object.
7455 func_append dlprefiles " $pic_object"
7456 prev=
7457 fi
7458
7459 # A PIC object.
7460 func_append libobjs " $pic_object"
7461 arg=$pic_object
7462 }
7463
7464 # Non-PIC object.
7465 if test none != "$non_pic_object"; then
7466 # Prepend the subdirectory the object is found in.
7467 non_pic_object=$xdir$non_pic_object
7468
7469 # A standard non-PIC object
7470 func_append non_pic_objects " $non_pic_object"
7471 if test -z "$pic_object" || test none = "$pic_object"; then
7472 arg=$non_pic_object
7473 fi
7474 else
7475 # If the PIC object exists, use it instead.
7476 # $xdir was prepended to $pic_object above.
7477 non_pic_object=$pic_object
7478 func_append non_pic_objects " $non_pic_object"
7479 fi
7480 else
7481 # Only an error if not doing a dry-run.
7482 if $opt_dry_run; then
7483 # Extract subdirectory from the argument.
7484 func_dirname "$arg" "/" ""
7485 xdir=$func_dirname_result
7486
7487 func_lo2o "$arg"
7488 pic_object=$xdir$objdir/$func_lo2o_result
7489 non_pic_object=$xdir$func_lo2o_result
7490 func_append libobjs " $pic_object"
7491 func_append non_pic_objects " $non_pic_object"
7492 else
7493 func_fatal_error "'$arg' is not a valid libtool object"
7494 fi
7495 fi
7496 ;;
7497
7498 *.$libext)
7499 # An archive.
7500 func_append deplibs " $arg"
7501 func_append old_deplibs " $arg"
7502 continue
7503 ;;
7504
7505 *.la)
7506 # A libtool-controlled library.
7507
7508 func_resolve_sysroot "$arg"
7509 if test dlfiles = "$prev"; then
7510 # This library was specified with -dlopen.
7511 func_append dlfiles " $func_resolve_sysroot_result"
7512 prev=
7513 elif test dlprefiles = "$prev"; then
7514 # The library was specified with -dlpreopen.
7515 func_append dlprefiles " $func_resolve_sysroot_result"
7516 prev=
7517 else
7518 func_append deplibs " $func_resolve_sysroot_result"
7519 fi
7520 continue
7521 ;;
7522
7523 # Some other compiler argument.
7524 *)
7525 # Unknown arguments in both finalize_command and compile_command need
7526 # to be aesthetically quoted because they are evaled later.
7527 func_quote_for_eval "$arg"
7528 arg=$func_quote_for_eval_result
7529 ;;
7530 esac # arg
7531
7532 # Now actually substitute the argument into the commands.
7533 if test -n "$arg"; then
7534 func_append compile_command " $arg"
7535 func_append finalize_command " $arg"
7536 fi
7537 done # argument parsing loop
7538
7539 test -n "$prev" && \
7540 func_fatal_help "the '$prevarg' option requires an argument"
7541
7542 if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
7543 eval arg=\"$export_dynamic_flag_spec\"
7544 func_append compile_command " $arg"
7545 func_append finalize_command " $arg"
7546 fi
7547
7548 oldlibs=
7549 # calculate the name of the file, without its directory
7550 func_basename "$output"
7551 outputname=$func_basename_result
7552 libobjs_save=$libobjs
7553
7554 if test -n "$shlibpath_var"; then
7555 # get the directories listed in $shlibpath_var
7556 eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
7557 else
7558 shlib_search_path=
7559 fi
7560 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
7561 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
7562
7563 # Definition is injected by LT_CONFIG during libtool generation.
7564 func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
7565
7566 func_dirname "$output" "/" ""
7567 output_objdir=$func_dirname_result$objdir
7568 func_to_tool_file "$output_objdir/"
7569 tool_output_objdir=$func_to_tool_file_result
7570 # Create the object directory.
7571 func_mkdir_p "$output_objdir"
7572
7573 # Determine the type of output
7574 case $output in
7575 "")
7576 func_fatal_help "you must specify an output file"
7577 ;;
7578 *.$libext) linkmode=oldlib ;;
7579 *.lo | *.$objext) linkmode=obj ;;
7580 *.la) linkmode=lib ;;
7581 *) linkmode=prog ;; # Anything else should be a program.
7582 esac
7583
7584 specialdeplibs=
7585
7586 libs=
7587 # Find all interdependent deplibs by searching for libraries
7588 # that are linked more than once (e.g. -la -lb -la)
7589 for deplib in $deplibs; do
7590 if $opt_preserve_dup_deps; then
7591 case "$libs " in
7592 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
7593 esac
7594 fi
7595 func_append libs " $deplib"
7596 done
7597
7598 if test lib = "$linkmode"; then
7599 libs="$predeps $libs $compiler_lib_search_path $postdeps"
7600
7601 # Compute libraries that are listed more than once in $predeps
7602 # $postdeps and mark them as special (i.e., whose duplicates are
7603 # not to be eliminated).
7604 pre_post_deps=
7605 if $opt_duplicate_compiler_generated_deps; then
7606 for pre_post_dep in $predeps $postdeps; do
7607 case "$pre_post_deps " in
7608 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
7609 esac
7610 func_append pre_post_deps " $pre_post_dep"
7611 done
7612 fi
7613 pre_post_deps=
7614 fi
7615
7616 deplibs=
7617 newdependency_libs=
7618 newlib_search_path=
7619 need_relink=no # whether we're linking any uninstalled libtool libraries
7620 notinst_deplibs= # not-installed libtool libraries
7621 notinst_path= # paths that contain not-installed libtool libraries
7622
7623 case $linkmode in
7624 lib)
7625 passes="conv dlpreopen link"
7626 for file in $dlfiles $dlprefiles; do
7627 case $file in
7628 *.la) ;;
7629 *)
7630 func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
7631 ;;
7632 esac
7633 done
7634 ;;
7635 prog)
7636 compile_deplibs=
7637 finalize_deplibs=
7638 alldeplibs=false
7639 newdlfiles=
7640 newdlprefiles=
7641 passes="conv scan dlopen dlpreopen link"
7642 ;;
7643 *) passes="conv"
7644 ;;
7645 esac
7646
7647 for pass in $passes; do
7648 # The preopen pass in lib mode reverses $deplibs; put it back here
7649 # so that -L comes before libs that need it for instance...
7650 if test lib,link = "$linkmode,$pass"; then
7651 ## FIXME: Find the place where the list is rebuilt in the wrong
7652 ## order, and fix it there properly
7653 tmp_deplibs=
7654 for deplib in $deplibs; do
7655 tmp_deplibs="$deplib $tmp_deplibs"
7656 done
7657 deplibs=$tmp_deplibs
7658 fi
7659
7660 if test lib,link = "$linkmode,$pass" ||
7661 test prog,scan = "$linkmode,$pass"; then
7662 libs=$deplibs
7663 deplibs=
7664 fi
7665 if test prog = "$linkmode"; then
7666 case $pass in
7667 dlopen) libs=$dlfiles ;;
7668 dlpreopen) libs=$dlprefiles ;;
7669 link)
7670 libs="$deplibs %DEPLIBS%"
7671 test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
7672 ;;
7673 esac
7674 fi
7675 if test lib,dlpreopen = "$linkmode,$pass"; then
7676 # Collect and forward deplibs of preopened libtool libs
7677 for lib in $dlprefiles; do
7678 # Ignore non-libtool-libs
7679 dependency_libs=
7680 func_resolve_sysroot "$lib"
7681 case $lib in
7682 *.la) func_source "$func_resolve_sysroot_result" ;;
7683 esac
7684
7685 # Collect preopened libtool deplibs, except any this library
7686 # has declared as weak libs
7687 for deplib in $dependency_libs; do
7688 func_basename "$deplib"
7689 deplib_base=$func_basename_result
7690 case " $weak_libs " in
7691 *" $deplib_base "*) ;;
7692 *) func_append deplibs " $deplib" ;;
7693 esac
7694 done
7695 done
7696 libs=$dlprefiles
7697 fi
7698 if test dlopen = "$pass"; then
7699 # Collect dlpreopened libraries
7700 save_deplibs=$deplibs
7701 deplibs=
7702 fi
7703
7704 for deplib in $libs; do
7705 lib=
7706 found=false
7707 case $deplib in
7708 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
7709 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7710 if test prog,link = "$linkmode,$pass"; then
7711 compile_deplibs="$deplib $compile_deplibs"
7712 finalize_deplibs="$deplib $finalize_deplibs"
7713 else
7714 func_append compiler_flags " $deplib"
7715 if test lib = "$linkmode"; then
7716 case "$new_inherited_linker_flags " in
7717 *" $deplib "*) ;;
7718 * ) func_append new_inherited_linker_flags " $deplib" ;;
7719 esac
7720 fi
7721 fi
7722 continue
7723 ;;
7724 -l*)
7725 if test lib != "$linkmode" && test prog != "$linkmode"; then
7726 func_warning "'-l' is ignored for archives/objects"
7727 continue
7728 fi
7729 func_stripname '-l' '' "$deplib"
7730 name=$func_stripname_result
7731 if test lib = "$linkmode"; then
7732 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
7733 else
7734 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
7735 fi
7736 for searchdir in $searchdirs; do
7737 for search_ext in .la $std_shrext .so .a; do
7738 # Search the libtool library
7739 lib=$searchdir/lib$name$search_ext
7740 if test -f "$lib"; then
7741 if test .la = "$search_ext"; then
7742 found=:
7743 else
7744 found=false
7745 fi
7746 break 2
7747 fi
7748 done
7749 done
7750 if $found; then
7751 # deplib is a libtool library
7752 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
7753 # We need to do some special things here, and not later.
7754 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
7755 case " $predeps $postdeps " in
7756 *" $deplib "*)
7757 if func_lalib_p "$lib"; then
7758 library_names=
7759 old_library=
7760 func_source "$lib"
7761 for l in $old_library $library_names; do
7762 ll=$l
7763 done
7764 if test "X$ll" = "X$old_library"; then # only static version available
7765 found=false
7766 func_dirname "$lib" "" "."
7767 ladir=$func_dirname_result
7768 lib=$ladir/$old_library
7769 if test prog,link = "$linkmode,$pass"; then
7770 compile_deplibs="$deplib $compile_deplibs"
7771 finalize_deplibs="$deplib $finalize_deplibs"
7772 else
7773 deplibs="$deplib $deplibs"
7774 test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7775 fi
7776 continue
7777 fi
7778 fi
7779 ;;
7780 *) ;;
7781 esac
7782 fi
7783 else
7784 # deplib doesn't seem to be a libtool library
7785 if test prog,link = "$linkmode,$pass"; then
7786 compile_deplibs="$deplib $compile_deplibs"
7787 finalize_deplibs="$deplib $finalize_deplibs"
7788 else
7789 deplibs="$deplib $deplibs"
7790 test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7791 fi
7792 continue
7793 fi
7794 ;; # -l
7795 *.ltframework)
7796 if test prog,link = "$linkmode,$pass"; then
7797 compile_deplibs="$deplib $compile_deplibs"
7798 finalize_deplibs="$deplib $finalize_deplibs"
7799 else
7800 deplibs="$deplib $deplibs"
7801 if test lib = "$linkmode"; then
7802 case "$new_inherited_linker_flags " in
7803 *" $deplib "*) ;;
7804 * ) func_append new_inherited_linker_flags " $deplib" ;;
7805 esac
7806 fi
7807 fi
7808 continue
7809 ;;
7810 -L*)
7811 case $linkmode in
7812 lib)
7813 deplibs="$deplib $deplibs"
7814 test conv = "$pass" && continue
7815 newdependency_libs="$deplib $newdependency_libs"
7816 func_stripname '-L' '' "$deplib"
7817 func_resolve_sysroot "$func_stripname_result"
7818 func_append newlib_search_path " $func_resolve_sysroot_result"
7819 ;;
7820 prog)
7821 if test conv = "$pass"; then
7822 deplibs="$deplib $deplibs"
7823 continue
7824 fi
7825 if test scan = "$pass"; then
7826 deplibs="$deplib $deplibs"
7827 else
7828 compile_deplibs="$deplib $compile_deplibs"
7829 finalize_deplibs="$deplib $finalize_deplibs"
7830 fi
7831 func_stripname '-L' '' "$deplib"
7832 func_resolve_sysroot "$func_stripname_result"