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