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