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