Annotation of OpenXM_contrib2/asir2018/ltmain.sh, Revision 1.2
1.2 ! ohara 1: #! /usr/bin/env sh
1.1 ohara 2: ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
1.2 ! ohara 3: ## by inline-source v2019-02-19.15
1.1 ohara 4:
1.2 ! ohara 5: # libtool (GNU libtool) 2.4.7
1.1 ohara 6: # Provide generalized library-building support services.
7: # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
8:
1.2 ! ohara 9: # Copyright (C) 1996-2019, 2021-2022 Free Software Foundation, Inc.
1.1 ohara 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:
32: PROGRAM=libtool
33: PACKAGE=libtool
1.2 ! ohara 34: VERSION=2.4.7
! 35: package_revision=2.4.7
1.1 ohara 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.
1.2 ! ohara 67: scriptversion=2019-02-19.15; # UTC
1.1 ohara 68:
69: # General shell script boiler plate, and helper functions.
70: # Written by Gary V. Vaughan, 2004
71:
1.2 ! ohara 72: # This is free software. There is NO warranty; not even for
! 73: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
! 74: #
! 75: # Copyright (C) 2004-2019, 2021 Bootstrap Authors
! 76: #
! 77: # This file is dual licensed under the terms of the MIT license
! 78: # <https://opensource.org/license/MIT>, and GPL version 2 or later
! 79: # <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of
! 80: # these licenses when using or redistributing this software or any of
! 81: # the files within it. See the URLs above, or the file `LICENSE`
! 82: # included in the Bootstrap distribution for the full license texts.
1.1 ohara 83:
1.2 ! ohara 84: # Please report bugs or propose patches to:
! 85: # <https://github.com/gnulib-modules/bootstrap/issues>
1.1 ohara 86:
87:
88: ## ------ ##
89: ## Usage. ##
90: ## ------ ##
91:
92: # Evaluate this file near the top of your script to gain access to
93: # the functions and variables defined here:
94: #
95: # . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
96: #
97: # If you need to override any of the default environment variable
98: # settings, do that before evaluating this file.
99:
100:
101: ## -------------------- ##
102: ## Shell normalisation. ##
103: ## -------------------- ##
104:
105: # Some shells need a little help to be as Bourne compatible as possible.
106: # Before doing anything else, make sure all that help has been provided!
107:
108: DUALCASE=1; export DUALCASE # for MKS sh
109: if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
110: emulate sh
111: NULLCMD=:
112: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
113: # is contrary to our usage. Disable this feature.
114: alias -g '${1+"$@"}'='"$@"'
115: setopt NO_GLOB_SUBST
116: else
117: case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
118: fi
119:
120: # NLS nuisances: We save the old values in case they are required later.
121: _G_user_locale=
122: _G_safe_locale=
123: for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
124: do
125: eval "if test set = \"\${$_G_var+set}\"; then
126: save_$_G_var=\$$_G_var
127: $_G_var=C
128: export $_G_var
129: _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
130: _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
131: fi"
132: done
1.2 ! ohara 133: # These NLS vars are set unconditionally (bootstrap issue #24). Unset those
! 134: # in case the environment reset is needed later and the $save_* variant is not
! 135: # defined (see the code above).
! 136: LC_ALL=C
! 137: LANGUAGE=C
! 138: export LANGUAGE LC_ALL
1.1 ohara 139:
140: # Make sure IFS has a sensible default
141: sp=' '
142: nl='
143: '
144: IFS="$sp $nl"
145:
146: # There are apparently some retarded systems that use ';' as a PATH separator!
147: if test "${PATH_SEPARATOR+set}" != set; then
148: PATH_SEPARATOR=:
149: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
150: (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
151: PATH_SEPARATOR=';'
152: }
153: fi
154:
155:
1.2 ! ohara 156: # func_unset VAR
! 157: # --------------
! 158: # Portably unset VAR.
! 159: # In some shells, an 'unset VAR' statement leaves a non-zero return
! 160: # status if VAR is already unset, which might be problematic if the
! 161: # statement is used at the end of a function (thus poisoning its return
! 162: # value) or when 'set -e' is active (causing even a spurious abort of
! 163: # the script in this case).
! 164: func_unset ()
! 165: {
! 166: { eval $1=; (eval unset $1) >/dev/null 2>&1 && eval unset $1 || : ; }
! 167: }
! 168:
! 169:
! 170: # Make sure CDPATH doesn't cause `cd` commands to output the target dir.
! 171: func_unset CDPATH
! 172:
! 173: # Make sure ${,E,F}GREP behave sanely.
! 174: func_unset GREP_OPTIONS
! 175:
1.1 ohara 176:
177: ## ------------------------- ##
178: ## Locate command utilities. ##
179: ## ------------------------- ##
180:
181:
182: # func_executable_p FILE
183: # ----------------------
184: # Check that FILE is an executable regular file.
185: func_executable_p ()
186: {
187: test -f "$1" && test -x "$1"
188: }
189:
190:
191: # func_path_progs PROGS_LIST CHECK_FUNC [PATH]
192: # --------------------------------------------
193: # Search for either a program that responds to --version with output
194: # containing "GNU", or else returned by CHECK_FUNC otherwise, by
195: # trying all the directories in PATH with each of the elements of
196: # PROGS_LIST.
197: #
198: # CHECK_FUNC should accept the path to a candidate program, and
199: # set $func_check_prog_result if it truncates its output less than
200: # $_G_path_prog_max characters.
201: func_path_progs ()
202: {
203: _G_progs_list=$1
204: _G_check_func=$2
205: _G_PATH=${3-"$PATH"}
206:
207: _G_path_prog_max=0
208: _G_path_prog_found=false
209: _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
210: for _G_dir in $_G_PATH; do
211: IFS=$_G_save_IFS
212: test -z "$_G_dir" && _G_dir=.
213: for _G_prog_name in $_G_progs_list; do
214: for _exeext in '' .EXE; do
215: _G_path_prog=$_G_dir/$_G_prog_name$_exeext
216: func_executable_p "$_G_path_prog" || continue
217: case `"$_G_path_prog" --version 2>&1` in
218: *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
219: *) $_G_check_func $_G_path_prog
220: func_path_progs_result=$func_check_prog_result
221: ;;
222: esac
223: $_G_path_prog_found && break 3
224: done
225: done
226: done
227: IFS=$_G_save_IFS
228: test -z "$func_path_progs_result" && {
229: echo "no acceptable sed could be found in \$PATH" >&2
230: exit 1
231: }
232: }
233:
234:
235: # We want to be able to use the functions in this file before configure
236: # has figured out where the best binaries are kept, which means we have
237: # to search for them ourselves - except when the results are already set
238: # where we skip the searches.
239:
240: # Unless the user overrides by setting SED, search the path for either GNU
241: # sed, or the sed that truncates its output the least.
242: test -z "$SED" && {
243: _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
244: for _G_i in 1 2 3 4 5 6 7; do
245: _G_sed_script=$_G_sed_script$nl$_G_sed_script
246: done
247: echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
248: _G_sed_script=
249:
250: func_check_prog_sed ()
251: {
252: _G_path_prog=$1
253:
254: _G_count=0
255: printf 0123456789 >conftest.in
256: while :
257: do
258: cat conftest.in conftest.in >conftest.tmp
259: mv conftest.tmp conftest.in
260: cp conftest.in conftest.nl
261: echo '' >> conftest.nl
262: "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
263: diff conftest.out conftest.nl >/dev/null 2>&1 || break
264: _G_count=`expr $_G_count + 1`
265: if test "$_G_count" -gt "$_G_path_prog_max"; then
266: # Best one so far, save it but keep looking for a better one
267: func_check_prog_result=$_G_path_prog
268: _G_path_prog_max=$_G_count
269: fi
270: # 10*(2^10) chars as input seems more than enough
271: test 10 -lt "$_G_count" && break
272: done
273: rm -f conftest.in conftest.tmp conftest.nl conftest.out
274: }
275:
1.2 ! ohara 276: func_path_progs "sed gsed" func_check_prog_sed "$PATH:/usr/xpg4/bin"
1.1 ohara 277: rm -f conftest.sed
278: SED=$func_path_progs_result
279: }
280:
281:
282: # Unless the user overrides by setting GREP, search the path for either GNU
283: # grep, or the grep that truncates its output the least.
284: test -z "$GREP" && {
285: func_check_prog_grep ()
286: {
287: _G_path_prog=$1
288:
289: _G_count=0
290: _G_path_prog_max=0
291: printf 0123456789 >conftest.in
292: while :
293: do
294: cat conftest.in conftest.in >conftest.tmp
295: mv conftest.tmp conftest.in
296: cp conftest.in conftest.nl
297: echo 'GREP' >> conftest.nl
298: "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
299: diff conftest.out conftest.nl >/dev/null 2>&1 || break
300: _G_count=`expr $_G_count + 1`
301: if test "$_G_count" -gt "$_G_path_prog_max"; then
302: # Best one so far, save it but keep looking for a better one
303: func_check_prog_result=$_G_path_prog
304: _G_path_prog_max=$_G_count
305: fi
306: # 10*(2^10) chars as input seems more than enough
307: test 10 -lt "$_G_count" && break
308: done
309: rm -f conftest.in conftest.tmp conftest.nl conftest.out
310: }
311:
1.2 ! ohara 312: func_path_progs "grep ggrep" func_check_prog_grep "$PATH:/usr/xpg4/bin"
1.1 ohara 313: GREP=$func_path_progs_result
314: }
315:
316:
317: ## ------------------------------- ##
318: ## User overridable command paths. ##
319: ## ------------------------------- ##
320:
321: # All uppercase variable names are used for environment variables. These
322: # variables can be overridden by the user before calling a script that
323: # uses them if a suitable command of that name is not already available
324: # in the command search PATH.
325:
326: : ${CP="cp -f"}
327: : ${ECHO="printf %s\n"}
328: : ${EGREP="$GREP -E"}
329: : ${FGREP="$GREP -F"}
330: : ${LN_S="ln -s"}
331: : ${MAKE="make"}
332: : ${MKDIR="mkdir"}
333: : ${MV="mv -f"}
334: : ${RM="rm -f"}
335: : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
336:
337:
338: ## -------------------- ##
339: ## Useful sed snippets. ##
340: ## -------------------- ##
341:
342: sed_dirname='s|/[^/]*$||'
343: sed_basename='s|^.*/||'
344:
345: # Sed substitution that helps us do robust quoting. It backslashifies
346: # metacharacters that are still active within double-quoted strings.
347: sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
348:
349: # Same as above, but do not quote variable references.
350: sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
351:
352: # Sed substitution that turns a string into a regex matching for the
353: # string literally.
354: sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
355:
356: # Sed substitution that converts a w32 file name or path
357: # that contains forward slashes, into one that contains
358: # (escaped) backslashes. A very naive implementation.
359: sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
360:
361: # Re-'\' parameter expansions in output of sed_double_quote_subst that
362: # were '\'-ed in input to the same. If an odd number of '\' preceded a
363: # '$' in input to sed_double_quote_subst, that '$' was protected from
364: # expansion. Since each input '\' is now two '\'s, look for any number
365: # of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'.
366: _G_bs='\\'
367: _G_bs2='\\\\'
368: _G_bs4='\\\\\\\\'
369: _G_dollar='\$'
370: sed_double_backslash="\
371: s/$_G_bs4/&\\
372: /g
373: s/^$_G_bs2$_G_dollar/$_G_bs&/
374: s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
375: s/\n//g"
376:
1.2 ! ohara 377: # require_check_ifs_backslash
! 378: # ---------------------------
! 379: # Check if we can use backslash as IFS='\' separator, and set
! 380: # $check_ifs_backshlash_broken to ':' or 'false'.
! 381: require_check_ifs_backslash=func_require_check_ifs_backslash
! 382: func_require_check_ifs_backslash ()
! 383: {
! 384: _G_save_IFS=$IFS
! 385: IFS='\'
! 386: _G_check_ifs_backshlash='a\\b'
! 387: for _G_i in $_G_check_ifs_backshlash
! 388: do
! 389: case $_G_i in
! 390: a)
! 391: check_ifs_backshlash_broken=false
! 392: ;;
! 393: '')
! 394: break
! 395: ;;
! 396: *)
! 397: check_ifs_backshlash_broken=:
! 398: break
! 399: ;;
! 400: esac
! 401: done
! 402: IFS=$_G_save_IFS
! 403: require_check_ifs_backslash=:
! 404: }
! 405:
1.1 ohara 406:
407: ## ----------------- ##
408: ## Global variables. ##
409: ## ----------------- ##
410:
411: # Except for the global variables explicitly listed below, the following
412: # functions in the '^func_' namespace, and the '^require_' namespace
413: # variables initialised in the 'Resource management' section, sourcing
414: # this file will not pollute your global namespace with anything
415: # else. There's no portable way to scope variables in Bourne shell
416: # though, so actually running these functions will sometimes place
417: # results into a variable named after the function, and often use
418: # temporary variables in the '^_G_' namespace. If you are careful to
419: # avoid using those namespaces casually in your sourcing script, things
420: # should continue to work as you expect. And, of course, you can freely
421: # overwrite any of the functions or variables defined here before
422: # calling anything to customize them.
423:
424: EXIT_SUCCESS=0
425: EXIT_FAILURE=1
426: EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
427: EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
428:
429: # Allow overriding, eg assuming that you follow the convention of
430: # putting '$debug_cmd' at the start of all your functions, you can get
431: # bash to show function call trace with:
432: #
433: # debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
434: debug_cmd=${debug_cmd-":"}
435: exit_cmd=:
436:
437: # By convention, finish your script with:
438: #
439: # exit $exit_status
440: #
441: # so that you can set exit_status to non-zero if you want to indicate
442: # something went wrong during execution without actually bailing out at
443: # the point of failure.
444: exit_status=$EXIT_SUCCESS
445:
446: # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
447: # is ksh but when the shell is invoked as "sh" and the current value of
448: # the _XPG environment variable is not equal to 1 (one), the special
449: # positional parameter $0, within a function call, is the name of the
450: # function.
451: progpath=$0
452:
453: # The name of this program.
454: progname=`$ECHO "$progpath" |$SED "$sed_basename"`
455:
456: # Make sure we have an absolute progpath for reexecution:
457: case $progpath in
458: [\\/]*|[A-Za-z]:\\*) ;;
459: *[\\/]*)
460: progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
461: progdir=`cd "$progdir" && pwd`
462: progpath=$progdir/$progname
463: ;;
464: *)
465: _G_IFS=$IFS
466: IFS=${PATH_SEPARATOR-:}
467: for progdir in $PATH; do
468: IFS=$_G_IFS
469: test -x "$progdir/$progname" && break
470: done
471: IFS=$_G_IFS
472: test -n "$progdir" || progdir=`pwd`
473: progpath=$progdir/$progname
474: ;;
475: esac
476:
477:
478: ## ----------------- ##
479: ## Standard options. ##
480: ## ----------------- ##
481:
482: # The following options affect the operation of the functions defined
483: # below, and should be set appropriately depending on run-time para-
484: # meters passed on the command line.
485:
486: opt_dry_run=false
487: opt_quiet=false
488: opt_verbose=false
489:
490: # Categories 'all' and 'none' are always available. Append any others
491: # you will pass as the first argument to func_warning from your own
492: # code.
493: warning_categories=
494:
495: # By default, display warnings according to 'opt_warning_types'. Set
496: # 'warning_func' to ':' to elide all warnings, or func_fatal_error to
497: # treat the next displayed warning as a fatal error.
498: warning_func=func_warn_and_continue
499:
500: # Set to 'all' to display all warnings, 'none' to suppress all
501: # warnings, or a space delimited list of some subset of
502: # 'warning_categories' to display only the listed warnings.
503: opt_warning_types=all
504:
505:
506: ## -------------------- ##
507: ## Resource management. ##
508: ## -------------------- ##
509:
510: # This section contains definitions for functions that each ensure a
511: # particular resource (a file, or a non-empty configuration variable for
512: # example) is available, and if appropriate to extract default values
513: # from pertinent package files. Call them using their associated
514: # 'require_*' variable to ensure that they are executed, at most, once.
515: #
516: # It's entirely deliberate that calling these functions can set
517: # variables that don't obey the namespace limitations obeyed by the rest
518: # of this file, in order that that they be as useful as possible to
519: # callers.
520:
521:
522: # require_term_colors
523: # -------------------
524: # Allow display of bold text on terminals that support it.
525: require_term_colors=func_require_term_colors
526: func_require_term_colors ()
527: {
528: $debug_cmd
529:
530: test -t 1 && {
531: # COLORTERM and USE_ANSI_COLORS environment variables take
532: # precedence, because most terminfo databases neglect to describe
533: # whether color sequences are supported.
534: test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
535:
536: if test 1 = "$USE_ANSI_COLORS"; then
537: # Standard ANSI escape sequences
538: tc_reset='[0m'
539: tc_bold='[1m'; tc_standout='[7m'
540: tc_red='[31m'; tc_green='[32m'
541: tc_blue='[34m'; tc_cyan='[36m'
542: else
543: # Otherwise trust the terminfo database after all.
544: test -n "`tput sgr0 2>/dev/null`" && {
545: tc_reset=`tput sgr0`
546: test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
547: tc_standout=$tc_bold
548: test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
549: test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
550: test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
551: test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
552: test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
553: }
554: fi
555: }
556:
557: require_term_colors=:
558: }
559:
560:
561: ## ----------------- ##
562: ## Function library. ##
563: ## ----------------- ##
564:
565: # This section contains a variety of useful functions to call in your
566: # scripts. Take note of the portable wrappers for features provided by
567: # some modern shells, which will fall back to slower equivalents on
568: # less featureful shells.
569:
570:
571: # func_append VAR VALUE
572: # ---------------------
573: # Append VALUE onto the existing contents of VAR.
574:
575: # We should try to minimise forks, especially on Windows where they are
576: # unreasonably slow, so skip the feature probes when bash or zsh are
577: # being used:
578: if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
579: : ${_G_HAVE_ARITH_OP="yes"}
580: : ${_G_HAVE_XSI_OPS="yes"}
581: # The += operator was introduced in bash 3.1
582: case $BASH_VERSION in
583: [12].* | 3.0 | 3.0*) ;;
584: *)
585: : ${_G_HAVE_PLUSEQ_OP="yes"}
586: ;;
587: esac
588: fi
589:
590: # _G_HAVE_PLUSEQ_OP
591: # Can be empty, in which case the shell is probed, "yes" if += is
592: # useable or anything else if it does not work.
593: test -z "$_G_HAVE_PLUSEQ_OP" \
594: && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
595: && _G_HAVE_PLUSEQ_OP=yes
596:
597: if test yes = "$_G_HAVE_PLUSEQ_OP"
598: then
599: # This is an XSI compatible shell, allowing a faster implementation...
600: eval 'func_append ()
601: {
602: $debug_cmd
603:
604: eval "$1+=\$2"
605: }'
606: else
607: # ...otherwise fall back to using expr, which is often a shell builtin.
608: func_append ()
609: {
610: $debug_cmd
611:
612: eval "$1=\$$1\$2"
613: }
614: fi
615:
616:
617: # func_append_quoted VAR VALUE
618: # ----------------------------
619: # Quote VALUE and append to the end of shell variable VAR, separated
620: # by a space.
621: if test yes = "$_G_HAVE_PLUSEQ_OP"; then
622: eval 'func_append_quoted ()
623: {
624: $debug_cmd
625:
1.2 ! ohara 626: func_quote_arg pretty "$2"
! 627: eval "$1+=\\ \$func_quote_arg_result"
1.1 ohara 628: }'
629: else
630: func_append_quoted ()
631: {
632: $debug_cmd
633:
1.2 ! ohara 634: func_quote_arg pretty "$2"
! 635: eval "$1=\$$1\\ \$func_quote_arg_result"
1.1 ohara 636: }
637: fi
638:
639:
640: # func_append_uniq VAR VALUE
641: # --------------------------
642: # Append unique VALUE onto the existing contents of VAR, assuming
643: # entries are delimited by the first character of VALUE. For example:
644: #
645: # func_append_uniq options " --another-option option-argument"
646: #
647: # will only append to $options if " --another-option option-argument "
648: # is not already present somewhere in $options already (note spaces at
649: # each end implied by leading space in second argument).
650: func_append_uniq ()
651: {
652: $debug_cmd
653:
654: eval _G_current_value='`$ECHO $'$1'`'
655: _G_delim=`expr "$2" : '\(.\)'`
656:
657: case $_G_delim$_G_current_value$_G_delim in
658: *"$2$_G_delim"*) ;;
659: *) func_append "$@" ;;
660: esac
661: }
662:
663:
664: # func_arith TERM...
665: # ------------------
666: # Set func_arith_result to the result of evaluating TERMs.
667: test -z "$_G_HAVE_ARITH_OP" \
668: && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
669: && _G_HAVE_ARITH_OP=yes
670:
671: if test yes = "$_G_HAVE_ARITH_OP"; then
672: eval 'func_arith ()
673: {
674: $debug_cmd
675:
676: func_arith_result=$(( $* ))
677: }'
678: else
679: func_arith ()
680: {
681: $debug_cmd
682:
683: func_arith_result=`expr "$@"`
684: }
685: fi
686:
687:
688: # func_basename FILE
689: # ------------------
690: # Set func_basename_result to FILE with everything up to and including
691: # the last / stripped.
692: if test yes = "$_G_HAVE_XSI_OPS"; then
693: # If this shell supports suffix pattern removal, then use it to avoid
694: # forking. Hide the definitions single quotes in case the shell chokes
695: # on unsupported syntax...
696: _b='func_basename_result=${1##*/}'
697: _d='case $1 in
698: */*) func_dirname_result=${1%/*}$2 ;;
699: * ) func_dirname_result=$3 ;;
700: esac'
701:
702: else
703: # ...otherwise fall back to using sed.
704: _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
705: _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"`
706: if test "X$func_dirname_result" = "X$1"; then
707: func_dirname_result=$3
708: else
709: func_append func_dirname_result "$2"
710: fi'
711: fi
712:
713: eval 'func_basename ()
714: {
715: $debug_cmd
716:
717: '"$_b"'
718: }'
719:
720:
721: # func_dirname FILE APPEND NONDIR_REPLACEMENT
722: # -------------------------------------------
723: # Compute the dirname of FILE. If nonempty, add APPEND to the result,
724: # otherwise set result to NONDIR_REPLACEMENT.
725: eval 'func_dirname ()
726: {
727: $debug_cmd
728:
729: '"$_d"'
730: }'
731:
732:
733: # func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
734: # --------------------------------------------------------
735: # Perform func_basename and func_dirname in a single function
736: # call:
737: # dirname: Compute the dirname of FILE. If nonempty,
738: # add APPEND to the result, otherwise set result
739: # to NONDIR_REPLACEMENT.
740: # value returned in "$func_dirname_result"
741: # basename: Compute filename of FILE.
742: # value retuned in "$func_basename_result"
743: # For efficiency, we do not delegate to the functions above but instead
744: # duplicate the functionality here.
745: eval 'func_dirname_and_basename ()
746: {
747: $debug_cmd
748:
749: '"$_b"'
750: '"$_d"'
751: }'
752:
753:
754: # func_echo ARG...
755: # ----------------
756: # Echo program name prefixed message.
757: func_echo ()
758: {
759: $debug_cmd
760:
761: _G_message=$*
762:
763: func_echo_IFS=$IFS
764: IFS=$nl
765: for _G_line in $_G_message; do
766: IFS=$func_echo_IFS
767: $ECHO "$progname: $_G_line"
768: done
769: IFS=$func_echo_IFS
770: }
771:
772:
773: # func_echo_all ARG...
774: # --------------------
775: # Invoke $ECHO with all args, space-separated.
776: func_echo_all ()
777: {
778: $ECHO "$*"
779: }
780:
781:
782: # func_echo_infix_1 INFIX ARG...
783: # ------------------------------
784: # Echo program name, followed by INFIX on the first line, with any
785: # additional lines not showing INFIX.
786: func_echo_infix_1 ()
787: {
788: $debug_cmd
789:
790: $require_term_colors
791:
792: _G_infix=$1; shift
793: _G_indent=$_G_infix
794: _G_prefix="$progname: $_G_infix: "
795: _G_message=$*
796:
797: # Strip color escape sequences before counting printable length
798: for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
799: do
800: test -n "$_G_tc" && {
801: _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
802: _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
803: }
804: done
805: _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes
806:
807: func_echo_infix_1_IFS=$IFS
808: IFS=$nl
809: for _G_line in $_G_message; do
810: IFS=$func_echo_infix_1_IFS
811: $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
812: _G_prefix=$_G_indent
813: done
814: IFS=$func_echo_infix_1_IFS
815: }
816:
817:
818: # func_error ARG...
819: # -----------------
820: # Echo program name prefixed message to standard error.
821: func_error ()
822: {
823: $debug_cmd
824:
825: $require_term_colors
826:
827: func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2
828: }
829:
830:
831: # func_fatal_error ARG...
832: # -----------------------
833: # Echo program name prefixed message to standard error, and exit.
834: func_fatal_error ()
835: {
836: $debug_cmd
837:
838: func_error "$*"
839: exit $EXIT_FAILURE
840: }
841:
842:
843: # func_grep EXPRESSION FILENAME
844: # -----------------------------
845: # Check whether EXPRESSION matches any line of FILENAME, without output.
846: func_grep ()
847: {
848: $debug_cmd
849:
850: $GREP "$1" "$2" >/dev/null 2>&1
851: }
852:
853:
854: # func_len STRING
855: # ---------------
856: # Set func_len_result to the length of STRING. STRING may not
857: # start with a hyphen.
858: test -z "$_G_HAVE_XSI_OPS" \
859: && (eval 'x=a/b/c;
860: test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
861: && _G_HAVE_XSI_OPS=yes
862:
863: if test yes = "$_G_HAVE_XSI_OPS"; then
864: eval 'func_len ()
865: {
866: $debug_cmd
867:
868: func_len_result=${#1}
869: }'
870: else
871: func_len ()
872: {
873: $debug_cmd
874:
875: func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
876: }
877: fi
878:
879:
880: # func_mkdir_p DIRECTORY-PATH
881: # ---------------------------
882: # Make sure the entire path to DIRECTORY-PATH is available.
883: func_mkdir_p ()
884: {
885: $debug_cmd
886:
887: _G_directory_path=$1
888: _G_dir_list=
889:
890: if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
891:
892: # Protect directory names starting with '-'
893: case $_G_directory_path in
894: -*) _G_directory_path=./$_G_directory_path ;;
895: esac
896:
897: # While some portion of DIR does not yet exist...
898: while test ! -d "$_G_directory_path"; do
899: # ...make a list in topmost first order. Use a colon delimited
900: # list incase some portion of path contains whitespace.
901: _G_dir_list=$_G_directory_path:$_G_dir_list
902:
903: # If the last portion added has no slash in it, the list is done
904: case $_G_directory_path in */*) ;; *) break ;; esac
905:
906: # ...otherwise throw away the child directory and loop
907: _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
908: done
909: _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
910:
911: func_mkdir_p_IFS=$IFS; IFS=:
912: for _G_dir in $_G_dir_list; do
913: IFS=$func_mkdir_p_IFS
914: # mkdir can fail with a 'File exist' error if two processes
915: # try to create one of the directories concurrently. Don't
916: # stop in that case!
917: $MKDIR "$_G_dir" 2>/dev/null || :
918: done
919: IFS=$func_mkdir_p_IFS
920:
921: # Bail out if we (or some other process) failed to create a directory.
922: test -d "$_G_directory_path" || \
923: func_fatal_error "Failed to create '$1'"
924: fi
925: }
926:
927:
928: # func_mktempdir [BASENAME]
929: # -------------------------
930: # Make a temporary directory that won't clash with other running
931: # libtool processes, and avoids race conditions if possible. If
932: # given, BASENAME is the basename for that directory.
933: func_mktempdir ()
934: {
935: $debug_cmd
936:
937: _G_template=${TMPDIR-/tmp}/${1-$progname}
938:
939: if test : = "$opt_dry_run"; then
940: # Return a directory name, but don't create it in dry-run mode
941: _G_tmpdir=$_G_template-$$
942: else
943:
944: # If mktemp works, use that first and foremost
945: _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
946:
947: if test ! -d "$_G_tmpdir"; then
948: # Failing that, at least try and use $RANDOM to avoid a race
949: _G_tmpdir=$_G_template-${RANDOM-0}$$
950:
951: func_mktempdir_umask=`umask`
952: umask 0077
953: $MKDIR "$_G_tmpdir"
954: umask $func_mktempdir_umask
955: fi
956:
957: # If we're not in dry-run mode, bomb out on failure
958: test -d "$_G_tmpdir" || \
959: func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
960: fi
961:
962: $ECHO "$_G_tmpdir"
963: }
964:
965:
966: # func_normal_abspath PATH
967: # ------------------------
968: # Remove doubled-up and trailing slashes, "." path components,
969: # and cancel out any ".." path components in PATH after making
970: # it an absolute path.
971: func_normal_abspath ()
972: {
973: $debug_cmd
974:
975: # These SED scripts presuppose an absolute path with a trailing slash.
976: _G_pathcar='s|^/\([^/]*\).*$|\1|'
977: _G_pathcdr='s|^/[^/]*||'
978: _G_removedotparts=':dotsl
979: s|/\./|/|g
980: t dotsl
981: s|/\.$|/|'
982: _G_collapseslashes='s|/\{1,\}|/|g'
983: _G_finalslash='s|/*$|/|'
984:
985: # Start from root dir and reassemble the path.
986: func_normal_abspath_result=
987: func_normal_abspath_tpath=$1
988: func_normal_abspath_altnamespace=
989: case $func_normal_abspath_tpath in
990: "")
991: # Empty path, that just means $cwd.
992: func_stripname '' '/' "`pwd`"
993: func_normal_abspath_result=$func_stripname_result
994: return
995: ;;
996: # The next three entries are used to spot a run of precisely
997: # two leading slashes without using negated character classes;
998: # we take advantage of case's first-match behaviour.
999: ///*)
1000: # Unusual form of absolute path, do nothing.
1001: ;;
1002: //*)
1003: # Not necessarily an ordinary path; POSIX reserves leading '//'
1004: # and for example Cygwin uses it to access remote file shares
1005: # over CIFS/SMB, so we conserve a leading double slash if found.
1006: func_normal_abspath_altnamespace=/
1007: ;;
1008: /*)
1009: # Absolute path, do nothing.
1010: ;;
1011: *)
1012: # Relative path, prepend $cwd.
1013: func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
1014: ;;
1015: esac
1016:
1017: # Cancel out all the simple stuff to save iterations. We also want
1018: # the path to end with a slash for ease of parsing, so make sure
1019: # there is one (and only one) here.
1020: func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
1021: -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
1022: while :; do
1023: # Processed it all yet?
1024: if test / = "$func_normal_abspath_tpath"; then
1025: # If we ascended to the root using ".." the result may be empty now.
1026: if test -z "$func_normal_abspath_result"; then
1027: func_normal_abspath_result=/
1028: fi
1029: break
1030: fi
1031: func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
1032: -e "$_G_pathcar"`
1033: func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
1034: -e "$_G_pathcdr"`
1035: # Figure out what to do with it
1036: case $func_normal_abspath_tcomponent in
1037: "")
1038: # Trailing empty path component, ignore it.
1039: ;;
1040: ..)
1041: # Parent dir; strip last assembled component from result.
1042: func_dirname "$func_normal_abspath_result"
1043: func_normal_abspath_result=$func_dirname_result
1044: ;;
1045: *)
1046: # Actual path component, append it.
1047: func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
1048: ;;
1049: esac
1050: done
1051: # Restore leading double-slash if one was found on entry.
1052: func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
1053: }
1054:
1055:
1056: # func_notquiet ARG...
1057: # --------------------
1058: # Echo program name prefixed message only when not in quiet mode.
1059: func_notquiet ()
1060: {
1061: $debug_cmd
1062:
1063: $opt_quiet || func_echo ${1+"$@"}
1064:
1065: # A bug in bash halts the script if the last line of a function
1066: # fails when set -e is in force, so we need another command to
1067: # work around that:
1068: :
1069: }
1070:
1071:
1072: # func_relative_path SRCDIR DSTDIR
1073: # --------------------------------
1074: # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
1075: func_relative_path ()
1076: {
1077: $debug_cmd
1078:
1079: func_relative_path_result=
1080: func_normal_abspath "$1"
1081: func_relative_path_tlibdir=$func_normal_abspath_result
1082: func_normal_abspath "$2"
1083: func_relative_path_tbindir=$func_normal_abspath_result
1084:
1085: # Ascend the tree starting from libdir
1086: while :; do
1087: # check if we have found a prefix of bindir
1088: case $func_relative_path_tbindir in
1089: $func_relative_path_tlibdir)
1090: # found an exact match
1091: func_relative_path_tcancelled=
1092: break
1093: ;;
1094: $func_relative_path_tlibdir*)
1095: # found a matching prefix
1096: func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
1097: func_relative_path_tcancelled=$func_stripname_result
1098: if test -z "$func_relative_path_result"; then
1099: func_relative_path_result=.
1100: fi
1101: break
1102: ;;
1103: *)
1104: func_dirname $func_relative_path_tlibdir
1105: func_relative_path_tlibdir=$func_dirname_result
1106: if test -z "$func_relative_path_tlibdir"; then
1107: # Have to descend all the way to the root!
1108: func_relative_path_result=../$func_relative_path_result
1109: func_relative_path_tcancelled=$func_relative_path_tbindir
1110: break
1111: fi
1112: func_relative_path_result=../$func_relative_path_result
1113: ;;
1114: esac
1115: done
1116:
1117: # Now calculate path; take care to avoid doubling-up slashes.
1118: func_stripname '' '/' "$func_relative_path_result"
1119: func_relative_path_result=$func_stripname_result
1120: func_stripname '/' '/' "$func_relative_path_tcancelled"
1121: if test -n "$func_stripname_result"; then
1122: func_append func_relative_path_result "/$func_stripname_result"
1123: fi
1124:
1125: # Normalisation. If bindir is libdir, return '.' else relative path.
1126: if test -n "$func_relative_path_result"; then
1127: func_stripname './' '' "$func_relative_path_result"
1128: func_relative_path_result=$func_stripname_result
1129: fi
1130:
1131: test -n "$func_relative_path_result" || func_relative_path_result=.
1132:
1133: :
1134: }
1135:
1136:
1.2 ! ohara 1137: # func_quote_portable EVAL ARG
! 1138: # ----------------------------
! 1139: # Internal function to portably implement func_quote_arg. Note that we still
! 1140: # keep attention to performance here so we as much as possible try to avoid
! 1141: # calling sed binary (so far O(N) complexity as long as func_append is O(1)).
! 1142: func_quote_portable ()
1.1 ohara 1143: {
1144: $debug_cmd
1145:
1.2 ! ohara 1146: $require_check_ifs_backslash
! 1147:
! 1148: func_quote_portable_result=$2
! 1149:
! 1150: # one-time-loop (easy break)
! 1151: while true
! 1152: do
! 1153: if $1; then
! 1154: func_quote_portable_result=`$ECHO "$2" | $SED \
! 1155: -e "$sed_double_quote_subst" -e "$sed_double_backslash"`
! 1156: break
! 1157: fi
! 1158:
! 1159: # Quote for eval.
! 1160: case $func_quote_portable_result in
1.1 ohara 1161: *[\\\`\"\$]*)
1.2 ! ohara 1162: # Fallback to sed for $func_check_bs_ifs_broken=:, or when the string
! 1163: # contains the shell wildcard characters.
! 1164: case $check_ifs_backshlash_broken$func_quote_portable_result in
! 1165: :*|*[\[\*\?]*)
! 1166: func_quote_portable_result=`$ECHO "$func_quote_portable_result" \
! 1167: | $SED "$sed_quote_subst"`
! 1168: break
! 1169: ;;
! 1170: esac
1.1 ohara 1171:
1.2 ! ohara 1172: func_quote_portable_old_IFS=$IFS
! 1173: for _G_char in '\' '`' '"' '$'
! 1174: do
! 1175: # STATE($1) PREV($2) SEPARATOR($3)
! 1176: set start "" ""
! 1177: func_quote_portable_result=dummy"$_G_char$func_quote_portable_result$_G_char"dummy
! 1178: IFS=$_G_char
! 1179: for _G_part in $func_quote_portable_result
! 1180: do
! 1181: case $1 in
! 1182: quote)
! 1183: func_append func_quote_portable_result "$3$2"
! 1184: set quote "$_G_part" "\\$_G_char"
! 1185: ;;
! 1186: start)
! 1187: set first "" ""
! 1188: func_quote_portable_result=
! 1189: ;;
! 1190: first)
! 1191: set quote "$_G_part" ""
! 1192: ;;
! 1193: esac
! 1194: done
! 1195: done
! 1196: IFS=$func_quote_portable_old_IFS
1.1 ohara 1197: ;;
1.2 ! ohara 1198: *) ;;
1.1 ohara 1199: esac
1.2 ! ohara 1200: break
! 1201: done
1.1 ohara 1202:
1.2 ! ohara 1203: func_quote_portable_unquoted_result=$func_quote_portable_result
! 1204: case $func_quote_portable_result in
! 1205: # double-quote args containing shell metacharacters to delay
! 1206: # word splitting, command substitution and variable expansion
! 1207: # for a subsequent eval.
! 1208: # many bourne shells cannot handle close brackets correctly
! 1209: # in scan sets, so we specify it separately.
! 1210: *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
! 1211: func_quote_portable_result=\"$func_quote_portable_result\"
! 1212: ;;
! 1213: esac
1.1 ohara 1214: }
1215:
1216:
1.2 ! ohara 1217: # func_quotefast_eval ARG
! 1218: # -----------------------
! 1219: # Quote one ARG (internal). This is equivalent to 'func_quote_arg eval ARG',
! 1220: # but optimized for speed. Result is stored in $func_quotefast_eval.
! 1221: if test xyes = `(x=; printf -v x %q yes; echo x"$x") 2>/dev/null`; then
! 1222: printf -v _GL_test_printf_tilde %q '~'
! 1223: if test '\~' = "$_GL_test_printf_tilde"; then
! 1224: func_quotefast_eval ()
! 1225: {
! 1226: printf -v func_quotefast_eval_result %q "$1"
! 1227: }
! 1228: else
! 1229: # Broken older Bash implementations. Make those faster too if possible.
! 1230: func_quotefast_eval ()
! 1231: {
! 1232: case $1 in
! 1233: '~'*)
! 1234: func_quote_portable false "$1"
! 1235: func_quotefast_eval_result=$func_quote_portable_result
! 1236: ;;
! 1237: *)
! 1238: printf -v func_quotefast_eval_result %q "$1"
! 1239: ;;
! 1240: esac
! 1241: }
! 1242: fi
! 1243: else
! 1244: func_quotefast_eval ()
! 1245: {
! 1246: func_quote_portable false "$1"
! 1247: func_quotefast_eval_result=$func_quote_portable_result
! 1248: }
! 1249: fi
! 1250:
1.1 ohara 1251:
1.2 ! ohara 1252: # func_quote_arg MODEs ARG
! 1253: # ------------------------
! 1254: # Quote one ARG to be evaled later. MODEs argument may contain zero or more
! 1255: # specifiers listed below separated by ',' character. This function returns two
! 1256: # values:
! 1257: # i) func_quote_arg_result
! 1258: # double-quoted (when needed), suitable for a subsequent eval
! 1259: # ii) func_quote_arg_unquoted_result
! 1260: # has all characters that are still active within double
! 1261: # quotes backslashified. Available only if 'unquoted' is specified.
! 1262: #
! 1263: # Available modes:
! 1264: # ----------------
! 1265: # 'eval' (default)
! 1266: # - escape shell special characters
! 1267: # 'expand'
! 1268: # - the same as 'eval'; but do not quote variable references
! 1269: # 'pretty'
! 1270: # - request aesthetic output, i.e. '"a b"' instead of 'a\ b'. This might
! 1271: # be used later in func_quote to get output like: 'echo "a b"' instead
! 1272: # of 'echo a\ b'. This is slower than default on some shells.
! 1273: # 'unquoted'
! 1274: # - produce also $func_quote_arg_unquoted_result which does not contain
! 1275: # wrapping double-quotes.
! 1276: #
! 1277: # Examples for 'func_quote_arg pretty,unquoted string':
! 1278: #
! 1279: # string | *_result | *_unquoted_result
! 1280: # ------------+-----------------------+-------------------
! 1281: # " | \" | \"
! 1282: # a b | "a b" | a b
! 1283: # "a b" | "\"a b\"" | \"a b\"
! 1284: # * | "*" | *
! 1285: # z="${x-$y}" | "z=\"\${x-\$y}\"" | z=\"\${x-\$y}\"
! 1286: #
! 1287: # Examples for 'func_quote_arg pretty,unquoted,expand string':
! 1288: #
! 1289: # string | *_result | *_unquoted_result
! 1290: # --------------+---------------------+--------------------
! 1291: # z="${x-$y}" | "z=\"${x-$y}\"" | z=\"${x-$y}\"
! 1292: func_quote_arg ()
! 1293: {
! 1294: _G_quote_expand=false
! 1295: case ,$1, in
! 1296: *,expand,*)
! 1297: _G_quote_expand=:
! 1298: ;;
1.1 ohara 1299: esac
1300:
1.2 ! ohara 1301: case ,$1, in
! 1302: *,pretty,*|*,expand,*|*,unquoted,*)
! 1303: func_quote_portable $_G_quote_expand "$2"
! 1304: func_quote_arg_result=$func_quote_portable_result
! 1305: func_quote_arg_unquoted_result=$func_quote_portable_unquoted_result
! 1306: ;;
! 1307: *)
! 1308: # Faster quote-for-eval for some shells.
! 1309: func_quotefast_eval "$2"
! 1310: func_quote_arg_result=$func_quotefast_eval_result
1.1 ohara 1311: ;;
1312: esac
1.2 ! ohara 1313: }
1.1 ohara 1314:
1.2 ! ohara 1315:
! 1316: # func_quote MODEs ARGs...
! 1317: # ------------------------
! 1318: # Quote all ARGs to be evaled later and join them into single command. See
! 1319: # func_quote_arg's description for more info.
! 1320: func_quote ()
! 1321: {
! 1322: $debug_cmd
! 1323: _G_func_quote_mode=$1 ; shift
! 1324: func_quote_result=
! 1325: while test 0 -lt $#; do
! 1326: func_quote_arg "$_G_func_quote_mode" "$1"
! 1327: if test -n "$func_quote_result"; then
! 1328: func_append func_quote_result " $func_quote_arg_result"
! 1329: else
! 1330: func_append func_quote_result "$func_quote_arg_result"
! 1331: fi
! 1332: shift
! 1333: done
1.1 ohara 1334: }
1335:
1336:
1337: # func_stripname PREFIX SUFFIX NAME
1338: # ---------------------------------
1339: # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
1340: # PREFIX and SUFFIX must not contain globbing or regex special
1341: # characters, hashes, percent signs, but SUFFIX may contain a leading
1342: # dot (in which case that matches only a dot).
1343: if test yes = "$_G_HAVE_XSI_OPS"; then
1344: eval 'func_stripname ()
1345: {
1346: $debug_cmd
1347:
1348: # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
1349: # positional parameters, so assign one to ordinary variable first.
1350: func_stripname_result=$3
1351: func_stripname_result=${func_stripname_result#"$1"}
1352: func_stripname_result=${func_stripname_result%"$2"}
1353: }'
1354: else
1355: func_stripname ()
1356: {
1357: $debug_cmd
1358:
1359: case $2 in
1360: .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
1361: *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
1362: esac
1363: }
1364: fi
1365:
1366:
1367: # func_show_eval CMD [FAIL_EXP]
1368: # -----------------------------
1369: # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
1370: # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
1371: # is given, then evaluate it.
1372: func_show_eval ()
1373: {
1374: $debug_cmd
1375:
1376: _G_cmd=$1
1377: _G_fail_exp=${2-':'}
1378:
1.2 ! ohara 1379: func_quote_arg pretty,expand "$_G_cmd"
! 1380: eval "func_notquiet $func_quote_arg_result"
1.1 ohara 1381:
1382: $opt_dry_run || {
1383: eval "$_G_cmd"
1384: _G_status=$?
1385: if test 0 -ne "$_G_status"; then
1386: eval "(exit $_G_status); $_G_fail_exp"
1387: fi
1388: }
1389: }
1390:
1391:
1392: # func_show_eval_locale CMD [FAIL_EXP]
1393: # ------------------------------------
1394: # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
1395: # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
1396: # is given, then evaluate it. Use the saved locale for evaluation.
1397: func_show_eval_locale ()
1398: {
1399: $debug_cmd
1400:
1401: _G_cmd=$1
1402: _G_fail_exp=${2-':'}
1403:
1404: $opt_quiet || {
1.2 ! ohara 1405: func_quote_arg expand,pretty "$_G_cmd"
! 1406: eval "func_echo $func_quote_arg_result"
1.1 ohara 1407: }
1408:
1409: $opt_dry_run || {
1410: eval "$_G_user_locale
1411: $_G_cmd"
1412: _G_status=$?
1413: eval "$_G_safe_locale"
1414: if test 0 -ne "$_G_status"; then
1415: eval "(exit $_G_status); $_G_fail_exp"
1416: fi
1417: }
1418: }
1419:
1420:
1421: # func_tr_sh
1422: # ----------
1423: # Turn $1 into a string suitable for a shell variable name.
1424: # Result is stored in $func_tr_sh_result. All characters
1425: # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
1426: # if $1 begins with a digit, a '_' is prepended as well.
1427: func_tr_sh ()
1428: {
1429: $debug_cmd
1430:
1431: case $1 in
1432: [0-9]* | *[!a-zA-Z0-9_]*)
1433: func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
1434: ;;
1435: * )
1436: func_tr_sh_result=$1
1437: ;;
1438: esac
1439: }
1440:
1441:
1442: # func_verbose ARG...
1443: # -------------------
1444: # Echo program name prefixed message in verbose mode only.
1445: func_verbose ()
1446: {
1447: $debug_cmd
1448:
1449: $opt_verbose && func_echo "$*"
1450:
1451: :
1452: }
1453:
1454:
1455: # func_warn_and_continue ARG...
1456: # -----------------------------
1457: # Echo program name prefixed warning message to standard error.
1458: func_warn_and_continue ()
1459: {
1460: $debug_cmd
1461:
1462: $require_term_colors
1463:
1464: func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
1465: }
1466:
1467:
1468: # func_warning CATEGORY ARG...
1469: # ----------------------------
1470: # Echo program name prefixed warning message to standard error. Warning
1471: # messages can be filtered according to CATEGORY, where this function
1472: # elides messages where CATEGORY is not listed in the global variable
1473: # 'opt_warning_types'.
1474: func_warning ()
1475: {
1476: $debug_cmd
1477:
1478: # CATEGORY must be in the warning_categories list!
1479: case " $warning_categories " in
1480: *" $1 "*) ;;
1481: *) func_internal_error "invalid warning category '$1'" ;;
1482: esac
1483:
1484: _G_category=$1
1485: shift
1486:
1487: case " $opt_warning_types " in
1488: *" $_G_category "*) $warning_func ${1+"$@"} ;;
1489: esac
1490: }
1491:
1492:
1493: # func_sort_ver VER1 VER2
1494: # -----------------------
1495: # 'sort -V' is not generally available.
1496: # Note this deviates from the version comparison in automake
1497: # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
1498: # but this should suffice as we won't be specifying old
1499: # version formats or redundant trailing .0 in bootstrap.conf.
1500: # If we did want full compatibility then we should probably
1501: # use m4_version_compare from autoconf.
1502: func_sort_ver ()
1503: {
1504: $debug_cmd
1505:
1506: printf '%s\n%s\n' "$1" "$2" \
1507: | 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
1508: }
1509:
1510: # func_lt_ver PREV CURR
1511: # ---------------------
1512: # Return true if PREV and CURR are in the correct order according to
1513: # func_sort_ver, otherwise false. Use it like this:
1514: #
1515: # func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
1516: func_lt_ver ()
1517: {
1518: $debug_cmd
1519:
1520: test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
1521: }
1522:
1523:
1524: # Local variables:
1525: # mode: shell-script
1526: # sh-indentation: 2
1527: # eval: (add-hook 'before-save-hook 'time-stamp)
1528: # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
1529: # time-stamp-time-zone: "UTC"
1530: # End:
1531: #! /bin/sh
1532:
1533: # A portable, pluggable option parser for Bourne shell.
1534: # Written by Gary V. Vaughan, 2010
1535:
1.2 ! ohara 1536: # This is free software. There is NO warranty; not even for
! 1537: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
! 1538: #
! 1539: # Copyright (C) 2010-2019, 2021 Bootstrap Authors
! 1540: #
! 1541: # This file is dual licensed under the terms of the MIT license
! 1542: # <https://opensource.org/license/MIT>, and GPL version 2 or later
! 1543: # <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of
! 1544: # these licenses when using or redistributing this software or any of
! 1545: # the files within it. See the URLs above, or the file `LICENSE`
! 1546: # included in the Bootstrap distribution for the full license texts.
1.1 ohara 1547:
1.2 ! ohara 1548: # Please report bugs or propose patches to:
! 1549: # <https://github.com/gnulib-modules/bootstrap/issues>
1.1 ohara 1550:
1.2 ! ohara 1551: # Set a version string for this script.
! 1552: scriptversion=2019-02-19.15; # UTC
1.1 ohara 1553:
1554:
1555: ## ------ ##
1556: ## Usage. ##
1557: ## ------ ##
1558:
1559: # This file is a library for parsing options in your shell scripts along
1560: # with assorted other useful supporting features that you can make use
1561: # of too.
1562: #
1563: # For the simplest scripts you might need only:
1564: #
1565: # #!/bin/sh
1566: # . relative/path/to/funclib.sh
1567: # . relative/path/to/options-parser
1568: # scriptversion=1.0
1569: # func_options ${1+"$@"}
1570: # eval set dummy "$func_options_result"; shift
1571: # ...rest of your script...
1572: #
1573: # In order for the '--version' option to work, you will need to have a
1574: # suitably formatted comment like the one at the top of this file
1.2 ! ohara 1575: # starting with '# Written by ' and ending with '# Copyright'.
1.1 ohara 1576: #
1577: # For '-h' and '--help' to work, you will also need a one line
1578: # description of your script's purpose in a comment directly above the
1579: # '# Written by ' line, like the one at the top of this file.
1580: #
1581: # The default options also support '--debug', which will turn on shell
1582: # execution tracing (see the comment above debug_cmd below for another
1583: # use), and '--verbose' and the func_verbose function to allow your script
1584: # to display verbose messages only when your user has specified
1585: # '--verbose'.
1586: #
1.2 ! ohara 1587: # After sourcing this file, you can plug in processing for additional
1.1 ohara 1588: # options by amending the variables from the 'Configuration' section
1589: # below, and following the instructions in the 'Option parsing'
1590: # section further down.
1591:
1592: ## -------------- ##
1593: ## Configuration. ##
1594: ## -------------- ##
1595:
1596: # You should override these variables in your script after sourcing this
1597: # file so that they reflect the customisations you have added to the
1598: # option parser.
1599:
1600: # The usage line for option parsing errors and the start of '-h' and
1601: # '--help' output messages. You can embed shell variables for delayed
1602: # expansion at the time the message is displayed, but you will need to
1603: # quote other shell meta-characters carefully to prevent them being
1604: # expanded when the contents are evaled.
1605: usage='$progpath [OPTION]...'
1606:
1607: # Short help message in response to '-h' and '--help'. Add to this or
1608: # override it after sourcing this library to reflect the full set of
1609: # options your script accepts.
1610: usage_message="\
1611: --debug enable verbose shell tracing
1612: -W, --warnings=CATEGORY
1613: report the warnings falling in CATEGORY [all]
1614: -v, --verbose verbosely report processing
1615: --version print version information and exit
1616: -h, --help print short or long help message and exit
1617: "
1618:
1619: # Additional text appended to 'usage_message' in response to '--help'.
1620: long_help_message="
1621: Warning categories include:
1622: 'all' show all warnings
1623: 'none' turn off all the warnings
1624: 'error' warnings are treated as fatal errors"
1625:
1626: # Help message printed before fatal option parsing errors.
1627: fatal_help="Try '\$progname --help' for more information."
1628:
1629:
1630:
1631: ## ------------------------- ##
1632: ## Hook function management. ##
1633: ## ------------------------- ##
1634:
1635: # This section contains functions for adding, removing, and running hooks
1.2 ! ohara 1636: # in the main code. A hook is just a list of function names that can be
! 1637: # run in order later on.
1.1 ohara 1638:
1639: # func_hookable FUNC_NAME
1640: # -----------------------
1641: # Declare that FUNC_NAME will run hooks added with
1642: # 'func_add_hook FUNC_NAME ...'.
1643: func_hookable ()
1644: {
1645: $debug_cmd
1646:
1647: func_append hookable_fns " $1"
1648: }
1649:
1650:
1651: # func_add_hook FUNC_NAME HOOK_FUNC
1652: # ---------------------------------
1653: # Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must
1654: # first have been declared "hookable" by a call to 'func_hookable'.
1655: func_add_hook ()
1656: {
1657: $debug_cmd
1658:
1659: case " $hookable_fns " in
1660: *" $1 "*) ;;
1661: *) func_fatal_error "'$1' does not accept hook functions." ;;
1662: esac
1663:
1664: eval func_append ${1}_hooks '" $2"'
1665: }
1666:
1667:
1668: # func_remove_hook FUNC_NAME HOOK_FUNC
1669: # ------------------------------------
1.2 ! ohara 1670: # Remove HOOK_FUNC from the list of hook functions to be called by
! 1671: # FUNC_NAME.
1.1 ohara 1672: func_remove_hook ()
1673: {
1674: $debug_cmd
1675:
1676: eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
1677: }
1678:
1679:
1.2 ! ohara 1680: # func_propagate_result FUNC_NAME_A FUNC_NAME_B
! 1681: # ---------------------------------------------
! 1682: # If the *_result variable of FUNC_NAME_A _is set_, assign its value to
! 1683: # *_result variable of FUNC_NAME_B.
! 1684: func_propagate_result ()
! 1685: {
! 1686: $debug_cmd
! 1687:
! 1688: func_propagate_result_result=:
! 1689: if eval "test \"\${${1}_result+set}\" = set"
! 1690: then
! 1691: eval "${2}_result=\$${1}_result"
! 1692: else
! 1693: func_propagate_result_result=false
! 1694: fi
! 1695: }
! 1696:
! 1697:
1.1 ohara 1698: # func_run_hooks FUNC_NAME [ARG]...
1699: # ---------------------------------
1700: # Run all hook functions registered to FUNC_NAME.
1.2 ! ohara 1701: # It's assumed that the list of hook functions contains nothing more
1.1 ohara 1702: # than a whitespace-delimited list of legal shell function names, and
1703: # no effort is wasted trying to catch shell meta-characters or preserve
1704: # whitespace.
1705: func_run_hooks ()
1706: {
1707: $debug_cmd
1708:
1709: case " $hookable_fns " in
1710: *" $1 "*) ;;
1.2 ! ohara 1711: *) func_fatal_error "'$1' does not support hook functions." ;;
1.1 ohara 1712: esac
1713:
1714: eval _G_hook_fns=\$$1_hooks; shift
1715:
1716: for _G_hook in $_G_hook_fns; do
1.2 ! ohara 1717: func_unset "${_G_hook}_result"
! 1718: eval $_G_hook '${1+"$@"}'
! 1719: func_propagate_result $_G_hook func_run_hooks
! 1720: if $func_propagate_result_result; then
! 1721: eval set dummy "$func_run_hooks_result"; shift
! 1722: fi
1.1 ohara 1723: done
1724: }
1725:
1726:
1727:
1728: ## --------------- ##
1729: ## Option parsing. ##
1730: ## --------------- ##
1731:
1732: # In order to add your own option parsing hooks, you must accept the
1.2 ! ohara 1733: # full positional parameter list from your hook function. You may remove
! 1734: # or edit any options that you action, and then pass back the remaining
! 1735: # unprocessed options in '<hooked_function_name>_result', escaped
! 1736: # suitably for 'eval'.
! 1737: #
! 1738: # The '<hooked_function_name>_result' variable is automatically unset
! 1739: # before your hook gets called; for best performance, only set the
! 1740: # *_result variable when necessary (i.e. don't call the 'func_quote'
! 1741: # function unnecessarily because it can be an expensive operation on some
! 1742: # machines).
! 1743: #
! 1744: # Like this:
1.1 ohara 1745: #
1746: # my_options_prep ()
1747: # {
1748: # $debug_cmd
1749: #
1750: # # Extend the existing usage message.
1751: # usage_message=$usage_message'
1752: # -s, --silent don'\''t print informational messages
1753: # '
1.2 ! ohara 1754: # # No change in '$@' (ignored completely by this hook). Leave
! 1755: # # my_options_prep_result variable intact.
1.1 ohara 1756: # }
1757: # func_add_hook func_options_prep my_options_prep
1758: #
1759: #
1760: # my_silent_option ()
1761: # {
1762: # $debug_cmd
1763: #
1.2 ! ohara 1764: # args_changed=false
! 1765: #
! 1766: # # Note that, for efficiency, we parse as many options as we can
1.1 ohara 1767: # # recognise in a loop before passing the remainder back to the
1768: # # caller on the first unrecognised argument we encounter.
1769: # while test $# -gt 0; do
1770: # opt=$1; shift
1771: # case $opt in
1.2 ! ohara 1772: # --silent|-s) opt_silent=:
! 1773: # args_changed=:
! 1774: # ;;
1.1 ohara 1775: # # Separate non-argument short options:
1776: # -s*) func_split_short_opt "$_G_opt"
1777: # set dummy "$func_split_short_opt_name" \
1778: # "-$func_split_short_opt_arg" ${1+"$@"}
1779: # shift
1.2 ! ohara 1780: # args_changed=:
1.1 ohara 1781: # ;;
1.2 ! ohara 1782: # *) # Make sure the first unrecognised option "$_G_opt"
! 1783: # # is added back to "$@" in case we need it later,
! 1784: # # if $args_changed was set to 'true'.
! 1785: # set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
1.1 ohara 1786: # esac
1787: # done
1788: #
1.2 ! ohara 1789: # # Only call 'func_quote' here if we processed at least one argument.
! 1790: # if $args_changed; then
! 1791: # func_quote eval ${1+"$@"}
! 1792: # my_silent_option_result=$func_quote_result
! 1793: # fi
1.1 ohara 1794: # }
1795: # func_add_hook func_parse_options my_silent_option
1796: #
1797: #
1798: # my_option_validation ()
1799: # {
1800: # $debug_cmd
1801: #
1802: # $opt_silent && $opt_verbose && func_fatal_help "\
1803: # '--silent' and '--verbose' options are mutually exclusive."
1804: # }
1805: # func_add_hook func_validate_options my_option_validation
1806: #
1.2 ! ohara 1807: # You'll also need to manually amend $usage_message to reflect the extra
1.1 ohara 1808: # options you parse. It's preferable to append if you can, so that
1809: # multiple option parsing hooks can be added safely.
1810:
1811:
1.2 ! ohara 1812: # func_options_finish [ARG]...
! 1813: # ----------------------------
! 1814: # Finishing the option parse loop (call 'func_options' hooks ATM).
! 1815: func_options_finish ()
! 1816: {
! 1817: $debug_cmd
! 1818:
! 1819: func_run_hooks func_options ${1+"$@"}
! 1820: func_propagate_result func_run_hooks func_options_finish
! 1821: }
! 1822:
! 1823:
1.1 ohara 1824: # func_options [ARG]...
1825: # ---------------------
1826: # All the functions called inside func_options are hookable. See the
1827: # individual implementations for details.
1828: func_hookable func_options
1829: func_options ()
1830: {
1831: $debug_cmd
1832:
1.2 ! ohara 1833: _G_options_quoted=false
1.1 ohara 1834:
1.2 ! ohara 1835: for my_func in options_prep parse_options validate_options options_finish
! 1836: do
! 1837: func_unset func_${my_func}_result
! 1838: func_unset func_run_hooks_result
! 1839: eval func_$my_func '${1+"$@"}'
! 1840: func_propagate_result func_$my_func func_options
! 1841: if $func_propagate_result_result; then
! 1842: eval set dummy "$func_options_result"; shift
! 1843: _G_options_quoted=:
! 1844: fi
! 1845: done
1.1 ohara 1846:
1.2 ! ohara 1847: $_G_options_quoted || {
! 1848: # As we (func_options) are top-level options-parser function and
! 1849: # nobody quoted "$@" for us yet, we need to do it explicitly for
! 1850: # caller.
! 1851: func_quote eval ${1+"$@"}
! 1852: func_options_result=$func_quote_result
! 1853: }
1.1 ohara 1854: }
1855:
1856:
1857: # func_options_prep [ARG]...
1858: # --------------------------
1859: # All initialisations required before starting the option parse loop.
1860: # Note that when calling hook functions, we pass through the list of
1861: # positional parameters. If a hook function modifies that list, and
1.2 ! ohara 1862: # needs to propagate that back to rest of this script, then the complete
! 1863: # modified list must be put in 'func_run_hooks_result' before returning.
1.1 ohara 1864: func_hookable func_options_prep
1865: func_options_prep ()
1866: {
1867: $debug_cmd
1868:
1869: # Option defaults:
1870: opt_verbose=false
1871: opt_warning_types=
1872:
1873: func_run_hooks func_options_prep ${1+"$@"}
1.2 ! ohara 1874: func_propagate_result func_run_hooks func_options_prep
1.1 ohara 1875: }
1876:
1877:
1878: # func_parse_options [ARG]...
1879: # ---------------------------
1880: # The main option parsing loop.
1881: func_hookable func_parse_options
1882: func_parse_options ()
1883: {
1884: $debug_cmd
1885:
1.2 ! ohara 1886: _G_parse_options_requote=false
1.1 ohara 1887: # this just eases exit handling
1888: while test $# -gt 0; do
1889: # Defer to hook functions for initial option parsing, so they
1890: # get priority in the event of reusing an option name.
1891: func_run_hooks func_parse_options ${1+"$@"}
1.2 ! ohara 1892: func_propagate_result func_run_hooks func_parse_options
! 1893: if $func_propagate_result_result; then
! 1894: eval set dummy "$func_parse_options_result"; shift
! 1895: # Even though we may have changed "$@", we passed the "$@" array
! 1896: # down into the hook and it quoted it for us (because we are in
! 1897: # this if-branch). No need to quote it again.
! 1898: _G_parse_options_requote=false
! 1899: fi
1.1 ohara 1900:
1901: # Break out of the loop if we already parsed every option.
1902: test $# -gt 0 || break
1903:
1.2 ! ohara 1904: # We expect that one of the options parsed in this function matches
! 1905: # and thus we remove _G_opt from "$@" and need to re-quote.
! 1906: _G_match_parse_options=:
1.1 ohara 1907: _G_opt=$1
1908: shift
1909: case $_G_opt in
1910: --debug|-x) debug_cmd='set -x'
1.2 ! ohara 1911: func_echo "enabling shell trace mode" >&2
1.1 ohara 1912: $debug_cmd
1913: ;;
1914:
1915: --no-warnings|--no-warning|--no-warn)
1916: set dummy --warnings none ${1+"$@"}
1917: shift
1918: ;;
1919:
1920: --warnings|--warning|-W)
1.2 ! ohara 1921: if test $# = 0 && func_missing_arg $_G_opt; then
! 1922: _G_parse_options_requote=:
! 1923: break
! 1924: fi
1.1 ohara 1925: case " $warning_categories $1" in
1926: *" $1 "*)
1927: # trailing space prevents matching last $1 above
1928: func_append_uniq opt_warning_types " $1"
1929: ;;
1930: *all)
1931: opt_warning_types=$warning_categories
1932: ;;
1933: *none)
1934: opt_warning_types=none
1935: warning_func=:
1936: ;;
1937: *error)
1938: opt_warning_types=$warning_categories
1939: warning_func=func_fatal_error
1940: ;;
1941: *)
1942: func_fatal_error \
1943: "unsupported warning category: '$1'"
1944: ;;
1945: esac
1946: shift
1947: ;;
1948:
1949: --verbose|-v) opt_verbose=: ;;
1950: --version) func_version ;;
1951: -\?|-h) func_usage ;;
1952: --help) func_help ;;
1953:
1954: # Separate optargs to long options (plugins may need this):
1955: --*=*) func_split_equals "$_G_opt"
1956: set dummy "$func_split_equals_lhs" \
1957: "$func_split_equals_rhs" ${1+"$@"}
1958: shift
1959: ;;
1960:
1961: # Separate optargs to short options:
1962: -W*)
1963: func_split_short_opt "$_G_opt"
1964: set dummy "$func_split_short_opt_name" \
1965: "$func_split_short_opt_arg" ${1+"$@"}
1966: shift
1967: ;;
1968:
1969: # Separate non-argument short options:
1970: -\?*|-h*|-v*|-x*)
1971: func_split_short_opt "$_G_opt"
1972: set dummy "$func_split_short_opt_name" \
1973: "-$func_split_short_opt_arg" ${1+"$@"}
1974: shift
1975: ;;
1976:
1.2 ! ohara 1977: --) _G_parse_options_requote=: ; break ;;
1.1 ohara 1978: -*) func_fatal_help "unrecognised option: '$_G_opt'" ;;
1.2 ! ohara 1979: *) set dummy "$_G_opt" ${1+"$@"}; shift
! 1980: _G_match_parse_options=false
! 1981: break
! 1982: ;;
1.1 ohara 1983: esac
1.2 ! ohara 1984:
! 1985: if $_G_match_parse_options; then
! 1986: _G_parse_options_requote=:
! 1987: fi
1.1 ohara 1988: done
1989:
1.2 ! ohara 1990: if $_G_parse_options_requote; then
! 1991: # save modified positional parameters for caller
! 1992: func_quote eval ${1+"$@"}
! 1993: func_parse_options_result=$func_quote_result
! 1994: fi
1.1 ohara 1995: }
1996:
1997:
1998: # func_validate_options [ARG]...
1999: # ------------------------------
2000: # Perform any sanity checks on option settings and/or unconsumed
2001: # arguments.
2002: func_hookable func_validate_options
2003: func_validate_options ()
2004: {
2005: $debug_cmd
2006:
2007: # Display all warnings if -W was not given.
2008: test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
2009:
2010: func_run_hooks func_validate_options ${1+"$@"}
1.2 ! ohara 2011: func_propagate_result func_run_hooks func_validate_options
1.1 ohara 2012:
2013: # Bail if the options were screwed!
2014: $exit_cmd $EXIT_FAILURE
2015: }
2016:
2017:
2018:
2019: ## ----------------- ##
2020: ## Helper functions. ##
2021: ## ----------------- ##
2022:
2023: # This section contains the helper functions used by the rest of the
2024: # hookable option parser framework in ascii-betical order.
2025:
2026:
2027: # func_fatal_help ARG...
2028: # ----------------------
2029: # Echo program name prefixed message to standard error, followed by
2030: # a help hint, and exit.
2031: func_fatal_help ()
2032: {
2033: $debug_cmd
2034:
2035: eval \$ECHO \""Usage: $usage"\"
2036: eval \$ECHO \""$fatal_help"\"
2037: func_error ${1+"$@"}
2038: exit $EXIT_FAILURE
2039: }
2040:
2041:
2042: # func_help
2043: # ---------
2044: # Echo long help message to standard output and exit.
2045: func_help ()
2046: {
2047: $debug_cmd
2048:
2049: func_usage_message
2050: $ECHO "$long_help_message"
2051: exit 0
2052: }
2053:
2054:
2055: # func_missing_arg ARGNAME
2056: # ------------------------
2057: # Echo program name prefixed message to standard error and set global
2058: # exit_cmd.
2059: func_missing_arg ()
2060: {
2061: $debug_cmd
2062:
2063: func_error "Missing argument for '$1'."
2064: exit_cmd=exit
2065: }
2066:
2067:
2068: # func_split_equals STRING
2069: # ------------------------
1.2 ! ohara 2070: # Set func_split_equals_lhs and func_split_equals_rhs shell variables
! 2071: # after splitting STRING at the '=' sign.
1.1 ohara 2072: test -z "$_G_HAVE_XSI_OPS" \
2073: && (eval 'x=a/b/c;
2074: test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
2075: && _G_HAVE_XSI_OPS=yes
2076:
2077: if test yes = "$_G_HAVE_XSI_OPS"
2078: then
2079: # This is an XSI compatible shell, allowing a faster implementation...
2080: eval 'func_split_equals ()
2081: {
2082: $debug_cmd
2083:
2084: func_split_equals_lhs=${1%%=*}
2085: func_split_equals_rhs=${1#*=}
1.2 ! ohara 2086: if test "x$func_split_equals_lhs" = "x$1"; then
! 2087: func_split_equals_rhs=
! 2088: fi
1.1 ohara 2089: }'
2090: else
2091: # ...otherwise fall back to using expr, which is often a shell builtin.
2092: func_split_equals ()
2093: {
2094: $debug_cmd
2095:
2096: func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
2097: func_split_equals_rhs=
1.2 ! ohara 2098: test "x$func_split_equals_lhs=" = "x$1" \
1.1 ohara 2099: || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
2100: }
2101: fi #func_split_equals
2102:
2103:
2104: # func_split_short_opt SHORTOPT
2105: # -----------------------------
2106: # Set func_split_short_opt_name and func_split_short_opt_arg shell
2107: # variables after splitting SHORTOPT after the 2nd character.
2108: if test yes = "$_G_HAVE_XSI_OPS"
2109: then
2110: # This is an XSI compatible shell, allowing a faster implementation...
2111: eval 'func_split_short_opt ()
2112: {
2113: $debug_cmd
2114:
2115: func_split_short_opt_arg=${1#??}
2116: func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
2117: }'
2118: else
2119: # ...otherwise fall back to using expr, which is often a shell builtin.
2120: func_split_short_opt ()
2121: {
2122: $debug_cmd
2123:
1.2 ! ohara 2124: func_split_short_opt_name=`expr "x$1" : 'x\(-.\)'`
1.1 ohara 2125: func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
2126: }
2127: fi #func_split_short_opt
2128:
2129:
2130: # func_usage
2131: # ----------
2132: # Echo short help message to standard output and exit.
2133: func_usage ()
2134: {
2135: $debug_cmd
2136:
2137: func_usage_message
2138: $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
2139: exit 0
2140: }
2141:
2142:
2143: # func_usage_message
2144: # ------------------
2145: # Echo short help message to standard output.
2146: func_usage_message ()
2147: {
2148: $debug_cmd
2149:
2150: eval \$ECHO \""Usage: $usage"\"
2151: echo
2152: $SED -n 's|^# ||
2153: /^Written by/{
2154: x;p;x
2155: }
2156: h
2157: /^Written by/q' < "$progpath"
2158: echo
2159: eval \$ECHO \""$usage_message"\"
2160: }
2161:
2162:
2163: # func_version
2164: # ------------
2165: # Echo version message to standard output and exit.
1.2 ! ohara 2166: # The version message is extracted from the calling file's header
! 2167: # comments, with leading '# ' stripped:
! 2168: # 1. First display the progname and version
! 2169: # 2. Followed by the header comment line matching /^# Written by /
! 2170: # 3. Then a blank line followed by the first following line matching
! 2171: # /^# Copyright /
! 2172: # 4. Immediately followed by any lines between the previous matches,
! 2173: # except lines preceding the intervening completely blank line.
! 2174: # For example, see the header comments of this file.
1.1 ohara 2175: func_version ()
2176: {
2177: $debug_cmd
2178:
2179: printf '%s\n' "$progname $scriptversion"
2180: $SED -n '
1.2 ! ohara 2181: /^# Written by /!b
! 2182: s|^# ||; p; n
! 2183:
! 2184: :fwd2blnk
! 2185: /./ {
! 2186: n
! 2187: b fwd2blnk
1.1 ohara 2188: }
1.2 ! ohara 2189: p; n
! 2190:
! 2191: :holdwrnt
! 2192: s|^# ||
! 2193: s|^# *$||
! 2194: /^Copyright /!{
! 2195: /./H
! 2196: n
! 2197: b holdwrnt
1.1 ohara 2198: }
1.2 ! ohara 2199:
! 2200: s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
! 2201: G
! 2202: s|\(\n\)\n*|\1|g
! 2203: p; q' < "$progpath"
1.1 ohara 2204:
2205: exit $?
2206: }
2207:
2208:
2209: # Local variables:
2210: # mode: shell-script
2211: # sh-indentation: 2
2212: # eval: (add-hook 'before-save-hook 'time-stamp)
1.2 ! ohara 2213: # time-stamp-pattern: "30/scriptversion=%:y-%02m-%02d.%02H; # UTC"
1.1 ohara 2214: # time-stamp-time-zone: "UTC"
2215: # End:
2216:
2217: # Set a version string.
1.2 ! ohara 2218: scriptversion='(GNU libtool) 2.4.7'
1.1 ohara 2219:
2220:
2221: # func_echo ARG...
2222: # ----------------
2223: # Libtool also displays the current mode in messages, so override
2224: # funclib.sh func_echo with this custom definition.
2225: func_echo ()
2226: {
2227: $debug_cmd
2228:
2229: _G_message=$*
2230:
2231: func_echo_IFS=$IFS
2232: IFS=$nl
2233: for _G_line in $_G_message; do
2234: IFS=$func_echo_IFS
2235: $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
2236: done
2237: IFS=$func_echo_IFS
2238: }
2239:
2240:
2241: # func_warning ARG...
2242: # -------------------
2243: # Libtool warnings are not categorized, so override funclib.sh
2244: # func_warning with this simpler definition.
2245: func_warning ()
2246: {
2247: $debug_cmd
2248:
2249: $warning_func ${1+"$@"}
2250: }
2251:
2252:
2253: ## ---------------- ##
2254: ## Options parsing. ##
2255: ## ---------------- ##
2256:
2257: # Hook in the functions to make sure our own options are parsed during
2258: # the option parsing loop.
2259:
2260: usage='$progpath [OPTION]... [MODE-ARG]...'
2261:
2262: # Short help message in response to '-h'.
2263: usage_message="Options:
2264: --config show all configuration variables
2265: --debug enable verbose shell tracing
2266: -n, --dry-run display commands without modifying any files
2267: --features display basic configuration information and exit
2268: --mode=MODE use operation mode MODE
2269: --no-warnings equivalent to '-Wnone'
2270: --preserve-dup-deps don't remove duplicate dependency libraries
2271: --quiet, --silent don't print informational messages
2272: --tag=TAG use configuration variables from tag TAG
2273: -v, --verbose print more informational messages than default
2274: --version print version information
2275: -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all]
2276: -h, --help, --help-all print short, long, or detailed help message
2277: "
2278:
2279: # Additional text appended to 'usage_message' in response to '--help'.
2280: func_help ()
2281: {
2282: $debug_cmd
2283:
2284: func_usage_message
2285: $ECHO "$long_help_message
2286:
2287: MODE must be one of the following:
2288:
2289: clean remove files from the build directory
2290: compile compile a source file into a libtool object
2291: execute automatically set library path, then run a program
2292: finish complete the installation of libtool libraries
2293: install install libraries or executables
2294: link create a library or an executable
2295: uninstall remove libraries from an installed directory
2296:
2297: MODE-ARGS vary depending on the MODE. When passed as first option,
2298: '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
2299: Try '$progname --help --mode=MODE' for a more detailed description of MODE.
2300:
2301: When reporting a bug, please describe a test case to reproduce it and
2302: include the following information:
2303:
2304: host-triplet: $host
2305: shell: $SHELL
2306: compiler: $LTCC
2307: compiler flags: $LTCFLAGS
2308: linker: $LD (gnu? $with_gnu_ld)
1.2 ! ohara 2309: version: $progname (GNU libtool) 2.4.7
1.1 ohara 2310: automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
2311: autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q`
2312:
2313: Report bugs to <bug-libtool@gnu.org>.
2314: GNU libtool home page: <http://www.gnu.org/software/libtool/>.
2315: General help using GNU software: <http://www.gnu.org/gethelp/>."
2316: exit 0
2317: }
2318:
2319:
2320: # func_lo2o OBJECT-NAME
2321: # ---------------------
2322: # Transform OBJECT-NAME from a '.lo' suffix to the platform specific
2323: # object suffix.
2324:
2325: lo2o=s/\\.lo\$/.$objext/
2326: o2lo=s/\\.$objext\$/.lo/
2327:
2328: if test yes = "$_G_HAVE_XSI_OPS"; then
2329: eval 'func_lo2o ()
2330: {
2331: case $1 in
2332: *.lo) func_lo2o_result=${1%.lo}.$objext ;;
2333: * ) func_lo2o_result=$1 ;;
2334: esac
2335: }'
2336:
2337: # func_xform LIBOBJ-OR-SOURCE
2338: # ---------------------------
2339: # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
2340: # suffix to a '.lo' libtool-object suffix.
2341: eval 'func_xform ()
2342: {
2343: func_xform_result=${1%.*}.lo
2344: }'
2345: else
2346: # ...otherwise fall back to using sed.
2347: func_lo2o ()
2348: {
2349: func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
2350: }
2351:
2352: func_xform ()
2353: {
2354: func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
2355: }
2356: fi
2357:
2358:
2359: # func_fatal_configuration ARG...
2360: # -------------------------------
2361: # Echo program name prefixed message to standard error, followed by
2362: # a configuration failure hint, and exit.
2363: func_fatal_configuration ()
2364: {
1.2 ! ohara 2365: func_fatal_error ${1+"$@"} \
1.1 ohara 2366: "See the $PACKAGE documentation for more information." \
2367: "Fatal configuration error."
2368: }
2369:
2370:
2371: # func_config
2372: # -----------
2373: # Display the configuration for all the tags in this script.
2374: func_config ()
2375: {
2376: re_begincf='^# ### BEGIN LIBTOOL'
2377: re_endcf='^# ### END LIBTOOL'
2378:
2379: # Default configuration.
2380: $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
2381:
2382: # Now print the configurations for the tags.
2383: for tagname in $taglist; do
2384: $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
2385: done
2386:
2387: exit $?
2388: }
2389:
2390:
2391: # func_features
2392: # -------------
2393: # Display the features supported by this script.
2394: func_features ()
2395: {
2396: echo "host: $host"
2397: if test yes = "$build_libtool_libs"; then
2398: echo "enable shared libraries"
2399: else
2400: echo "disable shared libraries"
2401: fi
2402: if test yes = "$build_old_libs"; then
2403: echo "enable static libraries"
2404: else
2405: echo "disable static libraries"
2406: fi
2407:
2408: exit $?
2409: }
2410:
2411:
2412: # func_enable_tag TAGNAME
2413: # -----------------------
2414: # Verify that TAGNAME is valid, and either flag an error and exit, or
2415: # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
2416: # variable here.
2417: func_enable_tag ()
2418: {
2419: # Global variable:
2420: tagname=$1
2421:
2422: re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
2423: re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
2424: sed_extractcf=/$re_begincf/,/$re_endcf/p
2425:
2426: # Validate tagname.
2427: case $tagname in
2428: *[!-_A-Za-z0-9,/]*)
2429: func_fatal_error "invalid tag name: $tagname"
2430: ;;
2431: esac
2432:
2433: # Don't test for the "default" C tag, as we know it's
2434: # there but not specially marked.
2435: case $tagname in
2436: CC) ;;
2437: *)
2438: if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
2439: taglist="$taglist $tagname"
2440:
2441: # Evaluate the configuration. Be careful to quote the path
2442: # and the sed script, to avoid splitting on whitespace, but
2443: # also don't use non-portable quotes within backquotes within
2444: # quotes we have to do it in 2 steps:
2445: extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
2446: eval "$extractedcf"
2447: else
2448: func_error "ignoring unknown tag $tagname"
2449: fi
2450: ;;
2451: esac
2452: }
2453:
2454:
2455: # func_check_version_match
2456: # ------------------------
2457: # Ensure that we are using m4 macros, and libtool script from the same
2458: # release of libtool.
2459: func_check_version_match ()
2460: {
2461: if test "$package_revision" != "$macro_revision"; then
2462: if test "$VERSION" != "$macro_version"; then
2463: if test -z "$macro_version"; then
2464: cat >&2 <<_LT_EOF
2465: $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2466: $progname: definition of this LT_INIT comes from an older release.
2467: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2468: $progname: and run autoconf again.
2469: _LT_EOF
2470: else
2471: cat >&2 <<_LT_EOF
2472: $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2473: $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
2474: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2475: $progname: and run autoconf again.
2476: _LT_EOF
2477: fi
2478: else
2479: cat >&2 <<_LT_EOF
2480: $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
2481: $progname: but the definition of this LT_INIT comes from revision $macro_revision.
2482: $progname: You should recreate aclocal.m4 with macros from revision $package_revision
2483: $progname: of $PACKAGE $VERSION and run autoconf again.
2484: _LT_EOF
2485: fi
2486:
2487: exit $EXIT_MISMATCH
2488: fi
2489: }
2490:
2491:
2492: # libtool_options_prep [ARG]...
2493: # -----------------------------
2494: # Preparation for options parsed by libtool.
2495: libtool_options_prep ()
2496: {
2497: $debug_mode
2498:
2499: # Option defaults:
2500: opt_config=false
2501: opt_dlopen=
2502: opt_dry_run=false
2503: opt_help=false
2504: opt_mode=
2505: opt_preserve_dup_deps=false
2506: opt_quiet=false
2507:
2508: nonopt=
2509: preserve_args=
2510:
1.2 ! ohara 2511: _G_rc_lt_options_prep=:
! 2512:
1.1 ohara 2513: # Shorthand for --mode=foo, only valid as the first argument
2514: case $1 in
2515: clean|clea|cle|cl)
2516: shift; set dummy --mode clean ${1+"$@"}; shift
2517: ;;
2518: compile|compil|compi|comp|com|co|c)
2519: shift; set dummy --mode compile ${1+"$@"}; shift
2520: ;;
2521: execute|execut|execu|exec|exe|ex|e)
2522: shift; set dummy --mode execute ${1+"$@"}; shift
2523: ;;
2524: finish|finis|fini|fin|fi|f)
2525: shift; set dummy --mode finish ${1+"$@"}; shift
2526: ;;
2527: install|instal|insta|inst|ins|in|i)
2528: shift; set dummy --mode install ${1+"$@"}; shift
2529: ;;
2530: link|lin|li|l)
2531: shift; set dummy --mode link ${1+"$@"}; shift
2532: ;;
2533: uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
2534: shift; set dummy --mode uninstall ${1+"$@"}; shift
2535: ;;
1.2 ! ohara 2536: *)
! 2537: _G_rc_lt_options_prep=false
! 2538: ;;
1.1 ohara 2539: esac
2540:
1.2 ! ohara 2541: if $_G_rc_lt_options_prep; then
! 2542: # Pass back the list of options.
! 2543: func_quote eval ${1+"$@"}
! 2544: libtool_options_prep_result=$func_quote_result
! 2545: fi
1.1 ohara 2546: }
2547: func_add_hook func_options_prep libtool_options_prep
2548:
2549:
2550: # libtool_parse_options [ARG]...
2551: # ---------------------------------
2552: # Provide handling for libtool specific options.
2553: libtool_parse_options ()
2554: {
2555: $debug_cmd
2556:
1.2 ! ohara 2557: _G_rc_lt_parse_options=false
! 2558:
1.1 ohara 2559: # Perform our own loop to consume as many options as possible in
2560: # each iteration.
2561: while test $# -gt 0; do
1.2 ! ohara 2562: _G_match_lt_parse_options=:
1.1 ohara 2563: _G_opt=$1
2564: shift
2565: case $_G_opt in
2566: --dry-run|--dryrun|-n)
2567: opt_dry_run=:
2568: ;;
2569:
2570: --config) func_config ;;
2571:
2572: --dlopen|-dlopen)
2573: opt_dlopen="${opt_dlopen+$opt_dlopen
2574: }$1"
2575: shift
2576: ;;
2577:
2578: --preserve-dup-deps)
2579: opt_preserve_dup_deps=: ;;
2580:
2581: --features) func_features ;;
2582:
2583: --finish) set dummy --mode finish ${1+"$@"}; shift ;;
2584:
2585: --help) opt_help=: ;;
2586:
2587: --help-all) opt_help=': help-all' ;;
2588:
2589: --mode) test $# = 0 && func_missing_arg $_G_opt && break
2590: opt_mode=$1
2591: case $1 in
2592: # Valid mode arguments:
2593: clean|compile|execute|finish|install|link|relink|uninstall) ;;
2594:
2595: # Catch anything else as an error
2596: *) func_error "invalid argument for $_G_opt"
2597: exit_cmd=exit
2598: break
2599: ;;
2600: esac
2601: shift
2602: ;;
2603:
2604: --no-silent|--no-quiet)
2605: opt_quiet=false
2606: func_append preserve_args " $_G_opt"
2607: ;;
2608:
2609: --no-warnings|--no-warning|--no-warn)
2610: opt_warning=false
2611: func_append preserve_args " $_G_opt"
2612: ;;
2613:
2614: --no-verbose)
2615: opt_verbose=false
2616: func_append preserve_args " $_G_opt"
2617: ;;
2618:
2619: --silent|--quiet)
2620: opt_quiet=:
2621: opt_verbose=false
2622: func_append preserve_args " $_G_opt"
2623: ;;
2624:
2625: --tag) test $# = 0 && func_missing_arg $_G_opt && break
2626: opt_tag=$1
2627: func_append preserve_args " $_G_opt $1"
2628: func_enable_tag "$1"
2629: shift
2630: ;;
2631:
2632: --verbose|-v) opt_quiet=false
2633: opt_verbose=:
2634: func_append preserve_args " $_G_opt"
2635: ;;
2636:
1.2 ! ohara 2637: # An option not handled by this hook function:
! 2638: *) set dummy "$_G_opt" ${1+"$@"} ; shift
! 2639: _G_match_lt_parse_options=false
! 2640: break
! 2641: ;;
1.1 ohara 2642: esac
1.2 ! ohara 2643: $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
1.1 ohara 2644: done
2645:
1.2 ! ohara 2646: if $_G_rc_lt_parse_options; then
! 2647: # save modified positional parameters for caller
! 2648: func_quote eval ${1+"$@"}
! 2649: libtool_parse_options_result=$func_quote_result
! 2650: fi
1.1 ohara 2651: }
2652: func_add_hook func_parse_options libtool_parse_options
2653:
2654:
2655:
2656: # libtool_validate_options [ARG]...
2657: # ---------------------------------
2658: # Perform any sanity checks on option settings and/or unconsumed
2659: # arguments.
2660: libtool_validate_options ()
2661: {
2662: # save first non-option argument
2663: if test 0 -lt $#; then
2664: nonopt=$1
2665: shift
2666: fi
2667:
2668: # preserve --debug
2669: test : = "$debug_cmd" || func_append preserve_args " --debug"
2670:
2671: case $host in
2672: # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
2673: # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
2674: *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
2675: # don't eliminate duplications in $postdeps and $predeps
2676: opt_duplicate_compiler_generated_deps=:
2677: ;;
2678: *)
2679: opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
2680: ;;
2681: esac
2682:
2683: $opt_help || {
2684: # Sanity checks first:
2685: func_check_version_match
2686:
2687: test yes != "$build_libtool_libs" \
2688: && test yes != "$build_old_libs" \
2689: && func_fatal_configuration "not configured to build any kind of library"
2690:
2691: # Darwin sucks
2692: eval std_shrext=\"$shrext_cmds\"
2693:
2694: # Only execute mode is allowed to have -dlopen flags.
2695: if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
2696: func_error "unrecognized option '-dlopen'"
2697: $ECHO "$help" 1>&2
2698: exit $EXIT_FAILURE
2699: fi
2700:
2701: # Change the help message to a mode-specific one.
2702: generic_help=$help
2703: help="Try '$progname --help --mode=$opt_mode' for more information."
2704: }
2705:
2706: # Pass back the unparsed argument list
1.2 ! ohara 2707: func_quote eval ${1+"$@"}
! 2708: libtool_validate_options_result=$func_quote_result
1.1 ohara 2709: }
2710: func_add_hook func_validate_options libtool_validate_options
2711:
2712:
2713: # Process options as early as possible so that --help and --version
2714: # can return quickly.
2715: func_options ${1+"$@"}
2716: eval set dummy "$func_options_result"; shift
2717:
2718:
2719:
2720: ## ----------- ##
2721: ## Main. ##
2722: ## ----------- ##
2723:
2724: magic='%%%MAGIC variable%%%'
2725: magic_exe='%%%MAGIC EXE variable%%%'
2726:
2727: # Global variables.
2728: extracted_archives=
2729: extracted_serial=0
2730:
2731: # If this variable is set in any of the actions, the command in it
2732: # will be execed at the end. This prevents here-documents from being
2733: # left over by shells.
2734: exec_cmd=
2735:
2736:
2737: # A function that is used when there is no print builtin or printf.
2738: func_fallback_echo ()
2739: {
2740: eval 'cat <<_LTECHO_EOF
2741: $1
2742: _LTECHO_EOF'
2743: }
2744:
2745: # func_generated_by_libtool
2746: # True iff stdin has been generated by Libtool. This function is only
2747: # a basic sanity check; it will hardly flush out determined imposters.
2748: func_generated_by_libtool_p ()
2749: {
2750: $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
2751: }
2752:
2753: # func_lalib_p file
2754: # True iff FILE is a libtool '.la' library or '.lo' object file.
2755: # This function is only a basic sanity check; it will hardly flush out
2756: # determined imposters.
2757: func_lalib_p ()
2758: {
2759: test -f "$1" &&
2760: $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
2761: }
2762:
2763: # func_lalib_unsafe_p file
2764: # True iff FILE is a libtool '.la' library or '.lo' object file.
2765: # This function implements the same check as func_lalib_p without
2766: # resorting to external programs. To this end, it redirects stdin and
2767: # closes it afterwards, without saving the original file descriptor.
2768: # As a safety measure, use it only where a negative result would be
2769: # fatal anyway. Works if 'file' does not exist.
2770: func_lalib_unsafe_p ()
2771: {
2772: lalib_p=no
2773: if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
2774: for lalib_p_l in 1 2 3 4
2775: do
2776: read lalib_p_line
2777: case $lalib_p_line in
2778: \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
2779: esac
2780: done
2781: exec 0<&5 5<&-
2782: fi
2783: test yes = "$lalib_p"
2784: }
2785:
2786: # func_ltwrapper_script_p file
2787: # True iff FILE is a libtool wrapper script
2788: # This function is only a basic sanity check; it will hardly flush out
2789: # determined imposters.
2790: func_ltwrapper_script_p ()
2791: {
2792: test -f "$1" &&
2793: $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
2794: }
2795:
2796: # func_ltwrapper_executable_p file
2797: # True iff FILE is a libtool wrapper executable
2798: # This function is only a basic sanity check; it will hardly flush out
2799: # determined imposters.
2800: func_ltwrapper_executable_p ()
2801: {
2802: func_ltwrapper_exec_suffix=
2803: case $1 in
2804: *.exe) ;;
2805: *) func_ltwrapper_exec_suffix=.exe ;;
2806: esac
2807: $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
2808: }
2809:
2810: # func_ltwrapper_scriptname file
2811: # Assumes file is an ltwrapper_executable
2812: # uses $file to determine the appropriate filename for a
2813: # temporary ltwrapper_script.
2814: func_ltwrapper_scriptname ()
2815: {
2816: func_dirname_and_basename "$1" "" "."
2817: func_stripname '' '.exe' "$func_basename_result"
2818: func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
2819: }
2820:
2821: # func_ltwrapper_p file
2822: # True iff FILE is a libtool wrapper script or wrapper executable
2823: # This function is only a basic sanity check; it will hardly flush out
2824: # determined imposters.
2825: func_ltwrapper_p ()
2826: {
2827: func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
2828: }
2829:
2830:
2831: # func_execute_cmds commands fail_cmd
2832: # Execute tilde-delimited COMMANDS.
2833: # If FAIL_CMD is given, eval that upon failure.
2834: # FAIL_CMD may read-access the current command in variable CMD!
2835: func_execute_cmds ()
2836: {
2837: $debug_cmd
2838:
2839: save_ifs=$IFS; IFS='~'
2840: for cmd in $1; do
2841: IFS=$sp$nl
2842: eval cmd=\"$cmd\"
2843: IFS=$save_ifs
2844: func_show_eval "$cmd" "${2-:}"
2845: done
2846: IFS=$save_ifs
2847: }
2848:
2849:
2850: # func_source file
2851: # Source FILE, adding directory component if necessary.
2852: # Note that it is not necessary on cygwin/mingw to append a dot to
2853: # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
2854: # behavior happens only for exec(3), not for open(2)! Also, sourcing
2855: # 'FILE.' does not work on cygwin managed mounts.
2856: func_source ()
2857: {
2858: $debug_cmd
2859:
2860: case $1 in
2861: */* | *\\*) . "$1" ;;
2862: *) . "./$1" ;;
2863: esac
2864: }
2865:
2866:
2867: # func_resolve_sysroot PATH
2868: # Replace a leading = in PATH with a sysroot. Store the result into
2869: # func_resolve_sysroot_result
2870: func_resolve_sysroot ()
2871: {
2872: func_resolve_sysroot_result=$1
2873: case $func_resolve_sysroot_result in
2874: =*)
2875: func_stripname '=' '' "$func_resolve_sysroot_result"
2876: func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
2877: ;;
2878: esac
2879: }
2880:
2881: # func_replace_sysroot PATH
2882: # If PATH begins with the sysroot, replace it with = and
2883: # store the result into func_replace_sysroot_result.
2884: func_replace_sysroot ()
2885: {
2886: case $lt_sysroot:$1 in
2887: ?*:"$lt_sysroot"*)
2888: func_stripname "$lt_sysroot" '' "$1"
2889: func_replace_sysroot_result='='$func_stripname_result
2890: ;;
2891: *)
2892: # Including no sysroot.
2893: func_replace_sysroot_result=$1
2894: ;;
2895: esac
2896: }
2897:
2898: # func_infer_tag arg
2899: # Infer tagged configuration to use if any are available and
2900: # if one wasn't chosen via the "--tag" command line option.
2901: # Only attempt this if the compiler in the base compile
2902: # command doesn't match the default compiler.
2903: # arg is usually of the form 'gcc ...'
2904: func_infer_tag ()
2905: {
2906: $debug_cmd
2907:
2908: if test -n "$available_tags" && test -z "$tagname"; then
2909: CC_quoted=
2910: for arg in $CC; do
2911: func_append_quoted CC_quoted "$arg"
2912: done
2913: CC_expanded=`func_echo_all $CC`
2914: CC_quoted_expanded=`func_echo_all $CC_quoted`
2915: case $@ in
2916: # Blanks in the command may have been stripped by the calling shell,
2917: # but not from the CC environment variable when configure was run.
2918: " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2919: " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
2920: # Blanks at the start of $base_compile will cause this to fail
2921: # if we don't check for them as well.
2922: *)
2923: for z in $available_tags; do
2924: if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
2925: # Evaluate the configuration.
2926: eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
2927: CC_quoted=
2928: for arg in $CC; do
2929: # Double-quote args containing other shell metacharacters.
2930: func_append_quoted CC_quoted "$arg"
2931: done
2932: CC_expanded=`func_echo_all $CC`
2933: CC_quoted_expanded=`func_echo_all $CC_quoted`
2934: case "$@ " in
2935: " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2936: " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
2937: # The compiler in the base compile command matches
2938: # the one in the tagged configuration.
2939: # Assume this is the tagged configuration we want.
2940: tagname=$z
2941: break
2942: ;;
2943: esac
2944: fi
2945: done
2946: # If $tagname still isn't set, then no tagged configuration
2947: # was found and let the user know that the "--tag" command
2948: # line option must be used.
2949: if test -z "$tagname"; then
2950: func_echo "unable to infer tagged configuration"
2951: func_fatal_error "specify a tag with '--tag'"
2952: # else
2953: # func_verbose "using $tagname tagged configuration"
2954: fi
2955: ;;
2956: esac
2957: fi
2958: }
2959:
2960:
2961:
2962: # func_write_libtool_object output_name pic_name nonpic_name
2963: # Create a libtool object file (analogous to a ".la" file),
2964: # but don't create it if we're doing a dry run.
2965: func_write_libtool_object ()
2966: {
2967: write_libobj=$1
2968: if test yes = "$build_libtool_libs"; then
2969: write_lobj=\'$2\'
2970: else
2971: write_lobj=none
2972: fi
2973:
2974: if test yes = "$build_old_libs"; then
2975: write_oldobj=\'$3\'
2976: else
2977: write_oldobj=none
2978: fi
2979:
2980: $opt_dry_run || {
2981: cat >${write_libobj}T <<EOF
2982: # $write_libobj - a libtool object file
2983: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
2984: #
2985: # Please DO NOT delete this file!
2986: # It is necessary for linking the library.
2987:
2988: # Name of the PIC object.
2989: pic_object=$write_lobj
2990:
2991: # Name of the non-PIC object
2992: non_pic_object=$write_oldobj
2993:
2994: EOF
2995: $MV "${write_libobj}T" "$write_libobj"
2996: }
2997: }
2998:
2999:
3000: ##################################################
3001: # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
3002: ##################################################
3003:
3004: # func_convert_core_file_wine_to_w32 ARG
3005: # Helper function used by file name conversion functions when $build is *nix,
3006: # and $host is mingw, cygwin, or some other w32 environment. Relies on a
3007: # correctly configured wine environment available, with the winepath program
3008: # in $build's $PATH.
3009: #
3010: # ARG is the $build file name to be converted to w32 format.
3011: # Result is available in $func_convert_core_file_wine_to_w32_result, and will
3012: # be empty on error (or when ARG is empty)
3013: func_convert_core_file_wine_to_w32 ()
3014: {
3015: $debug_cmd
3016:
3017: func_convert_core_file_wine_to_w32_result=$1
3018: if test -n "$1"; then
3019: # Unfortunately, winepath does not exit with a non-zero error code, so we
3020: # are forced to check the contents of stdout. On the other hand, if the
3021: # command is not found, the shell will set an exit code of 127 and print
3022: # *an error message* to stdout. So we must check for both error code of
3023: # zero AND non-empty stdout, which explains the odd construction:
3024: func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
3025: if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
3026: func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
3027: $SED -e "$sed_naive_backslashify"`
3028: else
3029: func_convert_core_file_wine_to_w32_result=
3030: fi
3031: fi
3032: }
3033: # end: func_convert_core_file_wine_to_w32
3034:
3035:
3036: # func_convert_core_path_wine_to_w32 ARG
3037: # Helper function used by path conversion functions when $build is *nix, and
3038: # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
3039: # configured wine environment available, with the winepath program in $build's
3040: # $PATH. Assumes ARG has no leading or trailing path separator characters.
3041: #
3042: # ARG is path to be converted from $build format to win32.
3043: # Result is available in $func_convert_core_path_wine_to_w32_result.
3044: # Unconvertible file (directory) names in ARG are skipped; if no directory names
3045: # are convertible, then the result may be empty.
3046: func_convert_core_path_wine_to_w32 ()
3047: {
3048: $debug_cmd
3049:
3050: # unfortunately, winepath doesn't convert paths, only file names
3051: func_convert_core_path_wine_to_w32_result=
3052: if test -n "$1"; then
3053: oldIFS=$IFS
3054: IFS=:
3055: for func_convert_core_path_wine_to_w32_f in $1; do
3056: IFS=$oldIFS
3057: func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
3058: if test -n "$func_convert_core_file_wine_to_w32_result"; then
3059: if test -z "$func_convert_core_path_wine_to_w32_result"; then
3060: func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
3061: else
3062: func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
3063: fi
3064: fi
3065: done
3066: IFS=$oldIFS
3067: fi
3068: }
3069: # end: func_convert_core_path_wine_to_w32
3070:
3071:
3072: # func_cygpath ARGS...
3073: # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
3074: # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
3075: # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
3076: # (2), returns the Cygwin file name or path in func_cygpath_result (input
3077: # file name or path is assumed to be in w32 format, as previously converted
3078: # from $build's *nix or MSYS format). In case (3), returns the w32 file name
3079: # or path in func_cygpath_result (input file name or path is assumed to be in
3080: # Cygwin format). Returns an empty string on error.
3081: #
3082: # ARGS are passed to cygpath, with the last one being the file name or path to
3083: # be converted.
3084: #
3085: # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
3086: # environment variable; do not put it in $PATH.
3087: func_cygpath ()
3088: {
3089: $debug_cmd
3090:
3091: if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
3092: func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
3093: if test "$?" -ne 0; then
3094: # on failure, ensure result is empty
3095: func_cygpath_result=
3096: fi
3097: else
3098: func_cygpath_result=
3099: func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
3100: fi
3101: }
3102: #end: func_cygpath
3103:
3104:
3105: # func_convert_core_msys_to_w32 ARG
3106: # Convert file name or path ARG from MSYS format to w32 format. Return
3107: # result in func_convert_core_msys_to_w32_result.
3108: func_convert_core_msys_to_w32 ()
3109: {
3110: $debug_cmd
3111:
3112: # awkward: cmd appends spaces to result
3113: func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
3114: $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
3115: }
3116: #end: func_convert_core_msys_to_w32
3117:
3118:
3119: # func_convert_file_check ARG1 ARG2
3120: # Verify that ARG1 (a file name in $build format) was converted to $host
3121: # format in ARG2. Otherwise, emit an error message, but continue (resetting
3122: # func_to_host_file_result to ARG1).
3123: func_convert_file_check ()
3124: {
3125: $debug_cmd
3126:
3127: if test -z "$2" && test -n "$1"; then
3128: func_error "Could not determine host file name corresponding to"
3129: func_error " '$1'"
3130: func_error "Continuing, but uninstalled executables may not work."
3131: # Fallback:
3132: func_to_host_file_result=$1
3133: fi
3134: }
3135: # end func_convert_file_check
3136:
3137:
3138: # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
3139: # Verify that FROM_PATH (a path in $build format) was converted to $host
3140: # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
3141: # func_to_host_file_result to a simplistic fallback value (see below).
3142: func_convert_path_check ()
3143: {
3144: $debug_cmd
3145:
3146: if test -z "$4" && test -n "$3"; then
3147: func_error "Could not determine the host path corresponding to"
3148: func_error " '$3'"
3149: func_error "Continuing, but uninstalled executables may not work."
3150: # Fallback. This is a deliberately simplistic "conversion" and
3151: # should not be "improved". See libtool.info.
3152: if test "x$1" != "x$2"; then
3153: lt_replace_pathsep_chars="s|$1|$2|g"
3154: func_to_host_path_result=`echo "$3" |
3155: $SED -e "$lt_replace_pathsep_chars"`
3156: else
3157: func_to_host_path_result=$3
3158: fi
3159: fi
3160: }
3161: # end func_convert_path_check
3162:
3163:
3164: # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
3165: # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
3166: # and appending REPL if ORIG matches BACKPAT.
3167: func_convert_path_front_back_pathsep ()
3168: {
3169: $debug_cmd
3170:
3171: case $4 in
3172: $1 ) func_to_host_path_result=$3$func_to_host_path_result
3173: ;;
3174: esac
3175: case $4 in
3176: $2 ) func_append func_to_host_path_result "$3"
3177: ;;
3178: esac
3179: }
3180: # end func_convert_path_front_back_pathsep
3181:
3182:
3183: ##################################################
3184: # $build to $host FILE NAME CONVERSION FUNCTIONS #
3185: ##################################################
3186: # invoked via '$to_host_file_cmd ARG'
3187: #
3188: # In each case, ARG is the path to be converted from $build to $host format.
3189: # Result will be available in $func_to_host_file_result.
3190:
3191:
3192: # func_to_host_file ARG
3193: # Converts the file name ARG from $build format to $host format. Return result
3194: # in func_to_host_file_result.
3195: func_to_host_file ()
3196: {
3197: $debug_cmd
3198:
3199: $to_host_file_cmd "$1"
3200: }
3201: # end func_to_host_file
3202:
3203:
3204: # func_to_tool_file ARG LAZY
3205: # converts the file name ARG from $build format to toolchain format. Return
3206: # result in func_to_tool_file_result. If the conversion in use is listed
3207: # in (the comma separated) LAZY, no conversion takes place.
3208: func_to_tool_file ()
3209: {
3210: $debug_cmd
3211:
3212: case ,$2, in
3213: *,"$to_tool_file_cmd",*)
3214: func_to_tool_file_result=$1
3215: ;;
3216: *)
3217: $to_tool_file_cmd "$1"
3218: func_to_tool_file_result=$func_to_host_file_result
3219: ;;
3220: esac
3221: }
3222: # end func_to_tool_file
3223:
3224:
3225: # func_convert_file_noop ARG
3226: # Copy ARG to func_to_host_file_result.
3227: func_convert_file_noop ()
3228: {
3229: func_to_host_file_result=$1
3230: }
3231: # end func_convert_file_noop
3232:
3233:
3234: # func_convert_file_msys_to_w32 ARG
3235: # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
3236: # conversion to w32 is not available inside the cwrapper. Returns result in
3237: # func_to_host_file_result.
3238: func_convert_file_msys_to_w32 ()
3239: {
3240: $debug_cmd
3241:
3242: func_to_host_file_result=$1
3243: if test -n "$1"; then
3244: func_convert_core_msys_to_w32 "$1"
3245: func_to_host_file_result=$func_convert_core_msys_to_w32_result
3246: fi
3247: func_convert_file_check "$1" "$func_to_host_file_result"
3248: }
3249: # end func_convert_file_msys_to_w32
3250:
3251:
3252: # func_convert_file_cygwin_to_w32 ARG
3253: # Convert file name ARG from Cygwin to w32 format. Returns result in
3254: # func_to_host_file_result.
3255: func_convert_file_cygwin_to_w32 ()
3256: {
3257: $debug_cmd
3258:
3259: func_to_host_file_result=$1
3260: if test -n "$1"; then
3261: # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
3262: # LT_CYGPATH in this case.
3263: func_to_host_file_result=`cygpath -m "$1"`
3264: fi
3265: func_convert_file_check "$1" "$func_to_host_file_result"
3266: }
3267: # end func_convert_file_cygwin_to_w32
3268:
3269:
3270: # func_convert_file_nix_to_w32 ARG
3271: # Convert file name ARG from *nix to w32 format. Requires a wine environment
3272: # and a working winepath. Returns result in func_to_host_file_result.
3273: func_convert_file_nix_to_w32 ()
3274: {
3275: $debug_cmd
3276:
3277: func_to_host_file_result=$1
3278: if test -n "$1"; then
3279: func_convert_core_file_wine_to_w32 "$1"
3280: func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
3281: fi
3282: func_convert_file_check "$1" "$func_to_host_file_result"
3283: }
3284: # end func_convert_file_nix_to_w32
3285:
3286:
3287: # func_convert_file_msys_to_cygwin ARG
3288: # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3289: # Returns result in func_to_host_file_result.
3290: func_convert_file_msys_to_cygwin ()
3291: {
3292: $debug_cmd
3293:
3294: func_to_host_file_result=$1
3295: if test -n "$1"; then
3296: func_convert_core_msys_to_w32 "$1"
3297: func_cygpath -u "$func_convert_core_msys_to_w32_result"
3298: func_to_host_file_result=$func_cygpath_result
3299: fi
3300: func_convert_file_check "$1" "$func_to_host_file_result"
3301: }
3302: # end func_convert_file_msys_to_cygwin
3303:
3304:
3305: # func_convert_file_nix_to_cygwin ARG
3306: # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
3307: # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
3308: # in func_to_host_file_result.
3309: func_convert_file_nix_to_cygwin ()
3310: {
3311: $debug_cmd
3312:
3313: func_to_host_file_result=$1
3314: if test -n "$1"; then
3315: # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
3316: func_convert_core_file_wine_to_w32 "$1"
3317: func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
3318: func_to_host_file_result=$func_cygpath_result
3319: fi
3320: func_convert_file_check "$1" "$func_to_host_file_result"
3321: }
3322: # end func_convert_file_nix_to_cygwin
3323:
3324:
3325: #############################################
3326: # $build to $host PATH CONVERSION FUNCTIONS #
3327: #############################################
3328: # invoked via '$to_host_path_cmd ARG'
3329: #
3330: # In each case, ARG is the path to be converted from $build to $host format.
3331: # The result will be available in $func_to_host_path_result.
3332: #
3333: # Path separators are also converted from $build format to $host format. If
3334: # ARG begins or ends with a path separator character, it is preserved (but
3335: # converted to $host format) on output.
3336: #
3337: # All path conversion functions are named using the following convention:
3338: # file name conversion function : func_convert_file_X_to_Y ()
3339: # path conversion function : func_convert_path_X_to_Y ()
3340: # where, for any given $build/$host combination the 'X_to_Y' value is the
3341: # same. If conversion functions are added for new $build/$host combinations,
3342: # the two new functions must follow this pattern, or func_init_to_host_path_cmd
3343: # will break.
3344:
3345:
3346: # func_init_to_host_path_cmd
3347: # Ensures that function "pointer" variable $to_host_path_cmd is set to the
3348: # appropriate value, based on the value of $to_host_file_cmd.
3349: to_host_path_cmd=
3350: func_init_to_host_path_cmd ()
3351: {
3352: $debug_cmd
3353:
3354: if test -z "$to_host_path_cmd"; then
3355: func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
3356: to_host_path_cmd=func_convert_path_$func_stripname_result
3357: fi
3358: }
3359:
3360:
3361: # func_to_host_path ARG
3362: # Converts the path ARG from $build format to $host format. Return result
3363: # in func_to_host_path_result.
3364: func_to_host_path ()
3365: {
3366: $debug_cmd
3367:
3368: func_init_to_host_path_cmd
3369: $to_host_path_cmd "$1"
3370: }
3371: # end func_to_host_path
3372:
3373:
3374: # func_convert_path_noop ARG
3375: # Copy ARG to func_to_host_path_result.
3376: func_convert_path_noop ()
3377: {
3378: func_to_host_path_result=$1
3379: }
3380: # end func_convert_path_noop
3381:
3382:
3383: # func_convert_path_msys_to_w32 ARG
3384: # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
3385: # conversion to w32 is not available inside the cwrapper. Returns result in
3386: # func_to_host_path_result.
3387: func_convert_path_msys_to_w32 ()
3388: {
3389: $debug_cmd
3390:
3391: func_to_host_path_result=$1
3392: if test -n "$1"; then
3393: # Remove leading and trailing path separator characters from ARG. MSYS
3394: # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
3395: # and winepath ignores them completely.
3396: func_stripname : : "$1"
3397: func_to_host_path_tmp1=$func_stripname_result
3398: func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3399: func_to_host_path_result=$func_convert_core_msys_to_w32_result
3400: func_convert_path_check : ";" \
3401: "$func_to_host_path_tmp1" "$func_to_host_path_result"
3402: func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3403: fi
3404: }
3405: # end func_convert_path_msys_to_w32
3406:
3407:
3408: # func_convert_path_cygwin_to_w32 ARG
3409: # Convert path ARG from Cygwin to w32 format. Returns result in
3410: # func_to_host_file_result.
3411: func_convert_path_cygwin_to_w32 ()
3412: {
3413: $debug_cmd
3414:
3415: func_to_host_path_result=$1
3416: if test -n "$1"; then
3417: # See func_convert_path_msys_to_w32:
3418: func_stripname : : "$1"
3419: func_to_host_path_tmp1=$func_stripname_result
3420: func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
3421: func_convert_path_check : ";" \
3422: "$func_to_host_path_tmp1" "$func_to_host_path_result"
3423: func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3424: fi
3425: }
3426: # end func_convert_path_cygwin_to_w32
3427:
3428:
3429: # func_convert_path_nix_to_w32 ARG
3430: # Convert path ARG from *nix to w32 format. Requires a wine environment and
3431: # a working winepath. Returns result in func_to_host_file_result.
3432: func_convert_path_nix_to_w32 ()
3433: {
3434: $debug_cmd
3435:
3436: func_to_host_path_result=$1
3437: if test -n "$1"; then
3438: # See func_convert_path_msys_to_w32:
3439: func_stripname : : "$1"
3440: func_to_host_path_tmp1=$func_stripname_result
3441: func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3442: func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
3443: func_convert_path_check : ";" \
3444: "$func_to_host_path_tmp1" "$func_to_host_path_result"
3445: func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3446: fi
3447: }
3448: # end func_convert_path_nix_to_w32
3449:
3450:
3451: # func_convert_path_msys_to_cygwin ARG
3452: # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3453: # Returns result in func_to_host_file_result.
3454: func_convert_path_msys_to_cygwin ()
3455: {
3456: $debug_cmd
3457:
3458: func_to_host_path_result=$1
3459: if test -n "$1"; then
3460: # See func_convert_path_msys_to_w32:
3461: func_stripname : : "$1"
3462: func_to_host_path_tmp1=$func_stripname_result
3463: func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3464: func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
3465: func_to_host_path_result=$func_cygpath_result
3466: func_convert_path_check : : \
3467: "$func_to_host_path_tmp1" "$func_to_host_path_result"
3468: func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3469: fi
3470: }
3471: # end func_convert_path_msys_to_cygwin
3472:
3473:
3474: # func_convert_path_nix_to_cygwin ARG
3475: # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
3476: # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
3477: # func_to_host_file_result.
3478: func_convert_path_nix_to_cygwin ()
3479: {
3480: $debug_cmd
3481:
3482: func_to_host_path_result=$1
3483: if test -n "$1"; then
3484: # Remove leading and trailing path separator characters from
3485: # ARG. msys behavior is inconsistent here, cygpath turns them
3486: # into '.;' and ';.', and winepath ignores them completely.
3487: func_stripname : : "$1"
3488: func_to_host_path_tmp1=$func_stripname_result
3489: func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3490: func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
3491: func_to_host_path_result=$func_cygpath_result
3492: func_convert_path_check : : \
3493: "$func_to_host_path_tmp1" "$func_to_host_path_result"
3494: func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3495: fi
3496: }
3497: # end func_convert_path_nix_to_cygwin
3498:
3499:
3500: # func_dll_def_p FILE
3501: # True iff FILE is a Windows DLL '.def' file.
3502: # Keep in sync with _LT_DLL_DEF_P in libtool.m4
3503: func_dll_def_p ()
3504: {
3505: $debug_cmd
3506:
3507: func_dll_def_p_tmp=`$SED -n \
3508: -e 's/^[ ]*//' \
3509: -e '/^\(;.*\)*$/d' \
3510: -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \
3511: -e q \
3512: "$1"`
3513: test DEF = "$func_dll_def_p_tmp"
3514: }
3515:
3516:
3517: # func_mode_compile arg...
3518: func_mode_compile ()
3519: {
3520: $debug_cmd
3521:
3522: # Get the compilation command and the source file.
3523: base_compile=
3524: srcfile=$nonopt # always keep a non-empty value in "srcfile"
3525: suppress_opt=yes
3526: suppress_output=
3527: arg_mode=normal
3528: libobj=
3529: later=
3530: pie_flag=
3531:
3532: for arg
3533: do
3534: case $arg_mode in
3535: arg )
3536: # do not "continue". Instead, add this to base_compile
3537: lastarg=$arg
3538: arg_mode=normal
3539: ;;
3540:
3541: target )
3542: libobj=$arg
3543: arg_mode=normal
3544: continue
3545: ;;
3546:
3547: normal )
3548: # Accept any command-line options.
3549: case $arg in
3550: -o)
3551: test -n "$libobj" && \
3552: func_fatal_error "you cannot specify '-o' more than once"
3553: arg_mode=target
3554: continue
3555: ;;
3556:
3557: -pie | -fpie | -fPIE)
3558: func_append pie_flag " $arg"
3559: continue
3560: ;;
3561:
3562: -shared | -static | -prefer-pic | -prefer-non-pic)
3563: func_append later " $arg"
3564: continue
3565: ;;
3566:
3567: -no-suppress)
3568: suppress_opt=no
3569: continue
3570: ;;
3571:
3572: -Xcompiler)
3573: arg_mode=arg # the next one goes into the "base_compile" arg list
3574: continue # The current "srcfile" will either be retained or
3575: ;; # replaced later. I would guess that would be a bug.
3576:
3577: -Wc,*)
3578: func_stripname '-Wc,' '' "$arg"
3579: args=$func_stripname_result
3580: lastarg=
3581: save_ifs=$IFS; IFS=,
3582: for arg in $args; do
3583: IFS=$save_ifs
3584: func_append_quoted lastarg "$arg"
3585: done
3586: IFS=$save_ifs
3587: func_stripname ' ' '' "$lastarg"
3588: lastarg=$func_stripname_result
3589:
3590: # Add the arguments to base_compile.
3591: func_append base_compile " $lastarg"
3592: continue
3593: ;;
3594:
3595: *)
3596: # Accept the current argument as the source file.
3597: # The previous "srcfile" becomes the current argument.
3598: #
3599: lastarg=$srcfile
3600: srcfile=$arg
3601: ;;
3602: esac # case $arg
3603: ;;
3604: esac # case $arg_mode
3605:
3606: # Aesthetically quote the previous argument.
3607: func_append_quoted base_compile "$lastarg"
3608: done # for arg
3609:
3610: case $arg_mode in
3611: arg)
3612: func_fatal_error "you must specify an argument for -Xcompile"
3613: ;;
3614: target)
3615: func_fatal_error "you must specify a target with '-o'"
3616: ;;
3617: *)
3618: # Get the name of the library object.
3619: test -z "$libobj" && {
3620: func_basename "$srcfile"
3621: libobj=$func_basename_result
3622: }
3623: ;;
3624: esac
3625:
3626: # Recognize several different file suffixes.
3627: # If the user specifies -o file.o, it is replaced with file.lo
3628: case $libobj in
3629: *.[cCFSifmso] | \
3630: *.ada | *.adb | *.ads | *.asm | \
3631: *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
3632: *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
3633: func_xform "$libobj"
3634: libobj=$func_xform_result
3635: ;;
3636: esac
3637:
3638: case $libobj in
3639: *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
3640: *)
3641: func_fatal_error "cannot determine name of library object from '$libobj'"
3642: ;;
3643: esac
3644:
3645: func_infer_tag $base_compile
3646:
3647: for arg in $later; do
3648: case $arg in
3649: -shared)
3650: test yes = "$build_libtool_libs" \
3651: || func_fatal_configuration "cannot build a shared library"
3652: build_old_libs=no
3653: continue
3654: ;;
3655:
3656: -static)
3657: build_libtool_libs=no
3658: build_old_libs=yes
3659: continue
3660: ;;
3661:
3662: -prefer-pic)
3663: pic_mode=yes
3664: continue
3665: ;;
3666:
3667: -prefer-non-pic)
3668: pic_mode=no
3669: continue
3670: ;;
3671: esac
3672: done
3673:
1.2 ! ohara 3674: func_quote_arg pretty "$libobj"
! 3675: test "X$libobj" != "X$func_quote_arg_result" \
1.1 ohara 3676: && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
3677: && func_warning "libobj name '$libobj' may not contain shell special characters."
3678: func_dirname_and_basename "$obj" "/" ""
3679: objname=$func_basename_result
3680: xdir=$func_dirname_result
3681: lobj=$xdir$objdir/$objname
3682:
3683: test -z "$base_compile" && \
3684: func_fatal_help "you must specify a compilation command"
3685:
3686: # Delete any leftover library objects.
3687: if test yes = "$build_old_libs"; then
3688: removelist="$obj $lobj $libobj ${libobj}T"
3689: else
3690: removelist="$lobj $libobj ${libobj}T"
3691: fi
3692:
3693: # On Cygwin there's no "real" PIC flag so we must build both object types
3694: case $host_os in
3695: cygwin* | mingw* | pw32* | os2* | cegcc*)
3696: pic_mode=default
3697: ;;
3698: esac
3699: if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
3700: # non-PIC code in shared libraries is not supported
3701: pic_mode=default
3702: fi
3703:
3704: # Calculate the filename of the output object if compiler does
3705: # not support -o with -c
3706: if test no = "$compiler_c_o"; then
3707: output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
3708: lockfile=$output_obj.lock
3709: else
3710: output_obj=
3711: need_locks=no
3712: lockfile=
3713: fi
3714:
3715: # Lock this critical section if it is needed
3716: # We use this script file to make the link, it avoids creating a new file
3717: if test yes = "$need_locks"; then
3718: until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3719: func_echo "Waiting for $lockfile to be removed"
3720: sleep 2
3721: done
3722: elif test warn = "$need_locks"; then
3723: if test -f "$lockfile"; then
3724: $ECHO "\
3725: *** ERROR, $lockfile exists and contains:
3726: `cat $lockfile 2>/dev/null`
3727:
3728: This indicates that another process is trying to use the same
3729: temporary object file, and libtool could not work around it because
3730: your compiler does not support '-c' and '-o' together. If you
3731: repeat this compilation, it may succeed, by chance, but you had better
3732: avoid parallel builds (make -j) in this platform, or get a better
3733: compiler."
3734:
3735: $opt_dry_run || $RM $removelist
3736: exit $EXIT_FAILURE
3737: fi
3738: func_append removelist " $output_obj"
3739: $ECHO "$srcfile" > "$lockfile"
3740: fi
3741:
3742: $opt_dry_run || $RM $removelist
3743: func_append removelist " $lockfile"
3744: trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
3745:
3746: func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
3747: srcfile=$func_to_tool_file_result
1.2 ! ohara 3748: func_quote_arg pretty "$srcfile"
! 3749: qsrcfile=$func_quote_arg_result
1.1 ohara 3750:
3751: # Only build a PIC object if we are building libtool libraries.
3752: if test yes = "$build_libtool_libs"; then
3753: # Without this assignment, base_compile gets emptied.
3754: fbsd_hideous_sh_bug=$base_compile
3755:
3756: if test no != "$pic_mode"; then
3757: command="$base_compile $qsrcfile $pic_flag"
3758: else
3759: # Don't build PIC code
3760: command="$base_compile $qsrcfile"
3761: fi
3762:
3763: func_mkdir_p "$xdir$objdir"
3764:
3765: if test -z "$output_obj"; then
3766: # Place PIC objects in $objdir
3767: func_append command " -o $lobj"
3768: fi
3769:
3770: func_show_eval_locale "$command" \
3771: 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
3772:
3773: if test warn = "$need_locks" &&
3774: test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3775: $ECHO "\
3776: *** ERROR, $lockfile contains:
3777: `cat $lockfile 2>/dev/null`
3778:
3779: but it should contain:
3780: $srcfile
3781:
3782: This indicates that another process is trying to use the same
3783: temporary object file, and libtool could not work around it because
3784: your compiler does not support '-c' and '-o' together. If you
3785: repeat this compilation, it may succeed, by chance, but you had better
3786: avoid parallel builds (make -j) in this platform, or get a better
3787: compiler."
3788:
3789: $opt_dry_run || $RM $removelist
3790: exit $EXIT_FAILURE
3791: fi
3792:
3793: # Just move the object if needed, then go on to compile the next one
3794: if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
3795: func_show_eval '$MV "$output_obj" "$lobj"' \
3796: 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3797: fi
3798:
3799: # Allow error messages only from the first compilation.
3800: if test yes = "$suppress_opt"; then
3801: suppress_output=' >/dev/null 2>&1'
3802: fi
3803: fi
3804:
3805: # Only build a position-dependent object if we build old libraries.
3806: if test yes = "$build_old_libs"; then
3807: if test yes != "$pic_mode"; then
3808: # Don't build PIC code
3809: command="$base_compile $qsrcfile$pie_flag"
3810: else
3811: command="$base_compile $qsrcfile $pic_flag"
3812: fi
3813: if test yes = "$compiler_c_o"; then
3814: func_append command " -o $obj"
3815: fi
3816:
3817: # Suppress compiler output if we already did a PIC compilation.
3818: func_append command "$suppress_output"
3819: func_show_eval_locale "$command" \
3820: '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
3821:
3822: if test warn = "$need_locks" &&
3823: test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3824: $ECHO "\
3825: *** ERROR, $lockfile contains:
3826: `cat $lockfile 2>/dev/null`
3827:
3828: but it should contain:
3829: $srcfile
3830:
3831: This indicates that another process is trying to use the same
3832: temporary object file, and libtool could not work around it because
3833: your compiler does not support '-c' and '-o' together. If you
3834: repeat this compilation, it may succeed, by chance, but you had better
3835: avoid parallel builds (make -j) in this platform, or get a better
3836: compiler."
3837:
3838: $opt_dry_run || $RM $removelist
3839: exit $EXIT_FAILURE
3840: fi
3841:
3842: # Just move the object if needed
3843: if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
3844: func_show_eval '$MV "$output_obj" "$obj"' \
3845: 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3846: fi
3847: fi
3848:
3849: $opt_dry_run || {
3850: func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
3851:
3852: # Unlock the critical section if it was locked
3853: if test no != "$need_locks"; then
3854: removelist=$lockfile
3855: $RM "$lockfile"
3856: fi
3857: }
3858:
3859: exit $EXIT_SUCCESS
3860: }
3861:
3862: $opt_help || {
3863: test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
3864: }
3865:
3866: func_mode_help ()
3867: {
3868: # We need to display help for each of the modes.
3869: case $opt_mode in
3870: "")
3871: # Generic help is extracted from the usage comments
3872: # at the start of this file.
3873: func_help
3874: ;;
3875:
3876: clean)
3877: $ECHO \
3878: "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
3879:
3880: Remove files from the build directory.
3881:
3882: RM is the name of the program to use to delete files associated with each FILE
3883: (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
3884: to RM.
3885:
3886: If FILE is a libtool library, object or program, all the files associated
3887: with it are deleted. Otherwise, only FILE itself is deleted using RM."
3888: ;;
3889:
3890: compile)
3891: $ECHO \
3892: "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
3893:
3894: Compile a source file into a libtool library object.
3895:
3896: This mode accepts the following additional options:
3897:
3898: -o OUTPUT-FILE set the output file name to OUTPUT-FILE
3899: -no-suppress do not suppress compiler output for multiple passes
3900: -prefer-pic try to build PIC objects only
3901: -prefer-non-pic try to build non-PIC objects only
3902: -shared do not build a '.o' file suitable for static linking
3903: -static only build a '.o' file suitable for static linking
1.2 ! ohara 3904: -Wc,FLAG
! 3905: -Xcompiler FLAG pass FLAG directly to the compiler
1.1 ohara 3906:
3907: COMPILE-COMMAND is a command to be used in creating a 'standard' object file
3908: from the given SOURCEFILE.
3909:
3910: The output file name is determined by removing the directory component from
3911: SOURCEFILE, then substituting the C source code suffix '.c' with the
3912: library object suffix, '.lo'."
3913: ;;
3914:
3915: execute)
3916: $ECHO \
3917: "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
3918:
3919: Automatically set library path, then run a program.
3920:
3921: This mode accepts the following additional options:
3922:
3923: -dlopen FILE add the directory containing FILE to the library path
3924:
3925: This mode sets the library path environment variable according to '-dlopen'
3926: flags.
3927:
3928: If any of the ARGS are libtool executable wrappers, then they are translated
3929: into their corresponding uninstalled binary, and any of their required library
3930: directories are added to the library path.
3931:
3932: Then, COMMAND is executed, with ARGS as arguments."
3933: ;;
3934:
3935: finish)
3936: $ECHO \
3937: "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
3938:
3939: Complete the installation of libtool libraries.
3940:
3941: Each LIBDIR is a directory that contains libtool libraries.
3942:
3943: The commands that this mode executes may require superuser privileges. Use
3944: the '--dry-run' option if you just want to see what would be executed."
3945: ;;
3946:
3947: install)
3948: $ECHO \
3949: "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
3950:
3951: Install executables or libraries.
3952:
3953: INSTALL-COMMAND is the installation command. The first component should be
3954: either the 'install' or 'cp' program.
3955:
3956: The following components of INSTALL-COMMAND are treated specially:
3957:
3958: -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
3959:
3960: The rest of the components are interpreted as arguments to that command (only
3961: BSD-compatible install options are recognized)."
3962: ;;
3963:
3964: link)
3965: $ECHO \
3966: "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
3967:
3968: Link object files or libraries together to form another library, or to
3969: create an executable program.
3970:
3971: LINK-COMMAND is a command using the C compiler that you would use to create
3972: a program from several object files.
3973:
3974: The following components of LINK-COMMAND are treated specially:
3975:
3976: -all-static do not do any dynamic linking at all
3977: -avoid-version do not add a version suffix if possible
3978: -bindir BINDIR specify path to binaries directory (for systems where
3979: libraries must be found in the PATH setting at runtime)
3980: -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime
3981: -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
3982: -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
3983: -export-symbols SYMFILE
3984: try to export only the symbols listed in SYMFILE
3985: -export-symbols-regex REGEX
3986: try to export only the symbols matching REGEX
3987: -LLIBDIR search LIBDIR for required installed libraries
3988: -lNAME OUTPUT-FILE requires the installed library libNAME
3989: -module build a library that can dlopened
3990: -no-fast-install disable the fast-install mode
3991: -no-install link a not-installable executable
3992: -no-undefined declare that a library does not refer to external symbols
3993: -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
3994: -objectlist FILE use a list of object files found in FILE to specify objects
3995: -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes)
3996: -precious-files-regex REGEX
3997: don't remove output files matching REGEX
3998: -release RELEASE specify package release information
3999: -rpath LIBDIR the created library will eventually be installed in LIBDIR
4000: -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
4001: -shared only do dynamic linking of libtool libraries
4002: -shrext SUFFIX override the standard shared library file extension
4003: -static do not do any dynamic linking of uninstalled libtool libraries
4004: -static-libtool-libs
4005: do not do any dynamic linking of libtool libraries
4006: -version-info CURRENT[:REVISION[:AGE]]
4007: specify library version info [each variable defaults to 0]
4008: -weak LIBNAME declare that the target provides the LIBNAME interface
4009: -Wc,FLAG
4010: -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
1.2 ! ohara 4011: -Wa,FLAG
! 4012: -Xassembler FLAG pass linker-specific FLAG directly to the assembler
1.1 ohara 4013: -Wl,FLAG
4014: -Xlinker FLAG pass linker-specific FLAG directly to the linker
4015: -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
4016:
4017: All other options (arguments beginning with '-') are ignored.
4018:
4019: Every other argument is treated as a filename. Files ending in '.la' are
4020: treated as uninstalled libtool libraries, other files are standard or library
4021: object files.
4022:
4023: If the OUTPUT-FILE ends in '.la', then a libtool library is created,
4024: only library objects ('.lo' files) may be specified, and '-rpath' is
4025: required, except when creating a convenience library.
4026:
4027: If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
4028: using 'ar' and 'ranlib', or on Windows using 'lib'.
4029:
4030: If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
4031: is created, otherwise an executable program is created."
4032: ;;
4033:
4034: uninstall)
4035: $ECHO \
4036: "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
4037:
4038: Remove libraries from an installation directory.
4039:
4040: RM is the name of the program to use to delete files associated with each FILE
4041: (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
4042: to RM.
4043:
4044: If FILE is a libtool library, all the files associated with it are deleted.
4045: Otherwise, only FILE itself is deleted using RM."
4046: ;;
4047:
4048: *)
4049: func_fatal_help "invalid operation mode '$opt_mode'"
4050: ;;
4051: esac
4052:
4053: echo
4054: $ECHO "Try '$progname --help' for more information about other modes."
4055: }
4056:
4057: # Now that we've collected a possible --mode arg, show help if necessary
4058: if $opt_help; then
4059: if test : = "$opt_help"; then
4060: func_mode_help
4061: else
4062: {
4063: func_help noexit
4064: for opt_mode in compile link execute install finish uninstall clean; do
4065: func_mode_help
4066: done
4067: } | $SED -n '1p; 2,$s/^Usage:/ or: /p'
4068: {
4069: func_help noexit
4070: for opt_mode in compile link execute install finish uninstall clean; do
4071: echo
4072: func_mode_help
4073: done
4074: } |
4075: $SED '1d
4076: /^When reporting/,/^Report/{
4077: H
4078: d
4079: }
4080: $x
4081: /information about other modes/d
4082: /more detailed .*MODE/d
4083: s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
4084: fi
4085: exit $?
4086: fi
4087:
4088:
4089: # func_mode_execute arg...
4090: func_mode_execute ()
4091: {
4092: $debug_cmd
4093:
4094: # The first argument is the command name.
4095: cmd=$nonopt
4096: test -z "$cmd" && \
4097: func_fatal_help "you must specify a COMMAND"
4098:
4099: # Handle -dlopen flags immediately.
4100: for file in $opt_dlopen; do
4101: test -f "$file" \
4102: || func_fatal_help "'$file' is not a file"
4103:
4104: dir=
4105: case $file in
4106: *.la)
4107: func_resolve_sysroot "$file"
4108: file=$func_resolve_sysroot_result
4109:
4110: # Check to see that this really is a libtool archive.
4111: func_lalib_unsafe_p "$file" \
4112: || func_fatal_help "'$lib' is not a valid libtool archive"
4113:
4114: # Read the libtool library.
4115: dlname=
4116: library_names=
4117: func_source "$file"
4118:
4119: # Skip this library if it cannot be dlopened.
4120: if test -z "$dlname"; then
4121: # Warn if it was a shared library.
4122: test -n "$library_names" && \
4123: func_warning "'$file' was not linked with '-export-dynamic'"
4124: continue
4125: fi
4126:
4127: func_dirname "$file" "" "."
4128: dir=$func_dirname_result
4129:
4130: if test -f "$dir/$objdir/$dlname"; then
4131: func_append dir "/$objdir"
4132: else
4133: if test ! -f "$dir/$dlname"; then
4134: func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
4135: fi
4136: fi
4137: ;;
4138:
4139: *.lo)
4140: # Just add the directory containing the .lo file.
4141: func_dirname "$file" "" "."
4142: dir=$func_dirname_result
4143: ;;
4144:
4145: *)
4146: func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
4147: continue
4148: ;;
4149: esac
4150:
4151: # Get the absolute pathname.
4152: absdir=`cd "$dir" && pwd`
4153: test -n "$absdir" && dir=$absdir
4154:
4155: # Now add the directory to shlibpath_var.
4156: if eval "test -z \"\$$shlibpath_var\""; then
4157: eval "$shlibpath_var=\"\$dir\""
4158: else
4159: eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
4160: fi
4161: done
4162:
4163: # This variable tells wrapper scripts just to set shlibpath_var
4164: # rather than running their programs.
4165: libtool_execute_magic=$magic
4166:
4167: # Check if any of the arguments is a wrapper script.
4168: args=
4169: for file
4170: do
4171: case $file in
4172: -* | *.la | *.lo ) ;;
4173: *)
4174: # Do a test to see if this is really a libtool program.
4175: if func_ltwrapper_script_p "$file"; then
4176: func_source "$file"
4177: # Transform arg to wrapped name.
4178: file=$progdir/$program
4179: elif func_ltwrapper_executable_p "$file"; then
4180: func_ltwrapper_scriptname "$file"
4181: func_source "$func_ltwrapper_scriptname_result"
4182: # Transform arg to wrapped name.
4183: file=$progdir/$program
4184: fi
4185: ;;
4186: esac
4187: # Quote arguments (to preserve shell metacharacters).
4188: func_append_quoted args "$file"
4189: done
4190:
4191: if $opt_dry_run; then
4192: # Display what would be done.
4193: if test -n "$shlibpath_var"; then
4194: eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
4195: echo "export $shlibpath_var"
4196: fi
4197: $ECHO "$cmd$args"
4198: exit $EXIT_SUCCESS
4199: else
4200: if test -n "$shlibpath_var"; then
4201: # Export the shlibpath_var.
4202: eval "export $shlibpath_var"
4203: fi
4204:
4205: # Restore saved environment variables
4206: for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
4207: do
4208: eval "if test \"\${save_$lt_var+set}\" = set; then
4209: $lt_var=\$save_$lt_var; export $lt_var
4210: else
4211: $lt_unset $lt_var
4212: fi"
4213: done
4214:
4215: # Now prepare to actually exec the command.
4216: exec_cmd=\$cmd$args
4217: fi
4218: }
4219:
4220: test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
4221:
4222:
4223: # func_mode_finish arg...
4224: func_mode_finish ()
4225: {
4226: $debug_cmd
4227:
4228: libs=
4229: libdirs=
4230: admincmds=
4231:
4232: for opt in "$nonopt" ${1+"$@"}
4233: do
4234: if test -d "$opt"; then
4235: func_append libdirs " $opt"
4236:
4237: elif test -f "$opt"; then
4238: if func_lalib_unsafe_p "$opt"; then
4239: func_append libs " $opt"
4240: else
4241: func_warning "'$opt' is not a valid libtool archive"
4242: fi
4243:
4244: else
4245: func_fatal_error "invalid argument '$opt'"
4246: fi
4247: done
4248:
4249: if test -n "$libs"; then
4250: if test -n "$lt_sysroot"; then
4251: sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
4252: sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
4253: else
4254: sysroot_cmd=
4255: fi
4256:
4257: # Remove sysroot references
4258: if $opt_dry_run; then
4259: for lib in $libs; do
4260: echo "removing references to $lt_sysroot and '=' prefixes from $lib"
4261: done
4262: else
4263: tmpdir=`func_mktempdir`
4264: for lib in $libs; do
4265: $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
4266: > $tmpdir/tmp-la
4267: mv -f $tmpdir/tmp-la $lib
4268: done
4269: ${RM}r "$tmpdir"
4270: fi
4271: fi
4272:
4273: if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4274: for libdir in $libdirs; do
4275: if test -n "$finish_cmds"; then
4276: # Do each command in the finish commands.
4277: func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
4278: '"$cmd"'"'
4279: fi
4280: if test -n "$finish_eval"; then
4281: # Do the single finish_eval.
4282: eval cmds=\"$finish_eval\"
4283: $opt_dry_run || eval "$cmds" || func_append admincmds "
4284: $cmds"
4285: fi
4286: done
4287: fi
4288:
4289: # Exit here if they wanted silent mode.
4290: $opt_quiet && exit $EXIT_SUCCESS
4291:
4292: if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4293: echo "----------------------------------------------------------------------"
4294: echo "Libraries have been installed in:"
4295: for libdir in $libdirs; do
4296: $ECHO " $libdir"
4297: done
4298: echo
4299: echo "If you ever happen to want to link against installed libraries"
4300: echo "in a given directory, LIBDIR, you must either use libtool, and"
4301: echo "specify the full pathname of the library, or use the '-LLIBDIR'"
4302: echo "flag during linking and do at least one of the following:"
4303: if test -n "$shlibpath_var"; then
4304: echo " - add LIBDIR to the '$shlibpath_var' environment variable"
4305: echo " during execution"
4306: fi
4307: if test -n "$runpath_var"; then
4308: echo " - add LIBDIR to the '$runpath_var' environment variable"
4309: echo " during linking"
4310: fi
4311: if test -n "$hardcode_libdir_flag_spec"; then
4312: libdir=LIBDIR
4313: eval flag=\"$hardcode_libdir_flag_spec\"
4314:
4315: $ECHO " - use the '$flag' linker flag"
4316: fi
4317: if test -n "$admincmds"; then
4318: $ECHO " - have your system administrator run these commands:$admincmds"
4319: fi
4320: if test -f /etc/ld.so.conf; then
4321: echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
4322: fi
4323: echo
4324:
4325: echo "See any operating system documentation about shared libraries for"
4326: case $host in
4327: solaris2.[6789]|solaris2.1[0-9])
4328: echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
4329: echo "pages."
4330: ;;
4331: *)
4332: echo "more information, such as the ld(1) and ld.so(8) manual pages."
4333: ;;
4334: esac
4335: echo "----------------------------------------------------------------------"
4336: fi
4337: exit $EXIT_SUCCESS
4338: }
4339:
4340: test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
4341:
4342:
4343: # func_mode_install arg...
4344: func_mode_install ()
4345: {
4346: $debug_cmd
4347:
4348: # There may be an optional sh(1) argument at the beginning of
4349: # install_prog (especially on Windows NT).
4350: if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
4351: # Allow the use of GNU shtool's install command.
4352: case $nonopt in *shtool*) :;; *) false;; esac
4353: then
4354: # Aesthetically quote it.
1.2 ! ohara 4355: func_quote_arg pretty "$nonopt"
! 4356: install_prog="$func_quote_arg_result "
1.1 ohara 4357: arg=$1
4358: shift
4359: else
4360: install_prog=
4361: arg=$nonopt
4362: fi
4363:
4364: # The real first argument should be the name of the installation program.
4365: # Aesthetically quote it.
1.2 ! ohara 4366: func_quote_arg pretty "$arg"
! 4367: func_append install_prog "$func_quote_arg_result"
1.1 ohara 4368: install_shared_prog=$install_prog
4369: case " $install_prog " in
4370: *[\\\ /]cp\ *) install_cp=: ;;
4371: *) install_cp=false ;;
4372: esac
4373:
4374: # We need to accept at least all the BSD install flags.
4375: dest=
4376: files=
4377: opts=
4378: prev=
4379: install_type=
4380: isdir=false
4381: stripme=
4382: no_mode=:
4383: for arg
4384: do
4385: arg2=
4386: if test -n "$dest"; then
4387: func_append files " $dest"
4388: dest=$arg
4389: continue
4390: fi
4391:
4392: case $arg in
4393: -d) isdir=: ;;
4394: -f)
4395: if $install_cp; then :; else
4396: prev=$arg
4397: fi
4398: ;;
4399: -g | -m | -o)
4400: prev=$arg
4401: ;;
4402: -s)
4403: stripme=" -s"
4404: continue
4405: ;;
4406: -*)
4407: ;;
4408: *)
4409: # If the previous option needed an argument, then skip it.
4410: if test -n "$prev"; then
4411: if test X-m = "X$prev" && test -n "$install_override_mode"; then
4412: arg2=$install_override_mode
4413: no_mode=false
4414: fi
4415: prev=
4416: else
4417: dest=$arg
4418: continue
4419: fi
4420: ;;
4421: esac
4422:
4423: # Aesthetically quote the argument.
1.2 ! ohara 4424: func_quote_arg pretty "$arg"
! 4425: func_append install_prog " $func_quote_arg_result"
1.1 ohara 4426: if test -n "$arg2"; then
1.2 ! ohara 4427: func_quote_arg pretty "$arg2"
1.1 ohara 4428: fi
1.2 ! ohara 4429: func_append install_shared_prog " $func_quote_arg_result"
1.1 ohara 4430: done
4431:
4432: test -z "$install_prog" && \
4433: func_fatal_help "you must specify an install program"
4434:
4435: test -n "$prev" && \
4436: func_fatal_help "the '$prev' option requires an argument"
4437:
4438: if test -n "$install_override_mode" && $no_mode; then
4439: if $install_cp; then :; else
1.2 ! ohara 4440: func_quote_arg pretty "$install_override_mode"
! 4441: func_append install_shared_prog " -m $func_quote_arg_result"
1.1 ohara 4442: fi
4443: fi
4444:
4445: if test -z "$files"; then
4446: if test -z "$dest"; then
4447: func_fatal_help "no file or destination specified"
4448: else
4449: func_fatal_help "you must specify a destination"
4450: fi
4451: fi
4452:
4453: # Strip any trailing slash from the destination.
4454: func_stripname '' '/' "$dest"
4455: dest=$func_stripname_result
4456:
4457: # Check to see that the destination is a directory.
4458: test -d "$dest" && isdir=:
4459: if $isdir; then
4460: destdir=$dest
4461: destname=
4462: else
4463: func_dirname_and_basename "$dest" "" "."
4464: destdir=$func_dirname_result
4465: destname=$func_basename_result
4466:
4467: # Not a directory, so check to see that there is only one file specified.
4468: set dummy $files; shift
4469: test "$#" -gt 1 && \
4470: func_fatal_help "'$dest' is not a directory"
4471: fi
4472: case $destdir in
4473: [\\/]* | [A-Za-z]:[\\/]*) ;;
4474: *)
4475: for file in $files; do
4476: case $file in
4477: *.lo) ;;
4478: *)
4479: func_fatal_help "'$destdir' must be an absolute directory name"
4480: ;;
4481: esac
4482: done
4483: ;;
4484: esac
4485:
4486: # This variable tells wrapper scripts just to set variables rather
4487: # than running their programs.
4488: libtool_install_magic=$magic
4489:
4490: staticlibs=
4491: future_libdirs=
4492: current_libdirs=
4493: for file in $files; do
4494:
4495: # Do each installation.
4496: case $file in
4497: *.$libext)
4498: # Do the static libraries later.
4499: func_append staticlibs " $file"
4500: ;;
4501:
4502: *.la)
4503: func_resolve_sysroot "$file"
4504: file=$func_resolve_sysroot_result
4505:
4506: # Check to see that this really is a libtool archive.
4507: func_lalib_unsafe_p "$file" \
4508: || func_fatal_help "'$file' is not a valid libtool archive"
4509:
4510: library_names=
4511: old_library=
4512: relink_command=
4513: func_source "$file"
4514:
4515: # Add the libdir to current_libdirs if it is the destination.
4516: if test "X$destdir" = "X$libdir"; then
4517: case "$current_libdirs " in
4518: *" $libdir "*) ;;
4519: *) func_append current_libdirs " $libdir" ;;
4520: esac
4521: else
4522: # Note the libdir as a future libdir.
4523: case "$future_libdirs " in
4524: *" $libdir "*) ;;
4525: *) func_append future_libdirs " $libdir" ;;
4526: esac
4527: fi
4528:
4529: func_dirname "$file" "/" ""
4530: dir=$func_dirname_result
4531: func_append dir "$objdir"
4532:
4533: if test -n "$relink_command"; then
4534: # Determine the prefix the user has applied to our future dir.
4535: inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
4536:
4537: # Don't allow the user to place us outside of our expected
4538: # location b/c this prevents finding dependent libraries that
4539: # are installed to the same prefix.
4540: # At present, this check doesn't affect windows .dll's that
4541: # are installed into $libdir/../bin (currently, that works fine)
4542: # but it's something to keep an eye on.
4543: test "$inst_prefix_dir" = "$destdir" && \
4544: func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
4545:
4546: if test -n "$inst_prefix_dir"; then
4547: # Stick the inst_prefix_dir data into the link command.
4548: relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
4549: else
4550: relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
4551: fi
4552:
4553: func_warning "relinking '$file'"
4554: func_show_eval "$relink_command" \
4555: 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
4556: fi
4557:
4558: # See the names of the shared library.
4559: set dummy $library_names; shift
4560: if test -n "$1"; then
4561: realname=$1
4562: shift
4563:
4564: srcname=$realname
4565: test -n "$relink_command" && srcname=${realname}T
4566:
4567: # Install the shared library and build the symlinks.
4568: func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
4569: 'exit $?'
4570: tstripme=$stripme
4571: case $host_os in
4572: cygwin* | mingw* | pw32* | cegcc*)
4573: case $realname in
4574: *.dll.a)
4575: tstripme=
4576: ;;
4577: esac
4578: ;;
4579: os2*)
4580: case $realname in
4581: *_dll.a)
4582: tstripme=
4583: ;;
4584: esac
4585: ;;
4586: esac
4587: if test -n "$tstripme" && test -n "$striplib"; then
4588: func_show_eval "$striplib $destdir/$realname" 'exit $?'
4589: fi
4590:
4591: if test "$#" -gt 0; then
4592: # Delete the old symlinks, and create new ones.
4593: # Try 'ln -sf' first, because the 'ln' binary might depend on
4594: # the symlink we replace! Solaris /bin/ln does not understand -f,
4595: # so we also need to try rm && ln -s.
4596: for linkname
4597: do
4598: test "$linkname" != "$realname" \
4599: && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
4600: done
4601: fi
4602:
4603: # Do each command in the postinstall commands.
4604: lib=$destdir/$realname
4605: func_execute_cmds "$postinstall_cmds" 'exit $?'
4606: fi
4607:
4608: # Install the pseudo-library for information purposes.
4609: func_basename "$file"
4610: name=$func_basename_result
4611: instname=$dir/${name}i
4612: func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
4613:
4614: # Maybe install the static library, too.
4615: test -n "$old_library" && func_append staticlibs " $dir/$old_library"
4616: ;;
4617:
4618: *.lo)
4619: # Install (i.e. copy) a libtool object.
4620:
4621: # Figure out destination file name, if it wasn't already specified.
4622: if test -n "$destname"; then
4623: destfile=$destdir/$destname
4624: else
4625: func_basename "$file"
4626: destfile=$func_basename_result
4627: destfile=$destdir/$destfile
4628: fi
4629:
4630: # Deduce the name of the destination old-style object file.
4631: case $destfile in
4632: *.lo)
4633: func_lo2o "$destfile"
4634: staticdest=$func_lo2o_result
4635: ;;
4636: *.$objext)
4637: staticdest=$destfile
4638: destfile=
4639: ;;
4640: *)
4641: func_fatal_help "cannot copy a libtool object to '$destfile'"
4642: ;;
4643: esac
4644:
4645: # Install the libtool object if requested.
4646: test -n "$destfile" && \
4647: func_show_eval "$install_prog $file $destfile" 'exit $?'
4648:
4649: # Install the old object if enabled.
4650: if test yes = "$build_old_libs"; then
4651: # Deduce the name of the old-style object file.
4652: func_lo2o "$file"
4653: staticobj=$func_lo2o_result
4654: func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
4655: fi
4656: exit $EXIT_SUCCESS
4657: ;;
4658:
4659: *)
4660: # Figure out destination file name, if it wasn't already specified.
4661: if test -n "$destname"; then
4662: destfile=$destdir/$destname
4663: else
4664: func_basename "$file"
4665: destfile=$func_basename_result
4666: destfile=$destdir/$destfile
4667: fi
4668:
4669: # If the file is missing, and there is a .exe on the end, strip it
4670: # because it is most likely a libtool script we actually want to
4671: # install
4672: stripped_ext=
4673: case $file in
4674: *.exe)
4675: if test ! -f "$file"; then
4676: func_stripname '' '.exe' "$file"
4677: file=$func_stripname_result
4678: stripped_ext=.exe
4679: fi
4680: ;;
4681: esac
4682:
4683: # Do a test to see if this is really a libtool program.
4684: case $host in
4685: *cygwin* | *mingw*)
4686: if func_ltwrapper_executable_p "$file"; then
4687: func_ltwrapper_scriptname "$file"
4688: wrapper=$func_ltwrapper_scriptname_result
4689: else
4690: func_stripname '' '.exe' "$file"
4691: wrapper=$func_stripname_result
4692: fi
4693: ;;
4694: *)
4695: wrapper=$file
4696: ;;
4697: esac
4698: if func_ltwrapper_script_p "$wrapper"; then
4699: notinst_deplibs=
4700: relink_command=
4701:
4702: func_source "$wrapper"
4703:
4704: # Check the variables that should have been set.
4705: test -z "$generated_by_libtool_version" && \
4706: func_fatal_error "invalid libtool wrapper script '$wrapper'"
4707:
4708: finalize=:
4709: for lib in $notinst_deplibs; do
4710: # Check to see that each library is installed.
4711: libdir=
4712: if test -f "$lib"; then
4713: func_source "$lib"
4714: fi
4715: libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
4716: if test -n "$libdir" && test ! -f "$libfile"; then
4717: func_warning "'$lib' has not been installed in '$libdir'"
4718: finalize=false
4719: fi
4720: done
4721:
4722: relink_command=
4723: func_source "$wrapper"
4724:
4725: outputname=
4726: if test no = "$fast_install" && test -n "$relink_command"; then
4727: $opt_dry_run || {
4728: if $finalize; then
4729: tmpdir=`func_mktempdir`
4730: func_basename "$file$stripped_ext"
4731: file=$func_basename_result
4732: outputname=$tmpdir/$file
4733: # Replace the output file specification.
4734: relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
4735:
4736: $opt_quiet || {
1.2 ! ohara 4737: func_quote_arg expand,pretty "$relink_command"
! 4738: eval "func_echo $func_quote_arg_result"
1.1 ohara 4739: }
4740: if eval "$relink_command"; then :
4741: else
4742: func_error "error: relink '$file' with the above command before installing it"
4743: $opt_dry_run || ${RM}r "$tmpdir"
4744: continue
4745: fi
4746: file=$outputname
4747: else
4748: func_warning "cannot relink '$file'"
4749: fi
4750: }
4751: else
4752: # Install the binary that we compiled earlier.
4753: file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
4754: fi
4755: fi
4756:
4757: # remove .exe since cygwin /usr/bin/install will append another
4758: # one anyway
4759: case $install_prog,$host in
4760: */usr/bin/install*,*cygwin*)
4761: case $file:$destfile in
4762: *.exe:*.exe)
4763: # this is ok
4764: ;;
4765: *.exe:*)
4766: destfile=$destfile.exe
4767: ;;
4768: *:*.exe)
4769: func_stripname '' '.exe' "$destfile"
4770: destfile=$func_stripname_result
4771: ;;
4772: esac
4773: ;;
4774: esac
4775: func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
4776: $opt_dry_run || if test -n "$outputname"; then
4777: ${RM}r "$tmpdir"
4778: fi
4779: ;;
4780: esac
4781: done
4782:
4783: for file in $staticlibs; do
4784: func_basename "$file"
4785: name=$func_basename_result
4786:
4787: # Set up the ranlib parameters.
4788: oldlib=$destdir/$name
4789: func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
4790: tool_oldlib=$func_to_tool_file_result
4791:
4792: func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
4793:
4794: if test -n "$stripme" && test -n "$old_striplib"; then
4795: func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
4796: fi
4797:
4798: # Do each command in the postinstall commands.
4799: func_execute_cmds "$old_postinstall_cmds" 'exit $?'
4800: done
4801:
4802: test -n "$future_libdirs" && \
4803: func_warning "remember to run '$progname --finish$future_libdirs'"
4804:
4805: if test -n "$current_libdirs"; then
4806: # Maybe just do a dry run.
4807: $opt_dry_run && current_libdirs=" -n$current_libdirs"
4808: exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
4809: else
4810: exit $EXIT_SUCCESS
4811: fi
4812: }
4813:
4814: test install = "$opt_mode" && func_mode_install ${1+"$@"}
4815:
4816:
4817: # func_generate_dlsyms outputname originator pic_p
4818: # Extract symbols from dlprefiles and create ${outputname}S.o with
4819: # a dlpreopen symbol table.
4820: func_generate_dlsyms ()
4821: {
4822: $debug_cmd
4823:
4824: my_outputname=$1
4825: my_originator=$2
4826: my_pic_p=${3-false}
4827: my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
4828: my_dlsyms=
4829:
4830: if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
4831: if test -n "$NM" && test -n "$global_symbol_pipe"; then
4832: my_dlsyms=${my_outputname}S.c
4833: else
4834: func_error "not configured to extract global symbols from dlpreopened files"
4835: fi
4836: fi
4837:
4838: if test -n "$my_dlsyms"; then
4839: case $my_dlsyms in
4840: "") ;;
4841: *.c)
4842: # Discover the nlist of each of the dlfiles.
4843: nlist=$output_objdir/$my_outputname.nm
4844:
4845: func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
4846:
4847: # Parse the name list into a source file.
4848: func_verbose "creating $output_objdir/$my_dlsyms"
4849:
4850: $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
4851: /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
4852: /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
4853:
4854: #ifdef __cplusplus
4855: extern \"C\" {
4856: #endif
4857:
4858: #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
4859: #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
4860: #endif
4861:
4862: /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
4863: #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
4864: /* DATA imports from DLLs on WIN32 can't be const, because runtime
4865: relocations are performed -- see ld's documentation on pseudo-relocs. */
4866: # define LT_DLSYM_CONST
4867: #elif defined __osf__
4868: /* This system does not cope well with relocations in const data. */
4869: # define LT_DLSYM_CONST
4870: #else
4871: # define LT_DLSYM_CONST const
4872: #endif
4873:
4874: #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
4875:
4876: /* External symbol declarations for the compiler. */\
4877: "
4878:
4879: if test yes = "$dlself"; then
4880: func_verbose "generating symbol list for '$output'"
4881:
4882: $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
4883:
4884: # Add our own program objects to the symbol list.
4885: progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
4886: for progfile in $progfiles; do
4887: func_to_tool_file "$progfile" func_convert_file_msys_to_w32
4888: func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
4889: $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
4890: done
4891:
4892: if test -n "$exclude_expsyms"; then
4893: $opt_dry_run || {
4894: eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4895: eval '$MV "$nlist"T "$nlist"'
4896: }
4897: fi
4898:
4899: if test -n "$export_symbols_regex"; then
4900: $opt_dry_run || {
4901: eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4902: eval '$MV "$nlist"T "$nlist"'
4903: }
4904: fi
4905:
4906: # Prepare the list of exported symbols
4907: if test -z "$export_symbols"; then
4908: export_symbols=$output_objdir/$outputname.exp
4909: $opt_dry_run || {
4910: $RM $export_symbols
4911: eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4912: case $host in
4913: *cygwin* | *mingw* | *cegcc* )
4914: eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4915: eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4916: ;;
4917: esac
4918: }
4919: else
4920: $opt_dry_run || {
4921: eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4922: eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4923: eval '$MV "$nlist"T "$nlist"'
4924: case $host in
4925: *cygwin* | *mingw* | *cegcc* )
4926: eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4927: eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4928: ;;
4929: esac
4930: }
4931: fi
4932: fi
4933:
4934: for dlprefile in $dlprefiles; do
4935: func_verbose "extracting global C symbols from '$dlprefile'"
4936: func_basename "$dlprefile"
4937: name=$func_basename_result
4938: case $host in
4939: *cygwin* | *mingw* | *cegcc* )
4940: # if an import library, we need to obtain dlname
4941: if func_win32_import_lib_p "$dlprefile"; then
4942: func_tr_sh "$dlprefile"
4943: eval "curr_lafile=\$libfile_$func_tr_sh_result"
4944: dlprefile_dlbasename=
4945: if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
4946: # Use subshell, to avoid clobbering current variable values
4947: dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
4948: if test -n "$dlprefile_dlname"; then
4949: func_basename "$dlprefile_dlname"
4950: dlprefile_dlbasename=$func_basename_result
4951: else
4952: # no lafile. user explicitly requested -dlpreopen <import library>.
4953: $sharedlib_from_linklib_cmd "$dlprefile"
4954: dlprefile_dlbasename=$sharedlib_from_linklib_result
4955: fi
4956: fi
4957: $opt_dry_run || {
4958: if test -n "$dlprefile_dlbasename"; then
4959: eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
4960: else
4961: func_warning "Could not compute DLL name from $name"
4962: eval '$ECHO ": $name " >> "$nlist"'
4963: fi
4964: func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4965: eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
4966: $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
4967: }
4968: else # not an import lib
4969: $opt_dry_run || {
4970: eval '$ECHO ": $name " >> "$nlist"'
4971: func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4972: eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4973: }
4974: fi
4975: ;;
4976: *)
4977: $opt_dry_run || {
4978: eval '$ECHO ": $name " >> "$nlist"'
4979: func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4980: eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4981: }
4982: ;;
4983: esac
4984: done
4985:
4986: $opt_dry_run || {
4987: # Make sure we have at least an empty file.
4988: test -f "$nlist" || : > "$nlist"
4989:
4990: if test -n "$exclude_expsyms"; then
4991: $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4992: $MV "$nlist"T "$nlist"
4993: fi
4994:
4995: # Try sorting and uniquifying the output.
4996: if $GREP -v "^: " < "$nlist" |
4997: if sort -k 3 </dev/null >/dev/null 2>&1; then
4998: sort -k 3
4999: else
5000: sort +2
5001: fi |
5002: uniq > "$nlist"S; then
5003: :
5004: else
5005: $GREP -v "^: " < "$nlist" > "$nlist"S
5006: fi
5007:
5008: if test -f "$nlist"S; then
5009: eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
5010: else
5011: echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
5012: fi
5013:
5014: func_show_eval '$RM "${nlist}I"'
5015: if test -n "$global_symbol_to_import"; then
5016: eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
5017: fi
5018:
5019: echo >> "$output_objdir/$my_dlsyms" "\
5020:
5021: /* The mapping between symbol names and symbols. */
5022: typedef struct {
5023: const char *name;
5024: void *address;
5025: } lt_dlsymlist;
5026: extern LT_DLSYM_CONST lt_dlsymlist
5027: lt_${my_prefix}_LTX_preloaded_symbols[];\
5028: "
5029:
5030: if test -s "$nlist"I; then
5031: echo >> "$output_objdir/$my_dlsyms" "\
5032: static void lt_syminit(void)
5033: {
5034: LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
5035: for (; symbol->name; ++symbol)
5036: {"
5037: $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
5038: echo >> "$output_objdir/$my_dlsyms" "\
5039: }
5040: }"
5041: fi
5042: echo >> "$output_objdir/$my_dlsyms" "\
5043: LT_DLSYM_CONST lt_dlsymlist
5044: lt_${my_prefix}_LTX_preloaded_symbols[] =
5045: { {\"$my_originator\", (void *) 0},"
5046:
5047: if test -s "$nlist"I; then
5048: echo >> "$output_objdir/$my_dlsyms" "\
5049: {\"@INIT@\", (void *) <_syminit},"
5050: fi
5051:
5052: case $need_lib_prefix in
5053: no)
5054: eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
5055: ;;
5056: *)
5057: eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
5058: ;;
5059: esac
5060: echo >> "$output_objdir/$my_dlsyms" "\
5061: {0, (void *) 0}
5062: };
5063:
5064: /* This works around a problem in FreeBSD linker */
5065: #ifdef FREEBSD_WORKAROUND
5066: static const void *lt_preloaded_setup() {
5067: return lt_${my_prefix}_LTX_preloaded_symbols;
5068: }
5069: #endif
5070:
5071: #ifdef __cplusplus
5072: }
5073: #endif\
5074: "
5075: } # !$opt_dry_run
5076:
5077: pic_flag_for_symtable=
5078: case "$compile_command " in
5079: *" -static "*) ;;
5080: *)
5081: case $host in
5082: # compiling the symbol table file with pic_flag works around
5083: # a FreeBSD bug that causes programs to crash when -lm is
5084: # linked before any other PIC object. But we must not use
5085: # pic_flag when linking with -static. The problem exists in
5086: # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
5087: *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
5088: pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
5089: *-*-hpux*)
5090: pic_flag_for_symtable=" $pic_flag" ;;
5091: *)
5092: $my_pic_p && pic_flag_for_symtable=" $pic_flag"
5093: ;;
5094: esac
5095: ;;
5096: esac
5097: symtab_cflags=
5098: for arg in $LTCFLAGS; do
5099: case $arg in
5100: -pie | -fpie | -fPIE) ;;
5101: *) func_append symtab_cflags " $arg" ;;
5102: esac
5103: done
5104:
5105: # Now compile the dynamic symbol file.
5106: func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
5107:
5108: # Clean up the generated files.
5109: func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
5110:
5111: # Transform the symbol file into the correct name.
5112: symfileobj=$output_objdir/${my_outputname}S.$objext
5113: case $host in
5114: *cygwin* | *mingw* | *cegcc* )
5115: if test -f "$output_objdir/$my_outputname.def"; then
5116: compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
5117: finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
5118: else
5119: compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5120: finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5121: fi
5122: ;;
5123: *)
5124: compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5125: finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5126: ;;
5127: esac
5128: ;;
5129: *)
5130: func_fatal_error "unknown suffix for '$my_dlsyms'"
5131: ;;
5132: esac
5133: else
5134: # We keep going just in case the user didn't refer to
5135: # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
5136: # really was required.
5137:
5138: # Nullify the symbol file.
5139: compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
5140: finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
5141: fi
5142: }
5143:
5144: # func_cygming_gnu_implib_p ARG
5145: # This predicate returns with zero status (TRUE) if
5146: # ARG is a GNU/binutils-style import library. Returns
5147: # with nonzero status (FALSE) otherwise.
5148: func_cygming_gnu_implib_p ()
5149: {
5150: $debug_cmd
5151:
5152: func_to_tool_file "$1" func_convert_file_msys_to_w32
5153: 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)$'`
5154: test -n "$func_cygming_gnu_implib_tmp"
5155: }
5156:
5157: # func_cygming_ms_implib_p ARG
5158: # This predicate returns with zero status (TRUE) if
5159: # ARG is an MS-style import library. Returns
5160: # with nonzero status (FALSE) otherwise.
5161: func_cygming_ms_implib_p ()
5162: {
5163: $debug_cmd
5164:
5165: func_to_tool_file "$1" func_convert_file_msys_to_w32
5166: func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
5167: test -n "$func_cygming_ms_implib_tmp"
5168: }
5169:
5170: # func_win32_libid arg
5171: # return the library type of file 'arg'
5172: #
5173: # Need a lot of goo to handle *both* DLLs and import libs
5174: # Has to be a shell function in order to 'eat' the argument
5175: # that is supplied when $file_magic_command is called.
5176: # Despite the name, also deal with 64 bit binaries.
5177: func_win32_libid ()
5178: {
5179: $debug_cmd
5180:
5181: win32_libid_type=unknown
5182: win32_fileres=`file -L $1 2>/dev/null`
5183: case $win32_fileres in
5184: *ar\ archive\ import\ library*) # definitely import
5185: win32_libid_type="x86 archive import"
5186: ;;
5187: *ar\ archive*) # could be an import, or static
5188: # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
5189: if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
5190: $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
5191: case $nm_interface in
5192: "MS dumpbin")
5193: if func_cygming_ms_implib_p "$1" ||
5194: func_cygming_gnu_implib_p "$1"
5195: then
5196: win32_nmres=import
5197: else
5198: win32_nmres=
5199: fi
5200: ;;
5201: *)
5202: func_to_tool_file "$1" func_convert_file_msys_to_w32
5203: win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
5204: $SED -n -e '
5205: 1,100{
5206: / I /{
5207: s|.*|import|
5208: p
5209: q
5210: }
5211: }'`
5212: ;;
5213: esac
5214: case $win32_nmres in
5215: import*) win32_libid_type="x86 archive import";;
5216: *) win32_libid_type="x86 archive static";;
5217: esac
5218: fi
5219: ;;
5220: *DLL*)
5221: win32_libid_type="x86 DLL"
5222: ;;
5223: *executable*) # but shell scripts are "executable" too...
5224: case $win32_fileres in
5225: *MS\ Windows\ PE\ Intel*)
5226: win32_libid_type="x86 DLL"
5227: ;;
5228: esac
5229: ;;
5230: esac
5231: $ECHO "$win32_libid_type"
5232: }
5233:
5234: # func_cygming_dll_for_implib ARG
5235: #
5236: # Platform-specific function to extract the
5237: # name of the DLL associated with the specified
5238: # import library ARG.
5239: # Invoked by eval'ing the libtool variable
5240: # $sharedlib_from_linklib_cmd
5241: # Result is available in the variable
5242: # $sharedlib_from_linklib_result
5243: func_cygming_dll_for_implib ()
5244: {
5245: $debug_cmd
5246:
5247: sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
5248: }
5249:
5250: # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
5251: #
5252: # The is the core of a fallback implementation of a
5253: # platform-specific function to extract the name of the
5254: # DLL associated with the specified import library LIBNAME.
5255: #
5256: # SECTION_NAME is either .idata$6 or .idata$7, depending
5257: # on the platform and compiler that created the implib.
5258: #
5259: # Echos the name of the DLL associated with the
5260: # specified import library.
5261: func_cygming_dll_for_implib_fallback_core ()
5262: {
5263: $debug_cmd
5264:
5265: match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
5266: $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
5267: $SED '/^Contents of section '"$match_literal"':/{
5268: # Place marker at beginning of archive member dllname section
5269: s/.*/====MARK====/
5270: p
5271: d
5272: }
5273: # These lines can sometimes be longer than 43 characters, but
5274: # are always uninteresting
5275: /:[ ]*file format pe[i]\{,1\}-/d
5276: /^In archive [^:]*:/d
5277: # Ensure marker is printed
5278: /^====MARK====/p
5279: # Remove all lines with less than 43 characters
5280: /^.\{43\}/!d
5281: # From remaining lines, remove first 43 characters
5282: s/^.\{43\}//' |
5283: $SED -n '
5284: # Join marker and all lines until next marker into a single line
5285: /^====MARK====/ b para
5286: H
5287: $ b para
5288: b
5289: :para
5290: x
5291: s/\n//g
5292: # Remove the marker
5293: s/^====MARK====//
5294: # Remove trailing dots and whitespace
5295: s/[\. \t]*$//
5296: # Print
5297: /./p' |
5298: # we now have a list, one entry per line, of the stringified
5299: # contents of the appropriate section of all members of the
5300: # archive that possess that section. Heuristic: eliminate
5301: # all those that have a first or second character that is
5302: # a '.' (that is, objdump's representation of an unprintable
5303: # character.) This should work for all archives with less than
5304: # 0x302f exports -- but will fail for DLLs whose name actually
5305: # begins with a literal '.' or a single character followed by
5306: # a '.'.
5307: #
5308: # Of those that remain, print the first one.
5309: $SED -e '/^\./d;/^.\./d;q'
5310: }
5311:
5312: # func_cygming_dll_for_implib_fallback ARG
5313: # Platform-specific function to extract the
5314: # name of the DLL associated with the specified
5315: # import library ARG.
5316: #
5317: # This fallback implementation is for use when $DLLTOOL
5318: # does not support the --identify-strict option.
5319: # Invoked by eval'ing the libtool variable
5320: # $sharedlib_from_linklib_cmd
5321: # Result is available in the variable
5322: # $sharedlib_from_linklib_result
5323: func_cygming_dll_for_implib_fallback ()
5324: {
5325: $debug_cmd
5326:
5327: if func_cygming_gnu_implib_p "$1"; then
5328: # binutils import library
5329: sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
5330: elif func_cygming_ms_implib_p "$1"; then
5331: # ms-generated import library
5332: sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
5333: else
5334: # unknown
5335: sharedlib_from_linklib_result=
5336: fi
5337: }
5338:
5339:
5340: # func_extract_an_archive dir oldlib
5341: func_extract_an_archive ()
5342: {
5343: $debug_cmd
5344:
5345: f_ex_an_ar_dir=$1; shift
5346: f_ex_an_ar_oldlib=$1
5347: if test yes = "$lock_old_archive_extraction"; then
5348: lockfile=$f_ex_an_ar_oldlib.lock
5349: until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
5350: func_echo "Waiting for $lockfile to be removed"
5351: sleep 2
5352: done
5353: fi
5354: func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
5355: 'stat=$?; rm -f "$lockfile"; exit $stat'
5356: if test yes = "$lock_old_archive_extraction"; then
5357: $opt_dry_run || rm -f "$lockfile"
5358: fi
5359: if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
5360: :
5361: else
5362: func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
5363: fi
5364: }
5365:
5366:
5367: # func_extract_archives gentop oldlib ...
5368: func_extract_archives ()
5369: {
5370: $debug_cmd
5371:
5372: my_gentop=$1; shift
5373: my_oldlibs=${1+"$@"}
5374: my_oldobjs=
5375: my_xlib=
5376: my_xabs=
5377: my_xdir=
5378:
5379: for my_xlib in $my_oldlibs; do
5380: # Extract the objects.
5381: case $my_xlib in
5382: [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
5383: *) my_xabs=`pwd`"/$my_xlib" ;;
5384: esac
5385: func_basename "$my_xlib"
5386: my_xlib=$func_basename_result
5387: my_xlib_u=$my_xlib
5388: while :; do
5389: case " $extracted_archives " in
5390: *" $my_xlib_u "*)
5391: func_arith $extracted_serial + 1
5392: extracted_serial=$func_arith_result
5393: my_xlib_u=lt$extracted_serial-$my_xlib ;;
5394: *) break ;;
5395: esac
5396: done
5397: extracted_archives="$extracted_archives $my_xlib_u"
5398: my_xdir=$my_gentop/$my_xlib_u
5399:
5400: func_mkdir_p "$my_xdir"
5401:
5402: case $host in
5403: *-darwin*)
5404: func_verbose "Extracting $my_xabs"
5405: # Do not bother doing anything if just a dry run
5406: $opt_dry_run || {
5407: darwin_orig_dir=`pwd`
5408: cd $my_xdir || exit $?
5409: darwin_archive=$my_xabs
5410: darwin_curdir=`pwd`
5411: func_basename "$darwin_archive"
5412: darwin_base_archive=$func_basename_result
5413: darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
5414: if test -n "$darwin_arches"; then
5415: darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
5416: darwin_arch=
5417: func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
5418: for darwin_arch in $darwin_arches; do
5419: func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
5420: $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
5421: cd "unfat-$$/$darwin_base_archive-$darwin_arch"
5422: func_extract_an_archive "`pwd`" "$darwin_base_archive"
5423: cd "$darwin_curdir"
5424: $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
5425: done # $darwin_arches
5426: ## Okay now we've a bunch of thin objects, gotta fatten them up :)
5427: darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
5428: darwin_file=
5429: darwin_files=
5430: for darwin_file in $darwin_filelist; do
5431: darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
5432: $LIPO -create -output "$darwin_file" $darwin_files
5433: done # $darwin_filelist
5434: $RM -rf unfat-$$
5435: cd "$darwin_orig_dir"
5436: else
5437: cd $darwin_orig_dir
5438: func_extract_an_archive "$my_xdir" "$my_xabs"
5439: fi # $darwin_arches
5440: } # !$opt_dry_run
5441: ;;
5442: *)
5443: func_extract_an_archive "$my_xdir" "$my_xabs"
5444: ;;
5445: esac
5446: my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
5447: done
5448:
5449: func_extract_archives_result=$my_oldobjs
5450: }
5451:
5452:
5453: # func_emit_wrapper [arg=no]
5454: #
5455: # Emit a libtool wrapper script on stdout.
5456: # Don't directly open a file because we may want to
5457: # incorporate the script contents within a cygwin/mingw
5458: # wrapper executable. Must ONLY be called from within
5459: # func_mode_link because it depends on a number of variables
5460: # set therein.
5461: #
5462: # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
5463: # variable will take. If 'yes', then the emitted script
5464: # will assume that the directory where it is stored is
5465: # the $objdir directory. This is a cygwin/mingw-specific
5466: # behavior.
5467: func_emit_wrapper ()
5468: {
5469: func_emit_wrapper_arg1=${1-no}
5470:
5471: $ECHO "\
5472: #! $SHELL
5473:
5474: # $output - temporary wrapper script for $objdir/$outputname
5475: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5476: #
5477: # The $output program cannot be directly executed until all the libtool
5478: # libraries that it depends on are installed.
5479: #
5480: # This wrapper script should never be moved out of the build directory.
5481: # If it is, it will not operate correctly.
5482:
5483: # Sed substitution that helps us do robust quoting. It backslashifies
5484: # metacharacters that are still active within double-quoted strings.
5485: sed_quote_subst='$sed_quote_subst'
5486:
5487: # Be Bourne compatible
5488: if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5489: emulate sh
5490: NULLCMD=:
5491: # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5492: # is contrary to our usage. Disable this feature.
5493: alias -g '\${1+\"\$@\"}'='\"\$@\"'
5494: setopt NO_GLOB_SUBST
5495: else
5496: case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5497: fi
5498: BIN_SH=xpg4; export BIN_SH # for Tru64
5499: DUALCASE=1; export DUALCASE # for MKS sh
5500:
5501: # The HP-UX ksh and POSIX shell print the target directory to stdout
5502: # if CDPATH is set.
5503: (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5504:
5505: relink_command=\"$relink_command\"
5506:
5507: # This environment variable determines our operation mode.
5508: if test \"\$libtool_install_magic\" = \"$magic\"; then
5509: # install mode needs the following variables:
5510: generated_by_libtool_version='$macro_version'
5511: notinst_deplibs='$notinst_deplibs'
5512: else
5513: # When we are sourced in execute mode, \$file and \$ECHO are already set.
5514: if test \"\$libtool_execute_magic\" != \"$magic\"; then
5515: file=\"\$0\""
5516:
1.2 ! ohara 5517: func_quote_arg pretty "$ECHO"
! 5518: qECHO=$func_quote_arg_result
1.1 ohara 5519: $ECHO "\
5520:
5521: # A function that is used when there is no print builtin or printf.
5522: func_fallback_echo ()
5523: {
5524: eval 'cat <<_LTECHO_EOF
5525: \$1
5526: _LTECHO_EOF'
5527: }
1.2 ! ohara 5528: ECHO=$qECHO
1.1 ohara 5529: fi
5530:
5531: # Very basic option parsing. These options are (a) specific to
5532: # the libtool wrapper, (b) are identical between the wrapper
5533: # /script/ and the wrapper /executable/ that is used only on
5534: # windows platforms, and (c) all begin with the string "--lt-"
5535: # (application programs are unlikely to have options that match
5536: # this pattern).
5537: #
5538: # There are only two supported options: --lt-debug and
5539: # --lt-dump-script. There is, deliberately, no --lt-help.
5540: #
5541: # The first argument to this parsing function should be the
5542: # script's $0 value, followed by "$@".
5543: lt_option_debug=
5544: func_parse_lt_options ()
5545: {
5546: lt_script_arg0=\$0
5547: shift
5548: for lt_opt
5549: do
5550: case \"\$lt_opt\" in
5551: --lt-debug) lt_option_debug=1 ;;
5552: --lt-dump-script)
5553: lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
5554: test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
5555: lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
5556: cat \"\$lt_dump_D/\$lt_dump_F\"
5557: exit 0
5558: ;;
5559: --lt-*)
5560: \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
5561: exit 1
5562: ;;
5563: esac
5564: done
5565:
5566: # Print the debug banner immediately:
5567: if test -n \"\$lt_option_debug\"; then
5568: echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
5569: fi
5570: }
5571:
5572: # Used when --lt-debug. Prints its arguments to stdout
5573: # (redirection is the responsibility of the caller)
5574: func_lt_dump_args ()
5575: {
5576: lt_dump_args_N=1;
5577: for lt_arg
5578: do
5579: \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
5580: lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
5581: done
5582: }
5583:
5584: # Core function for launching the target application
5585: func_exec_program_core ()
5586: {
5587: "
5588: case $host in
5589: # Backslashes separate directories on plain windows
5590: *-*-mingw | *-*-os2* | *-cegcc*)
5591: $ECHO "\
5592: if test -n \"\$lt_option_debug\"; then
5593: \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
5594: func_lt_dump_args \${1+\"\$@\"} 1>&2
5595: fi
5596: exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5597: "
5598: ;;
5599:
5600: *)
5601: $ECHO "\
5602: if test -n \"\$lt_option_debug\"; then
5603: \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
5604: func_lt_dump_args \${1+\"\$@\"} 1>&2
5605: fi
5606: exec \"\$progdir/\$program\" \${1+\"\$@\"}
5607: "
5608: ;;
5609: esac
5610: $ECHO "\
5611: \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
5612: exit 1
5613: }
5614:
5615: # A function to encapsulate launching the target application
5616: # Strips options in the --lt-* namespace from \$@ and
5617: # launches target application with the remaining arguments.
5618: func_exec_program ()
5619: {
5620: case \" \$* \" in
5621: *\\ --lt-*)
5622: for lt_wr_arg
5623: do
5624: case \$lt_wr_arg in
5625: --lt-*) ;;
5626: *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
5627: esac
5628: shift
5629: done ;;
5630: esac
5631: func_exec_program_core \${1+\"\$@\"}
5632: }
5633:
5634: # Parse options
5635: func_parse_lt_options \"\$0\" \${1+\"\$@\"}
5636:
5637: # Find the directory that this script lives in.
5638: thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
5639: test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5640:
5641: # Follow symbolic links until we get to the real thisdir.
5642: file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
5643: while test -n \"\$file\"; do
5644: destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
5645:
5646: # If there was a directory component, then change thisdir.
5647: if test \"x\$destdir\" != \"x\$file\"; then
5648: case \"\$destdir\" in
5649: [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5650: *) thisdir=\"\$thisdir/\$destdir\" ;;
5651: esac
5652: fi
5653:
5654: file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
5655: file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
5656: done
5657:
5658: # Usually 'no', except on cygwin/mingw when embedded into
5659: # the cwrapper.
5660: WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
5661: if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
5662: # special case for '.'
5663: if test \"\$thisdir\" = \".\"; then
5664: thisdir=\`pwd\`
5665: fi
5666: # remove .libs from thisdir
5667: case \"\$thisdir\" in
5668: *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
5669: $objdir ) thisdir=. ;;
5670: esac
5671: fi
5672:
5673: # Try to get the absolute directory name.
5674: absdir=\`cd \"\$thisdir\" && pwd\`
5675: test -n \"\$absdir\" && thisdir=\"\$absdir\"
5676: "
5677:
5678: if test yes = "$fast_install"; then
5679: $ECHO "\
5680: program=lt-'$outputname'$exeext
5681: progdir=\"\$thisdir/$objdir\"
5682:
5683: if test ! -f \"\$progdir/\$program\" ||
5684: { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
5685: test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5686:
5687: file=\"\$\$-\$program\"
5688:
5689: if test ! -d \"\$progdir\"; then
5690: $MKDIR \"\$progdir\"
5691: else
5692: $RM \"\$progdir/\$file\"
5693: fi"
5694:
5695: $ECHO "\
5696:
5697: # relink executable if necessary
5698: if test -n \"\$relink_command\"; then
5699: if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5700: else
5701: \$ECHO \"\$relink_command_output\" >&2
5702: $RM \"\$progdir/\$file\"
5703: exit 1
5704: fi
5705: fi
5706:
5707: $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5708: { $RM \"\$progdir/\$program\";
5709: $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5710: $RM \"\$progdir/\$file\"
5711: fi"
5712: else
5713: $ECHO "\
5714: program='$outputname'
5715: progdir=\"\$thisdir/$objdir\"
5716: "
5717: fi
5718:
5719: $ECHO "\
5720:
5721: if test -f \"\$progdir/\$program\"; then"
5722:
5723: # fixup the dll searchpath if we need to.
5724: #
5725: # Fix the DLL searchpath if we need to. Do this before prepending
5726: # to shlibpath, because on Windows, both are PATH and uninstalled
5727: # libraries must come first.
5728: if test -n "$dllsearchpath"; then
5729: $ECHO "\
5730: # Add the dll search path components to the executable PATH
5731: PATH=$dllsearchpath:\$PATH
5732: "
5733: fi
5734:
5735: # Export our shlibpath_var if we have one.
5736: if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5737: $ECHO "\
5738: # Add our own library path to $shlibpath_var
5739: $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5740:
5741: # Some systems cannot cope with colon-terminated $shlibpath_var
5742: # The second colon is a workaround for a bug in BeOS R4 sed
5743: $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
5744:
5745: export $shlibpath_var
5746: "
5747: fi
5748:
5749: $ECHO "\
5750: if test \"\$libtool_execute_magic\" != \"$magic\"; then
5751: # Run the actual program with our arguments.
5752: func_exec_program \${1+\"\$@\"}
5753: fi
5754: else
5755: # The program doesn't exist.
5756: \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
5757: \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
5758: \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
5759: exit 1
5760: fi
5761: fi\
5762: "
5763: }
5764:
5765:
5766: # func_emit_cwrapperexe_src
5767: # emit the source code for a wrapper executable on stdout
5768: # Must ONLY be called from within func_mode_link because
5769: # it depends on a number of variable set therein.
5770: func_emit_cwrapperexe_src ()
5771: {
5772: cat <<EOF
5773:
5774: /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
5775: Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5776:
5777: The $output program cannot be directly executed until all the libtool
5778: libraries that it depends on are installed.
5779:
5780: This wrapper executable should never be moved out of the build directory.
5781: If it is, it will not operate correctly.
5782: */
5783: EOF
5784: cat <<"EOF"
5785: #ifdef _MSC_VER
5786: # define _CRT_SECURE_NO_DEPRECATE 1
5787: #endif
5788: #include <stdio.h>
5789: #include <stdlib.h>
5790: #ifdef _MSC_VER
5791: # include <direct.h>
5792: # include <process.h>
5793: # include <io.h>
5794: #else
5795: # include <unistd.h>
5796: # include <stdint.h>
5797: # ifdef __CYGWIN__
5798: # include <io.h>
5799: # endif
5800: #endif
5801: #include <malloc.h>
5802: #include <stdarg.h>
5803: #include <assert.h>
5804: #include <string.h>
5805: #include <ctype.h>
5806: #include <errno.h>
5807: #include <fcntl.h>
5808: #include <sys/stat.h>
5809:
5810: #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
5811:
5812: /* declarations of non-ANSI functions */
5813: #if defined __MINGW32__
5814: # ifdef __STRICT_ANSI__
5815: int _putenv (const char *);
5816: # endif
5817: #elif defined __CYGWIN__
5818: # ifdef __STRICT_ANSI__
5819: char *realpath (const char *, char *);
5820: int putenv (char *);
5821: int setenv (const char *, const char *, int);
5822: # endif
5823: /* #elif defined other_platform || defined ... */
5824: #endif
5825:
5826: /* portability defines, excluding path handling macros */
5827: #if defined _MSC_VER
5828: # define setmode _setmode
5829: # define stat _stat
5830: # define chmod _chmod
5831: # define getcwd _getcwd
5832: # define putenv _putenv
5833: # define S_IXUSR _S_IEXEC
5834: #elif defined __MINGW32__
5835: # define setmode _setmode
5836: # define stat _stat
5837: # define chmod _chmod
5838: # define getcwd _getcwd
5839: # define putenv _putenv
5840: #elif defined __CYGWIN__
5841: # define HAVE_SETENV
5842: # define FOPEN_WB "wb"
5843: /* #elif defined other platforms ... */
5844: #endif
5845:
5846: #if defined PATH_MAX
5847: # define LT_PATHMAX PATH_MAX
5848: #elif defined MAXPATHLEN
5849: # define LT_PATHMAX MAXPATHLEN
5850: #else
5851: # define LT_PATHMAX 1024
5852: #endif
5853:
5854: #ifndef S_IXOTH
5855: # define S_IXOTH 0
5856: #endif
5857: #ifndef S_IXGRP
5858: # define S_IXGRP 0
5859: #endif
5860:
5861: /* path handling portability macros */
5862: #ifndef DIR_SEPARATOR
5863: # define DIR_SEPARATOR '/'
5864: # define PATH_SEPARATOR ':'
5865: #endif
5866:
5867: #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
5868: defined __OS2__
5869: # define HAVE_DOS_BASED_FILE_SYSTEM
5870: # define FOPEN_WB "wb"
5871: # ifndef DIR_SEPARATOR_2
5872: # define DIR_SEPARATOR_2 '\\'
5873: # endif
5874: # ifndef PATH_SEPARATOR_2
5875: # define PATH_SEPARATOR_2 ';'
5876: # endif
5877: #endif
5878:
5879: #ifndef DIR_SEPARATOR_2
5880: # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5881: #else /* DIR_SEPARATOR_2 */
5882: # define IS_DIR_SEPARATOR(ch) \
5883: (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
5884: #endif /* DIR_SEPARATOR_2 */
5885:
5886: #ifndef PATH_SEPARATOR_2
5887: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5888: #else /* PATH_SEPARATOR_2 */
5889: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5890: #endif /* PATH_SEPARATOR_2 */
5891:
5892: #ifndef FOPEN_WB
5893: # define FOPEN_WB "w"
5894: #endif
5895: #ifndef _O_BINARY
5896: # define _O_BINARY 0
5897: #endif
5898:
5899: #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5900: #define XFREE(stale) do { \
5901: if (stale) { free (stale); stale = 0; } \
5902: } while (0)
5903:
5904: #if defined LT_DEBUGWRAPPER
5905: static int lt_debug = 1;
5906: #else
5907: static int lt_debug = 0;
5908: #endif
5909:
5910: const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
5911:
5912: void *xmalloc (size_t num);
5913: char *xstrdup (const char *string);
5914: const char *base_name (const char *name);
5915: char *find_executable (const char *wrapper);
5916: char *chase_symlinks (const char *pathspec);
5917: int make_executable (const char *path);
5918: int check_executable (const char *path);
5919: char *strendzap (char *str, const char *pat);
5920: void lt_debugprintf (const char *file, int line, const char *fmt, ...);
5921: void lt_fatal (const char *file, int line, const char *message, ...);
5922: static const char *nonnull (const char *s);
5923: static const char *nonempty (const char *s);
5924: void lt_setenv (const char *name, const char *value);
5925: char *lt_extend_str (const char *orig_value, const char *add, int to_end);
5926: void lt_update_exe_path (const char *name, const char *value);
5927: void lt_update_lib_path (const char *name, const char *value);
5928: char **prepare_spawn (char **argv);
5929: void lt_dump_script (FILE *f);
5930: EOF
5931:
5932: cat <<EOF
5933: #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
5934: # define externally_visible volatile
5935: #else
5936: # define externally_visible __attribute__((externally_visible)) volatile
5937: #endif
5938: externally_visible const char * MAGIC_EXE = "$magic_exe";
5939: const char * LIB_PATH_VARNAME = "$shlibpath_var";
5940: EOF
5941:
5942: if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5943: func_to_host_path "$temp_rpath"
5944: cat <<EOF
5945: const char * LIB_PATH_VALUE = "$func_to_host_path_result";
5946: EOF
5947: else
5948: cat <<"EOF"
5949: const char * LIB_PATH_VALUE = "";
5950: EOF
5951: fi
5952:
5953: if test -n "$dllsearchpath"; then
5954: func_to_host_path "$dllsearchpath:"
5955: cat <<EOF
5956: const char * EXE_PATH_VARNAME = "PATH";
5957: const char * EXE_PATH_VALUE = "$func_to_host_path_result";
5958: EOF
5959: else
5960: cat <<"EOF"
5961: const char * EXE_PATH_VARNAME = "";
5962: const char * EXE_PATH_VALUE = "";
5963: EOF
5964: fi
5965:
5966: if test yes = "$fast_install"; then
5967: cat <<EOF
5968: const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
5969: EOF
5970: else
5971: cat <<EOF
5972: const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
5973: EOF
5974: fi
5975:
5976:
5977: cat <<"EOF"
5978:
5979: #define LTWRAPPER_OPTION_PREFIX "--lt-"
5980:
5981: static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
5982: static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
5983: static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
5984:
5985: int
5986: main (int argc, char *argv[])
5987: {
5988: char **newargz;
5989: int newargc;
5990: char *tmp_pathspec;
5991: char *actual_cwrapper_path;
5992: char *actual_cwrapper_name;
5993: char *target_name;
5994: char *lt_argv_zero;
5995: int rval = 127;
5996:
5997: int i;
5998:
5999: program_name = (char *) xstrdup (base_name (argv[0]));
6000: newargz = XMALLOC (char *, (size_t) argc + 1);
6001:
6002: /* very simple arg parsing; don't want to rely on getopt
6003: * also, copy all non cwrapper options to newargz, except
6004: * argz[0], which is handled differently
6005: */
6006: newargc=0;
6007: for (i = 1; i < argc; i++)
6008: {
6009: if (STREQ (argv[i], dumpscript_opt))
6010: {
6011: EOF
6012: case $host in
6013: *mingw* | *cygwin* )
6014: # make stdout use "unix" line endings
6015: echo " setmode(1,_O_BINARY);"
6016: ;;
6017: esac
6018:
6019: cat <<"EOF"
6020: lt_dump_script (stdout);
6021: return 0;
6022: }
6023: if (STREQ (argv[i], debug_opt))
6024: {
6025: lt_debug = 1;
6026: continue;
6027: }
6028: if (STREQ (argv[i], ltwrapper_option_prefix))
6029: {
6030: /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
6031: namespace, but it is not one of the ones we know about and
6032: have already dealt with, above (inluding dump-script), then
6033: report an error. Otherwise, targets might begin to believe
6034: they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
6035: namespace. The first time any user complains about this, we'll
6036: need to make LTWRAPPER_OPTION_PREFIX a configure-time option
6037: or a configure.ac-settable value.
6038: */
6039: lt_fatal (__FILE__, __LINE__,
6040: "unrecognized %s option: '%s'",
6041: ltwrapper_option_prefix, argv[i]);
6042: }
6043: /* otherwise ... */
6044: newargz[++newargc] = xstrdup (argv[i]);
6045: }
6046: newargz[++newargc] = NULL;
6047:
6048: EOF
6049: cat <<EOF
6050: /* The GNU banner must be the first non-error debug message */
6051: lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
6052: EOF
6053: cat <<"EOF"
6054: lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
6055: lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
6056:
6057: tmp_pathspec = find_executable (argv[0]);
6058: if (tmp_pathspec == NULL)
6059: lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
6060: lt_debugprintf (__FILE__, __LINE__,
6061: "(main) found exe (before symlink chase) at: %s\n",
6062: tmp_pathspec);
6063:
6064: actual_cwrapper_path = chase_symlinks (tmp_pathspec);
6065: lt_debugprintf (__FILE__, __LINE__,
6066: "(main) found exe (after symlink chase) at: %s\n",
6067: actual_cwrapper_path);
6068: XFREE (tmp_pathspec);
6069:
6070: actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
6071: strendzap (actual_cwrapper_path, actual_cwrapper_name);
6072:
6073: /* wrapper name transforms */
6074: strendzap (actual_cwrapper_name, ".exe");
6075: tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
6076: XFREE (actual_cwrapper_name);
6077: actual_cwrapper_name = tmp_pathspec;
6078: tmp_pathspec = 0;
6079:
6080: /* target_name transforms -- use actual target program name; might have lt- prefix */
6081: target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
6082: strendzap (target_name, ".exe");
6083: tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
6084: XFREE (target_name);
6085: target_name = tmp_pathspec;
6086: tmp_pathspec = 0;
6087:
6088: lt_debugprintf (__FILE__, __LINE__,
6089: "(main) libtool target name: %s\n",
6090: target_name);
6091: EOF
6092:
6093: cat <<EOF
6094: newargz[0] =
6095: XMALLOC (char, (strlen (actual_cwrapper_path) +
6096: strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
6097: strcpy (newargz[0], actual_cwrapper_path);
6098: strcat (newargz[0], "$objdir");
6099: strcat (newargz[0], "/");
6100: EOF
6101:
6102: cat <<"EOF"
6103: /* stop here, and copy so we don't have to do this twice */
6104: tmp_pathspec = xstrdup (newargz[0]);
6105:
6106: /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
6107: strcat (newargz[0], actual_cwrapper_name);
6108:
6109: /* DO want the lt- prefix here if it exists, so use target_name */
6110: lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
6111: XFREE (tmp_pathspec);
6112: tmp_pathspec = NULL;
6113: EOF
6114:
6115: case $host_os in
6116: mingw*)
6117: cat <<"EOF"
6118: {
6119: char* p;
6120: while ((p = strchr (newargz[0], '\\')) != NULL)
6121: {
6122: *p = '/';
6123: }
6124: while ((p = strchr (lt_argv_zero, '\\')) != NULL)
6125: {
6126: *p = '/';
6127: }
6128: }
6129: EOF
6130: ;;
6131: esac
6132:
6133: cat <<"EOF"
6134: XFREE (target_name);
6135: XFREE (actual_cwrapper_path);
6136: XFREE (actual_cwrapper_name);
6137:
6138: lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
6139: lt_setenv ("DUALCASE", "1"); /* for MSK sh */
6140: /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
6141: be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
6142: because on Windows, both *_VARNAMEs are PATH but uninstalled
6143: libraries must come first. */
6144: lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
6145: lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
6146:
6147: lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
6148: nonnull (lt_argv_zero));
6149: for (i = 0; i < newargc; i++)
6150: {
6151: lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
6152: i, nonnull (newargz[i]));
6153: }
6154:
6155: EOF
6156:
6157: case $host_os in
6158: mingw*)
6159: cat <<"EOF"
6160: /* execv doesn't actually work on mingw as expected on unix */
6161: newargz = prepare_spawn (newargz);
6162: rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
6163: if (rval == -1)
6164: {
6165: /* failed to start process */
6166: lt_debugprintf (__FILE__, __LINE__,
6167: "(main) failed to launch target \"%s\": %s\n",
6168: lt_argv_zero, nonnull (strerror (errno)));
6169: return 127;
6170: }
6171: return rval;
6172: EOF
6173: ;;
6174: *)
6175: cat <<"EOF"
6176: execv (lt_argv_zero, newargz);
6177: return rval; /* =127, but avoids unused variable warning */
6178: EOF
6179: ;;
6180: esac
6181:
6182: cat <<"EOF"
6183: }
6184:
6185: void *
6186: xmalloc (size_t num)
6187: {
6188: void *p = (void *) malloc (num);
6189: if (!p)
6190: lt_fatal (__FILE__, __LINE__, "memory exhausted");
6191:
6192: return p;
6193: }
6194:
6195: char *
6196: xstrdup (const char *string)
6197: {
6198: return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
6199: string) : NULL;
6200: }
6201:
6202: const char *
6203: base_name (const char *name)
6204: {
6205: const char *base;
6206:
6207: #if defined HAVE_DOS_BASED_FILE_SYSTEM
6208: /* Skip over the disk name in MSDOS pathnames. */
6209: if (isalpha ((unsigned char) name[0]) && name[1] == ':')
6210: name += 2;
6211: #endif
6212:
6213: for (base = name; *name; name++)
6214: if (IS_DIR_SEPARATOR (*name))
6215: base = name + 1;
6216: return base;
6217: }
6218:
6219: int
6220: check_executable (const char *path)
6221: {
6222: struct stat st;
6223:
6224: lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
6225: nonempty (path));
6226: if ((!path) || (!*path))
6227: return 0;
6228:
6229: if ((stat (path, &st) >= 0)
6230: && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
6231: return 1;
6232: else
6233: return 0;
6234: }
6235:
6236: int
6237: make_executable (const char *path)
6238: {
6239: int rval = 0;
6240: struct stat st;
6241:
6242: lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
6243: nonempty (path));
6244: if ((!path) || (!*path))
6245: return 0;
6246:
6247: if (stat (path, &st) >= 0)
6248: {
6249: rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
6250: }
6251: return rval;
6252: }
6253:
6254: /* Searches for the full path of the wrapper. Returns
6255: newly allocated full path name if found, NULL otherwise
6256: Does not chase symlinks, even on platforms that support them.
6257: */
6258: char *
6259: find_executable (const char *wrapper)
6260: {
6261: int has_slash = 0;
6262: const char *p;
6263: const char *p_next;
6264: /* static buffer for getcwd */
6265: char tmp[LT_PATHMAX + 1];
6266: size_t tmp_len;
6267: char *concat_name;
6268:
6269: lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
6270: nonempty (wrapper));
6271:
6272: if ((wrapper == NULL) || (*wrapper == '\0'))
6273: return NULL;
6274:
6275: /* Absolute path? */
6276: #if defined HAVE_DOS_BASED_FILE_SYSTEM
6277: if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
6278: {
6279: concat_name = xstrdup (wrapper);
6280: if (check_executable (concat_name))
6281: return concat_name;
6282: XFREE (concat_name);
6283: }
6284: else
6285: {
6286: #endif
6287: if (IS_DIR_SEPARATOR (wrapper[0]))
6288: {
6289: concat_name = xstrdup (wrapper);
6290: if (check_executable (concat_name))
6291: return concat_name;
6292: XFREE (concat_name);
6293: }
6294: #if defined HAVE_DOS_BASED_FILE_SYSTEM
6295: }
6296: #endif
6297:
6298: for (p = wrapper; *p; p++)
6299: if (*p == '/')
6300: {
6301: has_slash = 1;
6302: break;
6303: }
6304: if (!has_slash)
6305: {
6306: /* no slashes; search PATH */
6307: const char *path = getenv ("PATH");
6308: if (path != NULL)
6309: {
6310: for (p = path; *p; p = p_next)
6311: {
6312: const char *q;
6313: size_t p_len;
6314: for (q = p; *q; q++)
6315: if (IS_PATH_SEPARATOR (*q))
6316: break;
6317: p_len = (size_t) (q - p);
6318: p_next = (*q == '\0' ? q : q + 1);
6319: if (p_len == 0)
6320: {
6321: /* empty path: current directory */
6322: if (getcwd (tmp, LT_PATHMAX) == NULL)
6323: lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6324: nonnull (strerror (errno)));
6325: tmp_len = strlen (tmp);
6326: concat_name =
6327: XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6328: memcpy (concat_name, tmp, tmp_len);
6329: concat_name[tmp_len] = '/';
6330: strcpy (concat_name + tmp_len + 1, wrapper);
6331: }
6332: else
6333: {
6334: concat_name =
6335: XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
6336: memcpy (concat_name, p, p_len);
6337: concat_name[p_len] = '/';
6338: strcpy (concat_name + p_len + 1, wrapper);
6339: }
6340: if (check_executable (concat_name))
6341: return concat_name;
6342: XFREE (concat_name);
6343: }
6344: }
6345: /* not found in PATH; assume curdir */
6346: }
6347: /* Relative path | not found in path: prepend cwd */
6348: if (getcwd (tmp, LT_PATHMAX) == NULL)
6349: lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6350: nonnull (strerror (errno)));
6351: tmp_len = strlen (tmp);
6352: concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6353: memcpy (concat_name, tmp, tmp_len);
6354: concat_name[tmp_len] = '/';
6355: strcpy (concat_name + tmp_len + 1, wrapper);
6356:
6357: if (check_executable (concat_name))
6358: return concat_name;
6359: XFREE (concat_name);
6360: return NULL;
6361: }
6362:
6363: char *
6364: chase_symlinks (const char *pathspec)
6365: {
6366: #ifndef S_ISLNK
6367: return xstrdup (pathspec);
6368: #else
6369: char buf[LT_PATHMAX];
6370: struct stat s;
6371: char *tmp_pathspec = xstrdup (pathspec);
6372: char *p;
6373: int has_symlinks = 0;
6374: while (strlen (tmp_pathspec) && !has_symlinks)
6375: {
6376: lt_debugprintf (__FILE__, __LINE__,
6377: "checking path component for symlinks: %s\n",
6378: tmp_pathspec);
6379: if (lstat (tmp_pathspec, &s) == 0)
6380: {
6381: if (S_ISLNK (s.st_mode) != 0)
6382: {
6383: has_symlinks = 1;
6384: break;
6385: }
6386:
6387: /* search backwards for last DIR_SEPARATOR */
6388: p = tmp_pathspec + strlen (tmp_pathspec) - 1;
6389: while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6390: p--;
6391: if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6392: {
6393: /* no more DIR_SEPARATORS left */
6394: break;
6395: }
6396: *p = '\0';
6397: }
6398: else
6399: {
6400: lt_fatal (__FILE__, __LINE__,
6401: "error accessing file \"%s\": %s",
6402: tmp_pathspec, nonnull (strerror (errno)));
6403: }
6404: }
6405: XFREE (tmp_pathspec);
6406:
6407: if (!has_symlinks)
6408: {
6409: return xstrdup (pathspec);
6410: }
6411:
6412: tmp_pathspec = realpath (pathspec, buf);
6413: if (tmp_pathspec == 0)
6414: {
6415: lt_fatal (__FILE__, __LINE__,
6416: "could not follow symlinks for %s", pathspec);
6417: }
6418: return xstrdup (tmp_pathspec);
6419: #endif
6420: }
6421:
6422: char *
6423: strendzap (char *str, const char *pat)
6424: {
6425: size_t len, patlen;
6426:
6427: assert (str != NULL);
6428: assert (pat != NULL);
6429:
6430: len = strlen (str);
6431: patlen = strlen (pat);
6432:
6433: if (patlen <= len)
6434: {
6435: str += len - patlen;
6436: if (STREQ (str, pat))
6437: *str = '\0';
6438: }
6439: return str;
6440: }
6441:
6442: void
6443: lt_debugprintf (const char *file, int line, const char *fmt, ...)
6444: {
6445: va_list args;
6446: if (lt_debug)
6447: {
6448: (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
6449: va_start (args, fmt);
6450: (void) vfprintf (stderr, fmt, args);
6451: va_end (args);
6452: }
6453: }
6454:
6455: static void
6456: lt_error_core (int exit_status, const char *file,
6457: int line, const char *mode,
6458: const char *message, va_list ap)
6459: {
6460: fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
6461: vfprintf (stderr, message, ap);
6462: fprintf (stderr, ".\n");
6463:
6464: if (exit_status >= 0)
6465: exit (exit_status);
6466: }
6467:
6468: void
6469: lt_fatal (const char *file, int line, const char *message, ...)
6470: {
6471: va_list ap;
6472: va_start (ap, message);
6473: lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
6474: va_end (ap);
6475: }
6476:
6477: static const char *
6478: nonnull (const char *s)
6479: {
6480: return s ? s : "(null)";
6481: }
6482:
6483: static const char *
6484: nonempty (const char *s)
6485: {
6486: return (s && !*s) ? "(empty)" : nonnull (s);
6487: }
6488:
6489: void
6490: lt_setenv (const char *name, const char *value)
6491: {
6492: lt_debugprintf (__FILE__, __LINE__,
6493: "(lt_setenv) setting '%s' to '%s'\n",
6494: nonnull (name), nonnull (value));
6495: {
6496: #ifdef HAVE_SETENV
6497: /* always make a copy, for consistency with !HAVE_SETENV */
6498: char *str = xstrdup (value);
6499: setenv (name, str, 1);
6500: #else
6501: size_t len = strlen (name) + 1 + strlen (value) + 1;
6502: char *str = XMALLOC (char, len);
6503: sprintf (str, "%s=%s", name, value);
6504: if (putenv (str) != EXIT_SUCCESS)
6505: {
6506: XFREE (str);
6507: }
6508: #endif
6509: }
6510: }
6511:
6512: char *
6513: lt_extend_str (const char *orig_value, const char *add, int to_end)
6514: {
6515: char *new_value;
6516: if (orig_value && *orig_value)
6517: {
6518: size_t orig_value_len = strlen (orig_value);
6519: size_t add_len = strlen (add);
6520: new_value = XMALLOC (char, add_len + orig_value_len + 1);
6521: if (to_end)
6522: {
6523: strcpy (new_value, orig_value);
6524: strcpy (new_value + orig_value_len, add);
6525: }
6526: else
6527: {
6528: strcpy (new_value, add);
6529: strcpy (new_value + add_len, orig_value);
6530: }
6531: }
6532: else
6533: {
6534: new_value = xstrdup (add);
6535: }
6536: return new_value;
6537: }
6538:
6539: void
6540: lt_update_exe_path (const char *name, const char *value)
6541: {
6542: lt_debugprintf (__FILE__, __LINE__,
6543: "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
6544: nonnull (name), nonnull (value));
6545:
6546: if (name && *name && value && *value)
6547: {
6548: char *new_value = lt_extend_str (getenv (name), value, 0);
6549: /* some systems can't cope with a ':'-terminated path #' */
6550: size_t len = strlen (new_value);
6551: while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
6552: {
6553: new_value[--len] = '\0';
6554: }
6555: lt_setenv (name, new_value);
6556: XFREE (new_value);
6557: }
6558: }
6559:
6560: void
6561: lt_update_lib_path (const char *name, const char *value)
6562: {
6563: lt_debugprintf (__FILE__, __LINE__,
6564: "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
6565: nonnull (name), nonnull (value));
6566:
6567: if (name && *name && value && *value)
6568: {
6569: char *new_value = lt_extend_str (getenv (name), value, 0);
6570: lt_setenv (name, new_value);
6571: XFREE (new_value);
6572: }
6573: }
6574:
6575: EOF
6576: case $host_os in
6577: mingw*)
6578: cat <<"EOF"
6579:
6580: /* Prepares an argument vector before calling spawn().
6581: Note that spawn() does not by itself call the command interpreter
6582: (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
6583: ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
6584: GetVersionEx(&v);
6585: v.dwPlatformId == VER_PLATFORM_WIN32_NT;
6586: }) ? "cmd.exe" : "command.com").
6587: Instead it simply concatenates the arguments, separated by ' ', and calls
6588: CreateProcess(). We must quote the arguments since Win32 CreateProcess()
6589: interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
6590: special way:
6591: - Space and tab are interpreted as delimiters. They are not treated as
6592: delimiters if they are surrounded by double quotes: "...".
6593: - Unescaped double quotes are removed from the input. Their only effect is
6594: that within double quotes, space and tab are treated like normal
6595: characters.
6596: - Backslashes not followed by double quotes are not special.
6597: - But 2*n+1 backslashes followed by a double quote become
6598: n backslashes followed by a double quote (n >= 0):
6599: \" -> "
6600: \\\" -> \"
6601: \\\\\" -> \\"
6602: */
6603: #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"
6604: #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"
6605: char **
6606: prepare_spawn (char **argv)
6607: {
6608: size_t argc;
6609: char **new_argv;
6610: size_t i;
6611:
6612: /* Count number of arguments. */
6613: for (argc = 0; argv[argc] != NULL; argc++)
6614: ;
6615:
6616: /* Allocate new argument vector. */
6617: new_argv = XMALLOC (char *, argc + 1);
6618:
6619: /* Put quoted arguments into the new argument vector. */
6620: for (i = 0; i < argc; i++)
6621: {
6622: const char *string = argv[i];
6623:
6624: if (string[0] == '\0')
6625: new_argv[i] = xstrdup ("\"\"");
6626: else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
6627: {
6628: int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
6629: size_t length;
6630: unsigned int backslashes;
6631: const char *s;
6632: char *quoted_string;
6633: char *p;
6634:
6635: length = 0;
6636: backslashes = 0;
6637: if (quote_around)
6638: length++;
6639: for (s = string; *s != '\0'; s++)
6640: {
6641: char c = *s;
6642: if (c == '"')
6643: length += backslashes + 1;
6644: length++;
6645: if (c == '\\')
6646: backslashes++;
6647: else
6648: backslashes = 0;
6649: }
6650: if (quote_around)
6651: length += backslashes + 1;
6652:
6653: quoted_string = XMALLOC (char, length + 1);
6654:
6655: p = quoted_string;
6656: backslashes = 0;
6657: if (quote_around)
6658: *p++ = '"';
6659: for (s = string; *s != '\0'; s++)
6660: {
6661: char c = *s;
6662: if (c == '"')
6663: {
6664: unsigned int j;
6665: for (j = backslashes + 1; j > 0; j--)
6666: *p++ = '\\';
6667: }
6668: *p++ = c;
6669: if (c == '\\')
6670: backslashes++;
6671: else
6672: backslashes = 0;
6673: }
6674: if (quote_around)
6675: {
6676: unsigned int j;
6677: for (j = backslashes; j > 0; j--)
6678: *p++ = '\\';
6679: *p++ = '"';
6680: }
6681: *p = '\0';
6682:
6683: new_argv[i] = quoted_string;
6684: }
6685: else
6686: new_argv[i] = (char *) string;
6687: }
6688: new_argv[argc] = NULL;
6689:
6690: return new_argv;
6691: }
6692: EOF
6693: ;;
6694: esac
6695:
6696: cat <<"EOF"
6697: void lt_dump_script (FILE* f)
6698: {
6699: EOF
6700: func_emit_wrapper yes |
6701: $SED -n -e '
6702: s/^\(.\{79\}\)\(..*\)/\1\
6703: \2/
6704: h
6705: s/\([\\"]\)/\\\1/g
6706: s/$/\\n/
6707: s/\([^\n]*\).*/ fputs ("\1", f);/p
6708: g
6709: D'
6710: cat <<"EOF"
6711: }
6712: EOF
6713: }
6714: # end: func_emit_cwrapperexe_src
6715:
6716: # func_win32_import_lib_p ARG
6717: # True if ARG is an import lib, as indicated by $file_magic_cmd
6718: func_win32_import_lib_p ()
6719: {
6720: $debug_cmd
6721:
6722: case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
6723: *import*) : ;;
6724: *) false ;;
6725: esac
6726: }
6727:
6728: # func_suncc_cstd_abi
6729: # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
6730: # Several compiler flags select an ABI that is incompatible with the
6731: # Cstd library. Avoid specifying it if any are in CXXFLAGS.
6732: func_suncc_cstd_abi ()
6733: {
6734: $debug_cmd
6735:
6736: case " $compile_command " in
6737: *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
6738: suncc_use_cstd_abi=no
6739: ;;
6740: *)
6741: suncc_use_cstd_abi=yes
6742: ;;
6743: esac
6744: }
6745:
6746: # func_mode_link arg...
6747: func_mode_link ()
6748: {
6749: $debug_cmd
6750:
6751: case $host in
6752: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
6753: # It is impossible to link a dll without this setting, and
6754: # we shouldn't force the makefile maintainer to figure out
6755: # what system we are compiling for in order to pass an extra
6756: # flag for every libtool invocation.
6757: # allow_undefined=no
6758:
6759: # FIXME: Unfortunately, there are problems with the above when trying
6760: # to make a dll that has undefined symbols, in which case not
6761: # even a static library is built. For now, we need to specify
6762: # -no-undefined on the libtool link line when we can be certain
6763: # that all symbols are satisfied, otherwise we get a static library.
6764: allow_undefined=yes
6765: ;;
6766: *)
6767: allow_undefined=yes
6768: ;;
6769: esac
6770: libtool_args=$nonopt
6771: base_compile="$nonopt $@"
6772: compile_command=$nonopt
6773: finalize_command=$nonopt
6774:
6775: compile_rpath=
6776: finalize_rpath=
6777: compile_shlibpath=
6778: finalize_shlibpath=
6779: convenience=
6780: old_convenience=
6781: deplibs=
6782: old_deplibs=
6783: compiler_flags=
6784: linker_flags=
6785: dllsearchpath=
6786: lib_search_path=`pwd`
6787: inst_prefix_dir=
6788: new_inherited_linker_flags=
6789:
6790: avoid_version=no
6791: bindir=
6792: dlfiles=
6793: dlprefiles=
6794: dlself=no
6795: export_dynamic=no
6796: export_symbols=
6797: export_symbols_regex=
6798: generated=
6799: libobjs=
6800: ltlibs=
6801: module=no
6802: no_install=no
6803: objs=
6804: os2dllname=
6805: non_pic_objects=
6806: precious_files_regex=
6807: prefer_static_libs=no
6808: preload=false
6809: prev=
6810: prevarg=
6811: release=
6812: rpath=
6813: xrpath=
6814: perm_rpath=
6815: temp_rpath=
6816: thread_safe=no
6817: vinfo=
6818: vinfo_number=no
6819: weak_libs=
6820: single_module=$wl-single_module
6821: func_infer_tag $base_compile
6822:
6823: # We need to know -static, to get the right output filenames.
6824: for arg
6825: do
6826: case $arg in
6827: -shared)
6828: test yes != "$build_libtool_libs" \
6829: && func_fatal_configuration "cannot build a shared library"
6830: build_old_libs=no
6831: break
6832: ;;
6833: -all-static | -static | -static-libtool-libs)
6834: case $arg in
6835: -all-static)
6836: if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
6837: func_warning "complete static linking is impossible in this configuration"
6838: fi
6839: if test -n "$link_static_flag"; then
6840: dlopen_self=$dlopen_self_static
6841: fi
6842: prefer_static_libs=yes
6843: ;;
6844: -static)
6845: if test -z "$pic_flag" && test -n "$link_static_flag"; then
6846: dlopen_self=$dlopen_self_static
6847: fi
6848: prefer_static_libs=built
6849: ;;
6850: -static-libtool-libs)
6851: if test -z "$pic_flag" && test -n "$link_static_flag"; then
6852: dlopen_self=$dlopen_self_static
6853: fi
6854: prefer_static_libs=yes
6855: ;;
6856: esac
6857: build_libtool_libs=no
6858: build_old_libs=yes
6859: break
6860: ;;
6861: esac
6862: done
6863:
6864: # See if our shared archives depend on static archives.
6865: test -n "$old_archive_from_new_cmds" && build_old_libs=yes
6866:
6867: # Go through the arguments, transforming them on the way.
6868: while test "$#" -gt 0; do
6869: arg=$1
6870: shift
1.2 ! ohara 6871: func_quote_arg pretty,unquoted "$arg"
! 6872: qarg=$func_quote_arg_unquoted_result
! 6873: func_append libtool_args " $func_quote_arg_result"
1.1 ohara 6874:
6875: # If the previous option needs an argument, assign it.
6876: if test -n "$prev"; then
6877: case $prev in
6878: output)
6879: func_append compile_command " @OUTPUT@"
6880: func_append finalize_command " @OUTPUT@"
6881: ;;
6882: esac
6883:
6884: case $prev in
6885: bindir)
6886: bindir=$arg
6887: prev=
6888: continue
6889: ;;
6890: dlfiles|dlprefiles)
6891: $preload || {
6892: # Add the symbol object into the linking commands.
6893: func_append compile_command " @SYMFILE@"
6894: func_append finalize_command " @SYMFILE@"
6895: preload=:
6896: }
6897: case $arg in
6898: *.la | *.lo) ;; # We handle these cases below.
6899: force)
6900: if test no = "$dlself"; then
6901: dlself=needless
6902: export_dynamic=yes
6903: fi
6904: prev=
6905: continue
6906: ;;
6907: self)
6908: if test dlprefiles = "$prev"; then
6909: dlself=yes
6910: elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
6911: dlself=yes
6912: else
6913: dlself=needless
6914: export_dynamic=yes
6915: fi
6916: prev=
6917: continue
6918: ;;
6919: *)
6920: if test dlfiles = "$prev"; then
6921: func_append dlfiles " $arg"
6922: else
6923: func_append dlprefiles " $arg"
6924: fi
6925: prev=
6926: continue
6927: ;;
6928: esac
6929: ;;
6930: expsyms)
6931: export_symbols=$arg
6932: test -f "$arg" \
6933: || func_fatal_error "symbol file '$arg' does not exist"
6934: prev=
6935: continue
6936: ;;
6937: expsyms_regex)
6938: export_symbols_regex=$arg
6939: prev=
6940: continue
6941: ;;
6942: framework)
6943: case $host in
6944: *-*-darwin*)
6945: case "$deplibs " in
6946: *" $qarg.ltframework "*) ;;
6947: *) func_append deplibs " $qarg.ltframework" # this is fixed later
6948: ;;
6949: esac
6950: ;;
6951: esac
6952: prev=
6953: continue
6954: ;;
6955: inst_prefix)
6956: inst_prefix_dir=$arg
6957: prev=
6958: continue
6959: ;;
6960: mllvm)
6961: # Clang does not use LLVM to link, so we can simply discard any
6962: # '-mllvm $arg' options when doing the link step.
6963: prev=
6964: continue
6965: ;;
6966: objectlist)
6967: if test -f "$arg"; then
6968: save_arg=$arg
6969: moreargs=
6970: for fil in `cat "$save_arg"`
6971: do
6972: # func_append moreargs " $fil"
6973: arg=$fil
6974: # A libtool-controlled object.
6975:
6976: # Check to see that this really is a libtool object.
6977: if func_lalib_unsafe_p "$arg"; then
6978: pic_object=
6979: non_pic_object=
6980:
6981: # Read the .lo file
6982: func_source "$arg"
6983:
6984: if test -z "$pic_object" ||
6985: test -z "$non_pic_object" ||
6986: test none = "$pic_object" &&
6987: test none = "$non_pic_object"; then
6988: func_fatal_error "cannot find name of object for '$arg'"
6989: fi
6990:
6991: # Extract subdirectory from the argument.
6992: func_dirname "$arg" "/" ""
6993: xdir=$func_dirname_result
6994:
6995: if test none != "$pic_object"; then
6996: # Prepend the subdirectory the object is found in.
6997: pic_object=$xdir$pic_object
6998:
6999: if test dlfiles = "$prev"; then
7000: if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7001: func_append dlfiles " $pic_object"
7002: prev=
7003: continue
7004: else
7005: # If libtool objects are unsupported, then we need to preload.
7006: prev=dlprefiles
7007: fi
7008: fi
7009:
7010: # CHECK ME: I think I busted this. -Ossama
7011: if test dlprefiles = "$prev"; then
7012: # Preload the old-style object.
7013: func_append dlprefiles " $pic_object"
7014: prev=
7015: fi
7016:
7017: # A PIC object.
7018: func_append libobjs " $pic_object"
7019: arg=$pic_object
7020: fi
7021:
7022: # Non-PIC object.
7023: if test none != "$non_pic_object"; then
7024: # Prepend the subdirectory the object is found in.
7025: non_pic_object=$xdir$non_pic_object
7026:
7027: # A standard non-PIC object
7028: func_append non_pic_objects " $non_pic_object"
7029: if test -z "$pic_object" || test none = "$pic_object"; then
7030: arg=$non_pic_object
7031: fi
7032: else
7033: # If the PIC object exists, use it instead.
7034: # $xdir was prepended to $pic_object above.
7035: non_pic_object=$pic_object
7036: func_append non_pic_objects " $non_pic_object"
7037: fi
7038: else
7039: # Only an error if not doing a dry-run.
7040: if $opt_dry_run; then
7041: # Extract subdirectory from the argument.
7042: func_dirname "$arg" "/" ""
7043: xdir=$func_dirname_result
7044:
7045: func_lo2o "$arg"
7046: pic_object=$xdir$objdir/$func_lo2o_result
7047: non_pic_object=$xdir$func_lo2o_result
7048: func_append libobjs " $pic_object"
7049: func_append non_pic_objects " $non_pic_object"
7050: else
7051: func_fatal_error "'$arg' is not a valid libtool object"
7052: fi
7053: fi
7054: done
7055: else
7056: func_fatal_error "link input file '$arg' does not exist"
7057: fi
7058: arg=$save_arg
7059: prev=
7060: continue
7061: ;;
7062: os2dllname)
7063: os2dllname=$arg
7064: prev=
7065: continue
7066: ;;
7067: precious_regex)
7068: precious_files_regex=$arg
7069: prev=
7070: continue
7071: ;;
7072: release)
7073: release=-$arg
7074: prev=
7075: continue
7076: ;;
7077: rpath | xrpath)
7078: # We need an absolute path.
7079: case $arg in
7080: [\\/]* | [A-Za-z]:[\\/]*) ;;
7081: *)
7082: func_fatal_error "only absolute run-paths are allowed"
7083: ;;
7084: esac
7085: if test rpath = "$prev"; then
7086: case "$rpath " in
7087: *" $arg "*) ;;
7088: *) func_append rpath " $arg" ;;
7089: esac
7090: else
7091: case "$xrpath " in
7092: *" $arg "*) ;;
7093: *) func_append xrpath " $arg" ;;
7094: esac
7095: fi
7096: prev=
7097: continue
7098: ;;
7099: shrext)
7100: shrext_cmds=$arg
7101: prev=
7102: continue
7103: ;;
7104: weak)
7105: func_append weak_libs " $arg"
7106: prev=
7107: continue
7108: ;;
1.2 ! ohara 7109: xassembler)
! 7110: func_append compiler_flags " -Xassembler $qarg"
! 7111: prev=
! 7112: func_append compile_command " -Xassembler $qarg"
! 7113: func_append finalize_command " -Xassembler $qarg"
! 7114: continue
! 7115: ;;
1.1 ohara 7116: xcclinker)
7117: func_append linker_flags " $qarg"
7118: func_append compiler_flags " $qarg"
7119: prev=
7120: func_append compile_command " $qarg"
7121: func_append finalize_command " $qarg"
7122: continue
7123: ;;
7124: xcompiler)
7125: func_append compiler_flags " $qarg"
7126: prev=
7127: func_append compile_command " $qarg"
7128: func_append finalize_command " $qarg"
7129: continue
7130: ;;
7131: xlinker)
7132: func_append linker_flags " $qarg"
7133: func_append compiler_flags " $wl$qarg"
7134: prev=
7135: func_append compile_command " $wl$qarg"
7136: func_append finalize_command " $wl$qarg"
7137: continue
7138: ;;
7139: *)
7140: eval "$prev=\"\$arg\""
7141: prev=
7142: continue
7143: ;;
7144: esac
7145: fi # test -n "$prev"
7146:
7147: prevarg=$arg
7148:
7149: case $arg in
7150: -all-static)
7151: if test -n "$link_static_flag"; then
7152: # See comment for -static flag below, for more details.
7153: func_append compile_command " $link_static_flag"
7154: func_append finalize_command " $link_static_flag"
7155: fi
7156: continue
7157: ;;
7158:
7159: -allow-undefined)
7160: # FIXME: remove this flag sometime in the future.
7161: func_fatal_error "'-allow-undefined' must not be used because it is the default"
7162: ;;
7163:
7164: -avoid-version)
7165: avoid_version=yes
7166: continue
7167: ;;
7168:
7169: -bindir)
7170: prev=bindir
7171: continue
7172: ;;
7173:
7174: -dlopen)
7175: prev=dlfiles
7176: continue
7177: ;;
7178:
7179: -dlpreopen)
7180: prev=dlprefiles
7181: continue
7182: ;;
7183:
7184: -export-dynamic)
7185: export_dynamic=yes
7186: continue
7187: ;;
7188:
7189: -export-symbols | -export-symbols-regex)
7190: if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
7191: func_fatal_error "more than one -exported-symbols argument is not allowed"
7192: fi
7193: if test X-export-symbols = "X$arg"; then
7194: prev=expsyms
7195: else
7196: prev=expsyms_regex
7197: fi
7198: continue
7199: ;;
7200:
7201: -framework)
7202: prev=framework
7203: continue
7204: ;;
7205:
7206: -inst-prefix-dir)
7207: prev=inst_prefix
7208: continue
7209: ;;
7210:
7211: # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
7212: # so, if we see these flags be careful not to treat them like -L
7213: -L[A-Z][A-Z]*:*)
7214: case $with_gcc/$host in
7215: no/*-*-irix* | /*-*-irix*)
7216: func_append compile_command " $arg"
7217: func_append finalize_command " $arg"
7218: ;;
7219: esac
7220: continue
7221: ;;
7222:
7223: -L*)
7224: func_stripname "-L" '' "$arg"
7225: if test -z "$func_stripname_result"; then
7226: if test "$#" -gt 0; then
7227: func_fatal_error "require no space between '-L' and '$1'"
7228: else
7229: func_fatal_error "need path for '-L' option"
7230: fi
7231: fi
7232: func_resolve_sysroot "$func_stripname_result"
7233: dir=$func_resolve_sysroot_result
7234: # We need an absolute path.
7235: case $dir in
7236: [\\/]* | [A-Za-z]:[\\/]*) ;;
7237: *)
7238: absdir=`cd "$dir" && pwd`
7239: test -z "$absdir" && \
7240: func_fatal_error "cannot determine absolute directory name of '$dir'"
7241: dir=$absdir
7242: ;;
7243: esac
7244: case "$deplibs " in
7245: *" -L$dir "* | *" $arg "*)
7246: # Will only happen for absolute or sysroot arguments
7247: ;;
7248: *)
7249: # Preserve sysroot, but never include relative directories
7250: case $dir in
7251: [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
7252: *) func_append deplibs " -L$dir" ;;
7253: esac
7254: func_append lib_search_path " $dir"
7255: ;;
7256: esac
7257: case $host in
7258: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7259: testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
7260: case :$dllsearchpath: in
7261: *":$dir:"*) ;;
7262: ::) dllsearchpath=$dir;;
7263: *) func_append dllsearchpath ":$dir";;
7264: esac
7265: case :$dllsearchpath: in
7266: *":$testbindir:"*) ;;
7267: ::) dllsearchpath=$testbindir;;
7268: *) func_append dllsearchpath ":$testbindir";;
7269: esac
7270: ;;
7271: esac
7272: continue
7273: ;;
7274:
7275: -l*)
7276: if test X-lc = "X$arg" || test X-lm = "X$arg"; then
7277: case $host in
7278: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
7279: # These systems don't actually have a C or math library (as such)
7280: continue
7281: ;;
7282: *-*-os2*)
7283: # These systems don't actually have a C library (as such)
7284: test X-lc = "X$arg" && continue
7285: ;;
1.2 ! ohara 7286: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
1.1 ohara 7287: # Do not include libc due to us having libc/libc_r.
7288: test X-lc = "X$arg" && continue
7289: ;;
7290: *-*-rhapsody* | *-*-darwin1.[012])
7291: # Rhapsody C and math libraries are in the System framework
7292: func_append deplibs " System.ltframework"
7293: continue
7294: ;;
7295: *-*-sco3.2v5* | *-*-sco5v6*)
7296: # Causes problems with __ctype
7297: test X-lc = "X$arg" && continue
7298: ;;
7299: *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7300: # Compiler inserts libc in the correct place for threads to work
7301: test X-lc = "X$arg" && continue
7302: ;;
7303: esac
7304: elif test X-lc_r = "X$arg"; then
7305: case $host in
1.2 ! ohara 7306: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
1.1 ohara 7307: # Do not include libc_r directly, use -pthread flag.
7308: continue
7309: ;;
7310: esac
7311: fi
7312: func_append deplibs " $arg"
7313: continue
7314: ;;
7315:
7316: -mllvm)
7317: prev=mllvm
7318: continue
7319: ;;
7320:
7321: -module)
7322: module=yes
7323: continue
7324: ;;
7325:
7326: # Tru64 UNIX uses -model [arg] to determine the layout of C++
7327: # classes, name mangling, and exception handling.
7328: # Darwin uses the -arch flag to determine output architecture.
7329: -model|-arch|-isysroot|--sysroot)
7330: func_append compiler_flags " $arg"
7331: func_append compile_command " $arg"
7332: func_append finalize_command " $arg"
7333: prev=xcompiler
7334: continue
7335: ;;
1.2 ! ohara 7336: # Solaris ld rejects as of 11.4. Refer to Oracle bug 22985199.
! 7337: -pthread)
! 7338: case $host in
! 7339: *solaris2*) ;;
! 7340: *)
! 7341: case "$new_inherited_linker_flags " in
! 7342: *" $arg "*) ;;
! 7343: * ) func_append new_inherited_linker_flags " $arg" ;;
! 7344: esac
! 7345: ;;
! 7346: esac
! 7347: continue
! 7348: ;;
! 7349: -mt|-mthreads|-kthread|-Kthread|-pthreads|--thread-safe \
1.1 ohara 7350: |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7351: func_append compiler_flags " $arg"
7352: func_append compile_command " $arg"
7353: func_append finalize_command " $arg"
7354: case "$new_inherited_linker_flags " in
7355: *" $arg "*) ;;
7356: * ) func_append new_inherited_linker_flags " $arg" ;;
7357: esac
7358: continue
7359: ;;
7360:
7361: -multi_module)
7362: single_module=$wl-multi_module
7363: continue
7364: ;;
7365:
7366: -no-fast-install)
7367: fast_install=no
7368: continue
7369: ;;
7370:
7371: -no-install)
7372: case $host in
7373: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
7374: # The PATH hackery in wrapper scripts is required on Windows
7375: # and Darwin in order for the loader to find any dlls it needs.
7376: func_warning "'-no-install' is ignored for $host"
7377: func_warning "assuming '-no-fast-install' instead"
7378: fast_install=no
7379: ;;
7380: *) no_install=yes ;;
7381: esac
7382: continue
7383: ;;
7384:
7385: -no-undefined)
7386: allow_undefined=no
7387: continue
7388: ;;
7389:
7390: -objectlist)
7391: prev=objectlist
7392: continue
7393: ;;
7394:
7395: -os2dllname)
7396: prev=os2dllname
7397: continue
7398: ;;
7399:
7400: -o) prev=output ;;
7401:
7402: -precious-files-regex)
7403: prev=precious_regex
7404: continue
7405: ;;
7406:
7407: -release)
7408: prev=release
7409: continue
7410: ;;
7411:
7412: -rpath)
7413: prev=rpath
7414: continue
7415: ;;
7416:
7417: -R)
7418: prev=xrpath
7419: continue
7420: ;;
7421:
7422: -R*)
7423: func_stripname '-R' '' "$arg"
7424: dir=$func_stripname_result
7425: # We need an absolute path.
7426: case $dir in
7427: [\\/]* | [A-Za-z]:[\\/]*) ;;
7428: =*)
7429: func_stripname '=' '' "$dir"
7430: dir=$lt_sysroot$func_stripname_result
7431: ;;
7432: *)
7433: func_fatal_error "only absolute run-paths are allowed"
7434: ;;
7435: esac
7436: case "$xrpath " in
7437: *" $dir "*) ;;
7438: *) func_append xrpath " $dir" ;;
7439: esac
7440: continue
7441: ;;
7442:
7443: -shared)
7444: # The effects of -shared are defined in a previous loop.
7445: continue
7446: ;;
7447:
7448: -shrext)
7449: prev=shrext
7450: continue
7451: ;;
7452:
7453: -static | -static-libtool-libs)
7454: # The effects of -static are defined in a previous loop.
7455: # We used to do the same as -all-static on platforms that
7456: # didn't have a PIC flag, but the assumption that the effects
7457: # would be equivalent was wrong. It would break on at least
7458: # Digital Unix and AIX.
7459: continue
7460: ;;
7461:
7462: -thread-safe)
7463: thread_safe=yes
7464: continue
7465: ;;
7466:
7467: -version-info)
7468: prev=vinfo
7469: continue
7470: ;;
7471:
7472: -version-number)
7473: prev=vinfo
7474: vinfo_number=yes
7475: continue
7476: ;;
7477:
7478: -weak)
7479: prev=weak
7480: continue
7481: ;;
7482:
7483: -Wc,*)
7484: func_stripname '-Wc,' '' "$arg"
7485: args=$func_stripname_result
7486: arg=
7487: save_ifs=$IFS; IFS=,
7488: for flag in $args; do
7489: IFS=$save_ifs
1.2 ! ohara 7490: func_quote_arg pretty "$flag"
! 7491: func_append arg " $func_quote_arg_result"
! 7492: func_append compiler_flags " $func_quote_arg_result"
1.1 ohara 7493: done
7494: IFS=$save_ifs
7495: func_stripname ' ' '' "$arg"
7496: arg=$func_stripname_result
7497: ;;
7498:
7499: -Wl,*)
7500: func_stripname '-Wl,' '' "$arg"
7501: args=$func_stripname_result
7502: arg=
7503: save_ifs=$IFS; IFS=,
7504: for flag in $args; do
7505: IFS=$save_ifs
1.2 ! ohara 7506: func_quote_arg pretty "$flag"
! 7507: func_append arg " $wl$func_quote_arg_result"
! 7508: func_append compiler_flags " $wl$func_quote_arg_result"
! 7509: func_append linker_flags " $func_quote_arg_result"
1.1 ohara 7510: done
7511: IFS=$save_ifs
7512: func_stripname ' ' '' "$arg"
7513: arg=$func_stripname_result
7514: ;;
7515:
1.2 ! ohara 7516: -Xassembler)
! 7517: prev=xassembler
! 7518: continue
! 7519: ;;
! 7520:
1.1 ohara 7521: -Xcompiler)
7522: prev=xcompiler
7523: continue
7524: ;;
7525:
7526: -Xlinker)
7527: prev=xlinker
7528: continue
7529: ;;
7530:
7531: -XCClinker)
7532: prev=xcclinker
7533: continue
7534: ;;
7535:
7536: # -msg_* for osf cc
7537: -msg_*)
1.2 ! ohara 7538: func_quote_arg pretty "$arg"
! 7539: arg=$func_quote_arg_result
1.1 ohara 7540: ;;
7541:
7542: # Flags to be passed through unchanged, with rationale:
7543: # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
7544: # -r[0-9][0-9]* specify processor for the SGI compiler
7545: # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
7546: # +DA*, +DD* enable 64-bit mode for the HP compiler
7547: # -q* compiler args for the IBM compiler
7548: # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
7549: # -F/path path to uninstalled frameworks, gcc on darwin
7550: # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
7551: # -fstack-protector* stack protector flags for GCC
7552: # @file GCC response files
7553: # -tp=* Portland pgcc target processor selection
7554: # --sysroot=* for sysroot support
7555: # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
1.2 ! ohara 7556: # -specs=* GCC specs files
1.1 ohara 7557: # -stdlib=* select c++ std lib with clang
1.2 ! ohara 7558: # -fsanitize=* Clang/GCC memory and address sanitizer
! 7559: # -fuse-ld=* Linker select flags for GCC
! 7560: # -Wa,* Pass flags directly to the assembler
1.1 ohara 7561: -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
7562: -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
1.2 ! ohara 7563: -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
! 7564: -specs=*|-fsanitize=*|-fuse-ld=*|-Wa,*)
! 7565: func_quote_arg pretty "$arg"
! 7566: arg=$func_quote_arg_result
1.1 ohara 7567: func_append compile_command " $arg"
7568: func_append finalize_command " $arg"
7569: func_append compiler_flags " $arg"
7570: continue
7571: ;;
7572:
7573: -Z*)
7574: if test os2 = "`expr $host : '.*\(os2\)'`"; then
7575: # OS/2 uses -Zxxx to specify OS/2-specific options
7576: compiler_flags="$compiler_flags $arg"
7577: func_append compile_command " $arg"
7578: func_append finalize_command " $arg"
7579: case $arg in
7580: -Zlinker | -Zstack)
7581: prev=xcompiler
7582: ;;
7583: esac
7584: continue
7585: else
7586: # Otherwise treat like 'Some other compiler flag' below
1.2 ! ohara 7587: func_quote_arg pretty "$arg"
! 7588: arg=$func_quote_arg_result
1.1 ohara 7589: fi
7590: ;;
7591:
7592: # Some other compiler flag.
7593: -* | +*)
1.2 ! ohara 7594: func_quote_arg pretty "$arg"
! 7595: arg=$func_quote_arg_result
1.1 ohara 7596: ;;
7597:
7598: *.$objext)
7599: # A standard object.
7600: func_append objs " $arg"
7601: ;;
7602:
7603: *.lo)
7604: # A libtool-controlled object.
7605:
7606: # Check to see that this really is a libtool object.
7607: if func_lalib_unsafe_p "$arg"; then
7608: pic_object=
7609: non_pic_object=
7610:
7611: # Read the .lo file
7612: func_source "$arg"
7613:
7614: if test -z "$pic_object" ||
7615: test -z "$non_pic_object" ||
7616: test none = "$pic_object" &&
7617: test none = "$non_pic_object"; then
7618: func_fatal_error "cannot find name of object for '$arg'"
7619: fi
7620:
7621: # Extract subdirectory from the argument.
7622: func_dirname "$arg" "/" ""
7623: xdir=$func_dirname_result
7624:
7625: test none = "$pic_object" || {
7626: # Prepend the subdirectory the object is found in.
7627: pic_object=$xdir$pic_object
7628:
7629: if test dlfiles = "$prev"; then
7630: if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7631: func_append dlfiles " $pic_object"
7632: prev=
7633: continue
7634: else
7635: # If libtool objects are unsupported, then we need to preload.
7636: prev=dlprefiles
7637: fi
7638: fi
7639:
7640: # CHECK ME: I think I busted this. -Ossama
7641: if test dlprefiles = "$prev"; then
7642: # Preload the old-style object.
7643: func_append dlprefiles " $pic_object"
7644: prev=
7645: fi
7646:
7647: # A PIC object.
7648: func_append libobjs " $pic_object"
7649: arg=$pic_object
7650: }
7651:
7652: # Non-PIC object.
7653: if test none != "$non_pic_object"; then
7654: # Prepend the subdirectory the object is found in.
7655: non_pic_object=$xdir$non_pic_object
7656:
7657: # A standard non-PIC object
7658: func_append non_pic_objects " $non_pic_object"
7659: if test -z "$pic_object" || test none = "$pic_object"; then
7660: arg=$non_pic_object
7661: fi
7662: else
7663: # If the PIC object exists, use it instead.
7664: # $xdir was prepended to $pic_object above.
7665: non_pic_object=$pic_object
7666: func_append non_pic_objects " $non_pic_object"
7667: fi
7668: else
7669: # Only an error if not doing a dry-run.
7670: if $opt_dry_run; then
7671: # Extract subdirectory from the argument.
7672: func_dirname "$arg" "/" ""
7673: xdir=$func_dirname_result
7674:
7675: func_lo2o "$arg"
7676: pic_object=$xdir$objdir/$func_lo2o_result
7677: non_pic_object=$xdir$func_lo2o_result
7678: func_append libobjs " $pic_object"
7679: func_append non_pic_objects " $non_pic_object"
7680: else
7681: func_fatal_error "'$arg' is not a valid libtool object"
7682: fi
7683: fi
7684: ;;
7685:
7686: *.$libext)
7687: # An archive.
7688: func_append deplibs " $arg"
7689: func_append old_deplibs " $arg"
7690: continue
7691: ;;
7692:
7693: *.la)
7694: # A libtool-controlled library.
7695:
7696: func_resolve_sysroot "$arg"
7697: if test dlfiles = "$prev"; then
7698: # This library was specified with -dlopen.
7699: func_append dlfiles " $func_resolve_sysroot_result"
7700: prev=
7701: elif test dlprefiles = "$prev"; then
7702: # The library was specified with -dlpreopen.
7703: func_append dlprefiles " $func_resolve_sysroot_result"
7704: prev=
7705: else
7706: func_append deplibs " $func_resolve_sysroot_result"
7707: fi
7708: continue
7709: ;;
7710:
7711: # Some other compiler argument.
7712: *)
7713: # Unknown arguments in both finalize_command and compile_command need
7714: # to be aesthetically quoted because they are evaled later.
1.2 ! ohara 7715: func_quote_arg pretty "$arg"
! 7716: arg=$func_quote_arg_result
1.1 ohara 7717: ;;
7718: esac # arg
7719:
7720: # Now actually substitute the argument into the commands.
7721: if test -n "$arg"; then
7722: func_append compile_command " $arg"
7723: func_append finalize_command " $arg"
7724: fi
7725: done # argument parsing loop
7726:
7727: test -n "$prev" && \
7728: func_fatal_help "the '$prevarg' option requires an argument"
7729:
7730: if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
7731: eval arg=\"$export_dynamic_flag_spec\"
7732: func_append compile_command " $arg"
7733: func_append finalize_command " $arg"
7734: fi
7735:
7736: oldlibs=
7737: # calculate the name of the file, without its directory
7738: func_basename "$output"
7739: outputname=$func_basename_result
7740: libobjs_save=$libobjs
7741:
7742: if test -n "$shlibpath_var"; then
7743: # get the directories listed in $shlibpath_var
7744: eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
7745: else
7746: shlib_search_path=
7747: fi
7748: eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
7749: eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
7750:
7751: # Definition is injected by LT_CONFIG during libtool generation.
7752: func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
7753:
7754: func_dirname "$output" "/" ""
7755: output_objdir=$func_dirname_result$objdir
7756: func_to_tool_file "$output_objdir/"
7757: tool_output_objdir=$func_to_tool_file_result
7758: # Create the object directory.
7759: func_mkdir_p "$output_objdir"
7760:
7761: # Determine the type of output
7762: case $output in
7763: "")
7764: func_fatal_help "you must specify an output file"
7765: ;;
7766: *.$libext) linkmode=oldlib ;;
7767: *.lo | *.$objext) linkmode=obj ;;
7768: *.la) linkmode=lib ;;
7769: *) linkmode=prog ;; # Anything else should be a program.
7770: esac
7771:
7772: specialdeplibs=
7773:
7774: libs=
7775: # Find all interdependent deplibs by searching for libraries
7776: # that are linked more than once (e.g. -la -lb -la)
7777: for deplib in $deplibs; do
7778: if $opt_preserve_dup_deps; then
7779: case "$libs " in
7780: *" $deplib "*) func_append specialdeplibs " $deplib" ;;
7781: esac
7782: fi
7783: func_append libs " $deplib"
7784: done
7785:
7786: if test lib = "$linkmode"; then
7787: libs="$predeps $libs $compiler_lib_search_path $postdeps"
7788:
7789: # Compute libraries that are listed more than once in $predeps
7790: # $postdeps and mark them as special (i.e., whose duplicates are
7791: # not to be eliminated).
7792: pre_post_deps=
7793: if $opt_duplicate_compiler_generated_deps; then
7794: for pre_post_dep in $predeps $postdeps; do
7795: case "$pre_post_deps " in
7796: *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
7797: esac
7798: func_append pre_post_deps " $pre_post_dep"
7799: done
7800: fi
7801: pre_post_deps=
7802: fi
7803:
7804: deplibs=
7805: newdependency_libs=
7806: newlib_search_path=
7807: need_relink=no # whether we're linking any uninstalled libtool libraries
7808: notinst_deplibs= # not-installed libtool libraries
7809: notinst_path= # paths that contain not-installed libtool libraries
7810:
7811: case $linkmode in
7812: lib)
7813: passes="conv dlpreopen link"
7814: for file in $dlfiles $dlprefiles; do
7815: case $file in
7816: *.la) ;;
7817: *)
7818: func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
7819: ;;
7820: esac
7821: done
7822: ;;
7823: prog)
7824: compile_deplibs=
7825: finalize_deplibs=
7826: alldeplibs=false
7827: newdlfiles=
7828: newdlprefiles=
7829: passes="conv scan dlopen dlpreopen link"
7830: ;;
7831: *) passes="conv"
7832: ;;
7833: esac
7834:
7835: for pass in $passes; do
7836: # The preopen pass in lib mode reverses $deplibs; put it back here
7837: # so that -L comes before libs that need it for instance...
7838: if test lib,link = "$linkmode,$pass"; then
7839: ## FIXME: Find the place where the list is rebuilt in the wrong
7840: ## order, and fix it there properly
7841: tmp_deplibs=
7842: for deplib in $deplibs; do
7843: tmp_deplibs="$deplib $tmp_deplibs"
7844: done
7845: deplibs=$tmp_deplibs
7846: fi
7847:
7848: if test lib,link = "$linkmode,$pass" ||
7849: test prog,scan = "$linkmode,$pass"; then
7850: libs=$deplibs
7851: deplibs=
7852: fi
7853: if test prog = "$linkmode"; then
7854: case $pass in
7855: dlopen) libs=$dlfiles ;;
7856: dlpreopen) libs=$dlprefiles ;;
7857: link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
7858: esac
7859: fi
7860: if test lib,dlpreopen = "$linkmode,$pass"; then
7861: # Collect and forward deplibs of preopened libtool libs
7862: for lib in $dlprefiles; do
7863: # Ignore non-libtool-libs
7864: dependency_libs=
7865: func_resolve_sysroot "$lib"
7866: case $lib in
7867: *.la) func_source "$func_resolve_sysroot_result" ;;
7868: esac
7869:
7870: # Collect preopened libtool deplibs, except any this library
7871: # has declared as weak libs
7872: for deplib in $dependency_libs; do
7873: func_basename "$deplib"
7874: deplib_base=$func_basename_result
7875: case " $weak_libs " in
7876: *" $deplib_base "*) ;;
7877: *) func_append deplibs " $deplib" ;;
7878: esac
7879: done
7880: done
7881: libs=$dlprefiles
7882: fi
7883: if test dlopen = "$pass"; then
7884: # Collect dlpreopened libraries
7885: save_deplibs=$deplibs
7886: deplibs=
7887: fi
7888:
7889: for deplib in $libs; do
7890: lib=
7891: found=false
7892: case $deplib in
7893: -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
7894: |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7895: if test prog,link = "$linkmode,$pass"; then
7896: compile_deplibs="$deplib $compile_deplibs"
7897: finalize_deplibs="$deplib $finalize_deplibs"
7898: else
7899: func_append compiler_flags " $deplib"
7900: if test lib = "$linkmode"; then
7901: case "$new_inherited_linker_flags " in
7902: *" $deplib "*) ;;
7903: * ) func_append new_inherited_linker_flags " $deplib" ;;
7904: esac
7905: fi
7906: fi
7907: continue
7908: ;;
7909: -l*)
7910: if test lib != "$linkmode" && test prog != "$linkmode"; then
7911: func_warning "'-l' is ignored for archives/objects"
7912: continue
7913: fi
7914: func_stripname '-l' '' "$deplib"
7915: name=$func_stripname_result
7916: if test lib = "$linkmode"; then
7917: searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
7918: else
7919: searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
7920: fi
7921: for searchdir in $searchdirs; do
7922: for search_ext in .la $std_shrext .so .a; do
7923: # Search the libtool library
7924: lib=$searchdir/lib$name$search_ext
7925: if test -f "$lib"; then
7926: if test .la = "$search_ext"; then
7927: found=:
7928: else
7929: found=false
7930: fi
7931: break 2
7932: fi
7933: done
7934: done
7935: if $found; then
7936: # deplib is a libtool library
7937: # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
7938: # We need to do some special things here, and not later.
7939: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
7940: case " $predeps $postdeps " in
7941: *" $deplib "*)
7942: if func_lalib_p "$lib"; then
7943: library_names=
7944: old_library=
7945: func_source "$lib"
7946: for l in $old_library $library_names; do
7947: ll=$l
7948: done
7949: if test "X$ll" = "X$old_library"; then # only static version available
7950: found=false
7951: func_dirname "$lib" "" "."
7952: ladir=$func_dirname_result
7953: lib=$ladir/$old_library
7954: if test prog,link = "$linkmode,$pass"; then
7955: compile_deplibs="$deplib $compile_deplibs"
7956: finalize_deplibs="$deplib $finalize_deplibs"
7957: else
7958: deplibs="$deplib $deplibs"
7959: test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7960: fi
7961: continue
7962: fi
7963: fi
7964: ;;
7965: *) ;;
7966: esac
7967: fi
7968: else
7969: # deplib doesn't seem to be a libtool library
7970: if test prog,link = "$linkmode,$pass"; then
7971: compile_deplibs="$deplib $compile_deplibs"
7972: finalize_deplibs="$deplib $finalize_deplibs"
7973: else
7974: deplibs="$deplib $deplibs"
7975: test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7976: fi
7977: continue
7978: fi
7979: ;; # -l
7980: *.ltframework)
7981: if test prog,link = "$linkmode,$pass"; then
7982: compile_deplibs="$deplib $compile_deplibs"
7983: finalize_deplibs="$deplib $finalize_deplibs"
7984: else
7985: deplibs="$deplib $deplibs"
7986: if test lib = "$linkmode"; then
7987: case "$new_inherited_linker_flags " in
7988: *" $deplib "*) ;;
7989: * ) func_append new_inherited_linker_flags " $deplib" ;;
7990: esac
7991: fi
7992: fi
7993: continue
7994: ;;
7995: -L*)
7996: case $linkmode in
7997: lib)
7998: deplibs="$deplib $deplibs"
7999: test conv = "$pass" && continue
8000: newdependency_libs="$deplib $newdependency_libs"
8001: func_stripname '-L' '' "$deplib"
8002: func_resolve_sysroot "$func_stripname_result"
8003: func_append newlib_search_path " $func_resolve_sysroot_result"
8004: ;;
8005: prog)
8006: if test conv = "$pass"; then
8007: deplibs="$deplib $deplibs"
8008: continue
8009: fi
8010: if test scan = "$pass"; then
8011: deplibs="$deplib $deplibs"
8012: else
8013: compile_deplibs="$deplib $compile_deplibs"
8014: finalize_deplibs="$deplib $finalize_deplibs"
8015: fi
8016: func_stripname '-L' '' "$deplib"
8017: func_resolve_sysroot "$func_stripname_result"
8018: func_append newlib_search_path " $func_resolve_sysroot_result"
8019: ;;
8020: *)
8021: func_warning "'-L' is ignored for archives/objects"
8022: ;;
8023: esac # linkmode
8024: continue
8025: ;; # -L
8026: -R*)
8027: if test link = "$pass"; then
8028: func_stripname '-R' '' "$deplib"
8029: func_resolve_sysroot "$func_stripname_result"
8030: dir=$func_resolve_sysroot_result
8031: # Make sure the xrpath contains only unique directories.
8032: case "$xrpath " in
8033: *" $dir "*) ;;
8034: *) func_append xrpath " $dir" ;;
8035: esac
8036: fi
8037: deplibs="$deplib $deplibs"
8038: continue
8039: ;;
8040: *.la)
8041: func_resolve_sysroot "$deplib"
8042: lib=$func_resolve_sysroot_result
8043: ;;
8044: *.$libext)
8045: if test conv = "$pass"; then
8046: deplibs="$deplib $deplibs"
8047: continue
8048: fi
8049: case $linkmode in
8050: lib)
8051: # Linking convenience modules into shared libraries is allowed,
8052: # but linking other static libraries is non-portable.
8053: case " $dlpreconveniencelibs " in
8054: *" $deplib "*) ;;
8055: *)
8056: valid_a_lib=false
8057: case $deplibs_check_method in
8058: match_pattern*)
8059: set dummy $deplibs_check_method; shift
8060: match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
8061: if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
8062: | $EGREP "$match_pattern_regex" > /dev/null; then
8063: valid_a_lib=:
8064: fi
8065: ;;
8066: pass_all)
8067: valid_a_lib=:
8068: ;;
8069: esac
8070: if $valid_a_lib; then
8071: echo
8072: $ECHO "*** Warning: Linking the shared library $output against the"
8073: $ECHO "*** static library $deplib is not portable!"
8074: deplibs="$deplib $deplibs"
8075: else
8076: echo
8077: $ECHO "*** Warning: Trying to link with static lib archive $deplib."
8078: echo "*** I have the capability to make that library automatically link in when"
8079: echo "*** you link to this library. But I can only do this if you have a"
8080: echo "*** shared version of the library, which you do not appear to have"
8081: echo "*** because the file extensions .$libext of this argument makes me believe"
8082: echo "*** that it is just a static archive that I should not use here."
8083: fi
8084: ;;
8085: esac
8086: continue
8087: ;;
8088: prog)
8089: if test link != "$pass"; then
8090: deplibs="$deplib $deplibs"
8091: else
8092: compile_deplibs="$deplib $compile_deplibs"
8093: finalize_deplibs="$deplib $finalize_deplibs"
8094: fi
8095: continue
8096: ;;
8097: esac # linkmode
8098: ;; # *.$libext
8099: *.lo | *.$objext)
8100: if test conv = "$pass"; then
8101: deplibs="$deplib $deplibs"
8102: elif test prog = "$linkmode"; then
8103: if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
8104: # If there is no dlopen support or we're linking statically,
8105: # we need to preload.
8106: func_append newdlprefiles " $deplib"
8107: compile_deplibs="$deplib $compile_deplibs"
8108: finalize_deplibs="$deplib $finalize_deplibs"
8109: else
8110: func_append newdlfiles " $deplib"
8111: fi
8112: fi
8113: continue
8114: ;;
8115: %DEPLIBS%)
8116: alldeplibs=:
8117: continue
8118: ;;
8119: esac # case $deplib
8120:
8121: $found || test -f "$lib" \
8122: || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
8123:
8124: # Check to see that this really is a libtool archive.
8125: func_lalib_unsafe_p "$lib" \
8126: || func_fatal_error "'$lib' is not a valid libtool archive"
8127:
8128: func_dirname "$lib" "" "."
8129: ladir=$func_dirname_result
8130:
8131: dlname=
8132: dlopen=
8133: dlpreopen=
8134: libdir=
8135: library_names=
8136: old_library=
8137: inherited_linker_flags=
8138: # If the library was installed with an old release of libtool,
8139: # it will not redefine variables installed, or shouldnotlink
8140: installed=yes
8141: shouldnotlink=no
8142: avoidtemprpath=
8143:
8144:
8145: # Read the .la file
8146: func_source "$lib"
8147:
8148: # Convert "-framework foo" to "foo.ltframework"
8149: if test -n "$inherited_linker_flags"; then
8150: tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
8151: for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
8152: case " $new_inherited_linker_flags " in
8153: *" $tmp_inherited_linker_flag "*) ;;
8154: *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
8155: esac
8156: done
8157: fi
8158: dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8159: if test lib,link = "$linkmode,$pass" ||
8160: test prog,scan = "$linkmode,$pass" ||
8161: { test prog != "$linkmode" && test lib != "$linkmode"; }; then
8162: test -n "$dlopen" && func_append dlfiles " $dlopen"
8163: test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
8164: fi
8165:
8166: if test conv = "$pass"; then
8167: # Only check for convenience libraries
8168: deplibs="$lib $deplibs"
8169: if test -z "$libdir"; then
8170: if test -z "$old_library"; then
8171: func_fatal_error "cannot find name of link library for '$lib'"
8172: fi
8173: # It is a libtool convenience library, so add in its objects.
8174: func_append convenience " $ladir/$objdir/$old_library"
8175: func_append old_convenience " $ladir/$objdir/$old_library"
8176: elif test prog != "$linkmode" && test lib != "$linkmode"; then
8177: func_fatal_error "'$lib' is not a convenience library"
8178: fi
8179: tmp_libs=
8180: for deplib in $dependency_libs; do
8181: deplibs="$deplib $deplibs"
8182: if $opt_preserve_dup_deps; then
8183: case "$tmp_libs " in
8184: *" $deplib "*) func_append specialdeplibs " $deplib" ;;
8185: esac
8186: fi
8187: func_append tmp_libs " $deplib"
8188: done
8189: continue
8190: fi # $pass = conv
8191:
8192:
8193: # Get the name of the library we link against.
8194: linklib=
8195: if test -n "$old_library" &&
8196: { test yes = "$prefer_static_libs" ||
8197: test built,no = "$prefer_static_libs,$installed"; }; then
8198: linklib=$old_library
8199: else
8200: for l in $old_library $library_names; do
8201: linklib=$l
8202: done
8203: fi
8204: if test -z "$linklib"; then
8205: func_fatal_error "cannot find name of link library for '$lib'"
8206: fi
8207:
8208: # This library was specified with -dlopen.
8209: if test dlopen = "$pass"; then
8210: test -z "$libdir" \
8211: && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
8212: if test -z "$dlname" ||
8213: test yes != "$dlopen_support" ||
8214: test no = "$build_libtool_libs"
8215: then
8216: # If there is no dlname, no dlopen support or we're linking
8217: # statically, we need to preload. We also need to preload any
8218: # dependent libraries so libltdl's deplib preloader doesn't
8219: # bomb out in the load deplibs phase.
8220: func_append dlprefiles " $lib $dependency_libs"
8221: else
8222: func_append newdlfiles " $lib"
8223: fi
8224: continue
8225: fi # $pass = dlopen
8226:
8227: # We need an absolute path.
8228: case $ladir in
8229: [\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
8230: *)
8231: abs_ladir=`cd "$ladir" && pwd`
8232: if test -z "$abs_ladir"; then
8233: func_warning "cannot determine absolute directory name of '$ladir'"
8234: func_warning "passing it literally to the linker, although it might fail"
8235: abs_ladir=$ladir
8236: fi
8237: ;;
8238: esac
8239: func_basename "$lib"
8240: laname=$func_basename_result
8241:
8242: # Find the relevant object directory and library name.
8243: if test yes = "$installed"; then
8244: if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
8245: func_warning "library '$lib' was moved."
8246: dir=$ladir
8247: absdir=$abs_ladir
8248: libdir=$abs_ladir
8249: else
8250: dir=$lt_sysroot$libdir
8251: absdir=$lt_sysroot$libdir
8252: fi
8253: test yes = "$hardcode_automatic" && avoidtemprpath=yes
8254: else
8255: if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
8256: dir=$ladir
8257: absdir=$abs_ladir
8258: # Remove this search path later
8259: func_append notinst_path " $abs_ladir"
8260: else
8261: dir=$ladir/$objdir
8262: absdir=$abs_ladir/$objdir
8263: # Remove this search path later
8264: func_append notinst_path " $abs_ladir"
8265: fi
8266: fi # $installed = yes
8267: func_stripname 'lib' '.la' "$laname"
8268: name=$func_stripname_result
8269:
8270: # This library was specified with -dlpreopen.
8271: if test dlpreopen = "$pass"; then
8272: if test -z "$libdir" && test prog = "$linkmode"; then
8273: func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
8274: fi
8275: case $host in
8276: # special handling for platforms with PE-DLLs.
8277: *cygwin* | *mingw* | *cegcc* )
8278: # Linker will automatically link against shared library if both
8279: # static and shared are present. Therefore, ensure we extract
8280: # symbols from the import library if a shared library is present
8281: # (otherwise, the dlopen module name will be incorrect). We do
8282: # this by putting the import library name into $newdlprefiles.
8283: # We recover the dlopen module name by 'saving' the la file
8284: # name in a special purpose variable, and (later) extracting the
8285: # dlname from the la file.
8286: if test -n "$dlname"; then
8287: func_tr_sh "$dir/$linklib"
8288: eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
8289: func_append newdlprefiles " $dir/$linklib"
8290: else
8291: func_append newdlprefiles " $dir/$old_library"
8292: # Keep a list of preopened convenience libraries to check
8293: # that they are being used correctly in the link pass.
8294: test -z "$libdir" && \
8295: func_append dlpreconveniencelibs " $dir/$old_library"
8296: fi
8297: ;;
8298: * )
8299: # Prefer using a static library (so that no silly _DYNAMIC symbols
8300: # are required to link).
8301: if test -n "$old_library"; then
8302: func_append newdlprefiles " $dir/$old_library"
8303: # Keep a list of preopened convenience libraries to check
8304: # that they are being used correctly in the link pass.
8305: test -z "$libdir" && \
8306: func_append dlpreconveniencelibs " $dir/$old_library"
8307: # Otherwise, use the dlname, so that lt_dlopen finds it.
8308: elif test -n "$dlname"; then
8309: func_append newdlprefiles " $dir/$dlname"
8310: else
8311: func_append newdlprefiles " $dir/$linklib"
8312: fi
8313: ;;
8314: esac
8315: fi # $pass = dlpreopen
8316:
8317: if test -z "$libdir"; then
8318: # Link the convenience library
8319: if test lib = "$linkmode"; then
8320: deplibs="$dir/$old_library $deplibs"
8321: elif test prog,link = "$linkmode,$pass"; then
8322: compile_deplibs="$dir/$old_library $compile_deplibs"
8323: finalize_deplibs="$dir/$old_library $finalize_deplibs"
8324: else
8325: deplibs="$lib $deplibs" # used for prog,scan pass
8326: fi
8327: continue
8328: fi
8329:
8330:
8331: if test prog = "$linkmode" && test link != "$pass"; then
8332: func_append newlib_search_path " $ladir"
8333: deplibs="$lib $deplibs"
8334:
8335: linkalldeplibs=false
8336: if test no != "$link_all_deplibs" || test -z "$library_names" ||
8337: test no = "$build_libtool_libs"; then
8338: linkalldeplibs=:
8339: fi
8340:
8341: tmp_libs=
8342: for deplib in $dependency_libs; do
8343: case $deplib in
8344: -L*) func_stripname '-L' '' "$deplib"
8345: func_resolve_sysroot "$func_stripname_result"
8346: func_append newlib_search_path " $func_resolve_sysroot_result"
8347: ;;
8348: esac
8349: # Need to link against all dependency_libs?
8350: if $linkalldeplibs; then
8351: deplibs="$deplib $deplibs"
8352: else
8353: # Need to hardcode shared library paths
8354: # or/and link against static libraries
8355: newdependency_libs="$deplib $newdependency_libs"
8356: fi
8357: if $opt_preserve_dup_deps; then
8358: case "$tmp_libs " in
8359: *" $deplib "*) func_append specialdeplibs " $deplib" ;;
8360: esac
8361: fi
8362: func_append tmp_libs " $deplib"
8363: done # for deplib
8364: continue
8365: fi # $linkmode = prog...
8366:
8367: if test prog,link = "$linkmode,$pass"; then
8368: if test -n "$library_names" &&
8369: { { test no = "$prefer_static_libs" ||
8370: test built,yes = "$prefer_static_libs,$installed"; } ||
8371: test -z "$old_library"; }; then
8372: # We need to hardcode the library path
8373: if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
8374: # Make sure the rpath contains only unique directories.
8375: case $temp_rpath: in
8376: *"$absdir:"*) ;;
8377: *) func_append temp_rpath "$absdir:" ;;
8378: esac
8379: fi
8380:
8381: # Hardcode the library path.
8382: # Skip directories that are in the system default run-time
8383: # search path.
8384: case " $sys_lib_dlsearch_path " in
8385: *" $absdir "*) ;;
8386: *)
8387: case "$compile_rpath " in
8388: *" $absdir "*) ;;
8389: *) func_append compile_rpath " $absdir" ;;
8390: esac
8391: ;;
8392: esac
8393: case " $sys_lib_dlsearch_path " in
8394: *" $libdir "*) ;;
8395: *)
8396: case "$finalize_rpath " in
8397: *" $libdir "*) ;;
8398: *) func_append finalize_rpath " $libdir" ;;
8399: esac
8400: ;;
8401: esac
8402: fi # $linkmode,$pass = prog,link...
8403:
8404: if $alldeplibs &&
8405: { test pass_all = "$deplibs_check_method" ||
8406: { test yes = "$build_libtool_libs" &&
8407: test -n "$library_names"; }; }; then
8408: # We only need to search for static libraries
8409: continue
8410: fi
8411: fi
8412:
8413: link_static=no # Whether the deplib will be linked statically
8414: use_static_libs=$prefer_static_libs
8415: if test built = "$use_static_libs" && test yes = "$installed"; then
8416: use_static_libs=no
8417: fi
8418: if test -n "$library_names" &&
8419: { test no = "$use_static_libs" || test -z "$old_library"; }; then
8420: case $host in
8421: *cygwin* | *mingw* | *cegcc* | *os2*)
8422: # No point in relinking DLLs because paths are not encoded
8423: func_append notinst_deplibs " $lib"
8424: need_relink=no
8425: ;;
8426: *)
8427: if test no = "$installed"; then
8428: func_append notinst_deplibs " $lib"
8429: need_relink=yes
8430: fi
8431: ;;
8432: esac
8433: # This is a shared library
8434:
8435: # Warn about portability, can't link against -module's on some
8436: # systems (darwin). Don't bleat about dlopened modules though!
8437: dlopenmodule=
8438: for dlpremoduletest in $dlprefiles; do
8439: if test "X$dlpremoduletest" = "X$lib"; then
8440: dlopenmodule=$dlpremoduletest
8441: break
8442: fi
8443: done
8444: if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
8445: echo
8446: if test prog = "$linkmode"; then
8447: $ECHO "*** Warning: Linking the executable $output against the loadable module"
8448: else
8449: $ECHO "*** Warning: Linking the shared library $output against the loadable module"
8450: fi
8451: $ECHO "*** $linklib is not portable!"
8452: fi
8453: if test lib = "$linkmode" &&
8454: test yes = "$hardcode_into_libs"; then
8455: # Hardcode the library path.
8456: # Skip directories that are in the system default run-time
8457: # search path.
8458: case " $sys_lib_dlsearch_path " in
8459: *" $absdir "*) ;;
8460: *)
8461: case "$compile_rpath " in
8462: *" $absdir "*) ;;
8463: *) func_append compile_rpath " $absdir" ;;
8464: esac
8465: ;;
8466: esac
8467: case " $sys_lib_dlsearch_path " in
8468: *" $libdir "*) ;;
8469: *)
8470: case "$finalize_rpath " in
8471: *" $libdir "*) ;;
8472: *) func_append finalize_rpath " $libdir" ;;
8473: esac
8474: ;;
8475: esac
8476: fi
8477:
8478: if test -n "$old_archive_from_expsyms_cmds"; then
8479: # figure out the soname
8480: set dummy $library_names
8481: shift
8482: realname=$1
8483: shift
8484: libname=`eval "\\$ECHO \"$libname_spec\""`
8485: # use dlname if we got it. it's perfectly good, no?
8486: if test -n "$dlname"; then
8487: soname=$dlname
8488: elif test -n "$soname_spec"; then
8489: # bleh windows
8490: case $host in
8491: *cygwin* | mingw* | *cegcc* | *os2*)
8492: func_arith $current - $age
8493: major=$func_arith_result
8494: versuffix=-$major
8495: ;;
8496: esac
8497: eval soname=\"$soname_spec\"
8498: else
8499: soname=$realname
8500: fi
8501:
8502: # Make a new name for the extract_expsyms_cmds to use
8503: soroot=$soname
8504: func_basename "$soroot"
8505: soname=$func_basename_result
8506: func_stripname 'lib' '.dll' "$soname"
8507: newlib=libimp-$func_stripname_result.a
8508:
8509: # If the library has no export list, then create one now
8510: if test -f "$output_objdir/$soname-def"; then :
8511: else
8512: func_verbose "extracting exported symbol list from '$soname'"
8513: func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
8514: fi
8515:
8516: # Create $newlib
8517: if test -f "$output_objdir/$newlib"; then :; else
8518: func_verbose "generating import library for '$soname'"
8519: func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
8520: fi
8521: # make sure the library variables are pointing to the new library
8522: dir=$output_objdir
8523: linklib=$newlib
8524: fi # test -n "$old_archive_from_expsyms_cmds"
8525:
8526: if test prog = "$linkmode" || test relink != "$opt_mode"; then
8527: add_shlibpath=
8528: add_dir=
8529: add=
8530: lib_linked=yes
8531: case $hardcode_action in
8532: immediate | unsupported)
8533: if test no = "$hardcode_direct"; then
8534: add=$dir/$linklib
8535: case $host in
8536: *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
8537: *-*-sysv4*uw2*) add_dir=-L$dir ;;
8538: *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
8539: *-*-unixware7*) add_dir=-L$dir ;;
8540: *-*-darwin* )
8541: # if the lib is a (non-dlopened) module then we cannot
8542: # link against it, someone is ignoring the earlier warnings
8543: if /usr/bin/file -L $add 2> /dev/null |
8544: $GREP ": [^:]* bundle" >/dev/null; then
8545: if test "X$dlopenmodule" != "X$lib"; then
8546: $ECHO "*** Warning: lib $linklib is a module, not a shared library"
8547: if test -z "$old_library"; then
8548: echo
8549: echo "*** And there doesn't seem to be a static archive available"
8550: echo "*** The link will probably fail, sorry"
8551: else
8552: add=$dir/$old_library
8553: fi
8554: elif test -n "$old_library"; then
8555: add=$dir/$old_library
8556: fi
8557: fi
8558: esac
8559: elif test no = "$hardcode_minus_L"; then
8560: case $host in
8561: *-*-sunos*) add_shlibpath=$dir ;;
8562: esac
8563: add_dir=-L$dir
8564: add=-l$name
8565: elif test no = "$hardcode_shlibpath_var"; then
8566: add_shlibpath=$dir
8567: add=-l$name
8568: else
8569: lib_linked=no
8570: fi
8571: ;;
8572: relink)
8573: if test yes = "$hardcode_direct" &&
8574: test no = "$hardcode_direct_absolute"; then
8575: add=$dir/$linklib
8576: elif test yes = "$hardcode_minus_L"; then
8577: add_dir=-L$absdir
8578: # Try looking first in the location we're being installed to.
8579: if test -n "$inst_prefix_dir"; then
8580: case $libdir in
8581: [\\/]*)
8582: func_append add_dir " -L$inst_prefix_dir$libdir"
8583: ;;
8584: esac
8585: fi
8586: add=-l$name
8587: elif test yes = "$hardcode_shlibpath_var"; then
8588: add_shlibpath=$dir
8589: add=-l$name
8590: else
8591: lib_linked=no
8592: fi
8593: ;;
8594: *) lib_linked=no ;;
8595: esac
8596:
8597: if test yes != "$lib_linked"; then
8598: func_fatal_configuration "unsupported hardcode properties"
8599: fi
8600:
8601: if test -n "$add_shlibpath"; then
8602: case :$compile_shlibpath: in
8603: *":$add_shlibpath:"*) ;;
8604: *) func_append compile_shlibpath "$add_shlibpath:" ;;
8605: esac
8606: fi
8607: if test prog = "$linkmode"; then
8608: test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
8609: test -n "$add" && compile_deplibs="$add $compile_deplibs"
8610: else
8611: test -n "$add_dir" && deplibs="$add_dir $deplibs"
8612: test -n "$add" && deplibs="$add $deplibs"
8613: if test yes != "$hardcode_direct" &&
8614: test yes != "$hardcode_minus_L" &&
8615: test yes = "$hardcode_shlibpath_var"; then
8616: case :$finalize_shlibpath: in
8617: *":$libdir:"*) ;;
8618: *) func_append finalize_shlibpath "$libdir:" ;;
8619: esac
8620: fi
8621: fi
8622: fi
8623:
8624: if test prog = "$linkmode" || test relink = "$opt_mode"; then
8625: add_shlibpath=
8626: add_dir=
8627: add=
8628: # Finalize command for both is simple: just hardcode it.
8629: if test yes = "$hardcode_direct" &&
8630: test no = "$hardcode_direct_absolute"; then
8631: add=$libdir/$linklib
8632: elif test yes = "$hardcode_minus_L"; then
8633: add_dir=-L$libdir
8634: add=-l$name
8635: elif test yes = "$hardcode_shlibpath_var"; then
8636: case :$finalize_shlibpath: in
8637: *":$libdir:"*) ;;
8638: *) func_append finalize_shlibpath "$libdir:" ;;
8639: esac
8640: add=-l$name
8641: elif test yes = "$hardcode_automatic"; then
8642: if test -n "$inst_prefix_dir" &&
8643: test -f "$inst_prefix_dir$libdir/$linklib"; then
8644: add=$inst_prefix_dir$libdir/$linklib
8645: else
8646: add=$libdir/$linklib
8647: fi
8648: else
8649: # We cannot seem to hardcode it, guess we'll fake it.
8650: add_dir=-L$libdir
8651: # Try looking first in the location we're being installed to.
8652: if test -n "$inst_prefix_dir"; then
8653: case $libdir in
8654: [\\/]*)
8655: func_append add_dir " -L$inst_prefix_dir$libdir"
8656: ;;
8657: esac
8658: fi
8659: add=-l$name
8660: fi
8661:
8662: if test prog = "$linkmode"; then
8663: test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
8664: test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
8665: else
8666: test -n "$add_dir" && deplibs="$add_dir $deplibs"
8667: test -n "$add" && deplibs="$add $deplibs"
8668: fi
8669: fi
8670: elif test prog = "$linkmode"; then
8671: # Here we assume that one of hardcode_direct or hardcode_minus_L
8672: # is not unsupported. This is valid on all known static and
8673: # shared platforms.
8674: if test unsupported != "$hardcode_direct"; then
8675: test -n "$old_library" && linklib=$old_library
8676: compile_deplibs="$dir/$linklib $compile_deplibs"
8677: finalize_deplibs="$dir/$linklib $finalize_deplibs"
8678: else
8679: compile_deplibs="-l$name -L$dir $compile_deplibs"
8680: finalize_deplibs="-l$name -L$dir $finalize_deplibs"
8681: fi
8682: elif test yes = "$build_libtool_libs"; then
8683: # Not a shared library
8684: if test pass_all != "$deplibs_check_method"; then
8685: # We're trying link a shared library against a static one
8686: # but the system doesn't support it.
8687:
8688: # Just print a warning and add the library to dependency_libs so
8689: # that the program can be linked against the static library.
8690: echo
8691: $ECHO "*** Warning: This system cannot link to static lib archive $lib."
8692: echo "*** I have the capability to make that library automatically link in when"
8693: echo "*** you link to this library. But I can only do this if you have a"
8694: echo "*** shared version of the library, which you do not appear to have."
8695: if test yes = "$module"; then
8696: echo "*** But as you try to build a module library, libtool will still create "
8697: echo "*** a static module, that should work as long as the dlopening application"
8698: echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
8699: if test -z "$global_symbol_pipe"; then
8700: echo
8701: echo "*** However, this would only work if libtool was able to extract symbol"
8702: echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
8703: echo "*** not find such a program. So, this module is probably useless."
8704: echo "*** 'nm' from GNU binutils and a full rebuild may help."
8705: fi
8706: if test no = "$build_old_libs"; then
8707: build_libtool_libs=module
8708: build_old_libs=yes
8709: else
8710: build_libtool_libs=no
8711: fi
8712: fi
8713: else
8714: deplibs="$dir/$old_library $deplibs"
8715: link_static=yes
8716: fi
8717: fi # link shared/static library?
8718:
8719: if test lib = "$linkmode"; then
8720: if test -n "$dependency_libs" &&
8721: { test yes != "$hardcode_into_libs" ||
8722: test yes = "$build_old_libs" ||
8723: test yes = "$link_static"; }; then
8724: # Extract -R from dependency_libs
8725: temp_deplibs=
8726: for libdir in $dependency_libs; do
8727: case $libdir in
8728: -R*) func_stripname '-R' '' "$libdir"
8729: temp_xrpath=$func_stripname_result
8730: case " $xrpath " in
8731: *" $temp_xrpath "*) ;;
8732: *) func_append xrpath " $temp_xrpath";;
8733: esac;;
8734: *) func_append temp_deplibs " $libdir";;
8735: esac
8736: done
8737: dependency_libs=$temp_deplibs
8738: fi
8739:
8740: func_append newlib_search_path " $absdir"
8741: # Link against this library
8742: test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
8743: # ... and its dependency_libs
8744: tmp_libs=
8745: for deplib in $dependency_libs; do
8746: newdependency_libs="$deplib $newdependency_libs"
8747: case $deplib in
8748: -L*) func_stripname '-L' '' "$deplib"
8749: func_resolve_sysroot "$func_stripname_result";;
8750: *) func_resolve_sysroot "$deplib" ;;
8751: esac
8752: if $opt_preserve_dup_deps; then
8753: case "$tmp_libs " in
8754: *" $func_resolve_sysroot_result "*)
8755: func_append specialdeplibs " $func_resolve_sysroot_result" ;;
8756: esac
8757: fi
8758: func_append tmp_libs " $func_resolve_sysroot_result"
8759: done
8760:
8761: if test no != "$link_all_deplibs"; then
8762: # Add the search paths of all dependency libraries
8763: for deplib in $dependency_libs; do
8764: path=
8765: case $deplib in
8766: -L*) path=$deplib ;;
8767: *.la)
8768: func_resolve_sysroot "$deplib"
8769: deplib=$func_resolve_sysroot_result
8770: func_dirname "$deplib" "" "."
8771: dir=$func_dirname_result
8772: # We need an absolute path.
8773: case $dir in
8774: [\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
8775: *)
8776: absdir=`cd "$dir" && pwd`
8777: if test -z "$absdir"; then
8778: func_warning "cannot determine absolute directory name of '$dir'"
8779: absdir=$dir
8780: fi
8781: ;;
8782: esac
8783: if $GREP "^installed=no" $deplib > /dev/null; then
8784: case $host in
8785: *-*-darwin*)
8786: depdepl=
8787: eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
8788: if test -n "$deplibrary_names"; then
8789: for tmp in $deplibrary_names; do
8790: depdepl=$tmp
8791: done
8792: if test -f "$absdir/$objdir/$depdepl"; then
8793: depdepl=$absdir/$objdir/$depdepl
8794: darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
8795: if test -z "$darwin_install_name"; then
8796: darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
8797: fi
8798: func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
8799: func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
8800: path=
8801: fi
8802: fi
8803: ;;
8804: *)
8805: path=-L$absdir/$objdir
8806: ;;
8807: esac
8808: else
8809: eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8810: test -z "$libdir" && \
8811: func_fatal_error "'$deplib' is not a valid libtool archive"
8812: test "$absdir" != "$libdir" && \
8813: func_warning "'$deplib' seems to be moved"
8814:
8815: path=-L$absdir
8816: fi
8817: ;;
8818: esac
8819: case " $deplibs " in
8820: *" $path "*) ;;
8821: *) deplibs="$path $deplibs" ;;
8822: esac
8823: done
8824: fi # link_all_deplibs != no
8825: fi # linkmode = lib
8826: done # for deplib in $libs
8827: if test link = "$pass"; then
8828: if test prog = "$linkmode"; then
8829: compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
8830: finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
8831: else
8832: compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8833: fi
8834: fi
8835: dependency_libs=$newdependency_libs
8836: if test dlpreopen = "$pass"; then
8837: # Link the dlpreopened libraries before other libraries
8838: for deplib in $save_deplibs; do
8839: deplibs="$deplib $deplibs"
8840: done
8841: fi
8842: if test dlopen != "$pass"; then
8843: test conv = "$pass" || {
8844: # Make sure lib_search_path contains only unique directories.
8845: lib_search_path=
8846: for dir in $newlib_search_path; do
8847: case "$lib_search_path " in
8848: *" $dir "*) ;;
8849: *) func_append lib_search_path " $dir" ;;
8850: esac
8851: done
8852: newlib_search_path=
8853: }
8854:
8855: if test prog,link = "$linkmode,$pass"; then
8856: vars="compile_deplibs finalize_deplibs"
8857: else
8858: vars=deplibs
8859: fi
8860: for var in $vars dependency_libs; do
8861: # Add libraries to $var in reverse order
8862: eval tmp_libs=\"\$$var\"
8863: new_libs=
8864: for deplib in $tmp_libs; do
8865: # FIXME: Pedantically, this is the right thing to do, so
8866: # that some nasty dependency loop isn't accidentally
8867: # broken:
8868: #new_libs="$deplib $new_libs"
8869: # Pragmatically, this seems to cause very few problems in
8870: # practice:
8871: case $deplib in
8872: -L*) new_libs="$deplib $new_libs" ;;
8873: -R*) ;;
8874: *)
8875: # And here is the reason: when a library appears more
8876: # than once as an explicit dependence of a library, or
8877: # is implicitly linked in more than once by the
8878: # compiler, it is considered special, and multiple
8879: # occurrences thereof are not removed. Compare this
8880: # with having the same library being listed as a
8881: # dependency of multiple other libraries: in this case,
8882: # we know (pedantically, we assume) the library does not
8883: # need to be listed more than once, so we keep only the
8884: # last copy. This is not always right, but it is rare
8885: # enough that we require users that really mean to play
8886: # such unportable linking tricks to link the library
8887: # using -Wl,-lname, so that libtool does not consider it
8888: # for duplicate removal.
8889: case " $specialdeplibs " in
8890: *" $deplib "*) new_libs="$deplib $new_libs" ;;
8891: *)
8892: case " $new_libs " in
8893: *" $deplib "*) ;;
8894: *) new_libs="$deplib $new_libs" ;;
8895: esac
8896: ;;
8897: esac
8898: ;;
8899: esac
8900: done
8901: tmp_libs=
8902: for deplib in $new_libs; do
8903: case $deplib in
8904: -L*)
8905: case " $tmp_libs " in
8906: *" $deplib "*) ;;
8907: *) func_append tmp_libs " $deplib" ;;
8908: esac
8909: ;;
8910: *) func_append tmp_libs " $deplib" ;;
8911: esac
8912: done
8913: eval $var=\"$tmp_libs\"
8914: done # for var
8915: fi
8916:
8917: # Add Sun CC postdeps if required:
8918: test CXX = "$tagname" && {
8919: case $host_os in
8920: linux*)
1.2 ! ohara 8921: case `$CC -V 2>&1 | $SED 5q` in
1.1 ohara 8922: *Sun\ C*) # Sun C++ 5.9
8923: func_suncc_cstd_abi
8924:
8925: if test no != "$suncc_use_cstd_abi"; then
8926: func_append postdeps ' -library=Cstd -library=Crun'
8927: fi
8928: ;;
8929: esac
8930: ;;
8931:
8932: solaris*)
8933: func_cc_basename "$CC"
8934: case $func_cc_basename_result in
8935: CC* | sunCC*)
8936: func_suncc_cstd_abi
8937:
8938: if test no != "$suncc_use_cstd_abi"; then
8939: func_append postdeps ' -library=Cstd -library=Crun'
8940: fi
8941: ;;
8942: esac
8943: ;;
8944: esac
8945: }
8946:
8947: # Last step: remove runtime libs from dependency_libs
8948: # (they stay in deplibs)
8949: tmp_libs=
8950: for i in $dependency_libs; do
8951: case " $predeps $postdeps $compiler_lib_search_path " in
8952: *" $i "*)
8953: i=
8954: ;;
8955: esac
8956: if test -n "$i"; then
8957: func_append tmp_libs " $i"
8958: fi
8959: done
8960: dependency_libs=$tmp_libs
8961: done # for pass
8962: if test prog = "$linkmode"; then
8963: dlfiles=$newdlfiles
8964: fi
8965: if test prog = "$linkmode" || test lib = "$linkmode"; then
8966: dlprefiles=$newdlprefiles
8967: fi
8968:
8969: case $linkmode in
8970: oldlib)
8971: if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
8972: func_warning "'-dlopen' is ignored for archives"
8973: fi
8974:
8975: case " $deplibs" in
8976: *\ -l* | *\ -L*)
8977: func_warning "'-l' and '-L' are ignored for archives" ;;
8978: esac
8979:
8980: test -n "$rpath" && \
8981: func_warning "'-rpath' is ignored for archives"
8982:
8983: test -n "$xrpath" && \
8984: func_warning "'-R' is ignored for archives"
8985:
8986: test -n "$vinfo" && \
8987: func_warning "'-version-info/-version-number' is ignored for archives"
8988:
8989: test -n "$release" && \
8990: func_warning "'-release' is ignored for archives"
8991:
8992: test -n "$export_symbols$export_symbols_regex" && \
8993: func_warning "'-export-symbols' is ignored for archives"
8994:
8995: # Now set the variables for building old libraries.
8996: build_libtool_libs=no
8997: oldlibs=$output
8998: func_append objs "$old_deplibs"
8999: ;;
9000:
9001: lib)
9002: # Make sure we only generate libraries of the form 'libNAME.la'.
9003: case $outputname in
9004: lib*)
9005: func_stripname 'lib' '.la' "$outputname"
9006: name=$func_stripname_result
9007: eval shared_ext=\"$shrext_cmds\"
9008: eval libname=\"$libname_spec\"
9009: ;;
9010: *)
9011: test no = "$module" \
9012: && func_fatal_help "libtool library '$output' must begin with 'lib'"
9013:
9014: if test no != "$need_lib_prefix"; then
9015: # Add the "lib" prefix for modules if required
9016: func_stripname '' '.la' "$outputname"
9017: name=$func_stripname_result
9018: eval shared_ext=\"$shrext_cmds\"
9019: eval libname=\"$libname_spec\"
9020: else
9021: func_stripname '' '.la' "$outputname"
9022: libname=$func_stripname_result
9023: fi
9024: ;;
9025: esac
9026:
9027: if test -n "$objs"; then
9028: if test pass_all != "$deplibs_check_method"; then
9029: func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
9030: else
9031: echo
9032: $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
9033: $ECHO "*** objects $objs is not portable!"
9034: func_append libobjs " $objs"
9035: fi
9036: fi
9037:
9038: test no = "$dlself" \
9039: || func_warning "'-dlopen self' is ignored for libtool libraries"
9040:
9041: set dummy $rpath
9042: shift
9043: test 1 -lt "$#" \
9044: && func_warning "ignoring multiple '-rpath's for a libtool library"
9045:
9046: install_libdir=$1
9047:
9048: oldlibs=
9049: if test -z "$rpath"; then
9050: if test yes = "$build_libtool_libs"; then
9051: # Building a libtool convenience library.
9052: # Some compilers have problems with a '.al' extension so
9053: # convenience libraries should have the same extension an
9054: # archive normally would.
9055: oldlibs="$output_objdir/$libname.$libext $oldlibs"
9056: build_libtool_libs=convenience
9057: build_old_libs=yes
9058: fi
9059:
9060: test -n "$vinfo" && \
9061: func_warning "'-version-info/-version-number' is ignored for convenience libraries"
9062:
9063: test -n "$release" && \
9064: func_warning "'-release' is ignored for convenience libraries"
9065: else
9066:
9067: # Parse the version information argument.
9068: save_ifs=$IFS; IFS=:
9069: set dummy $vinfo 0 0 0
9070: shift
9071: IFS=$save_ifs
9072:
9073: test -n "$7" && \
9074: func_fatal_help "too many parameters to '-version-info'"
9075:
9076: # convert absolute version numbers to libtool ages
9077: # this retains compatibility with .la files and attempts
9078: # to make the code below a bit more comprehensible
9079:
9080: case $vinfo_number in
9081: yes)
9082: number_major=$1
9083: number_minor=$2
9084: number_revision=$3
9085: #
9086: # There are really only two kinds -- those that
9087: # use the current revision as the major version
9088: # and those that subtract age and use age as
9089: # a minor version. But, then there is irix
9090: # that has an extra 1 added just for fun
9091: #
9092: case $version_type in
9093: # correct linux to gnu/linux during the next big refactor
1.2 ! ohara 9094: darwin|freebsd-elf|linux|midnightbsd-elf|osf|windows|none)
1.1 ohara 9095: func_arith $number_major + $number_minor
9096: current=$func_arith_result
9097: age=$number_minor
9098: revision=$number_revision
9099: ;;
9100: freebsd-aout|qnx|sunos)
9101: current=$number_major
9102: revision=$number_minor
9103: age=0
9104: ;;
9105: irix|nonstopux)
9106: func_arith $number_major + $number_minor
9107: current=$func_arith_result
9108: age=$number_minor
9109: revision=$number_minor
9110: lt_irix_increment=no
9111: ;;
9112: esac
9113: ;;
9114: no)
9115: current=$1
9116: revision=$2
9117: age=$3
9118: ;;
9119: esac
9120:
9121: # Check that each of the things are valid numbers.
9122: case $current in
9123: 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9124: *)
9125: func_error "CURRENT '$current' must be a nonnegative integer"
9126: func_fatal_error "'$vinfo' is not valid version information"
9127: ;;
9128: esac
9129:
9130: case $revision in
9131: 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9132: *)
9133: func_error "REVISION '$revision' must be a nonnegative integer"
9134: func_fatal_error "'$vinfo' is not valid version information"
9135: ;;
9136: esac
9137:
9138: case $age in
9139: 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9140: *)
9141: func_error "AGE '$age' must be a nonnegative integer"
9142: func_fatal_error "'$vinfo' is not valid version information"
9143: ;;
9144: esac
9145:
9146: if test "$age" -gt "$current"; then
9147: func_error "AGE '$age' is greater than the current interface number '$current'"
9148: func_fatal_error "'$vinfo' is not valid version information"
9149: fi
9150:
9151: # Calculate the version variables.
9152: major=
9153: versuffix=
9154: verstring=
9155: case $version_type in
9156: none) ;;
9157:
9158: darwin)
9159: # Like Linux, but with the current version available in
9160: # verstring for coding it into the library header
9161: func_arith $current - $age
9162: major=.$func_arith_result
9163: versuffix=$major.$age.$revision
9164: # Darwin ld doesn't like 0 for these options...
9165: func_arith $current + 1
9166: minor_current=$func_arith_result
9167: xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
9168: verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
9169: # On Darwin other compilers
9170: case $CC in
9171: nagfor*)
9172: verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
9173: ;;
9174: *)
9175: verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
9176: ;;
9177: esac
9178: ;;
9179:
9180: freebsd-aout)
9181: major=.$current
9182: versuffix=.$current.$revision
9183: ;;
9184:
1.2 ! ohara 9185: freebsd-elf | midnightbsd-elf)
1.1 ohara 9186: func_arith $current - $age
9187: major=.$func_arith_result
9188: versuffix=$major.$age.$revision
9189: ;;
9190:
9191: irix | nonstopux)
9192: if test no = "$lt_irix_increment"; then
9193: func_arith $current - $age
9194: else
9195: func_arith $current - $age + 1
9196: fi
9197: major=$func_arith_result
9198:
9199: case $version_type in
9200: nonstopux) verstring_prefix=nonstopux ;;
9201: *) verstring_prefix=sgi ;;
9202: esac
9203: verstring=$verstring_prefix$major.$revision
9204:
9205: # Add in all the interfaces that we are compatible with.
9206: loop=$revision
9207: while test 0 -ne "$loop"; do
9208: func_arith $revision - $loop
9209: iface=$func_arith_result
9210: func_arith $loop - 1
9211: loop=$func_arith_result
9212: verstring=$verstring_prefix$major.$iface:$verstring
9213: done
9214:
9215: # Before this point, $major must not contain '.'.
9216: major=.$major
9217: versuffix=$major.$revision
9218: ;;
9219:
9220: linux) # correct to gnu/linux during the next big refactor
9221: func_arith $current - $age
9222: major=.$func_arith_result
9223: versuffix=$major.$age.$revision
9224: ;;
9225:
9226: osf)
9227: func_arith $current - $age
9228: major=.$func_arith_result
9229: versuffix=.$current.$age.$revision
9230: verstring=$current.$age.$revision
9231:
9232: # Add in all the interfaces that we are compatible with.
9233: loop=$age
9234: while test 0 -ne "$loop"; do
9235: func_arith $current - $loop
9236: iface=$func_arith_result
9237: func_arith $loop - 1
9238: loop=$func_arith_result
9239: verstring=$verstring:$iface.0
9240: done
9241:
9242: # Make executables depend on our current version.
9243: func_append verstring ":$current.0"
9244: ;;
9245:
9246: qnx)
9247: major=.$current
9248: versuffix=.$current
9249: ;;
9250:
9251: sco)
9252: major=.$current
9253: versuffix=.$current
9254: ;;
9255:
9256: sunos)
9257: major=.$current
9258: versuffix=.$current.$revision
9259: ;;
9260:
9261: windows)
9262: # Use '-' rather than '.', since we only want one
9263: # extension on DOS 8.3 file systems.
9264: func_arith $current - $age
9265: major=$func_arith_result
9266: versuffix=-$major
9267: ;;
9268:
9269: *)
9270: func_fatal_configuration "unknown library version type '$version_type'"
9271: ;;
9272: esac
9273:
9274: # Clear the version info if we defaulted, and they specified a release.
9275: if test -z "$vinfo" && test -n "$release"; then
9276: major=
9277: case $version_type in
9278: darwin)
9279: # we can't check for "0.0" in archive_cmds due to quoting
9280: # problems, so we reset it completely
9281: verstring=
9282: ;;
9283: *)
9284: verstring=0.0
9285: ;;
9286: esac
9287: if test no = "$need_version"; then
9288: versuffix=
9289: else
9290: versuffix=.0.0
9291: fi
9292: fi
9293:
9294: # Remove version info from name if versioning should be avoided
9295: if test yes,no = "$avoid_version,$need_version"; then
9296: major=
9297: versuffix=
9298: verstring=
9299: fi
9300:
9301: # Check to see if the archive will have undefined symbols.
9302: if test yes = "$allow_undefined"; then
9303: if test unsupported = "$allow_undefined_flag"; then
9304: if test yes = "$build_old_libs"; then
9305: func_warning "undefined symbols not allowed in $host shared libraries; building static only"
9306: build_libtool_libs=no
9307: else
9308: func_fatal_error "can't build $host shared library unless -no-undefined is specified"
9309: fi
9310: fi
9311: else
9312: # Don't allow undefined symbols.
9313: allow_undefined_flag=$no_undefined_flag
9314: fi
9315:
9316: fi
9317:
9318: func_generate_dlsyms "$libname" "$libname" :
9319: func_append libobjs " $symfileobj"
9320: test " " = "$libobjs" && libobjs=
9321:
9322: if test relink != "$opt_mode"; then
9323: # Remove our outputs, but don't remove object files since they
9324: # may have been created when compiling PIC objects.
9325: removelist=
9326: tempremovelist=`$ECHO "$output_objdir/*"`
9327: for p in $tempremovelist; do
9328: case $p in
9329: *.$objext | *.gcno)
9330: ;;
9331: $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
9332: if test -n "$precious_files_regex"; then
9333: if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
9334: then
9335: continue
9336: fi
9337: fi
9338: func_append removelist " $p"
9339: ;;
9340: *) ;;
9341: esac
9342: done
9343: test -n "$removelist" && \
9344: func_show_eval "${RM}r \$removelist"
9345: fi
9346:
9347: # Now set the variables for building old libraries.
9348: if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
9349: func_append oldlibs " $output_objdir/$libname.$libext"
9350:
9351: # Transform .lo files to .o files.
9352: oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
9353: fi
9354:
9355: # Eliminate all temporary directories.
9356: #for path in $notinst_path; do
9357: # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
9358: # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
9359: # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
9360: #done
9361:
9362: if test -n "$xrpath"; then
9363: # If the user specified any rpath flags, then add them.
9364: temp_xrpath=
9365: for libdir in $xrpath; do
9366: func_replace_sysroot "$libdir"
9367: func_append temp_xrpath " -R$func_replace_sysroot_result"
9368: case "$finalize_rpath " in
9369: *" $libdir "*) ;;
9370: *) func_append finalize_rpath " $libdir" ;;
9371: esac
9372: done
9373: if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
9374: dependency_libs="$temp_xrpath $dependency_libs"
9375: fi
9376: fi
9377:
9378: # Make sure dlfiles contains only unique files that won't be dlpreopened
9379: old_dlfiles=$dlfiles
9380: dlfiles=
9381: for lib in $old_dlfiles; do
9382: case " $dlprefiles $dlfiles " in
9383: *" $lib "*) ;;
9384: *) func_append dlfiles " $lib" ;;
9385: esac
9386: done
9387:
9388: # Make sure dlprefiles contains only unique files
9389: old_dlprefiles=$dlprefiles
9390: dlprefiles=
9391: for lib in $old_dlprefiles; do
9392: case "$dlprefiles " in
9393: *" $lib "*) ;;
9394: *) func_append dlprefiles " $lib" ;;
9395: esac
9396: done
9397:
9398: if test yes = "$build_libtool_libs"; then
9399: if test -n "$rpath"; then
9400: case $host in
9401: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
9402: # these systems don't actually have a c library (as such)!
9403: ;;
9404: *-*-rhapsody* | *-*-darwin1.[012])
9405: # Rhapsody C library is in the System framework
9406: func_append deplibs " System.ltframework"
9407: ;;
9408: *-*-netbsd*)
9409: # Don't link with libc until the a.out ld.so is fixed.
9410: ;;
1.2 ! ohara 9411: *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-midnightbsd*)
1.1 ohara 9412: # Do not include libc due to us having libc/libc_r.
9413: ;;
9414: *-*-sco3.2v5* | *-*-sco5v6*)
9415: # Causes problems with __ctype
9416: ;;
9417: *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
9418: # Compiler inserts libc in the correct place for threads to work
9419: ;;
9420: *)
9421: # Add libc to deplibs on all other systems if necessary.
9422: if test yes = "$build_libtool_need_lc"; then
9423: func_append deplibs " -lc"
9424: fi
9425: ;;
9426: esac
9427: fi
9428:
9429: # Transform deplibs into only deplibs that can be linked in shared.
9430: name_save=$name
9431: libname_save=$libname
9432: release_save=$release
9433: versuffix_save=$versuffix
9434: major_save=$major
9435: # I'm not sure if I'm treating the release correctly. I think
9436: # release should show up in the -l (ie -lgmp5) so we don't want to
9437: # add it in twice. Is that correct?
9438: release=
9439: versuffix=
9440: major=
9441: newdeplibs=
9442: droppeddeps=no
9443: case $deplibs_check_method in
9444: pass_all)
9445: # Don't check for shared/static. Everything works.
9446: # This might be a little naive. We might want to check
9447: # whether the library exists or not. But this is on
9448: # osf3 & osf4 and I'm not really sure... Just
9449: # implementing what was already the behavior.
9450: newdeplibs=$deplibs
9451: ;;
9452: test_compile)
9453: # This code stresses the "libraries are programs" paradigm to its
9454: # limits. Maybe even breaks it. We compile a program, linking it
9455: # against the deplibs as a proxy for the library. Then we can check
9456: # whether they linked in statically or dynamically with ldd.
9457: $opt_dry_run || $RM conftest.c
9458: cat > conftest.c <<EOF
9459: int main() { return 0; }
9460: EOF
9461: $opt_dry_run || $RM conftest
9462: if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
9463: ldd_output=`ldd conftest`
9464: for i in $deplibs; do
9465: case $i in
9466: -l*)
9467: func_stripname -l '' "$i"
9468: name=$func_stripname_result
9469: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9470: case " $predeps $postdeps " in
9471: *" $i "*)
9472: func_append newdeplibs " $i"
9473: i=
9474: ;;
9475: esac
9476: fi
9477: if test -n "$i"; then
9478: libname=`eval "\\$ECHO \"$libname_spec\""`
9479: deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
9480: set dummy $deplib_matches; shift
9481: deplib_match=$1
9482: if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
9483: func_append newdeplibs " $i"
9484: else
9485: droppeddeps=yes
9486: echo
9487: $ECHO "*** Warning: dynamic linker does not accept needed library $i."
9488: echo "*** I have the capability to make that library automatically link in when"
9489: echo "*** you link to this library. But I can only do this if you have a"
9490: echo "*** shared version of the library, which I believe you do not have"
9491: echo "*** because a test_compile did reveal that the linker did not use it for"
9492: echo "*** its dynamic dependency list that programs get resolved with at runtime."
9493: fi
9494: fi
9495: ;;
9496: *)
9497: func_append newdeplibs " $i"
9498: ;;
9499: esac
9500: done
9501: else
9502: # Error occurred in the first compile. Let's try to salvage
9503: # the situation: Compile a separate program for each library.
9504: for i in $deplibs; do
9505: case $i in
9506: -l*)
9507: func_stripname -l '' "$i"
9508: name=$func_stripname_result
9509: $opt_dry_run || $RM conftest
9510: if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
9511: ldd_output=`ldd conftest`
9512: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9513: case " $predeps $postdeps " in
9514: *" $i "*)
9515: func_append newdeplibs " $i"
9516: i=
9517: ;;
9518: esac
9519: fi
9520: if test -n "$i"; then
9521: libname=`eval "\\$ECHO \"$libname_spec\""`
9522: deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
9523: set dummy $deplib_matches; shift
9524: deplib_match=$1
9525: if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
9526: func_append newdeplibs " $i"
9527: else
9528: droppeddeps=yes
9529: echo
9530: $ECHO "*** Warning: dynamic linker does not accept needed library $i."
9531: echo "*** I have the capability to make that library automatically link in when"
9532: echo "*** you link to this library. But I can only do this if you have a"
9533: echo "*** shared version of the library, which you do not appear to have"
9534: echo "*** because a test_compile did reveal that the linker did not use this one"
9535: echo "*** as a dynamic dependency that programs can get resolved with at runtime."
9536: fi
9537: fi
9538: else
9539: droppeddeps=yes
9540: echo
9541: $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
9542: echo "*** make it link in! You will probably need to install it or some"
9543: echo "*** library that it depends on before this library will be fully"
9544: echo "*** functional. Installing it before continuing would be even better."
9545: fi
9546: ;;
9547: *)
9548: func_append newdeplibs " $i"
9549: ;;
9550: esac
9551: done
9552: fi
9553: ;;
9554: file_magic*)
9555: set dummy $deplibs_check_method; shift
9556: file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
9557: for a_deplib in $deplibs; do
9558: case $a_deplib in
9559: -l*)
9560: func_stripname -l '' "$a_deplib"
9561: name=$func_stripname_result
9562: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9563: case " $predeps $postdeps " in
9564: *" $a_deplib "*)
9565: func_append newdeplibs " $a_deplib"
9566: a_deplib=
9567: ;;
9568: esac
9569: fi
9570: if test -n "$a_deplib"; then
9571: libname=`eval "\\$ECHO \"$libname_spec\""`
9572: if test -n "$file_magic_glob"; then
9573: libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
9574: else
9575: libnameglob=$libname
9576: fi
9577: test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
9578: for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9579: if test yes = "$want_nocaseglob"; then
9580: shopt -s nocaseglob
9581: potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9582: $nocaseglob
9583: else
9584: potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9585: fi
9586: for potent_lib in $potential_libs; do
9587: # Follow soft links.
9588: if ls -lLd "$potent_lib" 2>/dev/null |
9589: $GREP " -> " >/dev/null; then
9590: continue
9591: fi
9592: # The statement above tries to avoid entering an
9593: # endless loop below, in case of cyclic links.
9594: # We might still enter an endless loop, since a link
9595: # loop can be closed while we follow links,
9596: # but so what?
9597: potlib=$potent_lib
9598: while test -h "$potlib" 2>/dev/null; do
9599: potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
9600: case $potliblink in
9601: [\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
9602: *) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
9603: esac
9604: done
9605: if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
9606: $SED -e 10q |
9607: $EGREP "$file_magic_regex" > /dev/null; then
9608: func_append newdeplibs " $a_deplib"
9609: a_deplib=
9610: break 2
9611: fi
9612: done
9613: done
9614: fi
9615: if test -n "$a_deplib"; then
9616: droppeddeps=yes
9617: echo
9618: $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9619: echo "*** I have the capability to make that library automatically link in when"
9620: echo "*** you link to this library. But I can only do this if you have a"
9621: echo "*** shared version of the library, which you do not appear to have"
9622: echo "*** because I did check the linker path looking for a file starting"
9623: if test -z "$potlib"; then
9624: $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
9625: else
9626: $ECHO "*** with $libname and none of the candidates passed a file format test"
9627: $ECHO "*** using a file magic. Last file checked: $potlib"
9628: fi
9629: fi
9630: ;;
9631: *)
9632: # Add a -L argument.
9633: func_append newdeplibs " $a_deplib"
9634: ;;
9635: esac
9636: done # Gone through all deplibs.
9637: ;;
9638: match_pattern*)
9639: set dummy $deplibs_check_method; shift
9640: match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
9641: for a_deplib in $deplibs; do
9642: case $a_deplib in
9643: -l*)
9644: func_stripname -l '' "$a_deplib"
9645: name=$func_stripname_result
9646: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9647: case " $predeps $postdeps " in
9648: *" $a_deplib "*)
9649: func_append newdeplibs " $a_deplib"
9650: a_deplib=
9651: ;;
9652: esac
9653: fi
9654: if test -n "$a_deplib"; then
9655: libname=`eval "\\$ECHO \"$libname_spec\""`
9656: for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9657: potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
9658: for potent_lib in $potential_libs; do
9659: potlib=$potent_lib # see symlink-check above in file_magic test
9660: if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
9661: $EGREP "$match_pattern_regex" > /dev/null; then
9662: func_append newdeplibs " $a_deplib"
9663: a_deplib=
9664: break 2
9665: fi
9666: done
9667: done
9668: fi
9669: if test -n "$a_deplib"; then
9670: droppeddeps=yes
9671: echo
9672: $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9673: echo "*** I have the capability to make that library automatically link in when"
9674: echo "*** you link to this library. But I can only do this if you have a"
9675: echo "*** shared version of the library, which you do not appear to have"
9676: echo "*** because I did check the linker path looking for a file starting"
9677: if test -z "$potlib"; then
9678: $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
9679: else
9680: $ECHO "*** with $libname and none of the candidates passed a file format test"
9681: $ECHO "*** using a regex pattern. Last file checked: $potlib"
9682: fi
9683: fi
9684: ;;
9685: *)
9686: # Add a -L argument.
9687: func_append newdeplibs " $a_deplib"
9688: ;;
9689: esac
9690: done # Gone through all deplibs.
9691: ;;
9692: none | unknown | *)
9693: newdeplibs=
9694: tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
9695: if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9696: for i in $predeps $postdeps; do
9697: # can't use Xsed below, because $i might contain '/'
9698: tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
9699: done
9700: fi
9701: case $tmp_deplibs in
9702: *[!\ \ ]*)
9703: echo
9704: if test none = "$deplibs_check_method"; then
9705: echo "*** Warning: inter-library dependencies are not supported in this platform."
9706: else
9707: echo "*** Warning: inter-library dependencies are not known to be supported."
9708: fi
9709: echo "*** All declared inter-library dependencies are being dropped."
9710: droppeddeps=yes
9711: ;;
9712: esac
9713: ;;
9714: esac
9715: versuffix=$versuffix_save
9716: major=$major_save
9717: release=$release_save
9718: libname=$libname_save
9719: name=$name_save
9720:
9721: case $host in
9722: *-*-rhapsody* | *-*-darwin1.[012])
9723: # On Rhapsody replace the C library with the System framework
9724: newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
9725: ;;
9726: esac
9727:
9728: if test yes = "$droppeddeps"; then
9729: if test yes = "$module"; then
9730: echo
9731: echo "*** Warning: libtool could not satisfy all declared inter-library"
9732: $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
9733: echo "*** a static module, that should work as long as the dlopening"
9734: echo "*** application is linked with the -dlopen flag."
9735: if test -z "$global_symbol_pipe"; then
9736: echo
9737: echo "*** However, this would only work if libtool was able to extract symbol"
9738: echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
9739: echo "*** not find such a program. So, this module is probably useless."
9740: echo "*** 'nm' from GNU binutils and a full rebuild may help."
9741: fi
9742: if test no = "$build_old_libs"; then
9743: oldlibs=$output_objdir/$libname.$libext
9744: build_libtool_libs=module
9745: build_old_libs=yes
9746: else
9747: build_libtool_libs=no
9748: fi
9749: else
9750: echo "*** The inter-library dependencies that have been dropped here will be"
9751: echo "*** automatically added whenever a program is linked with this library"
9752: echo "*** or is declared to -dlopen it."
9753:
9754: if test no = "$allow_undefined"; then
9755: echo
9756: echo "*** Since this library must not contain undefined symbols,"
9757: echo "*** because either the platform does not support them or"
9758: echo "*** it was explicitly requested with -no-undefined,"
9759: echo "*** libtool will only create a static version of it."
9760: if test no = "$build_old_libs"; then
9761: oldlibs=$output_objdir/$libname.$libext
9762: build_libtool_libs=module
9763: build_old_libs=yes
9764: else
9765: build_libtool_libs=no
9766: fi
9767: fi
9768: fi
9769: fi
9770: # Done checking deplibs!
9771: deplibs=$newdeplibs
9772: fi
9773: # Time to change all our "foo.ltframework" stuff back to "-framework foo"
9774: case $host in
9775: *-*-darwin*)
9776: newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9777: new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9778: deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9779: ;;
9780: esac
9781:
9782: # move library search paths that coincide with paths to not yet
9783: # installed libraries to the beginning of the library search list
9784: new_libs=
9785: for path in $notinst_path; do
9786: case " $new_libs " in
9787: *" -L$path/$objdir "*) ;;
9788: *)
9789: case " $deplibs " in
9790: *" -L$path/$objdir "*)
9791: func_append new_libs " -L$path/$objdir" ;;
9792: esac
9793: ;;
9794: esac
9795: done
9796: for deplib in $deplibs; do
9797: case $deplib in
9798: -L*)
9799: case " $new_libs " in
9800: *" $deplib "*) ;;
9801: *) func_append new_libs " $deplib" ;;
9802: esac
9803: ;;
9804: *) func_append new_libs " $deplib" ;;
9805: esac
9806: done
9807: deplibs=$new_libs
9808:
9809: # All the library-specific variables (install_libdir is set above).
9810: library_names=
9811: old_library=
9812: dlname=
9813:
9814: # Test again, we may have decided not to build it any more
9815: if test yes = "$build_libtool_libs"; then
9816: # Remove $wl instances when linking with ld.
9817: # FIXME: should test the right _cmds variable.
9818: case $archive_cmds in
9819: *\$LD\ *) wl= ;;
9820: esac
9821: if test yes = "$hardcode_into_libs"; then
9822: # Hardcode the library paths
9823: hardcode_libdirs=
9824: dep_rpath=
9825: rpath=$finalize_rpath
9826: test relink = "$opt_mode" || rpath=$compile_rpath$rpath
9827: for libdir in $rpath; do
9828: if test -n "$hardcode_libdir_flag_spec"; then
9829: if test -n "$hardcode_libdir_separator"; then
9830: func_replace_sysroot "$libdir"
9831: libdir=$func_replace_sysroot_result
9832: if test -z "$hardcode_libdirs"; then
9833: hardcode_libdirs=$libdir
9834: else
9835: # Just accumulate the unique libdirs.
9836: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
9837: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
9838: ;;
9839: *)
9840: func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
9841: ;;
9842: esac
9843: fi
9844: else
9845: eval flag=\"$hardcode_libdir_flag_spec\"
9846: func_append dep_rpath " $flag"
9847: fi
9848: elif test -n "$runpath_var"; then
9849: case "$perm_rpath " in
9850: *" $libdir "*) ;;
9851: *) func_append perm_rpath " $libdir" ;;
9852: esac
9853: fi
9854: done
9855: # Substitute the hardcoded libdirs into the rpath.
9856: if test -n "$hardcode_libdir_separator" &&
9857: test -n "$hardcode_libdirs"; then
9858: libdir=$hardcode_libdirs
9859: eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
9860: fi
9861: if test -n "$runpath_var" && test -n "$perm_rpath"; then
9862: # We should set the runpath_var.
9863: rpath=
9864: for dir in $perm_rpath; do
9865: func_append rpath "$dir:"
9866: done
9867: eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
9868: fi
9869: test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
9870: fi
9871:
9872: shlibpath=$finalize_shlibpath
9873: test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
9874: if test -n "$shlibpath"; then
9875: eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
9876: fi
9877:
9878: # Get the real and link names of the library.
9879: eval shared_ext=\"$shrext_cmds\"
9880: eval library_names=\"$library_names_spec\"
9881: set dummy $library_names
9882: shift
9883: realname=$1
9884: shift
9885:
9886: if test -n "$soname_spec"; then
9887: eval soname=\"$soname_spec\"
9888: else
9889: soname=$realname
9890: fi
9891: if test -z "$dlname"; then
9892: dlname=$soname
9893: fi
9894:
9895: lib=$output_objdir/$realname
9896: linknames=
9897: for link
9898: do
9899: func_append linknames " $link"
9900: done
9901:
9902: # Use standard objects if they are pic
9903: test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
9904: test "X$libobjs" = "X " && libobjs=
9905:
9906: delfiles=
9907: if test -n "$export_symbols" && test -n "$include_expsyms"; then
9908: $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
9909: export_symbols=$output_objdir/$libname.uexp
9910: func_append delfiles " $export_symbols"
9911: fi
9912:
9913: orig_export_symbols=
9914: case $host_os in
9915: cygwin* | mingw* | cegcc*)
9916: if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
9917: # exporting using user supplied symfile
9918: func_dll_def_p "$export_symbols" || {
9919: # and it's NOT already a .def file. Must figure out
9920: # which of the given symbols are data symbols and tag
9921: # them as such. So, trigger use of export_symbols_cmds.
9922: # export_symbols gets reassigned inside the "prepare
9923: # the list of exported symbols" if statement, so the
9924: # include_expsyms logic still works.
9925: orig_export_symbols=$export_symbols
9926: export_symbols=
9927: always_export_symbols=yes
9928: }
9929: fi
9930: ;;
9931: esac
9932:
9933: # Prepare the list of exported symbols
9934: if test -z "$export_symbols"; then
9935: if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
9936: func_verbose "generating symbol list for '$libname.la'"
9937: export_symbols=$output_objdir/$libname.exp
9938: $opt_dry_run || $RM $export_symbols
9939: cmds=$export_symbols_cmds
9940: save_ifs=$IFS; IFS='~'
9941: for cmd1 in $cmds; do
9942: IFS=$save_ifs
9943: # Take the normal branch if the nm_file_list_spec branch
9944: # doesn't work or if tool conversion is not needed.
9945: case $nm_file_list_spec~$to_tool_file_cmd in
9946: *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
9947: try_normal_branch=yes
9948: eval cmd=\"$cmd1\"
9949: func_len " $cmd"
9950: len=$func_len_result
9951: ;;
9952: *)
9953: try_normal_branch=no
9954: ;;
9955: esac
9956: if test yes = "$try_normal_branch" \
9957: && { test "$len" -lt "$max_cmd_len" \
9958: || test "$max_cmd_len" -le -1; }
9959: then
9960: func_show_eval "$cmd" 'exit $?'
9961: skipped_export=false
9962: elif test -n "$nm_file_list_spec"; then
9963: func_basename "$output"
9964: output_la=$func_basename_result
9965: save_libobjs=$libobjs
9966: save_output=$output
9967: output=$output_objdir/$output_la.nm
9968: func_to_tool_file "$output"
9969: libobjs=$nm_file_list_spec$func_to_tool_file_result
9970: func_append delfiles " $output"
9971: func_verbose "creating $NM input file list: $output"
9972: for obj in $save_libobjs; do
9973: func_to_tool_file "$obj"
9974: $ECHO "$func_to_tool_file_result"
9975: done > "$output"
9976: eval cmd=\"$cmd1\"
9977: func_show_eval "$cmd" 'exit $?'
9978: output=$save_output
9979: libobjs=$save_libobjs
9980: skipped_export=false
9981: else
9982: # The command line is too long to execute in one step.
9983: func_verbose "using reloadable object file for export list..."
9984: skipped_export=:
9985: # Break out early, otherwise skipped_export may be
9986: # set to false by a later but shorter cmd.
9987: break
9988: fi
9989: done
9990: IFS=$save_ifs
9991: if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
9992: func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
9993: func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
9994: fi
9995: fi
9996: fi
9997:
9998: if test -n "$export_symbols" && test -n "$include_expsyms"; then
9999: tmp_export_symbols=$export_symbols
10000: test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
10001: $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
10002: fi
10003:
10004: if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
10005: # The given exports_symbols file has to be filtered, so filter it.
10006: func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
10007: # FIXME: $output_objdir/$libname.filter potentially contains lots of
10008: # 's' commands, which not all seds can handle. GNU sed should be fine
10009: # though. Also, the filter scales superlinearly with the number of
10010: # global variables. join(1) would be nice here, but unfortunately
10011: # isn't a blessed tool.
10012: $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
10013: func_append delfiles " $export_symbols $output_objdir/$libname.filter"
10014: export_symbols=$output_objdir/$libname.def
10015: $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
10016: fi
10017:
10018: tmp_deplibs=
10019: for test_deplib in $deplibs; do
10020: case " $convenience " in
10021: *" $test_deplib "*) ;;
10022: *)
10023: func_append tmp_deplibs " $test_deplib"
10024: ;;
10025: esac
10026: done
10027: deplibs=$tmp_deplibs
10028:
10029: if test -n "$convenience"; then
10030: if test -n "$whole_archive_flag_spec" &&
10031: test yes = "$compiler_needs_object" &&
10032: test -z "$libobjs"; then
10033: # extract the archives, so we have objects to list.
10034: # TODO: could optimize this to just extract one archive.
10035: whole_archive_flag_spec=
10036: fi
10037: if test -n "$whole_archive_flag_spec"; then
10038: save_libobjs=$libobjs
10039: eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
10040: test "X$libobjs" = "X " && libobjs=
10041: else
10042: gentop=$output_objdir/${outputname}x
10043: func_append generated " $gentop"
10044:
10045: func_extract_archives $gentop $convenience
10046: func_append libobjs " $func_extract_archives_result"
10047: test "X$libobjs" = "X " && libobjs=
10048: fi
10049: fi
10050:
10051: if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
10052: eval flag=\"$thread_safe_flag_spec\"
10053: func_append linker_flags " $flag"
10054: fi
10055:
10056: # Make a backup of the uninstalled library when relinking
10057: if test relink = "$opt_mode"; then
10058: $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
10059: fi
10060:
10061: # Do each of the archive commands.
10062: if test yes = "$module" && test -n "$module_cmds"; then
10063: if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
10064: eval test_cmds=\"$module_expsym_cmds\"
10065: cmds=$module_expsym_cmds
10066: else
10067: eval test_cmds=\"$module_cmds\"
10068: cmds=$module_cmds
10069: fi
10070: else
10071: if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
10072: eval test_cmds=\"$archive_expsym_cmds\"
10073: cmds=$archive_expsym_cmds
10074: else
10075: eval test_cmds=\"$archive_cmds\"
10076: cmds=$archive_cmds
10077: fi
10078: fi
10079:
10080: if test : != "$skipped_export" &&
10081: func_len " $test_cmds" &&
10082: len=$func_len_result &&
10083: test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
10084: :
10085: else
10086: # The command line is too long to link in one step, link piecewise
10087: # or, if using GNU ld and skipped_export is not :, use a linker
10088: # script.
10089:
10090: # Save the value of $output and $libobjs because we want to
10091: # use them later. If we have whole_archive_flag_spec, we
10092: # want to use save_libobjs as it was before
10093: # whole_archive_flag_spec was expanded, because we can't
10094: # assume the linker understands whole_archive_flag_spec.
10095: # This may have to be revisited, in case too many
10096: # convenience libraries get linked in and end up exceeding
10097: # the spec.
10098: if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
10099: save_libobjs=$libobjs
10100: fi
10101: save_output=$output
10102: func_basename "$output"
10103: output_la=$func_basename_result
10104:
10105: # Clear the reloadable object creation command queue and
10106: # initialize k to one.
10107: test_cmds=
10108: concat_cmds=
10109: objlist=
10110: last_robj=
10111: k=1
10112:
10113: if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
10114: output=$output_objdir/$output_la.lnkscript
10115: func_verbose "creating GNU ld script: $output"
10116: echo 'INPUT (' > $output
10117: for obj in $save_libobjs
10118: do
10119: func_to_tool_file "$obj"
10120: $ECHO "$func_to_tool_file_result" >> $output
10121: done
10122: echo ')' >> $output
10123: func_append delfiles " $output"
10124: func_to_tool_file "$output"
10125: output=$func_to_tool_file_result
10126: elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
10127: output=$output_objdir/$output_la.lnk
10128: func_verbose "creating linker input file list: $output"
10129: : > $output
10130: set x $save_libobjs
10131: shift
10132: firstobj=
10133: if test yes = "$compiler_needs_object"; then
10134: firstobj="$1 "
10135: shift
10136: fi
10137: for obj
10138: do
10139: func_to_tool_file "$obj"
10140: $ECHO "$func_to_tool_file_result" >> $output
10141: done
10142: func_append delfiles " $output"
10143: func_to_tool_file "$output"
10144: output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
10145: else
10146: if test -n "$save_libobjs"; then
10147: func_verbose "creating reloadable object files..."
10148: output=$output_objdir/$output_la-$k.$objext
10149: eval test_cmds=\"$reload_cmds\"
10150: func_len " $test_cmds"
10151: len0=$func_len_result
10152: len=$len0
10153:
10154: # Loop over the list of objects to be linked.
10155: for obj in $save_libobjs
10156: do
10157: func_len " $obj"
10158: func_arith $len + $func_len_result
10159: len=$func_arith_result
10160: if test -z "$objlist" ||
10161: test "$len" -lt "$max_cmd_len"; then
10162: func_append objlist " $obj"
10163: else
10164: # The command $test_cmds is almost too long, add a
10165: # command to the queue.
10166: if test 1 -eq "$k"; then
10167: # The first file doesn't have a previous command to add.
10168: reload_objs=$objlist
10169: eval concat_cmds=\"$reload_cmds\"
10170: else
10171: # All subsequent reloadable object files will link in
10172: # the last one created.
10173: reload_objs="$objlist $last_robj"
10174: eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
10175: fi
10176: last_robj=$output_objdir/$output_la-$k.$objext
10177: func_arith $k + 1
10178: k=$func_arith_result
10179: output=$output_objdir/$output_la-$k.$objext
10180: objlist=" $obj"
10181: func_len " $last_robj"
10182: func_arith $len0 + $func_len_result
10183: len=$func_arith_result
10184: fi
10185: done
10186: # Handle the remaining objects by creating one last
10187: # reloadable object file. All subsequent reloadable object
10188: # files will link in the last one created.
10189: test -z "$concat_cmds" || concat_cmds=$concat_cmds~
10190: reload_objs="$objlist $last_robj"
10191: eval concat_cmds=\"\$concat_cmds$reload_cmds\"
10192: if test -n "$last_robj"; then
10193: eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
10194: fi
10195: func_append delfiles " $output"
10196:
10197: else
10198: output=
10199: fi
10200:
10201: ${skipped_export-false} && {
10202: func_verbose "generating symbol list for '$libname.la'"
10203: export_symbols=$output_objdir/$libname.exp
10204: $opt_dry_run || $RM $export_symbols
10205: libobjs=$output
10206: # Append the command to create the export file.
10207: test -z "$concat_cmds" || concat_cmds=$concat_cmds~
10208: eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
10209: if test -n "$last_robj"; then
10210: eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
10211: fi
10212: }
10213:
10214: test -n "$save_libobjs" &&
10215: func_verbose "creating a temporary reloadable object file: $output"
10216:
10217: # Loop through the commands generated above and execute them.
10218: save_ifs=$IFS; IFS='~'
10219: for cmd in $concat_cmds; do
10220: IFS=$save_ifs
10221: $opt_quiet || {
1.2 ! ohara 10222: func_quote_arg expand,pretty "$cmd"
! 10223: eval "func_echo $func_quote_arg_result"
1.1 ohara 10224: }
10225: $opt_dry_run || eval "$cmd" || {
10226: lt_exit=$?
10227:
10228: # Restore the uninstalled library and exit
10229: if test relink = "$opt_mode"; then
10230: ( cd "$output_objdir" && \
10231: $RM "${realname}T" && \
10232: $MV "${realname}U" "$realname" )
10233: fi
10234:
10235: exit $lt_exit
10236: }
10237: done
10238: IFS=$save_ifs
10239:
10240: if test -n "$export_symbols_regex" && ${skipped_export-false}; then
10241: func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
10242: func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
10243: fi
10244: fi
10245:
10246: ${skipped_export-false} && {
10247: if test -n "$export_symbols" && test -n "$include_expsyms"; then
10248: tmp_export_symbols=$export_symbols
10249: test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
10250: $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
10251: fi
10252:
10253: if test -n "$orig_export_symbols"; then
10254: # The given exports_symbols file has to be filtered, so filter it.
10255: func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
10256: # FIXME: $output_objdir/$libname.filter potentially contains lots of
10257: # 's' commands, which not all seds can handle. GNU sed should be fine
10258: # though. Also, the filter scales superlinearly with the number of
10259: # global variables. join(1) would be nice here, but unfortunately
10260: # isn't a blessed tool.
10261: $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
10262: func_append delfiles " $export_symbols $output_objdir/$libname.filter"
10263: export_symbols=$output_objdir/$libname.def
10264: $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
10265: fi
10266: }
10267:
10268: libobjs=$output
10269: # Restore the value of output.
10270: output=$save_output
10271:
10272: if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
10273: eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
10274: test "X$libobjs" = "X " && libobjs=
10275: fi
10276: # Expand the library linking commands again to reset the
10277: # value of $libobjs for piecewise linking.
10278:
10279: # Do each of the archive commands.
10280: if test yes = "$module" && test -n "$module_cmds"; then
10281: if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
10282: cmds=$module_expsym_cmds
10283: else
10284: cmds=$module_cmds
10285: fi
10286: else
10287: if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
10288: cmds=$archive_expsym_cmds
10289: else
10290: cmds=$archive_cmds
10291: fi
10292: fi
10293: fi
10294:
10295: if test -n "$delfiles"; then
10296: # Append the command to remove temporary files to $cmds.
10297: eval cmds=\"\$cmds~\$RM $delfiles\"
10298: fi
10299:
10300: # Add any objects from preloaded convenience libraries
10301: if test -n "$dlprefiles"; then
10302: gentop=$output_objdir/${outputname}x
10303: func_append generated " $gentop"
10304:
10305: func_extract_archives $gentop $dlprefiles
10306: func_append libobjs " $func_extract_archives_result"
10307: test "X$libobjs" = "X " && libobjs=
10308: fi
10309:
10310: save_ifs=$IFS; IFS='~'
10311: for cmd in $cmds; do
10312: IFS=$sp$nl
10313: eval cmd=\"$cmd\"
10314: IFS=$save_ifs
10315: $opt_quiet || {
1.2 ! ohara 10316: func_quote_arg expand,pretty "$cmd"
! 10317: eval "func_echo $func_quote_arg_result"
1.1 ohara 10318: }
10319: $opt_dry_run || eval "$cmd" || {
10320: lt_exit=$?
10321:
10322: # Restore the uninstalled library and exit
10323: if test relink = "$opt_mode"; then
10324: ( cd "$output_objdir" && \
10325: $RM "${realname}T" && \
10326: $MV "${realname}U" "$realname" )
10327: fi
10328:
10329: exit $lt_exit
10330: }
10331: done
10332: IFS=$save_ifs
10333:
10334: # Restore the uninstalled library and exit
10335: if test relink = "$opt_mode"; then
10336: $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
10337:
10338: if test -n "$convenience"; then
10339: if test -z "$whole_archive_flag_spec"; then
10340: func_show_eval '${RM}r "$gentop"'
10341: fi
10342: fi
10343:
10344: exit $EXIT_SUCCESS
10345: fi
10346:
10347: # Create links to the real library.
10348: for linkname in $linknames; do
10349: if test "$realname" != "$linkname"; then
10350: func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
10351: fi
10352: done
10353:
10354: # If -module or -export-dynamic was specified, set the dlname.
10355: if test yes = "$module" || test yes = "$export_dynamic"; then
10356: # On all known operating systems, these are identical.
10357: dlname=$soname
10358: fi
10359: fi
10360: ;;
10361:
10362: obj)
10363: if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
10364: func_warning "'-dlopen' is ignored for objects"
10365: fi
10366:
10367: case " $deplibs" in
10368: *\ -l* | *\ -L*)
10369: func_warning "'-l' and '-L' are ignored for objects" ;;
10370: esac
10371:
10372: test -n "$rpath" && \
10373: func_warning "'-rpath' is ignored for objects"
10374:
10375: test -n "$xrpath" && \
10376: func_warning "'-R' is ignored for objects"
10377:
10378: test -n "$vinfo" && \
10379: func_warning "'-version-info' is ignored for objects"
10380:
10381: test -n "$release" && \
10382: func_warning "'-release' is ignored for objects"
10383:
10384: case $output in
10385: *.lo)
10386: test -n "$objs$old_deplibs" && \
10387: func_fatal_error "cannot build library object '$output' from non-libtool objects"
10388:
10389: libobj=$output
10390: func_lo2o "$libobj"
10391: obj=$func_lo2o_result
10392: ;;
10393: *)
10394: libobj=
10395: obj=$output
10396: ;;
10397: esac
10398:
10399: # Delete the old objects.
10400: $opt_dry_run || $RM $obj $libobj
10401:
10402: # Objects from convenience libraries. This assumes
10403: # single-version convenience libraries. Whenever we create
10404: # different ones for PIC/non-PIC, this we'll have to duplicate
10405: # the extraction.
10406: reload_conv_objs=
10407: gentop=
10408: # if reload_cmds runs $LD directly, get rid of -Wl from
10409: # whole_archive_flag_spec and hope we can get by with turning comma
10410: # into space.
10411: case $reload_cmds in
10412: *\$LD[\ \$]*) wl= ;;
10413: esac
10414: if test -n "$convenience"; then
10415: if test -n "$whole_archive_flag_spec"; then
10416: eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
10417: test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
10418: reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
10419: else
10420: gentop=$output_objdir/${obj}x
10421: func_append generated " $gentop"
10422:
10423: func_extract_archives $gentop $convenience
10424: reload_conv_objs="$reload_objs $func_extract_archives_result"
10425: fi
10426: fi
10427:
10428: # If we're not building shared, we need to use non_pic_objs
10429: test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
10430:
10431: # Create the old-style object.
10432: reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
10433:
10434: output=$obj
10435: func_execute_cmds "$reload_cmds" 'exit $?'
10436:
10437: # Exit if we aren't doing a library object file.
10438: if test -z "$libobj"; then
10439: if test -n "$gentop"; then
10440: func_show_eval '${RM}r "$gentop"'
10441: fi
10442:
10443: exit $EXIT_SUCCESS
10444: fi
10445:
10446: test yes = "$build_libtool_libs" || {
10447: if test -n "$gentop"; then
10448: func_show_eval '${RM}r "$gentop"'
10449: fi
10450:
10451: # Create an invalid libtool object if no PIC, so that we don't
10452: # accidentally link it into a program.
10453: # $show "echo timestamp > $libobj"
10454: # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
10455: exit $EXIT_SUCCESS
10456: }
10457:
10458: if test -n "$pic_flag" || test default != "$pic_mode"; then
10459: # Only do commands if we really have different PIC objects.
10460: reload_objs="$libobjs $reload_conv_objs"
10461: output=$libobj
10462: func_execute_cmds "$reload_cmds" 'exit $?'
10463: fi
10464:
10465: if test -n "$gentop"; then
10466: func_show_eval '${RM}r "$gentop"'
10467: fi
10468:
10469: exit $EXIT_SUCCESS
10470: ;;
10471:
10472: prog)
10473: case $host in
10474: *cygwin*) func_stripname '' '.exe' "$output"
10475: output=$func_stripname_result.exe;;
10476: esac
10477: test -n "$vinfo" && \
10478: func_warning "'-version-info' is ignored for programs"
10479:
10480: test -n "$release" && \
10481: func_warning "'-release' is ignored for programs"
10482:
10483: $preload \
10484: && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
10485: && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
10486:
10487: case $host in
10488: *-*-rhapsody* | *-*-darwin1.[012])
10489: # On Rhapsody replace the C library is the System framework
10490: compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
10491: finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
10492: ;;
10493: esac
10494:
10495: case $host in
10496: *-*-darwin*)
10497: # Don't allow lazy linking, it breaks C++ global constructors
10498: # But is supposedly fixed on 10.4 or later (yay!).
10499: if test CXX = "$tagname"; then
10500: case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
10501: 10.[0123])
10502: func_append compile_command " $wl-bind_at_load"
10503: func_append finalize_command " $wl-bind_at_load"
10504: ;;
10505: esac
10506: fi
10507: # Time to change all our "foo.ltframework" stuff back to "-framework foo"
10508: compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
10509: finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
10510: ;;
10511: esac
10512:
10513:
10514: # move library search paths that coincide with paths to not yet
10515: # installed libraries to the beginning of the library search list
10516: new_libs=
10517: for path in $notinst_path; do
10518: case " $new_libs " in
10519: *" -L$path/$objdir "*) ;;
10520: *)
10521: case " $compile_deplibs " in
10522: *" -L$path/$objdir "*)
10523: func_append new_libs " -L$path/$objdir" ;;
10524: esac
10525: ;;
10526: esac
10527: done
10528: for deplib in $compile_deplibs; do
10529: case $deplib in
10530: -L*)
10531: case " $new_libs " in
10532: *" $deplib "*) ;;
10533: *) func_append new_libs " $deplib" ;;
10534: esac
10535: ;;
10536: *) func_append new_libs " $deplib" ;;
10537: esac
10538: done
10539: compile_deplibs=$new_libs
10540:
10541:
10542: func_append compile_command " $compile_deplibs"
10543: func_append finalize_command " $finalize_deplibs"
10544:
10545: if test -n "$rpath$xrpath"; then
10546: # If the user specified any rpath flags, then add them.
10547: for libdir in $rpath $xrpath; do
10548: # This is the magic to use -rpath.
10549: case "$finalize_rpath " in
10550: *" $libdir "*) ;;
10551: *) func_append finalize_rpath " $libdir" ;;
10552: esac
10553: done
10554: fi
10555:
10556: # Now hardcode the library paths
10557: rpath=
10558: hardcode_libdirs=
10559: for libdir in $compile_rpath $finalize_rpath; do
10560: if test -n "$hardcode_libdir_flag_spec"; then
10561: if test -n "$hardcode_libdir_separator"; then
10562: if test -z "$hardcode_libdirs"; then
10563: hardcode_libdirs=$libdir
10564: else
10565: # Just accumulate the unique libdirs.
10566: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10567: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
10568: ;;
10569: *)
10570: func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10571: ;;
10572: esac
10573: fi
10574: else
10575: eval flag=\"$hardcode_libdir_flag_spec\"
10576: func_append rpath " $flag"
10577: fi
10578: elif test -n "$runpath_var"; then
10579: case "$perm_rpath " in
10580: *" $libdir "*) ;;
10581: *) func_append perm_rpath " $libdir" ;;
10582: esac
10583: fi
10584: case $host in
10585: *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
10586: testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
10587: case :$dllsearchpath: in
10588: *":$libdir:"*) ;;
10589: ::) dllsearchpath=$libdir;;
10590: *) func_append dllsearchpath ":$libdir";;
10591: esac
10592: case :$dllsearchpath: in
10593: *":$testbindir:"*) ;;
10594: ::) dllsearchpath=$testbindir;;
10595: *) func_append dllsearchpath ":$testbindir";;
10596: esac
10597: ;;
10598: esac
10599: done
10600: # Substitute the hardcoded libdirs into the rpath.
10601: if test -n "$hardcode_libdir_separator" &&
10602: test -n "$hardcode_libdirs"; then
10603: libdir=$hardcode_libdirs
10604: eval rpath=\" $hardcode_libdir_flag_spec\"
10605: fi
10606: compile_rpath=$rpath
10607:
10608: rpath=
10609: hardcode_libdirs=
10610: for libdir in $finalize_rpath; do
10611: if test -n "$hardcode_libdir_flag_spec"; then
10612: if test -n "$hardcode_libdir_separator"; then
10613: if test -z "$hardcode_libdirs"; then
10614: hardcode_libdirs=$libdir
10615: else
10616: # Just accumulate the unique libdirs.
10617: case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10618: *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
10619: ;;
10620: *)
10621: func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10622: ;;
10623: esac
10624: fi
10625: else
10626: eval flag=\"$hardcode_libdir_flag_spec\"
10627: func_append rpath " $flag"
10628: fi
10629: elif test -n "$runpath_var"; then
10630: case "$finalize_perm_rpath " in
10631: *" $libdir "*) ;;
10632: *) func_append finalize_perm_rpath " $libdir" ;;
10633: esac
10634: fi
10635: done
10636: # Substitute the hardcoded libdirs into the rpath.
10637: if test -n "$hardcode_libdir_separator" &&
10638: test -n "$hardcode_libdirs"; then
10639: libdir=$hardcode_libdirs
10640: eval rpath=\" $hardcode_libdir_flag_spec\"
10641: fi
10642: finalize_rpath=$rpath
10643:
10644: if test -n "$libobjs" && test yes = "$build_old_libs"; then
10645: # Transform all the library objects into standard objects.
10646: compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
10647: finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
10648: fi
10649:
10650: func_generate_dlsyms "$outputname" "@PROGRAM@" false
10651:
10652: # template prelinking step
10653: if test -n "$prelink_cmds"; then
10654: func_execute_cmds "$prelink_cmds" 'exit $?'
10655: fi
10656:
10657: wrappers_required=:
10658: case $host in
10659: *cegcc* | *mingw32ce*)
10660: # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
10661: wrappers_required=false
10662: ;;
10663: *cygwin* | *mingw* )
10664: test yes = "$build_libtool_libs" || wrappers_required=false
10665: ;;
10666: *)
10667: if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
10668: wrappers_required=false
10669: fi
10670: ;;
10671: esac
10672: $wrappers_required || {
10673: # Replace the output file specification.
10674: compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
10675: link_command=$compile_command$compile_rpath
10676:
10677: # We have no uninstalled library dependencies, so finalize right now.
10678: exit_status=0
10679: func_show_eval "$link_command" 'exit_status=$?'
10680:
10681: if test -n "$postlink_cmds"; then
10682: func_to_tool_file "$output"
10683: postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10684: func_execute_cmds "$postlink_cmds" 'exit $?'
10685: fi
10686:
10687: # Delete the generated files.
10688: if test -f "$output_objdir/${outputname}S.$objext"; then
10689: func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
10690: fi
10691:
10692: exit $exit_status
10693: }
10694:
10695: if test -n "$compile_shlibpath$finalize_shlibpath"; then
10696: compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
10697: fi
10698: if test -n "$finalize_shlibpath"; then
10699: finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
10700: fi
10701:
10702: compile_var=
10703: finalize_var=
10704: if test -n "$runpath_var"; then
10705: if test -n "$perm_rpath"; then
10706: # We should set the runpath_var.
10707: rpath=
10708: for dir in $perm_rpath; do
10709: func_append rpath "$dir:"
10710: done
10711: compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
10712: fi
10713: if test -n "$finalize_perm_rpath"; then
10714: # We should set the runpath_var.
10715: rpath=
10716: for dir in $finalize_perm_rpath; do
10717: func_append rpath "$dir:"
10718: done
10719: finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
10720: fi
10721: fi
10722:
10723: if test yes = "$no_install"; then
10724: # We don't need to create a wrapper script.
10725: link_command=$compile_var$compile_command$compile_rpath
10726: # Replace the output file specification.
10727: link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
10728: # Delete the old output file.
10729: $opt_dry_run || $RM $output
10730: # Link the executable and exit
10731: func_show_eval "$link_command" 'exit $?'
10732:
10733: if test -n "$postlink_cmds"; then
10734: func_to_tool_file "$output"
10735: postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10736: func_execute_cmds "$postlink_cmds" 'exit $?'
10737: fi
10738:
10739: exit $EXIT_SUCCESS
10740: fi
10741:
10742: case $hardcode_action,$fast_install in
10743: relink,*)
10744: # Fast installation is not supported
10745: link_command=$compile_var$compile_command$compile_rpath
10746: relink_command=$finalize_var$finalize_command$finalize_rpath
10747:
10748: func_warning "this platform does not like uninstalled shared libraries"
10749: func_warning "'$output' will be relinked during installation"
10750: ;;
10751: *,yes)
10752: link_command=$finalize_var$compile_command$finalize_rpath
10753: relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
10754: ;;
10755: *,no)
10756: link_command=$compile_var$compile_command$compile_rpath
10757: relink_command=$finalize_var$finalize_command$finalize_rpath
10758: ;;
10759: *,needless)
10760: link_command=$finalize_var$compile_command$finalize_rpath
10761: relink_command=
10762: ;;
10763: esac
10764:
10765: # Replace the output file specification.
10766: link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
10767:
10768: # Delete the old output files.
10769: $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
10770:
10771: func_show_eval "$link_command" 'exit $?'
10772:
10773: if test -n "$postlink_cmds"; then
10774: func_to_tool_file "$output_objdir/$outputname"
10775: postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10776: func_execute_cmds "$postlink_cmds" 'exit $?'
10777: fi
10778:
10779: # Now create the wrapper script.
10780: func_verbose "creating $output"
10781:
10782: # Quote the relink command for shipping.
10783: if test -n "$relink_command"; then
10784: # Preserve any variables that may affect compiler behavior
10785: for var in $variables_saved_for_relink; do
10786: if eval test -z \"\${$var+set}\"; then
10787: relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
10788: elif eval var_value=\$$var; test -z "$var_value"; then
10789: relink_command="$var=; export $var; $relink_command"
10790: else
1.2 ! ohara 10791: func_quote_arg pretty "$var_value"
! 10792: relink_command="$var=$func_quote_arg_result; export $var; $relink_command"
1.1 ohara 10793: fi
10794: done
1.2 ! ohara 10795: func_quote eval cd "`pwd`"
! 10796: func_quote_arg pretty,unquoted "($func_quote_result; $relink_command)"
! 10797: relink_command=$func_quote_arg_unquoted_result
1.1 ohara 10798: fi
10799:
10800: # Only actually do things if not in dry run mode.
10801: $opt_dry_run || {
10802: # win32 will think the script is a binary if it has
10803: # a .exe suffix, so we strip it off here.
10804: case $output in
10805: *.exe) func_stripname '' '.exe' "$output"
10806: output=$func_stripname_result ;;
10807: esac
10808: # test for cygwin because mv fails w/o .exe extensions
10809: case $host in
10810: *cygwin*)
10811: exeext=.exe
10812: func_stripname '' '.exe' "$outputname"
10813: outputname=$func_stripname_result ;;
10814: *) exeext= ;;
10815: esac
10816: case $host in
10817: *cygwin* | *mingw* )
10818: func_dirname_and_basename "$output" "" "."
10819: output_name=$func_basename_result
10820: output_path=$func_dirname_result
10821: cwrappersource=$output_path/$objdir/lt-$output_name.c
10822: cwrapper=$output_path/$output_name.exe
10823: $RM $cwrappersource $cwrapper
10824: trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
10825:
10826: func_emit_cwrapperexe_src > $cwrappersource
10827:
10828: # The wrapper executable is built using the $host compiler,
10829: # because it contains $host paths and files. If cross-
10830: # compiling, it, like the target executable, must be
10831: # executed on the $host or under an emulation environment.
10832: $opt_dry_run || {
10833: $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
10834: $STRIP $cwrapper
10835: }
10836:
10837: # Now, create the wrapper script for func_source use:
10838: func_ltwrapper_scriptname $cwrapper
10839: $RM $func_ltwrapper_scriptname_result
10840: trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
10841: $opt_dry_run || {
10842: # note: this script will not be executed, so do not chmod.
10843: if test "x$build" = "x$host"; then
10844: $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
10845: else
10846: func_emit_wrapper no > $func_ltwrapper_scriptname_result
10847: fi
10848: }
10849: ;;
10850: * )
10851: $RM $output
10852: trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
10853:
10854: func_emit_wrapper no > $output
10855: chmod +x $output
10856: ;;
10857: esac
10858: }
10859: exit $EXIT_SUCCESS
10860: ;;
10861: esac
10862:
10863: # See if we need to build an old-fashioned archive.
10864: for oldlib in $oldlibs; do
10865:
10866: case $build_libtool_libs in
10867: convenience)
10868: oldobjs="$libobjs_save $symfileobj"
10869: addlibs=$convenience
10870: build_libtool_libs=no
10871: ;;
10872: module)
10873: oldobjs=$libobjs_save
10874: addlibs=$old_convenience
10875: build_libtool_libs=no
10876: ;;
10877: *)
10878: oldobjs="$old_deplibs $non_pic_objects"
10879: $preload && test -f "$symfileobj" \
10880: && func_append oldobjs " $symfileobj"
10881: addlibs=$old_convenience
10882: ;;
10883: esac
10884:
10885: if test -n "$addlibs"; then
10886: gentop=$output_objdir/${outputname}x
10887: func_append generated " $gentop"
10888:
10889: func_extract_archives $gentop $addlibs
10890: func_append oldobjs " $func_extract_archives_result"
10891: fi
10892:
10893: # Do each command in the archive commands.
10894: if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
10895: cmds=$old_archive_from_new_cmds
10896: else
10897:
10898: # Add any objects from preloaded convenience libraries
10899: if test -n "$dlprefiles"; then
10900: gentop=$output_objdir/${outputname}x
10901: func_append generated " $gentop"
10902:
10903: func_extract_archives $gentop $dlprefiles
10904: func_append oldobjs " $func_extract_archives_result"
10905: fi
10906:
10907: # POSIX demands no paths to be encoded in archives. We have
10908: # to avoid creating archives with duplicate basenames if we
10909: # might have to extract them afterwards, e.g., when creating a
10910: # static archive out of a convenience library, or when linking
10911: # the entirety of a libtool archive into another (currently
10912: # not supported by libtool).
10913: if (for obj in $oldobjs
10914: do
10915: func_basename "$obj"
10916: $ECHO "$func_basename_result"
10917: done | sort | sort -uc >/dev/null 2>&1); then
10918: :
10919: else
10920: echo "copying selected object files to avoid basename conflicts..."
10921: gentop=$output_objdir/${outputname}x
10922: func_append generated " $gentop"
10923: func_mkdir_p "$gentop"
10924: save_oldobjs=$oldobjs
10925: oldobjs=
10926: counter=1
10927: for obj in $save_oldobjs
10928: do
10929: func_basename "$obj"
10930: objbase=$func_basename_result
10931: case " $oldobjs " in
10932: " ") oldobjs=$obj ;;
10933: *[\ /]"$objbase "*)
10934: while :; do
10935: # Make sure we don't pick an alternate name that also
10936: # overlaps.
10937: newobj=lt$counter-$objbase
10938: func_arith $counter + 1
10939: counter=$func_arith_result
10940: case " $oldobjs " in
10941: *[\ /]"$newobj "*) ;;
10942: *) if test ! -f "$gentop/$newobj"; then break; fi ;;
10943: esac
10944: done
10945: func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
10946: func_append oldobjs " $gentop/$newobj"
10947: ;;
10948: *) func_append oldobjs " $obj" ;;
10949: esac
10950: done
10951: fi
10952: func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
10953: tool_oldlib=$func_to_tool_file_result
10954: eval cmds=\"$old_archive_cmds\"
10955:
10956: func_len " $cmds"
10957: len=$func_len_result
10958: if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
10959: cmds=$old_archive_cmds
10960: elif test -n "$archiver_list_spec"; then
10961: func_verbose "using command file archive linking..."
10962: for obj in $oldobjs
10963: do
10964: func_to_tool_file "$obj"
10965: $ECHO "$func_to_tool_file_result"
10966: done > $output_objdir/$libname.libcmd
10967: func_to_tool_file "$output_objdir/$libname.libcmd"
10968: oldobjs=" $archiver_list_spec$func_to_tool_file_result"
10969: cmds=$old_archive_cmds
10970: else
10971: # the command line is too long to link in one step, link in parts
10972: func_verbose "using piecewise archive linking..."
10973: save_RANLIB=$RANLIB
10974: RANLIB=:
10975: objlist=
10976: concat_cmds=
10977: save_oldobjs=$oldobjs
10978: oldobjs=
10979: # Is there a better way of finding the last object in the list?
10980: for obj in $save_oldobjs
10981: do
10982: last_oldobj=$obj
10983: done
10984: eval test_cmds=\"$old_archive_cmds\"
10985: func_len " $test_cmds"
10986: len0=$func_len_result
10987: len=$len0
10988: for obj in $save_oldobjs
10989: do
10990: func_len " $obj"
10991: func_arith $len + $func_len_result
10992: len=$func_arith_result
10993: func_append objlist " $obj"
10994: if test "$len" -lt "$max_cmd_len"; then
10995: :
10996: else
10997: # the above command should be used before it gets too long
10998: oldobjs=$objlist
10999: if test "$obj" = "$last_oldobj"; then
11000: RANLIB=$save_RANLIB
11001: fi
11002: test -z "$concat_cmds" || concat_cmds=$concat_cmds~
11003: eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
11004: objlist=
11005: len=$len0
11006: fi
11007: done
11008: RANLIB=$save_RANLIB
11009: oldobjs=$objlist
11010: if test -z "$oldobjs"; then
11011: eval cmds=\"\$concat_cmds\"
11012: else
11013: eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
11014: fi
11015: fi
11016: fi
11017: func_execute_cmds "$cmds" 'exit $?'
11018: done
11019:
11020: test -n "$generated" && \
11021: func_show_eval "${RM}r$generated"
11022:
11023: # Now create the libtool archive.
11024: case $output in
11025: *.la)
11026: old_library=
11027: test yes = "$build_old_libs" && old_library=$libname.$libext
11028: func_verbose "creating $output"
11029:
11030: # Preserve any variables that may affect compiler behavior
11031: for var in $variables_saved_for_relink; do
11032: if eval test -z \"\${$var+set}\"; then
11033: relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
11034: elif eval var_value=\$$var; test -z "$var_value"; then
11035: relink_command="$var=; export $var; $relink_command"
11036: else
1.2 ! ohara 11037: func_quote_arg pretty,unquoted "$var_value"
! 11038: relink_command="$var=$func_quote_arg_unquoted_result; export $var; $relink_command"
1.1 ohara 11039: fi
11040: done
11041: # Quote the link command for shipping.
1.2 ! ohara 11042: func_quote eval cd "`pwd`"
! 11043: relink_command="($func_quote_result; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
! 11044: func_quote_arg pretty,unquoted "$relink_command"
! 11045: relink_command=$func_quote_arg_unquoted_result
1.1 ohara 11046: if test yes = "$hardcode_automatic"; then
11047: relink_command=
11048: fi
11049:
11050: # Only create the output if not a dry run.
11051: $opt_dry_run || {
11052: for installed in no yes; do
11053: if test yes = "$installed"; then
11054: if test -z "$install_libdir"; then
11055: break
11056: fi
11057: output=$output_objdir/${outputname}i
11058: # Replace all uninstalled libtool libraries with the installed ones
11059: newdependency_libs=
11060: for deplib in $dependency_libs; do
11061: case $deplib in
11062: *.la)
11063: func_basename "$deplib"
11064: name=$func_basename_result
11065: func_resolve_sysroot "$deplib"
11066: eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
11067: test -z "$libdir" && \
11068: func_fatal_error "'$deplib' is not a valid libtool archive"
11069: func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
11070: ;;
11071: -L*)
11072: func_stripname -L '' "$deplib"
11073: func_replace_sysroot "$func_stripname_result"
11074: func_append newdependency_libs " -L$func_replace_sysroot_result"
11075: ;;
11076: -R*)
11077: func_stripname -R '' "$deplib"
11078: func_replace_sysroot "$func_stripname_result"
11079: func_append newdependency_libs " -R$func_replace_sysroot_result"
11080: ;;
11081: *) func_append newdependency_libs " $deplib" ;;
11082: esac
11083: done
11084: dependency_libs=$newdependency_libs
11085: newdlfiles=
11086:
11087: for lib in $dlfiles; do
11088: case $lib in
11089: *.la)
11090: func_basename "$lib"
11091: name=$func_basename_result
11092: eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
11093: test -z "$libdir" && \
11094: func_fatal_error "'$lib' is not a valid libtool archive"
11095: func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
11096: ;;
11097: *) func_append newdlfiles " $lib" ;;
11098: esac
11099: done
11100: dlfiles=$newdlfiles
11101: newdlprefiles=
11102: for lib in $dlprefiles; do
11103: case $lib in
11104: *.la)
11105: # Only pass preopened files to the pseudo-archive (for
11106: # eventual linking with the app. that links it) if we
11107: # didn't already link the preopened objects directly into
11108: # the library:
11109: func_basename "$lib"
11110: name=$func_basename_result
11111: eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
11112: test -z "$libdir" && \
11113: func_fatal_error "'$lib' is not a valid libtool archive"
11114: func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
11115: ;;
11116: esac
11117: done
11118: dlprefiles=$newdlprefiles
11119: else
11120: newdlfiles=
11121: for lib in $dlfiles; do
11122: case $lib in
11123: [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
11124: *) abs=`pwd`"/$lib" ;;
11125: esac
11126: func_append newdlfiles " $abs"
11127: done
11128: dlfiles=$newdlfiles
11129: newdlprefiles=
11130: for lib in $dlprefiles; do
11131: case $lib in
11132: [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
11133: *) abs=`pwd`"/$lib" ;;
11134: esac
11135: func_append newdlprefiles " $abs"
11136: done
11137: dlprefiles=$newdlprefiles
11138: fi
11139: $RM $output
11140: # place dlname in correct position for cygwin
11141: # In fact, it would be nice if we could use this code for all target
11142: # systems that can't hard-code library paths into their executables
11143: # and that have no shared library path variable independent of PATH,
11144: # but it turns out we can't easily determine that from inspecting
11145: # libtool variables, so we have to hard-code the OSs to which it
11146: # applies here; at the moment, that means platforms that use the PE
11147: # object format with DLL files. See the long comment at the top of
11148: # tests/bindir.at for full details.
11149: tdlname=$dlname
11150: case $host,$output,$installed,$module,$dlname in
11151: *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
11152: # If a -bindir argument was supplied, place the dll there.
11153: if test -n "$bindir"; then
11154: func_relative_path "$install_libdir" "$bindir"
11155: tdlname=$func_relative_path_result/$dlname
11156: else
11157: # Otherwise fall back on heuristic.
11158: tdlname=../bin/$dlname
11159: fi
11160: ;;
11161: esac
11162: $ECHO > $output "\
11163: # $outputname - a libtool library file
11164: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
11165: #
11166: # Please DO NOT delete this file!
11167: # It is necessary for linking the library.
11168:
11169: # The name that we can dlopen(3).
11170: dlname='$tdlname'
11171:
11172: # Names of this library.
11173: library_names='$library_names'
11174:
11175: # The name of the static archive.
11176: old_library='$old_library'
11177:
11178: # Linker flags that cannot go in dependency_libs.
11179: inherited_linker_flags='$new_inherited_linker_flags'
11180:
11181: # Libraries that this one depends upon.
11182: dependency_libs='$dependency_libs'
11183:
11184: # Names of additional weak libraries provided by this library
11185: weak_library_names='$weak_libs'
11186:
11187: # Version information for $libname.
11188: current=$current
11189: age=$age
11190: revision=$revision
11191:
11192: # Is this an already installed library?
11193: installed=$installed
11194:
11195: # Should we warn about portability when linking against -modules?
11196: shouldnotlink=$module
11197:
11198: # Files to dlopen/dlpreopen
11199: dlopen='$dlfiles'
11200: dlpreopen='$dlprefiles'
11201:
11202: # Directory that this library needs to be installed in:
11203: libdir='$install_libdir'"
11204: if test no,yes = "$installed,$need_relink"; then
11205: $ECHO >> $output "\
11206: relink_command=\"$relink_command\""
11207: fi
11208: done
11209: }
11210:
11211: # Do a symbolic link so that the libtool archive can be found in
11212: # LD_LIBRARY_PATH before the program is installed.
11213: func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
11214: ;;
11215: esac
11216: exit $EXIT_SUCCESS
11217: }
11218:
11219: if test link = "$opt_mode" || test relink = "$opt_mode"; then
11220: func_mode_link ${1+"$@"}
11221: fi
11222:
11223:
11224: # func_mode_uninstall arg...
11225: func_mode_uninstall ()
11226: {
11227: $debug_cmd
11228:
11229: RM=$nonopt
11230: files=
11231: rmforce=false
11232: exit_status=0
11233:
11234: # This variable tells wrapper scripts just to set variables rather
11235: # than running their programs.
11236: libtool_install_magic=$magic
11237:
11238: for arg
11239: do
11240: case $arg in
11241: -f) func_append RM " $arg"; rmforce=: ;;
11242: -*) func_append RM " $arg" ;;
11243: *) func_append files " $arg" ;;
11244: esac
11245: done
11246:
11247: test -z "$RM" && \
11248: func_fatal_help "you must specify an RM program"
11249:
11250: rmdirs=
11251:
11252: for file in $files; do
11253: func_dirname "$file" "" "."
11254: dir=$func_dirname_result
11255: if test . = "$dir"; then
11256: odir=$objdir
11257: else
11258: odir=$dir/$objdir
11259: fi
11260: func_basename "$file"
11261: name=$func_basename_result
11262: test uninstall = "$opt_mode" && odir=$dir
11263:
11264: # Remember odir for removal later, being careful to avoid duplicates
11265: if test clean = "$opt_mode"; then
11266: case " $rmdirs " in
11267: *" $odir "*) ;;
11268: *) func_append rmdirs " $odir" ;;
11269: esac
11270: fi
11271:
11272: # Don't error if the file doesn't exist and rm -f was used.
11273: if { test -L "$file"; } >/dev/null 2>&1 ||
11274: { test -h "$file"; } >/dev/null 2>&1 ||
11275: test -f "$file"; then
11276: :
11277: elif test -d "$file"; then
11278: exit_status=1
11279: continue
11280: elif $rmforce; then
11281: continue
11282: fi
11283:
11284: rmfiles=$file
11285:
11286: case $name in
11287: *.la)
11288: # Possibly a libtool archive, so verify it.
11289: if func_lalib_p "$file"; then
11290: func_source $dir/$name
11291:
11292: # Delete the libtool libraries and symlinks.
11293: for n in $library_names; do
11294: func_append rmfiles " $odir/$n"
11295: done
11296: test -n "$old_library" && func_append rmfiles " $odir/$old_library"
11297:
11298: case $opt_mode in
11299: clean)
11300: case " $library_names " in
11301: *" $dlname "*) ;;
11302: *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
11303: esac
11304: test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
11305: ;;
11306: uninstall)
11307: if test -n "$library_names"; then
11308: # Do each command in the postuninstall commands.
11309: func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
11310: fi
11311:
11312: if test -n "$old_library"; then
11313: # Do each command in the old_postuninstall commands.
11314: func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
11315: fi
11316: # FIXME: should reinstall the best remaining shared library.
11317: ;;
11318: esac
11319: fi
11320: ;;
11321:
11322: *.lo)
11323: # Possibly a libtool object, so verify it.
11324: if func_lalib_p "$file"; then
11325:
11326: # Read the .lo file
11327: func_source $dir/$name
11328:
11329: # Add PIC object to the list of files to remove.
11330: if test -n "$pic_object" && test none != "$pic_object"; then
11331: func_append rmfiles " $dir/$pic_object"
11332: fi
11333:
11334: # Add non-PIC object to the list of files to remove.
11335: if test -n "$non_pic_object" && test none != "$non_pic_object"; then
11336: func_append rmfiles " $dir/$non_pic_object"
11337: fi
11338: fi
11339: ;;
11340:
11341: *)
11342: if test clean = "$opt_mode"; then
11343: noexename=$name
11344: case $file in
11345: *.exe)
11346: func_stripname '' '.exe' "$file"
11347: file=$func_stripname_result
11348: func_stripname '' '.exe' "$name"
11349: noexename=$func_stripname_result
11350: # $file with .exe has already been added to rmfiles,
11351: # add $file without .exe
11352: func_append rmfiles " $file"
11353: ;;
11354: esac
11355: # Do a test to see if this is a libtool program.
11356: if func_ltwrapper_p "$file"; then
11357: if func_ltwrapper_executable_p "$file"; then
11358: func_ltwrapper_scriptname "$file"
11359: relink_command=
11360: func_source $func_ltwrapper_scriptname_result
11361: func_append rmfiles " $func_ltwrapper_scriptname_result"
11362: else
11363: relink_command=
11364: func_source $dir/$noexename
11365: fi
11366:
11367: # note $name still contains .exe if it was in $file originally
11368: # as does the version of $file that was added into $rmfiles
11369: func_append rmfiles " $odir/$name $odir/${name}S.$objext"
11370: if test yes = "$fast_install" && test -n "$relink_command"; then
11371: func_append rmfiles " $odir/lt-$name"
11372: fi
11373: if test "X$noexename" != "X$name"; then
11374: func_append rmfiles " $odir/lt-$noexename.c"
11375: fi
11376: fi
11377: fi
11378: ;;
11379: esac
11380: func_show_eval "$RM $rmfiles" 'exit_status=1'
11381: done
11382:
11383: # Try to remove the $objdir's in the directories where we deleted files
11384: for dir in $rmdirs; do
11385: if test -d "$dir"; then
11386: func_show_eval "rmdir $dir >/dev/null 2>&1"
11387: fi
11388: done
11389:
11390: exit $exit_status
11391: }
11392:
11393: if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
11394: func_mode_uninstall ${1+"$@"}
11395: fi
11396:
11397: test -z "$opt_mode" && {
11398: help=$generic_help
11399: func_fatal_help "you must specify a MODE"
11400: }
11401:
11402: test -z "$exec_cmd" && \
11403: func_fatal_help "invalid operation mode '$opt_mode'"
11404:
11405: if test -n "$exec_cmd"; then
11406: eval exec "$exec_cmd"
11407: exit $EXIT_FAILURE
11408: fi
11409:
11410: exit $exit_status
11411:
11412:
11413: # The TAGs below are defined such that we never get into a situation
11414: # where we disable both kinds of libraries. Given conflicting
11415: # choices, we go for a static library, that is the most portable,
11416: # since we can't tell whether shared libraries were disabled because
11417: # the user asked for that or because the platform doesn't support
11418: # them. This is particularly important on AIX, because we don't
11419: # support having both static and shared libraries enabled at the same
11420: # time on that platform, so we default to a shared-only configuration.
11421: # If a disable-shared tag is given, we'll fallback to a static-only
11422: # configuration. But we'll never go from static-only to shared-only.
11423:
11424: # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
11425: build_libtool_libs=no
11426: build_old_libs=yes
11427: # ### END LIBTOOL TAG CONFIG: disable-shared
11428:
11429: # ### BEGIN LIBTOOL TAG CONFIG: disable-static
11430: build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
11431: # ### END LIBTOOL TAG CONFIG: disable-static
11432:
11433: # Local Variables:
11434: # mode:shell-script
11435: # sh-indentation:2
11436: # End:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ltmain.sh CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2018