Merging upstream version 0.5.0.
[debian/lxdm.git] / ltmain.sh
1
2 # libtool (GNU libtool) 2.4.2
3 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4
5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6 # 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 # This is free software; see the source for copying conditions. There is NO
8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9
10 # GNU Libtool is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
14 #
15 # As a special exception to the GNU General Public License,
16 # if you distribute this file as part of a program or library that
17 # is built using GNU Libtool, you may include this file under the
18 # same distribution terms that you use for the rest of that program.
19 #
20 # GNU Libtool is distributed in the hope that it will be useful, but
21 # WITHOUT ANY WARRANTY; without even the implied warranty of
22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 # General Public License for more details.
24 #
25 # You should have received a copy of the GNU General Public License
26 # along with GNU Libtool; see the file COPYING. If not, a copy
27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28 # or obtained by writing to the Free Software Foundation, Inc.,
29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30
31 # Usage: $progname [OPTION]... [MODE-ARG]...
32 #
33 # Provide generalized library-building support services.
34 #
35 # --config show all configuration variables
36 # --debug enable verbose shell tracing
37 # -n, --dry-run display commands without modifying any files
38 # --features display basic configuration information and exit
39 # --mode=MODE use operation mode MODE
40 # --preserve-dup-deps don't remove duplicate dependency libraries
41 # --quiet, --silent don't print informational messages
42 # --no-quiet, --no-silent
43 # print informational messages (default)
44 # --no-warn don't display warning messages
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.4.2
74 # automake: $automake_version
75 # autoconf: $autoconf_version
76 #
77 # Report bugs to <bug-libtool@gnu.org>.
78 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79 # General help using GNU software: <http://www.gnu.org/gethelp/>.
80
81 PROGRAM=libtool
82 PACKAGE=libtool
83 VERSION=2.4.2
84 TIMESTAMP=""
85 package_revision=1.3337
86
87 # Be Bourne compatible
88 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
89 emulate sh
90 NULLCMD=:
91 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92 # is contrary to our usage. Disable this feature.
93 alias -g '${1+"$@"}'='"$@"'
94 setopt NO_GLOB_SUBST
95 else
96 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97 fi
98 BIN_SH=xpg4; export BIN_SH # for Tru64
99 DUALCASE=1; export DUALCASE # for MKS sh
100
101 # A function that is used when there is no print builtin or printf.
102 func_fallback_echo ()
103 {
104 eval 'cat <<_LTECHO_EOF
105 $1
106 _LTECHO_EOF'
107 }
108
109 # NLS nuisances: We save the old values to restore during execute mode.
110 lt_user_locale=
111 lt_safe_locale=
112 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113 do
114 eval "if test \"\${$lt_var+set}\" = set; then
115 save_$lt_var=\$$lt_var
116 $lt_var=C
117 export $lt_var
118 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
120 fi"
121 done
122 LC_ALL=C
123 LANGUAGE=C
124 export LANGUAGE LC_ALL
125
126 $lt_unset CDPATH
127
128
129 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130 # is ksh but when the shell is invoked as "sh" and the current value of
131 # the _XPG environment variable is not equal to 1 (one), the special
132 # positional parameter $0, within a function call, is the name of the
133 # function.
134 progpath="$0"
135
136
137
138 : ${CP="cp -f"}
139 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
140 : ${MAKE="make"}
141 : ${MKDIR="mkdir"}
142 : ${MV="mv -f"}
143 : ${RM="rm -f"}
144 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145 : ${Xsed="$SED -e 1s/^X//"}
146
147 # Global variables:
148 EXIT_SUCCESS=0
149 EXIT_FAILURE=1
150 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
151 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
152
153 exit_status=$EXIT_SUCCESS
154
155 # Make sure IFS has a sensible default
156 lt_nl='
157 '
158 IFS=" $lt_nl"
159
160 dirname="s,/[^/]*$,,"
161 basename="s,^.*/,,"
162
163 # func_dirname file append nondir_replacement
164 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
165 # otherwise set result to NONDIR_REPLACEMENT.
166 func_dirname ()
167 {
168 func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
169 if test "X$func_dirname_result" = "X${1}"; then
170 func_dirname_result="${3}"
171 else
172 func_dirname_result="$func_dirname_result${2}"
173 fi
174 } # func_dirname may be replaced by extended shell implementation
175
176
177 # func_basename file
178 func_basename ()
179 {
180 func_basename_result=`$ECHO "${1}" | $SED "$basename"`
181 } # func_basename may be replaced by extended shell implementation
182
183
184 # func_dirname_and_basename file append nondir_replacement
185 # perform func_basename and func_dirname in a single function
186 # call:
187 # dirname: Compute the dirname of FILE. If nonempty,
188 # add APPEND to the result, otherwise set result
189 # to NONDIR_REPLACEMENT.
190 # value returned in "$func_dirname_result"
191 # basename: Compute filename of FILE.
192 # value retuned in "$func_basename_result"
193 # Implementation must be kept synchronized with func_dirname
194 # and func_basename. For efficiency, we do not delegate to
195 # those functions but instead duplicate the functionality here.
196 func_dirname_and_basename ()
197 {
198 # Extract subdirectory from the argument.
199 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
200 if test "X$func_dirname_result" = "X${1}"; then
201 func_dirname_result="${3}"
202 else
203 func_dirname_result="$func_dirname_result${2}"
204 fi
205 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
206 } # func_dirname_and_basename may be replaced by extended shell implementation
207
208
209 # func_stripname prefix suffix name
210 # strip PREFIX and SUFFIX off of NAME.
211 # PREFIX and SUFFIX must not contain globbing or regex special
212 # characters, hashes, percent signs, but SUFFIX may contain a leading
213 # dot (in which case that matches only a dot).
214 # func_strip_suffix prefix name
215 func_stripname ()
216 {
217 case ${2} in
218 .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219 *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
220 esac
221 } # func_stripname may be replaced by extended shell implementation
222
223
224 # These SED scripts presuppose an absolute path with a trailing slash.
225 pathcar='s,^/\([^/]*\).*$,\1,'
226 pathcdr='s,^/[^/]*,,'
227 removedotparts=':dotsl
228 s@/\./@/@g
229 t dotsl
230 s,/\.$,/,'
231 collapseslashes='s@/\{1,\}@/@g'
232 finalslash='s,/*$,/,'
233
234 # func_normal_abspath PATH
235 # Remove doubled-up and trailing slashes, "." path components,
236 # and cancel out any ".." path components in PATH after making
237 # it an absolute path.
238 # value returned in "$func_normal_abspath_result"
239 func_normal_abspath ()
240 {
241 # Start from root dir and reassemble the path.
242 func_normal_abspath_result=
243 func_normal_abspath_tpath=$1
244 func_normal_abspath_altnamespace=
245 case $func_normal_abspath_tpath in
246 "")
247 # Empty path, that just means $cwd.
248 func_stripname '' '/' "`pwd`"
249 func_normal_abspath_result=$func_stripname_result
250 return
251 ;;
252 # The next three entries are used to spot a run of precisely
253 # two leading slashes without using negated character classes;
254 # we take advantage of case's first-match behaviour.
255 ///*)
256 # Unusual form of absolute path, do nothing.
257 ;;
258 //*)
259 # Not necessarily an ordinary path; POSIX reserves leading '//'
260 # and for example Cygwin uses it to access remote file shares
261 # over CIFS/SMB, so we conserve a leading double slash if found.
262 func_normal_abspath_altnamespace=/
263 ;;
264 /*)
265 # Absolute path, do nothing.
266 ;;
267 *)
268 # Relative path, prepend $cwd.
269 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
270 ;;
271 esac
272 # Cancel out all the simple stuff to save iterations. We also want
273 # the path to end with a slash for ease of parsing, so make sure
274 # there is one (and only one) here.
275 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
276 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
277 while :; do
278 # Processed it all yet?
279 if test "$func_normal_abspath_tpath" = / ; then
280 # If we ascended to the root using ".." the result may be empty now.
281 if test -z "$func_normal_abspath_result" ; then
282 func_normal_abspath_result=/
283 fi
284 break
285 fi
286 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
287 -e "$pathcar"`
288 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
289 -e "$pathcdr"`
290 # Figure out what to do with it
291 case $func_normal_abspath_tcomponent in
292 "")
293 # Trailing empty path component, ignore it.
294 ;;
295 ..)
296 # Parent dir; strip last assembled component from result.
297 func_dirname "$func_normal_abspath_result"
298 func_normal_abspath_result=$func_dirname_result
299 ;;
300 *)
301 # Actual path component, append it.
302 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
303 ;;
304 esac
305 done
306 # Restore leading double-slash if one was found on entry.
307 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
308 }
309
310 # func_relative_path SRCDIR DSTDIR
311 # generates a relative path from SRCDIR to DSTDIR, with a trailing
312 # slash if non-empty, suitable for immediately appending a filename
313 # without needing to append a separator.
314 # value returned in "$func_relative_path_result"
315 func_relative_path ()
316 {
317 func_relative_path_result=
318 func_normal_abspath "$1"
319 func_relative_path_tlibdir=$func_normal_abspath_result
320 func_normal_abspath "$2"
321 func_relative_path_tbindir=$func_normal_abspath_result
322
323 # Ascend the tree starting from libdir
324 while :; do
325 # check if we have found a prefix of bindir
326 case $func_relative_path_tbindir in
327 $func_relative_path_tlibdir)
328 # found an exact match
329 func_relative_path_tcancelled=
330 break
331 ;;
332 $func_relative_path_tlibdir*)
333 # found a matching prefix
334 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335 func_relative_path_tcancelled=$func_stripname_result
336 if test -z "$func_relative_path_result"; then
337 func_relative_path_result=.
338 fi
339 break
340 ;;
341 *)
342 func_dirname $func_relative_path_tlibdir
343 func_relative_path_tlibdir=${func_dirname_result}
344 if test "x$func_relative_path_tlibdir" = x ; then
345 # Have to descend all the way to the root!
346 func_relative_path_result=../$func_relative_path_result
347 func_relative_path_tcancelled=$func_relative_path_tbindir
348 break
349 fi
350 func_relative_path_result=../$func_relative_path_result
351 ;;
352 esac
353 done
354
355 # Now calculate path; take care to avoid doubling-up slashes.
356 func_stripname '' '/' "$func_relative_path_result"
357 func_relative_path_result=$func_stripname_result
358 func_stripname '/' '/' "$func_relative_path_tcancelled"
359 if test "x$func_stripname_result" != x ; then
360 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
361 fi
362
363 # Normalisation. If bindir is libdir, return empty string,
364 # else relative path ending with a slash; either way, target
365 # file name can be directly appended.
366 if test ! -z "$func_relative_path_result"; then
367 func_stripname './' '' "$func_relative_path_result/"
368 func_relative_path_result=$func_stripname_result
369 fi
370 }
371
372 # The name of this program:
373 func_dirname_and_basename "$progpath"
374 progname=$func_basename_result
375
376 # Make sure we have an absolute path for reexecution:
377 case $progpath in
378 [\\/]*|[A-Za-z]:\\*) ;;
379 *[\\/]*)
380 progdir=$func_dirname_result
381 progdir=`cd "$progdir" && pwd`
382 progpath="$progdir/$progname"
383 ;;
384 *)
385 save_IFS="$IFS"
386 IFS=${PATH_SEPARATOR-:}
387 for progdir in $PATH; do
388 IFS="$save_IFS"
389 test -x "$progdir/$progname" && break
390 done
391 IFS="$save_IFS"
392 test -n "$progdir" || progdir=`pwd`
393 progpath="$progdir/$progname"
394 ;;
395 esac
396
397 # Sed substitution that helps us do robust quoting. It backslashifies
398 # metacharacters that are still active within double-quoted strings.
399 Xsed="${SED}"' -e 1s/^X//'
400 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
401
402 # Same as above, but do not quote variable references.
403 double_quote_subst='s/\(["`\\]\)/\\\1/g'
404
405 # Sed substitution that turns a string into a regex matching for the
406 # string literally.
407 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
408
409 # Sed substitution that converts a w32 file name or path
410 # which contains forward slashes, into one that contains
411 # (escaped) backslashes. A very naive implementation.
412 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
413
414 # Re-`\' parameter expansions in output of double_quote_subst that were
415 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
416 # in input to double_quote_subst, that '$' was protected from expansion.
417 # Since each input `\' is now two `\'s, look for any number of runs of
418 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
419 bs='\\'
420 bs2='\\\\'
421 bs4='\\\\\\\\'
422 dollar='\$'
423 sed_double_backslash="\
424 s/$bs4/&\\
425 /g
426 s/^$bs2$dollar/$bs&/
427 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
428 s/\n//g"
429
430 # Standard options:
431 opt_dry_run=false
432 opt_help=false
433 opt_quiet=false
434 opt_verbose=false
435 opt_warning=:
436
437 # func_echo arg...
438 # Echo program name prefixed message, along with the current mode
439 # name if it has been set yet.
440 func_echo ()
441 {
442 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
443 }
444
445 # func_verbose arg...
446 # Echo program name prefixed message in verbose mode only.
447 func_verbose ()
448 {
449 $opt_verbose && func_echo ${1+"$@"}
450
451 # A bug in bash halts the script if the last line of a function
452 # fails when set -e is in force, so we need another command to
453 # work around that:
454 :
455 }
456
457 # func_echo_all arg...
458 # Invoke $ECHO with all args, space-separated.
459 func_echo_all ()
460 {
461 $ECHO "$*"
462 }
463
464 # func_error arg...
465 # Echo program name prefixed message to standard error.
466 func_error ()
467 {
468 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
469 }
470
471 # func_warning arg...
472 # Echo program name prefixed warning message to standard error.
473 func_warning ()
474 {
475 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
476
477 # bash bug again:
478 :
479 }
480
481 # func_fatal_error arg...
482 # Echo program name prefixed message to standard error, and exit.
483 func_fatal_error ()
484 {
485 func_error ${1+"$@"}
486 exit $EXIT_FAILURE
487 }
488
489 # func_fatal_help arg...
490 # Echo program name prefixed message to standard error, followed by
491 # a help hint, and exit.
492 func_fatal_help ()
493 {
494 func_error ${1+"$@"}
495 func_fatal_error "$help"
496 }
497 help="Try \`$progname --help' for more information." ## default
498
499
500 # func_grep expression filename
501 # Check whether EXPRESSION matches any line of FILENAME, without output.
502 func_grep ()
503 {
504 $GREP "$1" "$2" >/dev/null 2>&1
505 }
506
507
508 # func_mkdir_p directory-path
509 # Make sure the entire path to DIRECTORY-PATH is available.
510 func_mkdir_p ()
511 {
512 my_directory_path="$1"
513 my_dir_list=
514
515 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
516
517 # Protect directory names starting with `-'
518 case $my_directory_path in
519 -*) my_directory_path="./$my_directory_path" ;;
520 esac
521
522 # While some portion of DIR does not yet exist...
523 while test ! -d "$my_directory_path"; do
524 # ...make a list in topmost first order. Use a colon delimited
525 # list incase some portion of path contains whitespace.
526 my_dir_list="$my_directory_path:$my_dir_list"
527
528 # If the last portion added has no slash in it, the list is done
529 case $my_directory_path in */*) ;; *) break ;; esac
530
531 # ...otherwise throw away the child directory and loop
532 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
533 done
534 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
535
536 save_mkdir_p_IFS="$IFS"; IFS=':'
537 for my_dir in $my_dir_list; do
538 IFS="$save_mkdir_p_IFS"
539 # mkdir can fail with a `File exist' error if two processes
540 # try to create one of the directories concurrently. Don't
541 # stop in that case!
542 $MKDIR "$my_dir" 2>/dev/null || :
543 done
544 IFS="$save_mkdir_p_IFS"
545
546 # Bail out if we (or some other process) failed to create a directory.
547 test -d "$my_directory_path" || \
548 func_fatal_error "Failed to create \`$1'"
549 fi
550 }
551
552
553 # func_mktempdir [string]
554 # Make a temporary directory that won't clash with other running
555 # libtool processes, and avoids race conditions if possible. If
556 # given, STRING is the basename for that directory.
557 func_mktempdir ()
558 {
559 my_template="${TMPDIR-/tmp}/${1-$progname}"
560
561 if test "$opt_dry_run" = ":"; then
562 # Return a directory name, but don't create it in dry-run mode
563 my_tmpdir="${my_template}-$$"
564 else
565
566 # If mktemp works, use that first and foremost
567 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
568
569 if test ! -d "$my_tmpdir"; then
570 # Failing that, at least try and use $RANDOM to avoid a race
571 my_tmpdir="${my_template}-${RANDOM-0}$$"
572
573 save_mktempdir_umask=`umask`
574 umask 0077
575 $MKDIR "$my_tmpdir"
576 umask $save_mktempdir_umask
577 fi
578
579 # If we're not in dry-run mode, bomb out on failure
580 test -d "$my_tmpdir" || \
581 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
582 fi
583
584 $ECHO "$my_tmpdir"
585 }
586
587
588 # func_quote_for_eval arg
589 # Aesthetically quote ARG to be evaled later.
590 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591 # is double-quoted, suitable for a subsequent eval, whereas
592 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593 # which are still active within double quotes backslashified.
594 func_quote_for_eval ()
595 {
596 case $1 in
597 *[\\\`\"\$]*)
598 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
599 *)
600 func_quote_for_eval_unquoted_result="$1" ;;
601 esac
602
603 case $func_quote_for_eval_unquoted_result in
604 # Double-quote args containing shell metacharacters to delay
605 # word splitting, command substitution and and variable
606 # expansion for a subsequent eval.
607 # Many Bourne shells cannot handle close brackets correctly
608 # in scan sets, so we specify it separately.
609 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
610 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
611 ;;
612 *)
613 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
614 esac
615 }
616
617
618 # func_quote_for_expand arg
619 # Aesthetically quote ARG to be evaled later; same as above,
620 # but do not quote variable references.
621 func_quote_for_expand ()
622 {
623 case $1 in
624 *[\\\`\"]*)
625 my_arg=`$ECHO "$1" | $SED \
626 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
627 *)
628 my_arg="$1" ;;
629 esac
630
631 case $my_arg in
632 # Double-quote args containing shell metacharacters to delay
633 # word splitting and command substitution for a subsequent eval.
634 # Many Bourne shells cannot handle close brackets correctly
635 # in scan sets, so we specify it separately.
636 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
637 my_arg="\"$my_arg\""
638 ;;
639 esac
640
641 func_quote_for_expand_result="$my_arg"
642 }
643
644
645 # func_show_eval cmd [fail_exp]
646 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
647 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
648 # is given, then evaluate it.
649 func_show_eval ()
650 {
651 my_cmd="$1"
652 my_fail_exp="${2-:}"
653
654 ${opt_silent-false} || {
655 func_quote_for_expand "$my_cmd"
656 eval "func_echo $func_quote_for_expand_result"
657 }
658
659 if ${opt_dry_run-false}; then :; else
660 eval "$my_cmd"
661 my_status=$?
662 if test "$my_status" -eq 0; then :; else
663 eval "(exit $my_status); $my_fail_exp"
664 fi
665 fi
666 }
667
668
669 # func_show_eval_locale cmd [fail_exp]
670 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
671 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
672 # is given, then evaluate it. Use the saved locale for evaluation.
673 func_show_eval_locale ()
674 {
675 my_cmd="$1"
676 my_fail_exp="${2-:}"
677
678 ${opt_silent-false} || {
679 func_quote_for_expand "$my_cmd"
680 eval "func_echo $func_quote_for_expand_result"
681 }
682
683 if ${opt_dry_run-false}; then :; else
684 eval "$lt_user_locale
685 $my_cmd"
686 my_status=$?
687 eval "$lt_safe_locale"
688 if test "$my_status" -eq 0; then :; else
689 eval "(exit $my_status); $my_fail_exp"
690 fi
691 fi
692 }
693
694 # func_tr_sh
695 # Turn $1 into a string suitable for a shell variable name.
696 # Result is stored in $func_tr_sh_result. All characters
697 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698 # if $1 begins with a digit, a '_' is prepended as well.
699 func_tr_sh ()
700 {
701 case $1 in
702 [0-9]* | *[!a-zA-Z0-9_]*)
703 func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
704 ;;
705 * )
706 func_tr_sh_result=$1
707 ;;
708 esac
709 }
710
711
712 # func_version
713 # Echo version message to standard output and exit.
714 func_version ()
715 {
716 $opt_debug
717
718 $SED -n '/(C)/!b go
719 :more
720 /\./!{
721 N
722 s/\n# / /
723 b more
724 }
725 :go
726 /^# '$PROGRAM' (GNU /,/# warranty; / {
727 s/^# //
728 s/^# *$//
729 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
730 p
731 }' < "$progpath"
732 exit $?
733 }
734
735 # func_usage
736 # Echo short help message to standard output and exit.
737 func_usage ()
738 {
739 $opt_debug
740
741 $SED -n '/^# Usage:/,/^# *.*--help/ {
742 s/^# //
743 s/^# *$//
744 s/\$progname/'$progname'/
745 p
746 }' < "$progpath"
747 echo
748 $ECHO "run \`$progname --help | more' for full usage"
749 exit $?
750 }
751
752 # func_help [NOEXIT]
753 # Echo long help message to standard output and exit,
754 # unless 'noexit' is passed as argument.
755 func_help ()
756 {
757 $opt_debug
758
759 $SED -n '/^# Usage:/,/# Report bugs to/ {
760 :print
761 s/^# //
762 s/^# *$//
763 s*\$progname*'$progname'*
764 s*\$host*'"$host"'*
765 s*\$SHELL*'"$SHELL"'*
766 s*\$LTCC*'"$LTCC"'*
767 s*\$LTCFLAGS*'"$LTCFLAGS"'*
768 s*\$LD*'"$LD"'*
769 s/\$with_gnu_ld/'"$with_gnu_ld"'/
770 s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771 s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
772 p
773 d
774 }
775 /^# .* home page:/b print
776 /^# General help using/b print
777 ' < "$progpath"
778 ret=$?
779 if test -z "$1"; then
780 exit $ret
781 fi
782 }
783
784 # func_missing_arg argname
785 # Echo program name prefixed message to standard error and set global
786 # exit_cmd.
787 func_missing_arg ()
788 {
789 $opt_debug
790
791 func_error "missing argument for $1."
792 exit_cmd=exit
793 }
794
795
796 # func_split_short_opt shortopt
797 # Set func_split_short_opt_name and func_split_short_opt_arg shell
798 # variables after splitting SHORTOPT after the 2nd character.
799 func_split_short_opt ()
800 {
801 my_sed_short_opt='1s/^\(..\).*$/\1/;q'
802 my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
803
804 func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805 func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806 } # func_split_short_opt may be replaced by extended shell implementation
807
808
809 # func_split_long_opt longopt
810 # Set func_split_long_opt_name and func_split_long_opt_arg shell
811 # variables after splitting LONGOPT at the `=' sign.
812 func_split_long_opt ()
813 {
814 my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
815 my_sed_long_arg='1s/^--[^=]*=//'
816
817 func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818 func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819 } # func_split_long_opt may be replaced by extended shell implementation
820
821 exit_cmd=:
822
823
824
825
826
827 magic="%%%MAGIC variable%%%"
828 magic_exe="%%%MAGIC EXE variable%%%"
829
830 # Global variables.
831 nonopt=
832 preserve_args=
833 lo2o="s/\\.lo\$/.${objext}/"
834 o2lo="s/\\.${objext}\$/.lo/"
835 extracted_archives=
836 extracted_serial=0
837
838 # If this variable is set in any of the actions, the command in it
839 # will be execed at the end. This prevents here-documents from being
840 # left over by shells.
841 exec_cmd=
842
843 # func_append var value
844 # Append VALUE to the end of shell variable VAR.
845 func_append ()
846 {
847 eval "${1}=\$${1}\${2}"
848 } # func_append may be replaced by extended shell implementation
849
850 # func_append_quoted var value
851 # Quote VALUE and append to the end of shell variable VAR, separated
852 # by a space.
853 func_append_quoted ()
854 {
855 func_quote_for_eval "${2}"
856 eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857 } # func_append_quoted may be replaced by extended shell implementation
858
859
860 # func_arith arithmetic-term...
861 func_arith ()
862 {
863 func_arith_result=`expr "${@}"`
864 } # func_arith may be replaced by extended shell implementation
865
866
867 # func_len string
868 # STRING may not start with a hyphen.
869 func_len ()
870 {
871 func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872 } # func_len may be replaced by extended shell implementation
873
874
875 # func_lo2o object
876 func_lo2o ()
877 {
878 func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
879 } # func_lo2o may be replaced by extended shell implementation
880
881
882 # func_xform libobj-or-source
883 func_xform ()
884 {
885 func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886 } # func_xform may be replaced by extended shell implementation
887
888
889 # func_fatal_configuration arg...
890 # Echo program name prefixed message to standard error, followed by
891 # a configuration failure hint, and exit.
892 func_fatal_configuration ()
893 {
894 func_error ${1+"$@"}
895 func_error "See the $PACKAGE documentation for more information."
896 func_fatal_error "Fatal configuration error."
897 }
898
899
900 # func_config
901 # Display the configuration for all the tags in this script.
902 func_config ()
903 {
904 re_begincf='^# ### BEGIN LIBTOOL'
905 re_endcf='^# ### END LIBTOOL'
906
907 # Default configuration.
908 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
909
910 # Now print the configurations for the tags.
911 for tagname in $taglist; do
912 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
913 done
914
915 exit $?
916 }
917
918 # func_features
919 # Display the features supported by this script.
920 func_features ()
921 {
922 echo "host: $host"
923 if test "$build_libtool_libs" = yes; then
924 echo "enable shared libraries"
925 else
926 echo "disable shared libraries"
927 fi
928 if test "$build_old_libs" = yes; then
929 echo "enable static libraries"
930 else
931 echo "disable static libraries"
932 fi
933
934 exit $?
935 }
936
937 # func_enable_tag tagname
938 # Verify that TAGNAME is valid, and either flag an error and exit, or
939 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
940 # variable here.
941 func_enable_tag ()
942 {
943 # Global variable:
944 tagname="$1"
945
946 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948 sed_extractcf="/$re_begincf/,/$re_endcf/p"
949
950 # Validate tagname.
951 case $tagname in
952 *[!-_A-Za-z0-9,/]*)
953 func_fatal_error "invalid tag name: $tagname"
954 ;;
955 esac
956
957 # Don't test for the "default" C tag, as we know it's
958 # there but not specially marked.
959 case $tagname in
960 CC) ;;
961 *)
962 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
963 taglist="$taglist $tagname"
964
965 # Evaluate the configuration. Be careful to quote the path
966 # and the sed script, to avoid splitting on whitespace, but
967 # also don't use non-portable quotes within backquotes within
968 # quotes we have to do it in 2 steps:
969 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
970 eval "$extractedcf"
971 else
972 func_error "ignoring unknown tag $tagname"
973 fi
974 ;;
975 esac
976 }
977
978 # func_check_version_match
979 # Ensure that we are using m4 macros, and libtool script from the same
980 # release of libtool.
981 func_check_version_match ()
982 {
983 if test "$package_revision" != "$macro_revision"; then
984 if test "$VERSION" != "$macro_version"; then
985 if test -z "$macro_version"; then
986 cat >&2 <<_LT_EOF
987 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
988 $progname: definition of this LT_INIT comes from an older release.
989 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990 $progname: and run autoconf again.
991 _LT_EOF
992 else
993 cat >&2 <<_LT_EOF
994 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
995 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997 $progname: and run autoconf again.
998 _LT_EOF
999 fi
1000 else
1001 cat >&2 <<_LT_EOF
1002 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1003 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005 $progname: of $PACKAGE $VERSION and run autoconf again.
1006 _LT_EOF
1007 fi
1008
1009 exit $EXIT_MISMATCH
1010 fi
1011 }
1012
1013
1014 # Shorthand for --mode=foo, only valid as the first argument
1015 case $1 in
1016 clean|clea|cle|cl)
1017 shift; set dummy --mode clean ${1+"$@"}; shift
1018 ;;
1019 compile|compil|compi|comp|com|co|c)
1020 shift; set dummy --mode compile ${1+"$@"}; shift
1021 ;;
1022 execute|execut|execu|exec|exe|ex|e)
1023 shift; set dummy --mode execute ${1+"$@"}; shift
1024 ;;
1025 finish|finis|fini|fin|fi|f)
1026 shift; set dummy --mode finish ${1+"$@"}; shift
1027 ;;
1028 install|instal|insta|inst|ins|in|i)
1029 shift; set dummy --mode install ${1+"$@"}; shift
1030 ;;
1031 link|lin|li|l)
1032 shift; set dummy --mode link ${1+"$@"}; shift
1033 ;;
1034 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1035 shift; set dummy --mode uninstall ${1+"$@"}; shift
1036 ;;
1037 esac
1038
1039
1040
1041 # Option defaults:
1042 opt_debug=:
1043 opt_dry_run=false
1044 opt_config=false
1045 opt_preserve_dup_deps=false
1046 opt_features=false
1047 opt_finish=false
1048 opt_help=false
1049 opt_help_all=false
1050 opt_silent=:
1051 opt_warning=:
1052 opt_verbose=:
1053 opt_silent=false
1054 opt_verbose=false
1055
1056
1057 # Parse options once, thoroughly. This comes as soon as possible in the
1058 # script to make things like `--version' happen as quickly as we can.
1059 {
1060 # this just eases exit handling
1061 while test $# -gt 0; do
1062 opt="$1"
1063 shift
1064 case $opt in
1065 --debug|-x) opt_debug='set -x'
1066 func_echo "enabling shell trace mode"
1067 $opt_debug
1068 ;;
1069 --dry-run|--dryrun|-n)
1070 opt_dry_run=:
1071 ;;
1072 --config)
1073 opt_config=:
1074 func_config
1075 ;;
1076 --dlopen|-dlopen)
1077 optarg="$1"
1078 opt_dlopen="${opt_dlopen+$opt_dlopen
1079 }$optarg"
1080 shift
1081 ;;
1082 --preserve-dup-deps)
1083 opt_preserve_dup_deps=:
1084 ;;
1085 --features)
1086 opt_features=:
1087 func_features
1088 ;;
1089 --finish)
1090 opt_finish=:
1091 set dummy --mode finish ${1+"$@"}; shift
1092 ;;
1093 --help)
1094 opt_help=:
1095 ;;
1096 --help-all)
1097 opt_help_all=:
1098 opt_help=': help-all'
1099 ;;
1100 --mode)
1101 test $# = 0 && func_missing_arg $opt && break
1102 optarg="$1"
1103 opt_mode="$optarg"
1104 case $optarg in
1105 # Valid mode arguments:
1106 clean|compile|execute|finish|install|link|relink|uninstall) ;;
1107
1108 # Catch anything else as an error
1109 *) func_error "invalid argument for $opt"
1110 exit_cmd=exit
1111 break
1112 ;;
1113 esac
1114 shift
1115 ;;
1116 --no-silent|--no-quiet)
1117 opt_silent=false
1118 func_append preserve_args " $opt"
1119 ;;
1120 --no-warning|--no-warn)
1121 opt_warning=false
1122 func_append preserve_args " $opt"
1123 ;;
1124 --no-verbose)
1125 opt_verbose=false
1126 func_append preserve_args " $opt"
1127 ;;
1128 --silent|--quiet)
1129 opt_silent=:
1130 func_append preserve_args " $opt"
1131 opt_verbose=false
1132 ;;
1133 --verbose|-v)
1134 opt_verbose=:
1135 func_append preserve_args " $opt"
1136 opt_silent=false
1137 ;;
1138 --tag)
1139 test $# = 0 && func_missing_arg $opt && break
1140 optarg="$1"
1141 opt_tag="$optarg"
1142 func_append preserve_args " $opt $optarg"
1143 func_enable_tag "$optarg"
1144 shift
1145 ;;
1146
1147 -\?|-h) func_usage ;;
1148 --help) func_help ;;
1149 --version) func_version ;;
1150
1151 # Separate optargs to long options:
1152 --*=*)
1153 func_split_long_opt "$opt"
1154 set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1155 shift
1156 ;;
1157
1158 # Separate non-argument short options:
1159 -\?*|-h*|-n*|-v*)
1160 func_split_short_opt "$opt"
1161 set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1162 shift
1163 ;;
1164
1165 --) break ;;
1166 -*) func_fatal_help "unrecognized option \`$opt'" ;;
1167 *) set dummy "$opt" ${1+"$@"}; shift; break ;;
1168 esac
1169 done
1170
1171 # Validate options:
1172
1173 # save first non-option argument
1174 if test "$#" -gt 0; then
1175 nonopt="$opt"
1176 shift
1177 fi
1178
1179 # preserve --debug
1180 test "$opt_debug" = : || func_append preserve_args " --debug"
1181
1182 case $host in
1183 *cygwin* | *mingw* | *pw32* | *cegcc*)
1184 # don't eliminate duplications in $postdeps and $predeps
1185 opt_duplicate_compiler_generated_deps=:
1186 ;;
1187 *)
1188 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1189 ;;
1190 esac
1191
1192 $opt_help || {
1193 # Sanity checks first:
1194 func_check_version_match
1195
1196 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197 func_fatal_configuration "not configured to build any kind of library"
1198 fi
1199
1200 # Darwin sucks
1201 eval std_shrext=\"$shrext_cmds\"
1202
1203 # Only execute mode is allowed to have -dlopen flags.
1204 if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1205 func_error "unrecognized option \`-dlopen'"
1206 $ECHO "$help" 1>&2
1207 exit $EXIT_FAILURE
1208 fi
1209
1210 # Change the help message to a mode-specific one.
1211 generic_help="$help"
1212 help="Try \`$progname --help --mode=$opt_mode' for more information."
1213 }
1214
1215
1216 # Bail if the options were screwed
1217 $exit_cmd $EXIT_FAILURE
1218 }
1219
1220
1221
1222
1223 ## ----------- ##
1224 ## Main. ##
1225 ## ----------- ##
1226
1227 # func_lalib_p file
1228 # True iff FILE is a libtool `.la' library or `.lo' object file.
1229 # This function is only a basic sanity check; it will hardly flush out
1230 # determined imposters.
1231 func_lalib_p ()
1232 {
1233 test -f "$1" &&
1234 $SED -e 4q "$1" 2>/dev/null \
1235 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1236 }
1237
1238 # func_lalib_unsafe_p file
1239 # True iff FILE is a libtool `.la' library or `.lo' object file.
1240 # This function implements the same check as func_lalib_p without
1241 # resorting to external programs. To this end, it redirects stdin and
1242 # closes it afterwards, without saving the original file descriptor.
1243 # As a safety measure, use it only where a negative result would be
1244 # fatal anyway. Works if `file' does not exist.
1245 func_lalib_unsafe_p ()
1246 {
1247 lalib_p=no
1248 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249 for lalib_p_l in 1 2 3 4
1250 do
1251 read lalib_p_line
1252 case "$lalib_p_line" in
1253 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1254 esac
1255 done
1256 exec 0<&5 5<&-
1257 fi
1258 test "$lalib_p" = yes
1259 }
1260
1261 # func_ltwrapper_script_p file
1262 # True iff FILE is a libtool wrapper script
1263 # This function is only a basic sanity check; it will hardly flush out
1264 # determined imposters.
1265 func_ltwrapper_script_p ()
1266 {
1267 func_lalib_p "$1"
1268 }
1269
1270 # func_ltwrapper_executable_p file
1271 # True iff FILE is a libtool wrapper executable
1272 # This function is only a basic sanity check; it will hardly flush out
1273 # determined imposters.
1274 func_ltwrapper_executable_p ()
1275 {
1276 func_ltwrapper_exec_suffix=
1277 case $1 in
1278 *.exe) ;;
1279 *) func_ltwrapper_exec_suffix=.exe ;;
1280 esac
1281 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1282 }
1283
1284 # func_ltwrapper_scriptname file
1285 # Assumes file is an ltwrapper_executable
1286 # uses $file to determine the appropriate filename for a
1287 # temporary ltwrapper_script.
1288 func_ltwrapper_scriptname ()
1289 {
1290 func_dirname_and_basename "$1" "" "."
1291 func_stripname '' '.exe' "$func_basename_result"
1292 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1293 }
1294
1295 # func_ltwrapper_p file
1296 # True iff FILE is a libtool wrapper script or wrapper executable
1297 # This function is only a basic sanity check; it will hardly flush out
1298 # determined imposters.
1299 func_ltwrapper_p ()
1300 {
1301 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1302 }
1303
1304
1305 # func_execute_cmds commands fail_cmd
1306 # Execute tilde-delimited COMMANDS.
1307 # If FAIL_CMD is given, eval that upon failure.
1308 # FAIL_CMD may read-access the current command in variable CMD!
1309 func_execute_cmds ()
1310 {
1311 $opt_debug
1312 save_ifs=$IFS; IFS='~'
1313 for cmd in $1; do
1314 IFS=$save_ifs
1315 eval cmd=\"$cmd\"
1316 func_show_eval "$cmd" "${2-:}"
1317 done
1318 IFS=$save_ifs
1319 }
1320
1321
1322 # func_source file
1323 # Source FILE, adding directory component if necessary.
1324 # Note that it is not necessary on cygwin/mingw to append a dot to
1325 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1327 # `FILE.' does not work on cygwin managed mounts.
1328 func_source ()
1329 {
1330 $opt_debug
1331 case $1 in
1332 */* | *\\*) . "$1" ;;
1333 *) . "./$1" ;;
1334 esac
1335 }
1336
1337
1338 # func_resolve_sysroot PATH
1339 # Replace a leading = in PATH with a sysroot. Store the result into
1340 # func_resolve_sysroot_result
1341 func_resolve_sysroot ()
1342 {
1343 func_resolve_sysroot_result=$1
1344 case $func_resolve_sysroot_result in
1345 =*)
1346 func_stripname '=' '' "$func_resolve_sysroot_result"
1347 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1348 ;;
1349 esac
1350 }
1351
1352 # func_replace_sysroot PATH
1353 # If PATH begins with the sysroot, replace it with = and
1354 # store the result into func_replace_sysroot_result.
1355 func_replace_sysroot ()
1356 {
1357 case "$lt_sysroot:$1" in
1358 ?*:"$lt_sysroot"*)
1359 func_stripname "$lt_sysroot" '' "$1"
1360 func_replace_sysroot_result="=$func_stripname_result"
1361 ;;
1362 *)
1363 # Including no sysroot.
1364 func_replace_sysroot_result=$1
1365 ;;
1366 esac
1367 }
1368
1369 # func_infer_tag arg
1370 # Infer tagged configuration to use if any are available and
1371 # if one wasn't chosen via the "--tag" command line option.
1372 # Only attempt this if the compiler in the base compile
1373 # command doesn't match the default compiler.
1374 # arg is usually of the form 'gcc ...'
1375 func_infer_tag ()
1376 {
1377 $opt_debug
1378 if test -n "$available_tags" && test -z "$tagname"; then
1379 CC_quoted=
1380 for arg in $CC; do
1381 func_append_quoted CC_quoted "$arg"
1382 done
1383 CC_expanded=`func_echo_all $CC`
1384 CC_quoted_expanded=`func_echo_all $CC_quoted`
1385 case $@ in
1386 # Blanks in the command may have been stripped by the calling shell,
1387 # but not from the CC environment variable when configure was run.
1388 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1390 # Blanks at the start of $base_compile will cause this to fail
1391 # if we don't check for them as well.
1392 *)
1393 for z in $available_tags; do
1394 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1395 # Evaluate the configuration.
1396 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1397 CC_quoted=
1398 for arg in $CC; do
1399 # Double-quote args containing other shell metacharacters.
1400 func_append_quoted CC_quoted "$arg"
1401 done
1402 CC_expanded=`func_echo_all $CC`
1403 CC_quoted_expanded=`func_echo_all $CC_quoted`
1404 case "$@ " in
1405 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1407 # The compiler in the base compile command matches
1408 # the one in the tagged configuration.
1409 # Assume this is the tagged configuration we want.
1410 tagname=$z
1411 break
1412 ;;
1413 esac
1414 fi
1415 done
1416 # If $tagname still isn't set, then no tagged configuration
1417 # was found and let the user know that the "--tag" command
1418 # line option must be used.
1419 if test -z "$tagname"; then
1420 func_echo "unable to infer tagged configuration"
1421 func_fatal_error "specify a tag with \`--tag'"
1422 # else
1423 # func_verbose "using $tagname tagged configuration"
1424 fi
1425 ;;
1426 esac
1427 fi
1428 }
1429
1430
1431
1432 # func_write_libtool_object output_name pic_name nonpic_name
1433 # Create a libtool object file (analogous to a ".la" file),
1434 # but don't create it if we're doing a dry run.
1435 func_write_libtool_object ()
1436 {
1437 write_libobj=${1}
1438 if test "$build_libtool_libs" = yes; then
1439 write_lobj=\'${2}\'
1440 else
1441 write_lobj=none
1442 fi
1443
1444 if test "$build_old_libs" = yes; then
1445 write_oldobj=\'${3}\'
1446 else
1447 write_oldobj=none
1448 fi
1449
1450 $opt_dry_run || {
1451 cat >${write_libobj}T <<EOF
1452 # $write_libobj - a libtool object file
1453 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454 #
1455 # Please DO NOT delete this file!
1456 # It is necessary for linking the library.
1457
1458 # Name of the PIC object.
1459 pic_object=$write_lobj
1460
1461 # Name of the non-PIC object
1462 non_pic_object=$write_oldobj
1463
1464 EOF
1465 $MV "${write_libobj}T" "${write_libobj}"
1466 }
1467 }
1468
1469
1470 ##################################################
1471 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472 ##################################################
1473
1474 # func_convert_core_file_wine_to_w32 ARG
1475 # Helper function used by file name conversion functions when $build is *nix,
1476 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477 # correctly configured wine environment available, with the winepath program
1478 # in $build's $PATH.
1479 #
1480 # ARG is the $build file name to be converted to w32 format.
1481 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482 # be empty on error (or when ARG is empty)
1483 func_convert_core_file_wine_to_w32 ()
1484 {
1485 $opt_debug
1486 func_convert_core_file_wine_to_w32_result="$1"
1487 if test -n "$1"; then
1488 # Unfortunately, winepath does not exit with a non-zero error code, so we
1489 # are forced to check the contents of stdout. On the other hand, if the
1490 # command is not found, the shell will set an exit code of 127 and print
1491 # *an error message* to stdout. So we must check for both error code of
1492 # zero AND non-empty stdout, which explains the odd construction:
1493 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1494 if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496 $SED -e "$lt_sed_naive_backslashify"`
1497 else
1498 func_convert_core_file_wine_to_w32_result=
1499 fi
1500 fi
1501 }
1502 # end: func_convert_core_file_wine_to_w32
1503
1504
1505 # func_convert_core_path_wine_to_w32 ARG
1506 # Helper function used by path conversion functions when $build is *nix, and
1507 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508 # configured wine environment available, with the winepath program in $build's
1509 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1510 #
1511 # ARG is path to be converted from $build format to win32.
1512 # Result is available in $func_convert_core_path_wine_to_w32_result.
1513 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1514 # are convertible, then the result may be empty.
1515 func_convert_core_path_wine_to_w32 ()
1516 {
1517 $opt_debug
1518 # unfortunately, winepath doesn't convert paths, only file names
1519 func_convert_core_path_wine_to_w32_result=""
1520 if test -n "$1"; then
1521 oldIFS=$IFS
1522 IFS=:
1523 for func_convert_core_path_wine_to_w32_f in $1; do
1524 IFS=$oldIFS
1525 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1526 if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527 if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528 func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529 else
1530 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1531 fi
1532 fi
1533 done
1534 IFS=$oldIFS
1535 fi
1536 }
1537 # end: func_convert_core_path_wine_to_w32
1538
1539
1540 # func_cygpath ARGS...
1541 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1545 # file name or path is assumed to be in w32 format, as previously converted
1546 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547 # or path in func_cygpath_result (input file name or path is assumed to be in
1548 # Cygwin format). Returns an empty string on error.
1549 #
1550 # ARGS are passed to cygpath, with the last one being the file name or path to
1551 # be converted.
1552 #
1553 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554 # environment variable; do not put it in $PATH.
1555 func_cygpath ()
1556 {
1557 $opt_debug
1558 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1560 if test "$?" -ne 0; then
1561 # on failure, ensure result is empty
1562 func_cygpath_result=
1563 fi
1564 else
1565 func_cygpath_result=
1566 func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1567 fi
1568 }
1569 #end: func_cygpath
1570
1571
1572 # func_convert_core_msys_to_w32 ARG
1573 # Convert file name or path ARG from MSYS format to w32 format. Return
1574 # result in func_convert_core_msys_to_w32_result.
1575 func_convert_core_msys_to_w32 ()
1576 {
1577 $opt_debug
1578 # awkward: cmd appends spaces to result
1579 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1580 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581 }
1582 #end: func_convert_core_msys_to_w32
1583
1584
1585 # func_convert_file_check ARG1 ARG2
1586 # Verify that ARG1 (a file name in $build format) was converted to $host
1587 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1588 # func_to_host_file_result to ARG1).
1589 func_convert_file_check ()
1590 {
1591 $opt_debug
1592 if test -z "$2" && test -n "$1" ; then
1593 func_error "Could not determine host file name corresponding to"
1594 func_error " \`$1'"
1595 func_error "Continuing, but uninstalled executables may not work."
1596 # Fallback:
1597 func_to_host_file_result="$1"
1598 fi
1599 }
1600 # end func_convert_file_check
1601
1602
1603 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604 # Verify that FROM_PATH (a path in $build format) was converted to $host
1605 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606 # func_to_host_file_result to a simplistic fallback value (see below).
1607 func_convert_path_check ()
1608 {
1609 $opt_debug
1610 if test -z "$4" && test -n "$3"; then
1611 func_error "Could not determine the host path corresponding to"
1612 func_error " \`$3'"
1613 func_error "Continuing, but uninstalled executables may not work."
1614 # Fallback. This is a deliberately simplistic "conversion" and
1615 # should not be "improved". See libtool.info.
1616 if test "x$1" != "x$2"; then
1617 lt_replace_pathsep_chars="s|$1|$2|g"
1618 func_to_host_path_result=`echo "$3" |
1619 $SED -e "$lt_replace_pathsep_chars"`
1620 else
1621 func_to_host_path_result="$3"
1622 fi
1623 fi
1624 }
1625 # end func_convert_path_check
1626
1627
1628 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630 # and appending REPL if ORIG matches BACKPAT.
1631 func_convert_path_front_back_pathsep ()
1632 {
1633 $opt_debug
1634 case $4 in
1635 $1 ) func_to_host_path_result="$3$func_to_host_path_result"
1636 ;;
1637 esac
1638 case $4 in
1639 $2 ) func_append func_to_host_path_result "$3"
1640 ;;
1641 esac
1642 }
1643 # end func_convert_path_front_back_pathsep
1644
1645
1646 ##################################################
1647 # $build to $host FILE NAME CONVERSION FUNCTIONS #
1648 ##################################################
1649 # invoked via `$to_host_file_cmd ARG'
1650 #
1651 # In each case, ARG is the path to be converted from $build to $host format.
1652 # Result will be available in $func_to_host_file_result.
1653
1654
1655 # func_to_host_file ARG
1656 # Converts the file name ARG from $build format to $host format. Return result
1657 # in func_to_host_file_result.
1658 func_to_host_file ()
1659 {
1660 $opt_debug
1661 $to_host_file_cmd "$1"
1662 }
1663 # end func_to_host_file
1664
1665
1666 # func_to_tool_file ARG LAZY
1667 # converts the file name ARG from $build format to toolchain format. Return
1668 # result in func_to_tool_file_result. If the conversion in use is listed
1669 # in (the comma separated) LAZY, no conversion takes place.
1670 func_to_tool_file ()
1671 {
1672 $opt_debug
1673 case ,$2, in
1674 *,"$to_tool_file_cmd",*)
1675 func_to_tool_file_result=$1
1676 ;;
1677 *)
1678 $to_tool_file_cmd "$1"
1679 func_to_tool_file_result=$func_to_host_file_result
1680 ;;
1681 esac
1682 }
1683 # end func_to_tool_file
1684
1685
1686 # func_convert_file_noop ARG
1687 # Copy ARG to func_to_host_file_result.
1688 func_convert_file_noop ()
1689 {
1690 func_to_host_file_result="$1"
1691 }
1692 # end func_convert_file_noop
1693
1694
1695 # func_convert_file_msys_to_w32 ARG
1696 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697 # conversion to w32 is not available inside the cwrapper. Returns result in
1698 # func_to_host_file_result.
1699 func_convert_file_msys_to_w32 ()
1700 {
1701 $opt_debug
1702 func_to_host_file_result="$1"
1703 if test -n "$1"; then
1704 func_convert_core_msys_to_w32 "$1"
1705 func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706 fi
1707 func_convert_file_check "$1" "$func_to_host_file_result"
1708 }
1709 # end func_convert_file_msys_to_w32
1710
1711
1712 # func_convert_file_cygwin_to_w32 ARG
1713 # Convert file name ARG from Cygwin to w32 format. Returns result in
1714 # func_to_host_file_result.
1715 func_convert_file_cygwin_to_w32 ()
1716 {
1717 $opt_debug
1718 func_to_host_file_result="$1"
1719 if test -n "$1"; then
1720 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721 # LT_CYGPATH in this case.
1722 func_to_host_file_result=`cygpath -m "$1"`
1723 fi
1724 func_convert_file_check "$1" "$func_to_host_file_result"
1725 }
1726 # end func_convert_file_cygwin_to_w32
1727
1728
1729 # func_convert_file_nix_to_w32 ARG
1730 # Convert file name ARG from *nix to w32 format. Requires a wine environment
1731 # and a working winepath. Returns result in func_to_host_file_result.
1732 func_convert_file_nix_to_w32 ()
1733 {
1734 $opt_debug
1735 func_to_host_file_result="$1"
1736 if test -n "$1"; then
1737 func_convert_core_file_wine_to_w32 "$1"
1738 func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739 fi
1740 func_convert_file_check "$1" "$func_to_host_file_result"
1741 }
1742 # end func_convert_file_nix_to_w32
1743
1744
1745 # func_convert_file_msys_to_cygwin ARG
1746 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1747 # Returns result in func_to_host_file_result.
1748 func_convert_file_msys_to_cygwin ()
1749 {
1750 $opt_debug
1751 func_to_host_file_result="$1"
1752 if test -n "$1"; then
1753 func_convert_core_msys_to_w32 "$1"
1754 func_cygpath -u "$func_convert_core_msys_to_w32_result"
1755 func_to_host_file_result="$func_cygpath_result"
1756 fi
1757 func_convert_file_check "$1" "$func_to_host_file_result"
1758 }
1759 # end func_convert_file_msys_to_cygwin
1760
1761
1762 # func_convert_file_nix_to_cygwin ARG
1763 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1764 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1765 # in func_to_host_file_result.
1766 func_convert_file_nix_to_cygwin ()
1767 {
1768 $opt_debug
1769 func_to_host_file_result="$1"
1770 if test -n "$1"; then
1771 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772 func_convert_core_file_wine_to_w32 "$1"
1773 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1774 func_to_host_file_result="$func_cygpath_result"
1775 fi
1776 func_convert_file_check "$1" "$func_to_host_file_result"
1777 }
1778 # end func_convert_file_nix_to_cygwin
1779
1780
1781 #############################################
1782 # $build to $host PATH CONVERSION FUNCTIONS #
1783 #############################################
1784 # invoked via `$to_host_path_cmd ARG'
1785 #
1786 # In each case, ARG is the path to be converted from $build to $host format.
1787 # The result will be available in $func_to_host_path_result.
1788 #
1789 # Path separators are also converted from $build format to $host format. If
1790 # ARG begins or ends with a path separator character, it is preserved (but
1791 # converted to $host format) on output.
1792 #
1793 # All path conversion functions are named using the following convention:
1794 # file name conversion function : func_convert_file_X_to_Y ()
1795 # path conversion function : func_convert_path_X_to_Y ()
1796 # where, for any given $build/$host combination the 'X_to_Y' value is the
1797 # same. If conversion functions are added for new $build/$host combinations,
1798 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1799 # will break.
1800
1801
1802 # func_init_to_host_path_cmd
1803 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804 # appropriate value, based on the value of $to_host_file_cmd.
1805 to_host_path_cmd=
1806 func_init_to_host_path_cmd ()
1807 {
1808 $opt_debug
1809 if test -z "$to_host_path_cmd"; then
1810 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1811 to_host_path_cmd="func_convert_path_${func_stripname_result}"
1812 fi
1813 }
1814
1815
1816 # func_to_host_path ARG
1817 # Converts the path ARG from $build format to $host format. Return result
1818 # in func_to_host_path_result.
1819 func_to_host_path ()
1820 {
1821 $opt_debug
1822 func_init_to_host_path_cmd
1823 $to_host_path_cmd "$1"
1824 }
1825 # end func_to_host_path
1826
1827
1828 # func_convert_path_noop ARG
1829 # Copy ARG to func_to_host_path_result.
1830 func_convert_path_noop ()
1831 {
1832 func_to_host_path_result="$1"
1833 }
1834 # end func_convert_path_noop
1835
1836
1837 # func_convert_path_msys_to_w32 ARG
1838 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839 # conversion to w32 is not available inside the cwrapper. Returns result in
1840 # func_to_host_path_result.
1841 func_convert_path_msys_to_w32 ()
1842 {
1843 $opt_debug
1844 func_to_host_path_result="$1"
1845 if test -n "$1"; then
1846 # Remove leading and trailing path separator characters from ARG. MSYS
1847 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848 # and winepath ignores them completely.
1849 func_stripname : : "$1"
1850 func_to_host_path_tmp1=$func_stripname_result
1851 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1852 func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1853 func_convert_path_check : ";" \
1854 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1855 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1856 fi
1857 }
1858 # end func_convert_path_msys_to_w32
1859
1860
1861 # func_convert_path_cygwin_to_w32 ARG
1862 # Convert path ARG from Cygwin to w32 format. Returns result in
1863 # func_to_host_file_result.
1864 func_convert_path_cygwin_to_w32 ()
1865 {
1866 $opt_debug
1867 func_to_host_path_result="$1"
1868 if test -n "$1"; then
1869 # See func_convert_path_msys_to_w32:
1870 func_stripname : : "$1"
1871 func_to_host_path_tmp1=$func_stripname_result
1872 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1873 func_convert_path_check : ";" \
1874 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1875 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1876 fi
1877 }
1878 # end func_convert_path_cygwin_to_w32
1879
1880
1881 # func_convert_path_nix_to_w32 ARG
1882 # Convert path ARG from *nix to w32 format. Requires a wine environment and
1883 # a working winepath. Returns result in func_to_host_file_result.
1884 func_convert_path_nix_to_w32 ()
1885 {
1886 $opt_debug
1887 func_to_host_path_result="$1"
1888 if test -n "$1"; then
1889 # See func_convert_path_msys_to_w32:
1890 func_stripname : : "$1"
1891 func_to_host_path_tmp1=$func_stripname_result
1892 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1893 func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1894 func_convert_path_check : ";" \
1895 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1896 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1897 fi
1898 }
1899 # end func_convert_path_nix_to_w32
1900
1901
1902 # func_convert_path_msys_to_cygwin ARG
1903 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1904 # Returns result in func_to_host_file_result.
1905 func_convert_path_msys_to_cygwin ()
1906 {
1907 $opt_debug
1908 func_to_host_path_result="$1"
1909 if test -n "$1"; then
1910 # See func_convert_path_msys_to_w32:
1911 func_stripname : : "$1"
1912 func_to_host_path_tmp1=$func_stripname_result
1913 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1914 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1915 func_to_host_path_result="$func_cygpath_result"
1916 func_convert_path_check : : \
1917 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1918 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1919 fi
1920 }
1921 # end func_convert_path_msys_to_cygwin
1922
1923
1924 # func_convert_path_nix_to_cygwin ARG
1925 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1926 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1927 # func_to_host_file_result.
1928 func_convert_path_nix_to_cygwin ()
1929 {
1930 $opt_debug
1931 func_to_host_path_result="$1"
1932 if test -n "$1"; then
1933 # Remove leading and trailing path separator characters from
1934 # ARG. msys behavior is inconsistent here, cygpath turns them
1935 # into '.;' and ';.', and winepath ignores them completely.
1936 func_stripname : : "$1"
1937 func_to_host_path_tmp1=$func_stripname_result
1938 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1939 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1940 func_to_host_path_result="$func_cygpath_result"
1941 func_convert_path_check : : \
1942 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1943 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1944 fi
1945 }
1946 # end func_convert_path_nix_to_cygwin
1947
1948
1949 # func_mode_compile arg...
1950 func_mode_compile ()
1951 {
1952 $opt_debug
1953 # Get the compilation command and the source file.
1954 base_compile=
1955 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1956 suppress_opt=yes
1957 suppress_output=
1958 arg_mode=normal
1959 libobj=
1960 later=
1961 pie_flag=
1962
1963 for arg
1964 do
1965 case $arg_mode in
1966 arg )
1967 # do not "continue". Instead, add this to base_compile
1968 lastarg="$arg"
1969 arg_mode=normal
1970 ;;
1971
1972 target )
1973 libobj="$arg"
1974 arg_mode=normal
1975 continue
1976 ;;
1977
1978 normal )
1979 # Accept any command-line options.
1980 case $arg in
1981 -o)
1982 test -n "$libobj" && \
1983 func_fatal_error "you cannot specify \`-o' more than once"
1984 arg_mode=target
1985 continue
1986 ;;
1987
1988 -pie | -fpie | -fPIE)
1989 func_append pie_flag " $arg"
1990 continue
1991 ;;
1992
1993 -shared | -static | -prefer-pic | -prefer-non-pic)
1994 func_append later " $arg"
1995 continue
1996 ;;
1997
1998 -no-suppress)
1999 suppress_opt=no
2000 continue
2001 ;;
2002
2003 -Xcompiler)
2004 arg_mode=arg # the next one goes into the "base_compile" arg list
2005 continue # The current "srcfile" will either be retained or
2006 ;; # replaced later. I would guess that would be a bug.
2007
2008 -Wc,*)
2009 func_stripname '-Wc,' '' "$arg"
2010 args=$func_stripname_result
2011 lastarg=
2012 save_ifs="$IFS"; IFS=','
2013 for arg in $args; do
2014 IFS="$save_ifs"
2015 func_append_quoted lastarg "$arg"
2016 done
2017 IFS="$save_ifs"
2018 func_stripname ' ' '' "$lastarg"
2019 lastarg=$func_stripname_result
2020
2021 # Add the arguments to base_compile.
2022 func_append base_compile " $lastarg"
2023 continue
2024 ;;
2025
2026 *)
2027 # Accept the current argument as the source file.
2028 # The previous "srcfile" becomes the current argument.
2029 #
2030 lastarg="$srcfile"
2031 srcfile="$arg"
2032 ;;
2033 esac # case $arg
2034 ;;
2035 esac # case $arg_mode
2036
2037 # Aesthetically quote the previous argument.
2038 func_append_quoted base_compile "$lastarg"
2039 done # for arg
2040
2041 case $arg_mode in
2042 arg)
2043 func_fatal_error "you must specify an argument for -Xcompile"
2044 ;;
2045 target)
2046 func_fatal_error "you must specify a target with \`-o'"
2047 ;;
2048 *)
2049 # Get the name of the library object.
2050 test -z "$libobj" && {
2051 func_basename "$srcfile"
2052 libobj="$func_basename_result"
2053 }
2054 ;;
2055 esac
2056
2057 # Recognize several different file suffixes.
2058 # If the user specifies -o file.o, it is replaced with file.lo
2059 case $libobj in
2060 *.[cCFSifmso] | \
2061 *.ada | *.adb | *.ads | *.asm | \
2062 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2063 *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
2064 func_xform "$libobj"
2065 libobj=$func_xform_result
2066 ;;
2067 esac
2068
2069 case $libobj in
2070 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071 *)
2072 func_fatal_error "cannot determine name of library object from \`$libobj'"
2073 ;;
2074 esac
2075
2076 func_infer_tag $base_compile
2077
2078 for arg in $later; do
2079 case $arg in
2080 -shared)
2081 test "$build_libtool_libs" != yes && \
2082 func_fatal_configuration "can not build a shared library"
2083 build_old_libs=no
2084 continue
2085 ;;
2086
2087 -static)
2088 build_libtool_libs=no
2089 build_old_libs=yes
2090 continue
2091 ;;
2092
2093 -prefer-pic)
2094 pic_mode=yes
2095 continue
2096 ;;
2097
2098 -prefer-non-pic)
2099 pic_mode=no
2100 continue
2101 ;;
2102 esac
2103 done
2104
2105 func_quote_for_eval "$libobj"
2106 test "X$libobj" != "X$func_quote_for_eval_result" \
2107 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2108 && func_warning "libobj name \`$libobj' may not contain shell special characters."
2109 func_dirname_and_basename "$obj" "/" ""
2110 objname="$func_basename_result"
2111 xdir="$func_dirname_result"
2112 lobj=${xdir}$objdir/$objname
2113
2114 test -z "$base_compile" && \
2115 func_fatal_help "you must specify a compilation command"
2116
2117 # Delete any leftover library objects.
2118 if test "$build_old_libs" = yes; then
2119 removelist="$obj $lobj $libobj ${libobj}T"
2120 else
2121 removelist="$lobj $libobj ${libobj}T"
2122 fi
2123
2124 # On Cygwin there's no "real" PIC flag so we must build both object types
2125 case $host_os in
2126 cygwin* | mingw* | pw32* | os2* | cegcc*)
2127 pic_mode=default
2128 ;;
2129 esac
2130 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2131 # non-PIC code in shared libraries is not supported
2132 pic_mode=default
2133 fi
2134
2135 # Calculate the filename of the output object if compiler does
2136 # not support -o with -c
2137 if test "$compiler_c_o" = no; then
2138 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2139 lockfile="$output_obj.lock"
2140 else
2141 output_obj=
2142 need_locks=no
2143 lockfile=
2144 fi
2145
2146 # Lock this critical section if it is needed
2147 # We use this script file to make the link, it avoids creating a new file
2148 if test "$need_locks" = yes; then
2149 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2150 func_echo "Waiting for $lockfile to be removed"
2151 sleep 2
2152 done
2153 elif test "$need_locks" = warn; then
2154 if test -f "$lockfile"; then
2155 $ECHO "\
2156 *** ERROR, $lockfile exists and contains:
2157 `cat $lockfile 2>/dev/null`
2158
2159 This indicates that another process is trying to use the same
2160 temporary object file, and libtool could not work around it because
2161 your compiler does not support \`-c' and \`-o' together. If you
2162 repeat this compilation, it may succeed, by chance, but you had better
2163 avoid parallel builds (make -j) in this platform, or get a better
2164 compiler."
2165
2166 $opt_dry_run || $RM $removelist
2167 exit $EXIT_FAILURE
2168 fi
2169 func_append removelist " $output_obj"
2170 $ECHO "$srcfile" > "$lockfile"
2171 fi
2172
2173 $opt_dry_run || $RM $removelist
2174 func_append removelist " $lockfile"
2175 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176
2177 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178 srcfile=$func_to_tool_file_result
2179 func_quote_for_eval "$srcfile"
2180 qsrcfile=$func_quote_for_eval_result
2181
2182 # Only build a PIC object if we are building libtool libraries.
2183 if test "$build_libtool_libs" = yes; then
2184 # Without this assignment, base_compile gets emptied.
2185 fbsd_hideous_sh_bug=$base_compile
2186
2187 if test "$pic_mode" != no; then
2188 command="$base_compile $qsrcfile $pic_flag"
2189 else
2190 # Don't build PIC code
2191 command="$base_compile $qsrcfile"
2192 fi
2193
2194 func_mkdir_p "$xdir$objdir"
2195
2196 if test -z "$output_obj"; then
2197 # Place PIC objects in $objdir
2198 func_append command " -o $lobj"
2199 fi
2200
2201 func_show_eval_locale "$command" \
2202 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203
2204 if test "$need_locks" = warn &&
2205 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206 $ECHO "\
2207 *** ERROR, $lockfile contains:
2208 `cat $lockfile 2>/dev/null`
2209
2210 but it should contain:
2211 $srcfile
2212
2213 This indicates that another process is trying to use the same
2214 temporary object file, and libtool could not work around it because
2215 your compiler does not support \`-c' and \`-o' together. If you
2216 repeat this compilation, it may succeed, by chance, but you had better
2217 avoid parallel builds (make -j) in this platform, or get a better
2218 compiler."
2219
2220 $opt_dry_run || $RM $removelist
2221 exit $EXIT_FAILURE
2222 fi
2223
2224 # Just move the object if needed, then go on to compile the next one
2225 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226 func_show_eval '$MV "$output_obj" "$lobj"' \
2227 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2228 fi
2229
2230 # Allow error messages only from the first compilation.
2231 if test "$suppress_opt" = yes; then
2232 suppress_output=' >/dev/null 2>&1'
2233 fi
2234 fi
2235
2236 # Only build a position-dependent object if we build old libraries.
2237 if test "$build_old_libs" = yes; then
2238 if test "$pic_mode" != yes; then
2239 # Don't build PIC code
2240 command="$base_compile $qsrcfile$pie_flag"
2241 else
2242 command="$base_compile $qsrcfile $pic_flag"
2243 fi
2244 if test "$compiler_c_o" = yes; then
2245 func_append command " -o $obj"
2246 fi
2247
2248 # Suppress compiler output if we already did a PIC compilation.
2249 func_append command "$suppress_output"
2250 func_show_eval_locale "$command" \
2251 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252
2253 if test "$need_locks" = warn &&
2254 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255 $ECHO "\
2256 *** ERROR, $lockfile contains:
2257 `cat $lockfile 2>/dev/null`
2258
2259 but it should contain:
2260 $srcfile
2261
2262 This indicates that another process is trying to use the same
2263 temporary object file, and libtool could not work around it because
2264 your compiler does not support \`-c' and \`-o' together. If you
2265 repeat this compilation, it may succeed, by chance, but you had better
2266 avoid parallel builds (make -j) in this platform, or get a better
2267 compiler."
2268
2269 $opt_dry_run || $RM $removelist
2270 exit $EXIT_FAILURE
2271 fi
2272
2273 # Just move the object if needed
2274 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275 func_show_eval '$MV "$output_obj" "$obj"' \
2276 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2277 fi
2278 fi
2279
2280 $opt_dry_run || {
2281 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282
2283 # Unlock the critical section if it was locked
2284 if test "$need_locks" != no; then
2285 removelist=$lockfile
2286 $RM "$lockfile"
2287 fi
2288 }
2289
2290 exit $EXIT_SUCCESS
2291 }
2292
2293 $opt_help || {
2294 test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2295 }
2296
2297 func_mode_help ()
2298 {
2299 # We need to display help for each of the modes.
2300 case $opt_mode in
2301 "")
2302 # Generic help is extracted from the usage comments
2303 # at the start of this file.
2304 func_help
2305 ;;
2306
2307 clean)
2308 $ECHO \
2309 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310
2311 Remove files from the build directory.
2312
2313 RM is the name of the program to use to delete files associated with each FILE
2314 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2315 to RM.
2316
2317 If FILE is a libtool library, object or program, all the files associated
2318 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2319 ;;
2320
2321 compile)
2322 $ECHO \
2323 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324
2325 Compile a source file into a libtool library object.
2326
2327 This mode accepts the following additional options:
2328
2329 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
2330 -no-suppress do not suppress compiler output for multiple passes
2331 -prefer-pic try to build PIC objects only
2332 -prefer-non-pic try to build non-PIC objects only
2333 -shared do not build a \`.o' file suitable for static linking
2334 -static only build a \`.o' file suitable for static linking
2335 -Wc,FLAG pass FLAG directly to the compiler
2336
2337 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338 from the given SOURCEFILE.
2339
2340 The output file name is determined by removing the directory component from
2341 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342 library object suffix, \`.lo'."
2343 ;;
2344
2345 execute)
2346 $ECHO \
2347 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348
2349 Automatically set library path, then run a program.
2350
2351 This mode accepts the following additional options:
2352
2353 -dlopen FILE add the directory containing FILE to the library path
2354
2355 This mode sets the library path environment variable according to \`-dlopen'
2356 flags.
2357
2358 If any of the ARGS are libtool executable wrappers, then they are translated
2359 into their corresponding uninstalled binary, and any of their required library
2360 directories are added to the library path.
2361
2362 Then, COMMAND is executed, with ARGS as arguments."
2363 ;;
2364
2365 finish)
2366 $ECHO \
2367 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368
2369 Complete the installation of libtool libraries.
2370
2371 Each LIBDIR is a directory that contains libtool libraries.
2372
2373 The commands that this mode executes may require superuser privileges. Use
2374 the \`--dry-run' option if you just want to see what would be executed."
2375 ;;
2376
2377 install)
2378 $ECHO \
2379 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380
2381 Install executables or libraries.
2382
2383 INSTALL-COMMAND is the installation command. The first component should be
2384 either the \`install' or \`cp' program.
2385
2386 The following components of INSTALL-COMMAND are treated specially:
2387
2388 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2389
2390 The rest of the components are interpreted as arguments to that command (only
2391 BSD-compatible install options are recognized)."
2392 ;;
2393
2394 link)
2395 $ECHO \
2396 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397
2398 Link object files or libraries together to form another library, or to
2399 create an executable program.
2400
2401 LINK-COMMAND is a command using the C compiler that you would use to create
2402 a program from several object files.
2403
2404 The following components of LINK-COMMAND are treated specially:
2405
2406 -all-static do not do any dynamic linking at all
2407 -avoid-version do not add a version suffix if possible
2408 -bindir BINDIR specify path to binaries directory (for systems where
2409 libraries must be found in the PATH setting at runtime)
2410 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2412 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413 -export-symbols SYMFILE
2414 try to export only the symbols listed in SYMFILE
2415 -export-symbols-regex REGEX
2416 try to export only the symbols matching REGEX
2417 -LLIBDIR search LIBDIR for required installed libraries
2418 -lNAME OUTPUT-FILE requires the installed library libNAME
2419 -module build a library that can dlopened
2420 -no-fast-install disable the fast-install mode
2421 -no-install link a not-installable executable
2422 -no-undefined declare that a library does not refer to external symbols
2423 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2424 -objectlist FILE Use a list of object files found in FILE to specify objects
2425 -precious-files-regex REGEX
2426 don't remove output files matching REGEX
2427 -release RELEASE specify package release information
2428 -rpath LIBDIR the created library will eventually be installed in LIBDIR
2429 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2430 -shared only do dynamic linking of libtool libraries
2431 -shrext SUFFIX override the standard shared library file extension
2432 -static do not do any dynamic linking of uninstalled libtool libraries
2433 -static-libtool-libs
2434 do not do any dynamic linking of libtool libraries
2435 -version-info CURRENT[:REVISION[:AGE]]
2436 specify library version info [each variable defaults to 0]
2437 -weak LIBNAME declare that the target provides the LIBNAME interface
2438 -Wc,FLAG
2439 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2440 -Wl,FLAG
2441 -Xlinker FLAG pass linker-specific FLAG directly to the linker
2442 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2443
2444 All other options (arguments beginning with \`-') are ignored.
2445
2446 Every other argument is treated as a filename. Files ending in \`.la' are
2447 treated as uninstalled libtool libraries, other files are standard or library
2448 object files.
2449
2450 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452 required, except when creating a convenience library.
2453
2454 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455 using \`ar' and \`ranlib', or on Windows using \`lib'.
2456
2457 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458 is created, otherwise an executable program is created."
2459 ;;
2460
2461 uninstall)
2462 $ECHO \
2463 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464
2465 Remove libraries from an installation directory.
2466
2467 RM is the name of the program to use to delete files associated with each FILE
2468 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2469 to RM.
2470
2471 If FILE is a libtool library, all the files associated with it are deleted.
2472 Otherwise, only FILE itself is deleted using RM."
2473 ;;
2474
2475 *)
2476 func_fatal_help "invalid operation mode \`$opt_mode'"
2477 ;;
2478 esac
2479
2480 echo
2481 $ECHO "Try \`$progname --help' for more information about other modes."
2482 }
2483
2484 # Now that we've collected a possible --mode arg, show help if necessary
2485 if $opt_help; then
2486 if test "$opt_help" = :; then
2487 func_mode_help
2488 else
2489 {
2490 func_help noexit
2491 for opt_mode in compile link execute install finish uninstall clean; do
2492 func_mode_help
2493 done
2494 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
2495 {
2496 func_help noexit
2497 for opt_mode in compile link execute install finish uninstall clean; do
2498 echo
2499 func_mode_help
2500 done
2501 } |
2502 sed '1d
2503 /^When reporting/,/^Report/{
2504 H
2505 d
2506 }
2507 $x
2508 /information about other modes/d
2509 /more detailed .*MODE/d
2510 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2511 fi
2512 exit $?
2513 fi
2514
2515
2516 # func_mode_execute arg...
2517 func_mode_execute ()
2518 {
2519 $opt_debug
2520 # The first argument is the command name.
2521 cmd="$nonopt"
2522 test -z "$cmd" && \
2523 func_fatal_help "you must specify a COMMAND"
2524
2525 # Handle -dlopen flags immediately.
2526 for file in $opt_dlopen; do
2527 test -f "$file" \
2528 || func_fatal_help "\`$file' is not a file"
2529
2530 dir=
2531 case $file in
2532 *.la)
2533 func_resolve_sysroot "$file"
2534 file=$func_resolve_sysroot_result
2535
2536 # Check to see that this really is a libtool archive.
2537 func_lalib_unsafe_p "$file" \
2538 || func_fatal_help "\`$lib' is not a valid libtool archive"
2539
2540 # Read the libtool library.
2541 dlname=
2542 library_names=
2543 func_source "$file"
2544
2545 # Skip this library if it cannot be dlopened.
2546 if test -z "$dlname"; then
2547 # Warn if it was a shared library.
2548 test -n "$library_names" && \
2549 func_warning "\`$file' was not linked with \`-export-dynamic'"
2550 continue
2551 fi
2552
2553 func_dirname "$file" "" "."
2554 dir="$func_dirname_result"
2555
2556 if test -f "$dir/$objdir/$dlname"; then
2557 func_append dir "/$objdir"
2558 else
2559 if test ! -f "$dir/$dlname"; then
2560 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2561 fi
2562 fi
2563 ;;
2564
2565 *.lo)
2566 # Just add the directory containing the .lo file.
2567 func_dirname "$file" "" "."
2568 dir="$func_dirname_result"
2569 ;;
2570
2571 *)
2572 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2573 continue
2574 ;;
2575 esac
2576
2577 # Get the absolute pathname.
2578 absdir=`cd "$dir" && pwd`
2579 test -n "$absdir" && dir="$absdir"
2580
2581 # Now add the directory to shlibpath_var.
2582 if eval "test -z \"\$$shlibpath_var\""; then
2583 eval "$shlibpath_var=\"\$dir\""
2584 else
2585 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2586 fi
2587 done
2588
2589 # This variable tells wrapper scripts just to set shlibpath_var
2590 # rather than running their programs.
2591 libtool_execute_magic="$magic"
2592
2593 # Check if any of the arguments is a wrapper script.
2594 args=
2595 for file
2596 do
2597 case $file in
2598 -* | *.la | *.lo ) ;;
2599 *)
2600 # Do a test to see if this is really a libtool program.
2601 if func_ltwrapper_script_p "$file"; then
2602 func_source "$file"
2603 # Transform arg to wrapped name.
2604 file="$progdir/$program"
2605 elif func_ltwrapper_executable_p "$file"; then
2606 func_ltwrapper_scriptname "$file"
2607 func_source "$func_ltwrapper_scriptname_result"
2608 # Transform arg to wrapped name.
2609 file="$progdir/$program"
2610 fi
2611 ;;
2612 esac
2613 # Quote arguments (to preserve shell metacharacters).
2614 func_append_quoted args "$file"
2615 done
2616
2617 if test "X$opt_dry_run" = Xfalse; then
2618 if test -n "$shlibpath_var"; then
2619 # Export the shlibpath_var.
2620 eval "export $shlibpath_var"
2621 fi
2622
2623 # Restore saved environment variables
2624 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625 do
2626 eval "if test \"\${save_$lt_var+set}\" = set; then
2627 $lt_var=\$save_$lt_var; export $lt_var
2628 else
2629 $lt_unset $lt_var
2630 fi"
2631 done
2632
2633 # Now prepare to actually exec the command.
2634 exec_cmd="\$cmd$args"
2635 else
2636 # Display what would be done.
2637 if test -n "$shlibpath_var"; then
2638 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639 echo "export $shlibpath_var"
2640 fi
2641 $ECHO "$cmd$args"
2642 exit $EXIT_SUCCESS
2643 fi
2644 }
2645
2646 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2647
2648
2649 # func_mode_finish arg...
2650 func_mode_finish ()
2651 {
2652 $opt_debug
2653 libs=
2654 libdirs=
2655 admincmds=
2656
2657 for opt in "$nonopt" ${1+"$@"}
2658 do
2659 if test -d "$opt"; then
2660 func_append libdirs " $opt"
2661
2662 elif test -f "$opt"; then
2663 if func_lalib_unsafe_p "$opt"; then
2664 func_append libs " $opt"
2665 else
2666 func_warning "\`$opt' is not a valid libtool archive"
2667 fi
2668
2669 else
2670 func_fatal_error "invalid argument \`$opt'"
2671 fi
2672 done
2673
2674 if test -n "$libs"; then
2675 if test -n "$lt_sysroot"; then
2676 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2678 else
2679 sysroot_cmd=
2680 fi
2681
2682 # Remove sysroot references
2683 if $opt_dry_run; then
2684 for lib in $libs; do
2685 echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2686 done
2687 else
2688 tmpdir=`func_mktempdir`
2689 for lib in $libs; do
2690 sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691 > $tmpdir/tmp-la
2692 mv -f $tmpdir/tmp-la $lib
2693 done
2694 ${RM}r "$tmpdir"
2695 fi
2696 fi
2697
2698 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699 for libdir in $libdirs; do
2700 if test -n "$finish_cmds"; then
2701 # Do each command in the finish commands.
2702 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2703 '"$cmd"'"'
2704 fi
2705 if test -n "$finish_eval"; then
2706 # Do the single finish_eval.
2707 eval cmds=\"$finish_eval\"
2708 $opt_dry_run || eval "$cmds" || func_append admincmds "
2709 $cmds"
2710 fi
2711 done
2712 fi
2713
2714 # Exit here if they wanted silent mode.
2715 $opt_silent && exit $EXIT_SUCCESS
2716
2717 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718 echo "----------------------------------------------------------------------"
2719 echo "Libraries have been installed in:"
2720 for libdir in $libdirs; do
2721 $ECHO " $libdir"
2722 done
2723 echo
2724 echo "If you ever happen to want to link against installed libraries"
2725 echo "in a given directory, LIBDIR, you must either use libtool, and"
2726 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727 echo "flag during linking and do at least one of the following:"
2728 if test -n "$shlibpath_var"; then
2729 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2730 echo " during execution"
2731 fi
2732 if test -n "$runpath_var"; then
2733 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2734 echo " during linking"
2735 fi
2736 if test -n "$hardcode_libdir_flag_spec"; then
2737 libdir=LIBDIR
2738 eval flag=\"$hardcode_libdir_flag_spec\"
2739
2740 $ECHO " - use the \`$flag' linker flag"
2741 fi
2742 if test -n "$admincmds"; then
2743 $ECHO " - have your system administrator run these commands:$admincmds"
2744 fi
2745 if test -f /etc/ld.so.conf; then
2746 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2747 fi
2748 echo
2749
2750 echo "See any operating system documentation about shared libraries for"
2751 case $host in
2752 solaris2.[6789]|solaris2.1[0-9])
2753 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2754 echo "pages."
2755 ;;
2756 *)
2757 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2758 ;;
2759 esac
2760 echo "----------------------------------------------------------------------"
2761 fi
2762 exit $EXIT_SUCCESS
2763 }
2764
2765 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2766
2767
2768 # func_mode_install arg...
2769 func_mode_install ()
2770 {
2771 $opt_debug
2772 # There may be an optional sh(1) argument at the beginning of
2773 # install_prog (especially on Windows NT).
2774 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775 # Allow the use of GNU shtool's install command.
2776 case $nonopt in *shtool*) :;; *) false;; esac; then
2777 # Aesthetically quote it.
2778 func_quote_for_eval "$nonopt"
2779 install_prog="$func_quote_for_eval_result "
2780 arg=$1
2781 shift
2782 else
2783 install_prog=
2784 arg=$nonopt
2785 fi
2786
2787 # The real first argument should be the name of the installation program.
2788 # Aesthetically quote it.
2789 func_quote_for_eval "$arg"
2790 func_append install_prog "$func_quote_for_eval_result"
2791 install_shared_prog=$install_prog
2792 case " $install_prog " in
2793 *[\\\ /]cp\ *) install_cp=: ;;
2794 *) install_cp=false ;;
2795 esac
2796
2797 # We need to accept at least all the BSD install flags.
2798 dest=
2799 files=
2800 opts=
2801 prev=
2802 install_type=
2803 isdir=no
2804 stripme=
2805 no_mode=:
2806 for arg
2807 do
2808 arg2=
2809 if test -n "$dest"; then
2810 func_append files " $dest"
2811 dest=$arg
2812 continue
2813 fi
2814
2815 case $arg in
2816 -d) isdir=yes ;;
2817 -f)
2818 if $install_cp; then :; else
2819 prev=$arg
2820 fi
2821 ;;
2822 -g | -m | -o)
2823 prev=$arg
2824 ;;
2825 -s)
2826 stripme=" -s"
2827 continue
2828 ;;
2829 -*)
2830 ;;
2831 *)
2832 # If the previous option needed an argument, then skip it.
2833 if test -n "$prev"; then
2834 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835 arg2=$install_override_mode
2836 no_mode=false
2837 fi
2838 prev=
2839 else
2840 dest=$arg
2841 continue
2842 fi
2843 ;;
2844 esac
2845
2846 # Aesthetically quote the argument.
2847 func_quote_for_eval "$arg"
2848 func_append install_prog " $func_quote_for_eval_result"
2849 if test -n "$arg2"; then
2850 func_quote_for_eval "$arg2"
2851 fi
2852 func_append install_shared_prog " $func_quote_for_eval_result"
2853 done
2854
2855 test -z "$install_prog" && \
2856 func_fatal_help "you must specify an install program"
2857
2858 test -n "$prev" && \
2859 func_fatal_help "the \`$prev' option requires an argument"
2860
2861 if test -n "$install_override_mode" && $no_mode; then
2862 if $install_cp; then :; else
2863 func_quote_for_eval "$install_override_mode"
2864 func_append install_shared_prog " -m $func_quote_for_eval_result"
2865 fi
2866 fi
2867
2868 if test -z "$files"; then
2869 if test -z "$dest"; then
2870 func_fatal_help "no file or destination specified"
2871 else
2872 func_fatal_help "you must specify a destination"
2873 fi
2874 fi
2875
2876 # Strip any trailing slash from the destination.
2877 func_stripname '' '/' "$dest"
2878 dest=$func_stripname_result
2879
2880 # Check to see that the destination is a directory.
2881 test -d "$dest" && isdir=yes
2882 if test "$isdir" = yes; then
2883 destdir="$dest"
2884 destname=
2885 else
2886 func_dirname_and_basename "$dest" "" "."
2887 destdir="$func_dirname_result"
2888 destname="$func_basename_result"
2889
2890 # Not a directory, so check to see that there is only one file specified.
2891 set dummy $files; shift
2892 test "$#" -gt 1 && \
2893 func_fatal_help "\`$dest' is not a directory"
2894 fi
2895 case $destdir in
2896 [\\/]* | [A-Za-z]:[\\/]*) ;;
2897 *)
2898 for file in $files; do
2899 case $file in
2900 *.lo) ;;
2901 *)
2902 func_fatal_help "\`$destdir' must be an absolute directory name"
2903 ;;
2904 esac
2905 done
2906 ;;
2907 esac
2908
2909 # This variable tells wrapper scripts just to set variables rather
2910 # than running their programs.
2911 libtool_install_magic="$magic"
2912
2913 staticlibs=
2914 future_libdirs=
2915 current_libdirs=
2916 for file in $files; do
2917
2918 # Do each installation.
2919 case $file in
2920 *.$libext)
2921 # Do the static libraries later.
2922 func_append staticlibs " $file"
2923 ;;
2924
2925 *.la)
2926 func_resolve_sysroot "$file"
2927 file=$func_resolve_sysroot_result
2928
2929 # Check to see that this really is a libtool archive.
2930 func_lalib_unsafe_p "$file" \
2931 || func_fatal_help "\`$file' is not a valid libtool archive"
2932
2933 library_names=
2934 old_library=
2935 relink_command=
2936 func_source "$file"
2937
2938 # Add the libdir to current_libdirs if it is the destination.
2939 if test "X$destdir" = "X$libdir"; then
2940 case "$current_libdirs " in
2941 *" $libdir "*) ;;
2942 *) func_append current_libdirs " $libdir" ;;
2943 esac
2944 else
2945 # Note the libdir as a future libdir.
2946 case "$future_libdirs " in
2947 *" $libdir "*) ;;
2948 *) func_append future_libdirs " $libdir" ;;
2949 esac
2950 fi
2951
2952 func_dirname "$file" "/" ""
2953 dir="$func_dirname_result"
2954 func_append dir "$objdir"
2955
2956 if test -n "$relink_command"; then
2957 # Determine the prefix the user has applied to our future dir.
2958 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959
2960 # Don't allow the user to place us outside of our expected
2961 # location b/c this prevents finding dependent libraries that
2962 # are installed to the same prefix.
2963 # At present, this check doesn't affect windows .dll's that
2964 # are installed into $libdir/../bin (currently, that works fine)
2965 # but it's something to keep an eye on.
2966 test "$inst_prefix_dir" = "$destdir" && \
2967 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968
2969 if test -n "$inst_prefix_dir"; then
2970 # Stick the inst_prefix_dir data into the link command.
2971 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972 else
2973 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2974 fi
2975
2976 func_warning "relinking \`$file'"
2977 func_show_eval "$relink_command" \
2978 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2979 fi
2980
2981 # See the names of the shared library.
2982 set dummy $library_names; shift
2983 if test -n "$1"; then
2984 realname="$1"
2985 shift
2986
2987 srcname="$realname"
2988 test -n "$relink_command" && srcname="$realname"T
2989
2990 # Install the shared library and build the symlinks.
2991 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2992 'exit $?'
2993 tstripme="$stripme"
2994 case $host_os in
2995 cygwin* | mingw* | pw32* | cegcc*)
2996 case $realname in
2997 *.dll.a)
2998 tstripme=""
2999 ;;
3000 esac
3001 ;;
3002 esac
3003 if test -n "$tstripme" && test -n "$striplib"; then
3004 func_show_eval "$striplib $destdir/$realname" 'exit $?'
3005 fi
3006
3007 if test "$#" -gt 0; then
3008 # Delete the old symlinks, and create new ones.
3009 # Try `ln -sf' first, because the `ln' binary might depend on
3010 # the symlink we replace! Solaris /bin/ln does not understand -f,
3011 # so we also need to try rm && ln -s.
3012 for linkname
3013 do
3014 test "$linkname" != "$realname" \
3015 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3016 done
3017 fi
3018
3019 # Do each command in the postinstall commands.
3020 lib="$destdir/$realname"
3021 func_execute_cmds "$postinstall_cmds" 'exit $?'
3022 fi
3023
3024 # Install the pseudo-library for information purposes.
3025 func_basename "$file"
3026 name="$func_basename_result"
3027 instname="$dir/$name"i
3028 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029
3030 # Maybe install the static library, too.
3031 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3032 ;;
3033
3034 *.lo)
3035 # Install (i.e. copy) a libtool object.
3036
3037 # Figure out destination file name, if it wasn't already specified.
3038 if test -n "$destname"; then
3039 destfile="$destdir/$destname"
3040 else
3041 func_basename "$file"
3042 destfile="$func_basename_result"
3043 destfile="$destdir/$destfile"
3044 fi
3045
3046 # Deduce the name of the destination old-style object file.
3047 case $destfile in
3048 *.lo)
3049 func_lo2o "$destfile"
3050 staticdest=$func_lo2o_result
3051 ;;
3052 *.$objext)
3053 staticdest="$destfile"
3054 destfile=
3055 ;;
3056 *)
3057 func_fatal_help "cannot copy a libtool object to \`$destfile'"
3058 ;;
3059 esac
3060
3061 # Install the libtool object if requested.
3062 test -n "$destfile" && \
3063 func_show_eval "$install_prog $file $destfile" 'exit $?'
3064
3065 # Install the old object if enabled.
3066 if test "$build_old_libs" = yes; then
3067 # Deduce the name of the old-style object file.
3068 func_lo2o "$file"
3069 staticobj=$func_lo2o_result
3070 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3071 fi
3072 exit $EXIT_SUCCESS
3073 ;;
3074
3075 *)
3076 # Figure out destination file name, if it wasn't already specified.
3077 if test -n "$destname"; then
3078 destfile="$destdir/$destname"
3079 else
3080 func_basename "$file"
3081 destfile="$func_basename_result"
3082 destfile="$destdir/$destfile"
3083 fi
3084
3085 # If the file is missing, and there is a .exe on the end, strip it
3086 # because it is most likely a libtool script we actually want to
3087 # install
3088 stripped_ext=""
3089 case $file in
3090 *.exe)
3091 if test ! -f "$file"; then
3092 func_stripname '' '.exe' "$file"
3093 file=$func_stripname_result
3094 stripped_ext=".exe"
3095 fi
3096 ;;
3097 esac
3098
3099 # Do a test to see if this is really a libtool program.
3100 case $host in
3101 *cygwin* | *mingw*)
3102 if func_ltwrapper_executable_p "$file"; then
3103 func_ltwrapper_scriptname "$file"
3104 wrapper=$func_ltwrapper_scriptname_result
3105 else
3106 func_stripname '' '.exe' "$file"
3107 wrapper=$func_stripname_result
3108 fi
3109 ;;
3110 *)
3111 wrapper=$file
3112 ;;
3113 esac
3114 if func_ltwrapper_script_p "$wrapper"; then
3115 notinst_deplibs=
3116 relink_command=
3117
3118 func_source "$wrapper"
3119
3120 # Check the variables that should have been set.
3121 test -z "$generated_by_libtool_version" && \
3122 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3123
3124 finalize=yes
3125 for lib in $notinst_deplibs; do
3126 # Check to see that each library is installed.
3127 libdir=
3128 if test -f "$lib"; then
3129 func_source "$lib"
3130 fi
3131 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132 if test -n "$libdir" && test ! -f "$libfile"; then
3133 func_warning "\`$lib' has not been installed in \`$libdir'"
3134 finalize=no
3135 fi
3136 done
3137
3138 relink_command=
3139 func_source "$wrapper"
3140
3141 outputname=
3142 if test "$fast_install" = no && test -n "$relink_command"; then
3143 $opt_dry_run || {
3144 if test "$finalize" = yes; then
3145 tmpdir=`func_mktempdir`
3146 func_basename "$file$stripped_ext"
3147 file="$func_basename_result"
3148 outputname="$tmpdir/$file"
3149 # Replace the output file specification.
3150 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3151
3152 $opt_silent || {
3153 func_quote_for_expand "$relink_command"
3154 eval "func_echo $func_quote_for_expand_result"
3155 }
3156 if eval "$relink_command"; then :
3157 else
3158 func_error "error: relink \`$file' with the above command before installing it"
3159 $opt_dry_run || ${RM}r "$tmpdir"
3160 continue
3161 fi
3162 file="$outputname"
3163 else
3164 func_warning "cannot relink \`$file'"
3165 fi
3166 }
3167 else
3168 # Install the binary that we compiled earlier.
3169 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3170 fi
3171 fi
3172
3173 # remove .exe since cygwin /usr/bin/install will append another
3174 # one anyway
3175 case $install_prog,$host in
3176 */usr/bin/install*,*cygwin*)
3177 case $file:$destfile in
3178 *.exe:*.exe)
3179 # this is ok
3180 ;;
3181 *.exe:*)
3182 destfile=$destfile.exe
3183 ;;
3184 *:*.exe)
3185 func_stripname '' '.exe' "$destfile"
3186 destfile=$func_stripname_result
3187 ;;
3188 esac
3189 ;;
3190 esac
3191 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192 $opt_dry_run || if test -n "$outputname"; then
3193 ${RM}r "$tmpdir"
3194 fi
3195 ;;
3196 esac
3197 done
3198
3199 for file in $staticlibs; do
3200 func_basename "$file"
3201 name="$func_basename_result"
3202
3203 # Set up the ranlib parameters.
3204 oldlib="$destdir/$name"
3205 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206 tool_oldlib=$func_to_tool_file_result
3207
3208 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3209
3210 if test -n "$stripme" && test -n "$old_striplib"; then
3211 func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3212 fi
3213
3214 # Do each command in the postinstall commands.
3215 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3216 done
3217
3218 test -n "$future_libdirs" && \
3219 func_warning "remember to run \`$progname --finish$future_libdirs'"
3220
3221 if test -n "$current_libdirs"; then
3222 # Maybe just do a dry run.
3223 $opt_dry_run && current_libdirs=" -n$current_libdirs"
3224 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3225 else
3226 exit $EXIT_SUCCESS
3227 fi
3228 }
3229
3230 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3231
3232
3233 # func_generate_dlsyms outputname originator pic_p
3234 # Extract symbols from dlprefiles and create ${outputname}S.o with
3235 # a dlpreopen symbol table.
3236 func_generate_dlsyms ()
3237 {
3238 $opt_debug
3239 my_outputname="$1"
3240 my_originator="$2"
3241 my_pic_p="${3-no}"
3242 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3243 my_dlsyms=
3244
3245 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3246 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247 my_dlsyms="${my_outputname}S.c"
3248 else
3249 func_error "not configured to extract global symbols from dlpreopened files"
3250 fi
3251 fi
3252
3253 if test -n "$my_dlsyms"; then
3254 case $my_dlsyms in
3255 "") ;;
3256 *.c)
3257 # Discover the nlist of each of the dlfiles.
3258 nlist="$output_objdir/${my_outputname}.nm"
3259
3260 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3261
3262 # Parse the name list into a source file.
3263 func_verbose "creating $output_objdir/$my_dlsyms"
3264
3265 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3266 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3268
3269 #ifdef __cplusplus
3270 extern \"C\" {
3271 #endif
3272
3273 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3275 #endif
3276
3277 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3278 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3280 relocations are performed -- see ld's documentation on pseudo-relocs. */
3281 # define LT_DLSYM_CONST
3282 #elif defined(__osf__)
3283 /* This system does not cope well with relocations in const data. */
3284 # define LT_DLSYM_CONST
3285 #else
3286 # define LT_DLSYM_CONST const
3287 #endif
3288
3289 /* External symbol declarations for the compiler. */\
3290 "
3291
3292 if test "$dlself" = yes; then
3293 func_verbose "generating symbol list for \`$output'"
3294
3295 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3296
3297 # Add our own program objects to the symbol list.
3298 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299 for progfile in $progfiles; do
3300 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3301 func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3302 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3303 done
3304
3305 if test -n "$exclude_expsyms"; then
3306 $opt_dry_run || {
3307 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308 eval '$MV "$nlist"T "$nlist"'
3309 }
3310 fi
3311
3312 if test -n "$export_symbols_regex"; then
3313 $opt_dry_run || {
3314 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315 eval '$MV "$nlist"T "$nlist"'
3316 }
3317 fi
3318
3319 # Prepare the list of exported symbols
3320 if test -z "$export_symbols"; then
3321 export_symbols="$output_objdir/$outputname.exp"
3322 $opt_dry_run || {
3323 $RM $export_symbols
3324 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3325 case $host in
3326 *cygwin* | *mingw* | *cegcc* )
3327 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3329 ;;
3330 esac
3331 }
3332 else
3333 $opt_dry_run || {
3334 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336 eval '$MV "$nlist"T "$nlist"'
3337 case $host in
3338 *cygwin* | *mingw* | *cegcc* )
3339 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3341 ;;
3342 esac
3343 }
3344 fi
3345 fi
3346
3347 for dlprefile in $dlprefiles; do
3348 func_verbose "extracting global C symbols from \`$dlprefile'"
3349 func_basename "$dlprefile"
3350 name="$func_basename_result"
3351 case $host in
3352 *cygwin* | *mingw* | *cegcc* )
3353 # if an import library, we need to obtain dlname
3354 if func_win32_import_lib_p "$dlprefile"; then
3355 func_tr_sh "$dlprefile"
3356 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357 dlprefile_dlbasename=""
3358 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3359 # Use subshell, to avoid clobbering current variable values
3360 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3361 if test -n "$dlprefile_dlname" ; then
3362 func_basename "$dlprefile_dlname"
3363 dlprefile_dlbasename="$func_basename_result"
3364 else
3365 # no lafile. user explicitly requested -dlpreopen <import library>.
3366 $sharedlib_from_linklib_cmd "$dlprefile"
3367 dlprefile_dlbasename=$sharedlib_from_linklib_result
3368 fi
3369 fi
3370 $opt_dry_run || {
3371 if test -n "$dlprefile_dlbasename" ; then
3372 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3373 else
3374 func_warning "Could not compute DLL name from $name"
3375 eval '$ECHO ": $name " >> "$nlist"'
3376 fi
3377 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3378 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3380 }
3381 else # not an import lib
3382 $opt_dry_run || {
3383 eval '$ECHO ": $name " >> "$nlist"'
3384 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3386 }
3387 fi
3388 ;;
3389 *)
3390 $opt_dry_run || {
3391 eval '$ECHO ": $name " >> "$nlist"'
3392 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3393 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3394 }
3395 ;;
3396 esac
3397 done
3398
3399 $opt_dry_run || {
3400 # Make sure we have at least an empty file.
3401 test -f "$nlist" || : > "$nlist"
3402
3403 if test -n "$exclude_expsyms"; then
3404 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405 $MV "$nlist"T "$nlist"
3406 fi
3407
3408 # Try sorting and uniquifying the output.
3409 if $GREP -v "^: " < "$nlist" |
3410 if sort -k 3 </dev/null >/dev/null 2>&1; then
3411 sort -k 3
3412 else
3413 sort +2
3414 fi |
3415 uniq > "$nlist"S; then
3416 :
3417 else
3418 $GREP -v "^: " < "$nlist" > "$nlist"S
3419 fi
3420
3421 if test -f "$nlist"S; then
3422 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3423 else
3424 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3425 fi
3426
3427 echo >> "$output_objdir/$my_dlsyms" "\
3428
3429 /* The mapping between symbol names and symbols. */
3430 typedef struct {
3431 const char *name;
3432 void *address;
3433 } lt_dlsymlist;
3434 extern LT_DLSYM_CONST lt_dlsymlist
3435 lt_${my_prefix}_LTX_preloaded_symbols[];
3436 LT_DLSYM_CONST lt_dlsymlist
3437 lt_${my_prefix}_LTX_preloaded_symbols[] =
3438 {\
3439 { \"$my_originator\", (void *) 0 },"
3440
3441 case $need_lib_prefix in
3442 no)
3443 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444 ;;
3445 *)
3446 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3447 ;;
3448 esac
3449 echo >> "$output_objdir/$my_dlsyms" "\
3450 {0, (void *) 0}
3451 };
3452
3453 /* This works around a problem in FreeBSD linker */
3454 #ifdef FREEBSD_WORKAROUND
3455 static const void *lt_preloaded_setup() {
3456 return lt_${my_prefix}_LTX_preloaded_symbols;
3457 }
3458 #endif
3459
3460 #ifdef __cplusplus
3461 }
3462 #endif\
3463 "
3464 } # !$opt_dry_run
3465
3466 pic_flag_for_symtable=
3467 case "$compile_command " in
3468 *" -static "*) ;;
3469 *)
3470 case $host in
3471 # compiling the symbol table file with pic_flag works around
3472 # a FreeBSD bug that causes programs to crash when -lm is
3473 # linked before any other PIC object. But we must not use
3474 # pic_flag when linking with -static. The problem exists in
3475 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476 *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3477 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3478 *-*-hpux*)
3479 pic_flag_for_symtable=" $pic_flag" ;;
3480 *)
3481 if test "X$my_pic_p" != Xno; then
3482 pic_flag_for_symtable=" $pic_flag"
3483 fi
3484 ;;
3485 esac
3486 ;;
3487 esac
3488 symtab_cflags=
3489 for arg in $LTCFLAGS; do
3490 case $arg in
3491 -pie | -fpie | -fPIE) ;;
3492 *) func_append symtab_cflags " $arg" ;;
3493 esac
3494 done
3495
3496 # Now compile the dynamic symbol file.
3497 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3498
3499 # Clean up the generated files.
3500 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3501
3502 # Transform the symbol file into the correct name.
3503 symfileobj="$output_objdir/${my_outputname}S.$objext"
3504 case $host in
3505 *cygwin* | *mingw* | *cegcc* )
3506 if test -f "$output_objdir/$my_outputname.def"; then
3507 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3509 else
3510 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512 fi
3513 ;;
3514 *)
3515 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3517 ;;
3518 esac
3519 ;;
3520 *)
3521 func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522 ;;
3523 esac
3524 else
3525 # We keep going just in case the user didn't refer to
3526 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3527 # really was required.
3528
3529 # Nullify the symbol file.
3530 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532 fi
3533 }
3534
3535 # func_win32_libid arg
3536 # return the library type of file 'arg'
3537 #
3538 # Need a lot of goo to handle *both* DLLs and import libs
3539 # Has to be a shell function in order to 'eat' the argument
3540 # that is supplied when $file_magic_command is called.
3541 # Despite the name, also deal with 64 bit binaries.
3542 func_win32_libid ()
3543 {
3544 $opt_debug
3545 win32_libid_type="unknown"
3546 win32_fileres=`file -L $1 2>/dev/null`
3547 case $win32_fileres in
3548 *ar\ archive\ import\ library*) # definitely import
3549 win32_libid_type="x86 archive import"
3550 ;;
3551 *ar\ archive*) # could be an import, or static
3552 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3554 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3555 func_to_tool_file "$1" func_convert_file_msys_to_w32
3556 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3557 $SED -n -e '
3558 1,100{
3559 / I /{
3560 s,.*,import,
3561 p
3562 q
3563 }
3564 }'`
3565 case $win32_nmres in
3566 import*) win32_libid_type="x86 archive import";;
3567 *) win32_libid_type="x86 archive static";;
3568 esac
3569 fi
3570 ;;
3571 *DLL*)
3572 win32_libid_type="x86 DLL"
3573 ;;
3574 *executable*) # but shell scripts are "executable" too...
3575 case $win32_fileres in
3576 *MS\ Windows\ PE\ Intel*)
3577 win32_libid_type="x86 DLL"
3578 ;;
3579 esac
3580 ;;
3581 esac
3582 $ECHO "$win32_libid_type"
3583 }
3584
3585 # func_cygming_dll_for_implib ARG
3586 #
3587 # Platform-specific function to extract the
3588 # name of the DLL associated with the specified
3589 # import library ARG.
3590 # Invoked by eval'ing the libtool variable
3591 # $sharedlib_from_linklib_cmd
3592 # Result is available in the variable
3593 # $sharedlib_from_linklib_result
3594 func_cygming_dll_for_implib ()
3595 {
3596 $opt_debug
3597 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3598 }
3599
3600 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3601 #
3602 # The is the core of a fallback implementation of a
3603 # platform-specific function to extract the name of the
3604 # DLL associated with the specified import library LIBNAME.
3605 #
3606 # SECTION_NAME is either .idata$6 or .idata$7, depending
3607 # on the platform and compiler that created the implib.
3608 #
3609 # Echos the name of the DLL associated with the
3610 # specified import library.
3611 func_cygming_dll_for_implib_fallback_core ()
3612 {
3613 $opt_debug
3614 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3616 $SED '/^Contents of section '"$match_literal"':/{
3617 # Place marker at beginning of archive member dllname section
3618 s/.*/====MARK====/
3619 p
3620 d
3621 }
3622 # These lines can sometimes be longer than 43 characters, but
3623 # are always uninteresting
3624 /:[ ]*file format pe[i]\{,1\}-/d
3625 /^In archive [^:]*:/d
3626 # Ensure marker is printed
3627 /^====MARK====/p
3628 # Remove all lines with less than 43 characters
3629 /^.\{43\}/!d
3630 # From remaining lines, remove first 43 characters
3631 s/^.\{43\}//' |
3632 $SED -n '
3633 # Join marker and all lines until next marker into a single line
3634 /^====MARK====/ b para
3635 H
3636 $ b para
3637 b
3638 :para
3639 x
3640 s/\n//g
3641 # Remove the marker
3642 s/^====MARK====//
3643 # Remove trailing dots and whitespace
3644 s/[\. \t]*$//
3645 # Print
3646 /./p' |
3647 # we now have a list, one entry per line, of the stringified
3648 # contents of the appropriate section of all members of the
3649 # archive which possess that section. Heuristic: eliminate
3650 # all those which have a first or second character that is
3651 # a '.' (that is, objdump's representation of an unprintable
3652 # character.) This should work for all archives with less than
3653 # 0x302f exports -- but will fail for DLLs whose name actually
3654 # begins with a literal '.' or a single character followed by
3655 # a '.'.
3656 #
3657 # Of those that remain, print the first one.
3658 $SED -e '/^\./d;/^.\./d;q'
3659 }
3660
3661 # func_cygming_gnu_implib_p ARG
3662 # This predicate returns with zero status (TRUE) if
3663 # ARG is a GNU/binutils-style import library. Returns
3664 # with nonzero status (FALSE) otherwise.
3665 func_cygming_gnu_implib_p ()
3666 {
3667 $opt_debug
3668 func_to_tool_file "$1" func_convert_file_msys_to_w32
3669 func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3670 test -n "$func_cygming_gnu_implib_tmp"
3671 }
3672
3673 # func_cygming_ms_implib_p ARG
3674 # This predicate returns with zero status (TRUE) if
3675 # ARG is an MS-style import library. Returns
3676 # with nonzero status (FALSE) otherwise.
3677 func_cygming_ms_implib_p ()
3678 {
3679 $opt_debug
3680 func_to_tool_file "$1" func_convert_file_msys_to_w32
3681 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682 test -n "$func_cygming_ms_implib_tmp"
3683 }
3684
3685 # func_cygming_dll_for_implib_fallback ARG
3686 # Platform-specific function to extract the
3687 # name of the DLL associated with the specified
3688 # import library ARG.
3689 #
3690 # This fallback implementation is for use when $DLLTOOL
3691 # does not support the --identify-strict option.
3692 # Invoked by eval'ing the libtool variable
3693 # $sharedlib_from_linklib_cmd
3694 # Result is available in the variable
3695 # $sharedlib_from_linklib_result
3696 func_cygming_dll_for_implib_fallback ()
3697 {
3698 $opt_debug
3699 if func_cygming_gnu_implib_p "$1" ; then
3700 # binutils import library
3701 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702 elif func_cygming_ms_implib_p "$1" ; then
3703 # ms-generated import library
3704 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3705 else
3706 # unknown
3707 sharedlib_from_linklib_result=""
3708 fi
3709 }
3710
3711
3712 # func_extract_an_archive dir oldlib
3713 func_extract_an_archive ()
3714 {
3715 $opt_debug
3716 f_ex_an_ar_dir="$1"; shift
3717 f_ex_an_ar_oldlib="$1"
3718 if test "$lock_old_archive_extraction" = yes; then
3719 lockfile=$f_ex_an_ar_oldlib.lock
3720 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3721 func_echo "Waiting for $lockfile to be removed"
3722 sleep 2
3723 done
3724 fi
3725 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726 'stat=$?; rm -f "$lockfile"; exit $stat'
3727 if test "$lock_old_archive_extraction" = yes; then
3728 $opt_dry_run || rm -f "$lockfile"
3729 fi
3730 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3731 :
3732 else
3733 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3734 fi
3735 }
3736
3737
3738 # func_extract_archives gentop oldlib ...
3739 func_extract_archives ()
3740 {
3741 $opt_debug
3742 my_gentop="$1"; shift
3743 my_oldlibs=${1+"$@"}
3744 my_oldobjs=""
3745 my_xlib=""
3746 my_xabs=""
3747 my_xdir=""
3748
3749 for my_xlib in $my_oldlibs; do
3750 # Extract the objects.
3751 case $my_xlib in
3752 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3753 *) my_xabs=`pwd`"/$my_xlib" ;;
3754 esac
3755 func_basename "$my_xlib"
3756 my_xlib="$func_basename_result"
3757 my_xlib_u=$my_xlib
3758 while :; do
3759 case " $extracted_archives " in
3760 *" $my_xlib_u "*)
3761 func_arith $extracted_serial + 1
3762 extracted_serial=$func_arith_result
3763 my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764 *) break ;;
3765 esac
3766 done
3767 extracted_archives="$extracted_archives $my_xlib_u"
3768 my_xdir="$my_gentop/$my_xlib_u"
3769
3770 func_mkdir_p "$my_xdir"
3771
3772 case $host in
3773 *-darwin*)
3774 func_verbose "Extracting $my_xabs"
3775 # Do not bother doing anything if just a dry run
3776 $opt_dry_run || {
3777 darwin_orig_dir=`pwd`
3778 cd $my_xdir || exit $?
3779 darwin_archive=$my_xabs
3780 darwin_curdir=`pwd`
3781 darwin_base_archive=`basename "$darwin_archive"`
3782 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783 if test -n "$darwin_arches"; then
3784 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3785 darwin_arch=
3786 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3787 for darwin_arch in $darwin_arches ; do
3788 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3792 cd "$darwin_curdir"
3793 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794 done # $darwin_arches
3795 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3797 darwin_file=
3798 darwin_files=
3799 for darwin_file in $darwin_filelist; do
3800 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801 $LIPO -create -output "$darwin_file" $darwin_files
3802 done # $darwin_filelist
3803 $RM -rf unfat-$$
3804 cd "$darwin_orig_dir"
3805 else
3806 cd $darwin_orig_dir
3807 func_extract_an_archive "$my_xdir" "$my_xabs"
3808 fi # $darwin_arches
3809 } # !$opt_dry_run
3810 ;;
3811 *)
3812 func_extract_an_archive "$my_xdir" "$my_xabs"
3813 ;;
3814 esac
3815 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3816 done
3817
3818 func_extract_archives_result="$my_oldobjs"
3819 }
3820
3821
3822 # func_emit_wrapper [arg=no]
3823 #
3824 # Emit a libtool wrapper script on stdout.
3825 # Don't directly open a file because we may want to
3826 # incorporate the script contents within a cygwin/mingw
3827 # wrapper executable. Must ONLY be called from within
3828 # func_mode_link because it depends on a number of variables
3829 # set therein.
3830 #
3831 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832 # variable will take. If 'yes', then the emitted script
3833 # will assume that the directory in which it is stored is
3834 # the $objdir directory. This is a cygwin/mingw-specific
3835 # behavior.
3836 func_emit_wrapper ()
3837 {
3838 func_emit_wrapper_arg1=${1-no}
3839
3840 $ECHO "\
3841 #! $SHELL
3842
3843 # $output - temporary wrapper script for $objdir/$outputname
3844 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3845 #
3846 # The $output program cannot be directly executed until all the libtool
3847 # libraries that it depends on are installed.
3848 #
3849 # This wrapper script should never be moved out of the build directory.
3850 # If it is, it will not operate correctly.
3851
3852 # Sed substitution that helps us do robust quoting. It backslashifies
3853 # metacharacters that are still active within double-quoted strings.
3854 sed_quote_subst='$sed_quote_subst'
3855
3856 # Be Bourne compatible
3857 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3858 emulate sh
3859 NULLCMD=:
3860 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861 # is contrary to our usage. Disable this feature.
3862 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863 setopt NO_GLOB_SUBST
3864 else
3865 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3866 fi
3867 BIN_SH=xpg4; export BIN_SH # for Tru64
3868 DUALCASE=1; export DUALCASE # for MKS sh
3869
3870 # The HP-UX ksh and POSIX shell print the target directory to stdout
3871 # if CDPATH is set.
3872 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3873
3874 relink_command=\"$relink_command\"
3875
3876 # This environment variable determines our operation mode.
3877 if test \"\$libtool_install_magic\" = \"$magic\"; then
3878 # install mode needs the following variables:
3879 generated_by_libtool_version='$macro_version'
3880 notinst_deplibs='$notinst_deplibs'
3881 else
3882 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3883 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3884 file=\"\$0\""
3885
3886 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3887 $ECHO "\
3888
3889 # A function that is used when there is no print builtin or printf.
3890 func_fallback_echo ()
3891 {
3892 eval 'cat <<_LTECHO_EOF
3893 \$1
3894 _LTECHO_EOF'
3895 }
3896 ECHO=\"$qECHO\"
3897 fi
3898
3899 # Very basic option parsing. These options are (a) specific to
3900 # the libtool wrapper, (b) are identical between the wrapper
3901 # /script/ and the wrapper /executable/ which is used only on
3902 # windows platforms, and (c) all begin with the string "--lt-"
3903 # (application programs are unlikely to have options which match
3904 # this pattern).
3905 #
3906 # There are only two supported options: --lt-debug and
3907 # --lt-dump-script. There is, deliberately, no --lt-help.
3908 #
3909 # The first argument to this parsing function should be the
3910 # script's $0 value, followed by "$@".
3911 lt_option_debug=
3912 func_parse_lt_options ()
3913 {
3914 lt_script_arg0=\$0
3915 shift
3916 for lt_opt
3917 do
3918 case \"\$lt_opt\" in
3919 --lt-debug) lt_option_debug=1 ;;
3920 --lt-dump-script)
3921 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924 cat \"\$lt_dump_D/\$lt_dump_F\"
3925 exit 0
3926 ;;
3927 --lt-*)
3928 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3929 exit 1
3930 ;;
3931 esac
3932 done
3933
3934 # Print the debug banner immediately:
3935 if test -n \"\$lt_option_debug\"; then
3936 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937 fi
3938 }
3939
3940 # Used when --lt-debug. Prints its arguments to stdout
3941 # (redirection is the responsibility of the caller)
3942 func_lt_dump_args ()
3943 {
3944 lt_dump_args_N=1;
3945 for lt_arg
3946 do
3947 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949 done
3950 }
3951
3952 # Core function for launching the target application
3953 func_exec_program_core ()
3954 {
3955 "
3956 case $host in
3957 # Backslashes separate directories on plain windows
3958 *-*-mingw | *-*-os2* | *-cegcc*)
3959 $ECHO "\
3960 if test -n \"\$lt_option_debug\"; then
3961 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962 func_lt_dump_args \${1+\"\$@\"} 1>&2
3963 fi
3964 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3965 "