ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/branches/newio/ltmain.sh
Revision: 1094
Committed: Sun Jun 13 10:09:34 2010 UTC (13 years, 9 months ago) by michael
Content type: text/x-sh
Original Path: ircd-hybrid-7.3/ltmain.sh
File size: 253153 byte(s)
Log Message:
- Updated ltdl to latest 2.2.10 release

File Contents

# Content
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="grep -E"}
139 : ${FGREP="grep -F"}
140 : ${GREP="grep"}
141 : ${LN_S="ln -s"}
142 : ${MAKE="make"}
143 : ${MKDIR="mkdir"}
144 : ${MV="mv -f"}
145 : ${RM="rm -f"}
146 : ${SED="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

Properties

Name Value
svn:eol-style native
svn:executable *