Adding upstream version 0.5.6.
[debian/lxpanel.git] / ltmain.sh
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)