Update test now sub ticks property is no more ignored
[scilab.git] / scilab / config / ltmain.sh
1 # Generated from ltmain.m4sh.
2
3 # libtool (GNU libtool 1.3121 2009-09-18) 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 #       --preserve-dup-deps  don't remove duplicate dependency libraries
42 #       --quiet, --silent    don't print informational messages
43 #       --no-quiet, --no-silent
44 #                            print informational messages (default)
45 #       --tag=TAG            use configuration variables from tag TAG
46 #   -v, --verbose            print more informational messages than default
47 #       --no-verbose         don't print the extra informational messages
48 #       --version            print version information
49 #   -h, --help, --help-all   print short, long, or detailed help message
50 #
51 # MODE must be one of the following:
52 #
53 #         clean              remove files from the build directory
54 #         compile            compile a source file into a libtool object
55 #         execute            automatically set library path, then run a program
56 #         finish             complete the installation of libtool libraries
57 #         install            install libraries or executables
58 #         link               create a library or an executable
59 #         uninstall          remove libraries from an installed directory
60 #
61 # MODE-ARGS vary depending on the MODE.  When passed as first option,
62 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
63 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64 #
65 # When reporting a bug, please describe a test case to reproduce it and
66 # include the following information:
67 #
68 #         host-triplet: $host
69 #         shell:                $SHELL
70 #         compiler:             $LTCC
71 #         compiler flags:               $LTCFLAGS
72 #         linker:               $LD (gnu? $with_gnu_ld)
73 #         $progname:    (GNU libtool 1.3121 2009-09-18) 2.2.7a
74 #         automake:     $automake_version
75 #         autoconf:     $autoconf_version
76 #
77 # Report bugs to <bug-libtool@gnu.org>.
78
79 PROGRAM=libtool
80 PACKAGE=libtool
81 VERSION=2.2.7a
82 TIMESTAMP=" 1.3121 2009-09-18"
83 package_revision=1.3121
84
85 # Be Bourne compatible
86 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
87   emulate sh
88   NULLCMD=:
89   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
90   # is contrary to our usage.  Disable this feature.
91   alias -g '${1+"$@"}'='"$@"'
92   setopt NO_GLOB_SUBST
93 else
94   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
95 fi
96 BIN_SH=xpg4; export BIN_SH # for Tru64
97 DUALCASE=1; export DUALCASE # for MKS sh
98
99 # A function that is used when there is no print builtin or printf.
100 func_fallback_echo ()
101 {
102   eval 'cat <<_LTECHO_EOF
103 $1
104 _LTECHO_EOF'
105 }
106
107 # NLS nuisances: We save the old values to restore during execute mode.
108 # Only set LANG and LC_ALL to C if already set.
109 # These must not be set unconditionally because not all systems understand
110 # e.g. LANG=C (notably SCO).
111 lt_user_locale=
112 lt_safe_locale=
113 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
114 do
115   eval "if test \"\${$lt_var+set}\" = set; then
116           save_$lt_var=\$$lt_var
117           $lt_var=C
118           export $lt_var
119           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
120           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
121         fi"
122 done
123
124 $lt_unset CDPATH
125
126
127
128
129
130
131
132 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
133 # is ksh but when the shell is invoked as "sh" and the current value of
134 # the _XPG environment variable is not equal to 1 (one), the special
135 # positional parameter $0, within a function call, is the name of the
136 # function.
137 progpath="$0"
138
139
140
141 : ${CP="cp -f"}
142 : ${ECHO=$as_echo}
143 : ${EGREP="/bin/grep -E"}
144 : ${FGREP="/bin/grep -F"}
145 : ${GREP="/bin/grep"}
146 : ${LN_S="ln -s"}
147 : ${MAKE="make"}
148 : ${MKDIR="mkdir"}
149 : ${MV="mv -f"}
150 : ${RM="rm -f"}
151 : ${SED="/bin/sed"}
152 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
153 : ${Xsed="$SED -e 1s/^X//"}
154
155 # Global variables:
156 EXIT_SUCCESS=0
157 EXIT_FAILURE=1
158 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
159 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
160
161 exit_status=$EXIT_SUCCESS
162
163 # Make sure IFS has a sensible default
164 lt_nl='
165 '
166 IFS="   $lt_nl"
167
168 dirname="s,/[^/]*$,,"
169 basename="s,^.*/,,"
170
171 # func_dirname_and_basename file append nondir_replacement
172 # perform func_basename and func_dirname in a single function
173 # call:
174 #   dirname:  Compute the dirname of FILE.  If nonempty,
175 #             add APPEND to the result, otherwise set result
176 #             to NONDIR_REPLACEMENT.
177 #             value returned in "$func_dirname_result"
178 #   basename: Compute filename of FILE.
179 #             value retuned in "$func_basename_result"
180 # Implementation must be kept synchronized with func_dirname
181 # and func_basename. For efficiency, we do not delegate to
182 # those functions but instead duplicate the functionality here.
183 func_dirname_and_basename ()
184 {
185   # Extract subdirectory from the argument.
186   func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
187   if test "X$func_dirname_result" = "X${1}"; then
188     func_dirname_result="${3}"
189   else
190     func_dirname_result="$func_dirname_result${2}"
191   fi
192   func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
193 }
194
195 # Generated shell functions inserted here.
196
197 # These SED scripts presuppose an absolute path with a trailing slash.
198 pathcar="s,^/\([^/]*\).*$,\1,"
199 pathcdr="s,^/[^/]*,,"
200 removedotparts="s@/\(\./\)\{1,\}@/@g;s,/\.$,/,"
201 collapseslashes="s@/\{1,\}@/@g"
202 finalslash="s,/*$,/,"
203
204 # func_normal_abspath PATH
205 # Remove doubled-up and trailing slashes, "." path components,
206 # and cancel out any ".." path components in PATH after making
207 # it an absolute path.
208 #             value returned in "$func_normal_abspath_result"
209 func_normal_abspath ()
210 {
211   # Start from root dir and reassemble the path.
212   func_normal_abspath_result=
213   func_normal_abspath_tpath=$1
214   func_normal_abspath_altnamespace=
215   case $func_normal_abspath_tpath in
216     "")
217       # Empty path, that just means $cwd.
218       func_stripname '' '/' "`pwd`"
219       func_normal_abspath_result=$func_stripname_result
220       return
221     ;;
222     # The next three entries are used to spot a run of precisely
223     # two leading slashes without using negated character classes;
224     # we take advantage of case's first-match behaviour.
225     ///*)
226       # Unusual form of absolute path, do nothing.
227     ;;
228     //*)
229       # Not necessarily an ordinary path; POSIX reserves leading '//'
230       # and for example Cygwin uses it to access remote file shares
231       # over CIFS/SMB, so we conserve a leading double slash if found.
232       func_normal_abspath_altnamespace=/
233     ;;
234     /*)
235       # Absolute path, do nothing.
236     ;;
237     *)
238       # Relative path, prepend $cwd.
239       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
240     ;;
241   esac
242   # Cancel out all the simple stuff to save iterations.  We also want
243   # the path to end with a slash for ease of parsing, so make sure
244   # there is one (and only one) here.
245   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
246         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
247   while :; do
248     # Processed it all yet?
249     if test "$func_normal_abspath_tpath" = / ; then
250       # If we ascended to the root using ".." the result may be empty now.
251       if test -z "$func_normal_abspath_result" ; then
252         func_normal_abspath_result=/
253       fi
254       break
255     fi
256     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
257         -e "$pathcar"`
258     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
259         -e "$pathcdr"`
260     # Figure out what to do with it
261     case $func_normal_abspath_tcomponent in
262       "")
263         # Trailing empty path component, ignore it.
264       ;;
265       ..)
266         # Parent dir; strip last assembled component from result.
267         func_dirname "$func_normal_abspath_result"
268         func_normal_abspath_result=$func_dirname_result
269       ;;
270       *)
271         # Actual path component, append it.
272         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
273       ;;
274     esac
275   done
276   # Restore leading double-slash if one was found on entry.
277   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
278 }
279
280 # func_relative_path SRCDIR DSTDIR
281 # generates a relative path from SRCDIR to DSTDIR, with a trailing
282 # slash if non-empty, suitable for immediately appending a filename
283 # without needing to append a separator.
284 #             value returned in "$func_relative_path_result"
285 func_relative_path ()
286 {
287   func_relative_path_result=
288   func_normal_abspath "$1"
289   func_relative_path_tlibdir=$func_normal_abspath_result
290   func_normal_abspath "$2"
291   func_relative_path_tbindir=$func_normal_abspath_result
292
293   # Ascend the tree starting from libdir
294   while :; do
295     # check if we have found a prefix of bindir
296     case $func_relative_path_tbindir in
297       $func_relative_path_tlibdir)
298         # found an exact match
299         func_relative_path_tcancelled=
300         break
301         ;;
302       $func_relative_path_tlibdir*)
303         # found a matching prefix
304         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
305         func_relative_path_tcancelled=$func_stripname_result
306         if test -z "$func_relative_path_result"; then
307           func_relative_path_result=.
308         fi
309         break
310         ;;
311       *)
312         func_dirname $func_relative_path_tlibdir
313         func_relative_path_tlibdir=${func_dirname_result}
314         if test "x$func_relative_path_tlibdir" = x ; then
315           # Have to descend all the way to the root!
316           func_relative_path_result=../$func_relative_path_result
317           func_relative_path_tcancelled=$func_relative_path_tbindir
318           break
319         fi
320         func_relative_path_result=../$func_relative_path_result
321         ;;
322     esac
323   done
324
325   # Now calculate path; take care to avoid doubling-up slashes.
326   func_stripname '' '/' "$func_relative_path_result"
327   func_relative_path_result=$func_stripname_result
328   func_stripname '/' '/' "$func_relative_path_tcancelled"
329   if test "x$func_stripname_result" != x ; then
330     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
331   fi
332
333   # Normalisation. If bindir is libdir, return empty string,
334   # else relative path ending with a slash; either way, target
335   # file name can be directly appended.
336   if test ! -z "$func_relative_path_result"; then
337     func_stripname './' '' "$func_relative_path_result/"
338     func_relative_path_result=$func_stripname_result
339   fi
340 }
341
342 # The name of this program:
343 func_dirname_and_basename "$progpath"
344 progname=$func_basename_result
345
346 # Make sure we have an absolute path for reexecution:
347 case $progpath in
348   [\\/]*|[A-Za-z]:\\*) ;;
349   *[\\/]*)
350      progdir=$func_dirname_result
351      progdir=`cd "$progdir" && pwd`
352      progpath="$progdir/$progname"
353      ;;
354   *)
355      save_IFS="$IFS"
356      IFS=:
357      for progdir in $PATH; do
358        IFS="$save_IFS"
359        test -x "$progdir/$progname" && break
360      done
361      IFS="$save_IFS"
362      test -n "$progdir" || progdir=`pwd`
363      progpath="$progdir/$progname"
364      ;;
365 esac
366
367 # Sed substitution that helps us do robust quoting.  It backslashifies
368 # metacharacters that are still active within double-quoted strings.
369 Xsed="${SED}"' -e 1s/^X//'
370 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
371
372 # Same as above, but do not quote variable references.
373 double_quote_subst='s/\(["`\\]\)/\\\1/g'
374
375 # Re-`\' parameter expansions in output of double_quote_subst that were
376 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
377 # in input to double_quote_subst, that '$' was protected from expansion.
378 # Since each input `\' is now two `\'s, look for any number of runs of
379 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
380 bs='\\'
381 bs2='\\\\'
382 bs4='\\\\\\\\'
383 dollar='\$'
384 sed_double_backslash="\
385   s/$bs4/&\\
386 /g
387   s/^$bs2$dollar/$bs&/
388   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
389   s/\n//g"
390
391 # Standard options:
392 opt_dry_run=false
393 opt_help=false
394 opt_quiet=false
395 opt_verbose=false
396 opt_warning=:
397
398 # func_echo arg...
399 # Echo program name prefixed message, along with the current mode
400 # name if it has been set yet.
401 func_echo ()
402 {
403     $ECHO "$progname${mode+: }$mode: $*"
404 }
405
406 # func_verbose arg...
407 # Echo program name prefixed message in verbose mode only.
408 func_verbose ()
409 {
410     $opt_verbose && func_echo ${1+"$@"}
411
412     # A bug in bash halts the script if the last line of a function
413     # fails when set -e is in force, so we need another command to
414     # work around that:
415     :
416 }
417
418 # func_echo_all arg...
419 # Invoke $ECHO with all args, space-separated.
420 func_echo_all ()
421 {
422     $ECHO "$*"
423 }
424
425 # func_error arg...
426 # Echo program name prefixed message to standard error.
427 func_error ()
428 {
429     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
430 }
431
432 # func_warning arg...
433 # Echo program name prefixed warning message to standard error.
434 func_warning ()
435 {
436     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
437
438     # bash bug again:
439     :
440 }
441
442 # func_fatal_error arg...
443 # Echo program name prefixed message to standard error, and exit.
444 func_fatal_error ()
445 {
446     func_error ${1+"$@"}
447     exit $EXIT_FAILURE
448 }
449
450 # func_fatal_help arg...
451 # Echo program name prefixed message to standard error, followed by
452 # a help hint, and exit.
453 func_fatal_help ()
454 {
455     func_error ${1+"$@"}
456     func_fatal_error "$help"
457 }
458 help="Try \`$progname --help' for more information."  ## default
459
460
461 # func_grep expression filename
462 # Check whether EXPRESSION matches any line of FILENAME, without output.
463 func_grep ()
464 {
465     $GREP "$1" "$2" >/dev/null 2>&1
466 }
467
468
469 # func_mkdir_p directory-path
470 # Make sure the entire path to DIRECTORY-PATH is available.
471 func_mkdir_p ()
472 {
473     my_directory_path="$1"
474     my_dir_list=
475
476     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
477
478       # Protect directory names starting with `-'
479       case $my_directory_path in
480         -*) my_directory_path="./$my_directory_path" ;;
481       esac
482
483       # While some portion of DIR does not yet exist...
484       while test ! -d "$my_directory_path"; do
485         # ...make a list in topmost first order.  Use a colon delimited
486         # list incase some portion of path contains whitespace.
487         my_dir_list="$my_directory_path:$my_dir_list"
488
489         # If the last portion added has no slash in it, the list is done
490         case $my_directory_path in */*) ;; *) break ;; esac
491
492         # ...otherwise throw away the child directory and loop
493         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
494       done
495       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
496
497       save_mkdir_p_IFS="$IFS"; IFS=':'
498       for my_dir in $my_dir_list; do
499         IFS="$save_mkdir_p_IFS"
500         # mkdir can fail with a `File exist' error if two processes
501         # try to create one of the directories concurrently.  Don't
502         # stop in that case!
503         $MKDIR "$my_dir" 2>/dev/null || :
504       done
505       IFS="$save_mkdir_p_IFS"
506
507       # Bail out if we (or some other process) failed to create a directory.
508       test -d "$my_directory_path" || \
509         func_fatal_error "Failed to create \`$1'"
510     fi
511 }
512
513
514 # func_mktempdir [string]
515 # Make a temporary directory that won't clash with other running
516 # libtool processes, and avoids race conditions if possible.  If
517 # given, STRING is the basename for that directory.
518 func_mktempdir ()
519 {
520     my_template="${TMPDIR-/tmp}/${1-$progname}"
521
522     if test "$opt_dry_run" = ":"; then
523       # Return a directory name, but don't create it in dry-run mode
524       my_tmpdir="${my_template}-$$"
525     else
526
527       # If mktemp works, use that first and foremost
528       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
529
530       if test ! -d "$my_tmpdir"; then
531         # Failing that, at least try and use $RANDOM to avoid a race
532         my_tmpdir="${my_template}-${RANDOM-0}$$"
533
534         save_mktempdir_umask=`umask`
535         umask 0077
536         $MKDIR "$my_tmpdir"
537         umask $save_mktempdir_umask
538       fi
539
540       # If we're not in dry-run mode, bomb out on failure
541       test -d "$my_tmpdir" || \
542         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
543     fi
544
545     $ECHO "$my_tmpdir"
546 }
547
548
549 # func_quote_for_eval arg
550 # Aesthetically quote ARG to be evaled later.
551 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
552 # is double-quoted, suitable for a subsequent eval, whereas
553 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
554 # which are still active within double quotes backslashified.
555 func_quote_for_eval ()
556 {
557     case $1 in
558       *[\\\`\"\$]*)
559         func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
560       *)
561         func_quote_for_eval_unquoted_result="$1" ;;
562     esac
563
564     case $func_quote_for_eval_unquoted_result in
565       # Double-quote args containing shell metacharacters to delay
566       # word splitting, command substitution and and variable
567       # expansion for a subsequent eval.
568       # Many Bourne shells cannot handle close brackets correctly
569       # in scan sets, so we specify it separately.
570       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
571         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
572         ;;
573       *)
574         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
575     esac
576 }
577
578
579 # func_quote_for_expand arg
580 # Aesthetically quote ARG to be evaled later; same as above,
581 # but do not quote variable references.
582 func_quote_for_expand ()
583 {
584     case $1 in
585       *[\\\`\"]*)
586         my_arg=`$ECHO "$1" | $SED \
587             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
588       *)
589         my_arg="$1" ;;
590     esac
591
592     case $my_arg in
593       # Double-quote args containing shell metacharacters to delay
594       # word splitting and command substitution for a subsequent eval.
595       # Many Bourne shells cannot handle close brackets correctly
596       # in scan sets, so we specify it separately.
597       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
598         my_arg="\"$my_arg\""
599         ;;
600     esac
601
602     func_quote_for_expand_result="$my_arg"
603 }
604
605
606 # func_show_eval cmd [fail_exp]
607 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
608 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
609 # is given, then evaluate it.
610 func_show_eval ()
611 {
612     my_cmd="$1"
613     my_fail_exp="${2-:}"
614
615     ${opt_silent-false} || {
616       func_quote_for_expand "$my_cmd"
617       eval "func_echo $func_quote_for_expand_result"
618     }
619
620     if ${opt_dry_run-false}; then :; else
621       eval "$my_cmd"
622       my_status=$?
623       if test "$my_status" -eq 0; then :; else
624         eval "(exit $my_status); $my_fail_exp"
625       fi
626     fi
627 }
628
629
630 # func_show_eval_locale cmd [fail_exp]
631 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
632 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
633 # is given, then evaluate it.  Use the saved locale for evaluation.
634 func_show_eval_locale ()
635 {
636     my_cmd="$1"
637     my_fail_exp="${2-:}"
638
639     ${opt_silent-false} || {
640       func_quote_for_expand "$my_cmd"
641       eval "func_echo $func_quote_for_expand_result"
642     }
643
644     if ${opt_dry_run-false}; then :; else
645       eval "$lt_user_locale
646             $my_cmd"
647       my_status=$?
648       eval "$lt_safe_locale"
649       if test "$my_status" -eq 0; then :; else
650         eval "(exit $my_status); $my_fail_exp"
651       fi
652     fi
653 }
654
655
656
657
658
659 # func_version
660 # Echo version message to standard output and exit.
661 func_version ()
662 {
663     $SED -n '/(C)/!b go
664         :more
665         /\./!{
666           N
667           s/\n# //
668           b more
669         }
670         :go
671         /^# '$PROGRAM' (GNU /,/# warranty; / {
672         s/^# //
673         s/^# *$//
674         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
675         p
676      }' < "$progpath"
677      exit $?
678 }
679
680 # func_usage
681 # Echo short help message to standard output and exit.
682 func_usage ()
683 {
684     $SED -n '/^# Usage:/,/^#  *-h/ {
685         s/^# //
686         s/^# *$//
687         s/\$progname/'$progname'/
688         p
689     }' < "$progpath"
690     echo
691     $ECHO "run \`$progname --help | more' for full usage"
692     exit $?
693 }
694
695 # func_help [NOEXIT]
696 # Echo long help message to standard output and exit,
697 # unless 'noexit' is passed as argument.
698 func_help ()
699 {
700     $SED -n '/^# Usage:/,/# Report bugs to/ {
701         s/^# //
702         s/^# *$//
703         s*\$progname*'$progname'*
704         s*\$host*'"$host"'*
705         s*\$SHELL*'"$SHELL"'*
706         s*\$LTCC*'"$LTCC"'*
707         s*\$LTCFLAGS*'"$LTCFLAGS"'*
708         s*\$LD*'"$LD"'*
709         s/\$with_gnu_ld/'"$with_gnu_ld"'/
710         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
711         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
712         p
713      }' < "$progpath"
714     ret=$?
715     if test -z "$1"; then
716       exit $ret
717     fi
718 }
719
720 # func_missing_arg argname
721 # Echo program name prefixed message to standard error and set global
722 # exit_cmd.
723 func_missing_arg ()
724 {
725     func_error "missing argument for $1"
726     exit_cmd=exit
727 }
728
729 exit_cmd=:
730
731
732
733
734
735
736 magic="%%%MAGIC variable%%%"
737 magic_exe="%%%MAGIC EXE variable%%%"
738
739 # Global variables.
740 # $mode is unset
741 nonopt=
742 execute_dlfiles=
743 preserve_args=
744 lo2o="s/\\.lo\$/.${objext}/"
745 o2lo="s/\\.${objext}\$/.lo/"
746 extracted_archives=
747 extracted_serial=0
748
749 opt_dry_run=false
750 opt_duplicate_deps=false
751 opt_silent=false
752 opt_debug=:
753
754 # If this variable is set in any of the actions, the command in it
755 # will be execed at the end.  This prevents here-documents from being
756 # left over by shells.
757 exec_cmd=
758
759 # func_fatal_configuration arg...
760 # Echo program name prefixed message to standard error, followed by
761 # a configuration failure hint, and exit.
762 func_fatal_configuration ()
763 {
764     func_error ${1+"$@"}
765     func_error "See the $PACKAGE documentation for more information."
766     func_fatal_error "Fatal configuration error."
767 }
768
769
770 # func_config
771 # Display the configuration for all the tags in this script.
772 func_config ()
773 {
774     re_begincf='^# ### BEGIN LIBTOOL'
775     re_endcf='^# ### END LIBTOOL'
776
777     # Default configuration.
778     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
779
780     # Now print the configurations for the tags.
781     for tagname in $taglist; do
782       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
783     done
784
785     exit $?
786 }
787
788 # func_features
789 # Display the features supported by this script.
790 func_features ()
791 {
792     echo "host: $host"
793     if test "$build_libtool_libs" = yes; then
794       echo "enable shared libraries"
795     else
796       echo "disable shared libraries"
797     fi
798     if test "$build_old_libs" = yes; then
799       echo "enable static libraries"
800     else
801       echo "disable static libraries"
802     fi
803
804     exit $?
805 }
806
807 # func_enable_tag tagname
808 # Verify that TAGNAME is valid, and either flag an error and exit, or
809 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
810 # variable here.
811 func_enable_tag ()
812 {
813   # Global variable:
814   tagname="$1"
815
816   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
817   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
818   sed_extractcf="/$re_begincf/,/$re_endcf/p"
819
820   # Validate tagname.
821   case $tagname in
822     *[!-_A-Za-z0-9,/]*)
823       func_fatal_error "invalid tag name: $tagname"
824       ;;
825   esac
826
827   # Don't test for the "default" C tag, as we know it's
828   # there but not specially marked.
829   case $tagname in
830     CC) ;;
831     *)
832       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
833         taglist="$taglist $tagname"
834
835         # Evaluate the configuration.  Be careful to quote the path
836         # and the sed script, to avoid splitting on whitespace, but
837         # also don't use non-portable quotes within backquotes within
838         # quotes we have to do it in 2 steps:
839         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
840         eval "$extractedcf"
841       else
842         func_error "ignoring unknown tag $tagname"
843       fi
844       ;;
845   esac
846 }
847
848 # Parse options once, thoroughly.  This comes as soon as possible in
849 # the script to make things like `libtool --version' happen quickly.
850 {
851
852   # Shorthand for --mode=foo, only valid as the first argument
853   case $1 in
854   clean|clea|cle|cl)
855     shift; set dummy --mode clean ${1+"$@"}; shift
856     ;;
857   compile|compil|compi|comp|com|co|c)
858     shift; set dummy --mode compile ${1+"$@"}; shift
859     ;;
860   execute|execut|execu|exec|exe|ex|e)
861     shift; set dummy --mode execute ${1+"$@"}; shift
862     ;;
863   finish|finis|fini|fin|fi|f)
864     shift; set dummy --mode finish ${1+"$@"}; shift
865     ;;
866   install|instal|insta|inst|ins|in|i)
867     shift; set dummy --mode install ${1+"$@"}; shift
868     ;;
869   link|lin|li|l)
870     shift; set dummy --mode link ${1+"$@"}; shift
871     ;;
872   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
873     shift; set dummy --mode uninstall ${1+"$@"}; shift
874     ;;
875   esac
876
877   # Parse non-mode specific arguments:
878   while test "$#" -gt 0; do
879     opt="$1"
880     shift
881
882     case $opt in
883       --config)         func_config                                     ;;
884
885       --debug)          preserve_args="$preserve_args $opt"
886                         func_echo "enabling shell trace mode"
887                         opt_debug='set -x'
888                         $opt_debug
889                         ;;
890
891       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
892                         execute_dlfiles="$execute_dlfiles $1"
893                         shift
894                         ;;
895
896       --dry-run | -n)   opt_dry_run=:                                   ;;
897       --features)       func_features                                   ;;
898       --finish)         mode="finish"                                   ;;
899
900       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
901                         case $1 in
902                           # Valid mode arguments:
903                           clean)        ;;
904                           compile)      ;;
905                           execute)      ;;
906                           finish)       ;;
907                           install)      ;;
908                           link)         ;;
909                           relink)       ;;
910                           uninstall)    ;;
911
912                           # Catch anything else as an error
913                           *) func_error "invalid argument for $opt"
914                              exit_cmd=exit
915                              break
916                              ;;
917                         esac
918
919                         mode="$1"
920                         shift
921                         ;;
922
923       --preserve-dup-deps)
924                         opt_duplicate_deps=:                            ;;
925
926       --quiet|--silent) preserve_args="$preserve_args $opt"
927                         opt_silent=:
928                         opt_verbose=false
929                         ;;
930
931       --no-quiet|--no-silent)
932                         preserve_args="$preserve_args $opt"
933                         opt_silent=false
934                         ;;
935
936       --verbose| -v)    preserve_args="$preserve_args $opt"
937                         opt_silent=false
938                         opt_verbose=:
939                         ;;
940
941       --no-verbose)     preserve_args="$preserve_args $opt"
942                         opt_verbose=false
943                         ;;
944
945       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
946                         preserve_args="$preserve_args $opt $1"
947                         func_enable_tag "$1"    # tagname is set here
948                         shift
949                         ;;
950
951       # Separate optargs to long options:
952       -dlopen=*|--mode=*|--tag=*)
953                         func_opt_split "$opt"
954                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
955                         shift
956                         ;;
957
958       -\?|-h)           func_usage                                      ;;
959       --help)           opt_help=:                                      ;;
960       --help-all)       opt_help=': help-all'                           ;;
961       --version)        func_version                                    ;;
962
963       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
964
965       *)                nonopt="$opt"
966                         break
967                         ;;
968     esac
969   done
970
971
972   case $host in
973     *cygwin* | *mingw* | *pw32* | *cegcc*)
974       # don't eliminate duplications in $postdeps and $predeps
975       opt_duplicate_compiler_generated_deps=:
976       ;;
977     *)
978       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
979       ;;
980   esac
981
982   # Having warned about all mis-specified options, bail out if
983   # anything was wrong.
984   $exit_cmd $EXIT_FAILURE
985 }
986
987 # func_check_version_match
988 # Ensure that we are using m4 macros, and libtool script from the same
989 # release of libtool.
990 func_check_version_match ()
991 {
992   if test "$package_revision" != "$macro_revision"; then
993     if test "$VERSION" != "$macro_version"; then
994       if test -z "$macro_version"; then
995         cat >&2 <<_LT_EOF
996 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
997 $progname: definition of this LT_INIT comes from an older release.
998 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
999 $progname: and run autoconf again.
1000 _LT_EOF
1001       else
1002         cat >&2 <<_LT_EOF
1003 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1004 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1005 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1006 $progname: and run autoconf again.
1007 _LT_EOF
1008       fi
1009     else
1010       cat >&2 <<_LT_EOF
1011 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1012 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1013 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1014 $progname: of $PACKAGE $VERSION and run autoconf again.
1015 _LT_EOF
1016     fi
1017
1018     exit $EXIT_MISMATCH
1019   fi
1020 }
1021
1022
1023 ## ----------- ##
1024 ##    Main.    ##
1025 ## ----------- ##
1026
1027 $opt_help || {
1028   # Sanity checks first:
1029   func_check_version_match
1030
1031   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1032     func_fatal_configuration "not configured to build any kind of library"
1033   fi
1034
1035   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1036
1037
1038   # Darwin sucks
1039   eval std_shrext=\"$shrext_cmds\"
1040
1041
1042   # Only execute mode is allowed to have -dlopen flags.
1043   if test -n "$execute_dlfiles" && test "$mode" != execute; then
1044     func_error "unrecognized option \`-dlopen'"
1045     $ECHO "$help" 1>&2
1046     exit $EXIT_FAILURE
1047   fi
1048
1049   # Change the help message to a mode-specific one.
1050   generic_help="$help"
1051   help="Try \`$progname --help --mode=$mode' for more information."
1052 }
1053
1054
1055 # func_lalib_p file
1056 # True iff FILE is a libtool `.la' library or `.lo' object file.
1057 # This function is only a basic sanity check; it will hardly flush out
1058 # determined imposters.
1059 func_lalib_p ()
1060 {
1061     test -f "$1" &&
1062       $SED -e 4q "$1" 2>/dev/null \
1063         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1064 }
1065
1066 # func_lalib_unsafe_p file
1067 # True iff FILE is a libtool `.la' library or `.lo' object file.
1068 # This function implements the same check as func_lalib_p without
1069 # resorting to external programs.  To this end, it redirects stdin and
1070 # closes it afterwards, without saving the original file descriptor.
1071 # As a safety measure, use it only where a negative result would be
1072 # fatal anyway.  Works if `file' does not exist.
1073 func_lalib_unsafe_p ()
1074 {
1075     lalib_p=no
1076     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1077         for lalib_p_l in 1 2 3 4
1078         do
1079             read lalib_p_line
1080             case "$lalib_p_line" in
1081                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1082             esac
1083         done
1084         exec 0<&5 5<&-
1085     fi
1086     test "$lalib_p" = yes
1087 }
1088
1089 # func_ltwrapper_script_p file
1090 # True iff FILE is a libtool wrapper script
1091 # This function is only a basic sanity check; it will hardly flush out
1092 # determined imposters.
1093 func_ltwrapper_script_p ()
1094 {
1095     func_lalib_p "$1"
1096 }
1097
1098 # func_ltwrapper_executable_p file
1099 # True iff FILE is a libtool wrapper executable
1100 # This function is only a basic sanity check; it will hardly flush out
1101 # determined imposters.
1102 func_ltwrapper_executable_p ()
1103 {
1104     func_ltwrapper_exec_suffix=
1105     case $1 in
1106     *.exe) ;;
1107     *) func_ltwrapper_exec_suffix=.exe ;;
1108     esac
1109     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1110 }
1111
1112 # func_ltwrapper_scriptname file
1113 # Assumes file is an ltwrapper_executable
1114 # uses $file to determine the appropriate filename for a
1115 # temporary ltwrapper_script.
1116 func_ltwrapper_scriptname ()
1117 {
1118     func_ltwrapper_scriptname_result=""
1119     if func_ltwrapper_executable_p "$1"; then
1120         func_dirname_and_basename "$1" "" "."
1121         func_stripname '' '.exe' "$func_basename_result"
1122         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1123     fi
1124 }
1125
1126 # func_ltwrapper_p file
1127 # True iff FILE is a libtool wrapper script or wrapper executable
1128 # This function is only a basic sanity check; it will hardly flush out
1129 # determined imposters.
1130 func_ltwrapper_p ()
1131 {
1132     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1133 }
1134
1135
1136 # func_execute_cmds commands fail_cmd
1137 # Execute tilde-delimited COMMANDS.
1138 # If FAIL_CMD is given, eval that upon failure.
1139 # FAIL_CMD may read-access the current command in variable CMD!
1140 func_execute_cmds ()
1141 {
1142     $opt_debug
1143     save_ifs=$IFS; IFS='~'
1144     for cmd in $1; do
1145       IFS=$save_ifs
1146       eval cmd=\"$cmd\"
1147       func_show_eval "$cmd" "${2-:}"
1148     done
1149     IFS=$save_ifs
1150 }
1151
1152
1153 # func_source file
1154 # Source FILE, adding directory component if necessary.
1155 # Note that it is not necessary on cygwin/mingw to append a dot to
1156 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1157 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1158 # `FILE.' does not work on cygwin managed mounts.
1159 func_source ()
1160 {
1161     $opt_debug
1162     case $1 in
1163     */* | *\\*) . "$1" ;;
1164     *)          . "./$1" ;;
1165     esac
1166 }
1167
1168
1169 # func_infer_tag arg
1170 # Infer tagged configuration to use if any are available and
1171 # if one wasn't chosen via the "--tag" command line option.
1172 # Only attempt this if the compiler in the base compile
1173 # command doesn't match the default compiler.
1174 # arg is usually of the form 'gcc ...'
1175 func_infer_tag ()
1176 {
1177     $opt_debug
1178     if test -n "$available_tags" && test -z "$tagname"; then
1179       CC_quoted=
1180       for arg in $CC; do
1181         func_quote_for_eval "$arg"
1182         CC_quoted="$CC_quoted $func_quote_for_eval_result"
1183       done
1184       CC_expanded=`func_echo_all $CC`
1185       CC_quoted_expanded=`func_echo_all $CC_quoted`
1186       case $@ in
1187       # Blanks in the command may have been stripped by the calling shell,
1188       # but not from the CC environment variable when configure was run.
1189       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1190       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1191       # Blanks at the start of $base_compile will cause this to fail
1192       # if we don't check for them as well.
1193       *)
1194         for z in $available_tags; do
1195           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1196             # Evaluate the configuration.
1197             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1198             CC_quoted=
1199             for arg in $CC; do
1200               # Double-quote args containing other shell metacharacters.
1201               func_quote_for_eval "$arg"
1202               CC_quoted="$CC_quoted $func_quote_for_eval_result"
1203             done
1204             CC_expanded=`func_echo_all $CC`
1205             CC_quoted_expanded=`func_echo_all $CC_quoted`
1206             case "$@ " in
1207             " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1208             " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1209               # The compiler in the base compile command matches
1210               # the one in the tagged configuration.
1211               # Assume this is the tagged configuration we want.
1212               tagname=$z
1213               break
1214               ;;
1215             esac
1216           fi
1217         done
1218         # If $tagname still isn't set, then no tagged configuration
1219         # was found and let the user know that the "--tag" command
1220         # line option must be used.
1221         if test -z "$tagname"; then
1222           func_echo "unable to infer tagged configuration"
1223           func_fatal_error "specify a tag with \`--tag'"
1224 #       else
1225 #         func_verbose "using $tagname tagged configuration"
1226         fi
1227         ;;
1228       esac
1229     fi
1230 }
1231
1232
1233
1234 # func_write_libtool_object output_name pic_name nonpic_name
1235 # Create a libtool object file (analogous to a ".la" file),
1236 # but don't create it if we're doing a dry run.
1237 func_write_libtool_object ()
1238 {
1239     write_libobj=${1}
1240     if test "$build_libtool_libs" = yes; then
1241       write_lobj=\'${2}\'
1242     else
1243       write_lobj=none
1244     fi
1245
1246     if test "$build_old_libs" = yes; then
1247       write_oldobj=\'${3}\'
1248     else
1249       write_oldobj=none
1250     fi
1251
1252     $opt_dry_run || {
1253       cat >${write_libobj}T <<EOF
1254 # $write_libobj - a libtool object file
1255 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1256 #
1257 # Please DO NOT delete this file!
1258 # It is necessary for linking the library.
1259
1260 # Name of the PIC object.
1261 pic_object=$write_lobj
1262
1263 # Name of the non-PIC object
1264 non_pic_object=$write_oldobj
1265
1266 EOF
1267       $MV "${write_libobj}T" "${write_libobj}"
1268     }
1269 }
1270
1271 # func_mode_compile arg...
1272 func_mode_compile ()
1273 {
1274     $opt_debug
1275     # Get the compilation command and the source file.
1276     base_compile=
1277     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1278     suppress_opt=yes
1279     suppress_output=
1280     arg_mode=normal
1281     libobj=
1282     later=
1283     pie_flag=
1284
1285     for arg
1286     do
1287       case $arg_mode in
1288       arg  )
1289         # do not "continue".  Instead, add this to base_compile
1290         lastarg="$arg"
1291         arg_mode=normal
1292         ;;
1293
1294       target )
1295         libobj="$arg"
1296         arg_mode=normal
1297         continue
1298         ;;
1299
1300       normal )
1301         # Accept any command-line options.
1302         case $arg in
1303         -o)
1304           test -n "$libobj" && \
1305             func_fatal_error "you cannot specify \`-o' more than once"
1306           arg_mode=target
1307           continue
1308           ;;
1309
1310         -pie | -fpie | -fPIE)
1311           pie_flag="$pie_flag $arg"
1312           continue
1313           ;;
1314
1315         -shared | -static | -prefer-pic | -prefer-non-pic)
1316           later="$later $arg"
1317           continue
1318           ;;
1319
1320         -no-suppress)
1321           suppress_opt=no
1322           continue
1323           ;;
1324
1325         -Xcompiler)
1326           arg_mode=arg  #  the next one goes into the "base_compile" arg list
1327           continue      #  The current "srcfile" will either be retained or
1328           ;;            #  replaced later.  I would guess that would be a bug.
1329
1330         -Wc,*)
1331           func_stripname '-Wc,' '' "$arg"
1332           args=$func_stripname_result
1333           lastarg=
1334           save_ifs="$IFS"; IFS=','
1335           for arg in $args; do
1336             IFS="$save_ifs"
1337             func_quote_for_eval "$arg"
1338             lastarg="$lastarg $func_quote_for_eval_result"
1339           done
1340           IFS="$save_ifs"
1341           func_stripname ' ' '' "$lastarg"
1342           lastarg=$func_stripname_result
1343
1344           # Add the arguments to base_compile.
1345           base_compile="$base_compile $lastarg"
1346           continue
1347           ;;
1348
1349         *)
1350           # Accept the current argument as the source file.
1351           # The previous "srcfile" becomes the current argument.
1352           #
1353           lastarg="$srcfile"
1354           srcfile="$arg"
1355           ;;
1356         esac  #  case $arg
1357         ;;
1358       esac    #  case $arg_mode
1359
1360       # Aesthetically quote the previous argument.
1361       func_quote_for_eval "$lastarg"
1362       base_compile="$base_compile $func_quote_for_eval_result"
1363     done # for arg
1364
1365     case $arg_mode in
1366     arg)
1367       func_fatal_error "you must specify an argument for -Xcompile"
1368       ;;
1369     target)
1370       func_fatal_error "you must specify a target with \`-o'"
1371       ;;
1372     *)
1373       # Get the name of the library object.
1374       test -z "$libobj" && {
1375         func_basename "$srcfile"
1376         libobj="$func_basename_result"
1377       }
1378       ;;
1379     esac
1380
1381     # Recognize several different file suffixes.
1382     # If the user specifies -o file.o, it is replaced with file.lo
1383     case $libobj in
1384     *.[cCFSifmso] | \
1385     *.ada | *.adb | *.ads | *.asm | \
1386     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1387     *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1388       func_xform "$libobj"
1389       libobj=$func_xform_result
1390       ;;
1391     esac
1392
1393     case $libobj in
1394     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1395     *)
1396       func_fatal_error "cannot determine name of library object from \`$libobj'"
1397       ;;
1398     esac
1399
1400     func_infer_tag $base_compile
1401
1402     for arg in $later; do
1403       case $arg in
1404       -shared)
1405         test "$build_libtool_libs" != yes && \
1406           func_fatal_configuration "can not build a shared library"
1407         build_old_libs=no
1408         continue
1409         ;;
1410
1411       -static)
1412         build_libtool_libs=no
1413         build_old_libs=yes
1414         continue
1415         ;;
1416
1417       -prefer-pic)
1418         pic_mode=yes
1419         continue
1420         ;;
1421
1422       -prefer-non-pic)
1423         pic_mode=no
1424         continue
1425         ;;
1426       esac
1427     done
1428
1429     func_quote_for_eval "$libobj"
1430     test "X$libobj" != "X$func_quote_for_eval_result" \
1431       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1432       && func_warning "libobj name \`$libobj' may not contain shell special characters."
1433     func_dirname_and_basename "$obj" "/" ""
1434     objname="$func_basename_result"
1435     xdir="$func_dirname_result"
1436     lobj=${xdir}$objdir/$objname
1437
1438     test -z "$base_compile" && \
1439       func_fatal_help "you must specify a compilation command"
1440
1441     # Delete any leftover library objects.
1442     if test "$build_old_libs" = yes; then
1443       removelist="$obj $lobj $libobj ${libobj}T"
1444     else
1445       removelist="$lobj $libobj ${libobj}T"
1446     fi
1447
1448     # On Cygwin there's no "real" PIC flag so we must build both object types
1449     case $host_os in
1450     cygwin* | mingw* | pw32* | os2* | cegcc*)
1451       pic_mode=default
1452       ;;
1453     esac
1454     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1455       # non-PIC code in shared libraries is not supported
1456       pic_mode=default
1457     fi
1458
1459     # Calculate the filename of the output object if compiler does
1460     # not support -o with -c
1461     if test "$compiler_c_o" = no; then
1462       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1463       lockfile="$output_obj.lock"
1464     else
1465       output_obj=
1466       need_locks=no
1467       lockfile=
1468     fi
1469
1470     # Lock this critical section if it is needed
1471     # We use this script file to make the link, it avoids creating a new file
1472     if test "$need_locks" = yes; then
1473       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1474         func_echo "Waiting for $lockfile to be removed"
1475         sleep 2
1476       done
1477     elif test "$need_locks" = warn; then
1478       if test -f "$lockfile"; then
1479         $ECHO "\
1480 *** ERROR, $lockfile exists and contains:
1481 `cat $lockfile 2>/dev/null`
1482
1483 This indicates that another process is trying to use the same
1484 temporary object file, and libtool could not work around it because
1485 your compiler does not support \`-c' and \`-o' together.  If you
1486 repeat this compilation, it may succeed, by chance, but you had better
1487 avoid parallel builds (make -j) in this platform, or get a better
1488 compiler."
1489
1490         $opt_dry_run || $RM $removelist
1491         exit $EXIT_FAILURE
1492       fi
1493       removelist="$removelist $output_obj"
1494       $ECHO "$srcfile" > "$lockfile"
1495     fi
1496
1497     $opt_dry_run || $RM $removelist
1498     removelist="$removelist $lockfile"
1499     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1500
1501     if test -n "$fix_srcfile_path"; then
1502       eval srcfile=\"$fix_srcfile_path\"
1503     fi
1504     func_quote_for_eval "$srcfile"
1505     qsrcfile=$func_quote_for_eval_result
1506
1507     # Only build a PIC object if we are building libtool libraries.
1508     if test "$build_libtool_libs" = yes; then
1509       # Without this assignment, base_compile gets emptied.
1510       fbsd_hideous_sh_bug=$base_compile
1511
1512       if test "$pic_mode" != no; then
1513         command="$base_compile $qsrcfile $pic_flag"
1514       else
1515         # Don't build PIC code
1516         command="$base_compile $qsrcfile"
1517       fi
1518
1519       func_mkdir_p "$xdir$objdir"
1520
1521       if test -z "$output_obj"; then
1522         # Place PIC objects in $objdir
1523         command="$command -o $lobj"
1524       fi
1525
1526       func_show_eval_locale "$command"  \
1527           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1528
1529       if test "$need_locks" = warn &&
1530          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1531         $ECHO "\
1532 *** ERROR, $lockfile contains:
1533 `cat $lockfile 2>/dev/null`
1534
1535 but it should contain:
1536 $srcfile
1537
1538 This indicates that another process is trying to use the same
1539 temporary object file, and libtool could not work around it because
1540 your compiler does not support \`-c' and \`-o' together.  If you
1541 repeat this compilation, it may succeed, by chance, but you had better
1542 avoid parallel builds (make -j) in this platform, or get a better
1543 compiler."
1544
1545         $opt_dry_run || $RM $removelist
1546         exit $EXIT_FAILURE
1547       fi
1548
1549       # Just move the object if needed, then go on to compile the next one
1550       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1551         func_show_eval '$MV "$output_obj" "$lobj"' \
1552           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1553       fi
1554
1555       # Allow error messages only from the first compilation.
1556       if test "$suppress_opt" = yes; then
1557         suppress_output=' >/dev/null 2>&1'
1558       fi
1559     fi
1560
1561     # Only build a position-dependent object if we build old libraries.
1562     if test "$build_old_libs" = yes; then
1563       if test "$pic_mode" != yes; then
1564         # Don't build PIC code
1565         command="$base_compile $qsrcfile$pie_flag"
1566       else
1567         command="$base_compile $qsrcfile $pic_flag"
1568       fi
1569       if test "$compiler_c_o" = yes; then
1570         command="$command -o $obj"
1571       fi
1572
1573       # Suppress compiler output if we already did a PIC compilation.
1574       command="$command$suppress_output"
1575       func_show_eval_locale "$command" \
1576         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1577
1578       if test "$need_locks" = warn &&
1579          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1580         $ECHO "\
1581 *** ERROR, $lockfile contains:
1582 `cat $lockfile 2>/dev/null`
1583
1584 but it should contain:
1585 $srcfile
1586
1587 This indicates that another process is trying to use the same
1588 temporary object file, and libtool could not work around it because
1589 your compiler does not support \`-c' and \`-o' together.  If you
1590 repeat this compilation, it may succeed, by chance, but you had better
1591 avoid parallel builds (make -j) in this platform, or get a better
1592 compiler."
1593
1594         $opt_dry_run || $RM $removelist
1595         exit $EXIT_FAILURE
1596       fi
1597
1598       # Just move the object if needed
1599       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1600         func_show_eval '$MV "$output_obj" "$obj"' \
1601           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1602       fi
1603     fi
1604
1605     $opt_dry_run || {
1606       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1607
1608       # Unlock the critical section if it was locked
1609       if test "$need_locks" != no; then
1610         removelist=$lockfile
1611         $RM "$lockfile"
1612       fi
1613     }
1614
1615     exit $EXIT_SUCCESS
1616 }
1617
1618 $opt_help || {
1619   test "$mode" = compile && func_mode_compile ${1+"$@"}
1620 }
1621
1622 func_mode_help ()
1623 {
1624     # We need to display help for each of the modes.
1625     case $mode in
1626       "")
1627         # Generic help is extracted from the usage comments
1628         # at the start of this file.
1629         func_help
1630         ;;
1631
1632       clean)
1633         $ECHO \
1634 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1635
1636 Remove files from the build directory.
1637
1638 RM is the name of the program to use to delete files associated with each FILE
1639 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1640 to RM.
1641
1642 If FILE is a libtool library, object or program, all the files associated
1643 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1644         ;;
1645
1646       compile)
1647       $ECHO \
1648 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1649
1650 Compile a source file into a libtool library object.
1651
1652 This mode accepts the following additional options:
1653
1654   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1655   -no-suppress      do not suppress compiler output for multiple passes
1656   -prefer-pic       try to building PIC objects only
1657   -prefer-non-pic   try to building non-PIC objects only
1658   -shared           do not build a \`.o' file suitable for static linking
1659   -static           only build a \`.o' file suitable for static linking
1660   -Wc,FLAG          pass FLAG directly to the compiler
1661
1662 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1663 from the given SOURCEFILE.
1664
1665 The output file name is determined by removing the directory component from
1666 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1667 library object suffix, \`.lo'."
1668         ;;
1669
1670       execute)
1671         $ECHO \
1672 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1673
1674 Automatically set library path, then run a program.
1675
1676 This mode accepts the following additional options:
1677
1678   -dlopen FILE      add the directory containing FILE to the library path
1679
1680 This mode sets the library path environment variable according to \`-dlopen'
1681 flags.
1682
1683 If any of the ARGS are libtool executable wrappers, then they are translated
1684 into their corresponding uninstalled binary, and any of their required library
1685 directories are added to the library path.
1686
1687 Then, COMMAND is executed, with ARGS as arguments."
1688         ;;
1689
1690       finish)
1691         $ECHO \
1692 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1693
1694 Complete the installation of libtool libraries.
1695
1696 Each LIBDIR is a directory that contains libtool libraries.
1697
1698 The commands that this mode executes may require superuser privileges.  Use
1699 the \`--dry-run' option if you just want to see what would be executed."
1700         ;;
1701
1702       install)
1703         $ECHO \
1704 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1705
1706 Install executables or libraries.
1707
1708 INSTALL-COMMAND is the installation command.  The first component should be
1709 either the \`install' or \`cp' program.
1710
1711 The following components of INSTALL-COMMAND are treated specially:
1712
1713   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
1714
1715 The rest of the components are interpreted as arguments to that command (only
1716 BSD-compatible install options are recognized)."
1717         ;;
1718
1719       link)
1720         $ECHO \
1721 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1722
1723 Link object files or libraries together to form another library, or to
1724 create an executable program.
1725
1726 LINK-COMMAND is a command using the C compiler that you would use to create
1727 a program from several object files.
1728
1729 The following components of LINK-COMMAND are treated specially:
1730
1731   -all-static       do not do any dynamic linking at all
1732   -avoid-version    do not add a version suffix if possible
1733   -bindir BINDIR    specify path to binaries directory (for systems where
1734                     libraries must be found in the PATH setting at runtime)
1735   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
1736   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
1737   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1738   -export-symbols SYMFILE
1739                     try to export only the symbols listed in SYMFILE
1740   -export-symbols-regex REGEX
1741                     try to export only the symbols matching REGEX
1742   -LLIBDIR          search LIBDIR for required installed libraries
1743   -lNAME            OUTPUT-FILE requires the installed library libNAME
1744   -module           build a library that can dlopened
1745   -no-fast-install  disable the fast-install mode
1746   -no-install       link a not-installable executable
1747   -no-undefined     declare that a library does not refer to external symbols
1748   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1749   -objectlist FILE  Use a list of object files found in FILE to specify objects
1750   -precious-files-regex REGEX
1751                     don't remove output files matching REGEX
1752   -release RELEASE  specify package release information
1753   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1754   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
1755   -shared           only do dynamic linking of libtool libraries
1756   -shrext SUFFIX    override the standard shared library file extension
1757   -static           do not do any dynamic linking of uninstalled libtool libraries
1758   -static-libtool-libs
1759                     do not do any dynamic linking of libtool libraries
1760   -version-info CURRENT[:REVISION[:AGE]]
1761                     specify library version info [each variable defaults to 0]
1762   -weak LIBNAME     declare that the target provides the LIBNAME interface
1763   -Wc,FLAG
1764   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
1765   -Wl,FLAG
1766   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
1767   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
1768
1769 All other options (arguments beginning with \`-') are ignored.
1770
1771 Every other argument is treated as a filename.  Files ending in \`.la' are
1772 treated as uninstalled libtool libraries, other files are standard or library
1773 object files.
1774
1775 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1776 only library objects (\`.lo' files) may be specified, and \`-rpath' is
1777 required, except when creating a convenience library.
1778
1779 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1780 using \`ar' and \`ranlib', or on Windows using \`lib'.
1781
1782 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1783 is created, otherwise an executable program is created."
1784         ;;
1785
1786       uninstall)
1787         $ECHO \
1788 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1789
1790 Remove libraries from an installation directory.
1791
1792 RM is the name of the program to use to delete files associated with each FILE
1793 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1794 to RM.
1795
1796 If FILE is a libtool library, all the files associated with it are deleted.
1797 Otherwise, only FILE itself is deleted using RM."
1798         ;;
1799
1800       *)
1801         func_fatal_help "invalid operation mode \`$mode'"
1802         ;;
1803     esac
1804
1805     echo
1806     $ECHO "Try \`$progname --help' for more information about other modes."
1807 }
1808
1809 # Now that we've collected a possible --mode arg, show help if necessary
1810 if $opt_help; then
1811   if test "$opt_help" = :; then
1812     func_mode_help
1813   else
1814     {
1815       func_help noexit
1816       for mode in compile link execute install finish uninstall clean; do
1817         func_mode_help
1818       done
1819     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
1820     {
1821       func_help noexit
1822       for mode in compile link execute install finish uninstall clean; do
1823         echo
1824         func_mode_help
1825       done
1826     } |
1827     sed '1d
1828       /^When reporting/,/^Report/{
1829         H
1830         d
1831       }
1832       $x
1833       /information about other modes/d
1834       /more detailed .*MODE/d
1835       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
1836   fi
1837   exit $?
1838 fi
1839
1840
1841 # func_mode_execute arg...
1842 func_mode_execute ()
1843 {
1844     $opt_debug
1845     # The first argument is the command name.
1846     cmd="$nonopt"
1847     test -z "$cmd" && \
1848       func_fatal_help "you must specify a COMMAND"
1849
1850     # Handle -dlopen flags immediately.
1851     for file in $execute_dlfiles; do
1852       test -f "$file" \
1853         || func_fatal_help "\`$file' is not a file"
1854
1855       dir=
1856       case $file in
1857       *.la)
1858         # Check to see that this really is a libtool archive.
1859         func_lalib_unsafe_p "$file" \
1860           || func_fatal_help "\`$lib' is not a valid libtool archive"
1861
1862         # Read the libtool library.
1863         dlname=
1864         library_names=
1865         func_source "$file"
1866
1867         # Skip this library if it cannot be dlopened.
1868         if test -z "$dlname"; then
1869           # Warn if it was a shared library.
1870           test -n "$library_names" && \
1871             func_warning "\`$file' was not linked with \`-export-dynamic'"
1872           continue
1873         fi
1874
1875         func_dirname "$file" "" "."
1876         dir="$func_dirname_result"
1877
1878         if test -f "$dir/$objdir/$dlname"; then
1879           dir="$dir/$objdir"
1880         else
1881           if test ! -f "$dir/$dlname"; then
1882             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1883           fi
1884         fi
1885         ;;
1886
1887       *.lo)
1888         # Just add the directory containing the .lo file.
1889         func_dirname "$file" "" "."
1890         dir="$func_dirname_result"
1891         ;;
1892
1893       *)
1894         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1895         continue
1896         ;;
1897       esac
1898
1899       # Get the absolute pathname.
1900       absdir=`cd "$dir" && pwd`
1901       test -n "$absdir" && dir="$absdir"
1902
1903       # Now add the directory to shlibpath_var.
1904       if eval "test -z \"\$$shlibpath_var\""; then
1905         eval "$shlibpath_var=\"\$dir\""
1906       else
1907         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1908       fi
1909     done
1910
1911     # This variable tells wrapper scripts just to set shlibpath_var
1912     # rather than running their programs.
1913     libtool_execute_magic="$magic"
1914
1915     # Check if any of the arguments is a wrapper script.
1916     args=
1917     for file
1918     do
1919       case $file in
1920       -* | *.la | *.lo ) ;;
1921       *)
1922         # Do a test to see if this is really a libtool program.
1923         if func_ltwrapper_script_p "$file"; then
1924           func_source "$file"
1925           # Transform arg to wrapped name.
1926           file="$progdir/$program"
1927         elif func_ltwrapper_executable_p "$file"; then
1928           func_ltwrapper_scriptname "$file"
1929           func_source "$func_ltwrapper_scriptname_result"
1930           # Transform arg to wrapped name.
1931           file="$progdir/$program"
1932         fi
1933         ;;
1934       esac
1935       # Quote arguments (to preserve shell metacharacters).
1936       func_quote_for_eval "$file"
1937       args="$args $func_quote_for_eval_result"
1938     done
1939
1940     if test "X$opt_dry_run" = Xfalse; then
1941       if test -n "$shlibpath_var"; then
1942         # Export the shlibpath_var.
1943         eval "export $shlibpath_var"
1944       fi
1945
1946       # Restore saved environment variables
1947       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1948       do
1949         eval "if test \"\${save_$lt_var+set}\" = set; then
1950                 $lt_var=\$save_$lt_var; export $lt_var
1951               else
1952                 $lt_unset $lt_var
1953               fi"
1954       done
1955
1956       # Now prepare to actually exec the command.
1957       exec_cmd="\$cmd$args"
1958     else
1959       # Display what would be done.
1960       if test -n "$shlibpath_var"; then
1961         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1962         echo "export $shlibpath_var"
1963       fi
1964       $ECHO "$cmd$args"
1965       exit $EXIT_SUCCESS
1966     fi
1967 }
1968
1969 test "$mode" = execute && func_mode_execute ${1+"$@"}
1970
1971
1972 # func_mode_finish arg...
1973 func_mode_finish ()
1974 {
1975     $opt_debug
1976     libdirs="$nonopt"
1977     admincmds=
1978
1979     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1980       for dir
1981       do
1982         libdirs="$libdirs $dir"
1983       done
1984
1985       for libdir in $libdirs; do
1986         if test -n "$finish_cmds"; then
1987           # Do each command in the finish commands.
1988           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1989 '"$cmd"'"'
1990         fi
1991         if test -n "$finish_eval"; then
1992           # Do the single finish_eval.
1993           eval cmds=\"$finish_eval\"
1994           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
1995        $cmds"
1996         fi
1997       done
1998     fi
1999
2000     # Exit here if they wanted silent mode.
2001     $opt_silent && exit $EXIT_SUCCESS
2002
2003     echo "----------------------------------------------------------------------"
2004     echo "Libraries have been installed in:"
2005     for libdir in $libdirs; do
2006       $ECHO "   $libdir"
2007     done
2008     echo
2009     echo "If you ever happen to want to link against installed libraries"
2010     echo "in a given directory, LIBDIR, you must either use libtool, and"
2011     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2012     echo "flag during linking and do at least one of the following:"
2013     if test -n "$shlibpath_var"; then
2014       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2015       echo "     during execution"
2016     fi
2017     if test -n "$runpath_var"; then
2018       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2019       echo "     during linking"
2020     fi
2021     if test -n "$hardcode_libdir_flag_spec"; then
2022       libdir=LIBDIR
2023       eval flag=\"$hardcode_libdir_flag_spec\"
2024
2025       $ECHO "   - use the \`$flag' linker flag"
2026     fi
2027     if test -n "$admincmds"; then
2028       $ECHO "   - have your system administrator run these commands:$admincmds"
2029     fi
2030     if test -f /etc/ld.so.conf; then
2031       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2032     fi
2033     echo
2034
2035     echo "See any operating system documentation about shared libraries for"
2036     case $host in
2037       solaris2.[6789]|solaris2.1[0-9])
2038         echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2039         echo "pages."
2040         ;;
2041       *)
2042         echo "more information, such as the ld(1) and ld.so(8) manual pages."
2043         ;;
2044     esac
2045     echo "----------------------------------------------------------------------"
2046     exit $EXIT_SUCCESS
2047 }
2048
2049 test "$mode" = finish && func_mode_finish ${1+"$@"}
2050
2051
2052 # func_mode_install arg...
2053 func_mode_install ()
2054 {
2055     $opt_debug
2056     # There may be an optional sh(1) argument at the beginning of
2057     # install_prog (especially on Windows NT).
2058     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2059        # Allow the use of GNU shtool's install command.
2060        case $nonopt in *shtool*) :;; *) false;; esac; then
2061       # Aesthetically quote it.
2062       func_quote_for_eval "$nonopt"
2063       install_prog="$func_quote_for_eval_result "
2064       arg=$1
2065       shift
2066     else
2067       install_prog=
2068       arg=$nonopt
2069     fi
2070
2071     # The real first argument should be the name of the installation program.
2072     # Aesthetically quote it.
2073     func_quote_for_eval "$arg"
2074     install_prog="$install_prog$func_quote_for_eval_result"
2075     install_shared_prog=$install_prog
2076     case " $install_prog " in
2077       *[\\\ /]cp\ *) install_cp=: ;;
2078       *) install_cp=false ;;
2079     esac
2080
2081     # We need to accept at least all the BSD install flags.
2082     dest=
2083     files=
2084     opts=
2085     prev=
2086     install_type=
2087     isdir=no
2088     stripme=
2089     no_mode=:
2090     for arg
2091     do
2092       arg2=
2093       if test -n "$dest"; then
2094         files="$files $dest"
2095         dest=$arg
2096         continue
2097       fi
2098
2099       case $arg in
2100       -d) isdir=yes ;;
2101       -f)
2102         if $install_cp; then :; else
2103           prev=$arg
2104         fi
2105         ;;
2106       -g | -m | -o)
2107         prev=$arg
2108         ;;
2109       -s)
2110         stripme=" -s"
2111         continue
2112         ;;
2113       -*)
2114         ;;
2115       *)
2116         # If the previous option needed an argument, then skip it.
2117         if test -n "$prev"; then
2118           if test "x$prev" = x-m && test -n "$install_override_mode"; then
2119             arg2=$install_override_mode
2120             no_mode=false
2121           fi
2122           prev=
2123         else
2124           dest=$arg
2125           continue
2126         fi
2127         ;;
2128       esac
2129
2130       # Aesthetically quote the argument.
2131       func_quote_for_eval "$arg"
2132       install_prog="$install_prog $func_quote_for_eval_result"
2133       if test -n "$arg2"; then
2134         func_quote_for_eval "$arg2"
2135       fi
2136       install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2137     done
2138
2139     test -z "$install_prog" && \
2140       func_fatal_help "you must specify an install program"
2141
2142     test -n "$prev" && \
2143       func_fatal_help "the \`$prev' option requires an argument"
2144
2145     if test -n "$install_override_mode" && $no_mode; then
2146       if $install_cp; then :; else
2147         func_quote_for_eval "$install_override_mode"
2148         install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2149       fi
2150     fi
2151
2152     if test -z "$files"; then
2153       if test -z "$dest"; then
2154         func_fatal_help "no file or destination specified"
2155       else
2156         func_fatal_help "you must specify a destination"
2157       fi
2158     fi
2159
2160     # Strip any trailing slash from the destination.
2161     func_stripname '' '/' "$dest"
2162     dest=$func_stripname_result
2163
2164     # Check to see that the destination is a directory.
2165     test -d "$dest" && isdir=yes
2166     if test "$isdir" = yes; then
2167       destdir="$dest"
2168       destname=
2169     else
2170       func_dirname_and_basename "$dest" "" "."
2171       destdir="$func_dirname_result"
2172       destname="$func_basename_result"
2173
2174       # Not a directory, so check to see that there is only one file specified.
2175       set dummy $files; shift
2176       test "$#" -gt 1 && \
2177         func_fatal_help "\`$dest' is not a directory"
2178     fi
2179     case $destdir in
2180     [\\/]* | [A-Za-z]:[\\/]*) ;;
2181     *)
2182       for file in $files; do
2183         case $file in
2184         *.lo) ;;
2185         *)
2186           func_fatal_help "\`$destdir' must be an absolute directory name"
2187           ;;
2188         esac
2189       done
2190       ;;
2191     esac
2192
2193     # This variable tells wrapper scripts just to set variables rather
2194     # than running their programs.
2195     libtool_install_magic="$magic"
2196
2197     staticlibs=
2198     future_libdirs=
2199     current_libdirs=
2200     for file in $files; do
2201
2202       # Do each installation.
2203       case $file in
2204       *.$libext)
2205         # Do the static libraries later.
2206         staticlibs="$staticlibs $file"
2207         ;;
2208
2209       *.la)
2210         # Check to see that this really is a libtool archive.
2211         func_lalib_unsafe_p "$file" \
2212           || func_fatal_help "\`$file' is not a valid libtool archive"
2213
2214         library_names=
2215         old_library=
2216         relink_command=
2217         func_source "$file"
2218
2219         # Add the libdir to current_libdirs if it is the destination.
2220         if test "X$destdir" = "X$libdir"; then
2221           case "$current_libdirs " in
2222           *" $libdir "*) ;;
2223           *) current_libdirs="$current_libdirs $libdir" ;;
2224           esac
2225         else
2226           # Note the libdir as a future libdir.
2227           case "$future_libdirs " in
2228           *" $libdir "*) ;;
2229           *) future_libdirs="$future_libdirs $libdir" ;;
2230           esac
2231         fi
2232
2233         func_dirname "$file" "/" ""
2234         dir="$func_dirname_result"
2235         dir="$dir$objdir"
2236
2237         if test -n "$relink_command"; then
2238           # Determine the prefix the user has applied to our future dir.
2239           inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2240
2241           # Don't allow the user to place us outside of our expected
2242           # location b/c this prevents finding dependent libraries that
2243           # are installed to the same prefix.
2244           # At present, this check doesn't affect windows .dll's that
2245           # are installed into $libdir/../bin (currently, that works fine)
2246           # but it's something to keep an eye on.
2247           test "$inst_prefix_dir" = "$destdir" && \
2248             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2249
2250           if test -n "$inst_prefix_dir"; then
2251             # Stick the inst_prefix_dir data into the link command.
2252             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2253           else
2254             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2255           fi
2256
2257           func_warning "relinking \`$file'"
2258           func_show_eval "$relink_command" \
2259             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2260         fi
2261
2262         # See the names of the shared library.
2263         set dummy $library_names; shift
2264         if test -n "$1"; then
2265           realname="$1"
2266           shift
2267
2268           srcname="$realname"
2269           test -n "$relink_command" && srcname="$realname"T
2270
2271           # Install the shared library and build the symlinks.
2272           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2273               'exit $?'
2274           tstripme="$stripme"
2275           case $host_os in
2276           cygwin* | mingw* | pw32* | cegcc*)
2277             case $realname in
2278             *.dll.a)
2279               tstripme=""
2280               ;;
2281             esac
2282             ;;
2283           esac
2284           if test -n "$tstripme" && test -n "$striplib"; then
2285             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2286           fi
2287
2288           if test "$#" -gt 0; then
2289             # Delete the old symlinks, and create new ones.
2290             # Try `ln -sf' first, because the `ln' binary might depend on
2291             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2292             # so we also need to try rm && ln -s.
2293             for linkname
2294             do
2295               test "$linkname" != "$realname" \
2296                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2297             done
2298           fi
2299
2300           # Do each command in the postinstall commands.
2301           lib="$destdir/$realname"
2302           func_execute_cmds "$postinstall_cmds" 'exit $?'
2303         fi
2304
2305         # Install the pseudo-library for information purposes.
2306         func_basename "$file"
2307         name="$func_basename_result"
2308         instname="$dir/$name"i
2309         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2310
2311         # Maybe install the static library, too.
2312         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2313         ;;
2314
2315       *.lo)
2316         # Install (i.e. copy) a libtool object.
2317
2318         # Figure out destination file name, if it wasn't already specified.
2319         if test -n "$destname"; then
2320           destfile="$destdir/$destname"
2321         else
2322           func_basename "$file"
2323           destfile="$func_basename_result"
2324           destfile="$destdir/$destfile"
2325         fi
2326
2327         # Deduce the name of the destination old-style object file.
2328         case $destfile in
2329         *.lo)
2330           func_lo2o "$destfile"
2331           staticdest=$func_lo2o_result
2332           ;;
2333         *.$objext)
2334           staticdest="$destfile"
2335           destfile=
2336           ;;
2337         *)
2338           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2339           ;;
2340         esac
2341
2342         # Install the libtool object if requested.
2343         test -n "$destfile" && \
2344           func_show_eval "$install_prog $file $destfile" 'exit $?'
2345
2346         # Install the old object if enabled.
2347         if test "$build_old_libs" = yes; then
2348           # Deduce the name of the old-style object file.
2349           func_lo2o "$file"
2350           staticobj=$func_lo2o_result
2351           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2352         fi
2353         exit $EXIT_SUCCESS
2354         ;;
2355
2356       *)
2357         # Figure out destination file name, if it wasn't already specified.
2358         if test -n "$destname"; then
2359           destfile="$destdir/$destname"
2360         else
2361           func_basename "$file"
2362           destfile="$func_basename_result"
2363           destfile="$destdir/$destfile"
2364         fi
2365
2366         # If the file is missing, and there is a .exe on the end, strip it
2367         # because it is most likely a libtool script we actually want to
2368         # install
2369         stripped_ext=""
2370         case $file in
2371           *.exe)
2372             if test ! -f "$file"; then
2373               func_stripname '' '.exe' "$file"
2374               file=$func_stripname_result
2375               stripped_ext=".exe"
2376             fi
2377             ;;
2378         esac
2379
2380         # Do a test to see if this is really a libtool program.
2381         case $host in
2382         *cygwin* | *mingw*)
2383             if func_ltwrapper_executable_p "$file"; then
2384               func_ltwrapper_scriptname "$file"
2385               wrapper=$func_ltwrapper_scriptname_result
2386             else
2387               func_stripname '' '.exe' "$file"
2388               wrapper=$func_stripname_result
2389             fi
2390             ;;
2391         *)
2392             wrapper=$file
2393             ;;
2394         esac
2395         if func_ltwrapper_script_p "$wrapper"; then
2396           notinst_deplibs=
2397           relink_command=
2398
2399           func_source "$wrapper"
2400
2401           # Check the variables that should have been set.
2402           test -z "$generated_by_libtool_version" && \
2403             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2404
2405           finalize=yes
2406           for lib in $notinst_deplibs; do
2407             # Check to see that each library is installed.
2408             libdir=
2409             if test -f "$lib"; then
2410               func_source "$lib"
2411             fi
2412             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2413             if test -n "$libdir" && test ! -f "$libfile"; then
2414               func_warning "\`$lib' has not been installed in \`$libdir'"
2415               finalize=no
2416             fi
2417           done
2418
2419           relink_command=
2420           func_source "$wrapper"
2421
2422           outputname=
2423           if test "$fast_install" = no && test -n "$relink_command"; then
2424             $opt_dry_run || {
2425               if test "$finalize" = yes; then
2426                 tmpdir=`func_mktempdir`
2427                 func_basename "$file$stripped_ext"
2428                 file="$func_basename_result"
2429                 outputname="$tmpdir/$file"
2430                 # Replace the output file specification.
2431                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2432
2433                 $opt_silent || {
2434                   func_quote_for_expand "$relink_command"
2435                   eval "func_echo $func_quote_for_expand_result"
2436                 }
2437                 if eval "$relink_command"; then :
2438                   else
2439                   func_error "error: relink \`$file' with the above command before installing it"
2440                   $opt_dry_run || ${RM}r "$tmpdir"
2441                   continue
2442                 fi
2443                 file="$outputname"
2444               else
2445                 func_warning "cannot relink \`$file'"
2446               fi
2447             }
2448           else
2449             # Install the binary that we compiled earlier.
2450             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2451           fi
2452         fi
2453
2454         # remove .exe since cygwin /usr/bin/install will append another
2455         # one anyway
2456         case $install_prog,$host in
2457         */usr/bin/install*,*cygwin*)
2458           case $file:$destfile in
2459           *.exe:*.exe)
2460             # this is ok
2461             ;;
2462           *.exe:*)
2463             destfile=$destfile.exe
2464             ;;
2465           *:*.exe)
2466             func_stripname '' '.exe' "$destfile"
2467             destfile=$func_stripname_result
2468             ;;
2469           esac
2470           ;;
2471         esac
2472         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2473         $opt_dry_run || if test -n "$outputname"; then
2474           ${RM}r "$tmpdir"
2475         fi
2476         ;;
2477       esac
2478     done
2479
2480     for file in $staticlibs; do
2481       func_basename "$file"
2482       name="$func_basename_result"
2483
2484       # Set up the ranlib parameters.
2485       oldlib="$destdir/$name"
2486
2487       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2488
2489       if test -n "$stripme" && test -n "$old_striplib"; then
2490         func_show_eval "$old_striplib $oldlib" 'exit $?'
2491       fi
2492
2493       # Do each command in the postinstall commands.
2494       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2495     done
2496
2497     test -n "$future_libdirs" && \
2498       func_warning "remember to run \`$progname --finish$future_libdirs'"
2499
2500     if test -n "$current_libdirs"; then
2501       # Maybe just do a dry run.
2502       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2503       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2504     else
2505       exit $EXIT_SUCCESS
2506     fi
2507 }
2508
2509 test "$mode" = install && func_mode_install ${1+"$@"}
2510
2511
2512 # func_generate_dlsyms outputname originator pic_p
2513 # Extract symbols from dlprefiles and create ${outputname}S.o with
2514 # a dlpreopen symbol table.
2515 func_generate_dlsyms ()
2516 {
2517     $opt_debug
2518     my_outputname="$1"
2519     my_originator="$2"
2520     my_pic_p="${3-no}"
2521     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2522     my_dlsyms=
2523
2524     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2525       if test -n "$NM" && test -n "$global_symbol_pipe"; then
2526         my_dlsyms="${my_outputname}S.c"
2527       else
2528         func_error "not configured to extract global symbols from dlpreopened files"
2529       fi
2530     fi
2531
2532     if test -n "$my_dlsyms"; then
2533       case $my_dlsyms in
2534       "") ;;
2535       *.c)
2536         # Discover the nlist of each of the dlfiles.
2537         nlist="$output_objdir/${my_outputname}.nm"
2538
2539         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2540
2541         # Parse the name list into a source file.
2542         func_verbose "creating $output_objdir/$my_dlsyms"
2543
2544         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2545 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2546 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2547
2548 #ifdef __cplusplus
2549 extern \"C\" {
2550 #endif
2551
2552 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
2553 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2554 #endif
2555
2556 /* External symbol declarations for the compiler. */\
2557 "
2558
2559         if test "$dlself" = yes; then
2560           func_verbose "generating symbol list for \`$output'"
2561
2562           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2563
2564           # Add our own program objects to the symbol list.
2565           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2566           for progfile in $progfiles; do
2567             func_verbose "extracting global C symbols from \`$progfile'"
2568             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2569           done
2570
2571           if test -n "$exclude_expsyms"; then
2572             $opt_dry_run || {
2573               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2574               eval '$MV "$nlist"T "$nlist"'
2575             }
2576           fi
2577
2578           if test -n "$export_symbols_regex"; then
2579             $opt_dry_run || {
2580               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2581               eval '$MV "$nlist"T "$nlist"'
2582             }
2583           fi
2584
2585           # Prepare the list of exported symbols
2586           if test -z "$export_symbols"; then
2587             export_symbols="$output_objdir/$outputname.exp"
2588             $opt_dry_run || {
2589               $RM $export_symbols
2590               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2591               case $host in
2592               *cygwin* | *mingw* | *cegcc* )
2593                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2594                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2595                 ;;
2596               esac
2597             }
2598           else
2599             $opt_dry_run || {
2600               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2601               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2602               eval '$MV "$nlist"T "$nlist"'
2603               case $host in
2604                 *cygwin* | *mingw* | *cegcc* )
2605                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2606                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2607                   ;;
2608               esac
2609             }
2610           fi
2611         fi
2612
2613         for dlprefile in $dlprefiles; do
2614           func_verbose "extracting global C symbols from \`$dlprefile'"
2615           func_basename "$dlprefile"
2616           name="$func_basename_result"
2617           $opt_dry_run || {
2618             eval '$ECHO ": $name " >> "$nlist"'
2619             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2620           }
2621         done
2622
2623         $opt_dry_run || {
2624           # Make sure we have at least an empty file.
2625           test -f "$nlist" || : > "$nlist"
2626
2627           if test -n "$exclude_expsyms"; then
2628             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2629             $MV "$nlist"T "$nlist"
2630           fi
2631
2632           # Try sorting and uniquifying the output.
2633           if $GREP -v "^: " < "$nlist" |
2634               if sort -k 3 </dev/null >/dev/null 2>&1; then
2635                 sort -k 3
2636               else
2637                 sort +2
2638               fi |
2639               uniq > "$nlist"S; then
2640             :
2641           else
2642             $GREP -v "^: " < "$nlist" > "$nlist"S
2643           fi
2644
2645           if test -f "$nlist"S; then
2646             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2647           else
2648             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2649           fi
2650
2651           echo >> "$output_objdir/$my_dlsyms" "\
2652
2653 /* The mapping between symbol names and symbols.  */
2654 typedef struct {
2655   const char *name;
2656   void *address;
2657 } lt_dlsymlist;
2658 "
2659           case $host in
2660           *cygwin* | *mingw* | *cegcc* )
2661             echo >> "$output_objdir/$my_dlsyms" "\
2662 /* DATA imports from DLLs on WIN32 con't be const, because
2663    runtime relocations are performed -- see ld's documentation
2664    on pseudo-relocs.  */"
2665             lt_dlsym_const= ;;
2666           *osf5*)
2667             echo >> "$output_objdir/$my_dlsyms" "\
2668 /* This system does not cope well with relocations in const data */"
2669             lt_dlsym_const= ;;
2670           *)
2671             lt_dlsym_const=const ;;
2672           esac
2673
2674           echo >> "$output_objdir/$my_dlsyms" "\
2675 extern $lt_dlsym_const lt_dlsymlist
2676 lt_${my_prefix}_LTX_preloaded_symbols[];
2677 $lt_dlsym_const lt_dlsymlist
2678 lt_${my_prefix}_LTX_preloaded_symbols[] =
2679 {\
2680   { \"$my_originator\", (void *) 0 },"
2681
2682           case $need_lib_prefix in
2683           no)
2684             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2685             ;;
2686           *)
2687             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2688             ;;
2689           esac
2690           echo >> "$output_objdir/$my_dlsyms" "\
2691   {0, (void *) 0}
2692 };
2693
2694 /* This works around a problem in FreeBSD linker */
2695 #ifdef FREEBSD_WORKAROUND
2696 static const void *lt_preloaded_setup() {
2697   return lt_${my_prefix}_LTX_preloaded_symbols;
2698 }
2699 #endif
2700
2701 #ifdef __cplusplus
2702 }
2703 #endif\
2704 "
2705         } # !$opt_dry_run
2706
2707         pic_flag_for_symtable=
2708         case "$compile_command " in
2709         *" -static "*) ;;
2710         *)
2711           case $host in
2712           # compiling the symbol table file with pic_flag works around
2713           # a FreeBSD bug that causes programs to crash when -lm is
2714           # linked before any other PIC object.  But we must not use
2715           # pic_flag when linking with -static.  The problem exists in
2716           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2717           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2718             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2719           *-*-hpux*)
2720             pic_flag_for_symtable=" $pic_flag"  ;;
2721           *)
2722             if test "X$my_pic_p" != Xno; then
2723               pic_flag_for_symtable=" $pic_flag"
2724             fi
2725             ;;
2726           esac
2727           ;;
2728         esac
2729         symtab_cflags=
2730         for arg in $LTCFLAGS; do
2731           case $arg in
2732           -pie | -fpie | -fPIE) ;;
2733           *) symtab_cflags="$symtab_cflags $arg" ;;
2734           esac
2735         done
2736
2737         # Now compile the dynamic symbol file.
2738         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2739
2740         # Clean up the generated files.
2741         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2742
2743         # Transform the symbol file into the correct name.
2744         symfileobj="$output_objdir/${my_outputname}S.$objext"
2745         case $host in
2746         *cygwin* | *mingw* | *cegcc* )
2747           if test -f "$output_objdir/$my_outputname.def"; then
2748             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2749             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2750           else
2751             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2752             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2753           fi
2754           ;;
2755         *)
2756           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2757           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2758           ;;
2759         esac
2760         ;;
2761       *)
2762         func_fatal_error "unknown suffix for \`$my_dlsyms'"
2763         ;;
2764       esac
2765     else
2766       # We keep going just in case the user didn't refer to
2767       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2768       # really was required.
2769
2770       # Nullify the symbol file.
2771       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
2772       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2773     fi
2774 }
2775
2776 # func_win32_libid arg
2777 # return the library type of file 'arg'
2778 #
2779 # Need a lot of goo to handle *both* DLLs and import libs
2780 # Has to be a shell function in order to 'eat' the argument
2781 # that is supplied when $file_magic_command is called.
2782 # Despite the name, also deal with 64 bit binaries.
2783 func_win32_libid ()
2784 {
2785   $opt_debug
2786   win32_libid_type="unknown"
2787   win32_fileres=`file -L $1 2>/dev/null`
2788   case $win32_fileres in
2789   *ar\ archive\ import\ library*) # definitely import
2790     win32_libid_type="x86 archive import"
2791     ;;
2792   *ar\ archive*) # could be an import, or static
2793     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2794        $EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
2795       win32_nmres=`eval $NM -f posix -A $1 |
2796         $SED -n -e '
2797             1,100{
2798                 / I /{
2799                     s,.*,import,
2800                     p
2801                     q
2802                 }
2803             }'`
2804       case $win32_nmres in
2805       import*)  win32_libid_type="x86 archive import";;
2806       *)        win32_libid_type="x86 archive static";;
2807       esac
2808     fi
2809     ;;
2810   *DLL*)
2811     win32_libid_type="x86 DLL"
2812     ;;
2813   *executable*) # but shell scripts are "executable" too...
2814     case $win32_fileres in
2815     *MS\ Windows\ PE\ Intel*)
2816       win32_libid_type="x86 DLL"
2817       ;;
2818     esac
2819     ;;
2820   esac
2821   $ECHO "$win32_libid_type"
2822 }
2823
2824
2825
2826 # func_extract_an_archive dir oldlib
2827 func_extract_an_archive ()
2828 {
2829     $opt_debug
2830     f_ex_an_ar_dir="$1"; shift
2831     f_ex_an_ar_oldlib="$1"
2832     if test "$lock_old_archive_extraction" = yes; then
2833       lockfile=$f_ex_an_ar_oldlib.lock
2834       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2835         func_echo "Waiting for $lockfile to be removed"
2836         sleep 2
2837       done
2838     fi
2839     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2840                    'stat=$?; rm -f "$lockfile"; exit $stat'
2841     if test "$lock_old_archive_extraction" = yes; then
2842       $opt_dry_run || rm -f "$lockfile"
2843     fi
2844     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2845      :
2846     else
2847       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2848     fi
2849 }
2850
2851
2852 # func_extract_archives gentop oldlib ...
2853 func_extract_archives ()
2854 {
2855     $opt_debug
2856     my_gentop="$1"; shift
2857     my_oldlibs=${1+"$@"}
2858     my_oldobjs=""
2859     my_xlib=""
2860     my_xabs=""
2861     my_xdir=""
2862
2863     for my_xlib in $my_oldlibs; do
2864       # Extract the objects.
2865       case $my_xlib in
2866         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2867         *) my_xabs=`pwd`"/$my_xlib" ;;
2868       esac
2869       func_basename "$my_xlib"
2870       my_xlib="$func_basename_result"
2871       my_xlib_u=$my_xlib
2872       while :; do
2873         case " $extracted_archives " in
2874         *" $my_xlib_u "*)
2875           func_arith $extracted_serial + 1
2876           extracted_serial=$func_arith_result
2877           my_xlib_u=lt$extracted_serial-$my_xlib ;;
2878         *) break ;;
2879         esac
2880       done
2881       extracted_archives="$extracted_archives $my_xlib_u"
2882       my_xdir="$my_gentop/$my_xlib_u"
2883
2884       func_mkdir_p "$my_xdir"
2885
2886       case $host in
2887       *-darwin*)
2888         func_verbose "Extracting $my_xabs"
2889         # Do not bother doing anything if just a dry run
2890         $opt_dry_run || {
2891           darwin_orig_dir=`pwd`
2892           cd $my_xdir || exit $?
2893           darwin_archive=$my_xabs
2894           darwin_curdir=`pwd`
2895           darwin_base_archive=`basename "$darwin_archive"`
2896           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2897           if test -n "$darwin_arches"; then
2898             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2899             darwin_arch=
2900             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2901             for darwin_arch in  $darwin_arches ; do
2902               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2903               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2904               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2905               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2906               cd "$darwin_curdir"
2907               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2908             done # $darwin_arches
2909             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2910             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2911             darwin_file=
2912             darwin_files=
2913             for darwin_file in $darwin_filelist; do
2914               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2915               $LIPO -create -output "$darwin_file" $darwin_files
2916             done # $darwin_filelist
2917             $RM -rf unfat-$$
2918             cd "$darwin_orig_dir"
2919           else
2920             cd $darwin_orig_dir
2921             func_extract_an_archive "$my_xdir" "$my_xabs"
2922           fi # $darwin_arches
2923         } # !$opt_dry_run
2924         ;;
2925       *)
2926         func_extract_an_archive "$my_xdir" "$my_xabs"
2927         ;;
2928       esac
2929       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2930     done
2931
2932     func_extract_archives_result="$my_oldobjs"
2933 }
2934
2935
2936 # func_emit_wrapper [arg=no]
2937 #
2938 # Emit a libtool wrapper script on stdout.
2939 # Don't directly open a file because we may want to
2940 # incorporate the script contents within a cygwin/mingw
2941 # wrapper executable.  Must ONLY be called from within
2942 # func_mode_link because it depends on a number of variables
2943 # set therein.
2944 #
2945 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2946 # variable will take.  If 'yes', then the emitted script
2947 # will assume that the directory in which it is stored is
2948 # the $objdir directory.  This is a cygwin/mingw-specific
2949 # behavior.
2950 func_emit_wrapper ()
2951 {
2952         func_emit_wrapper_arg1=${1-no}
2953
2954         $ECHO "\
2955 #! $SHELL
2956
2957 # $output - temporary wrapper script for $objdir/$outputname
2958 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2959 #
2960 # The $output program cannot be directly executed until all the libtool
2961 # libraries that it depends on are installed.
2962 #
2963 # This wrapper script should never be moved out of the build directory.
2964 # If it is, it will not operate correctly.
2965
2966 # Sed substitution that helps us do robust quoting.  It backslashifies
2967 # metacharacters that are still active within double-quoted strings.
2968 sed_quote_subst='$sed_quote_subst'
2969
2970 # Be Bourne compatible
2971 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2972   emulate sh
2973   NULLCMD=:
2974   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2975   # is contrary to our usage.  Disable this feature.
2976   alias -g '\${1+\"\$@\"}'='\"\$@\"'
2977   setopt NO_GLOB_SUBST
2978 else
2979   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2980 fi
2981 BIN_SH=xpg4; export BIN_SH # for Tru64
2982 DUALCASE=1; export DUALCASE # for MKS sh
2983
2984 # The HP-UX ksh and POSIX shell print the target directory to stdout
2985 # if CDPATH is set.
2986 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2987
2988 relink_command=\"$relink_command\"
2989
2990 # This environment variable determines our operation mode.
2991 if test \"\$libtool_install_magic\" = \"$magic\"; then
2992   # install mode needs the following variables:
2993   generated_by_libtool_version='$macro_version'
2994   notinst_deplibs='$notinst_deplibs'
2995 else
2996   # When we are sourced in execute mode, \$file and \$ECHO are already set.
2997   if test \"\$libtool_execute_magic\" != \"$magic\"; then
2998     file=\"\$0\""
2999
3000     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3001     $ECHO "\
3002
3003 # A function that is used when there is no print builtin or printf.
3004 func_fallback_echo ()
3005 {
3006   eval 'cat <<_LTECHO_EOF
3007 \$1
3008 _LTECHO_EOF'
3009 }
3010     ECHO=\"$qECHO\"
3011   fi\
3012
3013   # Find the directory that this script lives in.
3014   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3015   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3016
3017   # Follow symbolic links until we get to the real thisdir.
3018   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3019   while test -n \"\$file\"; do
3020     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3021
3022     # If there was a directory component, then change thisdir.
3023     if test \"x\$destdir\" != \"x\$file\"; then
3024       case \"\$destdir\" in
3025       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3026       *) thisdir=\"\$thisdir/\$destdir\" ;;
3027       esac
3028     fi
3029
3030     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3031     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3032   done
3033
3034   # Usually 'no', except on cygwin/mingw when embedded into
3035   # the cwrapper.
3036   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3037   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3038     # special case for '.'
3039     if test \"\$thisdir\" = \".\"; then
3040       thisdir=\`pwd\`
3041     fi
3042     # remove .libs from thisdir
3043     case \"\$thisdir\" in
3044     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3045     $objdir )   thisdir=. ;;
3046     esac
3047   fi
3048
3049   # Try to get the absolute directory name.
3050   absdir=\`cd \"\$thisdir\" && pwd\`
3051   test -n \"\$absdir\" && thisdir=\"\$absdir\"
3052 "
3053
3054         if test "$fast_install" = yes; then
3055           $ECHO "\
3056   program=lt-'$outputname'$exeext
3057   progdir=\"\$thisdir/$objdir\"
3058
3059   if test ! -f \"\$progdir/\$program\" ||
3060      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3061        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3062
3063     file=\"\$\$-\$program\"
3064
3065     if test ! -d \"\$progdir\"; then
3066       $MKDIR \"\$progdir\"
3067     else
3068       $RM \"\$progdir/\$file\"
3069     fi"
3070
3071           $ECHO "\
3072
3073     # relink executable if necessary
3074     if test -n \"\$relink_command\"; then
3075       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3076       else
3077         $ECHO \"\$relink_command_output\" >&2
3078         $RM \"\$progdir/\$file\"
3079         exit 1
3080       fi
3081     fi
3082
3083     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3084     { $RM \"\$progdir/\$program\";
3085       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3086     $RM \"\$progdir/\$file\"
3087   fi"
3088         else
3089           $ECHO "\
3090   program='$outputname'
3091   progdir=\"\$thisdir/$objdir\"
3092 "
3093         fi
3094
3095         $ECHO "\
3096
3097   if test -f \"\$progdir/\$program\"; then"
3098
3099         # Export our shlibpath_var if we have one.
3100         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3101           $ECHO "\
3102     # Add our own library path to $shlibpath_var
3103     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3104
3105     # Some systems cannot cope with colon-terminated $shlibpath_var
3106     # The second colon is a workaround for a bug in BeOS R4 sed
3107     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3108
3109     export $shlibpath_var
3110 "
3111         fi
3112
3113         # fixup the dll searchpath if we need to.
3114         if test -n "$dllsearchpath"; then
3115           $ECHO "\
3116     # Add the dll search path components to the executable PATH
3117     PATH=$dllsearchpath:\$PATH
3118 "
3119         fi
3120
3121         $ECHO "\
3122     if test \"\$libtool_execute_magic\" != \"$magic\"; then
3123       # Run the actual program with our arguments.
3124 "
3125         case $host in
3126         # Backslashes separate directories on plain windows
3127         *-*-mingw | *-*-os2* | *-cegcc*)
3128           $ECHO "\
3129       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3130 "
3131           ;;
3132
3133         *)
3134           $ECHO "\
3135       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3136 "
3137           ;;
3138         esac
3139         $ECHO "\
3140       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3141       exit 1
3142     fi
3143   else
3144     # The program doesn't exist.
3145     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3146     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3147     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3148     exit 1
3149   fi
3150 fi\
3151 "
3152 }
3153
3154
3155 # func_to_host_path arg
3156 #
3157 # Convert paths to host format when used with build tools.
3158 # Intended for use with "native" mingw (where libtool itself
3159 # is running under the msys shell), or in the following cross-
3160 # build environments:
3161 #    $build          $host
3162 #    mingw (msys)    mingw  [e.g. native]
3163 #    cygwin          mingw
3164 #    *nix + wine     mingw
3165 # where wine is equipped with the `winepath' executable.
3166 # In the native mingw case, the (msys) shell automatically
3167 # converts paths for any non-msys applications it launches,
3168 # but that facility isn't available from inside the cwrapper.
3169 # Similar accommodations are necessary for $host mingw and
3170 # $build cygwin.  Calling this function does no harm for other
3171 # $host/$build combinations not listed above.
3172 #
3173 # ARG is the path (on $build) that should be converted to
3174 # the proper representation for $host. The result is stored
3175 # in $func_to_host_path_result.
3176 func_to_host_path ()
3177 {
3178   func_to_host_path_result="$1"
3179   if test -n "$1"; then
3180     case $host in
3181       *mingw* )
3182         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3183         case $build in
3184           *mingw* ) # actually, msys
3185             # awkward: cmd appends spaces to result
3186             func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3187               $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3188             ;;
3189           *cygwin* )
3190             func_to_host_path_result=`cygpath -w "$1" |
3191               $SED -e "$lt_sed_naive_backslashify"`
3192             ;;
3193           * )
3194             # Unfortunately, winepath does not exit with a non-zero
3195             # error code, so we are forced to check the contents of
3196             # stdout. On the other hand, if the command is not
3197             # found, the shell will set an exit code of 127 and print
3198             # *an error message* to stdout. So we must check for both
3199             # error code of zero AND non-empty stdout, which explains
3200             # the odd construction:
3201             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3202             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3203               func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3204                 $SED -e "$lt_sed_naive_backslashify"`
3205             else
3206               # Allow warning below.
3207               func_to_host_path_result=
3208             fi
3209             ;;
3210         esac
3211         if test -z "$func_to_host_path_result" ; then
3212           func_error "Could not determine host path corresponding to"
3213           func_error "  \`$1'"
3214           func_error "Continuing, but uninstalled executables may not work."
3215           # Fallback:
3216           func_to_host_path_result="$1"
3217         fi
3218         ;;
3219     esac
3220   fi
3221 }
3222 # end: func_to_host_path
3223
3224 # func_to_host_pathlist arg
3225 #
3226 # Convert pathlists to host format when used with build tools.
3227 # See func_to_host_path(), above. This function supports the
3228 # following $build/$host combinations (but does no harm for
3229 # combinations not listed here):
3230 #    $build          $host
3231 #    mingw (msys)    mingw  [e.g. native]
3232 #    cygwin          mingw
3233 #    *nix + wine     mingw
3234 #
3235 # Path separators are also converted from $build format to
3236 # $host format. If ARG begins or ends with a path separator
3237 # character, it is preserved (but converted to $host format)
3238 # on output.
3239 #
3240 # ARG is a pathlist (on $build) that should be converted to
3241 # the proper representation on $host. The result is stored
3242 # in $func_to_host_pathlist_result.
3243 func_to_host_pathlist ()
3244 {
3245   func_to_host_pathlist_result="$1"
3246   if test -n "$1"; then
3247     case $host in
3248       *mingw* )
3249         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3250         # Remove leading and trailing path separator characters from
3251         # ARG. msys behavior is inconsistent here, cygpath turns them
3252         # into '.;' and ';.', and winepath ignores them completely.
3253         func_stripname : : "$1"
3254         func_to_host_pathlist_tmp1=$func_stripname_result
3255         case $build in
3256           *mingw* ) # Actually, msys.
3257             # Awkward: cmd appends spaces to result.
3258             func_to_host_pathlist_result=`
3259               ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
3260               $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3261             ;;
3262           *cygwin* )
3263             func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
3264               $SED -e "$lt_sed_naive_backslashify"`
3265             ;;
3266           * )
3267             # unfortunately, winepath doesn't convert pathlists
3268             func_to_host_pathlist_result=""
3269             func_to_host_pathlist_oldIFS=$IFS
3270             IFS=:
3271             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3272               IFS=$func_to_host_pathlist_oldIFS
3273               if test -n "$func_to_host_pathlist_f" ; then
3274                 func_to_host_path "$func_to_host_pathlist_f"
3275                 if test -n "$func_to_host_path_result" ; then
3276                   if test -z "$func_to_host_pathlist_result" ; then
3277                     func_to_host_pathlist_result="$func_to_host_path_result"
3278                   else
3279                     func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3280                   fi
3281                 fi
3282               fi
3283             done
3284             IFS=$func_to_host_pathlist_oldIFS
3285             ;;
3286         esac
3287         if test -z "$func_to_host_pathlist_result"; then
3288           func_error "Could not determine the host path(s) corresponding to"
3289           func_error "  \`$1'"
3290           func_error "Continuing, but uninstalled executables may not work."
3291           # Fallback. This may break if $1 contains DOS-style drive
3292           # specifications. The fix is not to complicate the expression
3293           # below, but for the user to provide a working wine installation
3294           # with winepath so that path translation in the cross-to-mingw
3295           # case works properly.
3296           lt_replace_pathsep_nix_to_dos="s|:|;|g"
3297           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3298             $SED -e "$lt_replace_pathsep_nix_to_dos"`
3299         fi
3300         # Now, add the leading and trailing path separators back
3301         case "$1" in
3302           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3303             ;;
3304         esac
3305         case "$1" in
3306           *: ) func_append func_to_host_pathlist_result ";"
3307             ;;
3308         esac
3309         ;;
3310     esac
3311   fi
3312 }
3313 # end: func_to_host_pathlist
3314
3315 # func_emit_cwrapperexe_src
3316 # emit the source code for a wrapper executable on stdout
3317 # Must ONLY be called from within func_mode_link because
3318 # it depends on a number of variable set therein.
3319 func_emit_cwrapperexe_src ()
3320 {
3321         cat <<EOF
3322
3323 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3324    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3325
3326    The $output program cannot be directly executed until all the libtool
3327    libraries that it depends on are installed.
3328
3329    This wrapper executable should never be moved out of the build directory.
3330    If it is, it will not operate correctly.
3331
3332    Currently, it simply execs the wrapper *script* "$SHELL $output",
3333    but could eventually absorb all of the scripts functionality and
3334    exec $objdir/$outputname directly.
3335 */
3336 EOF
3337             cat <<"EOF"
3338 #ifdef _MSC_VER
3339 # define _CRT_SECURE_NO_DEPRECATE 1
3340 #endif
3341 #include <stdio.h>
3342 #include <stdlib.h>
3343 #ifdef _MSC_VER
3344 # include <direct.h>
3345 # include <process.h>
3346 # include <io.h>
3347 #else
3348 # include <unistd.h>
3349 # include <stdint.h>
3350 # ifdef __CYGWIN__
3351 #  include <io.h>
3352 # endif
3353 #endif
3354 #include <malloc.h>
3355 #include <stdarg.h>
3356 #include <assert.h>
3357 #include <string.h>
3358 #include <ctype.h>
3359 #include <errno.h>
3360 #include <fcntl.h>
3361 #include <sys/stat.h>
3362
3363 /* declarations of non-ANSI functions */
3364 #if defined(__MINGW32__)
3365 # ifdef __STRICT_ANSI__
3366 int _putenv (const char *);
3367 # endif
3368 #elif defined(__CYGWIN__)
3369 # ifdef __STRICT_ANSI__
3370 char *realpath (const char *, char *);
3371 int putenv (char *);
3372 int setenv (const char *, const char *, int);
3373 # endif
3374 /* #elif defined (other platforms) ... */
3375 #endif
3376
3377 /* portability defines, excluding path handling macros */
3378 #if defined(_MSC_VER)
3379 # define setmode _setmode
3380 # define stat    _stat
3381 # define chmod   _chmod
3382 # define getcwd  _getcwd
3383 # define putenv  _putenv
3384 # define S_IXUSR _S_IEXEC
3385 # ifndef _INTPTR_T_DEFINED
3386 #  define _INTPTR_T_DEFINED
3387 #  define intptr_t int
3388 # endif
3389 #elif defined(__MINGW32__)
3390 # define setmode _setmode
3391 # define stat    _stat
3392 # define chmod   _chmod
3393 # define getcwd  _getcwd
3394 # define putenv  _putenv
3395 #elif defined(__CYGWIN__)
3396 # define HAVE_SETENV
3397 # define FOPEN_WB "wb"
3398 /* #elif defined (other platforms) ... */
3399 #endif
3400
3401 #if defined(PATH_MAX)
3402 # define LT_PATHMAX PATH_MAX
3403 #elif defined(MAXPATHLEN)
3404 # define LT_PATHMAX MAXPATHLEN
3405 #else
3406 # define LT_PATHMAX 1024
3407 #endif
3408
3409 #ifndef S_IXOTH
3410 # define S_IXOTH 0
3411 #endif
3412 #ifndef S_IXGRP
3413 # define S_IXGRP 0
3414 #endif
3415
3416 /* path handling portability macros */
3417 #ifndef DIR_SEPARATOR
3418 # define DIR_SEPARATOR '/'
3419 # define PATH_SEPARATOR ':'
3420 #endif
3421
3422 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3423   defined (__OS2__)
3424 # define HAVE_DOS_BASED_FILE_SYSTEM
3425 # define FOPEN_WB "wb"
3426 # ifndef DIR_SEPARATOR_2
3427 #  define DIR_SEPARATOR_2 '\\'
3428 # endif
3429 # ifndef PATH_SEPARATOR_2
3430 #  define PATH_SEPARATOR_2 ';'
3431 # endif
3432 #endif
3433
3434 #ifndef DIR_SEPARATOR_2
3435 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3436 #else /* DIR_SEPARATOR_2 */
3437 # define IS_DIR_SEPARATOR(ch) \
3438         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3439 #endif /* DIR_SEPARATOR_2 */
3440
3441 #ifndef PATH_SEPARATOR_2
3442 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3443 #else /* PATH_SEPARATOR_2 */
3444 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3445 #endif /* PATH_SEPARATOR_2 */
3446
3447 #ifndef FOPEN_WB
3448 # define FOPEN_WB "w"
3449 #endif
3450 #ifndef _O_BINARY
3451 # define _O_BINARY 0
3452 #endif
3453
3454 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3455 #define XFREE(stale) do { \
3456   if (stale) { free ((void *) stale); stale = 0; } \
3457 } while (0)
3458
3459 #undef LTWRAPPER_DEBUGPRINTF
3460 #if defined LT_DEBUGWRAPPER
3461 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3462 static void
3463 ltwrapper_debugprintf (const char *fmt, ...)
3464 {
3465     va_list args;
3466     va_start (args, fmt);
3467     (void) vfprintf (stderr, fmt, args);
3468     va_end (args);
3469 }
3470 #else
3471 # define LTWRAPPER_DEBUGPRINTF(args)
3472 #endif
3473
3474 const char *program_name = NULL;
3475
3476 void *xmalloc (size_t num);
3477 char *xstrdup (const char *string);
3478 const char *base_name (const char *name);
3479 char *find_executable (const char *wrapper);
3480 char *chase_symlinks (const char *pathspec);
3481 int make_executable (const char *path);
3482 int check_executable (const char *path);
3483 char *strendzap (char *str, const char *pat);
3484 void lt_fatal (const char *message, ...);
3485 void lt_setenv (const char *name, const char *value);
3486 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3487 void lt_update_exe_path (const char *name, const char *value);
3488 void lt_update_lib_path (const char *name, const char *value);
3489 char **prepare_spawn (char **argv);
3490 void lt_dump_script (FILE *f);
3491 EOF
3492
3493             cat <<EOF
3494 const char * MAGIC_EXE = "$magic_exe";
3495 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3496 EOF
3497
3498             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3499               func_to_host_pathlist "$temp_rpath"
3500               cat <<EOF
3501 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3502 EOF
3503             else
3504               cat <<"EOF"
3505 const char * LIB_PATH_VALUE   = "";
3506 EOF
3507             fi
3508
3509             if test -n "$dllsearchpath"; then
3510               func_to_host_pathlist "$dllsearchpath:"
3511               cat <<EOF
3512 const char * EXE_PATH_VARNAME = "PATH";
3513 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3514 EOF
3515             else
3516               cat <<"EOF"
3517 const char * EXE_PATH_VARNAME = "";
3518 const char * EXE_PATH_VALUE   = "";
3519 EOF
3520             fi
3521
3522             if test "$fast_install" = yes; then
3523               cat <<EOF
3524 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3525 EOF
3526             else
3527               cat <<EOF
3528 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3529 EOF
3530             fi
3531
3532
3533             cat <<"EOF"
3534
3535 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
3536 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3537
3538 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3539 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3540
3541 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3542
3543 int
3544 main (int argc, char *argv[])
3545 {
3546   char **newargz;
3547   int  newargc;
3548   char *tmp_pathspec;
3549   char *actual_cwrapper_path;
3550   char *actual_cwrapper_name;
3551   char *target_name;
3552   char *lt_argv_zero;
3553   intptr_t rval = 127;
3554
3555   int i;
3556
3557   program_name = (char *) xstrdup (base_name (argv[0]));
3558   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3559   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3560
3561   /* very simple arg parsing; don't want to rely on getopt */
3562   for (i = 1; i < argc; i++)
3563     {
3564       if (strcmp (argv[i], dumpscript_opt) == 0)
3565         {
3566 EOF
3567             case "$host" in
3568               *mingw* | *cygwin* )
3569                 # make stdout use "unix" line endings
3570                 echo "          setmode(1,_O_BINARY);"
3571                 ;;
3572               esac
3573
3574             cat <<"EOF"
3575           lt_dump_script (stdout);
3576           return 0;
3577         }
3578     }
3579
3580   newargz = XMALLOC (char *, argc + 1);
3581   tmp_pathspec = find_executable (argv[0]);
3582   if (tmp_pathspec == NULL)
3583     lt_fatal ("Couldn't find %s", argv[0]);
3584   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3585                           tmp_pathspec));
3586
3587   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3588   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3589                           actual_cwrapper_path));
3590   XFREE (tmp_pathspec);
3591
3592   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3593   strendzap (actual_cwrapper_path, actual_cwrapper_name);
3594
3595   /* wrapper name transforms */
3596   strendzap (actual_cwrapper_name, ".exe");
3597   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3598   XFREE (actual_cwrapper_name);
3599   actual_cwrapper_name = tmp_pathspec;
3600   tmp_pathspec = 0;
3601
3602   /* target_name transforms -- use actual target program name; might have lt- prefix */
3603   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3604   strendzap (target_name, ".exe");
3605   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3606   XFREE (target_name);
3607   target_name = tmp_pathspec;
3608   tmp_pathspec = 0;
3609
3610   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3611                           target_name));
3612 EOF
3613
3614             cat <<EOF
3615   newargz[0] =
3616     XMALLOC (char, (strlen (actual_cwrapper_path) +
3617                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3618   strcpy (newargz[0], actual_cwrapper_path);
3619   strcat (newargz[0], "$objdir");
3620   strcat (newargz[0], "/");
3621 EOF
3622
3623             cat <<"EOF"
3624   /* stop here, and copy so we don't have to do this twice */
3625   tmp_pathspec = xstrdup (newargz[0]);
3626
3627   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3628   strcat (newargz[0], actual_cwrapper_name);
3629
3630   /* DO want the lt- prefix here if it exists, so use target_name */
3631   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3632   XFREE (tmp_pathspec);
3633   tmp_pathspec = NULL;
3634 EOF
3635
3636             case $host_os in
3637               mingw*)
3638             cat <<"EOF"
3639   {
3640     char* p;
3641     while ((p = strchr (newargz[0], '\\')) != NULL)
3642       {
3643         *p = '/';
3644       }
3645     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3646       {
3647         *p = '/';
3648       }
3649   }
3650 EOF
3651             ;;
3652             esac
3653
3654             cat <<"EOF"
3655   XFREE (target_name);
3656   XFREE (actual_cwrapper_path);
3657   XFREE (actual_cwrapper_name);
3658
3659   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3660   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3661   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3662   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3663
3664   newargc=0;
3665   for (i = 1; i < argc; i++)
3666     {
3667       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3668         {
3669           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3670              namespace, but it is not one of the ones we know about and
3671              have already dealt with, above (inluding dump-script), then
3672              report an error. Otherwise, targets might begin to believe
3673              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3674              namespace. The first time any user complains about this, we'll
3675              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3676              or a configure.ac-settable value.
3677            */
3678           lt_fatal ("Unrecognized option in %s namespace: '%s'",
3679                     ltwrapper_option_prefix, argv[i]);
3680         }
3681       /* otherwise ... */
3682       newargz[++newargc] = xstrdup (argv[i]);
3683     }
3684   newargz[++newargc] = NULL;
3685
3686   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3687   for (i = 0; i < newargc; i++)
3688     {
3689       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3690     }
3691
3692 EOF
3693
3694             case $host_os in
3695               mingw*)
3696                 cat <<"EOF"
3697   /* execv doesn't actually work on mingw as expected on unix */
3698   newargz = prepare_spawn (newargz);
3699   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3700   if (rval == -1)
3701     {
3702       /* failed to start process */
3703       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3704       return 127;
3705     }
3706   return rval;
3707 EOF
3708                 ;;
3709               *)
3710                 cat <<"EOF"
3711   execv (lt_argv_zero, newargz);
3712   return rval; /* =127, but avoids unused variable warning */
3713 EOF
3714                 ;;
3715             esac
3716
3717             cat <<"EOF"
3718 }
3719
3720 void *
3721 xmalloc (size_t num)
3722 {
3723   void *p = (void *) malloc (num);
3724   if (!p)
3725     lt_fatal ("Memory exhausted");
3726
3727   return p;
3728 }
3729
3730 char *
3731 xstrdup (const char *string)
3732 {
3733   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3734                           string) : NULL;
3735 }
3736
3737 const char *
3738 base_name (const char *name)
3739 {
3740   const char *base;
3741
3742 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3743   /* Skip over the disk name in MSDOS pathnames. */
3744   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3745     name += 2;
3746 #endif
3747
3748   for (base = name; *name; name++)
3749     if (IS_DIR_SEPARATOR (*name))
3750       base = name + 1;
3751   return base;
3752 }
3753
3754 int
3755 check_executable (const char *path)
3756 {
3757   struct stat st;
3758
3759   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
3760                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3761   if ((!path) || (!*path))
3762     return 0;
3763
3764   if ((stat (path, &st) >= 0)
3765       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3766     return 1;
3767   else
3768     return 0;
3769 }
3770
3771 int
3772 make_executable (const char *path)
3773 {
3774   int rval = 0;
3775   struct stat st;
3776
3777   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
3778                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3779   if ((!path) || (!*path))
3780     return 0;
3781
3782   if (stat (path, &st) >= 0)
3783     {
3784       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3785     }
3786   return rval;
3787 }
3788
3789 /* Searches for the full path of the wrapper.  Returns
3790    newly allocated full path name if found, NULL otherwise
3791    Does not chase symlinks, even on platforms that support them.
3792 */
3793 char *
3794 find_executable (const char *wrapper)
3795 {
3796   int has_slash = 0;
3797   const char *p;
3798   const char *p_next;
3799   /* static buffer for getcwd */
3800   char tmp[LT_PATHMAX + 1];
3801   int tmp_len;
3802   char *concat_name;
3803
3804   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
3805                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3806
3807   if ((wrapper == NULL) || (*wrapper == '\0'))
3808     return NULL;
3809
3810   /* Absolute path? */
3811 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3812   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3813     {
3814       concat_name = xstrdup (wrapper);
3815       if (check_executable (concat_name))
3816         return concat_name;
3817       XFREE (concat_name);
3818     }
3819   else
3820     {
3821 #endif
3822       if (IS_DIR_SEPARATOR (wrapper[0]))
3823         {
3824           concat_name = xstrdup (wrapper);
3825           if (check_executable (concat_name))
3826             return concat_name;
3827           XFREE (concat_name);
3828         }
3829 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3830     }
3831 #endif
3832
3833   for (p = wrapper; *p; p++)
3834     if (*p == '/')
3835       {
3836         has_slash = 1;
3837         break;
3838       }
3839   if (!has_slash)
3840     {
3841       /* no slashes; search PATH */
3842       const char *path = getenv ("PATH");
3843       if (path != NULL)
3844         {
3845           for (p = path; *p; p = p_next)
3846             {
3847               const char *q;
3848               size_t p_len;
3849               for (q = p; *q; q++)
3850                 if (IS_PATH_SEPARATOR (*q))
3851                   break;
3852               p_len = q - p;
3853               p_next = (*q == '\0' ? q : q + 1);
3854               if (p_len == 0)
3855                 {
3856                   /* empty path: current directory */
3857                   if (getcwd (tmp, LT_PATHMAX) == NULL)
3858                     lt_fatal ("getcwd failed");
3859                   tmp_len = strlen (tmp);
3860                   concat_name =
3861                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3862                   memcpy (concat_name, tmp, tmp_len);
3863                   concat_name[tmp_len] = '/';
3864                   strcpy (concat_name + tmp_len + 1, wrapper);
3865                 }
3866               else
3867                 {
3868                   concat_name =
3869                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3870                   memcpy (concat_name, p, p_len);
3871                   concat_name[p_len] = '/';
3872                   strcpy (concat_name + p_len + 1, wrapper);
3873                 }
3874               if (check_executable (concat_name))
3875                 return concat_name;
3876               XFREE (concat_name);
3877             }
3878         }
3879       /* not found in PATH; assume curdir */
3880     }
3881   /* Relative path | not found in path: prepend cwd */
3882   if (getcwd (tmp, LT_PATHMAX) == NULL)
3883     lt_fatal ("getcwd failed");
3884   tmp_len = strlen (tmp);
3885   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3886   memcpy (concat_name, tmp, tmp_len);
3887   concat_name[tmp_len] = '/';
3888   strcpy (concat_name + tmp_len + 1, wrapper);
3889
3890   if (check_executable (concat_name))
3891     return concat_name;
3892   XFREE (concat_name);
3893   return NULL;
3894 }
3895
3896 char *
3897 chase_symlinks (const char *pathspec)
3898 {
3899 #ifndef S_ISLNK
3900   return xstrdup (pathspec);
3901 #else
3902   char buf[LT_PATHMAX];
3903   struct stat s;
3904   char *tmp_pathspec = xstrdup (pathspec);
3905   char *p;
3906   int has_symlinks = 0;
3907   while (strlen (tmp_pathspec) && !has_symlinks)
3908     {
3909       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3910                               tmp_pathspec));
3911       if (lstat (tmp_pathspec, &s) == 0)
3912         {
3913           if (S_ISLNK (s.st_mode) != 0)
3914             {
3915               has_symlinks = 1;
3916               break;
3917             }
3918
3919           /* search backwards for last DIR_SEPARATOR */
3920           p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3921           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3922             p--;
3923           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3924             {
3925               /* no more DIR_SEPARATORS left */
3926               break;
3927             }
3928           *p = '\0';
3929         }
3930       else
3931         {
3932           char *errstr = strerror (errno);
3933           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3934         }
3935     }
3936   XFREE (tmp_pathspec);
3937
3938   if (!has_symlinks)
3939     {
3940       return xstrdup (pathspec);
3941     }
3942
3943   tmp_pathspec = realpath (pathspec, buf);
3944   if (tmp_pathspec == 0)
3945     {
3946       lt_fatal ("Could not follow symlinks for %s", pathspec);
3947     }
3948   return xstrdup (tmp_pathspec);
3949 #endif
3950 }
3951
3952 char *
3953 strendzap (char *str, const char *pat)
3954 {
3955   size_t len, patlen;
3956
3957   assert (str != NULL);
3958   assert (pat != NULL);
3959
3960   len = strlen (str);
3961   patlen = strlen (pat);
3962
3963   if (patlen <= len)
3964     {
3965       str += len - patlen;
3966       if (strcmp (str, pat) == 0)
3967         *str = '\0';
3968     }
3969   return str;
3970 }
3971
3972 static void
3973 lt_error_core (int exit_status, const char *mode,
3974                const char *message, va_list ap)
3975 {
3976   fprintf (stderr, "%s: %s: ", program_name, mode);
3977   vfprintf (stderr, message, ap);
3978   fprintf (stderr, ".\n");
3979
3980   if (exit_status >= 0)
3981     exit (exit_status);
3982 }
3983
3984 void
3985 lt_fatal (const char *message, ...)
3986 {
3987   va_list ap;
3988   va_start (ap, message);
3989   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3990   va_end (ap);
3991 }
3992
3993 void
3994 lt_setenv (const char *name, const char *value)
3995 {
3996   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3997                           (name ? name : "<NULL>"),
3998                           (value ? value : "<NULL>")));
3999   {
4000 #ifdef HAVE_SETENV
4001     /* always make a copy, for consistency with !HAVE_SETENV */
4002     char *str = xstrdup (value);
4003     setenv (name, str, 1);
4004 #else
4005     int len = strlen (name) + 1 + strlen (value) + 1;
4006     char *str = XMALLOC (char, len);
4007     sprintf (str, "%s=%s", name, value);
4008     if (putenv (str) != EXIT_SUCCESS)
4009       {
4010         XFREE (str);
4011       }
4012 #endif
4013   }
4014 }
4015
4016 char *
4017 lt_extend_str (const char *orig_value, const char *add, int to_end)
4018 {
4019   char *new_value;
4020   if (orig_value && *orig_value)
4021     {
4022       int orig_value_len = strlen (orig_value);
4023       int add_len = strlen (add);
4024       new_value = XMALLOC (char, add_len + orig_value_len + 1);
4025       if (to_end)
4026         {
4027           strcpy (new_value, orig_value);
4028           strcpy (new_value + orig_value_len, add);
4029         }
4030       else
4031         {
4032           strcpy (new_value, add);
4033           strcpy (new_value + add_len, orig_value);
4034         }
4035     }
4036   else
4037     {
4038       new_value = xstrdup (add);
4039     }
4040   return new_value;
4041 }
4042
4043 void
4044 lt_update_exe_path (const char *name, const char *value)
4045 {
4046   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4047                           (name ? name : "<NULL>"),
4048                           (value ? value : "<NULL>")));
4049
4050   if (name && *name && value && *value)
4051     {
4052       char *new_value = lt_extend_str (getenv (name), value, 0);
4053       /* some systems can't cope with a ':'-terminated path #' */
4054       int len = strlen (new_value);
4055       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4056         {
4057           new_value[len-1] = '\0';
4058         }
4059       lt_setenv (name, new_value);
4060       XFREE (new_value);
4061     }
4062 }
4063
4064 void
4065 lt_update_lib_path (const char *name, const char *value)
4066 {
4067   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4068                           (name ? name : "<NULL>"),
4069                           (value ? value : "<NULL>")));
4070
4071   if (name && *name && value && *value)
4072     {
4073       char *new_value = lt_extend_str (getenv (name), value, 0);
4074       lt_setenv (name, new_value);
4075       XFREE (new_value);
4076     }
4077 }
4078
4079 EOF
4080             case $host_os in
4081               mingw*)
4082                 cat <<"EOF"
4083
4084 /* Prepares an argument vector before calling spawn().
4085    Note that spawn() does not by itself call the command interpreter
4086      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4087       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4088          GetVersionEx(&v);
4089          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4090       }) ? "cmd.exe" : "command.com").
4091    Instead it simply concatenates the arguments, separated by ' ', and calls
4092    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4093    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4094    special way:
4095    - Space and tab are interpreted as delimiters. They are not treated as
4096      delimiters if they are surrounded by double quotes: "...".
4097    - Unescaped double quotes are removed from the input. Their only effect is
4098      that within double quotes, space and tab are treated like normal
4099      characters.
4100    - Backslashes not followed by double quotes are not special.
4101    - But 2*n+1 backslashes followed by a double quote become
4102      n backslashes followed by a double quote (n >= 0):
4103        \" -> "
4104        \\\" -> \"
4105        \\\\\" -> \\"
4106  */
4107 #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"
4108 #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"
4109 char **
4110 prepare_spawn (char **argv)
4111 {
4112   size_t argc;
4113   char **new_argv;
4114   size_t i;
4115
4116   /* Count number of arguments.  */
4117   for (argc = 0; argv[argc] != NULL; argc++)
4118     ;
4119
4120   /* Allocate new argument vector.  */
4121   new_argv = XMALLOC (char *, argc + 1);
4122
4123   /* Put quoted arguments into the new argument vector.  */
4124   for (i = 0; i < argc; i++)
4125     {
4126       const char *string = argv[i];
4127
4128       if (string[0] == '\0')
4129         new_argv[i] = xstrdup ("\"\"");
4130       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4131         {
4132           int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4133           size_t length;
4134           unsigned int backslashes;
4135           const char *s;
4136           char *quoted_string;
4137           char *p;
4138
4139           length = 0;
4140           backslashes = 0;
4141           if (quote_around)
4142             length++;
4143           for (s = string; *s != '\0'; s++)
4144             {
4145               char c = *s;
4146               if (c == '"')
4147                 length += backslashes + 1;
4148               length++;
4149               if (c == '\\')
4150                 backslashes++;
4151               else
4152                 backslashes = 0;
4153             }
4154           if (quote_around)
4155             length += backslashes + 1;
4156
4157           quoted_string = XMALLOC (char, length + 1);
4158
4159           p = quoted_string;
4160           backslashes = 0;
4161           if (quote_around)
4162             *p++ = '"';
4163           for (s = string; *s != '\0'; s++)
4164             {
4165               char c = *s;
4166               if (c == '"')
4167                 {
4168                   unsigned int j;
4169                   for (j = backslashes + 1; j > 0; j--)
4170                     *p++ = '\\';
4171                 }
4172               *p++ = c;
4173               if (c == '\\')
4174                 backslashes++;
4175               else
4176                 backslashes = 0;
4177             }
4178           if (quote_around)
4179             {
4180               unsigned int j;
4181               for (j = backslashes; j > 0; j--)
4182                 *p++ = '\\';
4183               *p++ = '"';
4184             }
4185           *p = '\0';
4186
4187           new_argv[i] = quoted_string;
4188         }
4189       else
4190         new_argv[i] = (char *) string;
4191     }
4192   new_argv[argc] = NULL;
4193
4194   return new_argv;
4195 }
4196 EOF
4197                 ;;
4198             esac
4199
4200             cat <<"EOF"
4201 void lt_dump_script (FILE* f)
4202 {
4203 EOF
4204             func_emit_wrapper yes |
4205               $SED -e 's/\([\\"]\)/\\\1/g' \
4206                    -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
4207
4208             cat <<"EOF"
4209 }
4210 EOF
4211 }
4212 # end: func_emit_cwrapperexe_src
4213
4214 # func_win32_import_lib_p ARG
4215 # True if ARG is an import lib, as indicated by $file_magic_cmd
4216 func_win32_import_lib_p ()
4217 {
4218     $opt_debug
4219     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
4220     *import*) : ;;
4221     *) false ;;
4222     esac
4223 }
4224
4225 # func_mode_link arg...
4226 func_mode_link ()
4227 {
4228     $opt_debug
4229     case $host in
4230     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4231       # It is impossible to link a dll without this setting, and
4232       # we shouldn't force the makefile maintainer to figure out
4233       # which system we are compiling for in order to pass an extra
4234       # flag for every libtool invocation.
4235       # allow_undefined=no
4236
4237       # FIXME: Unfortunately, there are problems with the above when trying
4238       # to make a dll which has undefined symbols, in which case not
4239       # even a static library is built.  For now, we need to specify
4240       # -no-undefined on the libtool link line when we can be certain
4241       # that all symbols are satisfied, otherwise we get a static library.
4242       allow_undefined=yes
4243       ;;
4244     *)
4245       allow_undefined=yes
4246       ;;
4247     esac
4248     libtool_args=$nonopt
4249     base_compile="$nonopt $@"
4250     compile_command=$nonopt
4251     finalize_command=$nonopt
4252
4253     compile_rpath=
4254     finalize_rpath=
4255     compile_shlibpath=
4256     finalize_shlibpath=
4257     convenience=
4258     old_convenience=
4259     deplibs=
4260     old_deplibs=
4261     compiler_flags=
4262     linker_flags=
4263     dllsearchpath=
4264     lib_search_path=`pwd`
4265     inst_prefix_dir=
4266     new_inherited_linker_flags=
4267
4268     avoid_version=no
4269     bindir=
4270     dlfiles=
4271     dlprefiles=
4272     dlself=no
4273     export_dynamic=no
4274     export_symbols=
4275     export_symbols_regex=
4276     generated=
4277     libobjs=
4278     ltlibs=
4279     module=no
4280     no_install=no
4281     objs=
4282     non_pic_objects=
4283     precious_files_regex=
4284     prefer_static_libs=no
4285     preload=no
4286     prev=
4287     prevarg=
4288     release=
4289     rpath=
4290     xrpath=
4291     perm_rpath=
4292     temp_rpath=
4293     thread_safe=no
4294     vinfo=
4295     vinfo_number=no
4296     weak_libs=
4297     single_module="${wl}-single_module"
4298     func_infer_tag $base_compile
4299
4300     # We need to know -static, to get the right output filenames.
4301     for arg
4302     do
4303       case $arg in
4304       -shared)
4305         test "$build_libtool_libs" != yes && \
4306           func_fatal_configuration "can not build a shared library"
4307         build_old_libs=no
4308         break
4309         ;;
4310       -all-static | -static | -static-libtool-libs)
4311         case $arg in
4312         -all-static)
4313           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4314             func_warning "complete static linking is impossible in this configuration"
4315           fi
4316           if test -n "$link_static_flag"; then
4317             dlopen_self=$dlopen_self_static
4318           fi
4319           prefer_static_libs=yes
4320           ;;
4321         -static)
4322           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4323             dlopen_self=$dlopen_self_static
4324           fi
4325           prefer_static_libs=built
4326           ;;
4327         -static-libtool-libs)
4328           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4329             dlopen_self=$dlopen_self_static
4330           fi
4331           prefer_static_libs=yes
4332           ;;
4333         esac
4334         build_libtool_libs=no
4335         build_old_libs=yes
4336         break
4337         ;;
4338       esac
4339     done
4340
4341     # See if our shared archives depend on static archives.
4342     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4343
4344     # Go through the arguments, transforming them on the way.
4345     while test "$#" -gt 0; do
4346       arg="$1"
4347       shift
4348       func_quote_for_eval "$arg"
4349       qarg=$func_quote_for_eval_unquoted_result
4350       func_append libtool_args " $func_quote_for_eval_result"
4351
4352       # If the previous option needs an argument, assign it.
4353       if test -n "$prev"; then
4354         case $prev in
4355         output)
4356           func_append compile_command " @OUTPUT@"
4357           func_append finalize_command " @OUTPUT@"
4358           ;;
4359         esac
4360
4361         case $prev in
4362         bindir)
4363           bindir="$arg"
4364           prev=
4365           continue
4366           ;;
4367         dlfiles|dlprefiles)
4368           if test "$preload" = no; then
4369             # Add the symbol object into the linking commands.
4370             func_append compile_command " @SYMFILE@"
4371             func_append finalize_command " @SYMFILE@"
4372             preload=yes
4373           fi
4374           case $arg in
4375           *.la | *.lo) ;;  # We handle these cases below.
4376           force)
4377             if test "$dlself" = no; then
4378               dlself=needless
4379               export_dynamic=yes
4380             fi
4381             prev=
4382             continue
4383             ;;
4384           self)
4385             if test "$prev" = dlprefiles; then
4386               dlself=yes
4387             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4388               dlself=yes
4389             else
4390               dlself=needless
4391               export_dynamic=yes
4392             fi
4393             prev=
4394             continue
4395             ;;
4396           *)
4397             if test "$prev" = dlfiles; then
4398               dlfiles="$dlfiles $arg"
4399             else
4400               dlprefiles="$dlprefiles $arg"
4401             fi
4402             prev=
4403             continue
4404             ;;
4405           esac
4406           ;;
4407         expsyms)
4408           export_symbols="$arg"
4409           test -f "$arg" \
4410             || func_fatal_error "symbol file \`$arg' does not exist"
4411           prev=
4412           continue
4413           ;;
4414         expsyms_regex)
4415           export_symbols_regex="$arg"
4416           prev=
4417           continue
4418           ;;
4419         framework)
4420           case $host in
4421             *-*-darwin*)
4422               case "$deplibs " in
4423                 *" $qarg.ltframework "*) ;;
4424                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4425                    ;;
4426               esac
4427               ;;
4428           esac
4429           prev=
4430           continue
4431           ;;
4432         inst_prefix)
4433           inst_prefix_dir="$arg"
4434           prev=
4435           continue
4436           ;;
4437         objectlist)
4438           if test -f "$arg"; then
4439             save_arg=$arg
4440             moreargs=
4441             for fil in `cat "$save_arg"`
4442             do
4443 #             moreargs="$moreargs $fil"
4444               arg=$fil
4445               # A libtool-controlled object.
4446
4447               # Check to see that this really is a libtool object.
4448               if func_lalib_unsafe_p "$arg"; then
4449                 pic_object=
4450                 non_pic_object=
4451
4452                 # Read the .lo file
4453                 func_source "$arg"
4454
4455                 if test -z "$pic_object" ||
4456                    test -z "$non_pic_object" ||
4457                    test "$pic_object" = none &&
4458                    test "$non_pic_object" = none; then
4459                   func_fatal_error "cannot find name of object for \`$arg'"
4460                 fi
4461
4462                 # Extract subdirectory from the argument.
4463                 func_dirname "$arg" "/" ""
4464                 xdir="$func_dirname_result"
4465
4466                 if test "$pic_object" != none; then
4467                   # Prepend the subdirectory the object is found in.
4468                   pic_object="$xdir$pic_object"
4469
4470                   if test "$prev" = dlfiles; then
4471                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4472                       dlfiles="$dlfiles $pic_object"
4473                       prev=
4474                       continue
4475                     else
4476                       # If libtool objects are unsupported, then we need to preload.
4477                       prev=dlprefiles
4478                     fi
4479                   fi
4480
4481                   # CHECK ME:  I think I busted this.  -Ossama
4482                   if test "$prev" = dlprefiles; then
4483                     # Preload the old-style object.
4484                     dlprefiles="$dlprefiles $pic_object"
4485                     prev=
4486                   fi
4487
4488                   # A PIC object.
4489                   func_append libobjs " $pic_object"
4490                   arg="$pic_object"
4491                 fi
4492
4493                 # Non-PIC object.
4494                 if test "$non_pic_object" != none; then
4495                   # Prepend the subdirectory the object is found in.
4496                   non_pic_object="$xdir$non_pic_object"
4497
4498                   # A standard non-PIC object
4499                   func_append non_pic_objects " $non_pic_object"
4500                   if test -z "$pic_object" || test "$pic_object" = none ; then
4501                     arg="$non_pic_object"
4502                   fi
4503                 else
4504                   # If the PIC object exists, use it instead.
4505                   # $xdir was prepended to $pic_object above.
4506                   non_pic_object="$pic_object"
4507                   func_append non_pic_objects " $non_pic_object"
4508                 fi
4509               else
4510                 # Only an error if not doing a dry-run.
4511                 if $opt_dry_run; then
4512                   # Extract subdirectory from the argument.
4513                   func_dirname "$arg" "/" ""
4514                   xdir="$func_dirname_result"
4515
4516                   func_lo2o "$arg"
4517                   pic_object=$xdir$objdir/$func_lo2o_result
4518                   non_pic_object=$xdir$func_lo2o_result
4519                   func_append libobjs " $pic_object"
4520                   func_append non_pic_objects " $non_pic_object"
4521                 else
4522                   func_fatal_error "\`$arg' is not a valid libtool object"
4523                 fi
4524               fi
4525             done
4526           else
4527             func_fatal_error "link input file \`$arg' does not exist"
4528           fi
4529           arg=$save_arg
4530           prev=
4531           continue
4532           ;;
4533         precious_regex)
4534           precious_files_regex="$arg"
4535           prev=
4536           continue
4537           ;;
4538         release)
4539           release="-$arg"
4540           prev=
4541           continue
4542           ;;
4543         rpath | xrpath)
4544           # We need an absolute path.
4545           case $arg in
4546           [\\/]* | [A-Za-z]:[\\/]*) ;;
4547           *)
4548             func_fatal_error "only absolute run-paths are allowed"
4549             ;;
4550           esac
4551           if test "$prev" = rpath; then
4552             case "$rpath " in
4553             *" $arg "*) ;;
4554             *) rpath="$rpath $arg" ;;
4555             esac
4556           else
4557             case "$xrpath " in
4558             *" $arg "*) ;;
4559             *) xrpath="$xrpath $arg" ;;
4560             esac
4561           fi
4562           prev=
4563           continue
4564           ;;
4565         shrext)
4566           shrext_cmds="$arg"
4567           prev=
4568           continue
4569           ;;
4570         weak)
4571           weak_libs="$weak_libs $arg"
4572           prev=
4573           continue
4574           ;;
4575         xcclinker)
4576           linker_flags="$linker_flags $qarg"
4577           compiler_flags="$compiler_flags $qarg"
4578           prev=
4579           func_append compile_command " $qarg"
4580           func_append finalize_command " $qarg"
4581           continue
4582           ;;
4583         xcompiler)
4584           compiler_flags="$compiler_flags $qarg"
4585           prev=
4586           func_append compile_command " $qarg"
4587           func_append finalize_command " $qarg"
4588           continue
4589           ;;
4590         xlinker)
4591           linker_flags="$linker_flags $qarg"
4592           compiler_flags="$compiler_flags $wl$qarg"
4593           prev=
4594           func_append compile_command " $wl$qarg"
4595           func_append finalize_command " $wl$qarg"
4596           continue
4597           ;;
4598         *)
4599           eval "$prev=\"\$arg\""
4600           prev=
4601           continue
4602           ;;
4603         esac
4604       fi # test -n "$prev"
4605
4606       prevarg="$arg"
4607
4608       case $arg in
4609       -all-static)
4610         if test -n "$link_static_flag"; then
4611           # See comment for -static flag below, for more details.
4612           func_append compile_command " $link_static_flag"
4613           func_append finalize_command " $link_static_flag"
4614         fi
4615         continue
4616         ;;
4617
4618       -allow-undefined)
4619         # FIXME: remove this flag sometime in the future.
4620         func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4621         ;;
4622
4623       -avoid-version)
4624         avoid_version=yes
4625         continue
4626         ;;
4627
4628       -bindir)
4629         prev=bindir
4630         continue
4631         ;;
4632
4633       -dlopen)
4634         prev=dlfiles
4635         continue
4636         ;;
4637
4638       -dlpreopen)
4639         prev=dlprefiles
4640         continue
4641         ;;
4642
4643       -export-dynamic)
4644         export_dynamic=yes
4645         continue
4646         ;;
4647
4648       -export-symbols | -export-symbols-regex)
4649         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4650           func_fatal_error "more than one -exported-symbols argument is not allowed"
4651         fi
4652         if test "X$arg" = "X-export-symbols"; then
4653           prev=expsyms
4654         else
4655           prev=expsyms_regex
4656         fi
4657         continue
4658         ;;
4659
4660       -framework)
4661         prev=framework
4662         continue
4663         ;;
4664
4665       -inst-prefix-dir)
4666         prev=inst_prefix
4667         continue
4668         ;;
4669
4670       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4671       # so, if we see these flags be careful not to treat them like -L
4672       -L[A-Z][A-Z]*:*)
4673         case $with_gcc/$host in
4674         no/*-*-irix* | /*-*-irix*)
4675           func_append compile_command " $arg"
4676           func_append finalize_command " $arg"
4677           ;;
4678         esac
4679         continue
4680         ;;
4681
4682       -L*)
4683         func_stripname '-L' '' "$arg"
4684         dir=$func_stripname_result
4685         if test -z "$dir"; then
4686           if test "$#" -gt 0; then
4687             func_fatal_error "require no space between \`-L' and \`$1'"
4688           else
4689             func_fatal_error "need path for \`-L' option"
4690           fi
4691         fi
4692         # We need an absolute path.
4693         case $dir in
4694         [\\/]* | [A-Za-z]:[\\/]*) ;;
4695         *)
4696           absdir=`cd "$dir" && pwd`
4697           test -z "$absdir" && \
4698             func_fatal_error "cannot determine absolute directory name of \`$dir'"
4699           dir="$absdir"
4700           ;;
4701         esac
4702         case "$deplibs " in
4703         *" -L$dir "*) ;;
4704         *)
4705           deplibs="$deplibs -L$dir"
4706           lib_search_path="$lib_search_path $dir"
4707           ;;
4708         esac
4709         case $host in
4710         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4711           testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4712           case :$dllsearchpath: in
4713           *":$dir:"*) ;;
4714           ::) dllsearchpath=$dir;;
4715           *) dllsearchpath="$dllsearchpath:$dir";;
4716           esac
4717           case :$dllsearchpath: in
4718           *":$testbindir:"*) ;;
4719           ::) dllsearchpath=$testbindir;;
4720           *) dllsearchpath="$dllsearchpath:$testbindir";;
4721           esac
4722           ;;
4723         esac
4724         continue
4725         ;;
4726
4727       -l*)
4728         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4729           case $host in
4730           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4731             # These systems don't actually have a C or math library (as such)
4732             continue
4733             ;;
4734           *-*-os2*)
4735             # These systems don't actually have a C library (as such)
4736             test "X$arg" = "X-lc" && continue
4737             ;;
4738           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4739             # Do not include libc due to us having libc/libc_r.
4740             test "X$arg" = "X-lc" && continue
4741             ;;
4742           *-*-rhapsody* | *-*-darwin1.[012])
4743             # Rhapsody C and math libraries are in the System framework
4744             deplibs="$deplibs System.ltframework"
4745             continue
4746             ;;
4747           *-*-sco3.2v5* | *-*-sco5v6*)
4748             # Causes problems with __ctype
4749             test "X$arg" = "X-lc" && continue
4750             ;;
4751           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4752             # Compiler inserts libc in the correct place for threads to work
4753             test "X$arg" = "X-lc" && continue
4754             ;;
4755           esac
4756         elif test "X$arg" = "X-lc_r"; then
4757          case $host in
4758          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4759            # Do not include libc_r directly, use -pthread flag.
4760            continue
4761            ;;
4762          esac
4763         fi
4764         deplibs="$deplibs $arg"
4765         continue
4766         ;;
4767
4768       -module)
4769         module=yes
4770         continue
4771         ;;
4772
4773       # Tru64 UNIX uses -model [arg] to determine the layout of C++
4774       # classes, name mangling, and exception handling.
4775       # Darwin uses the -arch flag to determine output architecture.
4776       -model|-arch|-isysroot)
4777         compiler_flags="$compiler_flags $arg"
4778         func_append compile_command " $arg"
4779         func_append finalize_command " $arg"
4780         prev=xcompiler
4781         continue
4782         ;;
4783
4784       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4785         compiler_flags="$compiler_flags $arg"
4786         func_append compile_command " $arg"
4787         func_append finalize_command " $arg"
4788         case "$new_inherited_linker_flags " in
4789             *" $arg "*) ;;
4790             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4791         esac
4792         continue
4793         ;;
4794
4795       -multi_module)
4796         single_module="${wl}-multi_module"
4797         continue
4798         ;;
4799
4800       -no-fast-install)
4801         fast_install=no
4802         continue
4803         ;;
4804
4805       -no-install)
4806         case $host in
4807         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4808           # The PATH hackery in wrapper scripts is required on Windows
4809           # and Darwin in order for the loader to find any dlls it needs.
4810           func_warning "\`-no-install' is ignored for $host"
4811           func_warning "assuming \`-no-fast-install' instead"
4812           fast_install=no
4813           ;;
4814         *) no_install=yes ;;
4815         esac
4816         continue
4817         ;;
4818
4819       -no-undefined)
4820         allow_undefined=no
4821         continue
4822         ;;
4823
4824       -objectlist)
4825         prev=objectlist
4826         continue
4827         ;;
4828
4829       -o) prev=output ;;
4830
4831       -precious-files-regex)
4832         prev=precious_regex
4833         continue
4834         ;;
4835
4836       -release)
4837         prev=release
4838         continue
4839         ;;
4840
4841       -rpath)
4842         prev=rpath
4843         continue
4844         ;;
4845
4846       -R)
4847         prev=xrpath
4848         continue
4849         ;;
4850
4851       -R*)
4852         func_stripname '-R' '' "$arg"
4853         dir=$func_stripname_result
4854         # We need an absolute path.
4855         case $dir in
4856         [\\/]* | [A-Za-z]:[\\/]*) ;;
4857         *)
4858           func_fatal_error "only absolute run-paths are allowed"
4859           ;;
4860         esac
4861         case "$xrpath " in
4862         *" $dir "*) ;;
4863         *) xrpath="$xrpath $dir" ;;
4864         esac
4865         continue
4866         ;;
4867
4868       -shared)
4869         # The effects of -shared are defined in a previous loop.
4870         continue
4871         ;;
4872
4873       -shrext)
4874         prev=shrext
4875         continue
4876         ;;
4877
4878       -static | -static-libtool-libs)
4879         # The effects of -static are defined in a previous loop.
4880         # We used to do the same as -all-static on platforms that
4881         # didn't have a PIC flag, but the assumption that the effects
4882         # would be equivalent was wrong.  It would break on at least
4883         # Digital Unix and AIX.
4884         continue
4885         ;;
4886
4887       -thread-safe)
4888         thread_safe=yes
4889         continue
4890         ;;
4891
4892       -version-info)
4893         prev=vinfo
4894         continue
4895         ;;
4896
4897       -version-number)
4898         prev=vinfo
4899         vinfo_number=yes
4900         continue
4901         ;;
4902
4903       -weak)
4904         prev=weak
4905         continue
4906         ;;
4907
4908       -Wc,*)
4909         func_stripname '-Wc,' '' "$arg"
4910         args=$func_stripname_result
4911         arg=
4912         save_ifs="$IFS"; IFS=','
4913         for flag in $args; do
4914           IFS="$save_ifs"
4915           func_quote_for_eval "$flag"
4916           arg="$arg $func_quote_for_eval_result"
4917           compiler_flags="$compiler_flags $func_quote_for_eval_result"
4918         done
4919         IFS="$save_ifs"
4920         func_stripname ' ' '' "$arg"
4921         arg=$func_stripname_result
4922         ;;
4923
4924       -Wl,--as-needed|-Wl,--no-as-needed)
4925         deplibs="$deplibs $arg"
4926         continue
4927         ;;
4928
4929       -Wl,*)
4930         func_stripname '-Wl,' '' "$arg"
4931         args=$func_stripname_result
4932         arg=
4933         save_ifs="$IFS"; IFS=','
4934         for flag in $args; do
4935           IFS="$save_ifs"
4936           func_quote_for_eval "$flag"
4937           arg="$arg $wl$func_quote_for_eval_result"
4938           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4939           linker_flags="$linker_flags $func_quote_for_eval_result"
4940         done
4941         IFS="$save_ifs"
4942         func_stripname ' ' '' "$arg"
4943         arg=$func_stripname_result
4944         ;;
4945
4946       -Xcompiler)
4947         prev=xcompiler
4948         continue
4949         ;;
4950
4951       -Xlinker)
4952         prev=xlinker
4953         continue
4954         ;;
4955
4956       -XCClinker)
4957         prev=xcclinker
4958         continue
4959         ;;
4960
4961       # -msg_* for osf cc
4962       -msg_*)
4963         func_quote_for_eval "$arg"
4964         arg="$func_quote_for_eval_result"
4965         ;;
4966
4967       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4968       # -r[0-9][0-9]* specifies the processor on the SGI compiler
4969       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4970       # +DA*, +DD* enable 64-bit mode on the HP compiler
4971       # -q* pass through compiler args for the IBM compiler
4972       # -m*, -t[45]*, -txscale* pass through architecture-specific
4973       # compiler args for GCC
4974       # -F/path gives path to uninstalled frameworks, gcc on darwin
4975       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4976       # @file GCC response files
4977       # -tp=* Portland pgcc target processor selection
4978       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4979       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
4980         func_quote_for_eval "$arg"
4981         arg="$func_quote_for_eval_result"
4982         func_append compile_command " $arg"
4983         func_append finalize_command " $arg"
4984         compiler_flags="$compiler_flags $arg"
4985         continue
4986         ;;
4987
4988       # Some other compiler flag.
4989       -* | +*)
4990         func_quote_for_eval "$arg"
4991         arg="$func_quote_for_eval_result"
4992         ;;
4993
4994       *.$objext)
4995         # A standard object.
4996         objs="$objs $arg"
4997         ;;
4998
4999       *.lo)
5000         # A libtool-controlled object.
5001
5002         # Check to see that this really is a libtool object.
5003         if func_lalib_unsafe_p "$arg"; then
5004           pic_object=
5005           non_pic_object=
5006
5007           # Read the .lo file
5008           func_source "$arg"
5009
5010           if test -z "$pic_object" ||
5011              test -z "$non_pic_object" ||
5012              test "$pic_object" = none &&
5013              test "$non_pic_object" = none; then
5014             func_fatal_error "cannot find name of object for \`$arg'"
5015           fi
5016
5017           # Extract subdirectory from the argument.
5018           func_dirname "$arg" "/" ""
5019           xdir="$func_dirname_result"
5020
5021           if test "$pic_object" != none; then
5022             # Prepend the subdirectory the object is found in.
5023             pic_object="$xdir$pic_object"
5024
5025             if test "$prev" = dlfiles; then
5026               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5027                 dlfiles="$dlfiles $pic_object"
5028                 prev=
5029                 continue
5030               else
5031                 # If libtool objects are unsupported, then we need to preload.
5032                 prev=dlprefiles
5033               fi
5034             fi
5035
5036             # CHECK ME:  I think I busted this.  -Ossama
5037             if test "$prev" = dlprefiles; then
5038               # Preload the old-style object.
5039               dlprefiles="$dlprefiles $pic_object"
5040               prev=
5041             fi
5042
5043             # A PIC object.
5044             func_append libobjs " $pic_object"
5045             arg="$pic_object"
5046           fi
5047
5048           # Non-PIC object.
5049           if test "$non_pic_object" != none; then
5050             # Prepend the subdirectory the object is found in.
5051             non_pic_object="$xdir$non_pic_object"
5052
5053             # A standard non-PIC object
5054             func_append non_pic_objects " $non_pic_object"
5055             if test -z "$pic_object" || test "$pic_object" = none ; then
5056               arg="$non_pic_object"
5057             fi
5058           else
5059             # If the PIC object exists, use it instead.
5060             # $xdir was prepended to $pic_object above.
5061             non_pic_object="$pic_object"
5062             func_append non_pic_objects " $non_pic_object"
5063           fi
5064         else
5065           # Only an error if not doing a dry-run.
5066           if $opt_dry_run; then
5067             # Extract subdirectory from the argument.
5068             func_dirname "$arg" "/" ""
5069             xdir="$func_dirname_result"
5070
5071             func_lo2o "$arg"
5072             pic_object=$xdir$objdir/$func_lo2o_result
5073             non_pic_object=$xdir$func_lo2o_result
5074             func_append libobjs " $pic_object"
5075             func_append non_pic_objects " $non_pic_object"
5076           else
5077             func_fatal_error "\`$arg' is not a valid libtool object"
5078           fi
5079         fi
5080         ;;
5081
5082       *.$libext)
5083         # An archive.
5084         deplibs="$deplibs $arg"
5085         old_deplibs="$old_deplibs $arg"
5086         continue
5087         ;;
5088
5089       *.la)
5090         # A libtool-controlled library.
5091
5092         if test "$prev" = dlfiles; then
5093           # This library was specified with -dlopen.
5094           dlfiles="$dlfiles $arg"
5095           prev=
5096         elif test "$prev" = dlprefiles; then
5097           # The library was specified with -dlpreopen.
5098           dlprefiles="$dlprefiles $arg"
5099           prev=
5100         else
5101           deplibs="$deplibs $arg"
5102         fi
5103         continue
5104         ;;
5105
5106       # Some other compiler argument.
5107       *)
5108         # Unknown arguments in both finalize_command and compile_command need
5109         # to be aesthetically quoted because they are evaled later.
5110         func_quote_for_eval "$arg"
5111         arg="$func_quote_for_eval_result"
5112         ;;
5113       esac # arg
5114
5115       # Now actually substitute the argument into the commands.
5116       if test -n "$arg"; then
5117         func_append compile_command " $arg"
5118         func_append finalize_command " $arg"
5119       fi
5120     done # argument parsing loop
5121
5122     test -n "$prev" && \
5123       func_fatal_help "the \`$prevarg' option requires an argument"
5124
5125     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5126       eval arg=\"$export_dynamic_flag_spec\"
5127       func_append compile_command " $arg"
5128       func_append finalize_command " $arg"
5129     fi
5130
5131     oldlibs=
5132     # calculate the name of the file, without its directory
5133     func_basename "$output"
5134     outputname="$func_basename_result"
5135     libobjs_save="$libobjs"
5136
5137     if test -n "$shlibpath_var"; then
5138       # get the directories listed in $shlibpath_var
5139       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5140     else
5141       shlib_search_path=
5142     fi
5143     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5144     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5145
5146     func_dirname "$output" "/" ""
5147     output_objdir="$func_dirname_result$objdir"
5148     # Create the object directory.
5149     func_mkdir_p "$output_objdir"
5150
5151     # Determine the type of output
5152     case $output in
5153     "")
5154       func_fatal_help "you must specify an output file"
5155       ;;
5156     *.$libext) linkmode=oldlib ;;
5157     *.lo | *.$objext) linkmode=obj ;;
5158     *.la) linkmode=lib ;;
5159     *) linkmode=prog ;; # Anything else should be a program.
5160     esac
5161
5162     specialdeplibs=
5163
5164     libs=
5165     # Find all interdependent deplibs by searching for libraries
5166     # that are linked more than once (e.g. -la -lb -la)
5167     for deplib in $deplibs; do
5168       if $opt_duplicate_deps ; then
5169         case "$libs " in
5170         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5171         esac
5172       fi
5173       libs="$libs $deplib"
5174     done
5175
5176     if test "$linkmode" = lib; then
5177       libs="$predeps $libs $compiler_lib_search_path $postdeps"
5178
5179       # Compute libraries that are listed more than once in $predeps
5180       # $postdeps and mark them as special (i.e., whose duplicates are
5181       # not to be eliminated).
5182       pre_post_deps=
5183       if $opt_duplicate_compiler_generated_deps; then
5184         for pre_post_dep in $predeps $postdeps; do
5185           case "$pre_post_deps " in
5186           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5187           esac
5188           pre_post_deps="$pre_post_deps $pre_post_dep"
5189         done
5190       fi
5191       pre_post_deps=
5192     fi
5193
5194     deplibs=
5195     newdependency_libs=
5196     newlib_search_path=
5197     need_relink=no # whether we're linking any uninstalled libtool libraries
5198     notinst_deplibs= # not-installed libtool libraries
5199     notinst_path= # paths that contain not-installed libtool libraries
5200
5201     case $linkmode in
5202     lib)
5203         passes="conv dlpreopen link"
5204         for file in $dlfiles $dlprefiles; do
5205           case $file in
5206           *.la) ;;
5207           *)
5208             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5209             ;;
5210           esac
5211         done
5212         ;;
5213     prog)
5214         compile_deplibs=
5215         finalize_deplibs=
5216         alldeplibs=no
5217         newdlfiles=
5218         newdlprefiles=
5219         passes="conv scan dlopen dlpreopen link"
5220         ;;
5221     *)  passes="conv"
5222         ;;
5223     esac
5224
5225     for pass in $passes; do
5226       # The preopen pass in lib mode reverses $deplibs; put it back here
5227       # so that -L comes before libs that need it for instance...
5228       if test "$linkmode,$pass" = "lib,link"; then
5229         ## FIXME: Find the place where the list is rebuilt in the wrong
5230         ##        order, and fix it there properly
5231         tmp_deplibs=
5232         for deplib in $deplibs; do
5233           tmp_deplibs="$deplib $tmp_deplibs"
5234         done
5235         deplibs="$tmp_deplibs"
5236       fi
5237
5238       if test "$linkmode,$pass" = "lib,link" ||
5239          test "$linkmode,$pass" = "prog,scan"; then
5240         libs="$deplibs"
5241         deplibs=
5242       fi
5243       if test "$linkmode" = prog; then
5244         case $pass in
5245         dlopen) libs="$dlfiles" ;;
5246         dlpreopen) libs="$dlprefiles" ;;
5247         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5248         esac
5249       fi
5250       if test "$linkmode,$pass" = "lib,dlpreopen"; then
5251         # Collect and forward deplibs of preopened libtool libs
5252         for lib in $dlprefiles; do
5253           # Ignore non-libtool-libs
5254           dependency_libs=
5255           case $lib in
5256           *.la) func_source "$lib" ;;
5257           esac
5258
5259           # Collect preopened libtool deplibs, except any this library
5260           # has declared as weak libs
5261           for deplib in $dependency_libs; do
5262             func_basename "$deplib"
5263             deplib_base=$func_basename_result
5264             case " $weak_libs " in
5265             *" $deplib_base "*) ;;
5266             *) deplibs="$deplibs $deplib" ;;
5267             esac
5268           done
5269         done
5270         libs="$dlprefiles"
5271       fi
5272       if test "$pass" = dlopen; then
5273         # Collect dlpreopened libraries
5274         save_deplibs="$deplibs"
5275         deplibs=
5276       fi
5277
5278       for deplib in $libs; do
5279         lib=
5280         found=no
5281         case $deplib in
5282         -Wl,--as-needed|-Wl,--no-as-needed)
5283           if test "$linkmode,$pass" = "prog,link"; then
5284             compile_deplibs="$deplib $compile_deplibs"
5285             finalize_deplibs="$deplib $finalize_deplibs"
5286           else
5287             deplibs="$deplib $deplibs"
5288           fi
5289           continue
5290           ;;
5291         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5292           if test "$linkmode,$pass" = "prog,link"; then
5293             compile_deplibs="$deplib $compile_deplibs"
5294             finalize_deplibs="$deplib $finalize_deplibs"
5295           else
5296             compiler_flags="$compiler_flags $deplib"
5297             if test "$linkmode" = lib ; then
5298                 case "$new_inherited_linker_flags " in
5299                     *" $deplib "*) ;;
5300                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5301                 esac
5302             fi
5303           fi
5304           continue
5305           ;;
5306         -l*)
5307           if test "$linkmode" != lib && test "$linkmode" != prog; then
5308             func_warning "\`-l' is ignored for archives/objects"
5309             continue
5310           fi
5311           func_stripname '-l' '' "$deplib"
5312           name=$func_stripname_result
5313           if test "$linkmode" = lib; then
5314             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5315           else
5316             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5317           fi
5318           for searchdir in $searchdirs; do
5319             for search_ext in .la $std_shrext .so .a; do
5320               # Search the libtool library
5321               lib="$searchdir/lib${name}${search_ext}"
5322               if test -f "$lib"; then
5323                 if test "$search_ext" = ".la"; then
5324                   found=yes
5325                 else
5326                   found=no
5327                 fi
5328                 break 2
5329               fi
5330             done
5331           done
5332           if test "$found" != yes; then
5333             # deplib doesn't seem to be a libtool library
5334             if test "$linkmode,$pass" = "prog,link"; then
5335               compile_deplibs="$deplib $compile_deplibs"
5336               finalize_deplibs="$deplib $finalize_deplibs"
5337             else
5338               deplibs="$deplib $deplibs"
5339               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5340             fi
5341             continue
5342           else # deplib is a libtool library
5343             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5344             # We need to do some special things here, and not later.
5345             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5346               case " $predeps $postdeps " in
5347               *" $deplib "*)
5348                 if func_lalib_p "$lib"; then
5349                   library_names=
5350                   old_library=
5351                   func_source "$lib"
5352                   for l in $old_library $library_names; do
5353                     ll="$l"
5354                   done
5355                   if test "X$ll" = "X$old_library" ; then # only static version available
5356                     found=no
5357                     func_dirname "$lib" "" "."
5358                     ladir="$func_dirname_result"
5359                     lib=$ladir/$old_library
5360                     if test "$linkmode,$pass" = "prog,link"; then
5361                       compile_deplibs="$deplib $compile_deplibs"
5362                       finalize_deplibs="$deplib $finalize_deplibs"
5363                     else
5364                       deplibs="$deplib $deplibs"
5365                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5366                     fi
5367                     continue
5368                   fi
5369                 fi
5370                 ;;
5371               *) ;;
5372               esac
5373             fi
5374           fi
5375           ;; # -l
5376         *.ltframework)
5377           if test "$linkmode,$pass" = "prog,link"; then
5378             compile_deplibs="$deplib $compile_deplibs"
5379             finalize_deplibs="$deplib $finalize_deplibs"
5380           else
5381             deplibs="$deplib $deplibs"
5382             if test "$linkmode" = lib ; then
5383                 case "$new_inherited_linker_flags " in
5384                     *" $deplib "*) ;;
5385                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5386                 esac
5387             fi
5388           fi
5389           continue
5390           ;;
5391         -L*)
5392           case $linkmode in
5393           lib)
5394             deplibs="$deplib $deplibs"
5395             test "$pass" = conv && continue
5396             newdependency_libs="$deplib $newdependency_libs"
5397             func_stripname '-L' '' "$deplib"
5398             newlib_search_path="$newlib_search_path $func_stripname_result"
5399             ;;
5400           prog)
5401             if test "$pass" = conv; then
5402               deplibs="$deplib $deplibs"
5403               continue
5404             fi
5405             if test "$pass" = scan; then
5406               deplibs="$deplib $deplibs"
5407             else
5408               compile_deplibs="$deplib $compile_deplibs"
5409               finalize_deplibs="$deplib $finalize_deplibs"
5410             fi
5411             func_stripname '-L' '' "$deplib"
5412             newlib_search_path="$newlib_search_path $func_stripname_result"
5413             ;;
5414           *)
5415             func_warning "\`-L' is ignored for archives/objects"
5416             ;;
5417           esac # linkmode
5418           continue
5419           ;; # -L
5420         -R*)
5421           if test "$pass" = link; then
5422             func_stripname '-R' '' "$deplib"
5423             dir=$func_stripname_result
5424             # Make sure the xrpath contains only unique directories.
5425             case "$xrpath " in
5426             *" $dir "*) ;;
5427             *) xrpath="$xrpath $dir" ;;
5428             esac
5429           fi
5430           deplibs="$deplib $deplibs"
5431           continue
5432           ;;
5433         *.la) lib="$deplib" ;;
5434         *.$libext)
5435           if test "$pass" = conv; then
5436             deplibs="$deplib $deplibs"
5437             continue
5438           fi
5439           case $linkmode in
5440           lib)
5441             # Linking convenience modules into shared libraries is allowed,
5442             # but linking other static libraries is non-portable.
5443             case " $dlpreconveniencelibs " in
5444             *" $deplib "*) ;;
5445             *)
5446               valid_a_lib=no
5447               case $deplibs_check_method in
5448                 match_pattern*)
5449                   set dummy $deplibs_check_method; shift
5450                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5451                   if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5452                     | $EGREP "$match_pattern_regex" > /dev/null; then
5453                     valid_a_lib=yes
5454                   fi
5455                 ;;
5456                 pass_all)
5457                   valid_a_lib=yes
5458                 ;;
5459               esac
5460               if test "$valid_a_lib" != yes; then
5461                 echo
5462                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5463                 echo "*** I have the capability to make that library automatically link in when"
5464                 echo "*** you link to this library.  But I can only do this if you have a"
5465                 echo "*** shared version of the library, which you do not appear to have"
5466                 echo "*** because the file extensions .$libext of this argument makes me believe"
5467                 echo "*** that it is just a static archive that I should not use here."
5468               else
5469                 echo
5470                 $ECHO "*** Warning: Linking the shared library $output against the"
5471                 $ECHO "*** static library $deplib is not portable!"
5472                 deplibs="$deplib $deplibs"
5473               fi
5474               ;;
5475             esac
5476             continue
5477             ;;
5478           prog)
5479             if test "$pass" != link; then
5480               deplibs="$deplib $deplibs"
5481             else
5482               compile_deplibs="$deplib $compile_deplibs"
5483               finalize_deplibs="$deplib $finalize_deplibs"
5484             fi
5485             continue
5486             ;;
5487           esac # linkmode
5488           ;; # *.$libext
5489         *.lo | *.$objext)
5490           if test "$pass" = conv; then
5491             deplibs="$deplib $deplibs"
5492           elif test "$linkmode" = prog; then
5493             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5494               # If there is no dlopen support or we're linking statically,
5495               # we need to preload.
5496               newdlprefiles="$newdlprefiles $deplib"
5497               compile_deplibs="$deplib $compile_deplibs"
5498               finalize_deplibs="$deplib $finalize_deplibs"
5499             else
5500               newdlfiles="$newdlfiles $deplib"
5501             fi
5502           fi
5503           continue
5504           ;;
5505         %DEPLIBS%)
5506           alldeplibs=yes
5507           continue
5508           ;;
5509         esac # case $deplib
5510
5511         if test "$found" = yes || test -f "$lib"; then :
5512         else
5513           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5514         fi
5515
5516         # Check to see that this really is a libtool archive.
5517         func_lalib_unsafe_p "$lib" \
5518           || func_fatal_error "\`$lib' is not a valid libtool archive"
5519
5520         func_dirname "$lib" "" "."
5521         ladir="$func_dirname_result"
5522
5523         dlname=
5524         dlopen=
5525         dlpreopen=
5526         libdir=
5527         library_names=
5528         old_library=
5529         inherited_linker_flags=
5530         # If the library was installed with an old release of libtool,
5531         # it will not redefine variables installed, or shouldnotlink
5532         installed=yes
5533         shouldnotlink=no
5534         avoidtemprpath=
5535
5536
5537         # Read the .la file
5538         func_source "$lib"
5539
5540         # Convert "-framework foo" to "foo.ltframework"
5541         if test -n "$inherited_linker_flags"; then
5542           tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5543           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5544             case " $new_inherited_linker_flags " in
5545               *" $tmp_inherited_linker_flag "*) ;;
5546               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5547             esac
5548           done
5549         fi
5550         dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5551         if test "$linkmode,$pass" = "lib,link" ||
5552            test "$linkmode,$pass" = "prog,scan" ||
5553            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5554           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5555           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5556         fi
5557
5558         if test "$pass" = conv; then
5559           # Only check for convenience libraries
5560           deplibs="$lib $deplibs"
5561           if test -z "$libdir"; then
5562             if test -z "$old_library"; then
5563               func_fatal_error "cannot find name of link library for \`$lib'"
5564             fi
5565             # It is a libtool convenience library, so add in its objects.
5566             convenience="$convenience $ladir/$objdir/$old_library"
5567             old_convenience="$old_convenience $ladir/$objdir/$old_library"
5568           elif test "$linkmode" != prog && test "$linkmode" != lib; then
5569             func_fatal_error "\`$lib' is not a convenience library"
5570           fi
5571           tmp_libs=
5572           for deplib in $dependency_libs; do
5573             deplibs="$deplib $deplibs"
5574             if $opt_duplicate_deps ; then
5575               case "$tmp_libs " in
5576               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5577               esac
5578             fi
5579             tmp_libs="$tmp_libs $deplib"
5580           done
5581           continue
5582         fi # $pass = conv
5583
5584
5585         # Get the name of the library we link against.
5586         linklib=
5587         for l in $old_library $library_names; do
5588           linklib="$l"
5589         done
5590         if test -z "$linklib"; then
5591           func_fatal_error "cannot find name of link library for \`$lib'"
5592         fi
5593
5594         # This library was specified with -dlopen.
5595         if test "$pass" = dlopen; then
5596           if test -z "$libdir"; then
5597             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5598           fi
5599           if test -z "$dlname" ||
5600              test "$dlopen_support" != yes ||
5601              test "$build_libtool_libs" = no; then
5602             # If there is no dlname, no dlopen support or we're linking
5603             # statically, we need to preload.  We also need to preload any
5604             # dependent libraries so libltdl's deplib preloader doesn't
5605             # bomb out in the load deplibs phase.
5606             dlprefiles="$dlprefiles $lib $dependency_libs"
5607           else
5608             newdlfiles="$newdlfiles $lib"
5609           fi
5610           continue
5611         fi # $pass = dlopen
5612
5613         # We need an absolute path.
5614         case $ladir in
5615         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5616         *)
5617           abs_ladir=`cd "$ladir" && pwd`
5618           if test -z "$abs_ladir"; then
5619             func_warning "cannot determine absolute directory name of \`$ladir'"
5620             func_warning "passing it literally to the linker, although it might fail"
5621             abs_ladir="$ladir"
5622           fi
5623           ;;
5624         esac
5625         func_basename "$lib"
5626         laname="$func_basename_result"
5627
5628         # Find the relevant object directory and library name.
5629         if test "X$installed" = Xyes; then
5630           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5631             func_warning "library \`$lib' was moved."
5632             dir="$ladir"
5633             absdir="$abs_ladir"
5634             libdir="$abs_ladir"
5635           else
5636             dir="$libdir"
5637             absdir="$libdir"
5638           fi
5639           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5640         else
5641           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5642             dir="$ladir"
5643             absdir="$abs_ladir"
5644             # Remove this search path later
5645             notinst_path="$notinst_path $abs_ladir"
5646           else
5647             dir="$ladir/$objdir"
5648             absdir="$abs_ladir/$objdir"
5649             # Remove this search path later
5650             notinst_path="$notinst_path $abs_ladir"
5651           fi
5652         fi # $installed = yes
5653         func_stripname 'lib' '.la' "$laname"
5654         name=$func_stripname_result
5655
5656         # This library was specified with -dlpreopen.
5657         if test "$pass" = dlpreopen; then
5658           if test -z "$libdir" && test "$linkmode" = prog; then
5659             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5660           fi
5661           # Prefer using a static library (so that no silly _DYNAMIC symbols
5662           # are required to link).
5663           if test -n "$old_library"; then
5664             newdlprefiles="$newdlprefiles $dir/$old_library"
5665             # Keep a list of preopened convenience libraries to check
5666             # that they are being used correctly in the link pass.
5667             test -z "$libdir" && \
5668                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5669           # Otherwise, use the dlname, so that lt_dlopen finds it.
5670           elif test -n "$dlname"; then
5671             newdlprefiles="$newdlprefiles $dir/$dlname"
5672           else
5673             newdlprefiles="$newdlprefiles $dir/$linklib"
5674           fi
5675         fi # $pass = dlpreopen
5676
5677         if test -z "$libdir"; then
5678           # Link the convenience library
5679           if test "$linkmode" = lib; then
5680             deplibs="$dir/$old_library $deplibs"
5681           elif test "$linkmode,$pass" = "prog,link"; then
5682             compile_deplibs="$dir/$old_library $compile_deplibs"
5683             finalize_deplibs="$dir/$old_library $finalize_deplibs"
5684           else
5685             deplibs="$lib $deplibs" # used for prog,scan pass
5686           fi
5687           continue
5688         fi
5689
5690
5691         if test "$linkmode" = prog && test "$pass" != link; then
5692           newlib_search_path="$newlib_search_path $ladir"
5693           deplibs="$lib $deplibs"
5694
5695           linkalldeplibs=no
5696           if test "$link_all_deplibs" != no || test -z "$library_names" ||
5697              test "$build_libtool_libs" = no; then
5698             linkalldeplibs=yes
5699           fi
5700
5701           tmp_libs=
5702           for deplib in $dependency_libs; do
5703             case $deplib in
5704             -L*) func_stripname '-L' '' "$deplib"
5705                  newlib_search_path="$newlib_search_path $func_stripname_result"
5706                  ;;
5707             esac
5708             # Need to link against all dependency_libs?
5709             if test "$linkalldeplibs" = yes; then
5710               deplibs="$deplib $deplibs"
5711             else
5712               # Need to hardcode shared library paths
5713               # or/and link against static libraries
5714               newdependency_libs="$deplib $newdependency_libs"
5715             fi
5716             if $opt_duplicate_deps ; then
5717               case "$tmp_libs " in
5718               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5719               esac
5720             fi
5721             tmp_libs="$tmp_libs $deplib"
5722           done # for deplib
5723           continue
5724         fi # $linkmode = prog...
5725
5726         if test "$linkmode,$pass" = "prog,link"; then
5727           if test -n "$library_names" &&
5728              { { test "$prefer_static_libs" = no ||
5729                  test "$prefer_static_libs,$installed" = "built,yes"; } ||
5730                test -z "$old_library"; }; then
5731             # We need to hardcode the library path
5732             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5733               # Make sure the rpath contains only unique directories.
5734               case "$temp_rpath:" in
5735               *"$absdir:"*) ;;
5736               *) temp_rpath="$temp_rpath$absdir:" ;;
5737               esac
5738             fi
5739
5740             # Hardcode the library path.
5741             # Skip directories that are in the system default run-time
5742             # search path.
5743             case " $sys_lib_dlsearch_path " in
5744             *" $absdir "*) ;;
5745             *)
5746               case "$compile_rpath " in
5747               *" $absdir "*) ;;
5748               *) compile_rpath="$compile_rpath $absdir"
5749               esac
5750               ;;
5751             esac
5752             case " $sys_lib_dlsearch_path " in
5753             *" $libdir "*) ;;
5754             *)
5755               case "$finalize_rpath " in
5756               *" $libdir "*) ;;
5757               *) finalize_rpath="$finalize_rpath $libdir"
5758               esac
5759               ;;
5760             esac
5761           fi # $linkmode,$pass = prog,link...
5762
5763           if test "$alldeplibs" = yes &&
5764              { test "$deplibs_check_method" = pass_all ||
5765                { test "$build_libtool_libs" = yes &&
5766                  test -n "$library_names"; }; }; then
5767             # We only need to search for static libraries
5768             continue
5769           fi
5770         fi
5771
5772         link_static=no # Whether the deplib will be linked statically
5773         use_static_libs=$prefer_static_libs
5774         if test "$use_static_libs" = built && test "$installed" = yes; then
5775           use_static_libs=no
5776         fi
5777         if test -n "$library_names" &&
5778            { test "$use_static_libs" = no || test -z "$old_library"; }; then
5779           case $host in
5780           *cygwin* | *mingw* | *cegcc*)
5781               # No point in relinking DLLs because paths are not encoded
5782               notinst_deplibs="$notinst_deplibs $lib"
5783               need_relink=no
5784             ;;
5785           *)
5786             if test "$installed" = no; then
5787               notinst_deplibs="$notinst_deplibs $lib"
5788               need_relink=yes
5789             fi
5790             ;;
5791           esac
5792           # This is a shared library
5793
5794           # Warn about portability, can't link against -module's on some
5795           # systems (darwin).  Don't bleat about dlopened modules though!
5796           dlopenmodule=""
5797           for dlpremoduletest in $dlprefiles; do
5798             if test "X$dlpremoduletest" = "X$lib"; then
5799               dlopenmodule="$dlpremoduletest"
5800               break
5801             fi
5802           done
5803           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5804             echo
5805             if test "$linkmode" = prog; then
5806               $ECHO "*** Warning: Linking the executable $output against the loadable module"
5807             else
5808               $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5809             fi
5810             $ECHO "*** $linklib is not portable!"
5811           fi
5812           if test "$linkmode" = lib &&
5813              test "$hardcode_into_libs" = yes; then
5814             # Hardcode the library path.
5815             # Skip directories that are in the system default run-time
5816             # search path.
5817             case " $sys_lib_dlsearch_path " in
5818             *" $absdir "*) ;;
5819             *)
5820               case "$compile_rpath " in
5821               *" $absdir "*) ;;
5822               *) compile_rpath="$compile_rpath $absdir"
5823               esac
5824               ;;
5825             esac
5826             case " $sys_lib_dlsearch_path " in
5827             *" $libdir "*) ;;
5828             *)
5829               case "$finalize_rpath " in
5830               *" $libdir "*) ;;
5831               *) finalize_rpath="$finalize_rpath $libdir"
5832               esac
5833               ;;
5834             esac
5835           fi
5836
5837           if test -n "$old_archive_from_expsyms_cmds"; then
5838             # figure out the soname
5839             set dummy $library_names
5840             shift
5841             realname="$1"
5842             shift
5843             libname=`eval "\\$ECHO \"$libname_spec\""`
5844             # use dlname if we got it. it's perfectly good, no?
5845             if test -n "$dlname"; then
5846               soname="$dlname"
5847             elif test -n "$soname_spec"; then
5848               # bleh windows
5849               case $host in
5850               *cygwin* | mingw* | *cegcc*)
5851                 func_arith $current - $age
5852                 major=$func_arith_result
5853                 versuffix="-$major"
5854                 ;;
5855               esac
5856               eval soname=\"$soname_spec\"
5857             else
5858               soname="$realname"
5859             fi
5860
5861             # Make a new name for the extract_expsyms_cmds to use
5862             soroot="$soname"
5863             func_basename "$soroot"
5864             soname="$func_basename_result"
5865             func_stripname 'lib' '.dll' "$soname"
5866             newlib=libimp-$func_stripname_result.a
5867
5868             # If the library has no export list, then create one now
5869             if test -f "$output_objdir/$soname-def"; then :
5870             else
5871               func_verbose "extracting exported symbol list from \`$soname'"
5872               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5873             fi
5874
5875             # Create $newlib
5876             if test -f "$output_objdir/$newlib"; then :; else
5877               func_verbose "generating import library for \`$soname'"
5878               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5879             fi
5880             # make sure the library variables are pointing to the new library
5881             dir=$output_objdir
5882             linklib=$newlib
5883           fi # test -n "$old_archive_from_expsyms_cmds"
5884
5885           if test "$linkmode" = prog || test "$mode" != relink; then
5886             add_shlibpath=
5887             add_dir=
5888             add=
5889             lib_linked=yes
5890             case $hardcode_action in
5891             immediate | unsupported)
5892               if test "$hardcode_direct" = no; then
5893                 add="$dir/$linklib"
5894                 case $host in
5895                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5896                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5897                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5898                     *-*-unixware7*) add_dir="-L$dir" ;;
5899                   *-*-darwin* )
5900                     # if the lib is a (non-dlopened) module then we can not
5901                     # link against it, someone is ignoring the earlier warnings
5902                     if /usr/bin/file -L $add 2> /dev/null |
5903                          $GREP ": [^:]* bundle" >/dev/null ; then
5904                       if test "X$dlopenmodule" != "X$lib"; then
5905                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5906                         if test -z "$old_library" ; then
5907                           echo
5908                           echo "*** And there doesn't seem to be a static archive available"
5909                           echo "*** The link will probably fail, sorry"
5910                         else
5911                           add="$dir/$old_library"
5912                         fi
5913                       elif test -n "$old_library"; then
5914                         add="$dir/$old_library"
5915                       fi
5916                     fi
5917                 esac
5918               elif test "$hardcode_minus_L" = no; then
5919                 case $host in
5920                 *-*-sunos*) add_shlibpath="$dir" ;;
5921                 esac
5922                 add_dir="-L$dir"
5923                 add="-l$name"
5924               elif test "$hardcode_shlibpath_var" = no; then
5925                 add_shlibpath="$dir"
5926                 add="-l$name"
5927               else
5928                 lib_linked=no
5929               fi
5930               ;;
5931             relink)
5932               if test "$hardcode_direct" = yes &&
5933                  test "$hardcode_direct_absolute" = no; then
5934                 add="$dir/$linklib"
5935               elif test "$hardcode_minus_L" = yes; then
5936                 add_dir="-L$dir"
5937                 # Try looking first in the location we're being installed to.
5938                 if test -n "$inst_prefix_dir"; then
5939                   case $libdir in
5940                     [\\/]*)
5941                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
5942                       ;;
5943                   esac
5944                 fi
5945                 add="-l$name"
5946               elif test "$hardcode_shlibpath_var" = yes; then
5947                 add_shlibpath="$dir"
5948                 add="-l$name"
5949               else
5950                 lib_linked=no
5951               fi
5952               ;;
5953             *) lib_linked=no ;;
5954             esac
5955
5956             if test "$lib_linked" != yes; then
5957               func_fatal_configuration "unsupported hardcode properties"
5958             fi
5959
5960             if test -n "$add_shlibpath"; then
5961               case :$compile_shlibpath: in
5962               *":$add_shlibpath:"*) ;;
5963               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5964               esac
5965             fi
5966             if test "$linkmode" = prog; then
5967               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5968               test -n "$add" && compile_deplibs="$add $compile_deplibs"
5969             else
5970               test -n "$add_dir" && deplibs="$add_dir $deplibs"
5971               test -n "$add" && deplibs="$add $deplibs"
5972               if test "$hardcode_direct" != yes &&
5973                  test "$hardcode_minus_L" != yes &&
5974                  test "$hardcode_shlibpath_var" = yes; then
5975                 case :$finalize_shlibpath: in
5976                 *":$libdir:"*) ;;
5977                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5978                 esac
5979               fi
5980             fi
5981           fi
5982
5983           if test "$linkmode" = prog || test "$mode" = relink; then
5984             add_shlibpath=
5985             add_dir=
5986             add=
5987             # Finalize command for both is simple: just hardcode it.
5988             if test "$hardcode_direct" = yes &&
5989                test "$hardcode_direct_absolute" = no; then
5990               add="$libdir/$linklib"
5991             elif test "$hardcode_minus_L" = yes; then
5992               add_dir="-L$libdir"
5993               add="-l$name"
5994             elif test "$hardcode_shlibpath_var" = yes; then
5995               case :$finalize_shlibpath: in
5996               *":$libdir:"*) ;;
5997               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5998               esac
5999               add="-l$name"
6000             elif test "$hardcode_automatic" = yes; then
6001               if test -n "$inst_prefix_dir" &&
6002                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
6003                 add="$inst_prefix_dir$libdir/$linklib"
6004               else
6005                 add="$libdir/$linklib"
6006               fi
6007             else
6008               # We cannot seem to hardcode it, guess we'll fake it.
6009               add_dir="-L$libdir"
6010               # Try looking first in the location we're being installed to.
6011               if test -n "$inst_prefix_dir"; then
6012                 case $libdir in
6013                   [\\/]*)
6014                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
6015                     ;;
6016                 esac
6017               fi
6018               add="-l$name"
6019             fi
6020
6021             if test "$linkmode" = prog; then
6022               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6023               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6024             else
6025               test -n "$add_dir" && deplibs="$add_dir $deplibs"
6026               test -n "$add" && deplibs="$add $deplibs"
6027             fi
6028           fi
6029         elif test "$linkmode" = prog; then
6030           # Here we assume that one of hardcode_direct or hardcode_minus_L
6031           # is not unsupported.  This is valid on all known static and
6032           # shared platforms.
6033           if test "$hardcode_direct" != unsupported; then
6034             test -n "$old_library" && linklib="$old_library"
6035             compile_deplibs="$dir/$linklib $compile_deplibs"
6036             finalize_deplibs="$dir/$linklib $finalize_deplibs"
6037           else
6038             compile_deplibs="-l$name -L$dir $compile_deplibs"
6039             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6040           fi
6041         elif test "$build_libtool_libs" = yes; then
6042           # Not a shared library
6043           if test "$deplibs_check_method" != pass_all; then
6044             # We're trying link a shared library against a static one
6045             # but the system doesn't support it.
6046
6047             # Just print a warning and add the library to dependency_libs so
6048             # that the program can be linked against the static library.
6049             echo
6050             $ECHO "*** Warning: This system can not link to static lib archive $lib."
6051             echo "*** I have the capability to make that library automatically link in when"
6052             echo "*** you link to this library.  But I can only do this if you have a"
6053             echo "*** shared version of the library, which you do not appear to have."
6054             if test "$module" = yes; then
6055               echo "*** But as you try to build a module library, libtool will still create "
6056               echo "*** a static module, that should work as long as the dlopening application"
6057               echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6058               if test -z "$global_symbol_pipe"; then
6059                 echo
6060                 echo "*** However, this would only work if libtool was able to extract symbol"
6061                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6062                 echo "*** not find such a program.  So, this module is probably useless."
6063                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6064               fi
6065               if test "$build_old_libs" = no; then
6066                 build_libtool_libs=module
6067                 build_old_libs=yes
6068               else
6069                 build_libtool_libs=no
6070               fi
6071             fi
6072           else
6073             deplibs="$dir/$old_library $deplibs"
6074             link_static=yes
6075           fi
6076         fi # link shared/static library?
6077
6078         if test "$linkmode" = lib; then
6079           if test -n "$dependency_libs" &&
6080              { test "$hardcode_into_libs" != yes ||
6081                test "$build_old_libs" = yes ||
6082                test "$link_static" = yes; }; then
6083             # Extract -R from dependency_libs
6084             temp_deplibs=
6085             for libdir in $dependency_libs; do
6086               case $libdir in
6087               -R*) func_stripname '-R' '' "$libdir"
6088                    temp_xrpath=$func_stripname_result
6089                    case " $xrpath " in
6090                    *" $temp_xrpath "*) ;;
6091                    *) xrpath="$xrpath $temp_xrpath";;
6092                    esac;;
6093               *) temp_deplibs="$temp_deplibs $libdir";;
6094               esac
6095             done
6096             dependency_libs="$temp_deplibs"
6097           fi
6098
6099           newlib_search_path="$newlib_search_path $absdir"
6100           # Link against this library
6101           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6102           # ... and its dependency_libs
6103           tmp_libs=
6104           for deplib in $dependency_libs; do
6105             newdependency_libs="$deplib $newdependency_libs"
6106             if $opt_duplicate_deps ; then
6107               case "$tmp_libs " in
6108               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6109               esac
6110             fi
6111             tmp_libs="$tmp_libs $deplib"
6112           done
6113
6114           if test "$link_all_deplibs" != no; then
6115             # Add the search paths of all dependency libraries
6116             for deplib in $dependency_libs; do
6117               path=
6118               case $deplib in
6119               -L*) path="$deplib" ;;
6120               *.la)
6121                 func_dirname "$deplib" "" "."
6122                 dir="$func_dirname_result"
6123                 # We need an absolute path.
6124                 case $dir in
6125                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6126                 *)
6127                   absdir=`cd "$dir" && pwd`
6128                   if test -z "$absdir"; then
6129                     func_warning "cannot determine absolute directory name of \`$dir'"
6130                     absdir="$dir"
6131                   fi
6132                   ;;
6133                 esac
6134                 if $GREP "^installed=no" $deplib > /dev/null; then
6135                 case $host in
6136                 *-*-darwin*)
6137                   depdepl=
6138                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6139                   if test -n "$deplibrary_names" ; then
6140                     for tmp in $deplibrary_names ; do
6141                       depdepl=$tmp
6142                     done
6143                     if test -f "$absdir/$objdir/$depdepl" ; then
6144                       depdepl="$absdir/$objdir/$depdepl"
6145                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6146                       if test -z "$darwin_install_name"; then
6147                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
6148                       fi
6149                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6150                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6151                       path=
6152                     fi
6153                   fi
6154                   ;;
6155                 *)
6156                   path="-L$absdir/$objdir"
6157                   ;;
6158                 esac
6159                 else
6160                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6161                   test -z "$libdir" && \
6162                     func_fatal_error "\`$deplib' is not a valid libtool archive"
6163                   test "$absdir" != "$libdir" && \
6164                     func_warning "\`$deplib' seems to be moved"
6165
6166                   path="-L$absdir"
6167                 fi
6168                 ;;
6169               esac
6170               case " $deplibs " in
6171               *" $path "*) ;;
6172               *) deplibs="$path $deplibs" ;;
6173               esac
6174             done
6175           fi # link_all_deplibs != no
6176         fi # linkmode = lib
6177       done # for deplib in $libs
6178       if test "$pass" = link; then
6179         if test "$linkmode" = "prog"; then
6180           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6181           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6182         else
6183           compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6184         fi
6185       fi
6186       dependency_libs="$newdependency_libs"
6187       if test "$pass" = dlpreopen; then
6188         # Link the dlpreopened libraries before other libraries
6189         for deplib in $save_deplibs; do
6190           deplibs="$deplib $deplibs"
6191         done
6192       fi
6193       if test "$pass" != dlopen; then
6194         if test "$pass" != conv; then
6195           # Make sure lib_search_path contains only unique directories.
6196           lib_search_path=
6197           for dir in $newlib_search_path; do
6198             case "$lib_search_path " in
6199             *" $dir "*) ;;
6200             *) lib_search_path="$lib_search_path $dir" ;;
6201             esac
6202           done
6203           newlib_search_path=
6204         fi
6205
6206         if test "$linkmode,$pass" != "prog,link"; then
6207           vars="deplibs"
6208         else
6209           vars="compile_deplibs finalize_deplibs"
6210         fi
6211         for var in $vars dependency_libs; do
6212           # Add libraries to $var in reverse order
6213           eval tmp_libs=\"\$$var\"
6214           new_libs=
6215           for deplib in $tmp_libs; do
6216             # FIXME: Pedantically, this is the right thing to do, so
6217             #        that some nasty dependency loop isn't accidentally
6218             #        broken:
6219             #new_libs="$deplib $new_libs"
6220             # Pragmatically, this seems to cause very few problems in
6221             # practice:
6222             case $deplib in
6223             -L*) new_libs="$deplib $new_libs" ;;
6224             -R*) ;;
6225             *)
6226               # And here is the reason: when a library appears more
6227               # than once as an explicit dependence of a library, or
6228               # is implicitly linked in more than once by the
6229               # compiler, it is considered special, and multiple
6230               # occurrences thereof are not removed.  Compare this
6231               # with having the same library being listed as a
6232               # dependency of multiple other libraries: in this case,
6233               # we know (pedantically, we assume) the library does not
6234               # need to be listed more than once, so we keep only the
6235               # last copy.  This is not always right, but it is rare
6236               # enough that we require users that really mean to play
6237               # such unportable linking tricks to link the library
6238               # using -Wl,-lname, so that libtool does not consider it
6239               # for duplicate removal.
6240               case " $specialdeplibs " in
6241               *" $deplib "*) new_libs="$deplib $new_libs" ;;
6242               *)
6243                 case " $new_libs " in
6244                 *" $deplib "*) ;;
6245                 *) new_libs="$deplib $new_libs" ;;
6246                 esac
6247                 ;;
6248               esac
6249               ;;
6250             esac
6251           done
6252           tmp_libs=
6253           for deplib in $new_libs; do
6254             case $deplib in
6255             -L*)
6256               case " $tmp_libs " in
6257               *" $deplib "*) ;;
6258               *) tmp_libs="$tmp_libs $deplib" ;;
6259               esac
6260               ;;
6261             *) tmp_libs="$tmp_libs $deplib" ;;
6262             esac
6263           done
6264           eval $var=\"$tmp_libs\"
6265         done # for var
6266       fi
6267       # Last step: remove runtime libs from dependency_libs
6268       # (they stay in deplibs)
6269       tmp_libs=
6270       for i in $dependency_libs ; do
6271         case " $predeps $postdeps $compiler_lib_search_path " in
6272         *" $i "*)
6273           i=""
6274           ;;
6275         esac
6276         if test -n "$i" ; then
6277           tmp_libs="$tmp_libs $i"
6278         fi
6279       done
6280       dependency_libs=$tmp_libs
6281     done # for pass
6282     if test "$linkmode" = prog; then
6283       dlfiles="$newdlfiles"
6284     fi
6285     if test "$linkmode" = prog || test "$linkmode" = lib; then
6286       dlprefiles="$newdlprefiles"
6287     fi
6288
6289     case $linkmode in
6290     oldlib)
6291       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6292         func_warning "\`-dlopen' is ignored for archives"
6293       fi
6294
6295       case " $deplibs" in
6296       *\ -l* | *\ -L*)
6297         func_warning "\`-l' and \`-L' are ignored for archives" ;;
6298       esac
6299
6300       test -n "$rpath" && \
6301         func_warning "\`-rpath' is ignored for archives"
6302
6303       test -n "$xrpath" && \
6304         func_warning "\`-R' is ignored for archives"
6305
6306       test -n "$vinfo" && \
6307         func_warning "\`-version-info/-version-number' is ignored for archives"
6308
6309       test -n "$release" && \
6310         func_warning "\`-release' is ignored for archives"
6311
6312       test -n "$export_symbols$export_symbols_regex" && \
6313         func_warning "\`-export-symbols' is ignored for archives"
6314
6315       # Now set the variables for building old libraries.
6316       build_libtool_libs=no
6317       oldlibs="$output"
6318       objs="$objs$old_deplibs"
6319       ;;
6320
6321     lib)
6322       # Make sure we only generate libraries of the form `libNAME.la'.
6323       case $outputname in
6324       lib*)
6325         func_stripname 'lib' '.la' "$outputname"
6326         name=$func_stripname_result
6327         eval shared_ext=\"$shrext_cmds\"
6328         eval libname=\"$libname_spec\"
6329         ;;
6330       *)
6331         test "$module" = no && \
6332           func_fatal_help "libtool library \`$output' must begin with \`lib'"
6333
6334         if test "$need_lib_prefix" != no; then
6335           # Add the "lib" prefix for modules if required
6336           func_stripname '' '.la' "$outputname"
6337           name=$func_stripname_result
6338           eval shared_ext=\"$shrext_cmds\"
6339           eval libname=\"$libname_spec\"
6340         else
6341           func_stripname '' '.la' "$outputname"
6342           libname=$func_stripname_result
6343         fi
6344         ;;
6345       esac
6346
6347       if test -n "$objs"; then
6348         if test "$deplibs_check_method" != pass_all; then
6349           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6350         else
6351           echo
6352           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6353           $ECHO "*** objects $objs is not portable!"
6354           libobjs="$libobjs $objs"
6355         fi
6356       fi
6357
6358       test "$dlself" != no && \
6359         func_warning "\`-dlopen self' is ignored for libtool libraries"
6360
6361       set dummy $rpath
6362       shift
6363       test "$#" -gt 1 && \
6364         func_warning "ignoring multiple \`-rpath's for a libtool library"
6365
6366       install_libdir="$1"
6367
6368       oldlibs=
6369       if test -z "$rpath"; then
6370         if test "$build_libtool_libs" = yes; then
6371           # Building a libtool convenience library.
6372           # Some compilers have problems with a `.al' extension so
6373           # convenience libraries should have the same extension an
6374           # archive normally would.
6375           oldlibs="$output_objdir/$libname.$libext $oldlibs"
6376           build_libtool_libs=convenience
6377           build_old_libs=yes
6378         fi
6379
6380         test -n "$vinfo" && \
6381           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6382
6383         test -n "$release" && \
6384           func_warning "\`-release' is ignored for convenience libraries"
6385       else
6386
6387         # Parse the version information argument.
6388         save_ifs="$IFS"; IFS=':'
6389         set dummy $vinfo 0 0 0
6390         shift
6391         IFS="$save_ifs"
6392
6393         test -n "$7" && \
6394           func_fatal_help "too many parameters to \`-version-info'"
6395
6396         # convert absolute version numbers to libtool ages
6397         # this retains compatibility with .la files and attempts
6398         # to make the code below a bit more comprehensible
6399
6400         case $vinfo_number in
6401         yes)
6402           number_major="$1"
6403           number_minor="$2"
6404           number_revision="$3"
6405           #
6406           # There are really only two kinds -- those that
6407           # use the current revision as the major version
6408           # and those that subtract age and use age as
6409           # a minor version.  But, then there is irix
6410           # which has an extra 1 added just for fun
6411           #
6412           case $version_type in
6413           darwin|linux|osf|windows|none)
6414             func_arith $number_major + $number_minor
6415             current=$func_arith_result
6416             age="$number_minor"
6417             revision="$number_revision"
6418             ;;
6419           freebsd-aout|freebsd-elf|qnx|sunos)
6420             current="$number_major"
6421             revision="$number_minor"
6422             age="0"
6423             ;;
6424           irix|nonstopux)
6425             func_arith $number_major + $number_minor
6426             current=$func_arith_result
6427             age="$number_minor"
6428             revision="$number_minor"
6429             lt_irix_increment=no
6430             ;;
6431           esac
6432           ;;
6433         no)
6434           current="$1"
6435           revision="$2"
6436           age="$3"
6437           ;;
6438         esac
6439
6440         # Check that each of the things are valid numbers.
6441         case $current in
6442         0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6443         *)
6444           func_error "CURRENT \`$current' must be a nonnegative integer"
6445           func_fatal_error "\`$vinfo' is not valid version information"
6446           ;;
6447         esac
6448
6449         case $revision in
6450         0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6451         *)
6452           func_error "REVISION \`$revision' must be a nonnegative integer"
6453           func_fatal_error "\`$vinfo' is not valid version information"
6454           ;;
6455         esac
6456
6457         case $age in
6458         0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6459         *)
6460           func_error "AGE \`$age' must be a nonnegative integer"
6461           func_fatal_error "\`$vinfo' is not valid version information"
6462           ;;
6463         esac
6464
6465         if test "$age" -gt "$current"; then
6466           func_error "AGE \`$age' is greater than the current interface number \`$current'"
6467           func_fatal_error "\`$vinfo' is not valid version information"
6468         fi
6469
6470         # Calculate the version variables.
6471         major=
6472         versuffix=
6473         verstring=
6474         case $version_type in
6475         none) ;;
6476
6477         darwin)
6478           # Like Linux, but with the current version available in
6479           # verstring for coding it into the library header
6480           func_arith $current - $age
6481           major=.$func_arith_result
6482           versuffix="$major.$age.$revision"
6483           # Darwin ld doesn't like 0 for these options...
6484           func_arith $current + 1
6485           minor_current=$func_arith_result
6486           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6487           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6488           ;;
6489
6490         freebsd-aout)
6491           major=".$current"
6492           versuffix=".$current.$revision";
6493           ;;
6494
6495         freebsd-elf)
6496           major=".$current"
6497           versuffix=".$current"
6498           ;;
6499
6500         irix | nonstopux)
6501           if test "X$lt_irix_increment" = "Xno"; then
6502             func_arith $current - $age
6503           else
6504             func_arith $current - $age + 1
6505           fi
6506           major=$func_arith_result
6507
6508           case $version_type in
6509             nonstopux) verstring_prefix=nonstopux ;;
6510             *)         verstring_prefix=sgi ;;
6511           esac
6512           verstring="$verstring_prefix$major.$revision"
6513
6514           # Add in all the interfaces that we are compatible with.
6515           loop=$revision
6516           while test "$loop" -ne 0; do
6517             func_arith $revision - $loop
6518             iface=$func_arith_result
6519             func_arith $loop - 1
6520             loop=$func_arith_result
6521             verstring="$verstring_prefix$major.$iface:$verstring"
6522           done
6523
6524           # Before this point, $major must not contain `.'.
6525           major=.$major
6526           versuffix="$major.$revision"
6527           ;;
6528
6529         linux)
6530           func_arith $current - $age
6531           major=.$func_arith_result
6532           versuffix="$major.$age.$revision"
6533           ;;
6534
6535         osf)
6536           func_arith $current - $age
6537           major=.$func_arith_result
6538           versuffix=".$current.$age.$revision"
6539           verstring="$current.$age.$revision"
6540
6541           # Add in all the interfaces that we are compatible with.
6542           loop=$age
6543           while test "$loop" -ne 0; do
6544             func_arith $current - $loop
6545             iface=$func_arith_result
6546             func_arith $loop - 1
6547             loop=$func_arith_result
6548             verstring="$verstring:${iface}.0"
6549           done
6550
6551           # Make executables depend on our current version.
6552           verstring="$verstring:${current}.0"
6553           ;;
6554
6555         qnx)
6556           major=".$current"
6557           versuffix=".$current"
6558           ;;
6559
6560         sunos)
6561           major=".$current"
6562           versuffix=".$current.$revision"
6563           ;;
6564
6565         windows)
6566           # Use '-' rather than '.', since we only want one
6567           # extension on DOS 8.3 filesystems.
6568           func_arith $current - $age
6569           major=$func_arith_result
6570           versuffix="-$major"
6571           ;;
6572
6573         *)
6574           func_fatal_configuration "unknown library version type \`$version_type'"
6575           ;;
6576         esac
6577
6578         # Clear the version info if we defaulted, and they specified a release.
6579         if test -z "$vinfo" && test -n "$release"; then
6580           major=
6581           case $version_type in
6582           darwin)
6583             # we can't check for "0.0" in archive_cmds due to quoting
6584             # problems, so we reset it completely
6585             verstring=
6586             ;;
6587           *)
6588             verstring="0.0"
6589             ;;
6590           esac
6591           if test "$need_version" = no; then
6592             versuffix=
6593           else
6594             versuffix=".0.0"
6595           fi
6596         fi
6597
6598         # Remove version info from name if versioning should be avoided
6599         if test "$avoid_version" = yes && test "$need_version" = no; then
6600           major=
6601           versuffix=
6602           verstring=""
6603         fi
6604
6605         # Check to see if the archive will have undefined symbols.
6606         if test "$allow_undefined" = yes; then
6607           if test "$allow_undefined_flag" = unsupported; then
6608             func_warning "undefined symbols not allowed in $host shared libraries"
6609             build_libtool_libs=no
6610             build_old_libs=yes
6611           fi
6612         else
6613           # Don't allow undefined symbols.
6614           allow_undefined_flag="$no_undefined_flag"
6615         fi
6616
6617       fi
6618
6619       func_generate_dlsyms "$libname" "$libname" "yes"
6620       libobjs="$libobjs $symfileobj"
6621       test "X$libobjs" = "X " && libobjs=
6622
6623       if test "$mode" != relink; then
6624         # Remove our outputs, but don't remove object files since they
6625         # may have been created when compiling PIC objects.
6626         removelist=
6627         tempremovelist=`$ECHO "$output_objdir/*"`
6628         for p in $tempremovelist; do
6629           case $p in
6630             *.$objext | *.gcno)
6631                ;;
6632             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6633                if test "X$precious_files_regex" != "X"; then
6634                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6635                  then
6636                    continue
6637                  fi
6638                fi
6639                removelist="$removelist $p"
6640                ;;
6641             *) ;;
6642           esac
6643         done
6644         test -n "$removelist" && \
6645           func_show_eval "${RM}r \$removelist"
6646       fi
6647
6648       # Now set the variables for building old libraries.
6649       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6650         oldlibs="$oldlibs $output_objdir/$libname.$libext"
6651
6652         # Transform .lo files to .o files.
6653         oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6654       fi
6655
6656       # Eliminate all temporary directories.
6657       #for path in $notinst_path; do
6658       # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
6659       # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
6660       # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6661       #done
6662
6663       if test -n "$xrpath"; then
6664         # If the user specified any rpath flags, then add them.
6665   &nbs