2010-10-08 Thomas Quinot <quinot@adacore.com>
[gcc/gcc.git] / ltmain.sh
1 # Generated from ltmain.m4sh.
2
3 # libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
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 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 #       --no-finish          let install mode avoid finish commands
42 #       --preserve-dup-deps  don't remove duplicate dependency libraries
43 #       --quiet, --silent    don't print informational messages
44 #       --no-quiet, --no-silent
45 #                            print informational messages (default)
46 #       --tag=TAG            use configuration variables from tag TAG
47 #   -v, --verbose            print more informational messages than default
48 #       --no-verbose         don't print the extra informational messages
49 #       --version            print version information
50 #   -h, --help, --help-all   print short, long, or detailed help message
51 #
52 # MODE must be one of the following:
53 #
54 #         clean              remove files from the build directory
55 #         compile            compile a source file into a libtool object
56 #         execute            automatically set library path, then run a program
57 #         finish             complete the installation of libtool libraries
58 #         install            install libraries or executables
59 #         link               create a library or an executable
60 #         uninstall          remove libraries from an installed directory
61 #
62 # MODE-ARGS vary depending on the MODE.  When passed as first option,
63 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
64 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
65 #
66 # When reporting a bug, please describe a test case to reproduce it and
67 # include the following information:
68 #
69 #         host-triplet: $host
70 #         shell:                $SHELL
71 #         compiler:             $LTCC
72 #         compiler flags:               $LTCFLAGS
73 #         linker:               $LD (gnu? $with_gnu_ld)
74 #         $progname:    (GNU libtool 1.3134 2009-11-29) 2.2.7a
75 #         automake:     $automake_version
76 #         autoconf:     $autoconf_version
77 #
78 # Report bugs to <bug-libtool@gnu.org>.
79
80 PROGRAM=libtool
81 PACKAGE=libtool
82 VERSION=2.2.7a
83 TIMESTAMP=" 1.3134 2009-11-29"
84 package_revision=1.3134
85
86 # Be Bourne compatible
87 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
88   emulate sh
89   NULLCMD=:
90   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91   # is contrary to our usage.  Disable this feature.
92   alias -g '${1+"$@"}'='"$@"'
93   setopt NO_GLOB_SUBST
94 else
95   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
96 fi
97 BIN_SH=xpg4; export BIN_SH # for Tru64
98 DUALCASE=1; export DUALCASE # for MKS sh
99
100 # A function that is used when there is no print builtin or printf.
101 func_fallback_echo ()
102 {
103   eval 'cat <<_LTECHO_EOF
104 $1
105 _LTECHO_EOF'
106 }
107
108 # NLS nuisances: We save the old values to restore during execute mode.
109 # Only set LANG and LC_ALL to C if already set.
110 # These must not be set unconditionally because not all systems understand
111 # e.g. LANG=C (notably SCO).
112 lt_user_locale=
113 lt_safe_locale=
114 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
115 do
116   eval "if test \"\${$lt_var+set}\" = set; then
117           save_$lt_var=\$$lt_var
118           $lt_var=C
119           export $lt_var
120           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
121           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
122         fi"
123 done
124
125 $lt_unset CDPATH
126
127
128
129
130
131
132
133 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
134 # is ksh but when the shell is invoked as "sh" and the current value of
135 # the _XPG environment variable is not equal to 1 (one), the special
136 # positional parameter $0, within a function call, is the name of the
137 # function.
138 progpath="$0"
139
140
141
142 : ${CP="cp -f"}
143 : ${ECHO=$as_echo}
144 : ${EGREP="/bin/grep -E"}
145 : ${FGREP="/bin/grep -F"}
146 : ${GREP="/bin/grep"}
147 : ${LN_S="ln -s"}
148 : ${MAKE="make"}
149 : ${MKDIR="mkdir"}
150 : ${MV="mv -f"}
151 : ${RM="rm -f"}
152 : ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"}
153 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
154 : ${Xsed="$SED -e 1s/^X//"}
155
156 # Global variables:
157 EXIT_SUCCESS=0
158 EXIT_FAILURE=1
159 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
160 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
161
162 exit_status=$EXIT_SUCCESS
163
164 # Make sure IFS has a sensible default
165 lt_nl='
166 '
167 IFS="   $lt_nl"
168
169 dirname="s,/[^/]*$,,"
170 basename="s,^.*/,,"
171
172 # func_dirname_and_basename file append nondir_replacement
173 # perform func_basename and func_dirname in a single function
174 # call:
175 #   dirname:  Compute the dirname of FILE.  If nonempty,
176 #             add APPEND to the result, otherwise set result
177 #             to NONDIR_REPLACEMENT.
178 #             value returned in "$func_dirname_result"
179 #   basename: Compute filename of FILE.
180 #             value retuned in "$func_basename_result"
181 # Implementation must be kept synchronized with func_dirname
182 # and func_basename. For efficiency, we do not delegate to
183 # those functions but instead duplicate the functionality here.
184 func_dirname_and_basename ()
185 {
186   # Extract subdirectory from the argument.
187   func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
188   if test "X$func_dirname_result" = "X${1}"; then
189     func_dirname_result="${3}"
190   else
191     func_dirname_result="$func_dirname_result${2}"
192   fi
193   func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
194 }
195
196 # Generated shell functions inserted here.
197
198 # These SED scripts presuppose an absolute path with a trailing slash.
199 pathcar='s,^/\([^/]*\).*$,\1,'
200 pathcdr='s,^/[^/]*,,'
201 removedotparts=':dotsl
202                 s@/\./@/@g
203                 t dotsl
204                 s,/\.$,/,'
205 collapseslashes='s@/\{1,\}@/@g'
206 finalslash='s,/*$,/,'
207
208 # func_normal_abspath PATH
209 # Remove doubled-up and trailing slashes, "." path components,
210 # and cancel out any ".." path components in PATH after making
211 # it an absolute path.
212 #             value returned in "$func_normal_abspath_result"
213 func_normal_abspath ()
214 {
215   # Start from root dir and reassemble the path.
216   func_normal_abspath_result=
217   func_normal_abspath_tpath=$1
218   func_normal_abspath_altnamespace=
219   case $func_normal_abspath_tpath in
220     "")
221       # Empty path, that just means $cwd.
222       func_stripname '' '/' "`pwd`"
223       func_normal_abspath_result=$func_stripname_result
224       return
225     ;;
226     # The next three entries are used to spot a run of precisely
227     # two leading slashes without using negated character classes;
228     # we take advantage of case's first-match behaviour.
229     ///*)
230       # Unusual form of absolute path, do nothing.
231     ;;
232     //*)
233       # Not necessarily an ordinary path; POSIX reserves leading '//'
234       # and for example Cygwin uses it to access remote file shares
235       # over CIFS/SMB, so we conserve a leading double slash if found.
236       func_normal_abspath_altnamespace=/
237     ;;
238     /*)
239       # Absolute path, do nothing.
240     ;;
241     *)
242       # Relative path, prepend $cwd.
243       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
244     ;;
245   esac
246   # Cancel out all the simple stuff to save iterations.  We also want
247   # the path to end with a slash for ease of parsing, so make sure
248   # there is one (and only one) here.
249   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
250         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
251   while :; do
252     # Processed it all yet?
253     if test "$func_normal_abspath_tpath" = / ; then
254       # If we ascended to the root using ".." the result may be empty now.
255       if test -z "$func_normal_abspath_result" ; then
256         func_normal_abspath_result=/
257       fi
258       break
259     fi
260     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
261         -e "$pathcar"`
262     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
263         -e "$pathcdr"`
264     # Figure out what to do with it
265     case $func_normal_abspath_tcomponent in
266       "")
267         # Trailing empty path component, ignore it.
268       ;;
269       ..)
270         # Parent dir; strip last assembled component from result.
271         func_dirname "$func_normal_abspath_result"
272         func_normal_abspath_result=$func_dirname_result
273       ;;
274       *)
275         # Actual path component, append it.
276         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
277       ;;
278     esac
279   done
280   # Restore leading double-slash if one was found on entry.
281   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
282 }
283
284 # func_relative_path SRCDIR DSTDIR
285 # generates a relative path from SRCDIR to DSTDIR, with a trailing
286 # slash if non-empty, suitable for immediately appending a filename
287 # without needing to append a separator.
288 #             value returned in "$func_relative_path_result"
289 func_relative_path ()
290 {
291   func_relative_path_result=
292   func_normal_abspath "$1"
293   func_relative_path_tlibdir=$func_normal_abspath_result
294   func_normal_abspath "$2"
295   func_relative_path_tbindir=$func_normal_abspath_result
296
297   # Ascend the tree starting from libdir
298   while :; do
299     # check if we have found a prefix of bindir
300     case $func_relative_path_tbindir in
301       $func_relative_path_tlibdir)
302         # found an exact match
303         func_relative_path_tcancelled=
304         break
305         ;;
306       $func_relative_path_tlibdir*)
307         # found a matching prefix
308         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
309         func_relative_path_tcancelled=$func_stripname_result
310         if test -z "$func_relative_path_result"; then
311           func_relative_path_result=.
312         fi
313         break
314         ;;
315       *)
316         func_dirname $func_relative_path_tlibdir
317         func_relative_path_tlibdir=${func_dirname_result}
318         if test "x$func_relative_path_tlibdir" = x ; then
319           # Have to descend all the way to the root!
320           func_relative_path_result=../$func_relative_path_result
321           func_relative_path_tcancelled=$func_relative_path_tbindir
322           break
323         fi
324         func_relative_path_result=../$func_relative_path_result
325         ;;
326     esac
327   done
328
329   # Now calculate path; take care to avoid doubling-up slashes.
330   func_stripname '' '/' "$func_relative_path_result"
331   func_relative_path_result=$func_stripname_result
332   func_stripname '/' '/' "$func_relative_path_tcancelled"
333   if test "x$func_stripname_result" != x ; then
334     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
335   fi
336
337   # Normalisation. If bindir is libdir, return empty string,
338   # else relative path ending with a slash; either way, target
339   # file name can be directly appended.
340   if test ! -z "$func_relative_path_result"; then
341     func_stripname './' '' "$func_relative_path_result/"
342     func_relative_path_result=$func_stripname_result
343   fi
344 }
345
346 # The name of this program:
347 func_dirname_and_basename "$progpath"
348 progname=$func_basename_result
349
350 # Make sure we have an absolute path for reexecution:
351 case $progpath in
352   [\\/]*|[A-Za-z]:\\*) ;;
353   *[\\/]*)
354      progdir=$func_dirname_result
355      progdir=`cd "$progdir" && pwd`
356      progpath="$progdir/$progname"
357      ;;
358   *)
359      save_IFS="$IFS"
360      IFS=:
361      for progdir in $PATH; do
362        IFS="$save_IFS"
363        test -x "$progdir/$progname" && break
364      done
365      IFS="$save_IFS"
366      test -n "$progdir" || progdir=`pwd`
367      progpath="$progdir/$progname"
368      ;;
369 esac
370
371 # Sed substitution that helps us do robust quoting.  It backslashifies
372 # metacharacters that are still active within double-quoted strings.
373 Xsed="${SED}"' -e 1s/^X//'
374 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
375
376 # Same as above, but do not quote variable references.
377 double_quote_subst='s/\(["`\\]\)/\\\1/g'
378
379 # Re-`\' parameter expansions in output of double_quote_subst that were
380 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
381 # in input to double_quote_subst, that '$' was protected from expansion.
382 # Since each input `\' is now two `\'s, look for any number of runs of
383 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
384 bs='\\'
385 bs2='\\\\'
386 bs4='\\\\\\\\'
387 dollar='\$'
388 sed_double_backslash="\
389   s/$bs4/&\\
390 /g
391   s/^$bs2$dollar/$bs&/
392   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
393   s/\n//g"
394
395 # Standard options:
396 opt_dry_run=false
397 opt_help=false
398 opt_quiet=false
399 opt_verbose=false
400 opt_warning=:
401
402 # func_echo arg...
403 # Echo program name prefixed message, along with the current mode
404 # name if it has been set yet.
405 func_echo ()
406 {
407     $ECHO "$progname${mode+: }$mode: $*"
408 }
409
410 # func_verbose arg...
411 # Echo program name prefixed message in verbose mode only.
412 func_verbose ()
413 {
414     $opt_verbose && func_echo ${1+"$@"}
415
416     # A bug in bash halts the script if the last line of a function
417     # fails when set -e is in force, so we need another command to
418     # work around that:
419     :
420 }
421
422 # func_echo_all arg...
423 # Invoke $ECHO with all args, space-separated.
424 func_echo_all ()
425 {
426     $ECHO "$*"
427 }
428
429 # func_error arg...
430 # Echo program name prefixed message to standard error.
431 func_error ()
432 {
433     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
434 }
435
436 # func_warning arg...
437 # Echo program name prefixed warning message to standard error.
438 func_warning ()
439 {
440     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
441
442     # bash bug again:
443     :
444 }
445
446 # func_fatal_error arg...
447 # Echo program name prefixed message to standard error, and exit.
448 func_fatal_error ()
449 {
450     func_error ${1+"$@"}
451     exit $EXIT_FAILURE
452 }
453
454 # func_fatal_help arg...
455 # Echo program name prefixed message to standard error, followed by
456 # a help hint, and exit.
457 func_fatal_help ()
458 {
459     func_error ${1+"$@"}
460     func_fatal_error "$help"
461 }
462 help="Try \`$progname --help' for more information."  ## default
463
464
465 # func_grep expression filename
466 # Check whether EXPRESSION matches any line of FILENAME, without output.
467 func_grep ()
468 {
469     $GREP "$1" "$2" >/dev/null 2>&1
470 }
471
472
473 # func_mkdir_p directory-path
474 # Make sure the entire path to DIRECTORY-PATH is available.
475 func_mkdir_p ()
476 {
477     my_directory_path="$1"
478     my_dir_list=
479
480     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
481
482       # Protect directory names starting with `-'
483       case $my_directory_path in
484         -*) my_directory_path="./$my_directory_path" ;;
485       esac
486
487       # While some portion of DIR does not yet exist...
488       while test ! -d "$my_directory_path"; do
489         # ...make a list in topmost first order.  Use a colon delimited
490         # list incase some portion of path contains whitespace.
491         my_dir_list="$my_directory_path:$my_dir_list"
492
493         # If the last portion added has no slash in it, the list is done
494         case $my_directory_path in */*) ;; *) break ;; esac
495
496         # ...otherwise throw away the child directory and loop
497         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
498       done
499       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
500
501       save_mkdir_p_IFS="$IFS"; IFS=':'
502       for my_dir in $my_dir_list; do
503         IFS="$save_mkdir_p_IFS"
504         # mkdir can fail with a `File exist' error if two processes
505         # try to create one of the directories concurrently.  Don't
506         # stop in that case!
507         $MKDIR "$my_dir" 2>/dev/null || :
508       done
509       IFS="$save_mkdir_p_IFS"
510
511       # Bail out if we (or some other process) failed to create a directory.
512       test -d "$my_directory_path" || \
513         func_fatal_error "Failed to create \`$1'"
514     fi
515 }
516
517
518 # func_mktempdir [string]
519 # Make a temporary directory that won't clash with other running
520 # libtool processes, and avoids race conditions if possible.  If
521 # given, STRING is the basename for that directory.
522 func_mktempdir ()
523 {
524     my_template="${TMPDIR-/tmp}/${1-$progname}"
525
526     if test "$opt_dry_run" = ":"; then
527       # Return a directory name, but don't create it in dry-run mode
528       my_tmpdir="${my_template}-$$"
529     else
530
531       # If mktemp works, use that first and foremost
532       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
533
534       if test ! -d "$my_tmpdir"; then
535         # Failing that, at least try and use $RANDOM to avoid a race
536         my_tmpdir="${my_template}-${RANDOM-0}$$"
537
538         save_mktempdir_umask=`umask`
539         umask 0077
540         $MKDIR "$my_tmpdir"
541         umask $save_mktempdir_umask
542       fi
543
544       # If we're not in dry-run mode, bomb out on failure
545       test -d "$my_tmpdir" || \
546         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
547     fi
548
549     $ECHO "$my_tmpdir"
550 }
551
552
553 # func_quote_for_eval arg
554 # Aesthetically quote ARG to be evaled later.
555 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
556 # is double-quoted, suitable for a subsequent eval, whereas
557 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
558 # which are still active within double quotes backslashified.
559 func_quote_for_eval ()
560 {
561     case $1 in
562       *[\\\`\"\$]*)
563         func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
564       *)
565         func_quote_for_eval_unquoted_result="$1" ;;
566     esac
567
568     case $func_quote_for_eval_unquoted_result in
569       # Double-quote args containing shell metacharacters to delay
570       # word splitting, command substitution and and variable
571       # expansion for a subsequent eval.
572       # Many Bourne shells cannot handle close brackets correctly
573       # in scan sets, so we specify it separately.
574       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
575         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
576         ;;
577       *)
578         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
579     esac
580 }
581
582
583 # func_quote_for_expand arg
584 # Aesthetically quote ARG to be evaled later; same as above,
585 # but do not quote variable references.
586 func_quote_for_expand ()
587 {
588     case $1 in
589       *[\\\`\"]*)
590         my_arg=`$ECHO "$1" | $SED \
591             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
592       *)
593         my_arg="$1" ;;
594     esac
595
596     case $my_arg in
597       # Double-quote args containing shell metacharacters to delay
598       # word splitting and command substitution for a subsequent eval.
599       # Many Bourne shells cannot handle close brackets correctly
600       # in scan sets, so we specify it separately.
601       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
602         my_arg="\"$my_arg\""
603         ;;
604     esac
605
606     func_quote_for_expand_result="$my_arg"
607 }
608
609
610 # func_show_eval cmd [fail_exp]
611 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
612 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
613 # is given, then evaluate it.
614 func_show_eval ()
615 {
616     my_cmd="$1"
617     my_fail_exp="${2-:}"
618
619     ${opt_silent-false} || {
620       func_quote_for_expand "$my_cmd"
621       eval "func_echo $func_quote_for_expand_result"
622     }
623
624     if ${opt_dry_run-false}; then :; else
625       eval "$my_cmd"
626       my_status=$?
627       if test "$my_status" -eq 0; then :; else
628         eval "(exit $my_status); $my_fail_exp"
629       fi
630     fi
631 }
632
633
634 # func_show_eval_locale cmd [fail_exp]
635 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
636 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
637 # is given, then evaluate it.  Use the saved locale for evaluation.
638 func_show_eval_locale ()
639 {
640     my_cmd="$1"
641     my_fail_exp="${2-:}"
642
643     ${opt_silent-false} || {
644       func_quote_for_expand "$my_cmd"
645       eval "func_echo $func_quote_for_expand_result"
646     }
647
648     if ${opt_dry_run-false}; then :; else
649       eval "$lt_user_locale
650             $my_cmd"
651       my_status=$?
652       eval "$lt_safe_locale"
653       if test "$my_status" -eq 0; then :; else
654         eval "(exit $my_status); $my_fail_exp"
655       fi
656     fi
657 }
658
659
660
661
662
663 # func_version
664 # Echo version message to standard output and exit.
665 func_version ()
666 {
667     $SED -n '/(C)/!b go
668         :more
669         /\./!{
670           N
671           s/\n# //
672           b more
673         }
674         :go
675         /^# '$PROGRAM' (GNU /,/# warranty; / {
676         s/^# //
677         s/^# *$//
678         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
679         p
680      }' < "$progpath"
681      exit $?
682 }
683
684 # func_usage
685 # Echo short help message to standard output and exit.
686 func_usage ()
687 {
688     $SED -n '/^# Usage:/,/^#  *-h/ {
689         s/^# //
690         s/^# *$//
691         s/\$progname/'$progname'/
692         p
693     }' < "$progpath"
694     echo
695     $ECHO "run \`$progname --help | more' for full usage"
696     exit $?
697 }
698
699 # func_help [NOEXIT]
700 # Echo long help message to standard output and exit,
701 # unless 'noexit' is passed as argument.
702 func_help ()
703 {
704     $SED -n '/^# Usage:/,/# Report bugs to/ {
705         s/^# //
706         s/^# *$//
707         s*\$progname*'$progname'*
708         s*\$host*'"$host"'*
709         s*\$SHELL*'"$SHELL"'*
710         s*\$LTCC*'"$LTCC"'*
711         s*\$LTCFLAGS*'"$LTCFLAGS"'*
712         s*\$LD*'"$LD"'*
713         s/\$with_gnu_ld/'"$with_gnu_ld"'/
714         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
715         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
716         p
717      }' < "$progpath"
718     ret=$?
719     if test -z "$1"; then
720       exit $ret
721     fi
722 }
723
724 # func_missing_arg argname
725 # Echo program name prefixed message to standard error and set global
726 # exit_cmd.
727 func_missing_arg ()
728 {
729     func_error "missing argument for $1"
730     exit_cmd=exit
731 }
732
733 exit_cmd=:
734
735
736
737
738
739
740 magic="%%%MAGIC variable%%%"
741 magic_exe="%%%MAGIC EXE variable%%%"
742
743 # Global variables.
744 # $mode is unset
745 nonopt=
746 execute_dlfiles=
747 preserve_args=
748 lo2o="s/\\.lo\$/.${objext}/"
749 o2lo="s/\\.${objext}\$/.lo/"
750 extracted_archives=
751 extracted_serial=0
752
753 opt_dry_run=false
754 opt_finish=:
755 opt_duplicate_deps=false
756 opt_silent=false
757 opt_debug=:
758
759 # If this variable is set in any of the actions, the command in it
760 # will be execed at the end.  This prevents here-documents from being
761 # left over by shells.
762 exec_cmd=
763
764 # func_fatal_configuration arg...
765 # Echo program name prefixed message to standard error, followed by
766 # a configuration failure hint, and exit.
767 func_fatal_configuration ()
768 {
769     func_error ${1+"$@"}
770     func_error "See the $PACKAGE documentation for more information."
771     func_fatal_error "Fatal configuration error."
772 }
773
774
775 # func_config
776 # Display the configuration for all the tags in this script.
777 func_config ()
778 {
779     re_begincf='^# ### BEGIN LIBTOOL'
780     re_endcf='^# ### END LIBTOOL'
781
782     # Default configuration.
783     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
784
785     # Now print the configurations for the tags.
786     for tagname in $taglist; do
787       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
788     done
789
790     exit $?
791 }
792
793 # func_features
794 # Display the features supported by this script.
795 func_features ()
796 {
797     echo "host: $host"
798     if test "$build_libtool_libs" = yes; then
799       echo "enable shared libraries"
800     else
801       echo "disable shared libraries"
802     fi
803     if test "$build_old_libs" = yes; then
804       echo "enable static libraries"
805     else
806       echo "disable static libraries"
807     fi
808
809     exit $?
810 }
811
812 # func_enable_tag tagname
813 # Verify that TAGNAME is valid, and either flag an error and exit, or
814 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
815 # variable here.
816 func_enable_tag ()
817 {
818   # Global variable:
819   tagname="$1"
820
821   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
822   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
823   sed_extractcf="/$re_begincf/,/$re_endcf/p"
824
825   # Validate tagname.
826   case $tagname in
827     *[!-_A-Za-z0-9,/]*)
828       func_fatal_error "invalid tag name: $tagname"
829       ;;
830   esac
831
832   # Don't test for the "default" C tag, as we know it's
833   # there but not specially marked.
834   case $tagname in
835     CC) ;;
836     *)
837       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
838         taglist="$taglist $tagname"
839
840         # Evaluate the configuration.  Be careful to quote the path
841         # and the sed script, to avoid splitting on whitespace, but
842         # also don't use non-portable quotes within backquotes within
843         # quotes we have to do it in 2 steps:
844         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
845         eval "$extractedcf"
846       else
847         func_error "ignoring unknown tag $tagname"
848       fi
849       ;;
850   esac
851 }
852
853 # Parse options once, thoroughly.  This comes as soon as possible in
854 # the script to make things like `libtool --version' happen quickly.
855 {
856
857   # Shorthand for --mode=foo, only valid as the first argument
858   case $1 in
859   clean|clea|cle|cl)
860     shift; set dummy --mode clean ${1+"$@"}; shift
861     ;;
862   compile|compil|compi|comp|com|co|c)
863     shift; set dummy --mode compile ${1+"$@"}; shift
864     ;;
865   execute|execut|execu|exec|exe|ex|e)
866     shift; set dummy --mode execute ${1+"$@"}; shift
867     ;;
868   finish|finis|fini|fin|fi|f)
869     shift; set dummy --mode finish ${1+"$@"}; shift
870     ;;
871   install|instal|insta|inst|ins|in|i)
872     shift; set dummy --mode install ${1+"$@"}; shift
873     ;;
874   link|lin|li|l)
875     shift; set dummy --mode link ${1+"$@"}; shift
876     ;;
877   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
878     shift; set dummy --mode uninstall ${1+"$@"}; shift
879     ;;
880   esac
881
882   # Parse non-mode specific arguments:
883   while test "$#" -gt 0; do
884     opt="$1"
885     shift
886
887     case $opt in
888       --config)         func_config                                     ;;
889
890       --debug)          preserve_args="$preserve_args $opt"
891                         func_echo "enabling shell trace mode"
892                         opt_debug='set -x'
893                         $opt_debug
894                         ;;
895
896       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
897                         execute_dlfiles="$execute_dlfiles $1"
898                         shift
899                         ;;
900
901       --dry-run | -n)   opt_dry_run=:                                   ;;
902       --features)       func_features                                   ;;
903       --finish)         mode="finish"                                   ;;
904       --no-finish)      opt_finish=false                                ;;
905
906       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
907                         case $1 in
908                           # Valid mode arguments:
909                           clean)        ;;
910                           compile)      ;;
911                           execute)      ;;
912                           finish)       ;;
913                           install)      ;;
914                           link)         ;;
915                           relink)       ;;
916                           uninstall)    ;;
917
918                           # Catch anything else as an error
919                           *) func_error "invalid argument for $opt"
920                              exit_cmd=exit
921                              break
922                              ;;
923                         esac
924
925                         mode="$1"
926                         shift
927                         ;;
928
929       --preserve-dup-deps)
930                         opt_duplicate_deps=:                            ;;
931
932       --quiet|--silent) preserve_args="$preserve_args $opt"
933                         opt_silent=:
934                         opt_verbose=false
935                         ;;
936
937       --no-quiet|--no-silent)
938                         preserve_args="$preserve_args $opt"
939                         opt_silent=false
940                         ;;
941
942       --verbose| -v)    preserve_args="$preserve_args $opt"
943                         opt_silent=false
944                         opt_verbose=:
945                         ;;
946
947       --no-verbose)     preserve_args="$preserve_args $opt"
948                         opt_verbose=false
949                         ;;
950
951       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
952                         preserve_args="$preserve_args $opt $1"
953                         func_enable_tag "$1"    # tagname is set here
954                         shift
955                         ;;
956
957       # Separate optargs to long options:
958       -dlopen=*|--mode=*|--tag=*)
959                         func_opt_split "$opt"
960                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
961                         shift
962                         ;;
963
964       -\?|-h)           func_usage                                      ;;
965       --help)           opt_help=:                                      ;;
966       --help-all)       opt_help=': help-all'                           ;;
967       --version)        func_version                                    ;;
968
969       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
970
971       *)                nonopt="$opt"
972                         break
973                         ;;
974     esac
975   done
976
977
978   case $host in
979     *cygwin* | *mingw* | *pw32* | *cegcc*)
980       # don't eliminate duplications in $postdeps and $predeps
981       opt_duplicate_compiler_generated_deps=:
982       ;;
983     *)
984       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
985       ;;
986   esac
987
988   # Having warned about all mis-specified options, bail out if
989   # anything was wrong.
990   $exit_cmd $EXIT_FAILURE
991 }
992
993 # func_check_version_match
994 # Ensure that we are using m4 macros, and libtool script from the same
995 # release of libtool.
996 func_check_version_match ()
997 {
998   if test "$package_revision" != "$macro_revision"; then
999     if test "$VERSION" != "$macro_version"; then
1000       if test -z "$macro_version"; then
1001         cat >&2 <<_LT_EOF
1002 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1003 $progname: definition of this LT_INIT comes from an older release.
1004 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1005 $progname: and run autoconf again.
1006 _LT_EOF
1007       else
1008         cat >&2 <<_LT_EOF
1009 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1010 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1011 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1012 $progname: and run autoconf again.
1013 _LT_EOF
1014       fi
1015     else
1016       cat >&2 <<_LT_EOF
1017 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1018 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1019 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1020 $progname: of $PACKAGE $VERSION and run autoconf again.
1021 _LT_EOF
1022     fi
1023
1024     exit $EXIT_MISMATCH
1025   fi
1026 }
1027
1028
1029 ## ----------- ##
1030 ##    Main.    ##
1031 ## ----------- ##
1032
1033 $opt_help || {
1034   # Sanity checks first:
1035   func_check_version_match
1036
1037   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1038     func_fatal_configuration "not configured to build any kind of library"
1039   fi
1040
1041   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1042
1043
1044   # Darwin sucks
1045   eval "std_shrext=\"$shrext_cmds\""
1046
1047
1048   # Only execute mode is allowed to have -dlopen flags.
1049   if test -n "$execute_dlfiles" && test "$mode" != execute; then
1050     func_error "unrecognized option \`-dlopen'"
1051     $ECHO "$help" 1>&2
1052     exit $EXIT_FAILURE
1053   fi
1054
1055   # Change the help message to a mode-specific one.
1056   generic_help="$help"
1057   help="Try \`$progname --help --mode=$mode' for more information."
1058 }
1059
1060
1061 # func_lalib_p file
1062 # True iff FILE is a libtool `.la' library or `.lo' object file.
1063 # This function is only a basic sanity check; it will hardly flush out
1064 # determined imposters.
1065 func_lalib_p ()
1066 {
1067     test -f "$1" &&
1068       $SED -e 4q "$1" 2>/dev/null \
1069         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1070 }
1071
1072 # func_lalib_unsafe_p file
1073 # True iff FILE is a libtool `.la' library or `.lo' object file.
1074 # This function implements the same check as func_lalib_p without
1075 # resorting to external programs.  To this end, it redirects stdin and
1076 # closes it afterwards, without saving the original file descriptor.
1077 # As a safety measure, use it only where a negative result would be
1078 # fatal anyway.  Works if `file' does not exist.
1079 func_lalib_unsafe_p ()
1080 {
1081     lalib_p=no
1082     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1083         for lalib_p_l in 1 2 3 4
1084         do
1085             read lalib_p_line
1086             case "$lalib_p_line" in
1087                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1088             esac
1089         done
1090         exec 0<&5 5<&-
1091     fi
1092     test "$lalib_p" = yes
1093 }
1094
1095 # func_ltwrapper_script_p file
1096 # True iff FILE is a libtool wrapper script
1097 # This function is only a basic sanity check; it will hardly flush out
1098 # determined imposters.
1099 func_ltwrapper_script_p ()
1100 {
1101     func_lalib_p "$1"
1102 }
1103
1104 # func_ltwrapper_executable_p file
1105 # True iff FILE is a libtool wrapper executable
1106 # This function is only a basic sanity check; it will hardly flush out
1107 # determined imposters.
1108 func_ltwrapper_executable_p ()
1109 {
1110     func_ltwrapper_exec_suffix=
1111     case $1 in
1112     *.exe) ;;
1113     *) func_ltwrapper_exec_suffix=.exe ;;
1114     esac
1115     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1116 }
1117
1118 # func_ltwrapper_scriptname file
1119 # Assumes file is an ltwrapper_executable
1120 # uses $file to determine the appropriate filename for a
1121 # temporary ltwrapper_script.
1122 func_ltwrapper_scriptname ()
1123 {
1124     func_ltwrapper_scriptname_result=""
1125     if func_ltwrapper_executable_p "$1"; then
1126         func_dirname_and_basename "$1" "" "."
1127         func_stripname '' '.exe' "$func_basename_result"
1128         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1129     fi
1130 }
1131
1132 # func_ltwrapper_p file
1133 # True iff FILE is a libtool wrapper script or wrapper executable
1134 # This function is only a basic sanity check; it will hardly flush out
1135 # determined imposters.
1136 func_ltwrapper_p ()
1137 {
1138     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1139 }
1140
1141
1142 # func_execute_cmds commands fail_cmd
1143 # Execute tilde-delimited COMMANDS.
1144 # If FAIL_CMD is given, eval that upon failure.
1145 # FAIL_CMD may read-access the current command in variable CMD!
1146 func_execute_cmds ()
1147 {
1148     $opt_debug
1149     save_ifs=$IFS; IFS='~'
1150     for cmd in $1; do
1151       IFS=$save_ifs
1152       eval "cmd=\"$cmd\""
1153       func_show_eval "$cmd" "${2-:}"
1154     done
1155     IFS=$save_ifs
1156 }
1157
1158
1159 # func_source file
1160 # Source FILE, adding directory component if necessary.
1161 # Note that it is not necessary on cygwin/mingw to append a dot to
1162 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1163 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1164 # `FILE.' does not work on cygwin managed mounts.
1165 func_source ()
1166 {
1167     $opt_debug
1168     case $1 in
1169     */* | *\\*) . "$1" ;;
1170     *)          . "./$1" ;;
1171     esac
1172 }
1173
1174
1175 # func_infer_tag arg
1176 # Infer tagged configuration to use if any are available and
1177 # if one wasn't chosen via the "--tag" command line option.
1178 # Only attempt this if the compiler in the base compile
1179 # command doesn't match the default compiler.
1180 # arg is usually of the form 'gcc ...'
1181 func_infer_tag ()
1182 {
1183     $opt_debug
1184     if test -n "$available_tags" && test -z "$tagname"; then
1185       CC_quoted=
1186       for arg in $CC; do
1187         func_quote_for_eval "$arg"
1188         CC_quoted="$CC_quoted $func_quote_for_eval_result"
1189       done
1190       CC_expanded=`func_echo_all $CC`
1191       CC_quoted_expanded=`func_echo_all $CC_quoted`
1192       case $@ in
1193       # Blanks in the command may have been stripped by the calling shell,
1194       # but not from the CC environment variable when configure was run.
1195       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1196       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1197       # Blanks at the start of $base_compile will cause this to fail
1198       # if we don't check for them as well.
1199       *)
1200         for z in $available_tags; do
1201           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1202             # Evaluate the configuration.
1203             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1204             CC_quoted=
1205             for arg in $CC; do
1206               # Double-quote args containing other shell metacharacters.
1207               func_quote_for_eval "$arg"
1208               CC_quoted="$CC_quoted $func_quote_for_eval_result"
1209             done
1210             CC_expanded=`func_echo_all $CC`
1211             CC_quoted_expanded=`func_echo_all $CC_quoted`
1212             case "$@ " in
1213             " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1214             " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1215               # The compiler in the base compile command matches
1216               # the one in the tagged configuration.
1217               # Assume this is the tagged configuration we want.
1218               tagname=$z
1219               break
1220               ;;
1221             esac
1222           fi
1223         done
1224         # If $tagname still isn't set, then no tagged configuration
1225         # was found and let the user know that the "--tag" command
1226         # line option must be used.
1227         if test -z "$tagname"; then
1228           func_echo "unable to infer tagged configuration"
1229           func_fatal_error "specify a tag with \`--tag'"
1230 #       else
1231 #         func_verbose "using $tagname tagged configuration"
1232         fi
1233         ;;
1234       esac
1235     fi
1236 }
1237
1238
1239
1240 # func_write_libtool_object output_name pic_name nonpic_name
1241 # Create a libtool object file (analogous to a ".la" file),
1242 # but don't create it if we're doing a dry run.
1243 func_write_libtool_object ()
1244 {
1245     write_libobj=${1}
1246     if test "$build_libtool_libs" = yes; then
1247       write_lobj=\'${2}\'
1248     else
1249       write_lobj=none
1250     fi
1251
1252     if test "$build_old_libs" = yes; then
1253       write_oldobj=\'${3}\'
1254     else
1255       write_oldobj=none
1256     fi
1257
1258     $opt_dry_run || {
1259       cat >${write_libobj}T <<EOF
1260 # $write_libobj - a libtool object file
1261 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1262 #
1263 # Please DO NOT delete this file!
1264 # It is necessary for linking the library.
1265
1266 # Name of the PIC object.
1267 pic_object=$write_lobj
1268
1269 # Name of the non-PIC object
1270 non_pic_object=$write_oldobj
1271
1272 EOF
1273       $MV "${write_libobj}T" "${write_libobj}"
1274     }
1275 }
1276
1277 # func_mode_compile arg...
1278 func_mode_compile ()
1279 {
1280     $opt_debug
1281     # Get the compilation command and the source file.
1282     base_compile=
1283     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1284     suppress_opt=yes
1285     suppress_output=
1286     arg_mode=normal
1287     libobj=
1288     later=
1289     pie_flag=
1290
1291     for arg
1292     do
1293       case $arg_mode in
1294       arg  )
1295         # do not "continue".  Instead, add this to base_compile
1296         lastarg="$arg"
1297         arg_mode=normal
1298         ;;
1299
1300       target )
1301         libobj="$arg"
1302         arg_mode=normal
1303         continue
1304         ;;
1305
1306       normal )
1307         # Accept any command-line options.
1308         case $arg in
1309         -o)
1310           test -n "$libobj" && \
1311             func_fatal_error "you cannot specify \`-o' more than once"
1312           arg_mode=target
1313           continue
1314           ;;
1315
1316         -pie | -fpie | -fPIE)
1317           pie_flag="$pie_flag $arg"
1318           continue
1319           ;;
1320
1321         -shared | -static | -prefer-pic | -prefer-non-pic)
1322           later="$later $arg"
1323           continue
1324           ;;
1325
1326         -no-suppress)
1327           suppress_opt=no
1328           continue
1329           ;;
1330
1331         -Xcompiler)
1332           arg_mode=arg  #  the next one goes into the "base_compile" arg list
1333           continue      #  The current "srcfile" will either be retained or
1334           ;;            #  replaced later.  I would guess that would be a bug.
1335
1336         -Wc,*)
1337           func_stripname '-Wc,' '' "$arg"
1338           args=$func_stripname_result
1339           lastarg=
1340           save_ifs="$IFS"; IFS=','
1341           for arg in $args; do
1342             IFS="$save_ifs"
1343             func_quote_for_eval "$arg"
1344             lastarg="$lastarg $func_quote_for_eval_result"
1345           done
1346           IFS="$save_ifs"
1347           func_stripname ' ' '' "$lastarg"
1348           lastarg=$func_stripname_result
1349
1350           # Add the arguments to base_compile.
1351           base_compile="$base_compile $lastarg"
1352           continue
1353           ;;
1354
1355         *)
1356           # Accept the current argument as the source file.
1357           # The previous "srcfile" becomes the current argument.
1358           #
1359           lastarg="$srcfile"
1360           srcfile="$arg"
1361           ;;
1362         esac  #  case $arg
1363         ;;
1364       esac    #  case $arg_mode
1365
1366       # Aesthetically quote the previous argument.
1367       func_quote_for_eval "$lastarg"
1368       base_compile="$base_compile $func_quote_for_eval_result"
1369     done # for arg
1370
1371     case $arg_mode in
1372     arg)
1373       func_fatal_error "you must specify an argument for -Xcompile"
1374       ;;
1375     target)
1376       func_fatal_error "you must specify a target with \`-o'"
1377       ;;
1378     *)
1379       # Get the name of the library object.
1380       test -z "$libobj" && {
1381         func_basename "$srcfile"
1382         libobj="$func_basename_result"
1383       }
1384       ;;
1385     esac
1386
1387     # Recognize several different file suffixes.
1388     # If the user specifies -o file.o, it is replaced with file.lo
1389     case $libobj in
1390     *.[cCFSifmso] | \
1391     *.ada | *.adb | *.ads | *.asm | \
1392     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1393     *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1394       func_xform "$libobj"
1395       libobj=$func_xform_result
1396       ;;
1397     esac
1398
1399     case $libobj in
1400     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1401     *)
1402       func_fatal_error "cannot determine name of library object from \`$libobj'"
1403       ;;
1404     esac
1405
1406     func_infer_tag $base_compile
1407
1408     for arg in $later; do
1409       case $arg in
1410       -shared)
1411         test "$build_libtool_libs" != yes && \
1412           func_fatal_configuration "can not build a shared library"
1413         build_old_libs=no
1414         continue
1415         ;;
1416
1417       -static)
1418         build_libtool_libs=no
1419         build_old_libs=yes
1420         continue
1421         ;;
1422
1423       -prefer-pic)
1424         pic_mode=yes
1425         continue
1426         ;;
1427
1428       -prefer-non-pic)
1429         pic_mode=no
1430         continue
1431         ;;
1432       esac
1433     done
1434
1435     func_quote_for_eval "$libobj"
1436     test "X$libobj" != "X$func_quote_for_eval_result" \
1437       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1438       && func_warning "libobj name \`$libobj' may not contain shell special characters."
1439     func_dirname_and_basename "$obj" "/" ""
1440     objname="$func_basename_result"
1441     xdir="$func_dirname_result"
1442     lobj=${xdir}$objdir/$objname
1443
1444     test -z "$base_compile" && \
1445       func_fatal_help "you must specify a compilation command"
1446
1447     # Delete any leftover library objects.
1448     if test "$build_old_libs" = yes; then
1449       removelist="$obj $lobj $libobj ${libobj}T"
1450     else
1451       removelist="$lobj $libobj ${libobj}T"
1452     fi
1453
1454     # On Cygwin there's no "real" PIC flag so we must build both object types
1455     case $host_os in
1456     cygwin* | mingw* | pw32* | os2* | cegcc*)
1457       pic_mode=default
1458       ;;
1459     esac
1460     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1461       # non-PIC code in shared libraries is not supported
1462       pic_mode=default
1463     fi
1464
1465     # Calculate the filename of the output object if compiler does
1466     # not support -o with -c
1467     if test "$compiler_c_o" = no; then
1468       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1469       lockfile="$output_obj.lock"
1470     else
1471       output_obj=
1472       need_locks=no
1473       lockfile=
1474     fi
1475
1476     # Lock this critical section if it is needed
1477     # We use this script file to make the link, it avoids creating a new file
1478     if test "$need_locks" = yes; then
1479       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1480         func_echo "Waiting for $lockfile to be removed"
1481         sleep 2
1482       done
1483     elif test "$need_locks" = warn; then
1484       if test -f "$lockfile"; then
1485         $ECHO "\
1486 *** ERROR, $lockfile exists and contains:
1487 `cat $lockfile 2>/dev/null`
1488
1489 This indicates that another process is trying to use the same
1490 temporary object file, and libtool could not work around it because
1491 your compiler does not support \`-c' and \`-o' together.  If you
1492 repeat this compilation, it may succeed, by chance, but you had better
1493 avoid parallel builds (make -j) in this platform, or get a better
1494 compiler."
1495
1496         $opt_dry_run || $RM $removelist
1497         exit $EXIT_FAILURE
1498       fi
1499       removelist="$removelist $output_obj"
1500       $ECHO "$srcfile" > "$lockfile"
1501     fi
1502
1503     $opt_dry_run || $RM $removelist
1504     removelist="$removelist $lockfile"
1505     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1506
1507     if test -n "$fix_srcfile_path"; then
1508       eval "srcfile=\"$fix_srcfile_path\""
1509     fi
1510     func_quote_for_eval "$srcfile"
1511     qsrcfile=$func_quote_for_eval_result
1512
1513     # Only build a PIC object if we are building libtool libraries.
1514     if test "$build_libtool_libs" = yes; then
1515       # Without this assignment, base_compile gets emptied.
1516       fbsd_hideous_sh_bug=$base_compile
1517
1518       if test "$pic_mode" != no; then
1519         command="$base_compile $qsrcfile $pic_flag"
1520       else
1521         # Don't build PIC code
1522         command="$base_compile $qsrcfile"
1523       fi
1524
1525       func_mkdir_p "$xdir$objdir"
1526
1527       if test -z "$output_obj"; then
1528         # Place PIC objects in $objdir
1529         command="$command -o $lobj"
1530       fi
1531
1532       func_show_eval_locale "$command"  \
1533           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1534
1535       if test "$need_locks" = warn &&
1536          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1537         $ECHO "\
1538 *** ERROR, $lockfile contains:
1539 `cat $lockfile 2>/dev/null`
1540
1541 but it should contain:
1542 $srcfile
1543
1544 This indicates that another process is trying to use the same
1545 temporary object file, and libtool could not work around it because
1546 your compiler does not support \`-c' and \`-o' together.  If you
1547 repeat this compilation, it may succeed, by chance, but you had better
1548 avoid parallel builds (make -j) in this platform, or get a better
1549 compiler."
1550
1551         $opt_dry_run || $RM $removelist
1552         exit $EXIT_FAILURE
1553       fi
1554
1555       # Just move the object if needed, then go on to compile the next one
1556       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1557         func_show_eval '$MV "$output_obj" "$lobj"' \
1558           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1559       fi
1560
1561       # Allow error messages only from the first compilation.
1562       if test "$suppress_opt" = yes; then
1563         suppress_output=' >/dev/null 2>&1'
1564       fi
1565     fi
1566
1567     # Only build a position-dependent object if we build old libraries.
1568     if test "$build_old_libs" = yes; then
1569       if test "$pic_mode" != yes; then
1570         # Don't build PIC code
1571         command="$base_compile $qsrcfile$pie_flag"
1572       else
1573         command="$base_compile $qsrcfile $pic_flag"
1574       fi
1575       if test "$compiler_c_o" = yes; then
1576         command="$command -o $obj"
1577       fi
1578
1579       # Suppress compiler output if we already did a PIC compilation.
1580       command="$command$suppress_output"
1581       func_show_eval_locale "$command" \
1582         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1583
1584       if test "$need_locks" = warn &&
1585          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1586         $ECHO "\
1587 *** ERROR, $lockfile contains:
1588 `cat $lockfile 2>/dev/null`
1589
1590 but it should contain:
1591 $srcfile
1592
1593 This indicates that another process is trying to use the same
1594 temporary object file, and libtool could not work around it because
1595 your compiler does not support \`-c' and \`-o' together.  If you
1596 repeat this compilation, it may succeed, by chance, but you had better
1597 avoid parallel builds (make -j) in this platform, or get a better
1598 compiler."
1599
1600         $opt_dry_run || $RM $removelist
1601         exit $EXIT_FAILURE
1602       fi
1603
1604       # Just move the object if needed
1605       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1606         func_show_eval '$MV "$output_obj" "$obj"' \
1607           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1608       fi
1609     fi
1610
1611     $opt_dry_run || {
1612       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1613
1614       # Unlock the critical section if it was locked
1615       if test "$need_locks" != no; then
1616         removelist=$lockfile
1617         $RM "$lockfile"
1618       fi
1619     }
1620
1621     exit $EXIT_SUCCESS
1622 }
1623
1624 $opt_help || {
1625   test "$mode" = compile && func_mode_compile ${1+"$@"}
1626 }
1627
1628 func_mode_help ()
1629 {
1630     # We need to display help for each of the modes.
1631     case $mode in
1632       "")
1633         # Generic help is extracted from the usage comments
1634         # at the start of this file.
1635         func_help
1636         ;;
1637
1638       clean)
1639         $ECHO \
1640 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1641
1642 Remove files from the build directory.
1643
1644 RM is the name of the program to use to delete files associated with each FILE
1645 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1646 to RM.
1647
1648 If FILE is a libtool library, object or program, all the files associated
1649 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1650         ;;
1651
1652       compile)
1653       $ECHO \
1654 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1655
1656 Compile a source file into a libtool library object.
1657
1658 This mode accepts the following additional options:
1659
1660   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1661   -no-suppress      do not suppress compiler output for multiple passes
1662   -prefer-pic       try to building PIC objects only
1663   -prefer-non-pic   try to building non-PIC objects only
1664   -shared           do not build a \`.o' file suitable for static linking
1665   -static           only build a \`.o' file suitable for static linking
1666   -Wc,FLAG          pass FLAG directly to the compiler
1667
1668 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1669 from the given SOURCEFILE.
1670
1671 The output file name is determined by removing the directory component from
1672 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1673 library object suffix, \`.lo'."
1674         ;;
1675
1676       execute)
1677         $ECHO \
1678 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1679
1680 Automatically set library path, then run a program.
1681
1682 This mode accepts the following additional options:
1683
1684   -dlopen FILE      add the directory containing FILE to the library path
1685
1686 This mode sets the library path environment variable according to \`-dlopen'
1687 flags.
1688
1689 If any of the ARGS are libtool executable wrappers, then they are translated
1690 into their corresponding uninstalled binary, and any of their required library
1691 directories are added to the library path.
1692
1693 Then, COMMAND is executed, with ARGS as arguments."
1694         ;;
1695
1696       finish)
1697         $ECHO \
1698 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1699
1700 Complete the installation of libtool libraries.
1701
1702 Each LIBDIR is a directory that contains libtool libraries.
1703
1704 The commands that this mode executes may require superuser privileges.  Use
1705 the \`--dry-run' option if you just want to see what would be executed."
1706         ;;
1707
1708       install)
1709         $ECHO \
1710 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1711
1712 Install executables or libraries.
1713
1714 INSTALL-COMMAND is the installation command.  The first component should be
1715 either the \`install' or \`cp' program.
1716
1717 The following components of INSTALL-COMMAND are treated specially:
1718
1719   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
1720
1721 The rest of the components are interpreted as arguments to that command (only
1722 BSD-compatible install options are recognized)."
1723         ;;
1724
1725       link)
1726         $ECHO \
1727 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1728
1729 Link object files or libraries together to form another library, or to
1730 create an executable program.
1731
1732 LINK-COMMAND is a command using the C compiler that you would use to create
1733 a program from several object files.
1734
1735 The following components of LINK-COMMAND are treated specially:
1736
1737   -all-static       do not do any dynamic linking at all
1738   -avoid-version    do not add a version suffix if possible
1739   -bindir BINDIR    specify path to binaries directory (for systems where
1740                     libraries must be found in the PATH setting at runtime)
1741   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
1742   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
1743   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1744   -export-symbols SYMFILE
1745                     try to export only the symbols listed in SYMFILE
1746   -export-symbols-regex REGEX
1747                     try to export only the symbols matching REGEX
1748   -LLIBDIR          search LIBDIR for required installed libraries
1749   -lNAME            OUTPUT-FILE requires the installed library libNAME
1750   -module           build a library that can dlopened
1751   -no-fast-install  disable the fast-install mode
1752   -no-install       link a not-installable executable
1753   -no-undefined     declare that a library does not refer to external symbols
1754   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1755   -objectlist FILE  Use a list of object files found in FILE to specify objects
1756   -precious-files-regex REGEX
1757                     don't remove output files matching REGEX
1758   -release RELEASE  specify package release information
1759   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1760   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
1761   -shared           only do dynamic linking of libtool libraries
1762   -shrext SUFFIX    override the standard shared library file extension
1763   -static           do not do any dynamic linking of uninstalled libtool libraries
1764   -static-libtool-libs
1765                     do not do any dynamic linking of libtool libraries
1766   -version-info CURRENT[:REVISION[:AGE]]
1767                     specify library version info [each variable defaults to 0]
1768   -weak LIBNAME     declare that the target provides the LIBNAME interface
1769   -Wc,FLAG
1770   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
1771   -Wl,FLAG
1772   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
1773   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
1774
1775 All other options (arguments beginning with \`-') are ignored.
1776
1777 Every other argument is treated as a filename.  Files ending in \`.la' are
1778 treated as uninstalled libtool libraries, other files are standard or library
1779 object files.
1780
1781 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1782 only library objects (\`.lo' files) may be specified, and \`-rpath' is
1783 required, except when creating a convenience library.
1784
1785 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1786 using \`ar' and \`ranlib', or on Windows using \`lib'.
1787
1788 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1789 is created, otherwise an executable program is created."
1790         ;;
1791
1792       uninstall)
1793         $ECHO \
1794 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1795
1796 Remove libraries from an installation directory.
1797
1798 RM is the name of the program to use to delete files associated with each FILE
1799 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1800 to RM.
1801
1802 If FILE is a libtool library, all the files associated with it are deleted.
1803 Otherwise, only FILE itself is deleted using RM."
1804         ;;
1805
1806       *)
1807         func_fatal_help "invalid operation mode \`$mode'"
1808         ;;
1809     esac
1810
1811     echo
1812     $ECHO "Try \`$progname --help' for more information about other modes."
1813 }
1814
1815 # Now that we've collected a possible --mode arg, show help if necessary
1816 if $opt_help; then
1817   if test "$opt_help" = :; then
1818     func_mode_help
1819   else
1820     {
1821       func_help noexit
1822       for mode in compile link execute install finish uninstall clean; do
1823         func_mode_help
1824       done
1825     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
1826     {
1827       func_help noexit
1828       for mode in compile link execute install finish uninstall clean; do
1829         echo
1830         func_mode_help
1831       done
1832     } |
1833     sed '1d
1834       /^When reporting/,/^Report/{
1835         H
1836         d
1837       }
1838       $x
1839       /information about other modes/d
1840       /more detailed .*MODE/d
1841       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
1842   fi
1843   exit $?
1844 fi
1845
1846
1847 # func_mode_execute arg...
1848 func_mode_execute ()
1849 {
1850     $opt_debug
1851     # The first argument is the command name.
1852     cmd="$nonopt"
1853     test -z "$cmd" && \
1854       func_fatal_help "you must specify a COMMAND"
1855
1856     # Handle -dlopen flags immediately.
1857     for file in $execute_dlfiles; do
1858       test -f "$file" \
1859         || func_fatal_help "\`$file' is not a file"
1860
1861       dir=
1862       case $file in
1863       *.la)
1864         # Check to see that this really is a libtool archive.
1865         func_lalib_unsafe_p "$file" \
1866           || func_fatal_help "\`$lib' is not a valid libtool archive"
1867
1868         # Read the libtool library.
1869         dlname=
1870         library_names=
1871         func_source "$file"
1872
1873         # Skip this library if it cannot be dlopened.
1874         if test -z "$dlname"; then
1875           # Warn if it was a shared library.
1876           test -n "$library_names" && \
1877             func_warning "\`$file' was not linked with \`-export-dynamic'"
1878           continue
1879         fi
1880
1881         func_dirname "$file" "" "."
1882         dir="$func_dirname_result"
1883
1884         if test -f "$dir/$objdir/$dlname"; then
1885           dir="$dir/$objdir"
1886         else
1887           if test ! -f "$dir/$dlname"; then
1888             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1889           fi
1890         fi
1891         ;;
1892
1893       *.lo)
1894         # Just add the directory containing the .lo file.
1895         func_dirname "$file" "" "."
1896         dir="$func_dirname_result"
1897         ;;
1898
1899       *)
1900         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1901         continue
1902         ;;
1903       esac
1904
1905       # Get the absolute pathname.
1906       absdir=`cd "$dir" && pwd`
1907       test -n "$absdir" && dir="$absdir"
1908
1909       # Now add the directory to shlibpath_var.
1910       if eval test -z \"\$$shlibpath_var\"; then
1911         eval $shlibpath_var=\$dir
1912       else
1913         eval $shlibpath_var=\$dir:\$$shlibpath_var
1914       fi
1915     done
1916
1917     # This variable tells wrapper scripts just to set shlibpath_var
1918     # rather than running their programs.
1919     libtool_execute_magic="$magic"
1920
1921     # Check if any of the arguments is a wrapper script.
1922     args=
1923     for file
1924     do
1925       case $file in
1926       -* | *.la | *.lo ) ;;
1927       *)
1928         # Do a test to see if this is really a libtool program.
1929         if func_ltwrapper_script_p "$file"; then
1930           func_source "$file"
1931           # Transform arg to wrapped name.
1932           file="$progdir/$program"
1933         elif func_ltwrapper_executable_p "$file"; then
1934           func_ltwrapper_scriptname "$file"
1935           func_source "$func_ltwrapper_scriptname_result"
1936           # Transform arg to wrapped name.
1937           file="$progdir/$program"
1938         fi
1939         ;;
1940       esac
1941       # Quote arguments (to preserve shell metacharacters).
1942       func_quote_for_eval "$file"
1943       args="$args $func_quote_for_eval_result"
1944     done
1945
1946     if test "X$opt_dry_run" = Xfalse; then
1947       if test -n "$shlibpath_var"; then
1948         # Export the shlibpath_var.
1949         eval "export $shlibpath_var"
1950       fi
1951
1952       # Restore saved environment variables
1953       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1954       do
1955         eval "if test \"\${save_$lt_var+set}\" = set; then
1956                 $lt_var=\$save_$lt_var; export $lt_var
1957               else
1958                 $lt_unset $lt_var
1959               fi"
1960       done
1961
1962       # Now prepare to actually exec the command.
1963       exec_cmd="\$cmd$args"
1964     else
1965       # Display what would be done.
1966       if test -n "$shlibpath_var"; then
1967         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1968         echo "export $shlibpath_var"
1969       fi
1970       $ECHO "$cmd$args"
1971       exit $EXIT_SUCCESS
1972     fi
1973 }
1974
1975 test "$mode" = execute && func_mode_execute ${1+"$@"}
1976
1977
1978 # func_mode_finish arg...
1979 func_mode_finish ()
1980 {
1981     $opt_debug
1982     libdirs="$nonopt"
1983     admincmds=
1984
1985     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1986       for dir
1987       do
1988         libdirs="$libdirs $dir"
1989       done
1990
1991       for libdir in $libdirs; do
1992         if test -n "$finish_cmds"; then
1993           # Do each command in the finish commands.
1994           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1995 '"$cmd"'"'
1996         fi
1997         if test -n "$finish_eval"; then
1998           # Do the single finish_eval.
1999           eval cmds=\"$finish_eval\"
2000           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2001        $cmds"
2002         fi
2003       done
2004     fi
2005
2006     # Exit here if they wanted silent mode.
2007     $opt_silent && exit $EXIT_SUCCESS
2008
2009     echo "----------------------------------------------------------------------"
2010     echo "Libraries have been installed in:"
2011     for libdir in $libdirs; do
2012       $ECHO "   $libdir"
2013     done
2014     echo
2015     echo "If you ever happen to want to link against installed libraries"
2016     echo "in a given directory, LIBDIR, you must either use libtool, and"
2017     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2018     echo "flag during linking and do at least one of the following:"
2019     if test -n "$shlibpath_var"; then
2020       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2021       echo "     during execution"
2022     fi
2023     if test -n "$runpath_var"; then
2024       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2025       echo "     during linking"
2026     fi
2027     if test -n "$hardcode_libdir_flag_spec"; then
2028       libdir=LIBDIR
2029       eval "flag=\"$hardcode_libdir_flag_spec\""
2030
2031       $ECHO "   - use the \`$flag' linker flag"
2032     fi
2033     if test -n "$admincmds"; then
2034       $ECHO "   - have your system administrator run these commands:$admincmds"
2035     fi
2036     if test -f /etc/ld.so.conf; then
2037       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2038     fi
2039     echo
2040
2041     echo "See any operating system documentation about shared libraries for"
2042     case $host in
2043       solaris2.[6789]|solaris2.1[0-9])
2044         echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2045         echo "pages."
2046         ;;
2047       *)
2048         echo "more information, such as the ld(1) and ld.so(8) manual pages."
2049         ;;
2050     esac
2051     echo "----------------------------------------------------------------------"
2052     exit $EXIT_SUCCESS
2053 }
2054
2055 test "$mode" = finish && func_mode_finish ${1+"$@"}
2056
2057
2058 # func_mode_install arg...
2059 func_mode_install ()
2060 {
2061     $opt_debug
2062     # There may be an optional sh(1) argument at the beginning of
2063     # install_prog (especially on Windows NT).
2064     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2065        # Allow the use of GNU shtool's install command.
2066        case $nonopt in *shtool*) :;; *) false;; esac; then
2067       # Aesthetically quote it.
2068       func_quote_for_eval "$nonopt"
2069       install_prog="$func_quote_for_eval_result "
2070       arg=$1
2071       shift
2072     else
2073       install_prog=
2074       arg=$nonopt
2075     fi
2076
2077     # The real first argument should be the name of the installation program.
2078     # Aesthetically quote it.
2079     func_quote_for_eval "$arg"
2080     install_prog="$install_prog$func_quote_for_eval_result"
2081     install_shared_prog=$install_prog
2082     case " $install_prog " in
2083       *[\\\ /]cp\ *) install_cp=: ;;
2084       *) install_cp=false ;;
2085     esac
2086
2087     # We need to accept at least all the BSD install flags.
2088     dest=
2089     files=
2090     opts=
2091     prev=
2092     install_type=
2093     isdir=no
2094     stripme=
2095     no_mode=:
2096     for arg
2097     do
2098       arg2=
2099       if test -n "$dest"; then
2100         files="$files $dest"
2101         dest=$arg
2102         continue
2103       fi
2104
2105       case $arg in
2106       -d) isdir=yes ;;
2107       -f)
2108         if $install_cp; then :; else
2109           prev=$arg
2110         fi
2111         ;;
2112       -g | -m | -o)
2113         prev=$arg
2114         ;;
2115       -s)
2116         stripme=" -s"
2117         continue
2118         ;;
2119       -*)
2120         ;;
2121       *)
2122         # If the previous option needed an argument, then skip it.
2123         if test -n "$prev"; then
2124           if test "x$prev" = x-m && test -n "$install_override_mode"; then
2125             arg2=$install_override_mode
2126             no_mode=false
2127           fi
2128           prev=
2129         else
2130           dest=$arg
2131           continue
2132         fi
2133         ;;
2134       esac
2135
2136       # Aesthetically quote the argument.
2137       func_quote_for_eval "$arg"
2138       install_prog="$install_prog $func_quote_for_eval_result"
2139       if test -n "$arg2"; then
2140         func_quote_for_eval "$arg2"
2141       fi
2142       install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2143     done
2144
2145     test -z "$install_prog" && \
2146       func_fatal_help "you must specify an install program"
2147
2148     test -n "$prev" && \
2149       func_fatal_help "the \`$prev' option requires an argument"
2150
2151     if test -n "$install_override_mode" && $no_mode; then
2152       if $install_cp; then :; else
2153         func_quote_for_eval "$install_override_mode"
2154         install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2155       fi
2156     fi
2157
2158     if test -z "$files"; then
2159       if test -z "$dest"; then
2160         func_fatal_help "no file or destination specified"
2161       else
2162         func_fatal_help "you must specify a destination"
2163       fi
2164     fi
2165
2166     # Strip any trailing slash from the destination.
2167     func_stripname '' '/' "$dest"
2168     dest=$func_stripname_result
2169
2170     # Check to see that the destination is a directory.
2171     test -d "$dest" && isdir=yes
2172     if test "$isdir" = yes; then
2173       destdir="$dest"
2174       destname=
2175     else
2176       func_dirname_and_basename "$dest" "" "."
2177       destdir="$func_dirname_result"
2178       destname="$func_basename_result"
2179
2180       # Not a directory, so check to see that there is only one file specified.
2181       set dummy $files; shift
2182       test "$#" -gt 1 && \
2183         func_fatal_help "\`$dest' is not a directory"
2184     fi
2185     case $destdir in
2186     [\\/]* | [A-Za-z]:[\\/]*) ;;
2187     *)
2188       for file in $files; do
2189         case $file in
2190         *.lo) ;;
2191         *)
2192           func_fatal_help "\`$destdir' must be an absolute directory name"
2193           ;;
2194         esac
2195       done
2196       ;;
2197     esac
2198
2199     # This variable tells wrapper scripts just to set variables rather
2200     # than running their programs.
2201     libtool_install_magic="$magic"
2202
2203     staticlibs=
2204     future_libdirs=
2205     current_libdirs=
2206     for file in $files; do
2207
2208       # Do each installation.
2209       case $file in
2210       *.$libext)
2211         # Do the static libraries later.
2212         staticlibs="$staticlibs $file"
2213         ;;
2214
2215       *.la)
2216         # Check to see that this really is a libtool archive.
2217         func_lalib_unsafe_p "$file" \
2218           || func_fatal_help "\`$file' is not a valid libtool archive"
2219
2220         library_names=
2221         old_library=
2222         relink_command=
2223         func_source "$file"
2224
2225         # Add the libdir to current_libdirs if it is the destination.
2226         if test "X$destdir" = "X$libdir"; then
2227           case "$current_libdirs " in
2228           *" $libdir "*) ;;
2229           *) current_libdirs="$current_libdirs $libdir" ;;
2230           esac
2231         else
2232           # Note the libdir as a future libdir.
2233           case "$future_libdirs " in
2234           *" $libdir "*) ;;
2235           *) future_libdirs="$future_libdirs $libdir" ;;
2236           esac
2237         fi
2238
2239         func_dirname "$file" "/" ""
2240         dir="$func_dirname_result"
2241         dir="$dir$objdir"
2242
2243         if test -n "$relink_command"; then
2244           # Determine the prefix the user has applied to our future dir.
2245           inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2246
2247           # Don't allow the user to place us outside of our expected
2248           # location b/c this prevents finding dependent libraries that
2249           # are installed to the same prefix.
2250           # At present, this check doesn't affect windows .dll's that
2251           # are installed into $libdir/../bin (currently, that works fine)
2252           # but it's something to keep an eye on.
2253           test "$inst_prefix_dir" = "$destdir" && \
2254             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2255
2256           if test -n "$inst_prefix_dir"; then
2257             # Stick the inst_prefix_dir data into the link command.
2258             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2259           else
2260             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2261           fi
2262
2263           func_warning "relinking \`$file'"
2264           func_show_eval "$relink_command" \
2265             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2266         fi
2267
2268         # See the names of the shared library.
2269         set dummy $library_names; shift
2270         if test -n "$1"; then
2271           realname="$1"
2272           shift
2273
2274           srcname="$realname"
2275           test -n "$relink_command" && srcname="$realname"T
2276
2277           # Install the shared library and build the symlinks.
2278           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2279               'exit $?'
2280           tstripme="$stripme"
2281           case $host_os in
2282           cygwin* | mingw* | pw32* | cegcc*)
2283             case $realname in
2284             *.dll.a)
2285               tstripme=""
2286               ;;
2287             esac
2288             ;;
2289           esac
2290           if test -n "$tstripme" && test -n "$striplib"; then
2291             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2292           fi
2293
2294           if test "$#" -gt 0; then
2295             # Delete the old symlinks, and create new ones.
2296             # Try `ln -sf' first, because the `ln' binary might depend on
2297             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2298             # so we also need to try rm && ln -s.
2299             for linkname
2300             do
2301               test "$linkname" != "$realname" \
2302                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2303             done
2304           fi
2305
2306           # Do each command in the postinstall commands.
2307           lib="$destdir/$realname"
2308           func_execute_cmds "$postinstall_cmds" 'exit $?'
2309         fi
2310
2311         # Install the pseudo-library for information purposes.
2312         func_basename "$file"
2313         name="$func_basename_result"
2314         instname="$dir/$name"i
2315         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2316
2317         # Maybe install the static library, too.
2318         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2319         ;;
2320
2321       *.lo)
2322         # Install (i.e. copy) a libtool object.
2323
2324         # Figure out destination file name, if it wasn't already specified.
2325         if test -n "$destname"; then
2326           destfile="$destdir/$destname"
2327         else
2328           func_basename "$file"
2329           destfile="$func_basename_result"
2330           destfile="$destdir/$destfile"
2331         fi
2332
2333         # Deduce the name of the destination old-style object file.
2334         case $destfile in
2335         *.lo)
2336           func_lo2o "$destfile"
2337           staticdest=$func_lo2o_result
2338           ;;
2339         *.$objext)
2340           staticdest="$destfile"
2341           destfile=
2342           ;;
2343         *)
2344           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2345           ;;
2346         esac
2347
2348         # Install the libtool object if requested.
2349         test -n "$destfile" && \
2350           func_show_eval "$install_prog $file $destfile" 'exit $?'
2351
2352         # Install the old object if enabled.
2353         if test "$build_old_libs" = yes; then
2354           # Deduce the name of the old-style object file.
2355           func_lo2o "$file"
2356           staticobj=$func_lo2o_result
2357           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2358         fi
2359         exit $EXIT_SUCCESS
2360         ;;
2361
2362       *)
2363         # Figure out destination file name, if it wasn't already specified.
2364         if test -n "$destname"; then
2365           destfile="$destdir/$destname"
2366         else
2367           func_basename "$file"
2368           destfile="$func_basename_result"
2369           destfile="$destdir/$destfile"
2370         fi
2371
2372         # If the file is missing, and there is a .exe on the end, strip it
2373         # because it is most likely a libtool script we actually want to
2374         # install
2375         stripped_ext=""
2376         case $file in
2377           *.exe)
2378             if test ! -f "$file"; then
2379               func_stripname '' '.exe' "$file"
2380               file=$func_stripname_result
2381               stripped_ext=".exe"
2382             fi
2383             ;;
2384         esac
2385
2386         # Do a test to see if this is really a libtool program.
2387         case $host in
2388         *cygwin* | *mingw*)
2389             if func_ltwrapper_executable_p "$file"; then
2390               func_ltwrapper_scriptname "$file"
2391               wrapper=$func_ltwrapper_scriptname_result
2392             else
2393               func_stripname '' '.exe' "$file"
2394               wrapper=$func_stripname_result
2395             fi
2396             ;;
2397         *)
2398             wrapper=$file
2399             ;;
2400         esac
2401         if func_ltwrapper_script_p "$wrapper"; then
2402           notinst_deplibs=
2403           relink_command=
2404
2405           func_source "$wrapper"
2406
2407           # Check the variables that should have been set.
2408           test -z "$generated_by_libtool_version" && \
2409             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2410
2411           finalize=yes
2412           for lib in $notinst_deplibs; do
2413             # Check to see that each library is installed.
2414             libdir=
2415             if test -f "$lib"; then
2416               func_source "$lib"
2417             fi
2418             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2419             if test -n "$libdir" && test ! -f "$libfile"; then
2420               func_warning "\`$lib' has not been installed in \`$libdir'"
2421               finalize=no
2422             fi
2423           done
2424
2425           relink_command=
2426           func_source "$wrapper"
2427
2428           outputname=
2429           if test "$fast_install" = no && test -n "$relink_command"; then
2430             $opt_dry_run || {
2431               if test "$finalize" = yes; then
2432                 tmpdir=`func_mktempdir`
2433                 func_basename "$file$stripped_ext"
2434                 file="$func_basename_result"
2435                 outputname="$tmpdir/$file"
2436                 # Replace the output file specification.
2437                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2438
2439                 $opt_silent || {
2440                   func_quote_for_expand "$relink_command"
2441                   eval "func_echo $func_quote_for_expand_result"
2442                 }
2443                 if eval "$relink_command"; then :
2444                   else
2445                   func_error "error: relink \`$file' with the above command before installing it"
2446                   $opt_dry_run || ${RM}r "$tmpdir"
2447                   continue
2448                 fi
2449                 file="$outputname"
2450               else
2451                 func_warning "cannot relink \`$file'"
2452               fi
2453             }
2454           else
2455             # Install the binary that we compiled earlier.
2456             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2457           fi
2458         fi
2459
2460         # remove .exe since cygwin /usr/bin/install will append another
2461         # one anyway
2462         case $install_prog,$host in
2463         */usr/bin/install*,*cygwin*)
2464           case $file:$destfile in
2465           *.exe:*.exe)
2466             # this is ok
2467             ;;
2468           *.exe:*)
2469             destfile=$destfile.exe
2470             ;;
2471           *:*.exe)
2472             func_stripname '' '.exe' "$destfile"
2473             destfile=$func_stripname_result
2474             ;;
2475           esac
2476           ;;
2477         esac
2478         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2479         $opt_dry_run || if test -n "$outputname"; then
2480           ${RM}r "$tmpdir"
2481         fi
2482         ;;
2483       esac
2484     done
2485
2486     for file in $staticlibs; do
2487       func_basename "$file"
2488       name="$func_basename_result"
2489
2490       # Set up the ranlib parameters.
2491       oldlib="$destdir/$name"
2492
2493       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2494
2495       if test -n "$stripme" && test -n "$old_striplib"; then
2496         func_show_eval "$old_striplib $oldlib" 'exit $?'
2497       fi
2498
2499       # Do each command in the postinstall commands.
2500       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2501     done
2502
2503     test -n "$future_libdirs" && \
2504       func_warning "remember to run \`$progname --finish$future_libdirs'"
2505
2506     if test -n "$current_libdirs" && $opt_finish; then
2507       # Maybe just do a dry run.
2508       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2509       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2510     else
2511       exit $EXIT_SUCCESS
2512     fi
2513 }
2514
2515 test "$mode" = install && func_mode_install ${1+"$@"}
2516
2517
2518 # func_generate_dlsyms outputname originator pic_p
2519 # Extract symbols from dlprefiles and create ${outputname}S.o with
2520 # a dlpreopen symbol table.
2521 func_generate_dlsyms ()
2522 {
2523     $opt_debug
2524     my_outputname="$1"
2525     my_originator="$2"
2526     my_pic_p="${3-no}"
2527     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2528     my_dlsyms=
2529
2530     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2531       if test -n "$NM" && test -n "$global_symbol_pipe"; then
2532         my_dlsyms="${my_outputname}S.c"
2533       else
2534         func_error "not configured to extract global symbols from dlpreopened files"
2535       fi
2536     fi
2537
2538     if test -n "$my_dlsyms"; then
2539       case $my_dlsyms in
2540       "") ;;
2541       *.c)
2542         # Discover the nlist of each of the dlfiles.
2543         nlist="$output_objdir/${my_outputname}.nm"
2544
2545         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2546
2547         # Parse the name list into a source file.
2548         func_verbose "creating $output_objdir/$my_dlsyms"
2549
2550         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2551 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2552 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2553
2554 #ifdef __cplusplus
2555 extern \"C\" {
2556 #endif
2557
2558 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
2559 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2560 #endif
2561
2562 /* External symbol declarations for the compiler. */\
2563 "
2564
2565         if test "$dlself" = yes; then
2566           func_verbose "generating symbol list for \`$output'"
2567
2568           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2569
2570           # Add our own program objects to the symbol list.
2571           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2572           for progfile in $progfiles; do
2573             func_verbose "extracting global C symbols from \`$progfile'"
2574             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2575           done
2576
2577           if test -n "$exclude_expsyms"; then
2578             $opt_dry_run || {
2579               $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2580               $MV "$nlist"T "$nlist"
2581             }
2582           fi
2583
2584           if test -n "$export_symbols_regex"; then
2585             $opt_dry_run || {
2586               $EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T
2587               $MV "$nlist"T "$nlist"
2588             }
2589           fi
2590
2591           # Prepare the list of exported symbols
2592           if test -z "$export_symbols"; then
2593             export_symbols="$output_objdir/$outputname.exp"
2594             $opt_dry_run || {
2595               $RM $export_symbols
2596               ${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' < "$nlist" > "$export_symbols"
2597               case $host in
2598               *cygwin* | *mingw* | *cegcc* )
2599                 echo EXPORTS > "$output_objdir/$outputname.def"
2600                 cat "$export_symbols" >> "$output_objdir/$outputname.def"
2601                 ;;
2602               esac
2603             }
2604           else
2605             $opt_dry_run || {
2606               ${SED} -e 's/\([].[*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp"
2607               $GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T
2608               $MV "$nlist"T "$nlist"
2609               case $host in
2610                 *cygwin* | *mingw* | *cegcc* )
2611                   echo EXPORTS > "$output_objdir/$outputname.def"
2612                   cat "$nlist" >> "$output_objdir/$outputname.def"
2613                   ;;
2614               esac
2615             }
2616           fi
2617         fi
2618
2619         for dlprefile in $dlprefiles; do
2620           func_verbose "extracting global C symbols from \`$dlprefile'"
2621           func_basename "$dlprefile"
2622           name="$func_basename_result"
2623           $opt_dry_run || {
2624             $ECHO ": $name " >> "$nlist"
2625             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2626           }
2627         done
2628
2629         $opt_dry_run || {
2630           # Make sure we have at least an empty file.
2631           test -f "$nlist" || : > "$nlist"
2632
2633           if test -n "$exclude_expsyms"; then
2634             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2635             $MV "$nlist"T "$nlist"
2636           fi
2637
2638           # Try sorting and uniquifying the output.
2639           if $GREP -v "^: " < "$nlist" |
2640               if sort -k 3 </dev/null >/dev/null 2>&1; then
2641                 sort -k 3
2642               else
2643                 sort +2
2644               fi |
2645               uniq > "$nlist"S; then
2646             :
2647           else
2648             $GREP -v "^: " < "$nlist" > "$nlist"S
2649           fi
2650
2651           if test -f "$nlist"S; then
2652             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2653           else
2654             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2655           fi
2656
2657           echo >> "$output_objdir/$my_dlsyms" "\
2658
2659 /* The mapping between symbol names and symbols.  */
2660 typedef struct {
2661   const char *name;
2662   void *address;
2663 } lt_dlsymlist;
2664 "
2665           case $host in
2666           *cygwin* | *mingw* | *cegcc* )
2667             echo >> "$output_objdir/$my_dlsyms" "\
2668 /* DATA imports from DLLs on WIN32 con't be const, because
2669    runtime relocations are performed -- see ld's documentation
2670    on pseudo-relocs.  */"
2671             lt_dlsym_const= ;;
2672           *osf5*)
2673             echo >> "$output_objdir/$my_dlsyms" "\
2674 /* This system does not cope well with relocations in const data */"
2675             lt_dlsym_const= ;;
2676           *)
2677             lt_dlsym_const=const ;;
2678           esac
2679
2680           echo >> "$output_objdir/$my_dlsyms" "\
2681 extern $lt_dlsym_const lt_dlsymlist
2682 lt_${my_prefix}_LTX_preloaded_symbols[];
2683 $lt_dlsym_const lt_dlsymlist
2684 lt_${my_prefix}_LTX_preloaded_symbols[] =
2685 {\
2686   { \"$my_originator\", (void *) 0 },"
2687
2688           case $need_lib_prefix in
2689           no)
2690             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2691             ;;
2692           *)
2693             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2694             ;;
2695           esac
2696           echo >> "$output_objdir/$my_dlsyms" "\
2697   {0, (void *) 0}
2698 };
2699
2700 /* This works around a problem in FreeBSD linker */
2701 #ifdef FREEBSD_WORKAROUND
2702 static const void *lt_preloaded_setup() {
2703   return lt_${my_prefix}_LTX_preloaded_symbols;
2704 }
2705 #endif
2706
2707 #ifdef __cplusplus
2708 }
2709 #endif\
2710 "
2711         } # !$opt_dry_run
2712
2713         pic_flag_for_symtable=
2714         case "$compile_command " in
2715         *" -static "*) ;;
2716         *)
2717           case $host in
2718           # compiling the symbol table file with pic_flag works around
2719           # a FreeBSD bug that causes programs to crash when -lm is
2720           # linked before any other PIC object.  But we must not use
2721           # pic_flag when linking with -static.  The problem exists in
2722           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2723           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2724             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2725           *-*-hpux*)
2726             pic_flag_for_symtable=" $pic_flag"  ;;
2727           *)
2728             if test "X$my_pic_p" != Xno; then
2729               pic_flag_for_symtable=" $pic_flag"
2730             fi
2731             ;;
2732           esac
2733           ;;
2734         esac
2735         symtab_cflags=
2736         for arg in $LTCFLAGS; do
2737           case $arg in
2738           -pie | -fpie | -fPIE) ;;
2739           *) symtab_cflags="$symtab_cflags $arg" ;;
2740           esac
2741         done
2742
2743         # Now compile the dynamic symbol file.
2744         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2745
2746         # Clean up the generated files.
2747         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2748
2749         # Transform the symbol file into the correct name.
2750         symfileobj="$output_objdir/${my_outputname}S.$objext"
2751         case $host in
2752         *cygwin* | *mingw* | *cegcc* )
2753           if test -f "$output_objdir/$my_outputname.def"; then
2754             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2755             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2756           else
2757             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2758             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2759           fi
2760           ;;
2761         *)
2762           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2763           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2764           ;;
2765         esac
2766         ;;
2767       *)
2768         func_fatal_error "unknown suffix for \`$my_dlsyms'"
2769         ;;
2770       esac
2771     else
2772       # We keep going just in case the user didn't refer to
2773       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2774       # really was required.
2775
2776       # Nullify the symbol file.
2777       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
2778       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2779     fi
2780 }
2781
2782 # func_win32_libid arg
2783 # return the library type of file 'arg'
2784 #
2785 # Need a lot of goo to handle *both* DLLs and import libs
2786 # Has to be a shell function in order to 'eat' the argument
2787 # that is supplied when $file_magic_command is called.
2788 # Despite the name, also deal with 64 bit binaries.
2789 func_win32_libid ()
2790 {
2791   $opt_debug
2792   win32_libid_type="unknown"
2793   win32_fileres=`file -L $1 2>/dev/null`
2794   case $win32_fileres in
2795   *ar\ archive\ import\ library*) # definitely import
2796     win32_libid_type="x86 archive import"
2797     ;;
2798   *ar\ archive*) # could be an import, or static
2799     if $OBJDUMP -f "$1" | $SED -e '10q' 2>/dev/null |
2800        $EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
2801       win32_nmres=`$NM -f posix -A "$1" |
2802         $SED -n -e '
2803             1,100{
2804                 / I /{
2805                     s,.*,import,
2806                     p
2807                     q
2808                 }
2809             }'`
2810       case $win32_nmres in
2811       import*)  win32_libid_type="x86 archive import";;
2812       *)        win32_libid_type="x86 archive static";;
2813       esac
2814     fi
2815     ;;
2816   *DLL*)
2817     win32_libid_type="x86 DLL"
2818     ;;
2819   *executable*) # but shell scripts are "executable" too...
2820     case $win32_fileres in
2821     *MS\ Windows\ PE\ Intel*)
2822       win32_libid_type="x86 DLL"
2823       ;;
2824     esac
2825     ;;
2826   esac
2827   $ECHO "$win32_libid_type"
2828 }
2829
2830
2831
2832 # func_extract_an_archive dir oldlib
2833 func_extract_an_archive ()
2834 {
2835     $opt_debug
2836     f_ex_an_ar_dir="$1"; shift
2837     f_ex_an_ar_oldlib="$1"
2838     if test "$lock_old_archive_extraction" = yes; then
2839       lockfile=$f_ex_an_ar_oldlib.lock
2840       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2841         func_echo "Waiting for $lockfile to be removed"
2842         sleep 2
2843       done
2844     fi
2845     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2846                    'stat=$?; rm -f "$lockfile"; exit $stat'
2847     if test "$lock_old_archive_extraction" = yes; then
2848       $opt_dry_run || rm -f "$lockfile"
2849     fi
2850     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2851      :
2852     else
2853       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2854     fi
2855 }
2856
2857
2858 # func_extract_archives gentop oldlib ...
2859 func_extract_archives ()
2860 {
2861     $opt_debug
2862     my_gentop="$1"; shift
2863     my_oldlibs=${1+"$@"}
2864     my_oldobjs=""
2865     my_xlib=""
2866     my_xabs=""
2867     my_xdir=""
2868
2869     for my_xlib in $my_oldlibs; do
2870       # Extract the objects.
2871       case $my_xlib in
2872         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2873         *) my_xabs=`pwd`"/$my_xlib" ;;
2874       esac
2875       func_basename "$my_xlib"
2876       my_xlib="$func_basename_result"
2877       my_xlib_u=$my_xlib
2878       while :; do
2879         case " $extracted_archives " in
2880         *" $my_xlib_u "*)
2881           func_arith $extracted_serial + 1
2882           extracted_serial=$func_arith_result
2883           my_xlib_u=lt$extracted_serial-$my_xlib ;;
2884         *) break ;;
2885         esac
2886       done
2887       extracted_archives="$extracted_archives $my_xlib_u"
2888       my_xdir="$my_gentop/$my_xlib_u"
2889
2890       func_mkdir_p "$my_xdir"
2891
2892       case $host in
2893       *-darwin*)
2894         func_verbose "Extracting $my_xabs"
2895         # Do not bother doing anything if just a dry run
2896         $opt_dry_run || {
2897           darwin_orig_dir=`pwd`
2898           cd $my_xdir || exit $?
2899           darwin_archive=$my_xabs
2900           darwin_curdir=`pwd`
2901           darwin_base_archive=`basename "$darwin_archive"`
2902           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2903           if test -n "$darwin_arches"; then
2904             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2905             darwin_arch=
2906             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2907             for darwin_arch in  $darwin_arches ; do
2908               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2909               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2910               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2911               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2912               cd "$darwin_curdir"
2913               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2914             done # $darwin_arches
2915             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2916             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2917             darwin_file=
2918             darwin_files=
2919             for darwin_file in $darwin_filelist; do
2920               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2921               $LIPO -create -output "$darwin_file" $darwin_files
2922             done # $darwin_filelist
2923             $RM -rf unfat-$$
2924             cd "$darwin_orig_dir"
2925           else
2926             cd $darwin_orig_dir
2927             func_extract_an_archive "$my_xdir" "$my_xabs"
2928           fi # $darwin_arches
2929         } # !$opt_dry_run
2930         ;;
2931       *)
2932         func_extract_an_archive "$my_xdir" "$my_xabs"
2933         ;;
2934       esac
2935       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2936     done
2937
2938     func_extract_archives_result="$my_oldobjs"
2939 }
2940
2941
2942 # func_emit_wrapper [arg=no]
2943 #
2944 # Emit a libtool wrapper script on stdout.
2945 # Don't directly open a file because we may want to
2946 # incorporate the script contents within a cygwin/mingw
2947 # wrapper executable.  Must ONLY be called from within
2948 # func_mode_link because it depends on a number of variables
2949 # set therein.
2950 #
2951 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2952 # variable will take.  If 'yes', then the emitted script
2953 # will assume that the directory in which it is stored is
2954 # the $objdir directory.  This is a cygwin/mingw-specific
2955 # behavior.
2956 func_emit_wrapper ()
2957 {
2958         func_emit_wrapper_arg1=${1-no}
2959
2960         $ECHO "\
2961 #! $SHELL
2962
2963 # $output - temporary wrapper script for $objdir/$outputname
2964 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2965 #
2966 # The $output program cannot be directly executed until all the libtool
2967 # libraries that it depends on are installed.
2968 #
2969 # This wrapper script should never be moved out of the build directory.
2970 # If it is, it will not operate correctly.
2971
2972 # Sed substitution that helps us do robust quoting.  It backslashifies
2973 # metacharacters that are still active within double-quoted strings.
2974 sed_quote_subst='$sed_quote_subst'
2975
2976 # Be Bourne compatible
2977 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2978   emulate sh
2979   NULLCMD=:
2980   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2981   # is contrary to our usage.  Disable this feature.
2982   alias -g '\${1+\"\$@\"}'='\"\$@\"'
2983   setopt NO_GLOB_SUBST
2984 else
2985   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2986 fi
2987 BIN_SH=xpg4; export BIN_SH # for Tru64
2988 DUALCASE=1; export DUALCASE # for MKS sh
2989
2990 # The HP-UX ksh and POSIX shell print the target directory to stdout
2991 # if CDPATH is set.
2992 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2993
2994 relink_command=\"$relink_command\"
2995
2996 # This environment variable determines our operation mode.
2997 if test \"\$libtool_install_magic\" = \"$magic\"; then
2998   # install mode needs the following variables:
2999   generated_by_libtool_version='$macro_version'
3000   notinst_deplibs='$notinst_deplibs'
3001 else
3002   # When we are sourced in execute mode, \$file and \$ECHO are already set.
3003   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3004     file=\"\$0\""
3005
3006     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3007     $ECHO "\
3008
3009 # A function that is used when there is no print builtin or printf.
3010 func_fallback_echo ()
3011 {
3012   eval 'cat <<_LTECHO_EOF
3013 \$1
3014 _LTECHO_EOF'
3015 }
3016     ECHO=\"$qECHO\"
3017   fi\
3018
3019   # Find the directory that this script lives in.
3020   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3021   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3022
3023   # Follow symbolic links until we get to the real thisdir.
3024   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3025   while test -n \"\$file\"; do
3026     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3027
3028     # If there was a directory component, then change thisdir.
3029     if test \"x\$destdir\" != \"x\$file\"; then
3030       case \"\$destdir\" in
3031       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3032       *) thisdir=\"\$thisdir/\$destdir\" ;;
3033       esac
3034     fi
3035
3036     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3037     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3038   done
3039
3040   # Usually 'no', except on cygwin/mingw when embedded into
3041   # the cwrapper.
3042   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3043   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3044     # special case for '.'
3045     if test \"\$thisdir\" = \".\"; then
3046       thisdir=\`pwd\`
3047     fi
3048     # remove .libs from thisdir
3049     case \"\$thisdir\" in
3050     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3051     $objdir )   thisdir=. ;;
3052     esac
3053   fi
3054
3055   # Try to get the absolute directory name.
3056   absdir=\`cd \"\$thisdir\" && pwd\`
3057   test -n \"\$absdir\" && thisdir=\"\$absdir\"
3058 "
3059
3060         if test "$fast_install" = yes; then
3061           $ECHO "\
3062   program=lt-'$outputname'$exeext
3063   progdir=\"\$thisdir/$objdir\"
3064
3065   if test ! -f \"\$progdir/\$program\" ||
3066      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3067        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3068
3069     file=\"\$\$-\$program\"
3070
3071     if test ! -d \"\$progdir\"; then
3072       $MKDIR \"\$progdir\"
3073     else
3074       $RM \"\$progdir/\$file\"
3075     fi"
3076
3077           $ECHO "\
3078
3079     # relink executable if necessary
3080     if test -n \"\$relink_command\"; then
3081       if relink_command_output=\`eval \"\$relink_command\" 2>&1\`; then :
3082       else
3083         $ECHO \"\$relink_command_output\" >&2
3084         $RM \"\$progdir/\$file\"
3085         exit 1
3086       fi
3087     fi
3088
3089     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3090     { $RM \"\$progdir/\$program\";
3091       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3092     $RM \"\$progdir/\$file\"
3093   fi"
3094         else
3095           $ECHO "\
3096   program='$outputname'
3097   progdir=\"\$thisdir/$objdir\"
3098 "
3099         fi
3100
3101         $ECHO "\
3102
3103   if test -f \"\$progdir/\$program\"; then"
3104
3105         # Export our shlibpath_var if we have one.
3106         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3107           $ECHO "\
3108     # Add our own library path to $shlibpath_var
3109     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3110
3111     # Some systems cannot cope with colon-terminated $shlibpath_var
3112     # The second colon is a workaround for a bug in BeOS R4 sed
3113     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3114
3115     export $shlibpath_var
3116 "
3117         fi
3118
3119         # fixup the dll searchpath if we need to.
3120         if test -n "$dllsearchpath"; then
3121           $ECHO "\
3122     # Add the dll search path components to the executable PATH
3123     PATH=$dllsearchpath:\$PATH
3124 "
3125         fi
3126
3127         $ECHO "\
3128     if test \"\$libtool_execute_magic\" != \"$magic\"; then
3129       # Run the actual program with our arguments.
3130 "
3131         case $host in
3132         # Backslashes separate directories on plain windows
3133         *-*-mingw | *-*-os2* | *-cegcc*)
3134           $ECHO "\
3135       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3136 "
3137           ;;
3138
3139         *)
3140           $ECHO "\
3141       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3142 "
3143           ;;
3144         esac
3145         $ECHO "\
3146       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3147       exit 1
3148     fi
3149   else
3150     # The program doesn't exist.
3151     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3152     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3153     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3154     exit 1
3155   fi
3156 fi\
3157 "
3158 }
3159
3160
3161 # func_to_host_path arg
3162 #
3163 # Convert paths to host format when used with build tools.
3164 # Intended for use with "native" mingw (where libtool itself
3165 # is running under the msys shell), or in the following cross-
3166 # build environments:
3167 #    $build          $host
3168 #    mingw (msys)    mingw  [e.g. native]
3169 #    cygwin          mingw
3170 #    *nix + wine     mingw
3171 # where wine is equipped with the `winepath' executable.
3172 # In the native mingw case, the (msys) shell automatically
3173 # converts paths for any non-msys applications it launches,
3174 # but that facility isn't available from inside the cwrapper.
3175 # Similar accommodations are necessary for $host mingw and
3176 # $build cygwin.  Calling this function does no harm for other
3177 # $host/$build combinations not listed above.
3178 #
3179 # ARG is the path (on $build) that should be converted to
3180 # the proper representation for $host. The result is stored
3181 # in $func_to_host_path_result.
3182 func_to_host_path ()
3183 {
3184   func_to_host_path_result="$1"
3185   if test -n "$1"; then
3186     case $host in
3187       *mingw* )
3188         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3189         case $build in
3190           *mingw* ) # actually, msys
3191             # awkward: cmd appends spaces to result
3192             func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3193               $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3194             ;;
3195           *cygwin* )
3196             func_to_host_path_result=`cygpath -w "$1" |
3197               $SED -e "$lt_sed_naive_backslashify"`
3198             ;;
3199           * )
3200             # Unfortunately, winepath does not exit with a non-zero
3201             # error code, so we are forced to check the contents of
3202             # stdout. On the other hand, if the command is not
3203             # found, the shell will set an exit code of 127 and print
3204             # *an error message* to stdout. So we must check for both
3205             # error code of zero AND non-empty stdout, which explains
3206             # the odd construction:
3207             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3208             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3209               func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3210                 $SED -e "$lt_sed_naive_backslashify"`
3211             else
3212               # Allow warning below.
3213               func_to_host_path_result=
3214             fi
3215             ;;
3216         esac
3217         if test -z "$func_to_host_path_result" ; then
3218           func_error "Could not determine host path corresponding to"
3219           func_error "  \`$1'"
3220           func_error "Continuing, but uninstalled executables may not work."
3221           # Fallback:
3222           func_to_host_path_result="$1"
3223         fi
3224         ;;
3225     esac
3226   fi
3227 }
3228 # end: func_to_host_path
3229
3230 # func_to_host_pathlist arg
3231 #
3232 # Convert pathlists to host format when used with build tools.
3233 # See func_to_host_path(), above. This function supports the
3234 # following $build/$host combinations (but does no harm for
3235 # combinations not listed here):
3236 #    $build          $host
3237 #    mingw (msys)    mingw  [e.g. native]
3238 #    cygwin          mingw
3239 #    *nix + wine     mingw
3240 #
3241 # Path separators are also converted from $build format to
3242 # $host format. If ARG begins or ends with a path separator
3243 # character, it is preserved (but converted to $host format)
3244 # on output.
3245 #
3246 # ARG is a pathlist (on $build) that should be converted to
3247 # the proper representation on $host. The result is stored
3248 # in $func_to_host_pathlist_result.
3249 func_to_host_pathlist ()
3250 {
3251   func_to_host_pathlist_result="$1"
3252   if test -n "$1"; then
3253     case $host in
3254       *mingw* )
3255         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3256         # Remove leading and trailing path separator characters from
3257         # ARG. msys behavior is inconsistent here, cygpath turns them
3258         # into '.;' and ';.', and winepath ignores them completely.
3259         func_stripname : : "$1"
3260         func_to_host_pathlist_tmp1=$func_stripname_result
3261         case $build in
3262           *mingw* ) # Actually, msys.
3263             # Awkward: cmd appends spaces to result.
3264             func_to_host_pathlist_result=`
3265               ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
3266               $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3267             ;;
3268           *cygwin* )
3269             func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
3270               $SED -e "$lt_sed_naive_backslashify"`
3271             ;;
3272           * )
3273             # unfortunately, winepath doesn't convert pathlists
3274             func_to_host_pathlist_result=""
3275             func_to_host_pathlist_oldIFS=$IFS
3276             IFS=:
3277             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3278               IFS=$func_to_host_pathlist_oldIFS
3279               if test -n "$func_to_host_pathlist_f" ; then
3280                 func_to_host_path "$func_to_host_pathlist_f"
3281                 if test -n "$func_to_host_path_result" ; then
3282                   if test -z "$func_to_host_pathlist_result" ; then
3283                     func_to_host_pathlist_result="$func_to_host_path_result"
3284                   else
3285                     func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3286                   fi
3287                 fi
3288               fi
3289             done
3290             IFS=$func_to_host_pathlist_oldIFS
3291             ;;
3292         esac
3293         if test -z "$func_to_host_pathlist_result"; then
3294           func_error "Could not determine the host path(s) corresponding to"
3295           func_error "  \`$1'"
3296           func_error "Continuing, but uninstalled executables may not work."
3297           # Fallback. This may break if $1 contains DOS-style drive
3298           # specifications. The fix is not to complicate the expression
3299           # below, but for the user to provide a working wine installation
3300           # with winepath so that path translation in the cross-to-mingw
3301           # case works properly.
3302           lt_replace_pathsep_nix_to_dos="s|:|;|g"
3303           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3304             $SED -e "$lt_replace_pathsep_nix_to_dos"`
3305         fi
3306         # Now, add the leading and trailing path separators back
3307         case "$1" in
3308           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3309             ;;
3310         esac
3311         case "$1" in
3312           *: ) func_append func_to_host_pathlist_result ";"
3313             ;;
3314         esac
3315         ;;
3316     esac
3317   fi
3318 }
3319 # end: func_to_host_pathlist
3320
3321 # func_emit_cwrapperexe_src
3322 # emit the source code for a wrapper executable on stdout
3323 # Must ONLY be called from within func_mode_link because
3324 # it depends on a number of variable set therein.
3325 func_emit_cwrapperexe_src ()
3326 {
3327         cat <<EOF
3328
3329 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3330    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3331
3332    The $output program cannot be directly executed until all the libtool
3333    libraries that it depends on are installed.
3334
3335    This wrapper executable should never be moved out of the build directory.
3336    If it is, it will not operate correctly.
3337
3338    Currently, it simply execs the wrapper *script* "$SHELL $output",
3339    but could eventually absorb all of the scripts functionality and
3340    exec $objdir/$outputname directly.
3341 */
3342 EOF
3343             cat <<"EOF"
3344 #ifdef _MSC_VER
3345 # define _CRT_SECURE_NO_DEPRECATE 1
3346 #endif
3347 #include <stdio.h>
3348 #include <stdlib.h>
3349 #ifdef _MSC_VER
3350 # include <direct.h>
3351 # include <process.h>
3352 # include <io.h>
3353 #else
3354 # include <unistd.h>
3355 # include <stdint.h>
3356 # ifdef __CYGWIN__
3357 #  include <io.h>
3358 # endif
3359 #endif
3360 #include <malloc.h>
3361 #include <stdarg.h>
3362 #include <assert.h>
3363 #include <string.h>
3364 #include <ctype.h>
3365 #include <errno.h>
3366 #include <fcntl.h>
3367 #include <sys/stat.h>
3368
3369 /* declarations of non-ANSI functions */
3370 #if defined(__MINGW32__)
3371 # ifdef __STRICT_ANSI__
3372 int _putenv (const char *);
3373 # endif
3374 #elif defined(__CYGWIN__)
3375 # ifdef __STRICT_ANSI__
3376 char *realpath (const char *, char *);
3377 int putenv (char *);
3378 int setenv (const char *, const char *, int);
3379 # endif
3380 /* #elif defined (other platforms) ... */
3381 #endif
3382
3383 /* portability defines, excluding path handling macros */
3384 #if defined(_MSC_VER)
3385 # define setmode _setmode
3386 # define stat    _stat
3387 # define chmod   _chmod
3388 # define getcwd  _getcwd
3389 # define putenv  _putenv
3390 # define S_IXUSR _S_IEXEC
3391 # ifndef _INTPTR_T_DEFINED
3392 #  define _INTPTR_T_DEFINED
3393 #  define intptr_t int
3394 # endif
3395 #elif defined(__MINGW32__)
3396 # define setmode _setmode
3397 # define stat    _stat
3398 # define chmod   _chmod
3399 # define getcwd  _getcwd
3400 # define putenv  _putenv
3401 #elif defined(__CYGWIN__)
3402 # define HAVE_SETENV
3403 # define FOPEN_WB "wb"
3404 /* #elif defined (other platforms) ... */
3405 #endif
3406
3407 #if defined(PATH_MAX)
3408 # define LT_PATHMAX PATH_MAX
3409 #elif defined(MAXPATHLEN)
3410 # define LT_PATHMAX MAXPATHLEN
3411 #else
3412 # define LT_PATHMAX 1024
3413 #endif
3414
3415 #ifndef S_IXOTH
3416 # define S_IXOTH 0
3417 #endif
3418 #ifndef S_IXGRP
3419 # define S_IXGRP 0
3420 #endif
3421
3422 /* path handling portability macros */
3423 #ifndef DIR_SEPARATOR
3424 # define DIR_SEPARATOR '/'
3425 # define PATH_SEPARATOR ':'
3426 #endif
3427
3428 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3429   defined (__OS2__)
3430 # define HAVE_DOS_BASED_FILE_SYSTEM
3431 # define FOPEN_WB "wb"
3432 # ifndef DIR_SEPARATOR_2
3433 #  define DIR_SEPARATOR_2 '\\'
3434 # endif
3435 # ifndef PATH_SEPARATOR_2
3436 #  define PATH_SEPARATOR_2 ';'
3437 # endif
3438 #endif
3439
3440 #ifndef DIR_SEPARATOR_2
3441 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3442 #else /* DIR_SEPARATOR_2 */
3443 # define IS_DIR_SEPARATOR(ch) \
3444         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3445 #endif /* DIR_SEPARATOR_2 */
3446
3447 #ifndef PATH_SEPARATOR_2
3448 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3449 #else /* PATH_SEPARATOR_2 */
3450 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3451 #endif /* PATH_SEPARATOR_2 */
3452
3453 #ifndef FOPEN_WB
3454 # define FOPEN_WB "w"
3455 #endif
3456 #ifndef _O_BINARY
3457 # define _O_BINARY 0
3458 #endif
3459
3460 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3461 #define XFREE(stale) do { \
3462   if (stale) { free ((void *) stale); stale = 0; } \
3463 } while (0)
3464
3465 #undef LTWRAPPER_DEBUGPRINTF
3466 #if defined LT_DEBUGWRAPPER
3467 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3468 static void
3469 ltwrapper_debugprintf (const char *fmt, ...)
3470 {
3471     va_list args;
3472     va_start (args, fmt);
3473     (void) vfprintf (stderr, fmt, args);
3474     va_end (args);
3475 }
3476 #else
3477 # define LTWRAPPER_DEBUGPRINTF(args)
3478 #endif
3479
3480 const char *program_name = NULL;
3481
3482 void *xmalloc (size_t num);
3483 char *xstrdup (const char *string);
3484 const char *base_name (const char *name);
3485 char *find_executable (const char *wrapper);
3486 char *chase_symlinks (const char *pathspec);
3487 int make_executable (const char *path);
3488 int check_executable (const char *path);
3489 char *strendzap (char *str, const char *pat);
3490 void lt_fatal (const char *message, ...);
3491 void lt_setenv (const char *name, const char *value);
3492 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3493 void lt_update_exe_path (const char *name, const char *value);
3494 void lt_update_lib_path (const char *name, const char *value);
3495 char **prepare_spawn (char **argv);
3496 void lt_dump_script (FILE *f);
3497 EOF
3498
3499             cat <<EOF
3500 const char * MAGIC_EXE = "$magic_exe";
3501 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3502 EOF
3503
3504             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3505               func_to_host_pathlist "$temp_rpath"
3506               cat <<EOF
3507 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3508 EOF
3509             else
3510               cat <<"EOF"
3511 const char * LIB_PATH_VALUE   = "";
3512 EOF
3513             fi
3514
3515             if test -n "$dllsearchpath"; then
3516               func_to_host_pathlist "$dllsearchpath:"
3517               cat <<EOF
3518 const char * EXE_PATH_VARNAME = "PATH";
3519 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3520 EOF
3521             else
3522               cat <<"EOF"
3523 const char * EXE_PATH_VARNAME = "";
3524 const char * EXE_PATH_VALUE   = "";
3525 EOF
3526             fi
3527
3528             if test "$fast_install" = yes; then
3529               cat <<EOF
3530 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3531 EOF
3532             else
3533               cat <<EOF
3534 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3535 EOF
3536             fi
3537
3538
3539             cat <<"EOF"
3540
3541 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
3542 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3543
3544 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3545 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3546
3547 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3548
3549 int
3550 main (int argc, char *argv[])
3551 {
3552   char **newargz;
3553   int  newargc;
3554   char *tmp_pathspec;
3555   char *actual_cwrapper_path;
3556   char *actual_cwrapper_name;
3557   char *target_name;
3558   char *lt_argv_zero;
3559   intptr_t rval = 127;
3560
3561   int i;
3562
3563   program_name = (char *) xstrdup (base_name (argv[0]));
3564   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3565   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3566
3567   /* very simple arg parsing; don't want to rely on getopt */
3568   for (i = 1; i < argc; i++)
3569     {
3570       if (strcmp (argv[i], dumpscript_opt) == 0)
3571         {
3572 EOF
3573             case "$host" in
3574               *mingw* | *cygwin* )
3575                 # make stdout use "unix" line endings
3576                 echo "          setmode(1,_O_BINARY);"
3577                 ;;
3578               esac
3579
3580             cat <<"EOF"
3581           lt_dump_script (stdout);
3582           return 0;
3583         }
3584     }
3585
3586   newargz = XMALLOC (char *, argc + 1);
3587   tmp_pathspec = find_executable (argv[0]);
3588   if (tmp_pathspec == NULL)
3589     lt_fatal ("Couldn't find %s", argv[0]);
3590   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3591                           tmp_pathspec));
3592
3593   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3594   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3595                           actual_cwrapper_path));
3596   XFREE (tmp_pathspec);
3597
3598   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3599   strendzap (actual_cwrapper_path, actual_cwrapper_name);
3600
3601   /* wrapper name transforms */
3602   strendzap (actual_cwrapper_name, ".exe");
3603   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3604   XFREE (actual_cwrapper_name);
3605   actual_cwrapper_name = tmp_pathspec;
3606   tmp_pathspec = 0;
3607
3608   /* target_name transforms -- use actual target program name; might have lt- prefix */
3609   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3610   strendzap (target_name, ".exe");
3611   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3612   XFREE (target_name);
3613   target_name = tmp_pathspec;
3614   tmp_pathspec = 0;
3615
3616   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3617                           target_name));
3618 EOF
3619
3620             cat <<EOF
3621   newargz[0] =
3622     XMALLOC (char, (strlen (actual_cwrapper_path) +
3623                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3624   strcpy (newargz[0], actual_cwrapper_path);
3625   strcat (newargz[0], "$objdir");
3626   strcat (newargz[0], "/");
3627 EOF
3628
3629             cat <<"EOF"
3630   /* stop here, and copy so we don't have to do this twice */
3631   tmp_pathspec = xstrdup (newargz[0]);
3632
3633   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3634   strcat (newargz[0], actual_cwrapper_name);
3635
3636   /* DO want the lt- prefix here if it exists, so use target_name */
3637   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3638   XFREE (tmp_pathspec);
3639   tmp_pathspec = NULL;
3640 EOF
3641
3642             case $host_os in
3643               mingw*)
3644             cat <<"EOF"
3645   {
3646     char* p;
3647     while ((p = strchr (newargz[0], '\\')) != NULL)
3648       {
3649         *p = '/';
3650       }
3651     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3652       {
3653         *p = '/';
3654       }
3655   }
3656 EOF
3657             ;;
3658             esac
3659
3660             cat <<"EOF"
3661   XFREE (target_name);
3662   XFREE (actual_cwrapper_path);
3663   XFREE (actual_cwrapper_name);
3664
3665   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3666   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3667   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3668   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3669
3670   newargc=0;
3671   for (i = 1; i < argc; i++)
3672     {
3673       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3674         {
3675           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3676              namespace, but it is not one of the ones we know about and
3677              have already dealt with, above (inluding dump-script), then
3678              report an error. Otherwise, targets might begin to believe
3679              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3680              namespace. The first time any user complains about this, we'll
3681              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3682              or a configure.ac-settable value.
3683            */
3684           lt_fatal ("Unrecognized option in %s namespace: '%s'",
3685                     ltwrapper_option_prefix, argv[i]);
3686         }
3687       /* otherwise ... */
3688       newargz[++newargc] = xstrdup (argv[i]);
3689     }
3690   newargz[++newargc] = NULL;
3691
3692   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3693   for (i = 0; i < newargc; i++)
3694     {
3695       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3696     }
3697
3698 EOF
3699
3700             case $host_os in
3701               mingw*)
3702                 cat <<"EOF"
3703   /* execv doesn't actually work on mingw as expected on unix */
3704   newargz = prepare_spawn (newargz);
3705   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3706   if (rval == -1)
3707     {
3708       /* failed to start process */
3709       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3710       return 127;
3711     }
3712   return rval;
3713 EOF
3714                 ;;
3715               *)
3716                 cat <<"EOF"
3717   execv (lt_argv_zero, newargz);
3718   return rval; /* =127, but avoids unused variable warning */
3719 EOF
3720                 ;;
3721             esac
3722
3723             cat <<"EOF"
3724 }
3725
3726 void *
3727 xmalloc (size_t num)
3728 {
3729   void *p = (void *) malloc (num);
3730   if (!p)
3731     lt_fatal ("Memory exhausted");
3732
3733   return p;
3734 }
3735
3736 char *
3737 xstrdup (const char *string)
3738 {
3739   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3740                           string) : NULL;
3741 }
3742
3743 const char *
3744 base_name (const char *name)
3745 {
3746   const char *base;
3747
3748 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3749   /* Skip over the disk name in MSDOS pathnames. */
3750   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3751     name += 2;
3752 #endif
3753
3754   for (base = name; *name; name++)
3755     if (IS_DIR_SEPARATOR (*name))
3756       base = name + 1;
3757   return base;
3758 }
3759
3760 int
3761 check_executable (const char *path)
3762 {
3763   struct stat st;
3764
3765   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
3766                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3767   if ((!path) || (!*path))
3768     return 0;
3769
3770   if ((stat (path, &st) >= 0)
3771       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3772     return 1;
3773   else
3774     return 0;
3775 }
3776
3777 int
3778 make_executable (const char *path)
3779 {
3780   int rval = 0;
3781   struct stat st;
3782
3783   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
3784                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3785   if ((!path) || (!*path))
3786     return 0;
3787
3788   if (stat (path, &st) >= 0)
3789     {
3790       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3791     }
3792   return rval;
3793 }
3794
3795 /* Searches for the full path of the wrapper.  Returns
3796    newly allocated full path name if found, NULL otherwise
3797    Does not chase symlinks, even on platforms that support them.
3798 */
3799 char *
3800 find_executable (const char *wrapper)
3801 {
3802   int has_slash = 0;
3803   const char *p;
3804   const char *p_next;
3805   /* static buffer for getcwd */
3806   char tmp[LT_PATHMAX + 1];
3807   int tmp_len;
3808   char *concat_name;
3809
3810   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
3811                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3812
3813   if ((wrapper == NULL) || (*wrapper == '\0'))
3814     return NULL;
3815
3816   /* Absolute path? */
3817 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3818   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3819     {
3820       concat_name = xstrdup (wrapper);
3821       if (check_executable (concat_name))
3822         return concat_name;
3823       XFREE (concat_name);
3824     }
3825   else
3826     {
3827 #endif
3828       if (IS_DIR_SEPARATOR (wrapper[0]))
3829         {
3830           concat_name = xstrdup (wrapper);
3831           if (check_executable (concat_name))
3832             return concat_name;
3833           XFREE (concat_name);
3834         }
3835 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3836     }
3837 #endif
3838
3839   for (p = wrapper; *p; p++)
3840     if (*p == '/')
3841       {
3842         has_slash = 1;
3843         break;
3844       }
3845   if (!has_slash)
3846     {
3847       /* no slashes; search PATH */
3848       const char *path = getenv ("PATH");
3849       if (path != NULL)
3850         {
3851           for (p = path; *p; p = p_next)
3852             {
3853               const char *q;
3854               size_t p_len;
3855               for (q = p; *q; q++)
3856                 if (IS_PATH_SEPARATOR (*q))
3857                   break;
3858               p_len = q - p;
3859               p_next = (*q == '\0' ? q : q + 1);
3860               if (p_len == 0)
3861                 {
3862                   /* empty path: current directory */
3863                   if (getcwd (tmp, LT_PATHMAX) == NULL)
3864                     lt_fatal ("getcwd failed");
3865                   tmp_len = strlen (tmp);
3866                   concat_name =
3867                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3868                   memcpy (concat_name, tmp, tmp_len);
3869                   concat_name[tmp_len] = '/';
3870                   strcpy (concat_name + tmp_len + 1, wrapper);
3871                 }
3872               else
3873                 {
3874                   concat_name =
3875                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3876                   memcpy (concat_name, p, p_len);
3877                   concat_name[p_len] = '/';
3878                   strcpy (concat_name + p_len + 1, wrapper);
3879                 }
3880               if (check_executable (concat_name))
3881                 return concat_name;
3882               XFREE (concat_name);
3883             }
3884         }
3885       /* not found in PATH; assume curdir */
3886     }
3887   /* Relative path | not found in path: prepend cwd */
3888   if (getcwd (tmp, LT_PATHMAX) == NULL)
3889     lt_fatal ("getcwd failed");
3890   tmp_len = strlen (tmp);
3891   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3892   memcpy (concat_name, tmp, tmp_len);
3893   concat_name[tmp_len] = '/';
3894   strcpy (concat_name + tmp_len + 1, wrapper);
3895
3896   if (check_executable (concat_name))
3897     return concat_name;
3898   XFREE (concat_name);
3899   return NULL;
3900 }
3901
3902 char *
3903 chase_symlinks (const char *pathspec)
3904 {
3905 #ifndef S_ISLNK
3906   return xstrdup (pathspec);
3907 #else
3908   char buf[LT_PATHMAX];
3909   struct stat s;
3910   char *tmp_pathspec = xstrdup (pathspec);
3911   char *p;
3912   int has_symlinks = 0;
3913   while (strlen (tmp_pathspec) && !has_symlinks)
3914     {
3915       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3916                               tmp_pathspec));
3917       if (lstat (tmp_pathspec, &s) == 0)
3918         {
3919           if (S_ISLNK (s.st_mode) != 0)
3920             {
3921               has_symlinks = 1;
3922               break;
3923             }
3924
3925           /* search backwards for last DIR_SEPARATOR */
3926           p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3927           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3928             p--;
3929           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3930             {
3931               /* no more DIR_SEPARATORS left */
3932               break;
3933             }
3934           *p = '\0';
3935         }
3936       else
3937         {
3938           char *errstr = strerror (errno);
3939           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3940         }
3941     }
3942   XFREE (tmp_pathspec);
3943
3944   if (!has_symlinks)
3945     {
3946       return xstrdup (pathspec);
3947     }
3948
3949   tmp_pathspec = realpath (pathspec, buf);
3950   if (tmp_pathspec == 0)
3951     {
3952       lt_fatal ("Could not follow symlinks for %s", pathspec);
3953     }
3954   return xstrdup (tmp_pathspec);
3955 #endif
3956 }
3957
3958 char *
3959 strendzap (char *str, const char *pat)
3960 {
3961   size_t len, patlen;
3962
3963   assert (str != NULL);
3964   assert (pat != NULL);
3965
3966   len = strlen (str);
3967   patlen = strlen (pat);
3968
3969   if (patlen <= len)
3970     {
3971       str += len - patlen;
3972       if (strcmp (str, pat) == 0)
3973         *str = '\0';
3974     }
3975   return str;
3976 }
3977
3978 static void
3979 lt_error_core (int exit_status, const char *mode,
3980                const char *message, va_list ap)
3981 {
3982   fprintf (stderr, "%s: %s: ", program_name, mode);
3983   vfprintf (stderr, message, ap);
3984   fprintf (stderr, ".\n");
3985
3986   if (exit_status >= 0)
3987     exit (exit_status);
3988 }
3989
3990 void
3991 lt_fatal (const char *message, ...)
3992 {
3993   va_list ap;
3994   va_start (ap, message);
3995   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3996   va_end (ap);
3997 }
3998
3999 void
4000 lt_setenv (const char *name, const char *value)
4001 {
4002   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4003                           (name ? name : "<NULL>"),
4004                           (value ? value : "<NULL>")));
4005   {
4006 #ifdef HAVE_SETENV
4007     /* always make a copy, for consistency with !HAVE_SETENV */
4008     char *str = xstrdup (value);
4009     setenv (name, str, 1);
4010 #else
4011     int len = strlen (name) + 1 + strlen (value) + 1;
4012     char *str = XMALLOC (char, len);
4013     sprintf (str, "%s=%s", name, value);
4014     if (putenv (str) != EXIT_SUCCESS)
4015       {
4016         XFREE (str);
4017       }
4018 #endif
4019   }
4020 }
4021
4022 char *
4023 lt_extend_str (const char *orig_value, const char *add, int to_end)
4024 {
4025   char *new_value;
4026   if (orig_value && *orig_value)
4027     {
4028       int orig_value_len = strlen (orig_value);
4029       int add_len = strlen (add);
4030       new_value = XMALLOC (char, add_len + orig_value_len + 1);
4031       if (to_end)
4032         {
4033           strcpy (new_value, orig_value);
4034           strcpy (new_value + orig_value_len, add);
4035         }
4036       else
4037         {
4038           strcpy (new_value, add);
4039           strcpy (new_value + add_len, orig_value);
4040         }
4041     }
4042   else
4043     {
4044       new_value = xstrdup (add);
4045     }
4046   return new_value;
4047 }
4048
4049 void
4050 lt_update_exe_path (const char *name, const char *value)
4051 {
4052   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4053                           (name ? name : "<NULL>"),
4054                           (value ? value : "<NULL>")));
4055
4056   if (name && *name && value && *value)
4057     {
4058       char *new_value = lt_extend_str (getenv (name), value, 0);
4059       /* some systems can't cope with a ':'-terminated path #' */
4060       int len = strlen (new_value);
4061       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4062         {
4063           new_value[len-1] = '\0';
4064         }
4065       lt_setenv (name, new_value);
4066       XFREE (new_value);
4067     }
4068 }
4069
4070 void
4071 lt_update_lib_path (const char *name, const char *value)
4072 {
4073   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4074                           (name ? name : "<NULL>"),
4075                           (value ? value : "<NULL>")));
4076
4077   if (name && *name && value && *value)
4078     {
4079       char *new_value = lt_extend_str (getenv (name), value, 0);
4080       lt_setenv (name, new_value);
4081       XFREE (new_value);
4082     }
4083 }
4084
4085 EOF
4086             case $host_os in
4087               mingw*)
4088                 cat <<"EOF"
4089
4090 /* Prepares an argument vector before calling spawn().
4091    Note that spawn() does not by itself call the command interpreter
4092      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4093       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4094          GetVersionEx(&v);
4095          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4096       }) ? "cmd.exe" : "command.com").
4097    Instead it simply concatenates the arguments, separated by ' ', and calls
4098    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4099    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4100    special way:
4101    - Space and tab are interpreted as delimiters. They are not treated as
4102      delimiters if they are surrounded by double quotes: "...".
4103    - Unescaped double quotes are removed from the input. Their only effect is
4104      that within double quotes, space and tab are treated like normal
4105      characters.
4106    - Backslashes not followed by double quotes are not special.
4107    - But 2*n+1 backslashes followed by a double quote become
4108      n backslashes followed by a double quote (n >= 0):
4109        \" -> "
4110        \\\" -> \"
4111        \\\\\" -> \\"
4112  */
4113 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4114 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4115 char **
4116 prepare_spawn (char **argv)
4117 {
4118   size_t argc;
4119   char **new_argv;
4120   size_t i;
4121
4122   /* Count number of arguments.  */
4123   for (argc = 0; argv[argc] != NULL; argc++)
4124     ;
4125
4126   /* Allocate new argument vector.  */
4127   new_argv = XMALLOC (char *, argc + 1);
4128
4129   /* Put quoted arguments into the new argument vector.  */
4130   for (i = 0; i < argc; i++)
4131     {
4132       const char *string = argv[i];
4133
4134       if (string[0] == '\0')
4135         new_argv[i] = xstrdup ("\"\"");
4136       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4137         {
4138           int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4139           size_t length;
4140           unsigned int backslashes;
4141           const char *s;
4142           char *quoted_string;
4143           char *p;
4144
4145           length = 0;
4146           backslashes = 0;
4147           if (quote_around)
4148             length++;
4149           for (s = string; *s != '\0'; s++)
4150             {
4151               char c = *s;
4152               if (c == '"')
4153                 length += backslashes + 1;
4154               length++;
4155               if (c == '\\')
4156                 backslashes++;
4157               else
4158                 backslashes = 0;
4159             }
4160           if (quote_around)
4161             length += backslashes + 1;
4162
4163           quoted_string = XMALLOC (char, length + 1);
4164
4165           p = quoted_string;
4166           backslashes = 0;
4167           if (quote_around)
4168             *p++ = '"';
4169           for (s = string; *s != '\0'; s++)
4170             {
4171               char c = *s;
4172               if (c == '"')
4173                 {
4174                   unsigned int j;
4175                   for (j = backslashes + 1; j > 0; j--)
4176                     *p++ = '\\';
4177                 }
4178               *p++ = c;
4179               if (c == '\\')
4180                 backslashes++;
4181               else
4182                 backslashes = 0;
4183             }
4184           if (quote_around)
4185             {
4186               unsigned int j;
4187               for (j = backslashes; j > 0; j--)
4188                 *p++ = '\\';
4189               *p++ = '"';
4190             }
4191           *p = '\0';
4192
4193           new_argv[i] = quoted_string;
4194         }
4195       else
4196         new_argv[i] = (char *) string;
4197     }
4198   new_argv[argc] = NULL;
4199
4200   return new_argv;
4201 }
4202 EOF
4203                 ;;
4204             esac
4205
4206             cat <<"EOF"
4207 void lt_dump_script (FILE* f)
4208 {
4209 EOF
4210             func_emit_wrapper yes |
4211               $SED -e 's/\([\\"]\)/\\\1/g' \
4212                    -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
4213
4214             cat <<"EOF"
4215 }
4216 EOF
4217 }
4218 # end: func_emit_cwrapperexe_src
4219
4220 # func_win32_import_lib_p ARG
4221 # True if ARG is an import lib, as indicated by $file_magic_cmd
4222 func_win32_import_lib_p ()
4223 {
4224     $opt_debug
4225     case `eval "$file_magic_cmd \"\$1\" 2>/dev/null" | $SED -e 10q` in
4226     *import*) : ;;
4227     *) false ;;
4228     esac
4229 }
4230
4231 # func_mode_link arg...
4232 func_mode_link ()
4233 {
4234     $opt_debug
4235     case $host in
4236     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4237       # It is impossible to link a dll without this setting, and
4238       # we shouldn't force the makefile maintainer to figure out
4239       # which system we are compiling for in order to pass an extra
4240       # flag for every libtool invocation.
4241       # allow_undefined=no
4242
4243       # FIXME: Unfortunately, there are problems with the above when trying
4244       # to make a dll which has undefined symbols, in which case not
4245       # even a static library is built.  For now, we need to specify
4246       # -no-undefined on the libtool link line when we can be certain
4247       # that all symbols are satisfied, otherwise we get a static library.
4248       allow_undefined=yes
4249       ;;
4250     *)
4251       allow_undefined=yes
4252       ;;
4253     esac
4254     libtool_args=$nonopt
4255     base_compile="$nonopt $@"
4256     compile_command=$nonopt
4257     finalize_command=$nonopt
4258
4259     compile_rpath=
4260     finalize_rpath=
4261     compile_shlibpath=
4262     finalize_shlibpath=
4263     convenience=
4264     old_convenience=
4265     deplibs=
4266     old_deplibs=
4267     compiler_flags=
4268     linker_flags=
4269     dllsearchpath=
4270     lib_search_path=`pwd`
4271     inst_prefix_dir=
4272     new_inherited_linker_flags=
4273
4274     avoid_version=no
4275     bindir=
4276     dlfiles=
4277     dlprefiles=
4278     dlself=no
4279     export_dynamic=no
4280     export_symbols=
4281     export_symbols_regex=
4282     generated=
4283     libobjs=
4284     ltlibs=
4285     module=no
4286     no_install=no
4287     objs=
4288     non_pic_objects=
4289     precious_files_regex=
4290     prefer_static_libs=no
4291     preload=no
4292     prev=
4293     prevarg=
4294     release=
4295     rpath=
4296     xrpath=
4297     perm_rpath=
4298     temp_rpath=
4299     thread_safe=no
4300     vinfo=
4301     vinfo_number=no
4302     weak_libs=
4303     single_module="${wl}-single_module"
4304     func_infer_tag $base_compile
4305
4306     # We need to know -static, to get the right output filenames.
4307     for arg
4308     do
4309       case $arg in
4310       -shared)
4311         test "$build_libtool_libs" != yes && \
4312           func_fatal_configuration "can not build a shared library"
4313         build_old_libs=no
4314         break
4315         ;;
4316       -all-static | -static | -static-libtool-libs)
4317         case $arg in
4318         -all-static)
4319           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4320             func_warning "complete static linking is impossible in this configuration"
4321           fi
4322           if test -n "$link_static_flag"; then
4323             dlopen_self=$dlopen_self_static
4324           fi
4325           prefer_static_libs=yes
4326           ;;
4327         -static)
4328           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4329             dlopen_self=$dlopen_self_static
4330           fi
4331           prefer_static_libs=built
4332           ;;
4333         -static-libtool-libs)
4334           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4335             dlopen_self=$dlopen_self_static
4336           fi
4337           prefer_static_libs=yes
4338           ;;
4339         esac
4340         build_libtool_libs=no
4341         build_old_libs=yes
4342         break
4343         ;;
4344       esac
4345     done
4346
4347     # See if our shared archives depend on static archives.
4348     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4349
4350     # Go through the arguments, transforming them on the way.
4351     while test "$#" -gt 0; do
4352       arg="$1"
4353       shift
4354       func_quote_for_eval "$arg"
4355       qarg=$func_quote_for_eval_unquoted_result
4356       func_append libtool_args " $func_quote_for_eval_result"
4357
4358       # If the previous option needs an argument, assign it.
4359       if test -n "$prev"; then
4360         case $prev in
4361         output)
4362           func_append compile_command " @OUTPUT@"
4363           func_append finalize_command " @OUTPUT@"
4364           ;;
4365         esac
4366
4367         case $prev in
4368         bindir)
4369           bindir="$arg"
4370           prev=
4371           continue
4372           ;;
4373         dlfiles|dlprefiles)
4374           if test "$preload" = no; then
4375             # Add the symbol object into the linking commands.
4376             func_append compile_command " @SYMFILE@"
4377             func_append finalize_command " @SYMFILE@"
4378             preload=yes
4379           fi
4380           case $arg in
4381           *.la | *.lo) ;;  # We handle these cases below.
4382           force)
4383             if test "$dlself" = no; then
4384               dlself=needless
4385               export_dynamic=yes
4386             fi
4387             prev=
4388             continue
4389             ;;
4390           self)
4391             if test "$prev" = dlprefiles; then
4392               dlself=yes
4393             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4394               dlself=yes
4395             else
4396               dlself=needless
4397               export_dynamic=yes
4398             fi
4399             prev=
4400             continue
4401             ;;
4402           *)
4403             if test "$prev" = dlfiles; then
4404               dlfiles="$dlfiles $arg"
4405             else
4406               dlprefiles="$dlprefiles $arg"
4407             fi
4408             prev=
4409             continue
4410             ;;
4411           esac
4412           ;;
4413         expsyms)
4414           export_symbols="$arg"
4415           test -f "$arg" \
4416             || func_fatal_error "symbol file \`$arg' does not exist"
4417           prev=
4418           continue
4419           ;;
4420         expsyms_regex)
4421           export_symbols_regex="$arg"
4422           prev=
4423           continue
4424           ;;
4425         framework)
4426           case $host in
4427             *-*-darwin*)
4428               case "$deplibs " in
4429                 *" $qarg.ltframework "*) ;;
4430                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4431                    ;;
4432               esac
4433               ;;
4434           esac
4435           prev=
4436           continue
4437           ;;
4438         inst_prefix)
4439           inst_prefix_dir="$arg"
4440           prev=
4441           continue
4442           ;;
4443         objectlist)
4444           if test -f "$arg"; then
4445             save_arg=$arg
4446             moreargs=
4447             for fil in `cat "$save_arg"`
4448             do
4449 #             moreargs="$moreargs $fil"
4450               arg=$fil
4451               # A libtool-controlled object.
4452
4453               # Check to see that this really is a libtool object.
4454               if func_lalib_unsafe_p "$arg"; then
4455                 pic_object=
4456                 non_pic_object=
4457
4458                 # Read the .lo file
4459                 func_source "$arg"
4460
4461                 if test -z "$pic_object" ||
4462                    test -z "$non_pic_object" ||
4463                    test "$pic_object" = none &&
4464                    test "$non_pic_object" = none; then
4465                   func_fatal_error "cannot find name of object for \`$arg'"
4466                 fi
4467
4468                 # Extract subdirectory from the argument.
4469                 func_dirname "$arg" "/" ""
4470                 xdir="$func_dirname_result"
4471
4472                 if test "$pic_object" != none; then
4473                   # Prepend the subdirectory the object is found in.
4474                   pic_object="$xdir$pic_object"
4475
4476                   if test "$prev" = dlfiles; then
4477                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4478                       dlfiles="$dlfiles $pic_object"
4479                       prev=
4480                       continue
4481                     else
4482                       # If libtool objects are unsupported, then we need to preload.
4483                       prev=dlprefiles
4484                     fi
4485                   fi
4486
4487                   # CHECK ME:  I think I busted this.  -Ossama
4488                   if test "$prev" = dlprefiles; then
4489                     # Preload the old-style object.
4490                     dlprefiles="$dlprefiles $pic_object"
4491                     prev=
4492                   fi
4493
4494                   # A PIC object.
4495                   func_append libobjs " $pic_object"
4496                   arg="$pic_object"
4497                 fi
4498
4499                 # Non-PIC object.
4500                 if test "$non_pic_object" != none; then
4501                   # Prepend the subdirectory the object is found in.
4502                   non_pic_object="$xdir$non_pic_object"
4503
4504                   # A standard non-PIC object
4505                   func_append non_pic_objects " $non_pic_object"
4506                   if test -z "$pic_object" || test "$pic_object" = none ; then
4507                     arg="$non_pic_object"
4508                   fi
4509                 else
4510                   # If the PIC object exists, use it instead.
4511                   # $xdir was prepended to $pic_object above.
4512                   non_pic_object="$pic_object"
4513                   func_append non_pic_objects " $non_pic_object"
4514                 fi
4515               else
4516                 # Only an error if not doing a dry-run.
4517                 if $opt_dry_run; then
4518                   # Extract subdirectory from the argument.
4519                   func_dirname "$arg" "/" ""
4520                   xdir="$func_dirname_result"
4521
4522                   func_lo2o "$arg"
4523                   pic_object=$xdir$objdir/$func_lo2o_result
4524                   non_pic_object=$xdir$func_lo2o_result
4525                   func_append libobjs " $pic_object"
4526                   func_append non_pic_objects " $non_pic_object"
4527                 else
4528                   func_fatal_error "\`$arg' is not a valid libtool object"
4529                 fi
4530               fi
4531             done
4532           else
4533             func_fatal_error "link input file \`$arg' does not exist"
4534           fi
4535           arg=$save_arg
4536           prev=
4537           continue
4538           ;;
4539         precious_regex)
4540           precious_files_regex="$arg"
4541           prev=
4542           continue
4543           ;;
4544         release)
4545           release="-$arg"
4546           prev=
4547           continue
4548           ;;
4549         rpath | xrpath)
4550           # We need an absolute path.
4551           case $arg in
4552           [\\/]* | [A-Za-z]:[\\/]*) ;;
4553           *)
4554             func_fatal_error "only absolute run-paths are allowed"
4555             ;;
4556           esac
4557           if test "$prev" = rpath; then
4558             case "$rpath " in
4559             *" $arg "*) ;;
4560             *) rpath="$rpath $arg" ;;
4561             esac
4562           else
4563             case "$xrpath " in
4564             *" $arg "*) ;;
4565             *) xrpath="$xrpath $arg" ;;
4566             esac
4567           fi
4568           prev=
4569           continue
4570           ;;
4571         shrext)
4572           shrext_cmds="$arg"
4573           prev=
4574           continue
4575           ;;
4576         weak)
4577           weak_libs="$weak_libs $arg"
4578           prev=
4579           continue
4580           ;;
4581         xcclinker)
4582           linker_flags="$linker_flags $qarg"
4583           compiler_flags="$compiler_flags $qarg"
4584           prev=
4585           func_append compile_command " $qarg"
4586           func_append finalize_command " $qarg"
4587           continue
4588           ;;
4589         xcompiler)
4590           compiler_flags="$compiler_flags $qarg"
4591           prev=
4592           func_append compile_command " $qarg"
4593           func_append finalize_command " $qarg"
4594           continue
4595           ;;
4596         xlinker)
4597           linker_flags="$linker_flags $qarg"
4598           compiler_flags="$compiler_flags $wl$qarg"
4599           prev=
4600           func_append compile_command " $wl$qarg"
4601           func_append finalize_command " $wl$qarg"
4602           continue
4603           ;;
4604         *)
4605           eval "$prev=\"\$arg\""
4606           prev=
4607           continue
4608           ;;
4609         esac
4610       fi # test -n "$prev"
4611
4612       prevarg="$arg"
4613
4614       case $arg in
4615       -all-static)
4616         if test -n "$link_static_flag"; then
4617           # See comment for -static flag below, for more details.
4618           func_append compile_command " $link_static_flag"
4619           func_append finalize_command " $link_static_flag"
4620         fi
4621         continue
4622         ;;
4623
4624       -allow-undefined)
4625         # FIXME: remove this flag sometime in the future.
4626         func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4627         ;;
4628
4629       -avoid-version)
4630         avoid_version=yes
4631         continue
4632         ;;
4633
4634       -bindir)
4635         prev=bindir
4636         continue
4637         ;;
4638
4639       -dlopen)
4640         prev=dlfiles
4641         continue
4642         ;;
4643
4644       -dlpreopen)
4645         prev=dlprefiles
4646         continue
4647         ;;
4648
4649       -export-dynamic)
4650         export_dynamic=yes
4651         continue
4652         ;;
4653
4654       -export-symbols | -export-symbols-regex)
4655         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4656           func_fatal_error "more than one -exported-symbols argument is not allowed"
4657         fi
4658         if test "X$arg" = "X-export-symbols"; then
4659           prev=expsyms
4660         else
4661           prev=expsyms_regex
4662         fi
4663         continue
4664         ;;
4665
4666       -framework)
4667         prev=framework
4668         continue
4669         ;;
4670
4671       -inst-prefix-dir)
4672         prev=inst_prefix
4673         continue
4674         ;;
4675
4676       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4677       # so, if we see these flags be careful not to treat them like -L
4678       -L[A-Z][A-Z]*:*)
4679         case $with_gcc/$host in
4680         no/*-*-irix* | /*-*-irix*)
4681           func_append compile_command " $arg"
4682           func_append finalize_command " $arg"
4683           ;;
4684         esac
4685         continue
4686         ;;
4687
4688       -L*)
4689         func_stripname '-L' '' "$arg"
4690         dir=$func_stripname_result
4691         if test -z "$dir"; then
4692           if test "$#" -gt 0; then
4693             func_fatal_error "require no space between \`-L' and \`$1'"
4694           else
4695             func_fatal_error "need path for \`-L' option"
4696           fi
4697         fi
4698         # We need an absolute path.
4699         case $dir in
4700         [\\/]* | [A-Za-z]:[\\/]*) ;;
4701         *)
4702           absdir=`cd "$dir" && pwd`
4703           test -z "$absdir" && \
4704             func_fatal_error "cannot determine absolute directory name of \`$dir'"
4705           dir="$absdir"
4706           ;;
4707         esac
4708         case "$deplibs " in
4709         *" -L$dir "*) ;;
4710         *)
4711           deplibs="$deplibs -L$dir"
4712           lib_search_path="$lib_search_path $dir"
4713           ;;
4714         esac
4715         case $host in
4716         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4717           testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4718           case :$dllsearchpath: in
4719           *":$dir:"*) ;;
4720           ::) dllsearchpath=$dir;;
4721           *) dllsearchpath="$dllsearchpath:$dir";;
4722           esac
4723           case :$dllsearchpath: in
4724           *":$testbindir:"*) ;;
4725           ::) dllsearchpath=$testbindir;;
4726           *) dllsearchpath="$dllsearchpath:$testbindir";;
4727           esac
4728           ;;
4729         esac
4730         continue
4731         ;;
4732
4733       -l*)
4734         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4735           case $host in
4736           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4737             # These systems don't actually have a C or math library (as such)
4738             continue
4739             ;;
4740           *-*-os2*)
4741             # These systems don't actually have a C library (as such)
4742             test "X$arg" = "X-lc" && continue
4743             ;;
4744           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4745             # Do not include libc due to us having libc/libc_r.
4746             test "X$arg" = "X-lc" && continue
4747             ;;
4748           *-*-rhapsody* | *-*-darwin1.[012])
4749             # Rhapsody C and math libraries are in the System framework
4750             deplibs="$deplibs System.ltframework"
4751             continue
4752             ;;
4753           *-*-sco3.2v5* | *-*-sco5v6*)
4754             # Causes problems with __ctype
4755             test "X$arg" = "X-lc" && continue
4756             ;;
4757           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4758             # Compiler inserts libc in the correct place for threads to work
4759             test "X$arg" = "X-lc" && continue
4760             ;;
4761           *-*-linux*)
4762             test "X$arg" = "X-lc" && continue
4763             ;;
4764           esac
4765         elif test "X$arg" = "X-lc_r"; then
4766          case $host in
4767          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4768            # Do not include libc_r directly, use -pthread flag.
4769            continue
4770            ;;
4771          esac
4772         fi
4773         deplibs="$deplibs $arg"
4774         continue
4775         ;;
4776
4777       -module)
4778         module=yes
4779         continue
4780         ;;
4781
4782       # Tru64 UNIX uses -model [arg] to determine the layout of C++
4783       # classes, name mangling, and exception handling.
4784       # Darwin uses the -arch flag to determine output architecture.
4785       -model|-arch|-isysroot)
4786         compiler_flags="$compiler_flags $arg"
4787         func_append compile_command " $arg"
4788         func_append finalize_command " $arg"
4789         prev=xcompiler
4790         continue
4791         ;;
4792
4793       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4794         compiler_flags="$compiler_flags $arg"
4795         func_append compile_command " $arg"
4796         func_append finalize_command " $arg"
4797         case "$new_inherited_linker_flags " in
4798             *" $arg "*) ;;
4799             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4800         esac
4801         continue
4802         ;;
4803
4804       -multi_module)
4805         single_module="${wl}-multi_module"
4806         continue
4807         ;;
4808
4809       -no-fast-install)
4810         fast_install=no
4811         continue
4812         ;;
4813
4814       -no-install)
4815         case $host in
4816         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4817           # The PATH hackery in wrapper scripts is required on Windows
4818           # and Darwin in order for the loader to find any dlls it needs.
4819           func_warning "\`-no-install' is ignored for $host"
4820           func_warning "assuming \`-no-fast-install' instead"
4821           fast_install=no
4822           ;;
4823         *) no_install=yes ;;
4824         esac
4825         continue
4826         ;;
4827
4828       -no-undefined)
4829         allow_undefined=no
4830         continue
4831         ;;
4832
4833       -objectlist)
4834         prev=objectlist
4835         continue
4836         ;;
4837
4838       -o) prev=output ;;
4839
4840       -precious-files-regex)
4841         prev=precious_regex
4842         continue
4843         ;;
4844
4845       -release)
4846         prev=release
4847         continue
4848         ;;
4849
4850       -rpath)
4851         prev=rpath
4852         continue
4853         ;;
4854
4855       -R)
4856         prev=xrpath
4857         continue
4858         ;;
4859
4860       -R*)
4861         func_stripname '-R' '' "$arg"
4862         dir=$func_stripname_result
4863         # We need an absolute path.
4864         case $dir in
4865         [\\/]* | [A-Za-z]:[\\/]*) ;;
4866         *)
4867           func_fatal_error "only absolute run-paths are allowed"
4868           ;;
4869         esac
4870         case "$xrpath " in
4871         *" $dir "*) ;;
4872         *) xrpath="$xrpath $dir" ;;
4873         esac
4874         continue
4875         ;;
4876
4877       -shared)
4878         # The effects of -shared are defined in a previous loop.
4879         continue
4880         ;;
4881
4882       -shrext)
4883         prev=shrext
4884         continue
4885         ;;
4886
4887       -static | -static-libtool-libs)
4888         # The effects of -static are defined in a previous loop.
4889         # We used to do the same as -all-static on platforms that
4890         # didn't have a PIC flag, but the assumption that the effects
4891         # would be equivalent was wrong.  It would break on at least
4892         # Digital Unix and AIX.
4893         continue
4894         ;;
4895
4896       -thread-safe)
4897         thread_safe=yes
4898         continue
4899         ;;
4900
4901       -version-info)
4902         prev=vinfo
4903         continue
4904         ;;
4905
4906       -version-number)
4907         prev=vinfo
4908         vinfo_number=yes
4909         continue
4910         ;;
4911
4912       -weak)
4913         prev=weak
4914         continue
4915         ;;
4916
4917       -Wc,*)
4918         func_stripname '-Wc,' '' "$arg"
4919         args=$func_stripname_result
4920         arg=
4921         save_ifs="$IFS"; IFS=','
4922         for flag in $args; do
4923           IFS="$save_ifs"
4924           func_quote_for_eval "$flag"
4925           arg="$arg $func_quote_for_eval_result"
4926           compiler_flags="$compiler_flags $func_quote_for_eval_result"
4927         done
4928         IFS="$save_ifs"
4929         func_stripname ' ' '' "$arg"
4930         arg=$func_stripname_result
4931         ;;
4932
4933       -Wl,*)
4934         func_stripname '-Wl,' '' "$arg"
4935         args=$func_stripname_result
4936         arg=
4937         save_ifs="$IFS"; IFS=','
4938         for flag in $args; do
4939           IFS="$save_ifs"
4940           func_quote_for_eval "$flag"
4941           arg="$arg $wl$func_quote_for_eval_result"
4942           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4943           linker_flags="$linker_flags $func_quote_for_eval_result"
4944         done
4945         IFS="$save_ifs"
4946         func_stripname ' ' '' "$arg"
4947         arg=$func_stripname_result
4948         ;;
4949
4950       -Xcompiler)
4951         prev=xcompiler
4952         continue
4953         ;;
4954
4955       -Xlinker)
4956         prev=xlinker
4957         continue
4958         ;;
4959
4960       -XCClinker)
4961         prev=xcclinker
4962         continue
4963         ;;
4964
4965       # -msg_* for osf cc
4966       -msg_*)
4967         func_quote_for_eval "$arg"
4968         arg="$func_quote_for_eval_result"
4969         ;;
4970
4971       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4972       # -r[0-9][0-9]* specifies the processor on the SGI compiler
4973       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4974       # +DA*, +DD* enable 64-bit mode on the HP compiler
4975       # -q* pass through compiler args for the IBM compiler
4976       # -m*, -t[45]*, -txscale* pass through architecture-specific
4977       # compiler args for GCC
4978       # -F/path gives path to uninstalled frameworks, gcc on darwin
4979       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4980       # @file GCC response files
4981       # -tp=* Portland pgcc target processor selection
4982       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4983       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
4984         func_quote_for_eval "$arg"
4985         arg="$func_quote_for_eval_result"
4986         func_append compile_command " $arg"
4987         func_append finalize_command " $arg"
4988         compiler_flags="$compiler_flags $arg"
4989         continue
4990         ;;
4991
4992       # Some other compiler flag.
4993       -* | +*)
4994         func_quote_for_eval "$arg"
4995         arg="$func_quote_for_eval_result"
4996         ;;
4997
4998       *.$objext)
4999         # A standard object.
5000         objs="$objs $arg"
5001         ;;
5002
5003       *.lo)
5004         # A libtool-controlled object.
5005
5006         # Check to see that this really is a libtool object.
5007         if func_lalib_unsafe_p "$arg"; then
5008           pic_object=
5009           non_pic_object=
5010
5011           # Read the .lo file
5012           func_source "$arg"
5013
5014           if test -z "$pic_object" ||
5015              test -z "$non_pic_object" ||
5016              test "$pic_object" = none &&
5017              test "$non_pic_object" = none; then
5018             func_fatal_error "cannot find name of object for \`$arg'"
5019           fi
5020
5021           # Extract subdirectory from the argument.
5022           func_dirname "$arg" "/" ""
5023           xdir="$func_dirname_result"
5024
5025           if test "$pic_object" != none; then
5026             # Prepend the subdirectory the object is found in.
5027             pic_object="$xdir$pic_object"
5028
5029             if test "$prev" = dlfiles; then
5030               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5031                 dlfiles="$dlfiles $pic_object"
5032                 prev=
5033                 continue
5034               else
5035                 # If libtool objects are unsupported, then we need to preload.
5036                 prev=dlprefiles
5037               fi
5038             fi
5039
5040             # CHECK ME:  I think I busted this.  -Ossama
5041             if test "$prev" = dlprefiles; then
5042               # Preload the old-style object.
5043               dlprefiles="$dlprefiles $pic_object"
5044               prev=
5045             fi
5046
5047             # A PIC object.
5048             func_append libobjs " $pic_object"
5049             arg="$pic_object"
5050           fi
5051
5052           # Non-PIC object.
5053           if test "$non_pic_object" != none; then
5054             # Prepend the subdirectory the object is found in.
5055             non_pic_object="$xdir$non_pic_object"
5056
5057             # A standard non-PIC object
5058             func_append non_pic_objects " $non_pic_object"
5059             if test -z "$pic_object" || test "$pic_object" = none ; then
5060               arg="$non_pic_object"