Janis Streib
12.12.21 0a10d5b55056643f20ea896c24a7acf7d63ea5c8
commit | author | age
0a10d5 1
JS 2 # libtool (GNU libtool) 2.4.2
3 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4
5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6 # 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 # This is free software; see the source for copying conditions.  There is NO
8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9
10 # GNU Libtool is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
14 #
15 # As a special exception to the GNU General Public License,
16 # if you distribute this file as part of a program or library that
17 # is built using GNU Libtool, you may include this file under the
18 # same distribution terms that you use for the rest of that program.
19 #
20 # GNU Libtool is distributed in the hope that it will be useful, but
21 # WITHOUT ANY WARRANTY; without even the implied warranty of
22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23 # General Public License for more details.
24 #
25 # You should have received a copy of the GNU General Public License
26 # along with GNU Libtool; see the file COPYING.  If not, a copy
27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28 # or obtained by writing to the Free Software Foundation, Inc.,
29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30
31 # Usage: $progname [OPTION]... [MODE-ARG]...
32 #
33 # Provide generalized library-building support services.
34 #
35 #       --config             show all configuration variables
36 #       --debug              enable verbose shell tracing
37 #   -n, --dry-run            display commands without modifying any files
38 #       --features           display basic configuration information and exit
39 #       --mode=MODE          use operation mode MODE
40 #       --preserve-dup-deps  don't remove duplicate dependency libraries
41 #       --quiet, --silent    don't print informational messages
42 #       --no-quiet, --no-silent
43 #                            print informational messages (default)
44 #       --no-warn            don't display warning messages
45 #       --tag=TAG            use configuration variables from tag TAG
46 #   -v, --verbose            print more informational messages than default
47 #       --no-verbose         don't print the extra informational messages
48 #       --version            print version information
49 #   -h, --help, --help-all   print short, long, or detailed help message
50 #
51 # MODE must be one of the following:
52 #
53 #         clean              remove files from the build directory
54 #         compile            compile a source file into a libtool object
55 #         execute            automatically set library path, then run a program
56 #         finish             complete the installation of libtool libraries
57 #         install            install libraries or executables
58 #         link               create a library or an executable
59 #         uninstall          remove libraries from an installed directory
60 #
61 # MODE-ARGS vary depending on the MODE.  When passed as first option,
62 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
63 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64 #
65 # When reporting a bug, please describe a test case to reproduce it and
66 # include the following information:
67 #
68 #         host-triplet:    $host
69 #         shell:        $SHELL
70 #         compiler:        $LTCC
71 #         compiler flags:        $LTCFLAGS
72 #         linker:        $LD (gnu? $with_gnu_ld)
73 #         $progname:    (GNU libtool) 2.4.2
74 #         automake:    $automake_version
75 #         autoconf:    $autoconf_version
76 #
77 # Report bugs to <bug-libtool@gnu.org>.
78 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79 # General help using GNU software: <http://www.gnu.org/gethelp/>.
80
81 PROGRAM=libtool
82 PACKAGE=libtool
83 VERSION=2.4.2
84 TIMESTAMP=""
85 package_revision=1.3337
86
87 # Be Bourne compatible
88 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
89   emulate sh
90   NULLCMD=:
91   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92   # is contrary to our usage.  Disable this feature.
93   alias -g '${1+"$@"}'='"$@"'
94   setopt NO_GLOB_SUBST
95 else
96   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97 fi
98 BIN_SH=xpg4; export BIN_SH # for Tru64
99 DUALCASE=1; export DUALCASE # for MKS sh
100
101 # A function that is used when there is no print builtin or printf.
102 func_fallback_echo ()
103 {
104   eval 'cat <<_LTECHO_EOF
105 $1
106 _LTECHO_EOF'
107 }
108
109 # NLS nuisances: We save the old values to restore during execute mode.
110 lt_user_locale=
111 lt_safe_locale=
112 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113 do
114   eval "if test \"\${$lt_var+set}\" = set; then
115           save_$lt_var=\$$lt_var
116           $lt_var=C
117       export $lt_var
118       lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119       lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
120     fi"
121 done
122 LC_ALL=C
123 LANGUAGE=C
124 export LANGUAGE LC_ALL
125
126 $lt_unset CDPATH
127
128
129 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130 # is ksh but when the shell is invoked as "sh" and the current value of
131 # the _XPG environment variable is not equal to 1 (one), the special
132 # positional parameter $0, within a function call, is the name of the
133 # function.
134 progpath="$0"
135
136
137
138 : ${CP="cp -f"}
139 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
140 : ${MAKE="make"}
141 : ${MKDIR="mkdir"}
142 : ${MV="mv -f"}
143 : ${RM="rm -f"}
144 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145 : ${Xsed="$SED -e 1s/^X//"}
146
147 # Global variables:
148 EXIT_SUCCESS=0
149 EXIT_FAILURE=1
150 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
151 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
152
153 exit_status=$EXIT_SUCCESS
154
155 # Make sure IFS has a sensible default
156 lt_nl='
157 '
158 IFS="     $lt_nl"
159
160 dirname="s,/[^/]*$,,"
161 basename="s,^.*/,,"
162
163 # func_dirname file append nondir_replacement
164 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
165 # otherwise set result to NONDIR_REPLACEMENT.
166 func_dirname ()
167 {
168     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
169     if test "X$func_dirname_result" = "X${1}"; then
170       func_dirname_result="${3}"
171     else
172       func_dirname_result="$func_dirname_result${2}"
173     fi
174 } # func_dirname may be replaced by extended shell implementation
175
176
177 # func_basename file
178 func_basename ()
179 {
180     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
181 } # func_basename may be replaced by extended shell implementation
182
183
184 # func_dirname_and_basename file append nondir_replacement
185 # perform func_basename and func_dirname in a single function
186 # call:
187 #   dirname:  Compute the dirname of FILE.  If nonempty,
188 #             add APPEND to the result, otherwise set result
189 #             to NONDIR_REPLACEMENT.
190 #             value returned in "$func_dirname_result"
191 #   basename: Compute filename of FILE.
192 #             value retuned in "$func_basename_result"
193 # Implementation must be kept synchronized with func_dirname
194 # and func_basename. For efficiency, we do not delegate to
195 # those functions but instead duplicate the functionality here.
196 func_dirname_and_basename ()
197 {
198     # Extract subdirectory from the argument.
199     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
200     if test "X$func_dirname_result" = "X${1}"; then
201       func_dirname_result="${3}"
202     else
203       func_dirname_result="$func_dirname_result${2}"
204     fi
205     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
206 } # func_dirname_and_basename may be replaced by extended shell implementation
207
208
209 # func_stripname prefix suffix name
210 # strip PREFIX and SUFFIX off of NAME.
211 # PREFIX and SUFFIX must not contain globbing or regex special
212 # characters, hashes, percent signs, but SUFFIX may contain a leading
213 # dot (in which case that matches only a dot).
214 # func_strip_suffix prefix name
215 func_stripname ()
216 {
217     case ${2} in
218       .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219       *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
220     esac
221 } # func_stripname may be replaced by extended shell implementation
222
223
224 # These SED scripts presuppose an absolute path with a trailing slash.
225 pathcar='s,^/\([^/]*\).*$,\1,'
226 pathcdr='s,^/[^/]*,,'
227 removedotparts=':dotsl
228         s@/\./@/@g
229         t dotsl
230         s,/\.$,/,'
231 collapseslashes='s@/\{1,\}@/@g'
232 finalslash='s,/*$,/,'
233
234 # func_normal_abspath PATH
235 # Remove doubled-up and trailing slashes, "." path components,
236 # and cancel out any ".." path components in PATH after making
237 # it an absolute path.
238 #             value returned in "$func_normal_abspath_result"
239 func_normal_abspath ()
240 {
241   # Start from root dir and reassemble the path.
242   func_normal_abspath_result=
243   func_normal_abspath_tpath=$1
244   func_normal_abspath_altnamespace=
245   case $func_normal_abspath_tpath in
246     "")
247       # Empty path, that just means $cwd.
248       func_stripname '' '/' "`pwd`"
249       func_normal_abspath_result=$func_stripname_result
250       return
251     ;;
252     # The next three entries are used to spot a run of precisely
253     # two leading slashes without using negated character classes;
254     # we take advantage of case's first-match behaviour.
255     ///*)
256       # Unusual form of absolute path, do nothing.
257     ;;
258     //*)
259       # Not necessarily an ordinary path; POSIX reserves leading '//'
260       # and for example Cygwin uses it to access remote file shares
261       # over CIFS/SMB, so we conserve a leading double slash if found.
262       func_normal_abspath_altnamespace=/
263     ;;
264     /*)
265       # Absolute path, do nothing.
266     ;;
267     *)
268       # Relative path, prepend $cwd.
269       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
270     ;;
271   esac
272   # Cancel out all the simple stuff to save iterations.  We also want
273   # the path to end with a slash for ease of parsing, so make sure
274   # there is one (and only one) here.
275   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
276         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
277   while :; do
278     # Processed it all yet?
279     if test "$func_normal_abspath_tpath" = / ; then
280       # If we ascended to the root using ".." the result may be empty now.
281       if test -z "$func_normal_abspath_result" ; then
282         func_normal_abspath_result=/
283       fi
284       break
285     fi
286     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
287         -e "$pathcar"`
288     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
289         -e "$pathcdr"`
290     # Figure out what to do with it
291     case $func_normal_abspath_tcomponent in
292       "")
293         # Trailing empty path component, ignore it.
294       ;;
295       ..)
296         # Parent dir; strip last assembled component from result.
297         func_dirname "$func_normal_abspath_result"
298         func_normal_abspath_result=$func_dirname_result
299       ;;
300       *)
301         # Actual path component, append it.
302         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
303       ;;
304     esac
305   done
306   # Restore leading double-slash if one was found on entry.
307   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
308 }
309
310 # func_relative_path SRCDIR DSTDIR
311 # generates a relative path from SRCDIR to DSTDIR, with a trailing
312 # slash if non-empty, suitable for immediately appending a filename
313 # without needing to append a separator.
314 #             value returned in "$func_relative_path_result"
315 func_relative_path ()
316 {
317   func_relative_path_result=
318   func_normal_abspath "$1"
319   func_relative_path_tlibdir=$func_normal_abspath_result
320   func_normal_abspath "$2"
321   func_relative_path_tbindir=$func_normal_abspath_result
322
323   # Ascend the tree starting from libdir
324   while :; do
325     # check if we have found a prefix of bindir
326     case $func_relative_path_tbindir in
327       $func_relative_path_tlibdir)
328         # found an exact match
329         func_relative_path_tcancelled=
330         break
331         ;;
332       $func_relative_path_tlibdir*)
333         # found a matching prefix
334         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335         func_relative_path_tcancelled=$func_stripname_result
336         if test -z "$func_relative_path_result"; then
337           func_relative_path_result=.
338         fi
339         break
340         ;;
341       *)
342         func_dirname $func_relative_path_tlibdir
343         func_relative_path_tlibdir=${func_dirname_result}
344         if test "x$func_relative_path_tlibdir" = x ; then
345           # Have to descend all the way to the root!
346           func_relative_path_result=../$func_relative_path_result
347           func_relative_path_tcancelled=$func_relative_path_tbindir
348           break
349         fi
350         func_relative_path_result=../$func_relative_path_result
351         ;;
352     esac
353   done
354
355   # Now calculate path; take care to avoid doubling-up slashes.
356   func_stripname '' '/' "$func_relative_path_result"
357   func_relative_path_result=$func_stripname_result
358   func_stripname '/' '/' "$func_relative_path_tcancelled"
359   if test "x$func_stripname_result" != x ; then
360     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
361   fi
362
363   # Normalisation. If bindir is libdir, return empty string,
364   # else relative path ending with a slash; either way, target
365   # file name can be directly appended.
366   if test ! -z "$func_relative_path_result"; then
367     func_stripname './' '' "$func_relative_path_result/"
368     func_relative_path_result=$func_stripname_result
369   fi
370 }
371
372 # The name of this program:
373 func_dirname_and_basename "$progpath"
374 progname=$func_basename_result
375
376 # Make sure we have an absolute path for reexecution:
377 case $progpath in
378   [\\/]*|[A-Za-z]:\\*) ;;
379   *[\\/]*)
380      progdir=$func_dirname_result
381      progdir=`cd "$progdir" && pwd`
382      progpath="$progdir/$progname"
383      ;;
384   *)
385      save_IFS="$IFS"
386      IFS=${PATH_SEPARATOR-:}
387      for progdir in $PATH; do
388        IFS="$save_IFS"
389        test -x "$progdir/$progname" && break
390      done
391      IFS="$save_IFS"
392      test -n "$progdir" || progdir=`pwd`
393      progpath="$progdir/$progname"
394      ;;
395 esac
396
397 # Sed substitution that helps us do robust quoting.  It backslashifies
398 # metacharacters that are still active within double-quoted strings.
399 Xsed="${SED}"' -e 1s/^X//'
400 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
401
402 # Same as above, but do not quote variable references.
403 double_quote_subst='s/\(["`\\]\)/\\\1/g'
404
405 # Sed substitution that turns a string into a regex matching for the
406 # string literally.
407 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
408
409 # Sed substitution that converts a w32 file name or path
410 # which contains forward slashes, into one that contains
411 # (escaped) backslashes.  A very naive implementation.
412 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
413
414 # Re-`\' parameter expansions in output of double_quote_subst that were
415 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
416 # in input to double_quote_subst, that '$' was protected from expansion.
417 # Since each input `\' is now two `\'s, look for any number of runs of
418 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
419 bs='\\'
420 bs2='\\\\'
421 bs4='\\\\\\\\'
422 dollar='\$'
423 sed_double_backslash="\
424   s/$bs4/&\\
425 /g
426   s/^$bs2$dollar/$bs&/
427   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
428   s/\n//g"
429
430 # Standard options:
431 opt_dry_run=false
432 opt_help=false
433 opt_quiet=false
434 opt_verbose=false
435 opt_warning=:
436
437 # func_echo arg...
438 # Echo program name prefixed message, along with the current mode
439 # name if it has been set yet.
440 func_echo ()
441 {
442     $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
443 }
444
445 # func_verbose arg...
446 # Echo program name prefixed message in verbose mode only.
447 func_verbose ()
448 {
449     $opt_verbose && func_echo ${1+"$@"}
450
451     # A bug in bash halts the script if the last line of a function
452     # fails when set -e is in force, so we need another command to
453     # work around that:
454     :
455 }
456
457 # func_echo_all arg...
458 # Invoke $ECHO with all args, space-separated.
459 func_echo_all ()
460 {
461     $ECHO "$*"
462 }
463
464 # func_error arg...
465 # Echo program name prefixed message to standard error.
466 func_error ()
467 {
468     $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
469 }
470
471 # func_warning arg...
472 # Echo program name prefixed warning message to standard error.
473 func_warning ()
474 {
475     $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
476
477     # bash bug again:
478     :
479 }
480
481 # func_fatal_error arg...
482 # Echo program name prefixed message to standard error, and exit.
483 func_fatal_error ()
484 {
485     func_error ${1+"$@"}
486     exit $EXIT_FAILURE
487 }
488
489 # func_fatal_help arg...
490 # Echo program name prefixed message to standard error, followed by
491 # a help hint, and exit.
492 func_fatal_help ()
493 {
494     func_error ${1+"$@"}
495     func_fatal_error "$help"
496 }
497 help="Try \`$progname --help' for more information."  ## default
498
499
500 # func_grep expression filename
501 # Check whether EXPRESSION matches any line of FILENAME, without output.
502 func_grep ()
503 {
504     $GREP "$1" "$2" >/dev/null 2>&1
505 }
506
507
508 # func_mkdir_p directory-path
509 # Make sure the entire path to DIRECTORY-PATH is available.
510 func_mkdir_p ()
511 {
512     my_directory_path="$1"
513     my_dir_list=
514
515     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
516
517       # Protect directory names starting with `-'
518       case $my_directory_path in
519         -*) my_directory_path="./$my_directory_path" ;;
520       esac
521
522       # While some portion of DIR does not yet exist...
523       while test ! -d "$my_directory_path"; do
524         # ...make a list in topmost first order.  Use a colon delimited
525     # list incase some portion of path contains whitespace.
526         my_dir_list="$my_directory_path:$my_dir_list"
527
528         # If the last portion added has no slash in it, the list is done
529         case $my_directory_path in */*) ;; *) break ;; esac
530
531         # ...otherwise throw away the child directory and loop
532         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
533       done
534       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
535
536       save_mkdir_p_IFS="$IFS"; IFS=':'
537       for my_dir in $my_dir_list; do
538     IFS="$save_mkdir_p_IFS"
539         # mkdir can fail with a `File exist' error if two processes
540         # try to create one of the directories concurrently.  Don't
541         # stop in that case!
542         $MKDIR "$my_dir" 2>/dev/null || :
543       done
544       IFS="$save_mkdir_p_IFS"
545
546       # Bail out if we (or some other process) failed to create a directory.
547       test -d "$my_directory_path" || \
548         func_fatal_error "Failed to create \`$1'"
549     fi
550 }
551
552
553 # func_mktempdir [string]
554 # Make a temporary directory that won't clash with other running
555 # libtool processes, and avoids race conditions if possible.  If
556 # given, STRING is the basename for that directory.
557 func_mktempdir ()
558 {
559     my_template="${TMPDIR-/tmp}/${1-$progname}"
560
561     if test "$opt_dry_run" = ":"; then
562       # Return a directory name, but don't create it in dry-run mode
563       my_tmpdir="${my_template}-$$"
564     else
565
566       # If mktemp works, use that first and foremost
567       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
568
569       if test ! -d "$my_tmpdir"; then
570         # Failing that, at least try and use $RANDOM to avoid a race
571         my_tmpdir="${my_template}-${RANDOM-0}$$"
572
573         save_mktempdir_umask=`umask`
574         umask 0077
575         $MKDIR "$my_tmpdir"
576         umask $save_mktempdir_umask
577       fi
578
579       # If we're not in dry-run mode, bomb out on failure
580       test -d "$my_tmpdir" || \
581         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
582     fi
583
584     $ECHO "$my_tmpdir"
585 }
586
587
588 # func_quote_for_eval arg
589 # Aesthetically quote ARG to be evaled later.
590 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591 # is double-quoted, suitable for a subsequent eval, whereas
592 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593 # which are still active within double quotes backslashified.
594 func_quote_for_eval ()
595 {
596     case $1 in
597       *[\\\`\"\$]*)
598     func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
599       *)
600         func_quote_for_eval_unquoted_result="$1" ;;
601     esac
602
603     case $func_quote_for_eval_unquoted_result in
604       # Double-quote args containing shell metacharacters to delay
605       # word splitting, command substitution and and variable
606       # expansion for a subsequent eval.
607       # Many Bourne shells cannot handle close brackets correctly
608       # in scan sets, so we specify it separately.
609       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
610         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
611         ;;
612       *)
613         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
614     esac
615 }
616
617
618 # func_quote_for_expand arg
619 # Aesthetically quote ARG to be evaled later; same as above,
620 # but do not quote variable references.
621 func_quote_for_expand ()
622 {
623     case $1 in
624       *[\\\`\"]*)
625     my_arg=`$ECHO "$1" | $SED \
626         -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
627       *)
628         my_arg="$1" ;;
629     esac
630
631     case $my_arg in
632       # Double-quote args containing shell metacharacters to delay
633       # word splitting and command substitution for a subsequent eval.
634       # Many Bourne shells cannot handle close brackets correctly
635       # in scan sets, so we specify it separately.
636       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
637         my_arg="\"$my_arg\""
638         ;;
639     esac
640
641     func_quote_for_expand_result="$my_arg"
642 }
643
644
645 # func_show_eval cmd [fail_exp]
646 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
647 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
648 # is given, then evaluate it.
649 func_show_eval ()
650 {
651     my_cmd="$1"
652     my_fail_exp="${2-:}"
653
654     ${opt_silent-false} || {
655       func_quote_for_expand "$my_cmd"
656       eval "func_echo $func_quote_for_expand_result"
657     }
658
659     if ${opt_dry_run-false}; then :; else
660       eval "$my_cmd"
661       my_status=$?
662       if test "$my_status" -eq 0; then :; else
663     eval "(exit $my_status); $my_fail_exp"
664       fi
665     fi
666 }
667
668
669 # func_show_eval_locale cmd [fail_exp]
670 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
671 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
672 # is given, then evaluate it.  Use the saved locale for evaluation.
673 func_show_eval_locale ()
674 {
675     my_cmd="$1"
676     my_fail_exp="${2-:}"
677
678     ${opt_silent-false} || {
679       func_quote_for_expand "$my_cmd"
680       eval "func_echo $func_quote_for_expand_result"
681     }
682
683     if ${opt_dry_run-false}; then :; else
684       eval "$lt_user_locale
685         $my_cmd"
686       my_status=$?
687       eval "$lt_safe_locale"
688       if test "$my_status" -eq 0; then :; else
689     eval "(exit $my_status); $my_fail_exp"
690       fi
691     fi
692 }
693
694 # func_tr_sh
695 # Turn $1 into a string suitable for a shell variable name.
696 # Result is stored in $func_tr_sh_result.  All characters
697 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698 # if $1 begins with a digit, a '_' is prepended as well.
699 func_tr_sh ()
700 {
701   case $1 in
702   [0-9]* | *[!a-zA-Z0-9_]*)
703     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
704     ;;
705   * )
706     func_tr_sh_result=$1
707     ;;
708   esac
709 }
710
711
712 # func_version
713 # Echo version message to standard output and exit.
714 func_version ()
715 {
716     $opt_debug
717
718     $SED -n '/(C)/!b go
719     :more
720     /\./!{
721       N
722       s/\n# / /
723       b more
724     }
725     :go
726     /^# '$PROGRAM' (GNU /,/# warranty; / {
727         s/^# //
728     s/^# *$//
729         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
730         p
731      }' < "$progpath"
732      exit $?
733 }
734
735 # func_usage
736 # Echo short help message to standard output and exit.
737 func_usage ()
738 {
739     $opt_debug
740
741     $SED -n '/^# Usage:/,/^#  *.*--help/ {
742         s/^# //
743     s/^# *$//
744     s/\$progname/'$progname'/
745     p
746     }' < "$progpath"
747     echo
748     $ECHO "run \`$progname --help | more' for full usage"
749     exit $?
750 }
751
752 # func_help [NOEXIT]
753 # Echo long help message to standard output and exit,
754 # unless 'noexit' is passed as argument.
755 func_help ()
756 {
757     $opt_debug
758
759     $SED -n '/^# Usage:/,/# Report bugs to/ {
760     :print
761         s/^# //
762     s/^# *$//
763     s*\$progname*'$progname'*
764     s*\$host*'"$host"'*
765     s*\$SHELL*'"$SHELL"'*
766     s*\$LTCC*'"$LTCC"'*
767     s*\$LTCFLAGS*'"$LTCFLAGS"'*
768     s*\$LD*'"$LD"'*
769     s/\$with_gnu_ld/'"$with_gnu_ld"'/
770     s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771     s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
772     p
773     d
774      }
775      /^# .* home page:/b print
776      /^# General help using/b print
777      ' < "$progpath"
778     ret=$?
779     if test -z "$1"; then
780       exit $ret
781     fi
782 }
783
784 # func_missing_arg argname
785 # Echo program name prefixed message to standard error and set global
786 # exit_cmd.
787 func_missing_arg ()
788 {
789     $opt_debug
790
791     func_error "missing argument for $1."
792     exit_cmd=exit
793 }
794
795
796 # func_split_short_opt shortopt
797 # Set func_split_short_opt_name and func_split_short_opt_arg shell
798 # variables after splitting SHORTOPT after the 2nd character.
799 func_split_short_opt ()
800 {
801     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
802     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
803
804     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806 } # func_split_short_opt may be replaced by extended shell implementation
807
808
809 # func_split_long_opt longopt
810 # Set func_split_long_opt_name and func_split_long_opt_arg shell
811 # variables after splitting LONGOPT at the `=' sign.
812 func_split_long_opt ()
813 {
814     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
815     my_sed_long_arg='1s/^--[^=]*=//'
816
817     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819 } # func_split_long_opt may be replaced by extended shell implementation
820
821 exit_cmd=:
822
823
824
825
826
827 magic="%%%MAGIC variable%%%"
828 magic_exe="%%%MAGIC EXE variable%%%"
829
830 # Global variables.
831 nonopt=
832 preserve_args=
833 lo2o="s/\\.lo\$/.${objext}/"
834 o2lo="s/\\.${objext}\$/.lo/"
835 extracted_archives=
836 extracted_serial=0
837
838 # If this variable is set in any of the actions, the command in it
839 # will be execed at the end.  This prevents here-documents from being
840 # left over by shells.
841 exec_cmd=
842
843 # func_append var value
844 # Append VALUE to the end of shell variable VAR.
845 func_append ()
846 {
847     eval "${1}=\$${1}\${2}"
848 } # func_append may be replaced by extended shell implementation
849
850 # func_append_quoted var value
851 # Quote VALUE and append to the end of shell variable VAR, separated
852 # by a space.
853 func_append_quoted ()
854 {
855     func_quote_for_eval "${2}"
856     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857 } # func_append_quoted may be replaced by extended shell implementation
858
859
860 # func_arith arithmetic-term...
861 func_arith ()
862 {
863     func_arith_result=`expr "${@}"`
864 } # func_arith may be replaced by extended shell implementation
865
866
867 # func_len string
868 # STRING may not start with a hyphen.
869 func_len ()
870 {
871     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872 } # func_len may be replaced by extended shell implementation
873
874
875 # func_lo2o object
876 func_lo2o ()
877 {
878     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
879 } # func_lo2o may be replaced by extended shell implementation
880
881
882 # func_xform libobj-or-source
883 func_xform ()
884 {
885     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886 } # func_xform may be replaced by extended shell implementation
887
888
889 # func_fatal_configuration arg...
890 # Echo program name prefixed message to standard error, followed by
891 # a configuration failure hint, and exit.
892 func_fatal_configuration ()
893 {
894     func_error ${1+"$@"}
895     func_error "See the $PACKAGE documentation for more information."
896     func_fatal_error "Fatal configuration error."
897 }
898
899
900 # func_config
901 # Display the configuration for all the tags in this script.
902 func_config ()
903 {
904     re_begincf='^# ### BEGIN LIBTOOL'
905     re_endcf='^# ### END LIBTOOL'
906
907     # Default configuration.
908     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
909
910     # Now print the configurations for the tags.
911     for tagname in $taglist; do
912       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
913     done
914
915     exit $?
916 }
917
918 # func_features
919 # Display the features supported by this script.
920 func_features ()
921 {
922     echo "host: $host"
923     if test "$build_libtool_libs" = yes; then
924       echo "enable shared libraries"
925     else
926       echo "disable shared libraries"
927     fi
928     if test "$build_old_libs" = yes; then
929       echo "enable static libraries"
930     else
931       echo "disable static libraries"
932     fi
933
934     exit $?
935 }
936
937 # func_enable_tag tagname
938 # Verify that TAGNAME is valid, and either flag an error and exit, or
939 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
940 # variable here.
941 func_enable_tag ()
942 {
943   # Global variable:
944   tagname="$1"
945
946   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948   sed_extractcf="/$re_begincf/,/$re_endcf/p"
949
950   # Validate tagname.
951   case $tagname in
952     *[!-_A-Za-z0-9,/]*)
953       func_fatal_error "invalid tag name: $tagname"
954       ;;
955   esac
956
957   # Don't test for the "default" C tag, as we know it's
958   # there but not specially marked.
959   case $tagname in
960     CC) ;;
961     *)
962       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
963     taglist="$taglist $tagname"
964
965     # Evaluate the configuration.  Be careful to quote the path
966     # and the sed script, to avoid splitting on whitespace, but
967     # also don't use non-portable quotes within backquotes within
968     # quotes we have to do it in 2 steps:
969     extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
970     eval "$extractedcf"
971       else
972     func_error "ignoring unknown tag $tagname"
973       fi
974       ;;
975   esac
976 }
977
978 # func_check_version_match
979 # Ensure that we are using m4 macros, and libtool script from the same
980 # release of libtool.
981 func_check_version_match ()
982 {
983   if test "$package_revision" != "$macro_revision"; then
984     if test "$VERSION" != "$macro_version"; then
985       if test -z "$macro_version"; then
986         cat >&2 <<_LT_EOF
987 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
988 $progname: definition of this LT_INIT comes from an older release.
989 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990 $progname: and run autoconf again.
991 _LT_EOF
992       else
993         cat >&2 <<_LT_EOF
994 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
995 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997 $progname: and run autoconf again.
998 _LT_EOF
999       fi
1000     else
1001       cat >&2 <<_LT_EOF
1002 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1003 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005 $progname: of $PACKAGE $VERSION and run autoconf again.
1006 _LT_EOF
1007     fi
1008
1009     exit $EXIT_MISMATCH
1010   fi
1011 }
1012
1013
1014 # Shorthand for --mode=foo, only valid as the first argument
1015 case $1 in
1016 clean|clea|cle|cl)
1017   shift; set dummy --mode clean ${1+"$@"}; shift
1018   ;;
1019 compile|compil|compi|comp|com|co|c)
1020   shift; set dummy --mode compile ${1+"$@"}; shift
1021   ;;
1022 execute|execut|execu|exec|exe|ex|e)
1023   shift; set dummy --mode execute ${1+"$@"}; shift
1024   ;;
1025 finish|finis|fini|fin|fi|f)
1026   shift; set dummy --mode finish ${1+"$@"}; shift
1027   ;;
1028 install|instal|insta|inst|ins|in|i)
1029   shift; set dummy --mode install ${1+"$@"}; shift
1030   ;;
1031 link|lin|li|l)
1032   shift; set dummy --mode link ${1+"$@"}; shift
1033   ;;
1034 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1035   shift; set dummy --mode uninstall ${1+"$@"}; shift
1036   ;;
1037 esac
1038
1039
1040
1041 # Option defaults:
1042 opt_debug=:
1043 opt_dry_run=false
1044 opt_config=false
1045 opt_preserve_dup_deps=false
1046 opt_features=false
1047 opt_finish=false
1048 opt_help=false
1049 opt_help_all=false
1050 opt_silent=:
1051 opt_warning=:
1052 opt_verbose=:
1053 opt_silent=false
1054 opt_verbose=false
1055
1056
1057 # Parse options once, thoroughly.  This comes as soon as possible in the
1058 # script to make things like `--version' happen as quickly as we can.
1059 {
1060   # this just eases exit handling
1061   while test $# -gt 0; do
1062     opt="$1"
1063     shift
1064     case $opt in
1065       --debug|-x)    opt_debug='set -x'
1066             func_echo "enabling shell trace mode"
1067             $opt_debug
1068             ;;
1069       --dry-run|--dryrun|-n)
1070             opt_dry_run=:
1071             ;;
1072       --config)
1073             opt_config=:
1074 func_config
1075             ;;
1076       --dlopen|-dlopen)
1077             optarg="$1"
1078             opt_dlopen="${opt_dlopen+$opt_dlopen
1079 }$optarg"
1080             shift
1081             ;;
1082       --preserve-dup-deps)
1083             opt_preserve_dup_deps=:
1084             ;;
1085       --features)
1086             opt_features=:
1087 func_features
1088             ;;
1089       --finish)
1090             opt_finish=:
1091 set dummy --mode finish ${1+"$@"}; shift
1092             ;;
1093       --help)
1094             opt_help=:
1095             ;;
1096       --help-all)
1097             opt_help_all=:
1098 opt_help=': help-all'
1099             ;;
1100       --mode)
1101             test $# = 0 && func_missing_arg $opt && break
1102             optarg="$1"
1103             opt_mode="$optarg"
1104 case $optarg in
1105   # Valid mode arguments:
1106   clean|compile|execute|finish|install|link|relink|uninstall) ;;
1107
1108   # Catch anything else as an error
1109   *) func_error "invalid argument for $opt"
1110      exit_cmd=exit
1111      break
1112      ;;
1113 esac
1114             shift
1115             ;;
1116       --no-silent|--no-quiet)
1117             opt_silent=false
1118 func_append preserve_args " $opt"
1119             ;;
1120       --no-warning|--no-warn)
1121             opt_warning=false
1122 func_append preserve_args " $opt"
1123             ;;
1124       --no-verbose)
1125             opt_verbose=false
1126 func_append preserve_args " $opt"
1127             ;;
1128       --silent|--quiet)
1129             opt_silent=:
1130 func_append preserve_args " $opt"
1131         opt_verbose=false
1132             ;;
1133       --verbose|-v)
1134             opt_verbose=:
1135 func_append preserve_args " $opt"
1136 opt_silent=false
1137             ;;
1138       --tag)
1139             test $# = 0 && func_missing_arg $opt && break
1140             optarg="$1"
1141             opt_tag="$optarg"
1142 func_append preserve_args " $opt $optarg"
1143 func_enable_tag "$optarg"
1144             shift
1145             ;;
1146
1147       -\?|-h)        func_usage                ;;
1148       --help)        func_help                ;;
1149       --version)    func_version                ;;
1150
1151       # Separate optargs to long options:
1152       --*=*)
1153             func_split_long_opt "$opt"
1154             set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1155             shift
1156             ;;
1157
1158       # Separate non-argument short options:
1159       -\?*|-h*|-n*|-v*)
1160             func_split_short_opt "$opt"
1161             set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1162             shift
1163             ;;
1164
1165       --)        break                    ;;
1166       -*)        func_fatal_help "unrecognized option \`$opt'" ;;
1167       *)        set dummy "$opt" ${1+"$@"};    shift; break  ;;
1168     esac
1169   done
1170
1171   # Validate options:
1172
1173   # save first non-option argument
1174   if test "$#" -gt 0; then
1175     nonopt="$opt"
1176     shift
1177   fi
1178
1179   # preserve --debug
1180   test "$opt_debug" = : || func_append preserve_args " --debug"
1181
1182   case $host in
1183     *cygwin* | *mingw* | *pw32* | *cegcc*)
1184       # don't eliminate duplications in $postdeps and $predeps
1185       opt_duplicate_compiler_generated_deps=:
1186       ;;
1187     *)
1188       opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1189       ;;
1190   esac
1191
1192   $opt_help || {
1193     # Sanity checks first:
1194     func_check_version_match
1195
1196     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197       func_fatal_configuration "not configured to build any kind of library"
1198     fi
1199
1200     # Darwin sucks
1201     eval std_shrext=\"$shrext_cmds\"
1202
1203     # Only execute mode is allowed to have -dlopen flags.
1204     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1205       func_error "unrecognized option \`-dlopen'"
1206       $ECHO "$help" 1>&2
1207       exit $EXIT_FAILURE
1208     fi
1209
1210     # Change the help message to a mode-specific one.
1211     generic_help="$help"
1212     help="Try \`$progname --help --mode=$opt_mode' for more information."
1213   }
1214
1215
1216   # Bail if the options were screwed
1217   $exit_cmd $EXIT_FAILURE
1218 }
1219
1220
1221
1222
1223 ## ----------- ##
1224 ##    Main.    ##
1225 ## ----------- ##
1226
1227 # func_lalib_p file
1228 # True iff FILE is a libtool `.la' library or `.lo' object file.
1229 # This function is only a basic sanity check; it will hardly flush out
1230 # determined imposters.
1231 func_lalib_p ()
1232 {
1233     test -f "$1" &&
1234       $SED -e 4q "$1" 2>/dev/null \
1235         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1236 }
1237
1238 # func_lalib_unsafe_p file
1239 # True iff FILE is a libtool `.la' library or `.lo' object file.
1240 # This function implements the same check as func_lalib_p without
1241 # resorting to external programs.  To this end, it redirects stdin and
1242 # closes it afterwards, without saving the original file descriptor.
1243 # As a safety measure, use it only where a negative result would be
1244 # fatal anyway.  Works if `file' does not exist.
1245 func_lalib_unsafe_p ()
1246 {
1247     lalib_p=no
1248     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249     for lalib_p_l in 1 2 3 4
1250     do
1251         read lalib_p_line
1252         case "$lalib_p_line" in
1253         \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1254         esac
1255     done
1256     exec 0<&5 5<&-
1257     fi
1258     test "$lalib_p" = yes
1259 }
1260
1261 # func_ltwrapper_script_p file
1262 # True iff FILE is a libtool wrapper script
1263 # This function is only a basic sanity check; it will hardly flush out
1264 # determined imposters.
1265 func_ltwrapper_script_p ()
1266 {
1267     func_lalib_p "$1"
1268 }
1269
1270 # func_ltwrapper_executable_p file
1271 # True iff FILE is a libtool wrapper executable
1272 # This function is only a basic sanity check; it will hardly flush out
1273 # determined imposters.
1274 func_ltwrapper_executable_p ()
1275 {
1276     func_ltwrapper_exec_suffix=
1277     case $1 in
1278     *.exe) ;;
1279     *) func_ltwrapper_exec_suffix=.exe ;;
1280     esac
1281     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1282 }
1283
1284 # func_ltwrapper_scriptname file
1285 # Assumes file is an ltwrapper_executable
1286 # uses $file to determine the appropriate filename for a
1287 # temporary ltwrapper_script.
1288 func_ltwrapper_scriptname ()
1289 {
1290     func_dirname_and_basename "$1" "" "."
1291     func_stripname '' '.exe' "$func_basename_result"
1292     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1293 }
1294
1295 # func_ltwrapper_p file
1296 # True iff FILE is a libtool wrapper script or wrapper executable
1297 # This function is only a basic sanity check; it will hardly flush out
1298 # determined imposters.
1299 func_ltwrapper_p ()
1300 {
1301     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1302 }
1303
1304
1305 # func_execute_cmds commands fail_cmd
1306 # Execute tilde-delimited COMMANDS.
1307 # If FAIL_CMD is given, eval that upon failure.
1308 # FAIL_CMD may read-access the current command in variable CMD!
1309 func_execute_cmds ()
1310 {
1311     $opt_debug
1312     save_ifs=$IFS; IFS='~'
1313     for cmd in $1; do
1314       IFS=$save_ifs
1315       eval cmd=\"$cmd\"
1316       func_show_eval "$cmd" "${2-:}"
1317     done
1318     IFS=$save_ifs
1319 }
1320
1321
1322 # func_source file
1323 # Source FILE, adding directory component if necessary.
1324 # Note that it is not necessary on cygwin/mingw to append a dot to
1325 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1327 # `FILE.' does not work on cygwin managed mounts.
1328 func_source ()
1329 {
1330     $opt_debug
1331     case $1 in
1332     */* | *\\*)    . "$1" ;;
1333     *)        . "./$1" ;;
1334     esac
1335 }
1336
1337
1338 # func_resolve_sysroot PATH
1339 # Replace a leading = in PATH with a sysroot.  Store the result into
1340 # func_resolve_sysroot_result
1341 func_resolve_sysroot ()
1342 {
1343   func_resolve_sysroot_result=$1
1344   case $func_resolve_sysroot_result in
1345   =*)
1346     func_stripname '=' '' "$func_resolve_sysroot_result"
1347     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1348     ;;
1349   esac
1350 }
1351
1352 # func_replace_sysroot PATH
1353 # If PATH begins with the sysroot, replace it with = and
1354 # store the result into func_replace_sysroot_result.
1355 func_replace_sysroot ()
1356 {
1357   case "$lt_sysroot:$1" in
1358   ?*:"$lt_sysroot"*)
1359     func_stripname "$lt_sysroot" '' "$1"
1360     func_replace_sysroot_result="=$func_stripname_result"
1361     ;;
1362   *)
1363     # Including no sysroot.
1364     func_replace_sysroot_result=$1
1365     ;;
1366   esac
1367 }
1368
1369 # func_infer_tag arg
1370 # Infer tagged configuration to use if any are available and
1371 # if one wasn't chosen via the "--tag" command line option.
1372 # Only attempt this if the compiler in the base compile
1373 # command doesn't match the default compiler.
1374 # arg is usually of the form 'gcc ...'
1375 func_infer_tag ()
1376 {
1377     $opt_debug
1378     if test -n "$available_tags" && test -z "$tagname"; then
1379       CC_quoted=
1380       for arg in $CC; do
1381     func_append_quoted CC_quoted "$arg"
1382       done
1383       CC_expanded=`func_echo_all $CC`
1384       CC_quoted_expanded=`func_echo_all $CC_quoted`
1385       case $@ in
1386       # Blanks in the command may have been stripped by the calling shell,
1387       # but not from the CC environment variable when configure was run.
1388       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1390       # Blanks at the start of $base_compile will cause this to fail
1391       # if we don't check for them as well.
1392       *)
1393     for z in $available_tags; do
1394       if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1395         # Evaluate the configuration.
1396         eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1397         CC_quoted=
1398         for arg in $CC; do
1399           # Double-quote args containing other shell metacharacters.
1400           func_append_quoted CC_quoted "$arg"
1401         done
1402         CC_expanded=`func_echo_all $CC`
1403         CC_quoted_expanded=`func_echo_all $CC_quoted`
1404         case "$@ " in
1405         " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406         " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1407           # The compiler in the base compile command matches
1408           # the one in the tagged configuration.
1409           # Assume this is the tagged configuration we want.
1410           tagname=$z
1411           break
1412           ;;
1413         esac
1414       fi
1415     done
1416     # If $tagname still isn't set, then no tagged configuration
1417     # was found and let the user know that the "--tag" command
1418     # line option must be used.
1419     if test -z "$tagname"; then
1420       func_echo "unable to infer tagged configuration"
1421       func_fatal_error "specify a tag with \`--tag'"
1422 #    else
1423 #      func_verbose "using $tagname tagged configuration"
1424     fi
1425     ;;
1426       esac
1427     fi
1428 }
1429
1430
1431
1432 # func_write_libtool_object output_name pic_name nonpic_name
1433 # Create a libtool object file (analogous to a ".la" file),
1434 # but don't create it if we're doing a dry run.
1435 func_write_libtool_object ()
1436 {
1437     write_libobj=${1}
1438     if test "$build_libtool_libs" = yes; then
1439       write_lobj=\'${2}\'
1440     else
1441       write_lobj=none
1442     fi
1443
1444     if test "$build_old_libs" = yes; then
1445       write_oldobj=\'${3}\'
1446     else
1447       write_oldobj=none
1448     fi
1449
1450     $opt_dry_run || {
1451       cat >${write_libobj}T <<EOF
1452 # $write_libobj - a libtool object file
1453 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454 #
1455 # Please DO NOT delete this file!
1456 # It is necessary for linking the library.
1457
1458 # Name of the PIC object.
1459 pic_object=$write_lobj
1460
1461 # Name of the non-PIC object
1462 non_pic_object=$write_oldobj
1463
1464 EOF
1465       $MV "${write_libobj}T" "${write_libobj}"
1466     }
1467 }
1468
1469
1470 ##################################################
1471 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472 ##################################################
1473
1474 # func_convert_core_file_wine_to_w32 ARG
1475 # Helper function used by file name conversion functions when $build is *nix,
1476 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477 # correctly configured wine environment available, with the winepath program
1478 # in $build's $PATH.
1479 #
1480 # ARG is the $build file name to be converted to w32 format.
1481 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482 # be empty on error (or when ARG is empty)
1483 func_convert_core_file_wine_to_w32 ()
1484 {
1485   $opt_debug
1486   func_convert_core_file_wine_to_w32_result="$1"
1487   if test -n "$1"; then
1488     # Unfortunately, winepath does not exit with a non-zero error code, so we
1489     # are forced to check the contents of stdout. On the other hand, if the
1490     # command is not found, the shell will set an exit code of 127 and print
1491     # *an error message* to stdout. So we must check for both error code of
1492     # zero AND non-empty stdout, which explains the odd construction:
1493     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1494     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496         $SED -e "$lt_sed_naive_backslashify"`
1497     else
1498       func_convert_core_file_wine_to_w32_result=
1499     fi
1500   fi
1501 }
1502 # end: func_convert_core_file_wine_to_w32
1503
1504
1505 # func_convert_core_path_wine_to_w32 ARG
1506 # Helper function used by path conversion functions when $build is *nix, and
1507 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508 # configured wine environment available, with the winepath program in $build's
1509 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1510 #
1511 # ARG is path to be converted from $build format to win32.
1512 # Result is available in $func_convert_core_path_wine_to_w32_result.
1513 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1514 # are convertible, then the result may be empty.
1515 func_convert_core_path_wine_to_w32 ()
1516 {
1517   $opt_debug
1518   # unfortunately, winepath doesn't convert paths, only file names
1519   func_convert_core_path_wine_to_w32_result=""
1520   if test -n "$1"; then
1521     oldIFS=$IFS
1522     IFS=:
1523     for func_convert_core_path_wine_to_w32_f in $1; do
1524       IFS=$oldIFS
1525       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1526       if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527         if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528           func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529         else
1530           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1531         fi
1532       fi
1533     done
1534     IFS=$oldIFS
1535   fi
1536 }
1537 # end: func_convert_core_path_wine_to_w32
1538
1539
1540 # func_cygpath ARGS...
1541 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1545 # file name or path is assumed to be in w32 format, as previously converted
1546 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547 # or path in func_cygpath_result (input file name or path is assumed to be in
1548 # Cygwin format). Returns an empty string on error.
1549 #
1550 # ARGS are passed to cygpath, with the last one being the file name or path to
1551 # be converted.
1552 #
1553 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554 # environment variable; do not put it in $PATH.
1555 func_cygpath ()
1556 {
1557   $opt_debug
1558   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1560     if test "$?" -ne 0; then
1561       # on failure, ensure result is empty
1562       func_cygpath_result=
1563     fi
1564   else
1565     func_cygpath_result=
1566     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1567   fi
1568 }
1569 #end: func_cygpath
1570
1571
1572 # func_convert_core_msys_to_w32 ARG
1573 # Convert file name or path ARG from MSYS format to w32 format.  Return
1574 # result in func_convert_core_msys_to_w32_result.
1575 func_convert_core_msys_to_w32 ()
1576 {
1577   $opt_debug
1578   # awkward: cmd appends spaces to result
1579   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1580     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581 }
1582 #end: func_convert_core_msys_to_w32
1583
1584
1585 # func_convert_file_check ARG1 ARG2
1586 # Verify that ARG1 (a file name in $build format) was converted to $host
1587 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1588 # func_to_host_file_result to ARG1).
1589 func_convert_file_check ()
1590 {
1591   $opt_debug
1592   if test -z "$2" && test -n "$1" ; then
1593     func_error "Could not determine host file name corresponding to"
1594     func_error "  \`$1'"
1595     func_error "Continuing, but uninstalled executables may not work."
1596     # Fallback:
1597     func_to_host_file_result="$1"
1598   fi
1599 }
1600 # end func_convert_file_check
1601
1602
1603 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604 # Verify that FROM_PATH (a path in $build format) was converted to $host
1605 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606 # func_to_host_file_result to a simplistic fallback value (see below).
1607 func_convert_path_check ()
1608 {
1609   $opt_debug
1610   if test -z "$4" && test -n "$3"; then
1611     func_error "Could not determine the host path corresponding to"
1612     func_error "  \`$3'"
1613     func_error "Continuing, but uninstalled executables may not work."
1614     # Fallback.  This is a deliberately simplistic "conversion" and
1615     # should not be "improved".  See libtool.info.
1616     if test "x$1" != "x$2"; then
1617       lt_replace_pathsep_chars="s|$1|$2|g"
1618       func_to_host_path_result=`echo "$3" |
1619         $SED -e "$lt_replace_pathsep_chars"`
1620     else
1621       func_to_host_path_result="$3"
1622     fi
1623   fi
1624 }
1625 # end func_convert_path_check
1626
1627
1628 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630 # and appending REPL if ORIG matches BACKPAT.
1631 func_convert_path_front_back_pathsep ()
1632 {
1633   $opt_debug
1634   case $4 in
1635   $1 ) func_to_host_path_result="$3$func_to_host_path_result"
1636     ;;
1637   esac
1638   case $4 in
1639   $2 ) func_append func_to_host_path_result "$3"
1640     ;;
1641   esac
1642 }
1643 # end func_convert_path_front_back_pathsep
1644
1645
1646 ##################################################
1647 # $build to $host FILE NAME CONVERSION FUNCTIONS #
1648 ##################################################
1649 # invoked via `$to_host_file_cmd ARG'
1650 #
1651 # In each case, ARG is the path to be converted from $build to $host format.
1652 # Result will be available in $func_to_host_file_result.
1653
1654
1655 # func_to_host_file ARG
1656 # Converts the file name ARG from $build format to $host format. Return result
1657 # in func_to_host_file_result.
1658 func_to_host_file ()
1659 {
1660   $opt_debug
1661   $to_host_file_cmd "$1"
1662 }
1663 # end func_to_host_file
1664
1665
1666 # func_to_tool_file ARG LAZY
1667 # converts the file name ARG from $build format to toolchain format. Return
1668 # result in func_to_tool_file_result.  If the conversion in use is listed
1669 # in (the comma separated) LAZY, no conversion takes place.
1670 func_to_tool_file ()
1671 {
1672   $opt_debug
1673   case ,$2, in
1674     *,"$to_tool_file_cmd",*)
1675       func_to_tool_file_result=$1
1676       ;;
1677     *)
1678       $to_tool_file_cmd "$1"
1679       func_to_tool_file_result=$func_to_host_file_result
1680       ;;
1681   esac
1682 }
1683 # end func_to_tool_file
1684
1685
1686 # func_convert_file_noop ARG
1687 # Copy ARG to func_to_host_file_result.
1688 func_convert_file_noop ()
1689 {
1690   func_to_host_file_result="$1"
1691 }
1692 # end func_convert_file_noop
1693
1694
1695 # func_convert_file_msys_to_w32 ARG
1696 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697 # conversion to w32 is not available inside the cwrapper.  Returns result in
1698 # func_to_host_file_result.
1699 func_convert_file_msys_to_w32 ()
1700 {
1701   $opt_debug
1702   func_to_host_file_result="$1"
1703   if test -n "$1"; then
1704     func_convert_core_msys_to_w32 "$1"
1705     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706   fi
1707   func_convert_file_check "$1" "$func_to_host_file_result"
1708 }
1709 # end func_convert_file_msys_to_w32
1710
1711
1712 # func_convert_file_cygwin_to_w32 ARG
1713 # Convert file name ARG from Cygwin to w32 format.  Returns result in
1714 # func_to_host_file_result.
1715 func_convert_file_cygwin_to_w32 ()
1716 {
1717   $opt_debug
1718   func_to_host_file_result="$1"
1719   if test -n "$1"; then
1720     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721     # LT_CYGPATH in this case.
1722     func_to_host_file_result=`cygpath -m "$1"`
1723   fi
1724   func_convert_file_check "$1" "$func_to_host_file_result"
1725 }
1726 # end func_convert_file_cygwin_to_w32
1727
1728
1729 # func_convert_file_nix_to_w32 ARG
1730 # Convert file name ARG from *nix to w32 format.  Requires a wine environment
1731 # and a working winepath. Returns result in func_to_host_file_result.
1732 func_convert_file_nix_to_w32 ()
1733 {
1734   $opt_debug
1735   func_to_host_file_result="$1"
1736   if test -n "$1"; then
1737     func_convert_core_file_wine_to_w32 "$1"
1738     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739   fi
1740   func_convert_file_check "$1" "$func_to_host_file_result"
1741 }
1742 # end func_convert_file_nix_to_w32
1743
1744
1745 # func_convert_file_msys_to_cygwin ARG
1746 # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
1747 # Returns result in func_to_host_file_result.
1748 func_convert_file_msys_to_cygwin ()
1749 {
1750   $opt_debug
1751   func_to_host_file_result="$1"
1752   if test -n "$1"; then
1753     func_convert_core_msys_to_w32 "$1"
1754     func_cygpath -u "$func_convert_core_msys_to_w32_result"
1755     func_to_host_file_result="$func_cygpath_result"
1756   fi
1757   func_convert_file_check "$1" "$func_to_host_file_result"
1758 }
1759 # end func_convert_file_msys_to_cygwin
1760
1761
1762 # func_convert_file_nix_to_cygwin ARG
1763 # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
1764 # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
1765 # in func_to_host_file_result.
1766 func_convert_file_nix_to_cygwin ()
1767 {
1768   $opt_debug
1769   func_to_host_file_result="$1"
1770   if test -n "$1"; then
1771     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772     func_convert_core_file_wine_to_w32 "$1"
1773     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1774     func_to_host_file_result="$func_cygpath_result"
1775   fi
1776   func_convert_file_check "$1" "$func_to_host_file_result"
1777 }
1778 # end func_convert_file_nix_to_cygwin
1779
1780
1781 #############################################
1782 # $build to $host PATH CONVERSION FUNCTIONS #
1783 #############################################
1784 # invoked via `$to_host_path_cmd ARG'
1785 #
1786 # In each case, ARG is the path to be converted from $build to $host format.
1787 # The result will be available in $func_to_host_path_result.
1788 #
1789 # Path separators are also converted from $build format to $host format.  If
1790 # ARG begins or ends with a path separator character, it is preserved (but
1791 # converted to $host format) on output.
1792 #
1793 # All path conversion functions are named using the following convention:
1794 #   file name conversion function    : func_convert_file_X_to_Y ()
1795 #   path conversion function         : func_convert_path_X_to_Y ()
1796 # where, for any given $build/$host combination the 'X_to_Y' value is the
1797 # same.  If conversion functions are added for new $build/$host combinations,
1798 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1799 # will break.
1800
1801
1802 # func_init_to_host_path_cmd
1803 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804 # appropriate value, based on the value of $to_host_file_cmd.
1805 to_host_path_cmd=
1806 func_init_to_host_path_cmd ()
1807 {
1808   $opt_debug
1809   if test -z "$to_host_path_cmd"; then
1810     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1811     to_host_path_cmd="func_convert_path_${func_stripname_result}"
1812   fi
1813 }
1814
1815
1816 # func_to_host_path ARG
1817 # Converts the path ARG from $build format to $host format. Return result
1818 # in func_to_host_path_result.
1819 func_to_host_path ()
1820 {
1821   $opt_debug
1822   func_init_to_host_path_cmd
1823   $to_host_path_cmd "$1"
1824 }
1825 # end func_to_host_path
1826
1827
1828 # func_convert_path_noop ARG
1829 # Copy ARG to func_to_host_path_result.
1830 func_convert_path_noop ()
1831 {
1832   func_to_host_path_result="$1"
1833 }
1834 # end func_convert_path_noop
1835
1836
1837 # func_convert_path_msys_to_w32 ARG
1838 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839 # conversion to w32 is not available inside the cwrapper.  Returns result in
1840 # func_to_host_path_result.
1841 func_convert_path_msys_to_w32 ()
1842 {
1843   $opt_debug
1844   func_to_host_path_result="$1"
1845   if test -n "$1"; then
1846     # Remove leading and trailing path separator characters from ARG.  MSYS
1847     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848     # and winepath ignores them completely.
1849     func_stripname : : "$1"
1850     func_to_host_path_tmp1=$func_stripname_result
1851     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1852     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1853     func_convert_path_check : ";" \
1854       "$func_to_host_path_tmp1" "$func_to_host_path_result"
1855     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1856   fi
1857 }
1858 # end func_convert_path_msys_to_w32
1859
1860
1861 # func_convert_path_cygwin_to_w32 ARG
1862 # Convert path ARG from Cygwin to w32 format.  Returns result in
1863 # func_to_host_file_result.
1864 func_convert_path_cygwin_to_w32 ()
1865 {
1866   $opt_debug
1867   func_to_host_path_result="$1"
1868   if test -n "$1"; then
1869     # See func_convert_path_msys_to_w32:
1870     func_stripname : : "$1"
1871     func_to_host_path_tmp1=$func_stripname_result
1872     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1873     func_convert_path_check : ";" \
1874       "$func_to_host_path_tmp1" "$func_to_host_path_result"
1875     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1876   fi
1877 }
1878 # end func_convert_path_cygwin_to_w32
1879
1880
1881 # func_convert_path_nix_to_w32 ARG
1882 # Convert path ARG from *nix to w32 format.  Requires a wine environment and
1883 # a working winepath.  Returns result in func_to_host_file_result.
1884 func_convert_path_nix_to_w32 ()
1885 {
1886   $opt_debug
1887   func_to_host_path_result="$1"
1888   if test -n "$1"; then
1889     # See func_convert_path_msys_to_w32:
1890     func_stripname : : "$1"
1891     func_to_host_path_tmp1=$func_stripname_result
1892     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1893     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1894     func_convert_path_check : ";" \
1895       "$func_to_host_path_tmp1" "$func_to_host_path_result"
1896     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1897   fi
1898 }
1899 # end func_convert_path_nix_to_w32
1900
1901
1902 # func_convert_path_msys_to_cygwin ARG
1903 # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
1904 # Returns result in func_to_host_file_result.
1905 func_convert_path_msys_to_cygwin ()
1906 {
1907   $opt_debug
1908   func_to_host_path_result="$1"
1909   if test -n "$1"; then
1910     # See func_convert_path_msys_to_w32:
1911     func_stripname : : "$1"
1912     func_to_host_path_tmp1=$func_stripname_result
1913     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1914     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1915     func_to_host_path_result="$func_cygpath_result"
1916     func_convert_path_check : : \
1917       "$func_to_host_path_tmp1" "$func_to_host_path_result"
1918     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1919   fi
1920 }
1921 # end func_convert_path_msys_to_cygwin
1922
1923
1924 # func_convert_path_nix_to_cygwin ARG
1925 # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
1926 # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
1927 # func_to_host_file_result.
1928 func_convert_path_nix_to_cygwin ()
1929 {
1930   $opt_debug
1931   func_to_host_path_result="$1"
1932   if test -n "$1"; then
1933     # Remove leading and trailing path separator characters from
1934     # ARG. msys behavior is inconsistent here, cygpath turns them
1935     # into '.;' and ';.', and winepath ignores them completely.
1936     func_stripname : : "$1"
1937     func_to_host_path_tmp1=$func_stripname_result
1938     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1939     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1940     func_to_host_path_result="$func_cygpath_result"
1941     func_convert_path_check : : \
1942       "$func_to_host_path_tmp1" "$func_to_host_path_result"
1943     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1944   fi
1945 }
1946 # end func_convert_path_nix_to_cygwin
1947
1948
1949 # func_mode_compile arg...
1950 func_mode_compile ()
1951 {
1952     $opt_debug
1953     # Get the compilation command and the source file.
1954     base_compile=
1955     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1956     suppress_opt=yes
1957     suppress_output=
1958     arg_mode=normal
1959     libobj=
1960     later=
1961     pie_flag=
1962
1963     for arg
1964     do
1965       case $arg_mode in
1966       arg  )
1967     # do not "continue".  Instead, add this to base_compile
1968     lastarg="$arg"
1969     arg_mode=normal
1970     ;;
1971
1972       target )
1973     libobj="$arg"
1974     arg_mode=normal
1975     continue
1976     ;;
1977
1978       normal )
1979     # Accept any command-line options.
1980     case $arg in
1981     -o)
1982       test -n "$libobj" && \
1983         func_fatal_error "you cannot specify \`-o' more than once"
1984       arg_mode=target
1985       continue
1986       ;;
1987
1988     -pie | -fpie | -fPIE)
1989           func_append pie_flag " $arg"
1990       continue
1991       ;;
1992
1993     -shared | -static | -prefer-pic | -prefer-non-pic)
1994       func_append later " $arg"
1995       continue
1996       ;;
1997
1998     -no-suppress)
1999       suppress_opt=no
2000       continue
2001       ;;
2002
2003     -Xcompiler)
2004       arg_mode=arg  #  the next one goes into the "base_compile" arg list
2005       continue      #  The current "srcfile" will either be retained or
2006       ;;            #  replaced later.  I would guess that would be a bug.
2007
2008     -Wc,*)
2009       func_stripname '-Wc,' '' "$arg"
2010       args=$func_stripname_result
2011       lastarg=
2012       save_ifs="$IFS"; IFS=','
2013       for arg in $args; do
2014         IFS="$save_ifs"
2015         func_append_quoted lastarg "$arg"
2016       done
2017       IFS="$save_ifs"
2018       func_stripname ' ' '' "$lastarg"
2019       lastarg=$func_stripname_result
2020
2021       # Add the arguments to base_compile.
2022       func_append base_compile " $lastarg"
2023       continue
2024       ;;
2025
2026     *)
2027       # Accept the current argument as the source file.
2028       # The previous "srcfile" becomes the current argument.
2029       #
2030       lastarg="$srcfile"
2031       srcfile="$arg"
2032       ;;
2033     esac  #  case $arg
2034     ;;
2035       esac    #  case $arg_mode
2036
2037       # Aesthetically quote the previous argument.
2038       func_append_quoted base_compile "$lastarg"
2039     done # for arg
2040
2041     case $arg_mode in
2042     arg)
2043       func_fatal_error "you must specify an argument for -Xcompile"
2044       ;;
2045     target)
2046       func_fatal_error "you must specify a target with \`-o'"
2047       ;;
2048     *)
2049       # Get the name of the library object.
2050       test -z "$libobj" && {
2051     func_basename "$srcfile"
2052     libobj="$func_basename_result"
2053       }
2054       ;;
2055     esac
2056
2057     # Recognize several different file suffixes.
2058     # If the user specifies -o file.o, it is replaced with file.lo
2059     case $libobj in
2060     *.[cCFSifmso] | \
2061     *.ada | *.adb | *.ads | *.asm | \
2062     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2063     *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
2064       func_xform "$libobj"
2065       libobj=$func_xform_result
2066       ;;
2067     esac
2068
2069     case $libobj in
2070     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071     *)
2072       func_fatal_error "cannot determine name of library object from \`$libobj'"
2073       ;;
2074     esac
2075
2076     func_infer_tag $base_compile
2077
2078     for arg in $later; do
2079       case $arg in
2080       -shared)
2081     test "$build_libtool_libs" != yes && \
2082       func_fatal_configuration "can not build a shared library"
2083     build_old_libs=no
2084     continue
2085     ;;
2086
2087       -static)
2088     build_libtool_libs=no
2089     build_old_libs=yes
2090     continue
2091     ;;
2092
2093       -prefer-pic)
2094     pic_mode=yes
2095     continue
2096     ;;
2097
2098       -prefer-non-pic)
2099     pic_mode=no
2100     continue
2101     ;;
2102       esac
2103     done
2104
2105     func_quote_for_eval "$libobj"
2106     test "X$libobj" != "X$func_quote_for_eval_result" \
2107       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'     &()|`$[]' \
2108       && func_warning "libobj name \`$libobj' may not contain shell special characters."
2109     func_dirname_and_basename "$obj" "/" ""
2110     objname="$func_basename_result"
2111     xdir="$func_dirname_result"
2112     lobj=${xdir}$objdir/$objname
2113
2114     test -z "$base_compile" && \
2115       func_fatal_help "you must specify a compilation command"
2116
2117     # Delete any leftover library objects.
2118     if test "$build_old_libs" = yes; then
2119       removelist="$obj $lobj $libobj ${libobj}T"
2120     else
2121       removelist="$lobj $libobj ${libobj}T"
2122     fi
2123
2124     # On Cygwin there's no "real" PIC flag so we must build both object types
2125     case $host_os in
2126     cygwin* | mingw* | pw32* | os2* | cegcc*)
2127       pic_mode=default
2128       ;;
2129     esac
2130     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2131       # non-PIC code in shared libraries is not supported
2132       pic_mode=default
2133     fi
2134
2135     # Calculate the filename of the output object if compiler does
2136     # not support -o with -c
2137     if test "$compiler_c_o" = no; then
2138       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2139       lockfile="$output_obj.lock"
2140     else
2141       output_obj=
2142       need_locks=no
2143       lockfile=
2144     fi
2145
2146     # Lock this critical section if it is needed
2147     # We use this script file to make the link, it avoids creating a new file
2148     if test "$need_locks" = yes; then
2149       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2150     func_echo "Waiting for $lockfile to be removed"
2151     sleep 2
2152       done
2153     elif test "$need_locks" = warn; then
2154       if test -f "$lockfile"; then
2155     $ECHO "\
2156 *** ERROR, $lockfile exists and contains:
2157 `cat $lockfile 2>/dev/null`
2158
2159 This indicates that another process is trying to use the same
2160 temporary object file, and libtool could not work around it because
2161 your compiler does not support \`-c' and \`-o' together.  If you
2162 repeat this compilation, it may succeed, by chance, but you had better
2163 avoid parallel builds (make -j) in this platform, or get a better
2164 compiler."
2165
2166     $opt_dry_run || $RM $removelist
2167     exit $EXIT_FAILURE
2168       fi
2169       func_append removelist " $output_obj"
2170       $ECHO "$srcfile" > "$lockfile"
2171     fi
2172
2173     $opt_dry_run || $RM $removelist
2174     func_append removelist " $lockfile"
2175     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176
2177     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178     srcfile=$func_to_tool_file_result
2179     func_quote_for_eval "$srcfile"
2180     qsrcfile=$func_quote_for_eval_result
2181
2182     # Only build a PIC object if we are building libtool libraries.
2183     if test "$build_libtool_libs" = yes; then
2184       # Without this assignment, base_compile gets emptied.
2185       fbsd_hideous_sh_bug=$base_compile
2186
2187       if test "$pic_mode" != no; then
2188     command="$base_compile $qsrcfile $pic_flag"
2189       else
2190     # Don't build PIC code
2191     command="$base_compile $qsrcfile"
2192       fi
2193
2194       func_mkdir_p "$xdir$objdir"
2195
2196       if test -z "$output_obj"; then
2197     # Place PIC objects in $objdir
2198     func_append command " -o $lobj"
2199       fi
2200
2201       func_show_eval_locale "$command"    \
2202           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203
2204       if test "$need_locks" = warn &&
2205      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206     $ECHO "\
2207 *** ERROR, $lockfile contains:
2208 `cat $lockfile 2>/dev/null`
2209
2210 but it should contain:
2211 $srcfile
2212
2213 This indicates that another process is trying to use the same
2214 temporary object file, and libtool could not work around it because
2215 your compiler does not support \`-c' and \`-o' together.  If you
2216 repeat this compilation, it may succeed, by chance, but you had better
2217 avoid parallel builds (make -j) in this platform, or get a better
2218 compiler."
2219
2220     $opt_dry_run || $RM $removelist
2221     exit $EXIT_FAILURE
2222       fi
2223
2224       # Just move the object if needed, then go on to compile the next one
2225       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226     func_show_eval '$MV "$output_obj" "$lobj"' \
2227       'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2228       fi
2229
2230       # Allow error messages only from the first compilation.
2231       if test "$suppress_opt" = yes; then
2232     suppress_output=' >/dev/null 2>&1'
2233       fi
2234     fi
2235
2236     # Only build a position-dependent object if we build old libraries.
2237     if test "$build_old_libs" = yes; then
2238       if test "$pic_mode" != yes; then
2239     # Don't build PIC code
2240     command="$base_compile $qsrcfile$pie_flag"
2241       else
2242     command="$base_compile $qsrcfile $pic_flag"
2243       fi
2244       if test "$compiler_c_o" = yes; then
2245     func_append command " -o $obj"
2246       fi
2247
2248       # Suppress compiler output if we already did a PIC compilation.
2249       func_append command "$suppress_output"
2250       func_show_eval_locale "$command" \
2251         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252
2253       if test "$need_locks" = warn &&
2254      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255     $ECHO "\
2256 *** ERROR, $lockfile contains:
2257 `cat $lockfile 2>/dev/null`
2258
2259 but it should contain:
2260 $srcfile
2261
2262 This indicates that another process is trying to use the same
2263 temporary object file, and libtool could not work around it because
2264 your compiler does not support \`-c' and \`-o' together.  If you
2265 repeat this compilation, it may succeed, by chance, but you had better
2266 avoid parallel builds (make -j) in this platform, or get a better
2267 compiler."
2268
2269     $opt_dry_run || $RM $removelist
2270     exit $EXIT_FAILURE
2271       fi
2272
2273       # Just move the object if needed
2274       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275     func_show_eval '$MV "$output_obj" "$obj"' \
2276       'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2277       fi
2278     fi
2279
2280     $opt_dry_run || {
2281       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282
2283       # Unlock the critical section if it was locked
2284       if test "$need_locks" != no; then
2285     removelist=$lockfile
2286         $RM "$lockfile"
2287       fi
2288     }
2289
2290     exit $EXIT_SUCCESS
2291 }
2292
2293 $opt_help || {
2294   test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2295 }
2296
2297 func_mode_help ()
2298 {
2299     # We need to display help for each of the modes.
2300     case $opt_mode in
2301       "")
2302         # Generic help is extracted from the usage comments
2303         # at the start of this file.
2304         func_help
2305         ;;
2306
2307       clean)
2308         $ECHO \
2309 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310
2311 Remove files from the build directory.
2312
2313 RM is the name of the program to use to delete files associated with each FILE
2314 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2315 to RM.
2316
2317 If FILE is a libtool library, object or program, all the files associated
2318 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2319         ;;
2320
2321       compile)
2322       $ECHO \
2323 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324
2325 Compile a source file into a libtool library object.
2326
2327 This mode accepts the following additional options:
2328
2329   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
2330   -no-suppress      do not suppress compiler output for multiple passes
2331   -prefer-pic       try to build PIC objects only
2332   -prefer-non-pic   try to build non-PIC objects only
2333   -shared           do not build a \`.o' file suitable for static linking
2334   -static           only build a \`.o' file suitable for static linking
2335   -Wc,FLAG          pass FLAG directly to the compiler
2336
2337 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338 from the given SOURCEFILE.
2339
2340 The output file name is determined by removing the directory component from
2341 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342 library object suffix, \`.lo'."
2343         ;;
2344
2345       execute)
2346         $ECHO \
2347 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348
2349 Automatically set library path, then run a program.
2350
2351 This mode accepts the following additional options:
2352
2353   -dlopen FILE      add the directory containing FILE to the library path
2354
2355 This mode sets the library path environment variable according to \`-dlopen'
2356 flags.
2357
2358 If any of the ARGS are libtool executable wrappers, then they are translated
2359 into their corresponding uninstalled binary, and any of their required library
2360 directories are added to the library path.
2361
2362 Then, COMMAND is executed, with ARGS as arguments."
2363         ;;
2364
2365       finish)
2366         $ECHO \
2367 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368
2369 Complete the installation of libtool libraries.
2370
2371 Each LIBDIR is a directory that contains libtool libraries.
2372
2373 The commands that this mode executes may require superuser privileges.  Use
2374 the \`--dry-run' option if you just want to see what would be executed."
2375         ;;
2376
2377       install)
2378         $ECHO \
2379 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380
2381 Install executables or libraries.
2382
2383 INSTALL-COMMAND is the installation command.  The first component should be
2384 either the \`install' or \`cp' program.
2385
2386 The following components of INSTALL-COMMAND are treated specially:
2387
2388   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2389
2390 The rest of the components are interpreted as arguments to that command (only
2391 BSD-compatible install options are recognized)."
2392         ;;
2393
2394       link)
2395         $ECHO \
2396 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397
2398 Link object files or libraries together to form another library, or to
2399 create an executable program.
2400
2401 LINK-COMMAND is a command using the C compiler that you would use to create
2402 a program from several object files.
2403
2404 The following components of LINK-COMMAND are treated specially:
2405
2406   -all-static       do not do any dynamic linking at all
2407   -avoid-version    do not add a version suffix if possible
2408   -bindir BINDIR    specify path to binaries directory (for systems where
2409                     libraries must be found in the PATH setting at runtime)
2410   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2412   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413   -export-symbols SYMFILE
2414                     try to export only the symbols listed in SYMFILE
2415   -export-symbols-regex REGEX
2416                     try to export only the symbols matching REGEX
2417   -LLIBDIR          search LIBDIR for required installed libraries
2418   -lNAME            OUTPUT-FILE requires the installed library libNAME
2419   -module           build a library that can dlopened
2420   -no-fast-install  disable the fast-install mode
2421   -no-install       link a not-installable executable
2422   -no-undefined     declare that a library does not refer to external symbols
2423   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2424   -objectlist FILE  Use a list of object files found in FILE to specify objects
2425   -precious-files-regex REGEX
2426                     don't remove output files matching REGEX
2427   -release RELEASE  specify package release information
2428   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2429   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2430   -shared           only do dynamic linking of libtool libraries
2431   -shrext SUFFIX    override the standard shared library file extension
2432   -static           do not do any dynamic linking of uninstalled libtool libraries
2433   -static-libtool-libs
2434                     do not do any dynamic linking of libtool libraries
2435   -version-info CURRENT[:REVISION[:AGE]]
2436                     specify library version info [each variable defaults to 0]
2437   -weak LIBNAME     declare that the target provides the LIBNAME interface
2438   -Wc,FLAG
2439   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
2440   -Wl,FLAG
2441   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
2442   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
2443
2444 All other options (arguments beginning with \`-') are ignored.
2445
2446 Every other argument is treated as a filename.  Files ending in \`.la' are
2447 treated as uninstalled libtool libraries, other files are standard or library
2448 object files.
2449
2450 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452 required, except when creating a convenience library.
2453
2454 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455 using \`ar' and \`ranlib', or on Windows using \`lib'.
2456
2457 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458 is created, otherwise an executable program is created."
2459         ;;
2460
2461       uninstall)
2462         $ECHO \
2463 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464
2465 Remove libraries from an installation directory.
2466
2467 RM is the name of the program to use to delete files associated with each FILE
2468 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2469 to RM.
2470
2471 If FILE is a libtool library, all the files associated with it are deleted.
2472 Otherwise, only FILE itself is deleted using RM."
2473         ;;
2474
2475       *)
2476         func_fatal_help "invalid operation mode \`$opt_mode'"
2477         ;;
2478     esac
2479
2480     echo
2481     $ECHO "Try \`$progname --help' for more information about other modes."
2482 }
2483
2484 # Now that we've collected a possible --mode arg, show help if necessary
2485 if $opt_help; then
2486   if test "$opt_help" = :; then
2487     func_mode_help
2488   else
2489     {
2490       func_help noexit
2491       for opt_mode in compile link execute install finish uninstall clean; do
2492     func_mode_help
2493       done
2494     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
2495     {
2496       func_help noexit
2497       for opt_mode in compile link execute install finish uninstall clean; do
2498     echo
2499     func_mode_help
2500       done
2501     } |
2502     sed '1d
2503       /^When reporting/,/^Report/{
2504     H
2505     d
2506       }
2507       $x
2508       /information about other modes/d
2509       /more detailed .*MODE/d
2510       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2511   fi
2512   exit $?
2513 fi
2514
2515
2516 # func_mode_execute arg...
2517 func_mode_execute ()
2518 {
2519     $opt_debug
2520     # The first argument is the command name.
2521     cmd="$nonopt"
2522     test -z "$cmd" && \
2523       func_fatal_help "you must specify a COMMAND"
2524
2525     # Handle -dlopen flags immediately.
2526     for file in $opt_dlopen; do
2527       test -f "$file" \
2528     || func_fatal_help "\`$file' is not a file"
2529
2530       dir=
2531       case $file in
2532       *.la)
2533     func_resolve_sysroot "$file"
2534     file=$func_resolve_sysroot_result
2535
2536     # Check to see that this really is a libtool archive.
2537     func_lalib_unsafe_p "$file" \
2538       || func_fatal_help "\`$lib' is not a valid libtool archive"
2539
2540     # Read the libtool library.
2541     dlname=
2542     library_names=
2543     func_source "$file"
2544
2545     # Skip this library if it cannot be dlopened.
2546     if test -z "$dlname"; then
2547       # Warn if it was a shared library.
2548       test -n "$library_names" && \
2549         func_warning "\`$file' was not linked with \`-export-dynamic'"
2550       continue
2551     fi
2552
2553     func_dirname "$file" "" "."
2554     dir="$func_dirname_result"
2555
2556     if test -f "$dir/$objdir/$dlname"; then
2557       func_append dir "/$objdir"
2558     else
2559       if test ! -f "$dir/$dlname"; then
2560         func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2561       fi
2562     fi
2563     ;;
2564
2565       *.lo)
2566     # Just add the directory containing the .lo file.
2567     func_dirname "$file" "" "."
2568     dir="$func_dirname_result"
2569     ;;
2570
2571       *)
2572     func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2573     continue
2574     ;;
2575       esac
2576
2577       # Get the absolute pathname.
2578       absdir=`cd "$dir" && pwd`
2579       test -n "$absdir" && dir="$absdir"
2580
2581       # Now add the directory to shlibpath_var.
2582       if eval "test -z \"\$$shlibpath_var\""; then
2583     eval "$shlibpath_var=\"\$dir\""
2584       else
2585     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2586       fi
2587     done
2588
2589     # This variable tells wrapper scripts just to set shlibpath_var
2590     # rather than running their programs.
2591     libtool_execute_magic="$magic"
2592
2593     # Check if any of the arguments is a wrapper script.
2594     args=
2595     for file
2596     do
2597       case $file in
2598       -* | *.la | *.lo ) ;;
2599       *)
2600     # Do a test to see if this is really a libtool program.
2601     if func_ltwrapper_script_p "$file"; then
2602       func_source "$file"
2603       # Transform arg to wrapped name.
2604       file="$progdir/$program"
2605     elif func_ltwrapper_executable_p "$file"; then
2606       func_ltwrapper_scriptname "$file"
2607       func_source "$func_ltwrapper_scriptname_result"
2608       # Transform arg to wrapped name.
2609       file="$progdir/$program"
2610     fi
2611     ;;
2612       esac
2613       # Quote arguments (to preserve shell metacharacters).
2614       func_append_quoted args "$file"
2615     done
2616
2617     if test "X$opt_dry_run" = Xfalse; then
2618       if test -n "$shlibpath_var"; then
2619     # Export the shlibpath_var.
2620     eval "export $shlibpath_var"
2621       fi
2622
2623       # Restore saved environment variables
2624       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625       do
2626     eval "if test \"\${save_$lt_var+set}\" = set; then
2627                 $lt_var=\$save_$lt_var; export $lt_var
2628           else
2629         $lt_unset $lt_var
2630           fi"
2631       done
2632
2633       # Now prepare to actually exec the command.
2634       exec_cmd="\$cmd$args"
2635     else
2636       # Display what would be done.
2637       if test -n "$shlibpath_var"; then
2638     eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639     echo "export $shlibpath_var"
2640       fi
2641       $ECHO "$cmd$args"
2642       exit $EXIT_SUCCESS
2643     fi
2644 }
2645
2646 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2647
2648
2649 # func_mode_finish arg...
2650 func_mode_finish ()
2651 {
2652     $opt_debug
2653     libs=
2654     libdirs=
2655     admincmds=
2656
2657     for opt in "$nonopt" ${1+"$@"}
2658     do
2659       if test -d "$opt"; then
2660     func_append libdirs " $opt"
2661
2662       elif test -f "$opt"; then
2663     if func_lalib_unsafe_p "$opt"; then
2664       func_append libs " $opt"
2665     else
2666       func_warning "\`$opt' is not a valid libtool archive"
2667     fi
2668
2669       else
2670     func_fatal_error "invalid argument \`$opt'"
2671       fi
2672     done
2673
2674     if test -n "$libs"; then
2675       if test -n "$lt_sysroot"; then
2676         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2678       else
2679         sysroot_cmd=
2680       fi
2681
2682       # Remove sysroot references
2683       if $opt_dry_run; then
2684         for lib in $libs; do
2685           echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2686         done
2687       else
2688         tmpdir=`func_mktempdir`
2689         for lib in $libs; do
2690       sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691         > $tmpdir/tmp-la
2692       mv -f $tmpdir/tmp-la $lib
2693     done
2694         ${RM}r "$tmpdir"
2695       fi
2696     fi
2697
2698     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699       for libdir in $libdirs; do
2700     if test -n "$finish_cmds"; then
2701       # Do each command in the finish commands.
2702       func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2703 '"$cmd"'"'
2704     fi
2705     if test -n "$finish_eval"; then
2706       # Do the single finish_eval.
2707       eval cmds=\"$finish_eval\"
2708       $opt_dry_run || eval "$cmds" || func_append admincmds "
2709        $cmds"
2710     fi
2711       done
2712     fi
2713
2714     # Exit here if they wanted silent mode.
2715     $opt_silent && exit $EXIT_SUCCESS
2716
2717     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718       echo "----------------------------------------------------------------------"
2719       echo "Libraries have been installed in:"
2720       for libdir in $libdirs; do
2721     $ECHO "   $libdir"
2722       done
2723       echo
2724       echo "If you ever happen to want to link against installed libraries"
2725       echo "in a given directory, LIBDIR, you must either use libtool, and"
2726       echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727       echo "flag during linking and do at least one of the following:"
2728       if test -n "$shlibpath_var"; then
2729     echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2730     echo "     during execution"
2731       fi
2732       if test -n "$runpath_var"; then
2733     echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2734     echo "     during linking"
2735       fi
2736       if test -n "$hardcode_libdir_flag_spec"; then
2737     libdir=LIBDIR
2738     eval flag=\"$hardcode_libdir_flag_spec\"
2739
2740     $ECHO "   - use the \`$flag' linker flag"
2741       fi
2742       if test -n "$admincmds"; then
2743     $ECHO "   - have your system administrator run these commands:$admincmds"
2744       fi
2745       if test -f /etc/ld.so.conf; then
2746     echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2747       fi
2748       echo
2749
2750       echo "See any operating system documentation about shared libraries for"
2751       case $host in
2752     solaris2.[6789]|solaris2.1[0-9])
2753       echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2754       echo "pages."
2755       ;;
2756     *)
2757       echo "more information, such as the ld(1) and ld.so(8) manual pages."
2758       ;;
2759       esac
2760       echo "----------------------------------------------------------------------"
2761     fi
2762     exit $EXIT_SUCCESS
2763 }
2764
2765 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2766
2767
2768 # func_mode_install arg...
2769 func_mode_install ()
2770 {
2771     $opt_debug
2772     # There may be an optional sh(1) argument at the beginning of
2773     # install_prog (especially on Windows NT).
2774     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775        # Allow the use of GNU shtool's install command.
2776        case $nonopt in *shtool*) :;; *) false;; esac; then
2777       # Aesthetically quote it.
2778       func_quote_for_eval "$nonopt"
2779       install_prog="$func_quote_for_eval_result "
2780       arg=$1
2781       shift
2782     else
2783       install_prog=
2784       arg=$nonopt
2785     fi
2786
2787     # The real first argument should be the name of the installation program.
2788     # Aesthetically quote it.
2789     func_quote_for_eval "$arg"
2790     func_append install_prog "$func_quote_for_eval_result"
2791     install_shared_prog=$install_prog
2792     case " $install_prog " in
2793       *[\\\ /]cp\ *) install_cp=: ;;
2794       *) install_cp=false ;;
2795     esac
2796
2797     # We need to accept at least all the BSD install flags.
2798     dest=
2799     files=
2800     opts=
2801     prev=
2802     install_type=
2803     isdir=no
2804     stripme=
2805     no_mode=:
2806     for arg
2807     do
2808       arg2=
2809       if test -n "$dest"; then
2810     func_append files " $dest"
2811     dest=$arg
2812     continue
2813       fi
2814
2815       case $arg in
2816       -d) isdir=yes ;;
2817       -f)
2818     if $install_cp; then :; else
2819       prev=$arg
2820     fi
2821     ;;
2822       -g | -m | -o)
2823     prev=$arg
2824     ;;
2825       -s)
2826     stripme=" -s"
2827     continue
2828     ;;
2829       -*)
2830     ;;
2831       *)
2832     # If the previous option needed an argument, then skip it.
2833     if test -n "$prev"; then
2834       if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835         arg2=$install_override_mode
2836         no_mode=false
2837       fi
2838       prev=
2839     else
2840       dest=$arg
2841       continue
2842     fi
2843     ;;
2844       esac
2845
2846       # Aesthetically quote the argument.
2847       func_quote_for_eval "$arg"
2848       func_append install_prog " $func_quote_for_eval_result"
2849       if test -n "$arg2"; then
2850     func_quote_for_eval "$arg2"
2851       fi
2852       func_append install_shared_prog " $func_quote_for_eval_result"
2853     done
2854
2855     test -z "$install_prog" && \
2856       func_fatal_help "you must specify an install program"
2857
2858     test -n "$prev" && \
2859       func_fatal_help "the \`$prev' option requires an argument"
2860
2861     if test -n "$install_override_mode" && $no_mode; then
2862       if $install_cp; then :; else
2863     func_quote_for_eval "$install_override_mode"
2864     func_append install_shared_prog " -m $func_quote_for_eval_result"
2865       fi
2866     fi
2867
2868     if test -z "$files"; then
2869       if test -z "$dest"; then
2870     func_fatal_help "no file or destination specified"
2871       else
2872     func_fatal_help "you must specify a destination"
2873       fi
2874     fi
2875
2876     # Strip any trailing slash from the destination.
2877     func_stripname '' '/' "$dest"
2878     dest=$func_stripname_result
2879
2880     # Check to see that the destination is a directory.
2881     test -d "$dest" && isdir=yes
2882     if test "$isdir" = yes; then
2883       destdir="$dest"
2884       destname=
2885     else
2886       func_dirname_and_basename "$dest" "" "."
2887       destdir="$func_dirname_result"
2888       destname="$func_basename_result"
2889
2890       # Not a directory, so check to see that there is only one file specified.
2891       set dummy $files; shift
2892       test "$#" -gt 1 && \
2893     func_fatal_help "\`$dest' is not a directory"
2894     fi
2895     case $destdir in
2896     [\\/]* | [A-Za-z]:[\\/]*) ;;
2897     *)
2898       for file in $files; do
2899     case $file in
2900     *.lo) ;;
2901     *)
2902       func_fatal_help "\`$destdir' must be an absolute directory name"
2903       ;;
2904     esac
2905       done
2906       ;;
2907     esac
2908
2909     # This variable tells wrapper scripts just to set variables rather
2910     # than running their programs.
2911     libtool_install_magic="$magic"
2912
2913     staticlibs=
2914     future_libdirs=
2915     current_libdirs=
2916     for file in $files; do
2917
2918       # Do each installation.
2919       case $file in
2920       *.$libext)
2921     # Do the static libraries later.
2922     func_append staticlibs " $file"
2923     ;;
2924
2925       *.la)
2926     func_resolve_sysroot "$file"
2927     file=$func_resolve_sysroot_result
2928
2929     # Check to see that this really is a libtool archive.
2930     func_lalib_unsafe_p "$file" \
2931       || func_fatal_help "\`$file' is not a valid libtool archive"
2932
2933     library_names=
2934     old_library=
2935     relink_command=
2936     func_source "$file"
2937
2938     # Add the libdir to current_libdirs if it is the destination.
2939     if test "X$destdir" = "X$libdir"; then
2940       case "$current_libdirs " in
2941       *" $libdir "*) ;;
2942       *) func_append current_libdirs " $libdir" ;;
2943       esac
2944     else
2945       # Note the libdir as a future libdir.
2946       case "$future_libdirs " in
2947       *" $libdir "*) ;;
2948       *) func_append future_libdirs " $libdir" ;;
2949       esac
2950     fi
2951
2952     func_dirname "$file" "/" ""
2953     dir="$func_dirname_result"
2954     func_append dir "$objdir"
2955
2956     if test -n "$relink_command"; then
2957       # Determine the prefix the user has applied to our future dir.
2958       inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959
2960       # Don't allow the user to place us outside of our expected
2961       # location b/c this prevents finding dependent libraries that
2962       # are installed to the same prefix.
2963       # At present, this check doesn't affect windows .dll's that
2964       # are installed into $libdir/../bin (currently, that works fine)
2965       # but it's something to keep an eye on.
2966       test "$inst_prefix_dir" = "$destdir" && \
2967         func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968
2969       if test -n "$inst_prefix_dir"; then
2970         # Stick the inst_prefix_dir data into the link command.
2971         relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972       else
2973         relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2974       fi
2975
2976       func_warning "relinking \`$file'"
2977       func_show_eval "$relink_command" \
2978         'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2979     fi
2980
2981     # See the names of the shared library.
2982     set dummy $library_names; shift
2983     if test -n "$1"; then
2984       realname="$1"
2985       shift
2986
2987       srcname="$realname"
2988       test -n "$relink_command" && srcname="$realname"T
2989
2990       # Install the shared library and build the symlinks.
2991       func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2992           'exit $?'
2993       tstripme="$stripme"
2994       case $host_os in
2995       cygwin* | mingw* | pw32* | cegcc*)
2996         case $realname in
2997         *.dll.a)
2998           tstripme=""
2999           ;;
3000         esac
3001         ;;
3002       esac
3003       if test -n "$tstripme" && test -n "$striplib"; then
3004         func_show_eval "$striplib $destdir/$realname" 'exit $?'
3005       fi
3006
3007       if test "$#" -gt 0; then
3008         # Delete the old symlinks, and create new ones.
3009         # Try `ln -sf' first, because the `ln' binary might depend on
3010         # the symlink we replace!  Solaris /bin/ln does not understand -f,
3011         # so we also need to try rm && ln -s.
3012         for linkname
3013         do
3014           test "$linkname" != "$realname" \
3015         && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3016         done
3017       fi
3018
3019       # Do each command in the postinstall commands.
3020       lib="$destdir/$realname"
3021       func_execute_cmds "$postinstall_cmds" 'exit $?'
3022     fi
3023
3024     # Install the pseudo-library for information purposes.
3025     func_basename "$file"
3026     name="$func_basename_result"
3027     instname="$dir/$name"i
3028     func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029
3030     # Maybe install the static library, too.
3031     test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3032     ;;
3033
3034       *.lo)
3035     # Install (i.e. copy) a libtool object.
3036
3037     # Figure out destination file name, if it wasn't already specified.
3038     if test -n "$destname"; then
3039       destfile="$destdir/$destname"
3040     else
3041       func_basename "$file"
3042       destfile="$func_basename_result"
3043       destfile="$destdir/$destfile"
3044     fi
3045
3046     # Deduce the name of the destination old-style object file.
3047     case $destfile in
3048     *.lo)
3049       func_lo2o "$destfile"
3050       staticdest=$func_lo2o_result
3051       ;;
3052     *.$objext)
3053       staticdest="$destfile"
3054       destfile=
3055       ;;
3056     *)
3057       func_fatal_help "cannot copy a libtool object to \`$destfile'"
3058       ;;
3059     esac
3060
3061     # Install the libtool object if requested.
3062     test -n "$destfile" && \
3063       func_show_eval "$install_prog $file $destfile" 'exit $?'
3064
3065     # Install the old object if enabled.
3066     if test "$build_old_libs" = yes; then
3067       # Deduce the name of the old-style object file.
3068       func_lo2o "$file"
3069       staticobj=$func_lo2o_result
3070       func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3071     fi
3072     exit $EXIT_SUCCESS
3073     ;;
3074
3075       *)
3076     # Figure out destination file name, if it wasn't already specified.
3077     if test -n "$destname"; then
3078       destfile="$destdir/$destname"
3079     else
3080       func_basename "$file"
3081       destfile="$func_basename_result"
3082       destfile="$destdir/$destfile"
3083     fi
3084
3085     # If the file is missing, and there is a .exe on the end, strip it
3086     # because it is most likely a libtool script we actually want to
3087     # install
3088     stripped_ext=""
3089     case $file in
3090       *.exe)
3091         if test ! -f "$file"; then
3092           func_stripname '' '.exe' "$file"
3093           file=$func_stripname_result
3094           stripped_ext=".exe"
3095         fi
3096         ;;
3097     esac
3098
3099     # Do a test to see if this is really a libtool program.
3100     case $host in
3101     *cygwin* | *mingw*)
3102         if func_ltwrapper_executable_p "$file"; then
3103           func_ltwrapper_scriptname "$file"
3104           wrapper=$func_ltwrapper_scriptname_result
3105         else
3106           func_stripname '' '.exe' "$file"
3107           wrapper=$func_stripname_result
3108         fi
3109         ;;
3110     *)
3111         wrapper=$file
3112         ;;
3113     esac
3114     if func_ltwrapper_script_p "$wrapper"; then
3115       notinst_deplibs=
3116       relink_command=
3117
3118       func_source "$wrapper"
3119
3120       # Check the variables that should have been set.
3121       test -z "$generated_by_libtool_version" && \
3122         func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3123
3124       finalize=yes
3125       for lib in $notinst_deplibs; do
3126         # Check to see that each library is installed.
3127         libdir=
3128         if test -f "$lib"; then
3129           func_source "$lib"
3130         fi
3131         libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132         if test -n "$libdir" && test ! -f "$libfile"; then
3133           func_warning "\`$lib' has not been installed in \`$libdir'"
3134           finalize=no
3135         fi
3136       done
3137
3138       relink_command=
3139       func_source "$wrapper"
3140
3141       outputname=
3142       if test "$fast_install" = no && test -n "$relink_command"; then
3143         $opt_dry_run || {
3144           if test "$finalize" = yes; then
3145             tmpdir=`func_mktempdir`
3146         func_basename "$file$stripped_ext"
3147         file="$func_basename_result"
3148             outputname="$tmpdir/$file"
3149             # Replace the output file specification.
3150             relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3151
3152             $opt_silent || {
3153               func_quote_for_expand "$relink_command"
3154           eval "func_echo $func_quote_for_expand_result"
3155             }
3156             if eval "$relink_command"; then :
3157               else
3158           func_error "error: relink \`$file' with the above command before installing it"
3159           $opt_dry_run || ${RM}r "$tmpdir"
3160           continue
3161             fi
3162             file="$outputname"
3163           else
3164             func_warning "cannot relink \`$file'"
3165           fi
3166         }
3167       else
3168         # Install the binary that we compiled earlier.
3169         file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3170       fi
3171     fi
3172
3173     # remove .exe since cygwin /usr/bin/install will append another
3174     # one anyway
3175     case $install_prog,$host in
3176     */usr/bin/install*,*cygwin*)
3177       case $file:$destfile in
3178       *.exe:*.exe)
3179         # this is ok
3180         ;;
3181       *.exe:*)
3182         destfile=$destfile.exe
3183         ;;
3184       *:*.exe)
3185         func_stripname '' '.exe' "$destfile"
3186         destfile=$func_stripname_result
3187         ;;
3188       esac
3189       ;;
3190     esac
3191     func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192     $opt_dry_run || if test -n "$outputname"; then
3193       ${RM}r "$tmpdir"
3194     fi
3195     ;;
3196       esac
3197     done
3198
3199     for file in $staticlibs; do
3200       func_basename "$file"
3201       name="$func_basename_result"
3202
3203       # Set up the ranlib parameters.
3204       oldlib="$destdir/$name"
3205       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206       tool_oldlib=$func_to_tool_file_result
3207
3208       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3209
3210       if test -n "$stripme" && test -n "$old_striplib"; then
3211     func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3212       fi
3213
3214       # Do each command in the postinstall commands.
3215       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3216     done
3217
3218     test -n "$future_libdirs" && \
3219       func_warning "remember to run \`$progname --finish$future_libdirs'"
3220
3221     if test -n "$current_libdirs"; then
3222       # Maybe just do a dry run.
3223       $opt_dry_run && current_libdirs=" -n$current_libdirs"
3224       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3225     else
3226       exit $EXIT_SUCCESS
3227     fi
3228 }
3229
3230 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3231
3232
3233 # func_generate_dlsyms outputname originator pic_p
3234 # Extract symbols from dlprefiles and create ${outputname}S.o with
3235 # a dlpreopen symbol table.
3236 func_generate_dlsyms ()
3237 {
3238     $opt_debug
3239     my_outputname="$1"
3240     my_originator="$2"
3241     my_pic_p="${3-no}"
3242     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3243     my_dlsyms=
3244
3245     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3246       if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247     my_dlsyms="${my_outputname}S.c"
3248       else
3249     func_error "not configured to extract global symbols from dlpreopened files"
3250       fi
3251     fi
3252
3253     if test -n "$my_dlsyms"; then
3254       case $my_dlsyms in
3255       "") ;;
3256       *.c)
3257     # Discover the nlist of each of the dlfiles.
3258     nlist="$output_objdir/${my_outputname}.nm"
3259
3260     func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3261
3262     # Parse the name list into a source file.
3263     func_verbose "creating $output_objdir/$my_dlsyms"
3264
3265     $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3266 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3268
3269 #ifdef __cplusplus
3270 extern \"C\" {
3271 #endif
3272
3273 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3275 #endif
3276
3277 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
3278 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3280    relocations are performed -- see ld's documentation on pseudo-relocs.  */
3281 # define LT_DLSYM_CONST
3282 #elif defined(__osf__)
3283 /* This system does not cope well with relocations in const data.  */
3284 # define LT_DLSYM_CONST
3285 #else
3286 # define LT_DLSYM_CONST const
3287 #endif
3288
3289 /* External symbol declarations for the compiler. */\
3290 "
3291
3292     if test "$dlself" = yes; then
3293       func_verbose "generating symbol list for \`$output'"
3294
3295       $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3296
3297       # Add our own program objects to the symbol list.
3298       progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299       for progfile in $progfiles; do
3300         func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3301         func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3302         $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3303       done
3304
3305       if test -n "$exclude_expsyms"; then
3306         $opt_dry_run || {
3307           eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308           eval '$MV "$nlist"T "$nlist"'
3309         }
3310       fi
3311
3312       if test -n "$export_symbols_regex"; then
3313         $opt_dry_run || {
3314           eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315           eval '$MV "$nlist"T "$nlist"'
3316         }
3317       fi
3318
3319       # Prepare the list of exported symbols
3320       if test -z "$export_symbols"; then
3321         export_symbols="$output_objdir/$outputname.exp"
3322         $opt_dry_run || {
3323           $RM $export_symbols
3324           eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3325           case $host in
3326           *cygwin* | *mingw* | *cegcc* )
3327                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3329             ;;
3330           esac
3331         }
3332       else
3333         $opt_dry_run || {
3334           eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335           eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336           eval '$MV "$nlist"T "$nlist"'
3337           case $host in
3338             *cygwin* | *mingw* | *cegcc* )
3339               eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340               eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3341               ;;
3342           esac
3343         }
3344       fi
3345     fi
3346
3347     for dlprefile in $dlprefiles; do
3348       func_verbose "extracting global C symbols from \`$dlprefile'"
3349       func_basename "$dlprefile"
3350       name="$func_basename_result"
3351           case $host in
3352         *cygwin* | *mingw* | *cegcc* )
3353           # if an import library, we need to obtain dlname
3354           if func_win32_import_lib_p "$dlprefile"; then
3355             func_tr_sh "$dlprefile"
3356             eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357             dlprefile_dlbasename=""
3358             if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3359               # Use subshell, to avoid clobbering current variable values
3360               dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3361               if test -n "$dlprefile_dlname" ; then
3362                 func_basename "$dlprefile_dlname"
3363                 dlprefile_dlbasename="$func_basename_result"
3364               else
3365                 # no lafile. user explicitly requested -dlpreopen <import library>.
3366                 $sharedlib_from_linklib_cmd "$dlprefile"
3367                 dlprefile_dlbasename=$sharedlib_from_linklib_result
3368               fi
3369             fi
3370             $opt_dry_run || {
3371               if test -n "$dlprefile_dlbasename" ; then
3372                 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3373               else
3374                 func_warning "Could not compute DLL name from $name"
3375                 eval '$ECHO ": $name " >> "$nlist"'
3376               fi
3377               func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3378               eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379                 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3380             }
3381           else # not an import lib
3382             $opt_dry_run || {
3383               eval '$ECHO ": $name " >> "$nlist"'
3384               func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385               eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3386             }
3387           fi
3388         ;;
3389         *)
3390           $opt_dry_run || {
3391             eval '$ECHO ": $name " >> "$nlist"'
3392             func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3393             eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3394           }
3395         ;;
3396           esac
3397     done
3398
3399     $opt_dry_run || {
3400       # Make sure we have at least an empty file.
3401       test -f "$nlist" || : > "$nlist"
3402
3403       if test -n "$exclude_expsyms"; then
3404         $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405         $MV "$nlist"T "$nlist"
3406       fi
3407
3408       # Try sorting and uniquifying the output.
3409       if $GREP -v "^: " < "$nlist" |
3410           if sort -k 3 </dev/null >/dev/null 2>&1; then
3411         sort -k 3
3412           else
3413         sort +2
3414           fi |
3415           uniq > "$nlist"S; then
3416         :
3417       else
3418         $GREP -v "^: " < "$nlist" > "$nlist"S
3419       fi
3420
3421       if test -f "$nlist"S; then
3422         eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3423       else
3424         echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3425       fi
3426
3427       echo >> "$output_objdir/$my_dlsyms" "\
3428
3429 /* The mapping between symbol names and symbols.  */
3430 typedef struct {
3431   const char *name;
3432   void *address;
3433 } lt_dlsymlist;
3434 extern LT_DLSYM_CONST lt_dlsymlist
3435 lt_${my_prefix}_LTX_preloaded_symbols[];
3436 LT_DLSYM_CONST lt_dlsymlist
3437 lt_${my_prefix}_LTX_preloaded_symbols[] =
3438 {\
3439   { \"$my_originator\", (void *) 0 },"
3440
3441       case $need_lib_prefix in
3442       no)
3443         eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444         ;;
3445       *)
3446         eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3447         ;;
3448       esac
3449       echo >> "$output_objdir/$my_dlsyms" "\
3450   {0, (void *) 0}
3451 };
3452
3453 /* This works around a problem in FreeBSD linker */
3454 #ifdef FREEBSD_WORKAROUND
3455 static const void *lt_preloaded_setup() {
3456   return lt_${my_prefix}_LTX_preloaded_symbols;
3457 }
3458 #endif
3459
3460 #ifdef __cplusplus
3461 }
3462 #endif\
3463 "
3464     } # !$opt_dry_run
3465
3466     pic_flag_for_symtable=
3467     case "$compile_command " in
3468     *" -static "*) ;;
3469     *)
3470       case $host in
3471       # compiling the symbol table file with pic_flag works around
3472       # a FreeBSD bug that causes programs to crash when -lm is
3473       # linked before any other PIC object.  But we must not use
3474       # pic_flag when linking with -static.  The problem exists in
3475       # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476       *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3477         pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3478       *-*-hpux*)
3479         pic_flag_for_symtable=" $pic_flag"  ;;
3480       *)
3481         if test "X$my_pic_p" != Xno; then
3482           pic_flag_for_symtable=" $pic_flag"
3483         fi
3484         ;;
3485       esac
3486       ;;
3487     esac
3488     symtab_cflags=
3489     for arg in $LTCFLAGS; do
3490       case $arg in
3491       -pie | -fpie | -fPIE) ;;
3492       *) func_append symtab_cflags " $arg" ;;
3493       esac
3494     done
3495
3496     # Now compile the dynamic symbol file.
3497     func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3498
3499     # Clean up the generated files.
3500     func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3501
3502     # Transform the symbol file into the correct name.
3503     symfileobj="$output_objdir/${my_outputname}S.$objext"
3504     case $host in
3505     *cygwin* | *mingw* | *cegcc* )
3506       if test -f "$output_objdir/$my_outputname.def"; then
3507         compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508         finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3509       else
3510         compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511         finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512       fi
3513       ;;
3514     *)
3515       compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516       finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3517       ;;
3518     esac
3519     ;;
3520       *)
3521     func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522     ;;
3523       esac
3524     else
3525       # We keep going just in case the user didn't refer to
3526       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3527       # really was required.
3528
3529       # Nullify the symbol file.
3530       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532     fi
3533 }
3534
3535 # func_win32_libid arg
3536 # return the library type of file 'arg'
3537 #
3538 # Need a lot of goo to handle *both* DLLs and import libs
3539 # Has to be a shell function in order to 'eat' the argument
3540 # that is supplied when $file_magic_command is called.
3541 # Despite the name, also deal with 64 bit binaries.
3542 func_win32_libid ()
3543 {
3544   $opt_debug
3545   win32_libid_type="unknown"
3546   win32_fileres=`file -L $1 2>/dev/null`
3547   case $win32_fileres in
3548   *ar\ archive\ import\ library*) # definitely import
3549     win32_libid_type="x86 archive import"
3550     ;;
3551   *ar\ archive*) # could be an import, or static
3552     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3554        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3555       func_to_tool_file "$1" func_convert_file_msys_to_w32
3556       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3557     $SED -n -e '
3558         1,100{
3559         / I /{
3560             s,.*,import,
3561             p
3562             q
3563         }
3564         }'`
3565       case $win32_nmres in
3566       import*)  win32_libid_type="x86 archive import";;
3567       *)        win32_libid_type="x86 archive static";;
3568       esac
3569     fi
3570     ;;
3571   *DLL*)
3572     win32_libid_type="x86 DLL"
3573     ;;
3574   *executable*) # but shell scripts are "executable" too...
3575     case $win32_fileres in
3576     *MS\ Windows\ PE\ Intel*)
3577       win32_libid_type="x86 DLL"
3578       ;;
3579     esac
3580     ;;
3581   esac
3582   $ECHO "$win32_libid_type"
3583 }
3584
3585 # func_cygming_dll_for_implib ARG
3586 #
3587 # Platform-specific function to extract the
3588 # name of the DLL associated with the specified
3589 # import library ARG.
3590 # Invoked by eval'ing the libtool variable
3591 #    $sharedlib_from_linklib_cmd
3592 # Result is available in the variable
3593 #    $sharedlib_from_linklib_result
3594 func_cygming_dll_for_implib ()
3595 {
3596   $opt_debug
3597   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3598 }
3599
3600 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3601 #
3602 # The is the core of a fallback implementation of a
3603 # platform-specific function to extract the name of the
3604 # DLL associated with the specified import library LIBNAME.
3605 #
3606 # SECTION_NAME is either .idata$6 or .idata$7, depending
3607 # on the platform and compiler that created the implib.
3608 #
3609 # Echos the name of the DLL associated with the
3610 # specified import library.
3611 func_cygming_dll_for_implib_fallback_core ()
3612 {
3613   $opt_debug
3614   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3616     $SED '/^Contents of section '"$match_literal"':/{
3617       # Place marker at beginning of archive member dllname section
3618       s/.*/====MARK====/
3619       p
3620       d
3621     }
3622     # These lines can sometimes be longer than 43 characters, but
3623     # are always uninteresting
3624     /:[     ]*file format pe[i]\{,1\}-/d
3625     /^In archive [^:]*:/d
3626     # Ensure marker is printed
3627     /^====MARK====/p
3628     # Remove all lines with less than 43 characters
3629     /^.\{43\}/!d
3630     # From remaining lines, remove first 43 characters
3631     s/^.\{43\}//' |
3632     $SED -n '
3633       # Join marker and all lines until next marker into a single line
3634       /^====MARK====/ b para
3635       H
3636       $ b para
3637       b
3638       :para
3639       x
3640       s/\n//g
3641       # Remove the marker
3642       s/^====MARK====//
3643       # Remove trailing dots and whitespace
3644       s/[\. \t]*$//
3645       # Print
3646       /./p' |
3647     # we now have a list, one entry per line, of the stringified
3648     # contents of the appropriate section of all members of the
3649     # archive which possess that section. Heuristic: eliminate
3650     # all those which have a first or second character that is
3651     # a '.' (that is, objdump's representation of an unprintable
3652     # character.) This should work for all archives with less than
3653     # 0x302f exports -- but will fail for DLLs whose name actually
3654     # begins with a literal '.' or a single character followed by
3655     # a '.'.
3656     #
3657     # Of those that remain, print the first one.
3658     $SED -e '/^\./d;/^.\./d;q'
3659 }
3660
3661 # func_cygming_gnu_implib_p ARG
3662 # This predicate returns with zero status (TRUE) if
3663 # ARG is a GNU/binutils-style import library. Returns
3664 # with nonzero status (FALSE) otherwise.
3665 func_cygming_gnu_implib_p ()
3666 {
3667   $opt_debug
3668   func_to_tool_file "$1" func_convert_file_msys_to_w32
3669   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3670   test -n "$func_cygming_gnu_implib_tmp"
3671 }
3672
3673 # func_cygming_ms_implib_p ARG
3674 # This predicate returns with zero status (TRUE) if
3675 # ARG is an MS-style import library. Returns
3676 # with nonzero status (FALSE) otherwise.
3677 func_cygming_ms_implib_p ()
3678 {
3679   $opt_debug
3680   func_to_tool_file "$1" func_convert_file_msys_to_w32
3681   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682   test -n "$func_cygming_ms_implib_tmp"
3683 }
3684
3685 # func_cygming_dll_for_implib_fallback ARG
3686 # Platform-specific function to extract the
3687 # name of the DLL associated with the specified
3688 # import library ARG.
3689 #
3690 # This fallback implementation is for use when $DLLTOOL
3691 # does not support the --identify-strict option.
3692 # Invoked by eval'ing the libtool variable
3693 #    $sharedlib_from_linklib_cmd
3694 # Result is available in the variable
3695 #    $sharedlib_from_linklib_result
3696 func_cygming_dll_for_implib_fallback ()
3697 {
3698   $opt_debug
3699   if func_cygming_gnu_implib_p "$1" ; then
3700     # binutils import library
3701     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702   elif func_cygming_ms_implib_p "$1" ; then
3703     # ms-generated import library
3704     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3705   else
3706     # unknown
3707     sharedlib_from_linklib_result=""
3708   fi
3709 }
3710
3711
3712 # func_extract_an_archive dir oldlib
3713 func_extract_an_archive ()
3714 {
3715     $opt_debug
3716     f_ex_an_ar_dir="$1"; shift
3717     f_ex_an_ar_oldlib="$1"
3718     if test "$lock_old_archive_extraction" = yes; then
3719       lockfile=$f_ex_an_ar_oldlib.lock
3720       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3721     func_echo "Waiting for $lockfile to be removed"
3722     sleep 2
3723       done
3724     fi
3725     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726            'stat=$?; rm -f "$lockfile"; exit $stat'
3727     if test "$lock_old_archive_extraction" = yes; then
3728       $opt_dry_run || rm -f "$lockfile"
3729     fi
3730     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3731      :
3732     else
3733       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3734     fi
3735 }
3736
3737
3738 # func_extract_archives gentop oldlib ...
3739 func_extract_archives ()
3740 {
3741     $opt_debug
3742     my_gentop="$1"; shift
3743     my_oldlibs=${1+"$@"}
3744     my_oldobjs=""
3745     my_xlib=""
3746     my_xabs=""
3747     my_xdir=""
3748
3749     for my_xlib in $my_oldlibs; do
3750       # Extract the objects.
3751       case $my_xlib in
3752     [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3753     *) my_xabs=`pwd`"/$my_xlib" ;;
3754       esac
3755       func_basename "$my_xlib"
3756       my_xlib="$func_basename_result"
3757       my_xlib_u=$my_xlib
3758       while :; do
3759         case " $extracted_archives " in
3760     *" $my_xlib_u "*)
3761       func_arith $extracted_serial + 1
3762       extracted_serial=$func_arith_result
3763       my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764     *) break ;;
3765     esac
3766       done
3767       extracted_archives="$extracted_archives $my_xlib_u"
3768       my_xdir="$my_gentop/$my_xlib_u"
3769
3770       func_mkdir_p "$my_xdir"
3771
3772       case $host in
3773       *-darwin*)
3774     func_verbose "Extracting $my_xabs"
3775     # Do not bother doing anything if just a dry run
3776     $opt_dry_run || {
3777       darwin_orig_dir=`pwd`
3778       cd $my_xdir || exit $?
3779       darwin_archive=$my_xabs
3780       darwin_curdir=`pwd`
3781       darwin_base_archive=`basename "$darwin_archive"`
3782       darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783       if test -n "$darwin_arches"; then
3784         darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3785         darwin_arch=
3786         func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3787         for darwin_arch in  $darwin_arches ; do
3788           func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789           $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790           cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791           func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3792           cd "$darwin_curdir"
3793           $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794         done # $darwin_arches
3795             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796         darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3797         darwin_file=
3798         darwin_files=
3799         for darwin_file in $darwin_filelist; do
3800           darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801           $LIPO -create -output "$darwin_file" $darwin_files
3802         done # $darwin_filelist
3803         $RM -rf unfat-$$
3804         cd "$darwin_orig_dir"
3805       else
3806         cd $darwin_orig_dir
3807         func_extract_an_archive "$my_xdir" "$my_xabs"
3808       fi # $darwin_arches
3809     } # !$opt_dry_run
3810     ;;
3811       *)
3812         func_extract_an_archive "$my_xdir" "$my_xabs"
3813     ;;
3814       esac
3815       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3816     done
3817
3818     func_extract_archives_result="$my_oldobjs"
3819 }
3820
3821
3822 # func_emit_wrapper [arg=no]
3823 #
3824 # Emit a libtool wrapper script on stdout.
3825 # Don't directly open a file because we may want to
3826 # incorporate the script contents within a cygwin/mingw
3827 # wrapper executable.  Must ONLY be called from within
3828 # func_mode_link because it depends on a number of variables
3829 # set therein.
3830 #
3831 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832 # variable will take.  If 'yes', then the emitted script
3833 # will assume that the directory in which it is stored is
3834 # the $objdir directory.  This is a cygwin/mingw-specific
3835 # behavior.
3836 func_emit_wrapper ()
3837 {
3838     func_emit_wrapper_arg1=${1-no}
3839
3840     $ECHO "\
3841 #! $SHELL
3842
3843 # $output - temporary wrapper script for $objdir/$outputname
3844 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3845 #
3846 # The $output program cannot be directly executed until all the libtool
3847 # libraries that it depends on are installed.
3848 #
3849 # This wrapper script should never be moved out of the build directory.
3850 # If it is, it will not operate correctly.
3851
3852 # Sed substitution that helps us do robust quoting.  It backslashifies
3853 # metacharacters that are still active within double-quoted strings.
3854 sed_quote_subst='$sed_quote_subst'
3855
3856 # Be Bourne compatible
3857 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3858   emulate sh
3859   NULLCMD=:
3860   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861   # is contrary to our usage.  Disable this feature.
3862   alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863   setopt NO_GLOB_SUBST
3864 else
3865   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3866 fi
3867 BIN_SH=xpg4; export BIN_SH # for Tru64
3868 DUALCASE=1; export DUALCASE # for MKS sh
3869
3870 # The HP-UX ksh and POSIX shell print the target directory to stdout
3871 # if CDPATH is set.
3872 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3873
3874 relink_command=\"$relink_command\"
3875
3876 # This environment variable determines our operation mode.
3877 if test \"\$libtool_install_magic\" = \"$magic\"; then
3878   # install mode needs the following variables:
3879   generated_by_libtool_version='$macro_version'
3880   notinst_deplibs='$notinst_deplibs'
3881 else
3882   # When we are sourced in execute mode, \$file and \$ECHO are already set.
3883   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3884     file=\"\$0\""
3885
3886     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3887     $ECHO "\
3888
3889 # A function that is used when there is no print builtin or printf.
3890 func_fallback_echo ()
3891 {
3892   eval 'cat <<_LTECHO_EOF
3893 \$1
3894 _LTECHO_EOF'
3895 }
3896     ECHO=\"$qECHO\"
3897   fi
3898
3899 # Very basic option parsing. These options are (a) specific to
3900 # the libtool wrapper, (b) are identical between the wrapper
3901 # /script/ and the wrapper /executable/ which is used only on
3902 # windows platforms, and (c) all begin with the string "--lt-"
3903 # (application programs are unlikely to have options which match
3904 # this pattern).
3905 #
3906 # There are only two supported options: --lt-debug and
3907 # --lt-dump-script. There is, deliberately, no --lt-help.
3908 #
3909 # The first argument to this parsing function should be the
3910 # script's $0 value, followed by "$@".
3911 lt_option_debug=
3912 func_parse_lt_options ()
3913 {
3914   lt_script_arg0=\$0
3915   shift
3916   for lt_opt
3917   do
3918     case \"\$lt_opt\" in
3919     --lt-debug) lt_option_debug=1 ;;
3920     --lt-dump-script)
3921         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924         cat \"\$lt_dump_D/\$lt_dump_F\"
3925         exit 0
3926       ;;
3927     --lt-*)
3928         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3929         exit 1
3930       ;;
3931     esac
3932   done
3933
3934   # Print the debug banner immediately:
3935   if test -n \"\$lt_option_debug\"; then
3936     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937   fi
3938 }
3939
3940 # Used when --lt-debug. Prints its arguments to stdout
3941 # (redirection is the responsibility of the caller)
3942 func_lt_dump_args ()
3943 {
3944   lt_dump_args_N=1;
3945   for lt_arg
3946   do
3947     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949   done
3950 }
3951
3952 # Core function for launching the target application
3953 func_exec_program_core ()
3954 {
3955 "
3956   case $host in
3957   # Backslashes separate directories on plain windows
3958   *-*-mingw | *-*-os2* | *-cegcc*)
3959     $ECHO "\
3960       if test -n \"\$lt_option_debug\"; then
3961         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962         func_lt_dump_args \${1+\"\$@\"} 1>&2
3963       fi
3964       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3965 "
3966     ;;
3967
3968   *)
3969     $ECHO "\
3970       if test -n \"\$lt_option_debug\"; then
3971         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3972         func_lt_dump_args \${1+\"\$@\"} 1>&2
3973       fi
3974       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3975 "
3976     ;;
3977   esac
3978   $ECHO "\
3979       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3980       exit 1
3981 }
3982
3983 # A function to encapsulate launching the target application
3984 # Strips options in the --lt-* namespace from \$@ and
3985 # launches target application with the remaining arguments.
3986 func_exec_program ()
3987 {
3988   case \" \$* \" in
3989   *\\ --lt-*)
3990     for lt_wr_arg
3991     do
3992       case \$lt_wr_arg in
3993       --lt-*) ;;
3994       *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3995       esac
3996       shift
3997     done ;;
3998   esac
3999   func_exec_program_core \${1+\"\$@\"}
4000 }
4001
4002   # Parse options
4003   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4004
4005   # Find the directory that this script lives in.
4006   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4007   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4008
4009   # Follow symbolic links until we get to the real thisdir.
4010   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4011   while test -n \"\$file\"; do
4012     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4013
4014     # If there was a directory component, then change thisdir.
4015     if test \"x\$destdir\" != \"x\$file\"; then
4016       case \"\$destdir\" in
4017       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4018       *) thisdir=\"\$thisdir/\$destdir\" ;;
4019       esac
4020     fi
4021
4022     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4024   done
4025
4026   # Usually 'no', except on cygwin/mingw when embedded into
4027   # the cwrapper.
4028   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4029   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4030     # special case for '.'
4031     if test \"\$thisdir\" = \".\"; then
4032       thisdir=\`pwd\`
4033     fi
4034     # remove .libs from thisdir
4035     case \"\$thisdir\" in
4036     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4037     $objdir )   thisdir=. ;;
4038     esac
4039   fi
4040
4041   # Try to get the absolute directory name.
4042   absdir=\`cd \"\$thisdir\" && pwd\`
4043   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4044 "
4045
4046     if test "$fast_install" = yes; then
4047       $ECHO "\
4048   program=lt-'$outputname'$exeext
4049   progdir=\"\$thisdir/$objdir\"
4050
4051   if test ! -f \"\$progdir/\$program\" ||
4052      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4053        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4054
4055     file=\"\$\$-\$program\"
4056
4057     if test ! -d \"\$progdir\"; then
4058       $MKDIR \"\$progdir\"
4059     else
4060       $RM \"\$progdir/\$file\"
4061     fi"
4062
4063       $ECHO "\
4064
4065     # relink executable if necessary
4066     if test -n \"\$relink_command\"; then
4067       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4068       else
4069     $ECHO \"\$relink_command_output\" >&2
4070     $RM \"\$progdir/\$file\"
4071     exit 1
4072       fi
4073     fi
4074
4075     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4076     { $RM \"\$progdir/\$program\";
4077       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4078     $RM \"\$progdir/\$file\"
4079   fi"
4080     else
4081       $ECHO "\
4082   program='$outputname'
4083   progdir=\"\$thisdir/$objdir\"
4084 "
4085     fi
4086
4087     $ECHO "\
4088
4089   if test -f \"\$progdir/\$program\"; then"
4090
4091     # fixup the dll searchpath if we need to.
4092     #
4093     # Fix the DLL searchpath if we need to.  Do this before prepending
4094     # to shlibpath, because on Windows, both are PATH and uninstalled
4095     # libraries must come first.
4096     if test -n "$dllsearchpath"; then
4097       $ECHO "\
4098     # Add the dll search path components to the executable PATH
4099     PATH=$dllsearchpath:\$PATH
4100 "
4101     fi
4102
4103     # Export our shlibpath_var if we have one.
4104     if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4105       $ECHO "\
4106     # Add our own library path to $shlibpath_var
4107     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4108
4109     # Some systems cannot cope with colon-terminated $shlibpath_var
4110     # The second colon is a workaround for a bug in BeOS R4 sed
4111     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4112
4113     export $shlibpath_var
4114 "
4115     fi
4116
4117     $ECHO "\
4118     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4119       # Run the actual program with our arguments.
4120       func_exec_program \${1+\"\$@\"}
4121     fi
4122   else
4123     # The program doesn't exist.
4124     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4125     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4126     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4127     exit 1
4128   fi
4129 fi\
4130 "
4131 }
4132
4133
4134 # func_emit_cwrapperexe_src
4135 # emit the source code for a wrapper executable on stdout
4136 # Must ONLY be called from within func_mode_link because
4137 # it depends on a number of variable set therein.
4138 func_emit_cwrapperexe_src ()
4139 {
4140     cat <<EOF
4141
4142 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4143    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4144
4145    The $output program cannot be directly executed until all the libtool
4146    libraries that it depends on are installed.
4147
4148    This wrapper executable should never be moved out of the build directory.
4149    If it is, it will not operate correctly.
4150 */
4151 EOF
4152         cat <<"EOF"
4153 #ifdef _MSC_VER
4154 # define _CRT_SECURE_NO_DEPRECATE 1
4155 #endif
4156 #include <stdio.h>
4157 #include <stdlib.h>
4158 #ifdef _MSC_VER
4159 # include <direct.h>
4160 # include <process.h>
4161 # include <io.h>
4162 #else
4163 # include <unistd.h>
4164 # include <stdint.h>
4165 # ifdef __CYGWIN__
4166 #  include <io.h>
4167 # endif
4168 #endif
4169 #include <malloc.h>
4170 #include <stdarg.h>
4171 #include <assert.h>
4172 #include <string.h>
4173 #include <ctype.h>
4174 #include <errno.h>
4175 #include <fcntl.h>
4176 #include <sys/stat.h>
4177
4178 /* declarations of non-ANSI functions */
4179 #if defined(__MINGW32__)
4180 # ifdef __STRICT_ANSI__
4181 int _putenv (const char *);
4182 # endif
4183 #elif defined(__CYGWIN__)
4184 # ifdef __STRICT_ANSI__
4185 char *realpath (const char *, char *);
4186 int putenv (char *);
4187 int setenv (const char *, const char *, int);
4188 # endif
4189 /* #elif defined (other platforms) ... */
4190 #endif
4191
4192 /* portability defines, excluding path handling macros */
4193 #if defined(_MSC_VER)
4194 # define setmode _setmode
4195 # define stat    _stat
4196 # define chmod   _chmod
4197 # define getcwd  _getcwd
4198 # define putenv  _putenv
4199 # define S_IXUSR _S_IEXEC
4200 # ifndef _INTPTR_T_DEFINED
4201 #  define _INTPTR_T_DEFINED
4202 #  define intptr_t int
4203 # endif
4204 #elif defined(__MINGW32__)
4205 # define setmode _setmode
4206 # define stat    _stat
4207 # define chmod   _chmod
4208 # define getcwd  _getcwd
4209 # define putenv  _putenv
4210 #elif defined(__CYGWIN__)
4211 # define HAVE_SETENV
4212 # define FOPEN_WB "wb"
4213 /* #elif defined (other platforms) ... */
4214 #endif
4215
4216 #if defined(PATH_MAX)
4217 # define LT_PATHMAX PATH_MAX
4218 #elif defined(MAXPATHLEN)
4219 # define LT_PATHMAX MAXPATHLEN
4220 #else
4221 # define LT_PATHMAX 1024
4222 #endif
4223
4224 #ifndef S_IXOTH
4225 # define S_IXOTH 0
4226 #endif
4227 #ifndef S_IXGRP
4228 # define S_IXGRP 0
4229 #endif
4230
4231 /* path handling portability macros */
4232 #ifndef DIR_SEPARATOR
4233 # define DIR_SEPARATOR '/'
4234 # define PATH_SEPARATOR ':'
4235 #endif
4236
4237 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4238   defined (__OS2__)
4239 # define HAVE_DOS_BASED_FILE_SYSTEM
4240 # define FOPEN_WB "wb"
4241 # ifndef DIR_SEPARATOR_2
4242 #  define DIR_SEPARATOR_2 '\\'
4243 # endif
4244 # ifndef PATH_SEPARATOR_2
4245 #  define PATH_SEPARATOR_2 ';'
4246 # endif
4247 #endif
4248
4249 #ifndef DIR_SEPARATOR_2
4250 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4251 #else /* DIR_SEPARATOR_2 */
4252 # define IS_DIR_SEPARATOR(ch) \
4253     (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4254 #endif /* DIR_SEPARATOR_2 */
4255
4256 #ifndef PATH_SEPARATOR_2
4257 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4258 #else /* PATH_SEPARATOR_2 */
4259 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4260 #endif /* PATH_SEPARATOR_2 */
4261
4262 #ifndef FOPEN_WB
4263 # define FOPEN_WB "w"
4264 #endif
4265 #ifndef _O_BINARY
4266 # define _O_BINARY 0
4267 #endif
4268
4269 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4270 #define XFREE(stale) do { \
4271   if (stale) { free ((void *) stale); stale = 0; } \
4272 } while (0)
4273
4274 #if defined(LT_DEBUGWRAPPER)
4275 static int lt_debug = 1;
4276 #else
4277 static int lt_debug = 0;
4278 #endif
4279
4280 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4281
4282 void *xmalloc (size_t num);
4283 char *xstrdup (const char *string);
4284 const char *base_name (const char *name);
4285 char *find_executable (const char *wrapper);
4286 char *chase_symlinks (const char *pathspec);
4287 int make_executable (const char *path);
4288 int check_executable (const char *path);
4289 char *strendzap (char *str, const char *pat);
4290 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4291 void lt_fatal (const char *file, int line, const char *message, ...);
4292 static const char *nonnull (const char *s);
4293 static const char *nonempty (const char *s);
4294 void lt_setenv (const char *name, const char *value);
4295 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4296 void lt_update_exe_path (const char *name, const char *value);
4297 void lt_update_lib_path (const char *name, const char *value);
4298 char **prepare_spawn (char **argv);
4299 void lt_dump_script (FILE *f);
4300 EOF
4301
4302         cat <<EOF
4303 volatile const char * MAGIC_EXE = "$magic_exe";
4304 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4305 EOF
4306
4307         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4308               func_to_host_path "$temp_rpath"
4309           cat <<EOF
4310 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
4311 EOF
4312         else
4313           cat <<"EOF"
4314 const char * LIB_PATH_VALUE   = "";
4315 EOF
4316         fi
4317
4318         if test -n "$dllsearchpath"; then
4319               func_to_host_path "$dllsearchpath:"
4320           cat <<EOF
4321 const char * EXE_PATH_VARNAME = "PATH";
4322 const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
4323 EOF
4324         else
4325           cat <<"EOF"
4326 const char * EXE_PATH_VARNAME = "";
4327 const char * EXE_PATH_VALUE   = "";
4328 EOF
4329         fi
4330
4331         if test "$fast_install" = yes; then
4332           cat <<EOF
4333 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4334 EOF
4335         else
4336           cat <<EOF
4337 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4338 EOF
4339         fi
4340
4341
4342         cat <<"EOF"
4343
4344 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
4345
4346 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4347 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
4348 static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
4349
4350 int
4351 main (int argc, char *argv[])
4352 {
4353   char **newargz;
4354   int  newargc;
4355   char *tmp_pathspec;
4356   char *actual_cwrapper_path;
4357   char *actual_cwrapper_name;
4358   char *target_name;
4359   char *lt_argv_zero;
4360   intptr_t rval = 127;
4361
4362   int i;
4363
4364   program_name = (char *) xstrdup (base_name (argv[0]));
4365   newargz = XMALLOC (char *, argc + 1);
4366
4367   /* very simple arg parsing; don't want to rely on getopt
4368    * also, copy all non cwrapper options to newargz, except
4369    * argz[0], which is handled differently
4370    */
4371   newargc=0;
4372   for (i = 1; i < argc; i++)
4373     {
4374       if (strcmp (argv[i], dumpscript_opt) == 0)
4375     {
4376 EOF
4377         case "$host" in
4378           *mingw* | *cygwin* )
4379         # make stdout use "unix" line endings
4380         echo "          setmode(1,_O_BINARY);"
4381         ;;
4382           esac
4383
4384         cat <<"EOF"
4385       lt_dump_script (stdout);
4386       return 0;
4387     }
4388       if (strcmp (argv[i], debug_opt) == 0)
4389     {
4390           lt_debug = 1;
4391           continue;
4392     }
4393       if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4394         {
4395           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4396              namespace, but it is not one of the ones we know about and
4397              have already dealt with, above (inluding dump-script), then
4398              report an error. Otherwise, targets might begin to believe
4399              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4400              namespace. The first time any user complains about this, we'll
4401              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4402              or a configure.ac-settable value.
4403            */
4404           lt_fatal (__FILE__, __LINE__,
4405             "unrecognized %s option: '%s'",
4406                     ltwrapper_option_prefix, argv[i]);
4407         }
4408       /* otherwise ... */
4409       newargz[++newargc] = xstrdup (argv[i]);
4410     }
4411   newargz[++newargc] = NULL;
4412
4413 EOF
4414         cat <<EOF
4415   /* The GNU banner must be the first non-error debug message */
4416   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4417 EOF
4418         cat <<"EOF"
4419   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4420   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4421
4422   tmp_pathspec = find_executable (argv[0]);
4423   if (tmp_pathspec == NULL)
4424     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4425   lt_debugprintf (__FILE__, __LINE__,
4426                   "(main) found exe (before symlink chase) at: %s\n",
4427           tmp_pathspec);
4428
4429   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4430   lt_debugprintf (__FILE__, __LINE__,
4431                   "(main) found exe (after symlink chase) at: %s\n",
4432           actual_cwrapper_path);
4433   XFREE (tmp_pathspec);
4434
4435   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4436   strendzap (actual_cwrapper_path, actual_cwrapper_name);
4437
4438   /* wrapper name transforms */
4439   strendzap (actual_cwrapper_name, ".exe");
4440   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4441   XFREE (actual_cwrapper_name);
4442   actual_cwrapper_name = tmp_pathspec;
4443   tmp_pathspec = 0;
4444
4445   /* target_name transforms -- use actual target program name; might have lt- prefix */
4446   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4447   strendzap (target_name, ".exe");
4448   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4449   XFREE (target_name);
4450   target_name = tmp_pathspec;
4451   tmp_pathspec = 0;
4452
4453   lt_debugprintf (__FILE__, __LINE__,
4454           "(main) libtool target name: %s\n",
4455           target_name);
4456 EOF
4457
4458         cat <<EOF
4459   newargz[0] =
4460     XMALLOC (char, (strlen (actual_cwrapper_path) +
4461             strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4462   strcpy (newargz[0], actual_cwrapper_path);
4463   strcat (newargz[0], "$objdir");
4464   strcat (newargz[0], "/");
4465 EOF
4466
4467         cat <<"EOF"
4468   /* stop here, and copy so we don't have to do this twice */
4469   tmp_pathspec = xstrdup (newargz[0]);
4470
4471   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4472   strcat (newargz[0], actual_cwrapper_name);
4473
4474   /* DO want the lt- prefix here if it exists, so use target_name */
4475   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4476   XFREE (tmp_pathspec);
4477   tmp_pathspec = NULL;
4478 EOF
4479
4480         case $host_os in
4481           mingw*)
4482         cat <<"EOF"
4483   {
4484     char* p;
4485     while ((p = strchr (newargz[0], '\\')) != NULL)
4486       {
4487     *p = '/';
4488       }
4489     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4490       {
4491     *p = '/';
4492       }
4493   }
4494 EOF
4495         ;;
4496         esac
4497
4498         cat <<"EOF"
4499   XFREE (target_name);
4500   XFREE (actual_cwrapper_path);
4501   XFREE (actual_cwrapper_name);
4502
4503   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4504   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
4505   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
4506      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4507      because on Windows, both *_VARNAMEs are PATH but uninstalled
4508      libraries must come first. */
4509   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4510   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4511
4512   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513           nonnull (lt_argv_zero));
4514   for (i = 0; i < newargc; i++)
4515     {
4516       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517               i, nonnull (newargz[i]));
4518     }
4519
4520 EOF
4521
4522         case $host_os in
4523           mingw*)
4524         cat <<"EOF"
4525   /* execv doesn't actually work on mingw as expected on unix */
4526   newargz = prepare_spawn (newargz);
4527   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4528   if (rval == -1)
4529     {
4530       /* failed to start process */
4531       lt_debugprintf (__FILE__, __LINE__,
4532               "(main) failed to launch target \"%s\": %s\n",
4533               lt_argv_zero, nonnull (strerror (errno)));
4534       return 127;
4535     }
4536   return rval;
4537 EOF
4538         ;;
4539           *)
4540         cat <<"EOF"
4541   execv (lt_argv_zero, newargz);
4542   return rval; /* =127, but avoids unused variable warning */
4543 EOF
4544         ;;
4545         esac
4546
4547         cat <<"EOF"
4548 }
4549
4550 void *
4551 xmalloc (size_t num)
4552 {
4553   void *p = (void *) malloc (num);
4554   if (!p)
4555     lt_fatal (__FILE__, __LINE__, "memory exhausted");
4556
4557   return p;
4558 }
4559
4560 char *
4561 xstrdup (const char *string)
4562 {
4563   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4564               string) : NULL;
4565 }
4566
4567 const char *
4568 base_name (const char *name)
4569 {
4570   const char *base;
4571
4572 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4573   /* Skip over the disk name in MSDOS pathnames. */
4574   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4575     name += 2;
4576 #endif
4577
4578   for (base = name; *name; name++)
4579     if (IS_DIR_SEPARATOR (*name))
4580       base = name + 1;
4581   return base;
4582 }
4583
4584 int
4585 check_executable (const char *path)
4586 {
4587   struct stat st;
4588
4589   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4590                   nonempty (path));
4591   if ((!path) || (!*path))
4592     return 0;
4593
4594   if ((stat (path, &st) >= 0)
4595       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4596     return 1;
4597   else
4598     return 0;
4599 }
4600
4601 int
4602 make_executable (const char *path)
4603 {
4604   int rval = 0;
4605   struct stat st;
4606
4607   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4608                   nonempty (path));
4609   if ((!path) || (!*path))
4610     return 0;
4611
4612   if (stat (path, &st) >= 0)
4613     {
4614       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4615     }
4616   return rval;
4617 }
4618
4619 /* Searches for the full path of the wrapper.  Returns
4620    newly allocated full path name if found, NULL otherwise
4621    Does not chase symlinks, even on platforms that support them.
4622 */
4623 char *
4624 find_executable (const char *wrapper)
4625 {
4626   int has_slash = 0;
4627   const char *p;
4628   const char *p_next;
4629   /* static buffer for getcwd */
4630   char tmp[LT_PATHMAX + 1];
4631   int tmp_len;
4632   char *concat_name;
4633
4634   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4635                   nonempty (wrapper));
4636
4637   if ((wrapper == NULL) || (*wrapper == '\0'))
4638     return NULL;
4639
4640   /* Absolute path? */
4641 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4642   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4643     {
4644       concat_name = xstrdup (wrapper);
4645       if (check_executable (concat_name))
4646     return concat_name;
4647       XFREE (concat_name);
4648     }
4649   else
4650     {
4651 #endif
4652       if (IS_DIR_SEPARATOR (wrapper[0]))
4653     {
4654       concat_name = xstrdup (wrapper);
4655       if (check_executable (concat_name))
4656         return concat_name;
4657       XFREE (concat_name);
4658     }
4659 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4660     }
4661 #endif
4662
4663   for (p = wrapper; *p; p++)
4664     if (*p == '/')
4665       {
4666     has_slash = 1;
4667     break;
4668       }
4669   if (!has_slash)
4670     {
4671       /* no slashes; search PATH */
4672       const char *path = getenv ("PATH");
4673       if (path != NULL)
4674     {
4675       for (p = path; *p; p = p_next)
4676         {
4677           const char *q;
4678           size_t p_len;
4679           for (q = p; *q; q++)
4680         if (IS_PATH_SEPARATOR (*q))
4681           break;
4682           p_len = q - p;
4683           p_next = (*q == '\0' ? q : q + 1);
4684           if (p_len == 0)
4685         {
4686           /* empty path: current directory */
4687           if (getcwd (tmp, LT_PATHMAX) == NULL)
4688             lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4689                               nonnull (strerror (errno)));
4690           tmp_len = strlen (tmp);
4691           concat_name =
4692             XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4693           memcpy (concat_name, tmp, tmp_len);
4694           concat_name[tmp_len] = '/';
4695           strcpy (concat_name + tmp_len + 1, wrapper);
4696         }
4697           else
4698         {
4699           concat_name =
4700             XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4701           memcpy (concat_name, p, p_len);
4702           concat_name[p_len] = '/';
4703           strcpy (concat_name + p_len + 1, wrapper);
4704         }
4705           if (check_executable (concat_name))
4706         return concat_name;
4707           XFREE (concat_name);
4708         }
4709     }
4710       /* not found in PATH; assume curdir */
4711     }
4712   /* Relative path | not found in path: prepend cwd */
4713   if (getcwd (tmp, LT_PATHMAX) == NULL)
4714     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4715               nonnull (strerror (errno)));
4716   tmp_len = strlen (tmp);
4717   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4718   memcpy (concat_name, tmp, tmp_len);
4719   concat_name[tmp_len] = '/';
4720   strcpy (concat_name + tmp_len + 1, wrapper);
4721
4722   if (check_executable (concat_name))
4723     return concat_name;
4724   XFREE (concat_name);
4725   return NULL;
4726 }
4727
4728 char *
4729 chase_symlinks (const char *pathspec)
4730 {
4731 #ifndef S_ISLNK
4732   return xstrdup (pathspec);
4733 #else
4734   char buf[LT_PATHMAX];
4735   struct stat s;
4736   char *tmp_pathspec = xstrdup (pathspec);
4737   char *p;
4738   int has_symlinks = 0;
4739   while (strlen (tmp_pathspec) && !has_symlinks)
4740     {
4741       lt_debugprintf (__FILE__, __LINE__,
4742               "checking path component for symlinks: %s\n",
4743               tmp_pathspec);
4744       if (lstat (tmp_pathspec, &s) == 0)
4745     {
4746       if (S_ISLNK (s.st_mode) != 0)
4747         {
4748           has_symlinks = 1;
4749           break;
4750         }
4751
4752       /* search backwards for last DIR_SEPARATOR */
4753       p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4754       while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4755         p--;
4756       if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4757         {
4758           /* no more DIR_SEPARATORS left */
4759           break;
4760         }
4761       *p = '\0';
4762     }
4763       else
4764     {
4765       lt_fatal (__FILE__, __LINE__,
4766             "error accessing file \"%s\": %s",
4767             tmp_pathspec, nonnull (strerror (errno)));
4768     }
4769     }
4770   XFREE (tmp_pathspec);
4771
4772   if (!has_symlinks)
4773     {
4774       return xstrdup (pathspec);
4775     }
4776
4777   tmp_pathspec = realpath (pathspec, buf);
4778   if (tmp_pathspec == 0)
4779     {
4780       lt_fatal (__FILE__, __LINE__,
4781         "could not follow symlinks for %s", pathspec);
4782     }
4783   return xstrdup (tmp_pathspec);
4784 #endif
4785 }
4786
4787 char *
4788 strendzap (char *str, const char *pat)
4789 {
4790   size_t len, patlen;
4791
4792   assert (str != NULL);
4793   assert (pat != NULL);
4794
4795   len = strlen (str);
4796   patlen = strlen (pat);
4797
4798   if (patlen <= len)
4799     {
4800       str += len - patlen;
4801       if (strcmp (str, pat) == 0)
4802     *str = '\0';
4803     }
4804   return str;
4805 }
4806
4807 void
4808 lt_debugprintf (const char *file, int line, const char *fmt, ...)
4809 {
4810   va_list args;
4811   if (lt_debug)
4812     {
4813       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4814       va_start (args, fmt);
4815       (void) vfprintf (stderr, fmt, args);
4816       va_end (args);
4817     }
4818 }
4819
4820 static void
4821 lt_error_core (int exit_status, const char *file,
4822            int line, const char *mode,
4823            const char *message, va_list ap)
4824 {
4825   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4826   vfprintf (stderr, message, ap);
4827   fprintf (stderr, ".\n");
4828
4829   if (exit_status >= 0)
4830     exit (exit_status);
4831 }
4832
4833 void
4834 lt_fatal (const char *file, int line, const char *message, ...)
4835 {
4836   va_list ap;
4837   va_start (ap, message);
4838   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4839   va_end (ap);
4840 }
4841
4842 static const char *
4843 nonnull (const char *s)
4844 {
4845   return s ? s : "(null)";
4846 }
4847
4848 static const char *
4849 nonempty (const char *s)
4850 {
4851   return (s && !*s) ? "(empty)" : nonnull (s);
4852 }
4853
4854 void
4855 lt_setenv (const char *name, const char *value)
4856 {
4857   lt_debugprintf (__FILE__, __LINE__,
4858           "(lt_setenv) setting '%s' to '%s'\n",
4859                   nonnull (name), nonnull (value));
4860   {
4861 #ifdef HAVE_SETENV
4862     /* always make a copy, for consistency with !HAVE_SETENV */
4863     char *str = xstrdup (value);
4864     setenv (name, str, 1);
4865 #else
4866     int len = strlen (name) + 1 + strlen (value) + 1;
4867     char *str = XMALLOC (char, len);
4868     sprintf (str, "%s=%s", name, value);
4869     if (putenv (str) != EXIT_SUCCESS)
4870       {
4871         XFREE (str);
4872       }
4873 #endif
4874   }
4875 }
4876
4877 char *
4878 lt_extend_str (const char *orig_value, const char *add, int to_end)
4879 {
4880   char *new_value;
4881   if (orig_value && *orig_value)
4882     {
4883       int orig_value_len = strlen (orig_value);
4884       int add_len = strlen (add);
4885       new_value = XMALLOC (char, add_len + orig_value_len + 1);
4886       if (to_end)
4887         {
4888           strcpy (new_value, orig_value);
4889           strcpy (new_value + orig_value_len, add);
4890         }
4891       else
4892         {
4893           strcpy (new_value, add);
4894           strcpy (new_value + add_len, orig_value);
4895         }
4896     }
4897   else
4898     {
4899       new_value = xstrdup (add);
4900     }
4901   return new_value;
4902 }
4903
4904 void
4905 lt_update_exe_path (const char *name, const char *value)
4906 {
4907   lt_debugprintf (__FILE__, __LINE__,
4908           "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909                   nonnull (name), nonnull (value));
4910
4911   if (name && *name && value && *value)
4912     {
4913       char *new_value = lt_extend_str (getenv (name), value, 0);
4914       /* some systems can't cope with a ':'-terminated path #' */
4915       int len = strlen (new_value);
4916       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4917         {
4918           new_value[len-1] = '\0';
4919         }
4920       lt_setenv (name, new_value);
4921       XFREE (new_value);
4922     }
4923 }
4924
4925 void
4926 lt_update_lib_path (const char *name, const char *value)
4927 {
4928   lt_debugprintf (__FILE__, __LINE__,
4929           "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930                   nonnull (name), nonnull (value));
4931
4932   if (name && *name && value && *value)
4933     {
4934       char *new_value = lt_extend_str (getenv (name), value, 0);
4935       lt_setenv (name, new_value);
4936       XFREE (new_value);
4937     }
4938 }
4939
4940 EOF
4941         case $host_os in
4942           mingw*)
4943         cat <<"EOF"
4944
4945 /* Prepares an argument vector before calling spawn().
4946    Note that spawn() does not by itself call the command interpreter
4947      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4948       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4949          GetVersionEx(&v);
4950          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4951       }) ? "cmd.exe" : "command.com").
4952    Instead it simply concatenates the arguments, separated by ' ', and calls
4953    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4954    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4955    special way:
4956    - Space and tab are interpreted as delimiters. They are not treated as
4957      delimiters if they are surrounded by double quotes: "...".
4958    - Unescaped double quotes are removed from the input. Their only effect is
4959      that within double quotes, space and tab are treated like normal
4960      characters.
4961    - Backslashes not followed by double quotes are not special.
4962    - But 2*n+1 backslashes followed by a double quote become
4963      n backslashes followed by a double quote (n >= 0):
4964        \" -> "
4965        \\\" -> \"
4966        \\\\\" -> \\"
4967  */
4968 #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"
4969 #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"
4970 char **
4971 prepare_spawn (char **argv)
4972 {
4973   size_t argc;
4974   char **new_argv;
4975   size_t i;
4976
4977   /* Count number of arguments.  */
4978   for (argc = 0; argv[argc] != NULL; argc++)
4979     ;
4980
4981   /* Allocate new argument vector.  */
4982   new_argv = XMALLOC (char *, argc + 1);
4983
4984   /* Put quoted arguments into the new argument vector.  */
4985   for (i = 0; i < argc; i++)
4986     {
4987       const char *string = argv[i];
4988
4989       if (string[0] == '\0')
4990     new_argv[i] = xstrdup ("\"\"");
4991       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4992     {
4993       int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4994       size_t length;
4995       unsigned int backslashes;
4996       const char *s;
4997       char *quoted_string;
4998       char *p;
4999
5000       length = 0;
5001       backslashes = 0;
5002       if (quote_around)
5003         length++;
5004       for (s = string; *s != '\0'; s++)
5005         {
5006           char c = *s;
5007           if (c == '"')
5008         length += backslashes + 1;
5009           length++;
5010           if (c == '\\')
5011         backslashes++;
5012           else
5013         backslashes = 0;
5014         }
5015       if (quote_around)
5016         length += backslashes + 1;
5017
5018       quoted_string = XMALLOC (char, length + 1);
5019
5020       p = quoted_string;
5021       backslashes = 0;
5022       if (quote_around)
5023         *p++ = '"';
5024       for (s = string; *s != '\0'; s++)
5025         {
5026           char c = *s;
5027           if (c == '"')
5028         {
5029           unsigned int j;
5030           for (j = backslashes + 1; j > 0; j--)
5031             *p++ = '\\';
5032         }
5033           *p++ = c;
5034           if (c == '\\')
5035         backslashes++;
5036           else
5037         backslashes = 0;
5038         }
5039       if (quote_around)
5040         {
5041           unsigned int j;
5042           for (j = backslashes; j > 0; j--)
5043         *p++ = '\\';
5044           *p++ = '"';
5045         }
5046       *p = '\0';
5047
5048       new_argv[i] = quoted_string;
5049     }
5050       else
5051     new_argv[i] = (char *) string;
5052     }
5053   new_argv[argc] = NULL;
5054
5055   return new_argv;
5056 }
5057 EOF
5058         ;;
5059         esac
5060
5061             cat <<"EOF"
5062 void lt_dump_script (FILE* f)
5063 {
5064 EOF
5065         func_emit_wrapper yes |
5066           $SED -n -e '
5067 s/^\(.\{79\}\)\(..*\)/\1\
5068 \2/
5069 h
5070 s/\([\\"]\)/\\\1/g
5071 s/$/\\n/
5072 s/\([^\n]*\).*/  fputs ("\1", f);/p
5073 g
5074 D'
5075             cat <<"EOF"
5076 }
5077 EOF
5078 }
5079 # end: func_emit_cwrapperexe_src
5080
5081 # func_win32_import_lib_p ARG
5082 # True if ARG is an import lib, as indicated by $file_magic_cmd
5083 func_win32_import_lib_p ()
5084 {
5085     $opt_debug
5086     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5087     *import*) : ;;
5088     *) false ;;
5089     esac
5090 }
5091
5092 # func_mode_link arg...
5093 func_mode_link ()
5094 {
5095     $opt_debug
5096     case $host in
5097     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5098       # It is impossible to link a dll without this setting, and
5099       # we shouldn't force the makefile maintainer to figure out
5100       # which system we are compiling for in order to pass an extra
5101       # flag for every libtool invocation.
5102       # allow_undefined=no
5103
5104       # FIXME: Unfortunately, there are problems with the above when trying
5105       # to make a dll which has undefined symbols, in which case not
5106       # even a static library is built.  For now, we need to specify
5107       # -no-undefined on the libtool link line when we can be certain
5108       # that all symbols are satisfied, otherwise we get a static library.
5109       allow_undefined=yes
5110       ;;
5111     *)
5112       allow_undefined=yes
5113       ;;
5114     esac
5115     libtool_args=$nonopt
5116     base_compile="$nonopt $@"
5117     compile_command=$nonopt
5118     finalize_command=$nonopt
5119
5120     compile_rpath=
5121     finalize_rpath=
5122     compile_shlibpath=
5123     finalize_shlibpath=
5124     convenience=
5125     old_convenience=
5126     deplibs=
5127     old_deplibs=
5128     compiler_flags=
5129     linker_flags=
5130     dllsearchpath=
5131     lib_search_path=`pwd`
5132     inst_prefix_dir=
5133     new_inherited_linker_flags=
5134
5135     avoid_version=no
5136     bindir=
5137     dlfiles=
5138     dlprefiles=
5139     dlself=no
5140     export_dynamic=no
5141     export_symbols=
5142     export_symbols_regex=
5143     generated=
5144     libobjs=
5145     ltlibs=
5146     module=no
5147     no_install=no
5148     objs=
5149     non_pic_objects=
5150     precious_files_regex=
5151     prefer_static_libs=no
5152     preload=no
5153     prev=
5154     prevarg=
5155     release=
5156     rpath=
5157     xrpath=
5158     perm_rpath=
5159     temp_rpath=
5160     thread_safe=no
5161     vinfo=
5162     vinfo_number=no
5163     weak_libs=
5164     single_module="${wl}-single_module"
5165     func_infer_tag $base_compile
5166
5167     # We need to know -static, to get the right output filenames.
5168     for arg
5169     do
5170       case $arg in
5171       -shared)
5172     test "$build_libtool_libs" != yes && \
5173       func_fatal_configuration "can not build a shared library"
5174     build_old_libs=no
5175     break
5176     ;;
5177       -all-static | -static | -static-libtool-libs)
5178     case $arg in
5179     -all-static)
5180       if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5181         func_warning "complete static linking is impossible in this configuration"
5182       fi
5183       if test -n "$link_static_flag"; then
5184         dlopen_self=$dlopen_self_static
5185       fi
5186       prefer_static_libs=yes
5187       ;;
5188     -static)
5189       if test -z "$pic_flag" && test -n "$link_static_flag"; then
5190         dlopen_self=$dlopen_self_static
5191       fi
5192       prefer_static_libs=built
5193       ;;
5194     -static-libtool-libs)
5195       if test -z "$pic_flag" && test -n "$link_static_flag"; then
5196         dlopen_self=$dlopen_self_static
5197       fi
5198       prefer_static_libs=yes
5199       ;;
5200     esac
5201     build_libtool_libs=no
5202     build_old_libs=yes
5203     break
5204     ;;
5205       esac
5206     done
5207
5208     # See if our shared archives depend on static archives.
5209     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5210
5211     # Go through the arguments, transforming them on the way.
5212     while test "$#" -gt 0; do
5213       arg="$1"
5214       shift
5215       func_quote_for_eval "$arg"
5216       qarg=$func_quote_for_eval_unquoted_result
5217       func_append libtool_args " $func_quote_for_eval_result"
5218
5219       # If the previous option needs an argument, assign it.
5220       if test -n "$prev"; then
5221     case $prev in
5222     output)
5223       func_append compile_command " @OUTPUT@"
5224       func_append finalize_command " @OUTPUT@"
5225       ;;
5226     esac
5227
5228     case $prev in
5229     bindir)
5230       bindir="$arg"
5231       prev=
5232       continue
5233       ;;
5234     dlfiles|dlprefiles)
5235       if test "$preload" = no; then
5236         # Add the symbol object into the linking commands.
5237         func_append compile_command " @SYMFILE@"
5238         func_append finalize_command " @SYMFILE@"
5239         preload=yes
5240       fi
5241       case $arg in
5242       *.la | *.lo) ;;  # We handle these cases below.
5243       force)
5244         if test "$dlself" = no; then
5245           dlself=needless
5246           export_dynamic=yes
5247         fi
5248         prev=
5249         continue
5250         ;;
5251       self)
5252         if test "$prev" = dlprefiles; then
5253           dlself=yes
5254         elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5255           dlself=yes
5256         else
5257           dlself=needless
5258           export_dynamic=yes
5259         fi
5260         prev=
5261         continue
5262         ;;
5263       *)
5264         if test "$prev" = dlfiles; then
5265           func_append dlfiles " $arg"
5266         else
5267           func_append dlprefiles " $arg"
5268         fi
5269         prev=
5270         continue
5271         ;;
5272       esac
5273       ;;
5274     expsyms)
5275       export_symbols="$arg"
5276       test -f "$arg" \
5277         || func_fatal_error "symbol file \`$arg' does not exist"
5278       prev=
5279       continue
5280       ;;
5281     expsyms_regex)
5282       export_symbols_regex="$arg"
5283       prev=
5284       continue
5285       ;;
5286     framework)
5287       case $host in
5288         *-*-darwin*)
5289           case "$deplibs " in
5290         *" $qarg.ltframework "*) ;;
5291         *) func_append deplibs " $qarg.ltframework" # this is fixed later
5292            ;;
5293           esac
5294           ;;
5295       esac
5296       prev=
5297       continue
5298       ;;
5299     inst_prefix)
5300       inst_prefix_dir="$arg"
5301       prev=
5302       continue
5303       ;;
5304     objectlist)
5305       if test -f "$arg"; then
5306         save_arg=$arg
5307         moreargs=
5308         for fil in `cat "$save_arg"`
5309         do
5310 #          func_append moreargs " $fil"
5311           arg=$fil
5312           # A libtool-controlled object.
5313
5314           # Check to see that this really is a libtool object.
5315           if func_lalib_unsafe_p "$arg"; then
5316         pic_object=
5317         non_pic_object=
5318
5319         # Read the .lo file
5320         func_source "$arg"
5321
5322         if test -z "$pic_object" ||
5323            test -z "$non_pic_object" ||
5324            test "$pic_object" = none &&
5325            test "$non_pic_object" = none; then
5326           func_fatal_error "cannot find name of object for \`$arg'"
5327         fi
5328
5329         # Extract subdirectory from the argument.
5330         func_dirname "$arg" "/" ""
5331         xdir="$func_dirname_result"
5332
5333         if test "$pic_object" != none; then
5334           # Prepend the subdirectory the object is found in.
5335           pic_object="$xdir$pic_object"
5336
5337           if test "$prev" = dlfiles; then
5338             if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5339               func_append dlfiles " $pic_object"
5340               prev=
5341               continue
5342             else
5343               # If libtool objects are unsupported, then we need to preload.
5344               prev=dlprefiles
5345             fi
5346           fi
5347
5348           # CHECK ME:  I think I busted this.  -Ossama
5349           if test "$prev" = dlprefiles; then
5350             # Preload the old-style object.
5351             func_append dlprefiles " $pic_object"
5352             prev=
5353           fi
5354
5355           # A PIC object.
5356           func_append libobjs " $pic_object"
5357           arg="$pic_object"
5358         fi
5359
5360         # Non-PIC object.
5361         if test "$non_pic_object" != none; then
5362           # Prepend the subdirectory the object is found in.
5363           non_pic_object="$xdir$non_pic_object"
5364
5365           # A standard non-PIC object
5366           func_append non_pic_objects " $non_pic_object"
5367           if test -z "$pic_object" || test "$pic_object" = none ; then
5368             arg="$non_pic_object"
5369           fi
5370         else
5371           # If the PIC object exists, use it instead.
5372           # $xdir was prepended to $pic_object above.
5373           non_pic_object="$pic_object"
5374           func_append non_pic_objects " $non_pic_object"
5375         fi
5376           else
5377         # Only an error if not doing a dry-run.
5378         if $opt_dry_run; then
5379           # Extract subdirectory from the argument.
5380           func_dirname "$arg" "/" ""
5381           xdir="$func_dirname_result"
5382
5383           func_lo2o "$arg"
5384           pic_object=$xdir$objdir/$func_lo2o_result
5385           non_pic_object=$xdir$func_lo2o_result
5386           func_append libobjs " $pic_object"
5387           func_append non_pic_objects " $non_pic_object"
5388             else
5389           func_fatal_error "\`$arg' is not a valid libtool object"
5390         fi
5391           fi
5392         done
5393       else
5394         func_fatal_error "link input file \`$arg' does not exist"
5395       fi
5396       arg=$save_arg
5397       prev=
5398       continue
5399       ;;
5400     precious_regex)
5401       precious_files_regex="$arg"
5402       prev=
5403       continue
5404       ;;
5405     release)
5406       release="-$arg"
5407       prev=
5408       continue
5409       ;;
5410     rpath | xrpath)
5411       # We need an absolute path.
5412       case $arg in
5413       [\\/]* | [A-Za-z]:[\\/]*) ;;
5414       *)
5415         func_fatal_error "only absolute run-paths are allowed"
5416         ;;
5417       esac
5418       if test "$prev" = rpath; then
5419         case "$rpath " in
5420         *" $arg "*) ;;
5421         *) func_append rpath " $arg" ;;
5422         esac
5423       else
5424         case "$xrpath " in
5425         *" $arg "*) ;;
5426         *) func_append xrpath " $arg" ;;
5427         esac
5428       fi
5429       prev=
5430       continue
5431       ;;
5432     shrext)
5433       shrext_cmds="$arg"
5434       prev=
5435       continue
5436       ;;
5437     weak)
5438       func_append weak_libs " $arg"
5439       prev=
5440       continue
5441       ;;
5442     xcclinker)
5443       func_append linker_flags " $qarg"
5444       func_append compiler_flags " $qarg"
5445       prev=
5446       func_append compile_command " $qarg"
5447       func_append finalize_command " $qarg"
5448       continue
5449       ;;
5450     xcompiler)
5451       func_append compiler_flags " $qarg"
5452       prev=
5453       func_append compile_command " $qarg"
5454       func_append finalize_command " $qarg"
5455       continue
5456       ;;
5457     xlinker)
5458       func_append linker_flags " $qarg"
5459       func_append compiler_flags " $wl$qarg"
5460       prev=
5461       func_append compile_command " $wl$qarg"
5462       func_append finalize_command " $wl$qarg"
5463       continue
5464       ;;
5465     *)
5466       eval "$prev=\"\$arg\""
5467       prev=
5468       continue
5469       ;;
5470     esac
5471       fi # test -n "$prev"
5472
5473       prevarg="$arg"
5474
5475       case $arg in
5476       -all-static)
5477     if test -n "$link_static_flag"; then
5478       # See comment for -static flag below, for more details.
5479       func_append compile_command " $link_static_flag"
5480       func_append finalize_command " $link_static_flag"
5481     fi
5482     continue
5483     ;;
5484
5485       -allow-undefined)
5486     # FIXME: remove this flag sometime in the future.
5487     func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5488     ;;
5489
5490       -avoid-version)
5491     avoid_version=yes
5492     continue
5493     ;;
5494
5495       -bindir)
5496     prev=bindir
5497     continue
5498     ;;
5499
5500       -dlopen)
5501     prev=dlfiles
5502     continue
5503     ;;
5504
5505       -dlpreopen)
5506     prev=dlprefiles
5507     continue
5508     ;;
5509
5510       -export-dynamic)
5511     export_dynamic=yes
5512     continue
5513     ;;
5514
5515       -export-symbols | -export-symbols-regex)
5516     if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5517       func_fatal_error "more than one -exported-symbols argument is not allowed"
5518     fi
5519     if test "X$arg" = "X-export-symbols"; then
5520       prev=expsyms
5521     else
5522       prev=expsyms_regex
5523     fi
5524     continue
5525     ;;
5526
5527       -framework)
5528     prev=framework
5529     continue
5530     ;;
5531
5532       -inst-prefix-dir)
5533     prev=inst_prefix
5534     continue
5535     ;;
5536
5537       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5538       # so, if we see these flags be careful not to treat them like -L
5539       -L[A-Z][A-Z]*:*)
5540     case $with_gcc/$host in
5541     no/*-*-irix* | /*-*-irix*)
5542       func_append compile_command " $arg"
5543       func_append finalize_command " $arg"
5544       ;;
5545     esac
5546     continue
5547     ;;
5548
5549       -L*)
5550     func_stripname "-L" '' "$arg"
5551     if test -z "$func_stripname_result"; then
5552       if test "$#" -gt 0; then
5553         func_fatal_error "require no space between \`-L' and \`$1'"
5554       else
5555         func_fatal_error "need path for \`-L' option"
5556       fi
5557     fi
5558     func_resolve_sysroot "$func_stripname_result"
5559     dir=$func_resolve_sysroot_result
5560     # We need an absolute path.
5561     case $dir in
5562     [\\/]* | [A-Za-z]:[\\/]*) ;;
5563     *)
5564       absdir=`cd "$dir" && pwd`
5565       test -z "$absdir" && \
5566         func_fatal_error "cannot determine absolute directory name of \`$dir'"
5567       dir="$absdir"
5568       ;;
5569     esac
5570     case "$deplibs " in
5571     *" -L$dir "* | *" $arg "*)
5572       # Will only happen for absolute or sysroot arguments
5573       ;;
5574     *)
5575       # Preserve sysroot, but never include relative directories
5576       case $dir in
5577         [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5578         *) func_append deplibs " -L$dir" ;;
5579       esac
5580       func_append lib_search_path " $dir"
5581       ;;
5582     esac
5583     case $host in
5584     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5585       testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5586       case :$dllsearchpath: in
5587       *":$dir:"*) ;;
5588       ::) dllsearchpath=$dir;;
5589       *) func_append dllsearchpath ":$dir";;
5590       esac
5591       case :$dllsearchpath: in
5592       *":$testbindir:"*) ;;
5593       ::) dllsearchpath=$testbindir;;
5594       *) func_append dllsearchpath ":$testbindir";;
5595       esac
5596       ;;
5597     esac
5598     continue
5599     ;;
5600
5601       -l*)
5602     if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5603       case $host in
5604       *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5605         # These systems don't actually have a C or math library (as such)
5606         continue
5607         ;;
5608       *-*-os2*)
5609         # These systems don't actually have a C library (as such)
5610         test "X$arg" = "X-lc" && continue
5611         ;;
5612       *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5613         # Do not include libc due to us having libc/libc_r.
5614         test "X$arg" = "X-lc" && continue
5615         ;;
5616       *-*-rhapsody* | *-*-darwin1.[012])
5617         # Rhapsody C and math libraries are in the System framework
5618         func_append deplibs " System.ltframework"
5619         continue
5620         ;;
5621       *-*-sco3.2v5* | *-*-sco5v6*)
5622         # Causes problems with __ctype
5623         test "X$arg" = "X-lc" && continue
5624         ;;
5625       *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5626         # Compiler inserts libc in the correct place for threads to work
5627         test "X$arg" = "X-lc" && continue
5628         ;;
5629       esac
5630     elif test "X$arg" = "X-lc_r"; then
5631      case $host in
5632      *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5633        # Do not include libc_r directly, use -pthread flag.
5634        continue
5635        ;;
5636      esac
5637     fi
5638     func_append deplibs " $arg"
5639     continue
5640     ;;
5641
5642       -module)
5643     module=yes
5644     continue
5645     ;;
5646
5647       # Tru64 UNIX uses -model [arg] to determine the layout of C++
5648       # classes, name mangling, and exception handling.
5649       # Darwin uses the -arch flag to determine output architecture.
5650       -model|-arch|-isysroot|--sysroot)
5651     func_append compiler_flags " $arg"
5652     func_append compile_command " $arg"
5653     func_append finalize_command " $arg"
5654     prev=xcompiler
5655     continue
5656     ;;
5657
5658       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660     func_append compiler_flags " $arg"
5661     func_append compile_command " $arg"
5662     func_append finalize_command " $arg"
5663     case "$new_inherited_linker_flags " in
5664         *" $arg "*) ;;
5665         * ) func_append new_inherited_linker_flags " $arg" ;;
5666     esac
5667     continue
5668     ;;
5669
5670       -multi_module)
5671     single_module="${wl}-multi_module"
5672     continue
5673     ;;
5674
5675       -no-fast-install)
5676     fast_install=no
5677     continue
5678     ;;
5679
5680       -no-install)
5681     case $host in
5682     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5683       # The PATH hackery in wrapper scripts is required on Windows
5684       # and Darwin in order for the loader to find any dlls it needs.
5685       func_warning "\`-no-install' is ignored for $host"
5686       func_warning "assuming \`-no-fast-install' instead"
5687       fast_install=no
5688       ;;
5689     *) no_install=yes ;;
5690     esac
5691     continue
5692     ;;
5693
5694       -no-undefined)
5695     allow_undefined=no
5696     continue
5697     ;;
5698
5699       -objectlist)
5700     prev=objectlist
5701     continue
5702     ;;
5703
5704       -o) prev=output ;;
5705
5706       -precious-files-regex)
5707     prev=precious_regex
5708     continue
5709     ;;
5710
5711       -release)
5712     prev=release
5713     continue
5714     ;;
5715
5716       -rpath)
5717     prev=rpath
5718     continue
5719     ;;
5720
5721       -R)
5722     prev=xrpath
5723     continue
5724     ;;
5725
5726       -R*)
5727     func_stripname '-R' '' "$arg"
5728     dir=$func_stripname_result
5729     # We need an absolute path.
5730     case $dir in
5731     [\\/]* | [A-Za-z]:[\\/]*) ;;
5732     =*)
5733       func_stripname '=' '' "$dir"
5734       dir=$lt_sysroot$func_stripname_result
5735       ;;
5736     *)
5737       func_fatal_error "only absolute run-paths are allowed"
5738       ;;
5739     esac
5740     case "$xrpath " in
5741     *" $dir "*) ;;
5742     *) func_append xrpath " $dir" ;;
5743     esac
5744     continue
5745     ;;
5746
5747       -shared)
5748     # The effects of -shared are defined in a previous loop.
5749     continue
5750     ;;
5751
5752       -shrext)
5753     prev=shrext
5754     continue
5755     ;;
5756
5757       -static | -static-libtool-libs)
5758     # The effects of -static are defined in a previous loop.
5759     # We used to do the same as -all-static on platforms that
5760     # didn't have a PIC flag, but the assumption that the effects
5761     # would be equivalent was wrong.  It would break on at least
5762     # Digital Unix and AIX.
5763     continue
5764     ;;
5765
5766       -thread-safe)
5767     thread_safe=yes
5768     continue
5769     ;;
5770
5771       -version-info)
5772     prev=vinfo
5773     continue
5774     ;;
5775
5776       -version-number)
5777     prev=vinfo
5778     vinfo_number=yes
5779     continue
5780     ;;
5781
5782       -weak)
5783         prev=weak
5784     continue
5785     ;;
5786
5787       -Wc,*)
5788     func_stripname '-Wc,' '' "$arg"
5789     args=$func_stripname_result
5790     arg=
5791     save_ifs="$IFS"; IFS=','
5792     for flag in $args; do
5793       IFS="$save_ifs"
5794           func_quote_for_eval "$flag"
5795       func_append arg " $func_quote_for_eval_result"
5796       func_append compiler_flags " $func_quote_for_eval_result"
5797     done
5798     IFS="$save_ifs"
5799     func_stripname ' ' '' "$arg"
5800     arg=$func_stripname_result
5801     ;;
5802
5803       -Wl,*)
5804     func_stripname '-Wl,' '' "$arg"
5805     args=$func_stripname_result
5806     arg=
5807     save_ifs="$IFS"; IFS=','
5808     for flag in $args; do
5809       IFS="$save_ifs"
5810           func_quote_for_eval "$flag"
5811       func_append arg " $wl$func_quote_for_eval_result"
5812       func_append compiler_flags " $wl$func_quote_for_eval_result"
5813       func_append linker_flags " $func_quote_for_eval_result"
5814     done
5815     IFS="$save_ifs"
5816     func_stripname ' ' '' "$arg"
5817     arg=$func_stripname_result
5818     ;;
5819
5820       -Xcompiler)
5821     prev=xcompiler
5822     continue
5823     ;;
5824
5825       -Xlinker)
5826     prev=xlinker
5827     continue
5828     ;;
5829
5830       -XCClinker)
5831     prev=xcclinker
5832     continue
5833     ;;
5834
5835       # -msg_* for osf cc
5836       -msg_*)
5837     func_quote_for_eval "$arg"
5838     arg="$func_quote_for_eval_result"
5839     ;;
5840
5841       # Flags to be passed through unchanged, with rationale:
5842       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
5843       # -r[0-9][0-9]*        specify processor for the SGI compiler
5844       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5845       # +DA*, +DD*           enable 64-bit mode for the HP compiler
5846       # -q*                  compiler args for the IBM compiler
5847       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5848       # -F/path              path to uninstalled frameworks, gcc on darwin
5849       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
5850       # @file                GCC response files
5851       # -tp=*                Portland pgcc target processor selection
5852       # --sysroot=*          for sysroot support
5853       # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5854       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5855       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856       -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5857         func_quote_for_eval "$arg"
5858     arg="$func_quote_for_eval_result"
5859         func_append compile_command " $arg"
5860         func_append finalize_command " $arg"
5861         func_append compiler_flags " $arg"
5862         continue
5863         ;;
5864
5865       # Some other compiler flag.
5866       -* | +*)
5867         func_quote_for_eval "$arg"
5868     arg="$func_quote_for_eval_result"
5869     ;;
5870
5871       *.$objext)
5872     # A standard object.
5873     func_append objs " $arg"
5874     ;;
5875
5876       *.lo)
5877     # A libtool-controlled object.
5878
5879     # Check to see that this really is a libtool object.
5880     if func_lalib_unsafe_p "$arg"; then
5881       pic_object=
5882       non_pic_object=
5883
5884       # Read the .lo file
5885       func_source "$arg"
5886
5887       if test -z "$pic_object" ||
5888          test -z "$non_pic_object" ||
5889          test "$pic_object" = none &&
5890          test "$non_pic_object" = none; then
5891         func_fatal_error "cannot find name of object for \`$arg'"
5892       fi
5893
5894       # Extract subdirectory from the argument.
5895       func_dirname "$arg" "/" ""
5896       xdir="$func_dirname_result"
5897
5898       if test "$pic_object" != none; then
5899         # Prepend the subdirectory the object is found in.
5900         pic_object="$xdir$pic_object"
5901
5902         if test "$prev" = dlfiles; then
5903           if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5904         func_append dlfiles " $pic_object"
5905         prev=
5906         continue
5907           else
5908         # If libtool objects are unsupported, then we need to preload.
5909         prev=dlprefiles
5910           fi
5911         fi
5912
5913         # CHECK ME:  I think I busted this.  -Ossama
5914         if test "$prev" = dlprefiles; then
5915           # Preload the old-style object.
5916           func_append dlprefiles " $pic_object"
5917           prev=
5918         fi
5919
5920         # A PIC object.
5921         func_append libobjs " $pic_object"
5922         arg="$pic_object"
5923       fi
5924
5925       # Non-PIC object.
5926       if test "$non_pic_object" != none; then
5927         # Prepend the subdirectory the object is found in.
5928         non_pic_object="$xdir$non_pic_object"
5929
5930         # A standard non-PIC object
5931         func_append non_pic_objects " $non_pic_object"
5932         if test -z "$pic_object" || test "$pic_object" = none ; then
5933           arg="$non_pic_object"
5934         fi
5935       else
5936         # If the PIC object exists, use it instead.
5937         # $xdir was prepended to $pic_object above.
5938         non_pic_object="$pic_object"
5939         func_append non_pic_objects " $non_pic_object"
5940       fi
5941     else
5942       # Only an error if not doing a dry-run.
5943       if $opt_dry_run; then
5944         # Extract subdirectory from the argument.
5945         func_dirname "$arg" "/" ""
5946         xdir="$func_dirname_result"
5947
5948         func_lo2o "$arg"
5949         pic_object=$xdir$objdir/$func_lo2o_result
5950         non_pic_object=$xdir$func_lo2o_result
5951         func_append libobjs " $pic_object"
5952         func_append non_pic_objects " $non_pic_object"
5953       else
5954         func_fatal_error "\`$arg' is not a valid libtool object"
5955       fi
5956     fi
5957     ;;
5958
5959       *.$libext)
5960     # An archive.
5961     func_append deplibs " $arg"
5962     func_append old_deplibs " $arg"
5963     continue
5964     ;;
5965
5966       *.la)
5967     # A libtool-controlled library.
5968
5969     func_resolve_sysroot "$arg"
5970     if test "$prev" = dlfiles; then
5971       # This library was specified with -dlopen.
5972       func_append dlfiles " $func_resolve_sysroot_result"
5973       prev=
5974     elif test "$prev" = dlprefiles; then
5975       # The library was specified with -dlpreopen.
5976       func_append dlprefiles " $func_resolve_sysroot_result"
5977       prev=
5978     else
5979       func_append deplibs " $func_resolve_sysroot_result"
5980     fi
5981     continue
5982     ;;
5983
5984       # Some other compiler argument.
5985       *)
5986     # Unknown arguments in both finalize_command and compile_command need
5987     # to be aesthetically quoted because they are evaled later.
5988     func_quote_for_eval "$arg"
5989     arg="$func_quote_for_eval_result"
5990     ;;
5991       esac # arg
5992
5993       # Now actually substitute the argument into the commands.
5994       if test -n "$arg"; then
5995     func_append compile_command " $arg"
5996     func_append finalize_command " $arg"
5997       fi
5998     done # argument parsing loop
5999
6000     test -n "$prev" && \
6001       func_fatal_help "the \`$prevarg' option requires an argument"
6002
6003     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6004       eval arg=\"$export_dynamic_flag_spec\"
6005       func_append compile_command " $arg"
6006       func_append finalize_command " $arg"
6007     fi
6008
6009     oldlibs=
6010     # calculate the name of the file, without its directory
6011     func_basename "$output"
6012     outputname="$func_basename_result"
6013     libobjs_save="$libobjs"
6014
6015     if test -n "$shlibpath_var"; then
6016       # get the directories listed in $shlibpath_var
6017       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6018     else
6019       shlib_search_path=
6020     fi
6021     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6022     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6023
6024     func_dirname "$output" "/" ""
6025     output_objdir="$func_dirname_result$objdir"
6026     func_to_tool_file "$output_objdir/"
6027     tool_output_objdir=$func_to_tool_file_result
6028     # Create the object directory.
6029     func_mkdir_p "$output_objdir"
6030
6031     # Determine the type of output
6032     case $output in
6033     "")
6034       func_fatal_help "you must specify an output file"
6035       ;;
6036     *.$libext) linkmode=oldlib ;;
6037     *.lo | *.$objext) linkmode=obj ;;
6038     *.la) linkmode=lib ;;
6039     *) linkmode=prog ;; # Anything else should be a program.
6040     esac
6041
6042     specialdeplibs=
6043
6044     libs=
6045     # Find all interdependent deplibs by searching for libraries
6046     # that are linked more than once (e.g. -la -lb -la)
6047     for deplib in $deplibs; do
6048       if $opt_preserve_dup_deps ; then
6049     case "$libs " in
6050     *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6051     esac
6052       fi
6053       func_append libs " $deplib"
6054     done
6055
6056     if test "$linkmode" = lib; then
6057       libs="$predeps $libs $compiler_lib_search_path $postdeps"
6058
6059       # Compute libraries that are listed more than once in $predeps
6060       # $postdeps and mark them as special (i.e., whose duplicates are
6061       # not to be eliminated).
6062       pre_post_deps=
6063       if $opt_duplicate_compiler_generated_deps; then
6064     for pre_post_dep in $predeps $postdeps; do
6065       case "$pre_post_deps " in
6066       *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6067       esac
6068       func_append pre_post_deps " $pre_post_dep"
6069     done
6070       fi
6071       pre_post_deps=
6072     fi
6073
6074     deplibs=
6075     newdependency_libs=
6076     newlib_search_path=
6077     need_relink=no # whether we're linking any uninstalled libtool libraries
6078     notinst_deplibs= # not-installed libtool libraries
6079     notinst_path= # paths that contain not-installed libtool libraries
6080
6081     case $linkmode in
6082     lib)
6083     passes="conv dlpreopen link"
6084     for file in $dlfiles $dlprefiles; do
6085       case $file in
6086       *.la) ;;
6087       *)
6088         func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6089         ;;
6090       esac
6091     done
6092     ;;
6093     prog)
6094     compile_deplibs=
6095     finalize_deplibs=
6096     alldeplibs=no
6097     newdlfiles=
6098     newdlprefiles=
6099     passes="conv scan dlopen dlpreopen link"
6100     ;;
6101     *)  passes="conv"
6102     ;;
6103     esac
6104
6105     for pass in $passes; do
6106       # The preopen pass in lib mode reverses $deplibs; put it back here
6107       # so that -L comes before libs that need it for instance...
6108       if test "$linkmode,$pass" = "lib,link"; then
6109     ## FIXME: Find the place where the list is rebuilt in the wrong
6110     ##        order, and fix it there properly
6111         tmp_deplibs=
6112     for deplib in $deplibs; do
6113       tmp_deplibs="$deplib $tmp_deplibs"
6114     done
6115     deplibs="$tmp_deplibs"
6116       fi
6117
6118       if test "$linkmode,$pass" = "lib,link" ||
6119      test "$linkmode,$pass" = "prog,scan"; then
6120     libs="$deplibs"
6121     deplibs=
6122       fi
6123       if test "$linkmode" = prog; then
6124     case $pass in
6125     dlopen) libs="$dlfiles" ;;
6126     dlpreopen) libs="$dlprefiles" ;;
6127     link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6128     esac
6129       fi
6130       if test "$linkmode,$pass" = "lib,dlpreopen"; then
6131     # Collect and forward deplibs of preopened libtool libs
6132     for lib in $dlprefiles; do
6133       # Ignore non-libtool-libs
6134       dependency_libs=
6135       func_resolve_sysroot "$lib"
6136       case $lib in
6137       *.la)    func_source "$func_resolve_sysroot_result" ;;
6138       esac
6139
6140       # Collect preopened libtool deplibs, except any this library
6141       # has declared as weak libs
6142       for deplib in $dependency_libs; do
6143         func_basename "$deplib"
6144             deplib_base=$func_basename_result
6145         case " $weak_libs " in
6146         *" $deplib_base "*) ;;
6147         *) func_append deplibs " $deplib" ;;
6148         esac
6149       done
6150     done
6151     libs="$dlprefiles"
6152       fi
6153       if test "$pass" = dlopen; then
6154     # Collect dlpreopened libraries
6155     save_deplibs="$deplibs"
6156     deplibs=
6157       fi
6158
6159       for deplib in $libs; do
6160     lib=
6161     found=no
6162     case $deplib in
6163     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6164         |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6165       if test "$linkmode,$pass" = "prog,link"; then
6166         compile_deplibs="$deplib $compile_deplibs"
6167         finalize_deplibs="$deplib $finalize_deplibs"
6168       else
6169         func_append compiler_flags " $deplib"
6170         if test "$linkmode" = lib ; then
6171         case "$new_inherited_linker_flags " in
6172             *" $deplib "*) ;;
6173             * ) func_append new_inherited_linker_flags " $deplib" ;;
6174         esac
6175         fi
6176       fi
6177       continue
6178       ;;
6179     -l*)
6180       if test "$linkmode" != lib && test "$linkmode" != prog; then
6181         func_warning "\`-l' is ignored for archives/objects"
6182         continue
6183       fi
6184       func_stripname '-l' '' "$deplib"
6185       name=$func_stripname_result
6186       if test "$linkmode" = lib; then
6187         searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6188       else
6189         searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6190       fi
6191       for searchdir in $searchdirs; do
6192         for search_ext in .la $std_shrext .so .a; do
6193           # Search the libtool library
6194           lib="$searchdir/lib${name}${search_ext}"
6195           if test -f "$lib"; then
6196         if test "$search_ext" = ".la"; then
6197           found=yes
6198         else
6199           found=no
6200         fi
6201         break 2
6202           fi
6203         done
6204       done
6205       if test "$found" != yes; then
6206         # deplib doesn't seem to be a libtool library
6207         if test "$linkmode,$pass" = "prog,link"; then
6208           compile_deplibs="$deplib $compile_deplibs"
6209           finalize_deplibs="$deplib $finalize_deplibs"
6210         else
6211           deplibs="$deplib $deplibs"
6212           test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6213         fi
6214         continue
6215       else # deplib is a libtool library
6216         # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6217         # We need to do some special things here, and not later.
6218         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6219           case " $predeps $postdeps " in
6220           *" $deplib "*)
6221         if func_lalib_p "$lib"; then
6222           library_names=
6223           old_library=
6224           func_source "$lib"
6225           for l in $old_library $library_names; do
6226             ll="$l"
6227           done
6228           if test "X$ll" = "X$old_library" ; then # only static version available
6229             found=no
6230             func_dirname "$lib" "" "."
6231             ladir="$func_dirname_result"
6232             lib=$ladir/$old_library
6233             if test "$linkmode,$pass" = "prog,link"; then
6234               compile_deplibs="$deplib $compile_deplibs"
6235               finalize_deplibs="$deplib $finalize_deplibs"
6236             else
6237               deplibs="$deplib $deplibs"
6238               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6239             fi
6240             continue
6241           fi
6242         fi
6243         ;;
6244           *) ;;
6245           esac
6246         fi
6247       fi
6248       ;; # -l
6249     *.ltframework)
6250       if test "$linkmode,$pass" = "prog,link"; then
6251         compile_deplibs="$deplib $compile_deplibs"
6252         finalize_deplibs="$deplib $finalize_deplibs"
6253       else
6254         deplibs="$deplib $deplibs"
6255         if test "$linkmode" = lib ; then
6256         case "$new_inherited_linker_flags " in
6257             *" $deplib "*) ;;
6258             * ) func_append new_inherited_linker_flags " $deplib" ;;
6259         esac
6260         fi
6261       fi
6262       continue
6263       ;;
6264     -L*)
6265       case $linkmode in
6266       lib)
6267         deplibs="$deplib $deplibs"
6268         test "$pass" = conv && continue
6269         newdependency_libs="$deplib $newdependency_libs"
6270         func_stripname '-L' '' "$deplib"
6271         func_resolve_sysroot "$func_stripname_result"
6272         func_append newlib_search_path " $func_resolve_sysroot_result"
6273         ;;
6274       prog)
6275         if test "$pass" = conv; then
6276           deplibs="$deplib $deplibs"
6277           continue
6278         fi
6279         if test "$pass" = scan; then
6280           deplibs="$deplib $deplibs"
6281         else
6282           compile_deplibs="$deplib $compile_deplibs"
6283           finalize_deplibs="$deplib $finalize_deplibs"
6284         fi
6285         func_stripname '-L' '' "$deplib"
6286         func_resolve_sysroot "$func_stripname_result"
6287         func_append newlib_search_path " $func_resolve_sysroot_result"
6288         ;;
6289       *)
6290         func_warning "\`-L' is ignored for archives/objects"
6291         ;;
6292       esac # linkmode
6293       continue
6294       ;; # -L
6295     -R*)
6296       if test "$pass" = link; then
6297         func_stripname '-R' '' "$deplib"
6298         func_resolve_sysroot "$func_stripname_result"
6299         dir=$func_resolve_sysroot_result
6300         # Make sure the xrpath contains only unique directories.
6301         case "$xrpath " in
6302         *" $dir "*) ;;
6303         *) func_append xrpath " $dir" ;;
6304         esac
6305       fi
6306       deplibs="$deplib $deplibs"
6307       continue
6308       ;;
6309     *.la)
6310       func_resolve_sysroot "$deplib"
6311       lib=$func_resolve_sysroot_result
6312       ;;
6313     *.$libext)
6314       if test "$pass" = conv; then
6315         deplibs="$deplib $deplibs"
6316         continue
6317       fi
6318       case $linkmode in
6319       lib)
6320         # Linking convenience modules into shared libraries is allowed,
6321         # but linking other static libraries is non-portable.
6322         case " $dlpreconveniencelibs " in
6323         *" $deplib "*) ;;
6324         *)
6325           valid_a_lib=no
6326           case $deplibs_check_method in
6327         match_pattern*)
6328           set dummy $deplibs_check_method; shift
6329           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6330           if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6331             | $EGREP "$match_pattern_regex" > /dev/null; then
6332             valid_a_lib=yes
6333           fi
6334         ;;
6335         pass_all)
6336           valid_a_lib=yes
6337         ;;
6338           esac
6339           if test "$valid_a_lib" != yes; then
6340         echo
6341         $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6342         echo "*** I have the capability to make that library automatically link in when"
6343         echo "*** you link to this library.  But I can only do this if you have a"
6344         echo "*** shared version of the library, which you do not appear to have"
6345         echo "*** because the file extensions .$libext of this argument makes me believe"
6346         echo "*** that it is just a static archive that I should not use here."
6347           else
6348         echo
6349         $ECHO "*** Warning: Linking the shared library $output against the"
6350         $ECHO "*** static library $deplib is not portable!"
6351         deplibs="$deplib $deplibs"
6352           fi
6353           ;;
6354         esac
6355         continue
6356         ;;
6357       prog)
6358         if test "$pass" != link; then
6359           deplibs="$deplib $deplibs"
6360         else
6361           compile_deplibs="$deplib $compile_deplibs"
6362           finalize_deplibs="$deplib $finalize_deplibs"
6363         fi
6364         continue
6365         ;;
6366       esac # linkmode
6367       ;; # *.$libext
6368     *.lo | *.$objext)
6369       if test "$pass" = conv; then
6370         deplibs="$deplib $deplibs"
6371       elif test "$linkmode" = prog; then
6372         if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6373           # If there is no dlopen support or we're linking statically,
6374           # we need to preload.
6375           func_append newdlprefiles " $deplib"
6376           compile_deplibs="$deplib $compile_deplibs"
6377           finalize_deplibs="$deplib $finalize_deplibs"
6378         else
6379           func_append newdlfiles " $deplib"
6380         fi
6381       fi
6382       continue
6383       ;;
6384     %DEPLIBS%)
6385       alldeplibs=yes
6386       continue
6387       ;;
6388     esac # case $deplib
6389
6390     if test "$found" = yes || test -f "$lib"; then :
6391     else
6392       func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6393     fi
6394
6395     # Check to see that this really is a libtool archive.
6396     func_lalib_unsafe_p "$lib" \
6397       || func_fatal_error "\`$lib' is not a valid libtool archive"
6398
6399     func_dirname "$lib" "" "."
6400     ladir="$func_dirname_result"
6401
6402     dlname=
6403     dlopen=
6404     dlpreopen=
6405     libdir=
6406     library_names=
6407     old_library=
6408     inherited_linker_flags=
6409     # If the library was installed with an old release of libtool,
6410     # it will not redefine variables installed, or shouldnotlink
6411     installed=yes
6412     shouldnotlink=no
6413     avoidtemprpath=
6414
6415
6416     # Read the .la file
6417     func_source "$lib"
6418
6419     # Convert "-framework foo" to "foo.ltframework"
6420     if test -n "$inherited_linker_flags"; then
6421       tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6422       for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6423         case " $new_inherited_linker_flags " in
6424           *" $tmp_inherited_linker_flag "*) ;;
6425           *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6426         esac
6427       done
6428     fi
6429     dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6430     if test "$linkmode,$pass" = "lib,link" ||
6431        test "$linkmode,$pass" = "prog,scan" ||
6432        { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6433       test -n "$dlopen" && func_append dlfiles " $dlopen"
6434       test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6435     fi
6436
6437     if test "$pass" = conv; then
6438       # Only check for convenience libraries
6439       deplibs="$lib $deplibs"
6440       if test -z "$libdir"; then
6441         if test -z "$old_library"; then
6442           func_fatal_error "cannot find name of link library for \`$lib'"
6443         fi
6444         # It is a libtool convenience library, so add in its objects.
6445         func_append convenience " $ladir/$objdir/$old_library"
6446         func_append old_convenience " $ladir/$objdir/$old_library"
6447       elif test "$linkmode" != prog && test "$linkmode" != lib; then
6448         func_fatal_error "\`$lib' is not a convenience library"
6449       fi
6450       tmp_libs=
6451       for deplib in $dependency_libs; do
6452         deplibs="$deplib $deplibs"
6453         if $opt_preserve_dup_deps ; then
6454           case "$tmp_libs " in
6455           *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6456           esac
6457         fi
6458         func_append tmp_libs " $deplib"
6459       done
6460       continue
6461     fi # $pass = conv
6462
6463
6464     # Get the name of the library we link against.
6465     linklib=
6466     if test -n "$old_library" &&
6467        { test "$prefer_static_libs" = yes ||
6468          test "$prefer_static_libs,$installed" = "built,no"; }; then
6469       linklib=$old_library
6470     else
6471       for l in $old_library $library_names; do
6472         linklib="$l"
6473       done
6474     fi
6475     if test -z "$linklib"; then
6476       func_fatal_error "cannot find name of link library for \`$lib'"
6477     fi
6478
6479     # This library was specified with -dlopen.
6480     if test "$pass" = dlopen; then
6481       if test -z "$libdir"; then
6482         func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6483       fi
6484       if test -z "$dlname" ||
6485          test "$dlopen_support" != yes ||
6486          test "$build_libtool_libs" = no; then
6487         # If there is no dlname, no dlopen support or we're linking
6488         # statically, we need to preload.  We also need to preload any
6489         # dependent libraries so libltdl's deplib preloader doesn't
6490         # bomb out in the load deplibs phase.
6491         func_append dlprefiles " $lib $dependency_libs"
6492       else
6493         func_append newdlfiles " $lib"
6494       fi
6495       continue
6496     fi # $pass = dlopen
6497
6498     # We need an absolute path.
6499     case $ladir in
6500     [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6501     *)
6502       abs_ladir=`cd "$ladir" && pwd`
6503       if test -z "$abs_ladir"; then
6504         func_warning "cannot determine absolute directory name of \`$ladir'"
6505         func_warning "passing it literally to the linker, although it might fail"
6506         abs_ladir="$ladir"
6507       fi
6508       ;;
6509     esac
6510     func_basename "$lib"
6511     laname="$func_basename_result"
6512
6513     # Find the relevant object directory and library name.
6514     if test "X$installed" = Xyes; then
6515       if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6516         func_warning "library \`$lib' was moved."
6517         dir="$ladir"
6518         absdir="$abs_ladir"
6519         libdir="$abs_ladir"
6520       else
6521         dir="$lt_sysroot$libdir"
6522         absdir="$lt_sysroot$libdir"
6523       fi
6524       test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6525     else
6526       if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6527         dir="$ladir"
6528         absdir="$abs_ladir"
6529         # Remove this search path later
6530         func_append notinst_path " $abs_ladir"
6531       else
6532         dir="$ladir/$objdir"
6533         absdir="$abs_ladir/$objdir"
6534         # Remove this search path later
6535         func_append notinst_path " $abs_ladir"
6536       fi
6537     fi # $installed = yes
6538     func_stripname 'lib' '.la' "$laname"
6539     name=$func_stripname_result
6540
6541     # This library was specified with -dlpreopen.
6542     if test "$pass" = dlpreopen; then
6543       if test -z "$libdir" && test "$linkmode" = prog; then
6544         func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6545       fi
6546       case "$host" in
6547         # special handling for platforms with PE-DLLs.
6548         *cygwin* | *mingw* | *cegcc* )
6549           # Linker will automatically link against shared library if both
6550           # static and shared are present.  Therefore, ensure we extract
6551           # symbols from the import library if a shared library is present
6552           # (otherwise, the dlopen module name will be incorrect).  We do
6553           # this by putting the import library name into $newdlprefiles.
6554           # We recover the dlopen module name by 'saving' the la file
6555           # name in a special purpose variable, and (later) extracting the
6556           # dlname from the la file.
6557           if test -n "$dlname"; then
6558             func_tr_sh "$dir/$linklib"
6559             eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6560             func_append newdlprefiles " $dir/$linklib"
6561           else
6562             func_append newdlprefiles " $dir/$old_library"
6563             # Keep a list of preopened convenience libraries to check
6564             # that they are being used correctly in the link pass.
6565             test -z "$libdir" && \
6566               func_append dlpreconveniencelibs " $dir/$old_library"
6567           fi
6568         ;;
6569         * )
6570           # Prefer using a static library (so that no silly _DYNAMIC symbols
6571           # are required to link).
6572           if test -n "$old_library"; then
6573             func_append newdlprefiles " $dir/$old_library"
6574             # Keep a list of preopened convenience libraries to check
6575             # that they are being used correctly in the link pass.
6576             test -z "$libdir" && \
6577               func_append dlpreconveniencelibs " $dir/$old_library"
6578           # Otherwise, use the dlname, so that lt_dlopen finds it.
6579           elif test -n "$dlname"; then
6580             func_append newdlprefiles " $dir/$dlname"
6581           else
6582             func_append newdlprefiles " $dir/$linklib"
6583           fi
6584         ;;
6585       esac
6586     fi # $pass = dlpreopen
6587
6588     if test -z "$libdir"; then
6589       # Link the convenience library
6590       if test "$linkmode" = lib; then
6591         deplibs="$dir/$old_library $deplibs"
6592       elif test "$linkmode,$pass" = "prog,link"; then
6593         compile_deplibs="$dir/$old_library $compile_deplibs"
6594         finalize_deplibs="$dir/$old_library $finalize_deplibs"
6595       else
6596         deplibs="$lib $deplibs" # used for prog,scan pass
6597       fi
6598       continue
6599     fi
6600
6601
6602     if test "$linkmode" = prog && test "$pass" != link; then
6603       func_append newlib_search_path " $ladir"
6604       deplibs="$lib $deplibs"
6605
6606       linkalldeplibs=no
6607       if test "$link_all_deplibs" != no || test -z "$library_names" ||
6608          test "$build_libtool_libs" = no; then
6609         linkalldeplibs=yes
6610       fi
6611
6612       tmp_libs=
6613       for deplib in $dependency_libs; do
6614         case $deplib in
6615         -L*) func_stripname '-L' '' "$deplib"
6616              func_resolve_sysroot "$func_stripname_result"
6617              func_append newlib_search_path " $func_resolve_sysroot_result"
6618          ;;
6619         esac
6620         # Need to link against all dependency_libs?
6621         if test "$linkalldeplibs" = yes; then
6622           deplibs="$deplib $deplibs"
6623         else
6624           # Need to hardcode shared library paths
6625           # or/and link against static libraries
6626           newdependency_libs="$deplib $newdependency_libs"
6627         fi
6628         if $opt_preserve_dup_deps ; then
6629           case "$tmp_libs " in
6630           *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6631           esac
6632         fi
6633         func_append tmp_libs " $deplib"
6634       done # for deplib
6635       continue
6636     fi # $linkmode = prog...
6637
6638     if test "$linkmode,$pass" = "prog,link"; then
6639       if test -n "$library_names" &&
6640          { { test "$prefer_static_libs" = no ||
6641              test "$prefer_static_libs,$installed" = "built,yes"; } ||
6642            test -z "$old_library"; }; then
6643         # We need to hardcode the library path
6644         if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6645           # Make sure the rpath contains only unique directories.
6646           case "$temp_rpath:" in
6647           *"$absdir:"*) ;;
6648           *) func_append temp_rpath "$absdir:" ;;
6649           esac
6650         fi
6651
6652         # Hardcode the library path.
6653         # Skip directories that are in the system default run-time
6654         # search path.
6655         case " $sys_lib_dlsearch_path " in
6656         *" $absdir "*) ;;
6657         *)
6658           case "$compile_rpath " in
6659           *" $absdir "*) ;;
6660           *) func_append compile_rpath " $absdir" ;;
6661           esac
6662           ;;
6663         esac
6664         case " $sys_lib_dlsearch_path " in
6665         *" $libdir "*) ;;
6666         *)
6667           case "$finalize_rpath " in
6668           *" $libdir "*) ;;
6669           *) func_append finalize_rpath " $libdir" ;;
6670           esac
6671           ;;
6672         esac
6673       fi # $linkmode,$pass = prog,link...
6674
6675       if test "$alldeplibs" = yes &&
6676          { test "$deplibs_check_method" = pass_all ||
6677            { test "$build_libtool_libs" = yes &&
6678          test -n "$library_names"; }; }; then
6679         # We only need to search for static libraries
6680         continue
6681       fi
6682     fi
6683
6684     link_static=no # Whether the deplib will be linked statically
6685     use_static_libs=$prefer_static_libs
6686     if test "$use_static_libs" = built && test "$installed" = yes; then
6687       use_static_libs=no
6688     fi
6689     if test -n "$library_names" &&
6690        { test "$use_static_libs" = no || test -z "$old_library"; }; then
6691       case $host in
6692       *cygwin* | *mingw* | *cegcc*)
6693           # No point in relinking DLLs because paths are not encoded
6694           func_append notinst_deplibs " $lib"
6695           need_relink=no
6696         ;;
6697       *)
6698         if test "$installed" = no; then
6699           func_append notinst_deplibs " $lib"
6700           need_relink=yes
6701         fi
6702         ;;
6703       esac
6704       # This is a shared library
6705
6706       # Warn about portability, can't link against -module's on some
6707       # systems (darwin).  Don't bleat about dlopened modules though!
6708       dlopenmodule=""
6709       for dlpremoduletest in $dlprefiles; do
6710         if test "X$dlpremoduletest" = "X$lib"; then
6711           dlopenmodule="$dlpremoduletest"
6712           break
6713         fi
6714       done
6715       if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6716         echo
6717         if test "$linkmode" = prog; then
6718           $ECHO "*** Warning: Linking the executable $output against the loadable module"
6719         else
6720           $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6721         fi
6722         $ECHO "*** $linklib is not portable!"
6723       fi
6724       if test "$linkmode" = lib &&
6725          test "$hardcode_into_libs" = yes; then
6726         # Hardcode the library path.
6727         # Skip directories that are in the system default run-time
6728         # search path.
6729         case " $sys_lib_dlsearch_path " in
6730         *" $absdir "*) ;;
6731         *)
6732           case "$compile_rpath " in
6733           *" $absdir "*) ;;
6734           *) func_append compile_rpath " $absdir" ;;
6735           esac
6736           ;;
6737         esac
6738         case " $sys_lib_dlsearch_path " in
6739         *" $libdir "*) ;;
6740         *)
6741           case "$finalize_rpath " in
6742           *" $libdir "*) ;;
6743           *) func_append finalize_rpath " $libdir" ;;
6744           esac
6745           ;;
6746         esac
6747       fi
6748
6749       if test -n "$old_archive_from_expsyms_cmds"; then
6750         # figure out the soname
6751         set dummy $library_names
6752         shift
6753         realname="$1"
6754         shift
6755         libname=`eval "\\$ECHO \"$libname_spec\""`
6756         # use dlname if we got it. it's perfectly good, no?
6757         if test -n "$dlname"; then
6758           soname="$dlname"
6759         elif test -n "$soname_spec"; then
6760           # bleh windows
6761           case $host in
6762           *cygwin* | mingw* | *cegcc*)
6763             func_arith $current - $age
6764         major=$func_arith_result
6765         versuffix="-$major"
6766         ;;
6767           esac
6768           eval soname=\"$soname_spec\"
6769         else
6770           soname="$realname"
6771         fi
6772
6773         # Make a new name for the extract_expsyms_cmds to use
6774         soroot="$soname"
6775         func_basename "$soroot"
6776         soname="$func_basename_result"
6777         func_stripname 'lib' '.dll' "$soname"
6778         newlib=libimp-$func_stripname_result.a
6779
6780         # If the library has no export list, then create one now
6781         if test -f "$output_objdir/$soname-def"; then :
6782         else
6783           func_verbose "extracting exported symbol list from \`$soname'"
6784           func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6785         fi
6786
6787         # Create $newlib
6788         if test -f "$output_objdir/$newlib"; then :; else
6789           func_verbose "generating import library for \`$soname'"
6790           func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6791         fi
6792         # make sure the library variables are pointing to the new library
6793         dir=$output_objdir
6794         linklib=$newlib
6795       fi # test -n "$old_archive_from_expsyms_cmds"
6796
6797       if test "$linkmode" = prog || test "$opt_mode" != relink; then
6798         add_shlibpath=
6799         add_dir=
6800         add=
6801         lib_linked=yes
6802         case $hardcode_action in
6803         immediate | unsupported)
6804           if test "$hardcode_direct" = no; then
6805         add="$dir/$linklib"
6806         case $host in
6807           *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6808           *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6809           *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6810             *-*-unixware7*) add_dir="-L$dir" ;;
6811           *-*-darwin* )
6812             # if the lib is a (non-dlopened) module then we can not
6813             # link against it, someone is ignoring the earlier warnings
6814             if /usr/bin/file -L $add 2> /dev/null |
6815              $GREP ": [^:]* bundle" >/dev/null ; then
6816               if test "X$dlopenmodule" != "X$lib"; then
6817             $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6818             if test -z "$old_library" ; then
6819               echo
6820               echo "*** And there doesn't seem to be a static archive available"
6821               echo "*** The link will probably fail, sorry"
6822             else
6823               add="$dir/$old_library"
6824             fi
6825               elif test -n "$old_library"; then
6826             add="$dir/$old_library"
6827               fi
6828             fi
6829         esac
6830           elif test "$hardcode_minus_L" = no; then
6831         case $host in
6832         *-*-sunos*) add_shlibpath="$dir" ;;
6833         esac
6834         add_dir="-L$dir"
6835         add="-l$name"
6836           elif test "$hardcode_shlibpath_var" = no; then
6837         add_shlibpath="$dir"
6838         add="-l$name"
6839           else
6840         lib_linked=no
6841           fi
6842           ;;
6843         relink)
6844           if test "$hardcode_direct" = yes &&
6845              test "$hardcode_direct_absolute" = no; then
6846         add="$dir/$linklib"
6847           elif test "$hardcode_minus_L" = yes; then
6848         add_dir="-L$absdir"
6849         # Try looking first in the location we're being installed to.
6850         if test -n "$inst_prefix_dir"; then
6851           case $libdir in
6852             [\\/]*)
6853               func_append add_dir " -L$inst_prefix_dir$libdir"
6854               ;;
6855           esac
6856         fi
6857         add="-l$name"
6858           elif test "$hardcode_shlibpath_var" = yes; then
6859         add_shlibpath="$dir"
6860         add="-l$name"
6861           else
6862         lib_linked=no
6863           fi
6864           ;;
6865         *) lib_linked=no ;;
6866         esac
6867
6868         if test "$lib_linked" != yes; then
6869           func_fatal_configuration "unsupported hardcode properties"
6870         fi
6871
6872         if test -n "$add_shlibpath"; then
6873           case :$compile_shlibpath: in
6874           *":$add_shlibpath:"*) ;;
6875           *) func_append compile_shlibpath "$add_shlibpath:" ;;
6876           esac
6877         fi
6878         if test "$linkmode" = prog; then
6879           test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6880           test -n "$add" && compile_deplibs="$add $compile_deplibs"
6881         else
6882           test -n "$add_dir" && deplibs="$add_dir $deplibs"
6883           test -n "$add" && deplibs="$add $deplibs"
6884           if test "$hardcode_direct" != yes &&
6885          test "$hardcode_minus_L" != yes &&
6886          test "$hardcode_shlibpath_var" = yes; then
6887         case :$finalize_shlibpath: in
6888         *":$libdir:"*) ;;
6889         *) func_append finalize_shlibpath "$libdir:" ;;
6890         esac
6891           fi
6892         fi
6893       fi
6894
6895       if test "$linkmode" = prog || test "$opt_mode" = relink; then
6896         add_shlibpath=
6897         add_dir=
6898         add=
6899         # Finalize command for both is simple: just hardcode it.
6900         if test "$hardcode_direct" = yes &&
6901            test "$hardcode_direct_absolute" = no; then
6902           add="$libdir/$linklib"
6903         elif test "$hardcode_minus_L" = yes; then
6904           add_dir="-L$libdir"
6905           add="-l$name"
6906         elif test "$hardcode_shlibpath_var" = yes; then
6907           case :$finalize_shlibpath: in
6908           *":$libdir:"*) ;;
6909           *) func_append finalize_shlibpath "$libdir:" ;;
6910           esac
6911           add="-l$name"
6912         elif test "$hardcode_automatic" = yes; then
6913           if test -n "$inst_prefix_dir" &&
6914          test -f "$inst_prefix_dir$libdir/$linklib" ; then
6915         add="$inst_prefix_dir$libdir/$linklib"
6916           else
6917         add="$libdir/$linklib"
6918           fi
6919         else
6920           # We cannot seem to hardcode it, guess we'll fake it.
6921           add_dir="-L$libdir"
6922           # Try looking first in the location we're being installed to.
6923           if test -n "$inst_prefix_dir"; then
6924         case $libdir in
6925           [\\/]*)
6926             func_append add_dir " -L$inst_prefix_dir$libdir"
6927             ;;
6928         esac
6929           fi
6930           add="-l$name"
6931         fi
6932
6933         if test "$linkmode" = prog; then
6934           test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6935           test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6936         else
6937           test -n "$add_dir" && deplibs="$add_dir $deplibs"
6938           test -n "$add" && deplibs="$add $deplibs"
6939         fi
6940       fi
6941     elif test "$linkmode" = prog; then
6942       # Here we assume that one of hardcode_direct or hardcode_minus_L
6943       # is not unsupported.  This is valid on all known static and
6944       # shared platforms.
6945       if test "$hardcode_direct" != unsupported; then
6946         test -n "$old_library" && linklib="$old_library"
6947         compile_deplibs="$dir/$linklib $compile_deplibs"
6948         finalize_deplibs="$dir/$linklib $finalize_deplibs"
6949       else
6950         compile_deplibs="-l$name -L$dir $compile_deplibs"
6951         finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6952       fi
6953     elif test "$build_libtool_libs" = yes; then
6954       # Not a shared library
6955       if test "$deplibs_check_method" != pass_all; then
6956         # We're trying link a shared library against a static one
6957         # but the system doesn't support it.
6958
6959         # Just print a warning and add the library to dependency_libs so
6960         # that the program can be linked against the static library.
6961         echo
6962         $ECHO "*** Warning: This system can not link to static lib archive $lib."
6963         echo "*** I have the capability to make that library automatically link in when"
6964         echo "*** you link to this library.  But I can only do this if you have a"
6965         echo "*** shared version of the library, which you do not appear to have."
6966         if test "$module" = yes; then
6967           echo "*** But as you try to build a module library, libtool will still create "
6968           echo "*** a static module, that should work as long as the dlopening application"
6969           echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6970           if test -z "$global_symbol_pipe"; then
6971         echo
6972         echo "*** However, this would only work if libtool was able to extract symbol"
6973         echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6974         echo "*** not find such a program.  So, this module is probably useless."
6975         echo "*** \`nm' from GNU binutils and a full rebuild may help."
6976           fi
6977           if test "$build_old_libs" = no; then
6978         build_libtool_libs=module
6979         build_old_libs=yes
6980           else
6981         build_libtool_libs=no
6982           fi
6983         fi
6984       else
6985         deplibs="$dir/$old_library $deplibs"
6986         link_static=yes
6987       fi
6988     fi # link shared/static library?
6989
6990     if test "$linkmode" = lib; then
6991       if test -n "$dependency_libs" &&
6992          { test "$hardcode_into_libs" != yes ||
6993            test "$build_old_libs" = yes ||
6994            test "$link_static" = yes; }; then
6995         # Extract -R from dependency_libs
6996         temp_deplibs=
6997         for libdir in $dependency_libs; do
6998           case $libdir in
6999           -R*) func_stripname '-R' '' "$libdir"
7000                temp_xrpath=$func_stripname_result
7001            case " $xrpath " in
7002            *" $temp_xrpath "*) ;;
7003            *) func_append xrpath " $temp_xrpath";;
7004            esac;;
7005           *) func_append temp_deplibs " $libdir";;
7006           esac
7007         done
7008         dependency_libs="$temp_deplibs"
7009       fi
7010
7011       func_append newlib_search_path " $absdir"
7012       # Link against this library
7013       test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7014       # ... and its dependency_libs
7015       tmp_libs=
7016       for deplib in $dependency_libs; do
7017         newdependency_libs="$deplib $newdependency_libs"
7018         case $deplib in
7019               -L*) func_stripname '-L' '' "$deplib"
7020                    func_resolve_sysroot "$func_stripname_result";;
7021               *) func_resolve_sysroot "$deplib" ;;
7022             esac
7023         if $opt_preserve_dup_deps ; then
7024           case "$tmp_libs " in
7025           *" $func_resolve_sysroot_result "*)
7026                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7027           esac
7028         fi
7029         func_append tmp_libs " $func_resolve_sysroot_result"
7030       done
7031
7032       if test "$link_all_deplibs" != no; then
7033         # Add the search paths of all dependency libraries
7034         for deplib in $dependency_libs; do
7035           path=
7036           case $deplib in
7037           -L*) path="$deplib" ;;
7038           *.la)
7039             func_resolve_sysroot "$deplib"
7040             deplib=$func_resolve_sysroot_result
7041             func_dirname "$deplib" "" "."
7042         dir=$func_dirname_result
7043         # We need an absolute path.
7044         case $dir in
7045         [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7046         *)
7047           absdir=`cd "$dir" && pwd`
7048           if test -z "$absdir"; then
7049             func_warning "cannot determine absolute directory name of \`$dir'"
7050             absdir="$dir"
7051           fi
7052           ;;
7053         esac
7054         if $GREP "^installed=no" $deplib > /dev/null; then
7055         case $host in
7056         *-*-darwin*)
7057           depdepl=
7058           eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7059           if test -n "$deplibrary_names" ; then
7060             for tmp in $deplibrary_names ; do
7061               depdepl=$tmp
7062             done
7063             if test -f "$absdir/$objdir/$depdepl" ; then
7064               depdepl="$absdir/$objdir/$depdepl"
7065               darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7066                       if test -z "$darwin_install_name"; then
7067                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
7068                       fi
7069               func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7070               func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7071               path=
7072             fi
7073           fi
7074           ;;
7075         *)
7076           path="-L$absdir/$objdir"
7077           ;;
7078         esac
7079         else
7080           eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7081           test -z "$libdir" && \
7082             func_fatal_error "\`$deplib' is not a valid libtool archive"
7083           test "$absdir" != "$libdir" && \
7084             func_warning "\`$deplib' seems to be moved"
7085
7086           path="-L$absdir"
7087         fi
7088         ;;
7089           esac
7090           case " $deplibs " in
7091           *" $path "*) ;;
7092           *) deplibs="$path $deplibs" ;;
7093           esac
7094         done
7095       fi # link_all_deplibs != no
7096     fi # linkmode = lib
7097       done # for deplib in $libs
7098       if test "$pass" = link; then
7099     if test "$linkmode" = "prog"; then
7100       compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7101       finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7102     else
7103       compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7104     fi
7105       fi
7106       dependency_libs="$newdependency_libs"
7107       if test "$pass" = dlpreopen; then
7108     # Link the dlpreopened libraries before other libraries
7109     for deplib in $save_deplibs; do
7110       deplibs="$deplib $deplibs"
7111     done
7112       fi
7113       if test "$pass" != dlopen; then
7114     if test "$pass" != conv; then
7115       # Make sure lib_search_path contains only unique directories.
7116       lib_search_path=
7117       for dir in $newlib_search_path; do
7118         case "$lib_search_path " in
7119         *" $dir "*) ;;
7120         *) func_append lib_search_path " $dir" ;;
7121         esac
7122       done
7123       newlib_search_path=
7124     fi
7125
7126     if test "$linkmode,$pass" != "prog,link"; then
7127       vars="deplibs"
7128     else
7129       vars="compile_deplibs finalize_deplibs"
7130     fi
7131     for var in $vars dependency_libs; do
7132       # Add libraries to $var in reverse order
7133       eval tmp_libs=\"\$$var\"
7134       new_libs=
7135       for deplib in $tmp_libs; do
7136         # FIXME: Pedantically, this is the right thing to do, so
7137         #        that some nasty dependency loop isn't accidentally
7138         #        broken:
7139         #new_libs="$deplib $new_libs"
7140         # Pragmatically, this seems to cause very few problems in
7141         # practice:
7142         case $deplib in
7143         -L*) new_libs="$deplib $new_libs" ;;
7144         -R*) ;;
7145         *)
7146           # And here is the reason: when a library appears more
7147           # than once as an explicit dependence of a library, or
7148           # is implicitly linked in more than once by the
7149           # compiler, it is considered special, and multiple
7150           # occurrences thereof are not removed.  Compare this
7151           # with having the same library being listed as a
7152           # dependency of multiple other libraries: in this case,
7153           # we know (pedantically, we assume) the library does not
7154           # need to be listed more than once, so we keep only the
7155           # last copy.  This is not always right, but it is rare
7156           # enough that we require users that really mean to play
7157           # such unportable linking tricks to link the library
7158           # using -Wl,-lname, so that libtool does not consider it
7159           # for duplicate removal.
7160           case " $specialdeplibs " in
7161           *" $deplib "*) new_libs="$deplib $new_libs" ;;
7162           *)
7163         case " $new_libs " in
7164         *" $deplib "*) ;;
7165         *) new_libs="$deplib $new_libs" ;;
7166         esac
7167         ;;
7168           esac
7169           ;;
7170         esac
7171       done
7172       tmp_libs=
7173       for deplib in $new_libs; do
7174         case $deplib in
7175         -L*)
7176           case " $tmp_libs " in
7177           *" $deplib "*) ;;
7178           *) func_append tmp_libs " $deplib" ;;
7179           esac
7180           ;;
7181         *) func_append tmp_libs " $deplib" ;;
7182         esac
7183       done
7184       eval $var=\"$tmp_libs\"
7185     done # for var
7186       fi
7187       # Last step: remove runtime libs from dependency_libs
7188       # (they stay in deplibs)
7189       tmp_libs=
7190       for i in $dependency_libs ; do
7191     case " $predeps $postdeps $compiler_lib_search_path " in
7192     *" $i "*)
7193       i=""
7194       ;;
7195     esac
7196     if test -n "$i" ; then
7197       func_append tmp_libs " $i"
7198     fi
7199       done
7200       dependency_libs=$tmp_libs
7201     done # for pass
7202     if test "$linkmode" = prog; then
7203       dlfiles="$newdlfiles"
7204     fi
7205     if test "$linkmode" = prog || test "$linkmode" = lib; then
7206       dlprefiles="$newdlprefiles"
7207     fi
7208
7209     case $linkmode in
7210     oldlib)
7211       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7212     func_warning "\`-dlopen' is ignored for archives"
7213       fi
7214
7215       case " $deplibs" in
7216       *\ -l* | *\ -L*)
7217     func_warning "\`-l' and \`-L' are ignored for archives" ;;
7218       esac
7219
7220       test -n "$rpath" && \
7221     func_warning "\`-rpath' is ignored for archives"
7222
7223       test -n "$xrpath" && \
7224     func_warning "\`-R' is ignored for archives"
7225
7226       test -n "$vinfo" && \
7227     func_warning "\`-version-info/-version-number' is ignored for archives"
7228
7229       test -n "$release" && \
7230     func_warning "\`-release' is ignored for archives"
7231
7232       test -n "$export_symbols$export_symbols_regex" && \
7233     func_warning "\`-export-symbols' is ignored for archives"
7234
7235       # Now set the variables for building old libraries.
7236       build_libtool_libs=no
7237       oldlibs="$output"
7238       func_append objs "$old_deplibs"
7239       ;;
7240
7241     lib)
7242       # Make sure we only generate libraries of the form `libNAME.la'.
7243       case $outputname in
7244       lib*)
7245     func_stripname 'lib' '.la' "$outputname"
7246     name=$func_stripname_result
7247     eval shared_ext=\"$shrext_cmds\"
7248     eval libname=\"$libname_spec\"
7249     ;;
7250       *)
7251     test "$module" = no && \
7252       func_fatal_help "libtool library \`$output' must begin with \`lib'"
7253
7254     if test "$need_lib_prefix" != no; then
7255       # Add the "lib" prefix for modules if required
7256       func_stripname '' '.la' "$outputname"
7257       name=$func_stripname_result
7258       eval shared_ext=\"$shrext_cmds\"
7259       eval libname=\"$libname_spec\"
7260     else
7261       func_stripname '' '.la' "$outputname"
7262       libname=$func_stripname_result
7263     fi
7264     ;;
7265       esac
7266
7267       if test -n "$objs"; then
7268     if test "$deplibs_check_method" != pass_all; then
7269       func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7270     else
7271       echo
7272       $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7273       $ECHO "*** objects $objs is not portable!"
7274       func_append libobjs " $objs"
7275     fi
7276       fi
7277
7278       test "$dlself" != no && \
7279     func_warning "\`-dlopen self' is ignored for libtool libraries"
7280
7281       set dummy $rpath
7282       shift
7283       test "$#" -gt 1 && \
7284     func_warning "ignoring multiple \`-rpath's for a libtool library"
7285
7286       install_libdir="$1"
7287
7288       oldlibs=
7289       if test -z "$rpath"; then
7290     if test "$build_libtool_libs" = yes; then
7291       # Building a libtool convenience library.
7292       # Some compilers have problems with a `.al' extension so
7293       # convenience libraries should have the same extension an
7294       # archive normally would.
7295       oldlibs="$output_objdir/$libname.$libext $oldlibs"
7296       build_libtool_libs=convenience
7297       build_old_libs=yes
7298     fi
7299
7300     test -n "$vinfo" && \
7301       func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7302
7303     test -n "$release" && \
7304       func_warning "\`-release' is ignored for convenience libraries"
7305       else
7306
7307     # Parse the version information argument.
7308     save_ifs="$IFS"; IFS=':'
7309     set dummy $vinfo 0 0 0
7310     shift
7311     IFS="$save_ifs"
7312
7313     test -n "$7" && \
7314       func_fatal_help "too many parameters to \`-version-info'"
7315
7316     # convert absolute version numbers to libtool ages
7317     # this retains compatibility with .la files and attempts
7318     # to make the code below a bit more comprehensible
7319
7320     case $vinfo_number in
7321     yes)
7322       number_major="$1"
7323       number_minor="$2"
7324       number_revision="$3"
7325       #
7326       # There are really only two kinds -- those that
7327       # use the current revision as the major version
7328       # and those that subtract age and use age as
7329       # a minor version.  But, then there is irix
7330       # which has an extra 1 added just for fun
7331       #
7332       case $version_type in
7333       # correct linux to gnu/linux during the next big refactor
7334       darwin|linux|osf|windows|none)
7335         func_arith $number_major + $number_minor
7336         current=$func_arith_result
7337         age="$number_minor"
7338         revision="$number_revision"
7339         ;;
7340       freebsd-aout|freebsd-elf|qnx|sunos)
7341         current="$number_major"
7342         revision="$number_minor"
7343         age="0"
7344         ;;
7345       irix|nonstopux)
7346         func_arith $number_major + $number_minor
7347         current=$func_arith_result
7348         age="$number_minor"
7349         revision="$number_minor"
7350         lt_irix_increment=no
7351         ;;
7352       esac
7353       ;;
7354     no)
7355       current="$1"
7356       revision="$2"
7357       age="$3"
7358       ;;
7359     esac
7360
7361     # Check that each of the things are valid numbers.
7362     case $current in
7363     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]) ;;
7364     *)
7365       func_error "CURRENT \`$current' must be a nonnegative integer"
7366       func_fatal_error "\`$vinfo' is not valid version information"
7367       ;;
7368     esac
7369
7370     case $revision in
7371     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]) ;;
7372     *)
7373       func_error "REVISION \`$revision' must be a nonnegative integer"
7374       func_fatal_error "\`$vinfo' is not valid version information"
7375       ;;
7376     esac
7377
7378     case $age in
7379     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]) ;;
7380     *)
7381       func_error "AGE \`$age' must be a nonnegative integer"
7382       func_fatal_error "\`$vinfo' is not valid version information"
7383       ;;
7384     esac
7385
7386     if test "$age" -gt "$current"; then
7387       func_error "AGE \`$age' is greater than the current interface number \`$current'"
7388       func_fatal_error "\`$vinfo' is not valid version information"
7389     fi
7390
7391     # Calculate the version variables.
7392     major=
7393     versuffix=
7394     verstring=
7395     case $version_type in
7396     none) ;;
7397
7398     darwin)
7399       # Like Linux, but with the current version available in
7400       # verstring for coding it into the library header
7401       func_arith $current - $age
7402       major=.$func_arith_result
7403       versuffix="$major.$age.$revision"
7404       # Darwin ld doesn't like 0 for these options...
7405       func_arith $current + 1
7406       minor_current=$func_arith_result
7407       xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7408       verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7409       ;;
7410
7411     freebsd-aout)
7412       major=".$current"
7413       versuffix=".$current.$revision";
7414       ;;
7415
7416     freebsd-elf)
7417       major=".$current"
7418       versuffix=".$current"
7419       ;;
7420
7421     irix | nonstopux)
7422       if test "X$lt_irix_increment" = "Xno"; then
7423         func_arith $current - $age
7424       else
7425         func_arith $current - $age + 1
7426       fi
7427       major=$func_arith_result
7428
7429       case $version_type in
7430         nonstopux) verstring_prefix=nonstopux ;;
7431         *)         verstring_prefix=sgi ;;
7432       esac
7433       verstring="$verstring_prefix$major.$revision"
7434
7435       # Add in all the interfaces that we are compatible with.
7436       loop=$revision
7437       while test "$loop" -ne 0; do
7438         func_arith $revision - $loop
7439         iface=$func_arith_result
7440         func_arith $loop - 1
7441         loop=$func_arith_result
7442         verstring="$verstring_prefix$major.$iface:$verstring"
7443       done
7444
7445       # Before this point, $major must not contain `.'.
7446       major=.$major
7447       versuffix="$major.$revision"
7448       ;;
7449
7450     linux) # correct to gnu/linux during the next big refactor
7451       func_arith $current - $age
7452       major=.$func_arith_result
7453       versuffix="$major.$age.$revision"
7454       ;;
7455
7456     osf)
7457       func_arith $current - $age
7458       major=.$func_arith_result
7459       versuffix=".$current.$age.$revision"
7460       verstring="$current.$age.$revision"
7461
7462       # Add in all the interfaces that we are compatible with.
7463       loop=$age
7464       while test "$loop" -ne 0; do
7465         func_arith $current - $loop
7466         iface=$func_arith_result
7467         func_arith $loop - 1
7468         loop=$func_arith_result
7469         verstring="$verstring:${iface}.0"
7470       done
7471
7472       # Make executables depend on our current version.
7473       func_append verstring ":${current}.0"
7474       ;;
7475
7476     qnx)
7477       major=".$current"
7478       versuffix=".$current"
7479       ;;
7480
7481     sunos)
7482       major=".$current"
7483       versuffix=".$current.$revision"
7484       ;;
7485
7486     windows)
7487       # Use '-' rather than '.', since we only want one
7488       # extension on DOS 8.3 filesystems.
7489       func_arith $current - $age
7490       major=$func_arith_result
7491       versuffix="-$major"
7492       ;;
7493
7494     *)
7495       func_fatal_configuration "unknown library version type \`$version_type'"
7496       ;;
7497     esac
7498
7499     # Clear the version info if we defaulted, and they specified a release.
7500     if test -z "$vinfo" && test -n "$release"; then
7501       major=
7502       case $version_type in
7503       darwin)
7504         # we can't check for "0.0" in archive_cmds due to quoting
7505         # problems, so we reset it completely
7506         verstring=
7507         ;;
7508       *)
7509         verstring="0.0"
7510         ;;
7511       esac
7512       if test "$need_version" = no; then
7513         versuffix=
7514       else
7515         versuffix=".0.0"
7516       fi
7517     fi
7518
7519     # Remove version info from name if versioning should be avoided
7520     if test "$avoid_version" = yes && test "$need_version" = no; then
7521       major=
7522       versuffix=
7523       verstring=""
7524     fi
7525
7526     # Check to see if the archive will have undefined symbols.
7527     if test "$allow_undefined" = yes; then
7528       if test "$allow_undefined_flag" = unsupported; then
7529         func_warning "undefined symbols not allowed in $host shared libraries"
7530         build_libtool_libs=no
7531         build_old_libs=yes
7532       fi
7533     else
7534       # Don't allow undefined symbols.
7535       allow_undefined_flag="$no_undefined_flag"
7536     fi
7537
7538       fi
7539
7540       func_generate_dlsyms "$libname" "$libname" "yes"
7541       func_append libobjs " $symfileobj"
7542       test "X$libobjs" = "X " && libobjs=
7543
7544       if test "$opt_mode" != relink; then
7545     # Remove our outputs, but don't remove object files since they
7546     # may have been created when compiling PIC objects.
7547     removelist=
7548     tempremovelist=`$ECHO "$output_objdir/*"`
7549     for p in $tempremovelist; do
7550       case $p in
7551         *.$objext | *.gcno)
7552            ;;
7553         $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7554            if test "X$precious_files_regex" != "X"; then
7555          if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7556          then
7557            continue
7558          fi
7559            fi
7560            func_append removelist " $p"
7561            ;;
7562         *) ;;
7563       esac
7564     done
7565     test -n "$removelist" && \
7566       func_show_eval "${RM}r \$removelist"
7567       fi
7568
7569       # Now set the variables for building old libraries.
7570       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7571     func_append oldlibs " $output_objdir/$libname.$libext"
7572
7573     # Transform .lo files to .o files.
7574     oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7575       fi
7576
7577       # Eliminate all temporary directories.
7578       #for path in $notinst_path; do
7579       #    lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7580       #    deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7581       #    dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7582       #done
7583
7584       if test -n "$xrpath"; then
7585     # If the user specified any rpath flags, then add them.
7586     temp_xrpath=
7587     for libdir in $xrpath; do
7588       func_replace_sysroot "$libdir"
7589       func_append temp_xrpath " -R$func_replace_sysroot_result"
7590       case "$finalize_rpath " in
7591       *" $libdir "*) ;;
7592       *) func_append finalize_rpath " $libdir" ;;
7593       esac
7594     done
7595     if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7596       dependency_libs="$temp_xrpath $dependency_libs"
7597     fi
7598       fi
7599
7600       # Make sure dlfiles contains only unique files that won't be dlpreopened
7601       old_dlfiles="$dlfiles"
7602       dlfiles=
7603       for lib in $old_dlfiles; do
7604     case " $dlprefiles $dlfiles " in
7605     *" $lib "*) ;;
7606     *) func_append dlfiles " $lib" ;;
7607     esac
7608       done
7609
7610       # Make sure dlprefiles contains only unique files
7611       old_dlprefiles="$dlprefiles"
7612       dlprefiles=
7613       for lib in $old_dlprefiles; do
7614     case "$dlprefiles " in
7615     *" $lib "*) ;;
7616     *) func_append dlprefiles " $lib" ;;
7617     esac
7618       done
7619
7620       if test "$build_libtool_libs" = yes; then
7621     if test -n "$rpath"; then
7622       case $host in
7623       *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7624         # these systems don't actually have a c library (as such)!
7625         ;;
7626       *-*-rhapsody* | *-*-darwin1.[012])
7627         # Rhapsody C library is in the System framework
7628         func_append deplibs " System.ltframework"
7629         ;;
7630       *-*-netbsd*)
7631         # Don't link with libc until the a.out ld.so is fixed.
7632         ;;
7633       *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7634         # Do not include libc due to us having libc/libc_r.
7635         ;;
7636       *-*-sco3.2v5* | *-*-sco5v6*)
7637         # Causes problems with __ctype
7638         ;;
7639       *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7640         # Compiler inserts libc in the correct place for threads to work
7641         ;;
7642       *)
7643         # Add libc to deplibs on all other systems if necessary.
7644         if test "$build_libtool_need_lc" = "yes"; then
7645           func_append deplibs " -lc"
7646         fi
7647         ;;
7648       esac
7649     fi
7650
7651     # Transform deplibs into only deplibs that can be linked in shared.
7652     name_save=$name
7653     libname_save=$libname
7654     release_save=$release
7655     versuffix_save=$versuffix
7656     major_save=$major
7657     # I'm not sure if I'm treating the release correctly.  I think
7658     # release should show up in the -l (ie -lgmp5) so we don't want to
7659     # add it in twice.  Is that correct?
7660     release=""
7661     versuffix=""
7662     major=""
7663     newdeplibs=
7664     droppeddeps=no
7665     case $deplibs_check_method in
7666     pass_all)
7667       # Don't check for shared/static.  Everything works.
7668       # This might be a little naive.  We might want to check
7669       # whether the library exists or not.  But this is on
7670       # osf3 & osf4 and I'm not really sure... Just
7671       # implementing what was already the behavior.
7672       newdeplibs=$deplibs
7673       ;;
7674     test_compile)
7675       # This code stresses the "libraries are programs" paradigm to its
7676       # limits. Maybe even breaks it.  We compile a program, linking it
7677       # against the deplibs as a proxy for the library.  Then we can check
7678       # whether they linked in statically or dynamically with ldd.
7679       $opt_dry_run || $RM conftest.c
7680       cat > conftest.c <<EOF
7681       int main() { return 0; }
7682 EOF
7683       $opt_dry_run || $RM conftest
7684       if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7685         ldd_output=`ldd conftest`
7686         for i in $deplibs; do
7687           case $i in
7688           -l*)
7689         func_stripname -l '' "$i"
7690         name=$func_stripname_result
7691         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7692           case " $predeps $postdeps " in
7693           *" $i "*)
7694             func_append newdeplibs " $i"
7695             i=""
7696             ;;
7697           esac
7698         fi
7699         if test -n "$i" ; then
7700           libname=`eval "\\$ECHO \"$libname_spec\""`
7701           deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7702           set dummy $deplib_matches; shift
7703           deplib_match=$1
7704           if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7705             func_append newdeplibs " $i"
7706           else
7707             droppeddeps=yes
7708             echo
7709             $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7710             echo "*** I have the capability to make that library automatically link in when"
7711             echo "*** you link to this library.  But I can only do this if you have a"
7712             echo "*** shared version of the library, which I believe you do not have"
7713             echo "*** because a test_compile did reveal that the linker did not use it for"
7714             echo "*** its dynamic dependency list that programs get resolved with at runtime."
7715           fi
7716         fi
7717         ;;
7718           *)
7719         func_append newdeplibs " $i"
7720         ;;
7721           esac
7722         done
7723       else
7724         # Error occurred in the first compile.  Let's try to salvage
7725         # the situation: Compile a separate program for each library.
7726         for i in $deplibs; do
7727           case $i in
7728           -l*)
7729         func_stripname -l '' "$i"
7730         name=$func_stripname_result
7731         $opt_dry_run || $RM conftest
7732         if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7733           ldd_output=`ldd conftest`
7734           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7735             case " $predeps $postdeps " in
7736             *" $i "*)
7737               func_append newdeplibs " $i"
7738               i=""
7739               ;;
7740             esac
7741           fi
7742           if test -n "$i" ; then
7743             libname=`eval "\\$ECHO \"$libname_spec\""`
7744             deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7745             set dummy $deplib_matches; shift
7746             deplib_match=$1
7747             if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7748               func_append newdeplibs " $i"
7749             else
7750               droppeddeps=yes
7751               echo
7752               $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7753               echo "*** I have the capability to make that library automatically link in when"
7754               echo "*** you link to this library.  But I can only do this if you have a"
7755               echo "*** shared version of the library, which you do not appear to have"
7756               echo "*** because a test_compile did reveal that the linker did not use this one"
7757               echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7758             fi
7759           fi
7760         else
7761           droppeddeps=yes
7762           echo
7763           $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7764           echo "*** make it link in!  You will probably need to install it or some"
7765           echo "*** library that it depends on before this library will be fully"
7766           echo "*** functional.  Installing it before continuing would be even better."
7767         fi
7768         ;;
7769           *)
7770         func_append newdeplibs " $i"
7771         ;;
7772           esac
7773         done
7774       fi
7775       ;;
7776     file_magic*)
7777       set dummy $deplibs_check_method; shift
7778       file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7779       for a_deplib in $deplibs; do
7780         case $a_deplib in
7781         -l*)
7782           func_stripname -l '' "$a_deplib"
7783           name=$func_stripname_result
7784           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7785         case " $predeps $postdeps " in
7786         *" $a_deplib "*)
7787           func_append newdeplibs " $a_deplib"
7788           a_deplib=""
7789           ;;
7790         esac
7791           fi
7792           if test -n "$a_deplib" ; then
7793         libname=`eval "\\$ECHO \"$libname_spec\""`
7794         if test -n "$file_magic_glob"; then
7795           libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7796         else
7797           libnameglob=$libname
7798         fi
7799         test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7800         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7801           if test "$want_nocaseglob" = yes; then
7802             shopt -s nocaseglob
7803             potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7804             $nocaseglob
7805           else
7806             potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7807           fi
7808           for potent_lib in $potential_libs; do
7809               # Follow soft links.
7810               if ls -lLd "$potent_lib" 2>/dev/null |
7811              $GREP " -> " >/dev/null; then
7812             continue
7813               fi
7814               # The statement above tries to avoid entering an
7815               # endless loop below, in case of cyclic links.
7816               # We might still enter an endless loop, since a link
7817               # loop can be closed while we follow links,
7818               # but so what?
7819               potlib="$potent_lib"
7820               while test -h "$potlib" 2>/dev/null; do
7821             potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7822             case $potliblink in
7823             [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7824             *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7825             esac
7826               done
7827               if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7828              $SED -e 10q |
7829              $EGREP "$file_magic_regex" > /dev/null; then
7830             func_append newdeplibs " $a_deplib"
7831             a_deplib=""
7832             break 2
7833               fi
7834           done
7835         done
7836           fi
7837           if test -n "$a_deplib" ; then
7838         droppeddeps=yes
7839         echo
7840         $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7841         echo "*** I have the capability to make that library automatically link in when"
7842         echo "*** you link to this library.  But I can only do this if you have a"
7843         echo "*** shared version of the library, which you do not appear to have"
7844         echo "*** because I did check the linker path looking for a file starting"
7845         if test -z "$potlib" ; then
7846           $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7847         else
7848           $ECHO "*** with $libname and none of the candidates passed a file format test"
7849           $ECHO "*** using a file magic. Last file checked: $potlib"
7850         fi
7851           fi
7852           ;;
7853         *)
7854           # Add a -L argument.
7855           func_append newdeplibs " $a_deplib"
7856           ;;
7857         esac
7858       done # Gone through all deplibs.
7859       ;;
7860     match_pattern*)
7861       set dummy $deplibs_check_method; shift
7862       match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7863       for a_deplib in $deplibs; do
7864         case $a_deplib in
7865         -l*)
7866           func_stripname -l '' "$a_deplib"
7867           name=$func_stripname_result
7868           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7869         case " $predeps $postdeps " in
7870         *" $a_deplib "*)
7871           func_append newdeplibs " $a_deplib"
7872           a_deplib=""
7873           ;;
7874         esac
7875           fi
7876           if test -n "$a_deplib" ; then
7877         libname=`eval "\\$ECHO \"$libname_spec\""`
7878         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7879           potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7880           for potent_lib in $potential_libs; do
7881             potlib="$potent_lib" # see symlink-check above in file_magic test
7882             if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7883                $EGREP "$match_pattern_regex" > /dev/null; then
7884               func_append newdeplibs " $a_deplib"
7885               a_deplib=""
7886               break 2
7887             fi
7888           done
7889         done
7890           fi
7891           if test -n "$a_deplib" ; then
7892         droppeddeps=yes
7893         echo
7894         $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7895         echo "*** I have the capability to make that library automatically link in when"
7896         echo "*** you link to this library.  But I can only do this if you have a"
7897         echo "*** shared version of the library, which you do not appear to have"
7898         echo "*** because I did check the linker path looking for a file starting"
7899         if test -z "$potlib" ; then
7900           $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7901         else
7902           $ECHO "*** with $libname and none of the candidates passed a file format test"
7903           $ECHO "*** using a regex pattern. Last file checked: $potlib"
7904         fi
7905           fi
7906           ;;
7907         *)
7908           # Add a -L argument.
7909           func_append newdeplibs " $a_deplib"
7910           ;;
7911         esac
7912       done # Gone through all deplibs.
7913       ;;
7914     none | unknown | *)
7915       newdeplibs=""
7916       tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7917       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7918         for i in $predeps $postdeps ; do
7919           # can't use Xsed below, because $i might contain '/'
7920           tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7921         done
7922       fi
7923       case $tmp_deplibs in
7924       *[!\    \ ]*)
7925         echo
7926         if test "X$deplibs_check_method" = "Xnone"; then
7927           echo "*** Warning: inter-library dependencies are not supported in this platform."
7928         else
7929           echo "*** Warning: inter-library dependencies are not known to be supported."
7930         fi
7931         echo "*** All declared inter-library dependencies are being dropped."
7932         droppeddeps=yes
7933         ;;
7934       esac
7935       ;;
7936     esac
7937     versuffix=$versuffix_save
7938     major=$major_save
7939     release=$release_save
7940     libname=$libname_save
7941     name=$name_save
7942
7943     case $host in
7944     *-*-rhapsody* | *-*-darwin1.[012])
7945       # On Rhapsody replace the C library with the System framework
7946       newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7947       ;;
7948     esac
7949
7950     if test "$droppeddeps" = yes; then
7951       if test "$module" = yes; then
7952         echo
7953         echo "*** Warning: libtool could not satisfy all declared inter-library"
7954         $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7955         echo "*** a static module, that should work as long as the dlopening"
7956         echo "*** application is linked with the -dlopen flag."
7957         if test -z "$global_symbol_pipe"; then
7958           echo
7959           echo "*** However, this would only work if libtool was able to extract symbol"
7960           echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7961           echo "*** not find such a program.  So, this module is probably useless."
7962           echo "*** \`nm' from GNU binutils and a full rebuild may help."
7963         fi
7964         if test "$build_old_libs" = no; then
7965           oldlibs="$output_objdir/$libname.$libext"
7966           build_libtool_libs=module
7967           build_old_libs=yes
7968         else
7969           build_libtool_libs=no
7970         fi
7971       else
7972         echo "*** The inter-library dependencies that have been dropped here will be"
7973         echo "*** automatically added whenever a program is linked with this library"
7974         echo "*** or is declared to -dlopen it."
7975
7976         if test "$allow_undefined" = no; then
7977           echo
7978           echo "*** Since this library must not contain undefined symbols,"
7979           echo "*** because either the platform does not support them or"
7980           echo "*** it was explicitly requested with -no-undefined,"
7981           echo "*** libtool will only create a static version of it."
7982           if test "$build_old_libs" = no; then
7983         oldlibs="$output_objdir/$libname.$libext"
7984         build_libtool_libs=module
7985         build_old_libs=yes
7986           else
7987         build_libtool_libs=no
7988           fi
7989         fi
7990       fi
7991     fi
7992     # Done checking deplibs!
7993     deplibs=$newdeplibs
7994       fi
7995       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7996       case $host in
7997     *-*-darwin*)
7998       newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7999       new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8000       deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8001       ;;
8002       esac
8003
8004       # move library search paths that coincide with paths to not yet
8005       # installed libraries to the beginning of the library search list
8006       new_libs=
8007       for path in $notinst_path; do
8008     case " $new_libs " in
8009     *" -L$path/$objdir "*) ;;
8010     *)
8011       case " $deplibs " in
8012       *" -L$path/$objdir "*)
8013         func_append new_libs " -L$path/$objdir" ;;
8014       esac
8015       ;;
8016     esac
8017       done
8018       for deplib in $deplibs; do
8019     case $deplib in
8020     -L*)
8021       case " $new_libs " in
8022       *" $deplib "*) ;;
8023       *) func_append new_libs " $deplib" ;;
8024       esac
8025       ;;
8026     *) func_append new_libs " $deplib" ;;
8027     esac
8028       done
8029       deplibs="$new_libs"
8030
8031       # All the library-specific variables (install_libdir is set above).
8032       library_names=
8033       old_library=
8034       dlname=
8035
8036       # Test again, we may have decided not to build it any more
8037       if test "$build_libtool_libs" = yes; then
8038     # Remove ${wl} instances when linking with ld.
8039     # FIXME: should test the right _cmds variable.
8040     case $archive_cmds in
8041       *\$LD\ *) wl= ;;
8042         esac
8043     if test "$hardcode_into_libs" = yes; then
8044       # Hardcode the library paths
8045       hardcode_libdirs=
8046       dep_rpath=
8047       rpath="$finalize_rpath"
8048       test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8049       for libdir in $rpath; do
8050         if test -n "$hardcode_libdir_flag_spec"; then
8051           if test -n "$hardcode_libdir_separator"; then
8052         func_replace_sysroot "$libdir"
8053         libdir=$func_replace_sysroot_result
8054         if test -z "$hardcode_libdirs"; then
8055           hardcode_libdirs="$libdir"
8056         else
8057           # Just accumulate the unique libdirs.
8058           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8059           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8060             ;;
8061           *)
8062             func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8063             ;;
8064           esac
8065         fi
8066           else
8067         eval flag=\"$hardcode_libdir_flag_spec\"
8068         func_append dep_rpath " $flag"
8069           fi
8070         elif test -n "$runpath_var"; then
8071           case "$perm_rpath " in
8072           *" $libdir "*) ;;
8073           *) func_append perm_rpath " $libdir" ;;
8074           esac
8075         fi
8076       done
8077       # Substitute the hardcoded libdirs into the rpath.
8078       if test -n "$hardcode_libdir_separator" &&
8079          test -n "$hardcode_libdirs"; then
8080         libdir="$hardcode_libdirs"
8081         eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8082       fi
8083       if test -n "$runpath_var" && test -n "$perm_rpath"; then
8084         # We should set the runpath_var.
8085         rpath=
8086         for dir in $perm_rpath; do
8087           func_append rpath "$dir:"
8088         done
8089         eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8090       fi
8091       test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8092     fi
8093
8094     shlibpath="$finalize_shlibpath"
8095     test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8096     if test -n "$shlibpath"; then
8097       eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8098     fi
8099
8100     # Get the real and link names of the library.
8101     eval shared_ext=\"$shrext_cmds\"
8102     eval library_names=\"$library_names_spec\"
8103     set dummy $library_names
8104     shift
8105     realname="$1"
8106     shift
8107
8108     if test -n "$soname_spec"; then
8109       eval soname=\"$soname_spec\"
8110     else
8111       soname="$realname"
8112     fi
8113     if test -z "$dlname"; then
8114       dlname=$soname
8115     fi
8116
8117     lib="$output_objdir/$realname"
8118     linknames=
8119     for link
8120     do
8121       func_append linknames " $link"
8122     done
8123
8124     # Use standard objects if they are pic
8125     test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8126     test "X$libobjs" = "X " && libobjs=
8127
8128     delfiles=
8129     if test -n "$export_symbols" && test -n "$include_expsyms"; then
8130       $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8131       export_symbols="$output_objdir/$libname.uexp"
8132       func_append delfiles " $export_symbols"
8133     fi
8134
8135     orig_export_symbols=
8136     case $host_os in
8137     cygwin* | mingw* | cegcc*)
8138       if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8139         # exporting using user supplied symfile
8140         if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8141           # and it's NOT already a .def file. Must figure out
8142           # which of the given symbols are data symbols and tag
8143           # them as such. So, trigger use of export_symbols_cmds.
8144           # export_symbols gets reassigned inside the "prepare
8145           # the list of exported symbols" if statement, so the
8146           # include_expsyms logic still works.
8147           orig_export_symbols="$export_symbols"
8148           export_symbols=
8149           always_export_symbols=yes
8150         fi
8151       fi
8152       ;;
8153     esac
8154
8155     # Prepare the list of exported symbols
8156     if test -z "$export_symbols"; then
8157       if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8158         func_verbose "generating symbol list for \`$libname.la'"
8159         export_symbols="$output_objdir/$libname.exp"
8160         $opt_dry_run || $RM $export_symbols
8161         cmds=$export_symbols_cmds
8162         save_ifs="$IFS"; IFS='~'
8163         for cmd1 in $cmds; do
8164           IFS="$save_ifs"
8165           # Take the normal branch if the nm_file_list_spec branch
8166           # doesn't work or if tool conversion is not needed.
8167           case $nm_file_list_spec~$to_tool_file_cmd in
8168         *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8169           try_normal_branch=yes
8170           eval cmd=\"$cmd1\"
8171           func_len " $cmd"
8172           len=$func_len_result
8173           ;;
8174         *)
8175           try_normal_branch=no
8176           ;;
8177           esac
8178           if test "$try_normal_branch" = yes \
8179          && { test "$len" -lt "$max_cmd_len" \
8180               || test "$max_cmd_len" -le -1; }
8181           then
8182         func_show_eval "$cmd" 'exit $?'
8183         skipped_export=false
8184           elif test -n "$nm_file_list_spec"; then
8185         func_basename "$output"
8186         output_la=$func_basename_result
8187         save_libobjs=$libobjs
8188         save_output=$output
8189         output=${output_objdir}/${output_la}.nm
8190         func_to_tool_file "$output"
8191         libobjs=$nm_file_list_spec$func_to_tool_file_result
8192         func_append delfiles " $output"
8193         func_verbose "creating $NM input file list: $output"
8194         for obj in $save_libobjs; do
8195           func_to_tool_file "$obj"
8196           $ECHO "$func_to_tool_file_result"
8197         done > "$output"
8198         eval cmd=\"$cmd1\"
8199         func_show_eval "$cmd" 'exit $?'
8200         output=$save_output
8201         libobjs=$save_libobjs
8202         skipped_export=false
8203           else
8204         # The command line is too long to execute in one step.
8205         func_verbose "using reloadable object file for export list..."
8206         skipped_export=:
8207         # Break out early, otherwise skipped_export may be
8208         # set to false by a later but shorter cmd.
8209         break
8210           fi
8211         done
8212         IFS="$save_ifs"
8213         if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8214           func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8215           func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8216         fi
8217       fi
8218     fi
8219
8220     if test -n "$export_symbols" && test -n "$include_expsyms"; then
8221       tmp_export_symbols="$export_symbols"
8222       test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8223       $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8224     fi
8225
8226     if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8227       # The given exports_symbols file has to be filtered, so filter it.
8228       func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8229       # FIXME: $output_objdir/$libname.filter potentially contains lots of
8230       # 's' commands which not all seds can handle. GNU sed should be fine
8231       # though. Also, the filter scales superlinearly with the number of
8232       # global variables. join(1) would be nice here, but unfortunately
8233       # isn't a blessed tool.
8234       $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8235       func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8236       export_symbols=$output_objdir/$libname.def
8237       $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8238     fi
8239
8240     tmp_deplibs=
8241     for test_deplib in $deplibs; do
8242       case " $convenience " in
8243       *" $test_deplib "*) ;;
8244       *)
8245         func_append tmp_deplibs " $test_deplib"
8246         ;;
8247       esac
8248     done
8249     deplibs="$tmp_deplibs"
8250
8251     if test -n "$convenience"; then
8252       if test -n "$whole_archive_flag_spec" &&
8253         test "$compiler_needs_object" = yes &&
8254         test -z "$libobjs"; then
8255         # extract the archives, so we have objects to list.
8256         # TODO: could optimize this to just extract one archive.
8257         whole_archive_flag_spec=
8258       fi
8259       if test -n "$whole_archive_flag_spec"; then
8260         save_libobjs=$libobjs
8261         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8262         test "X$libobjs" = "X " && libobjs=
8263       else
8264         gentop="$output_objdir/${outputname}x"
8265         func_append generated " $gentop"
8266
8267         func_extract_archives $gentop $convenience
8268         func_append libobjs " $func_extract_archives_result"
8269         test "X$libobjs" = "X " && libobjs=
8270       fi
8271     fi
8272
8273     if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8274       eval flag=\"$thread_safe_flag_spec\"
8275       func_append linker_flags " $flag"
8276     fi
8277
8278     # Make a backup of the uninstalled library when relinking
8279     if test "$opt_mode" = relink; then
8280       $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8281     fi
8282
8283     # Do each of the archive commands.
8284     if test "$module" = yes && test -n "$module_cmds" ; then
8285       if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8286         eval test_cmds=\"$module_expsym_cmds\"
8287         cmds=$module_expsym_cmds
8288       else
8289         eval test_cmds=\"$module_cmds\"
8290         cmds=$module_cmds
8291       fi
8292     else
8293       if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8294         eval test_cmds=\"$archive_expsym_cmds\"
8295         cmds=$archive_expsym_cmds
8296       else
8297         eval test_cmds=\"$archive_cmds\"
8298         cmds=$archive_cmds
8299       fi
8300     fi
8301
8302     if test "X$skipped_export" != "X:" &&
8303        func_len " $test_cmds" &&
8304        len=$func_len_result &&
8305        test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8306       :
8307     else
8308       # The command line is too long to link in one step, link piecewise
8309       # or, if using GNU ld and skipped_export is not :, use a linker
8310       # script.
8311
8312       # Save the value of $output and $libobjs because we want to
8313       # use them later.  If we have whole_archive_flag_spec, we
8314       # want to use save_libobjs as it was before
8315       # whole_archive_flag_spec was expanded, because we can't
8316       # assume the linker understands whole_archive_flag_spec.
8317       # This may have to be revisited, in case too many
8318       # convenience libraries get linked in and end up exceeding
8319       # the spec.
8320       if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8321         save_libobjs=$libobjs
8322       fi
8323       save_output=$output
8324       func_basename "$output"
8325       output_la=$func_basename_result
8326
8327       # Clear the reloadable object creation command queue and
8328       # initialize k to one.
8329       test_cmds=
8330       concat_cmds=
8331       objlist=
8332       last_robj=
8333       k=1
8334
8335       if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8336         output=${output_objdir}/${output_la}.lnkscript
8337         func_verbose "creating GNU ld script: $output"
8338         echo 'INPUT (' > $output
8339         for obj in $save_libobjs
8340         do
8341           func_to_tool_file "$obj"
8342           $ECHO "$func_to_tool_file_result" >> $output
8343         done
8344         echo ')' >> $output
8345         func_append delfiles " $output"
8346         func_to_tool_file "$output"
8347         output=$func_to_tool_file_result
8348       elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8349         output=${output_objdir}/${output_la}.lnk
8350         func_verbose "creating linker input file list: $output"
8351         : > $output
8352         set x $save_libobjs
8353         shift
8354         firstobj=
8355         if test "$compiler_needs_object" = yes; then
8356           firstobj="$1 "
8357           shift
8358         fi
8359         for obj
8360         do
8361           func_to_tool_file "$obj"
8362           $ECHO "$func_to_tool_file_result" >> $output
8363         done
8364         func_append delfiles " $output"
8365         func_to_tool_file "$output"
8366         output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8367       else
8368         if test -n "$save_libobjs"; then
8369           func_verbose "creating reloadable object files..."
8370           output=$output_objdir/$output_la-${k}.$objext
8371           eval test_cmds=\"$reload_cmds\"
8372           func_len " $test_cmds"
8373           len0=$func_len_result
8374           len=$len0
8375
8376           # Loop over the list of objects to be linked.
8377           for obj in $save_libobjs
8378           do
8379         func_len " $obj"
8380         func_arith $len + $func_len_result
8381         len=$func_arith_result
8382         if test "X$objlist" = X ||
8383            test "$len" -lt "$max_cmd_len"; then
8384           func_append objlist " $obj"
8385         else
8386           # The command $test_cmds is almost too long, add a
8387           # command to the queue.
8388           if test "$k" -eq 1 ; then
8389             # The first file doesn't have a previous command to add.
8390             reload_objs=$objlist
8391             eval concat_cmds=\"$reload_cmds\"
8392           else
8393             # All subsequent reloadable object files will link in
8394             # the last one created.
8395             reload_objs="$objlist $last_robj"
8396             eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8397           fi
8398           last_robj=$output_objdir/$output_la-${k}.$objext
8399           func_arith $k + 1
8400           k=$func_arith_result
8401           output=$output_objdir/$output_la-${k}.$objext
8402           objlist=" $obj"
8403           func_len " $last_robj"
8404           func_arith $len0 + $func_len_result
8405           len=$func_arith_result
8406         fi
8407           done
8408           # Handle the remaining objects by creating one last
8409           # reloadable object file.  All subsequent reloadable object
8410           # files will link in the last one created.
8411           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8412           reload_objs="$objlist $last_robj"
8413           eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8414           if test -n "$last_robj"; then
8415             eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8416           fi
8417           func_append delfiles " $output"
8418
8419         else
8420           output=
8421         fi
8422
8423         if ${skipped_export-false}; then
8424           func_verbose "generating symbol list for \`$libname.la'"
8425           export_symbols="$output_objdir/$libname.exp"
8426           $opt_dry_run || $RM $export_symbols
8427           libobjs=$output
8428           # Append the command to create the export file.
8429           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8430           eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8431           if test -n "$last_robj"; then
8432         eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8433           fi
8434         fi
8435
8436         test -n "$save_libobjs" &&
8437           func_verbose "creating a temporary reloadable object file: $output"
8438
8439         # Loop through the commands generated above and execute them.
8440         save_ifs="$IFS"; IFS='~'
8441         for cmd in $concat_cmds; do
8442           IFS="$save_ifs"
8443           $opt_silent || {
8444           func_quote_for_expand "$cmd"
8445           eval "func_echo $func_quote_for_expand_result"
8446           }
8447           $opt_dry_run || eval "$cmd" || {
8448         lt_exit=$?
8449
8450         # Restore the uninstalled library and exit
8451         if test "$opt_mode" = relink; then
8452           ( cd "$output_objdir" && \
8453             $RM "${realname}T" && \
8454             $MV "${realname}U" "$realname" )
8455         fi
8456
8457         exit $lt_exit
8458           }
8459         done
8460         IFS="$save_ifs"
8461
8462         if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8463           func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8464           func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8465         fi
8466       fi
8467
8468           if ${skipped_export-false}; then
8469         if test -n "$export_symbols" && test -n "$include_expsyms"; then
8470           tmp_export_symbols="$export_symbols"
8471           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8472           $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8473         fi
8474
8475         if test -n "$orig_export_symbols"; then
8476           # The given exports_symbols file has to be filtered, so filter it.
8477           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8478           # FIXME: $output_objdir/$libname.filter potentially contains lots of
8479           # 's' commands which not all seds can handle. GNU sed should be fine
8480           # though. Also, the filter scales superlinearly with the number of
8481           # global variables. join(1) would be nice here, but unfortunately
8482           # isn't a blessed tool.
8483           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8484           func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8485           export_symbols=$output_objdir/$libname.def
8486           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8487         fi
8488       fi
8489
8490       libobjs=$output
8491       # Restore the value of output.
8492       output=$save_output
8493
8494       if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8495         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8496         test "X$libobjs" = "X " && libobjs=
8497       fi
8498       # Expand the library linking commands again to reset the
8499       # value of $libobjs for piecewise linking.
8500
8501       # Do each of the archive commands.
8502       if test "$module" = yes && test -n "$module_cmds" ; then
8503         if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8504           cmds=$module_expsym_cmds
8505         else
8506           cmds=$module_cmds
8507         fi
8508       else
8509         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8510           cmds=$archive_expsym_cmds
8511         else
8512           cmds=$archive_cmds
8513         fi
8514       fi
8515     fi
8516
8517     if test -n "$delfiles"; then
8518       # Append the command to remove temporary files to $cmds.
8519       eval cmds=\"\$cmds~\$RM $delfiles\"
8520     fi
8521
8522     # Add any objects from preloaded convenience libraries
8523     if test -n "$dlprefiles"; then
8524       gentop="$output_objdir/${outputname}x"
8525       func_append generated " $gentop"
8526
8527       func_extract_archives $gentop $dlprefiles
8528       func_append libobjs " $func_extract_archives_result"
8529       test "X$libobjs" = "X " && libobjs=
8530     fi
8531
8532     save_ifs="$IFS"; IFS='~'
8533     for cmd in $cmds; do
8534       IFS="$save_ifs"
8535       eval cmd=\"$cmd\"
8536       $opt_silent || {
8537         func_quote_for_expand "$cmd"
8538         eval "func_echo $func_quote_for_expand_result"
8539       }
8540       $opt_dry_run || eval "$cmd" || {
8541         lt_exit=$?
8542
8543         # Restore the uninstalled library and exit
8544         if test "$opt_mode" = relink; then
8545           ( cd "$output_objdir" && \
8546             $RM "${realname}T" && \
8547         $MV "${realname}U" "$realname" )
8548         fi
8549
8550         exit $lt_exit
8551       }
8552     done
8553     IFS="$save_ifs"
8554
8555     # Restore the uninstalled library and exit
8556     if test "$opt_mode" = relink; then
8557       $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8558
8559       if test -n "$convenience"; then
8560         if test -z "$whole_archive_flag_spec"; then
8561           func_show_eval '${RM}r "$gentop"'
8562         fi
8563       fi
8564
8565       exit $EXIT_SUCCESS
8566     fi
8567
8568     # Create links to the real library.
8569     for linkname in $linknames; do
8570       if test "$realname" != "$linkname"; then
8571         func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8572       fi
8573     done
8574
8575     # If -module or -export-dynamic was specified, set the dlname.
8576     if test "$module" = yes || test "$export_dynamic" = yes; then
8577       # On all known operating systems, these are identical.
8578       dlname="$soname"
8579     fi
8580       fi
8581       ;;
8582
8583     obj)
8584       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8585     func_warning "\`-dlopen' is ignored for objects"
8586       fi
8587
8588       case " $deplibs" in
8589       *\ -l* | *\ -L*)
8590     func_warning "\`-l' and \`-L' are ignored for objects" ;;
8591       esac
8592
8593       test -n "$rpath" && \
8594     func_warning "\`-rpath' is ignored for objects"
8595
8596       test -n "$xrpath" && \
8597     func_warning "\`-R' is ignored for objects"
8598
8599       test -n "$vinfo" && \
8600     func_warning "\`-version-info' is ignored for objects"
8601
8602       test -n "$release" && \
8603     func_warning "\`-release' is ignored for objects"
8604
8605       case $output in
8606       *.lo)
8607     test -n "$objs$old_deplibs" && \
8608       func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8609
8610     libobj=$output
8611     func_lo2o "$libobj"
8612     obj=$func_lo2o_result
8613     ;;
8614       *)
8615     libobj=
8616     obj="$output"
8617     ;;
8618       esac
8619
8620       # Delete the old objects.
8621       $opt_dry_run || $RM $obj $libobj
8622
8623       # Objects from convenience libraries.  This assumes
8624       # single-version convenience libraries.  Whenever we create
8625       # different ones for PIC/non-PIC, this we'll have to duplicate
8626       # the extraction.
8627       reload_conv_objs=
8628       gentop=
8629       # reload_cmds runs $LD directly, so let us get rid of
8630       # -Wl from whole_archive_flag_spec and hope we can get by with
8631       # turning comma into space..
8632       wl=
8633
8634       if test -n "$convenience"; then
8635     if test -n "$whole_archive_flag_spec"; then
8636       eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8637       reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8638     else
8639       gentop="$output_objdir/${obj}x"
8640       func_append generated " $gentop"
8641
8642       func_extract_archives $gentop $convenience
8643       reload_conv_objs="$reload_objs $func_extract_archives_result"
8644     fi
8645       fi
8646
8647       # If we're not building shared, we need to use non_pic_objs
8648       test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8649
8650       # Create the old-style object.
8651       reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8652
8653       output="$obj"
8654       func_execute_cmds "$reload_cmds" 'exit $?'
8655
8656       # Exit if we aren't doing a library object file.
8657       if test -z "$libobj"; then
8658     if test -n "$gentop"; then
8659       func_show_eval '${RM}r "$gentop"'
8660     fi
8661
8662     exit $EXIT_SUCCESS
8663       fi
8664
8665       if test "$build_libtool_libs" != yes; then
8666     if test -n "$gentop"; then
8667       func_show_eval '${RM}r "$gentop"'
8668     fi
8669
8670     # Create an invalid libtool object if no PIC, so that we don't
8671     # accidentally link it into a program.
8672     # $show "echo timestamp > $libobj"
8673     # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8674     exit $EXIT_SUCCESS
8675       fi
8676
8677       if test -n "$pic_flag" || test "$pic_mode" != default; then
8678     # Only do commands if we really have different PIC objects.
8679     reload_objs="$libobjs $reload_conv_objs"
8680     output="$libobj"
8681     func_execute_cmds "$reload_cmds" 'exit $?'
8682       fi
8683
8684       if test -n "$gentop"; then
8685     func_show_eval '${RM}r "$gentop"'
8686       fi
8687
8688       exit $EXIT_SUCCESS
8689       ;;
8690
8691     prog)
8692       case $host in
8693     *cygwin*) func_stripname '' '.exe' "$output"
8694               output=$func_stripname_result.exe;;
8695       esac
8696       test -n "$vinfo" && \
8697     func_warning "\`-version-info' is ignored for programs"
8698
8699       test -n "$release" && \
8700     func_warning "\`-release' is ignored for programs"
8701
8702       test "$preload" = yes \
8703         && test "$dlopen_support" = unknown \
8704     && test "$dlopen_self" = unknown \
8705     && test "$dlopen_self_static" = unknown && \
8706       func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8707
8708       case $host in
8709       *-*-rhapsody* | *-*-darwin1.[012])
8710     # On Rhapsody replace the C library is the System framework
8711     compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8712     finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8713     ;;
8714       esac
8715
8716       case $host in
8717       *-*-darwin*)
8718     # Don't allow lazy linking, it breaks C++ global constructors
8719     # But is supposedly fixed on 10.4 or later (yay!).
8720     if test "$tagname" = CXX ; then
8721       case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8722         10.[0123])
8723           func_append compile_command " ${wl}-bind_at_load"
8724           func_append finalize_command " ${wl}-bind_at_load"
8725         ;;
8726       esac
8727     fi
8728     # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8729     compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730     finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8731     ;;
8732       esac
8733
8734
8735       # move library search paths that coincide with paths to not yet
8736       # installed libraries to the beginning of the library search list
8737       new_libs=
8738       for path in $notinst_path; do
8739     case " $new_libs " in
8740     *" -L$path/$objdir "*) ;;
8741     *)
8742       case " $compile_deplibs " in
8743       *" -L$path/$objdir "*)
8744         func_append new_libs " -L$path/$objdir" ;;
8745       esac
8746       ;;
8747     esac
8748       done
8749       for deplib in $compile_deplibs; do
8750     case $deplib in
8751     -L*)
8752       case " $new_libs " in
8753       *" $deplib "*) ;;
8754       *) func_append new_libs " $deplib" ;;
8755       esac
8756       ;;
8757     *) func_append new_libs " $deplib" ;;
8758     esac
8759       done
8760       compile_deplibs="$new_libs"
8761
8762
8763       func_append compile_command " $compile_deplibs"
8764       func_append finalize_command " $finalize_deplibs"
8765
8766       if test -n "$rpath$xrpath"; then
8767     # If the user specified any rpath flags, then add them.
8768     for libdir in $rpath $xrpath; do
8769       # This is the magic to use -rpath.
8770       case "$finalize_rpath " in
8771       *" $libdir "*) ;;
8772       *) func_append finalize_rpath " $libdir" ;;
8773       esac
8774     done
8775       fi
8776
8777       # Now hardcode the library paths
8778       rpath=
8779       hardcode_libdirs=
8780       for libdir in $compile_rpath $finalize_rpath; do
8781     if test -n "$hardcode_libdir_flag_spec"; then
8782       if test -n "$hardcode_libdir_separator"; then
8783         if test -z "$hardcode_libdirs"; then
8784           hardcode_libdirs="$libdir"
8785         else
8786           # Just accumulate the unique libdirs.
8787           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8788           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8789         ;;
8790           *)
8791         func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8792         ;;
8793           esac
8794         fi
8795       else
8796         eval flag=\"$hardcode_libdir_flag_spec\"
8797         func_append rpath " $flag"
8798       fi
8799     elif test -n "$runpath_var"; then
8800       case "$perm_rpath " in
8801       *" $libdir "*) ;;
8802       *) func_append perm_rpath " $libdir" ;;
8803       esac
8804     fi
8805     case $host in
8806     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8807       testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8808       case :$dllsearchpath: in
8809       *":$libdir:"*) ;;
8810       ::) dllsearchpath=$libdir;;
8811       *) func_append dllsearchpath ":$libdir";;
8812       esac
8813       case :$dllsearchpath: in
8814       *":$testbindir:"*) ;;
8815       ::) dllsearchpath=$testbindir;;
8816       *) func_append dllsearchpath ":$testbindir";;
8817       esac
8818       ;;
8819     esac
8820       done
8821       # Substitute the hardcoded libdirs into the rpath.
8822       if test -n "$hardcode_libdir_separator" &&
8823      test -n "$hardcode_libdirs"; then
8824     libdir="$hardcode_libdirs"
8825     eval rpath=\" $hardcode_libdir_flag_spec\"
8826       fi
8827       compile_rpath="$rpath"
8828
8829       rpath=
8830       hardcode_libdirs=
8831       for libdir in $finalize_rpath; do
8832     if test -n "$hardcode_libdir_flag_spec"; then
8833       if test -n "$hardcode_libdir_separator"; then
8834         if test -z "$hardcode_libdirs"; then
8835           hardcode_libdirs="$libdir"
8836         else
8837           # Just accumulate the unique libdirs.
8838           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8839           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8840         ;;
8841           *)
8842         func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8843         ;;
8844           esac
8845         fi
8846       else
8847         eval flag=\"$hardcode_libdir_flag_spec\"
8848         func_append rpath " $flag"
8849       fi
8850     elif test -n "$runpath_var"; then
8851       case "$finalize_perm_rpath " in
8852       *" $libdir "*) ;;
8853       *) func_append finalize_perm_rpath " $libdir" ;;
8854       esac
8855     fi
8856       done
8857       # Substitute the hardcoded libdirs into the rpath.
8858       if test -n "$hardcode_libdir_separator" &&
8859      test -n "$hardcode_libdirs"; then
8860     libdir="$hardcode_libdirs"
8861     eval rpath=\" $hardcode_libdir_flag_spec\"
8862       fi
8863       finalize_rpath="$rpath"
8864
8865       if test -n "$libobjs" && test "$build_old_libs" = yes; then
8866     # Transform all the library objects into standard objects.
8867     compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8868     finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8869       fi
8870
8871       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8872
8873       # template prelinking step
8874       if test -n "$prelink_cmds"; then
8875     func_execute_cmds "$prelink_cmds" 'exit $?'
8876       fi
8877
8878       wrappers_required=yes
8879       case $host in
8880       *cegcc* | *mingw32ce*)
8881         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8882         wrappers_required=no
8883         ;;
8884       *cygwin* | *mingw* )
8885         if test "$build_libtool_libs" != yes; then
8886           wrappers_required=no
8887         fi
8888         ;;
8889       *)
8890         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8891           wrappers_required=no
8892         fi
8893         ;;
8894       esac
8895       if test "$wrappers_required" = no; then
8896     # Replace the output file specification.
8897     compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8898     link_command="$compile_command$compile_rpath"
8899
8900     # We have no uninstalled library dependencies, so finalize right now.
8901     exit_status=0
8902     func_show_eval "$link_command" 'exit_status=$?'
8903
8904     if test -n "$postlink_cmds"; then
8905       func_to_tool_file "$output"
8906       postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8907       func_execute_cmds "$postlink_cmds" 'exit $?'
8908     fi
8909
8910     # Delete the generated files.
8911     if test -f "$output_objdir/${outputname}S.${objext}"; then
8912       func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8913     fi
8914
8915     exit $exit_status
8916       fi
8917
8918       if test -n "$compile_shlibpath$finalize_shlibpath"; then
8919     compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8920       fi
8921       if test -n "$finalize_shlibpath"; then
8922     finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8923       fi
8924
8925       compile_var=
8926       finalize_var=
8927       if test -n "$runpath_var"; then
8928     if test -n "$perm_rpath"; then
8929       # We should set the runpath_var.
8930       rpath=
8931       for dir in $perm_rpath; do
8932         func_append rpath "$dir:"
8933       done
8934       compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8935     fi
8936     if test -n "$finalize_perm_rpath"; then
8937       # We should set the runpath_var.
8938       rpath=
8939       for dir in $finalize_perm_rpath; do
8940         func_append rpath "$dir:"
8941       done
8942       finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8943     fi
8944       fi
8945
8946       if test "$no_install" = yes; then
8947     # We don't need to create a wrapper script.
8948     link_command="$compile_var$compile_command$compile_rpath"
8949     # Replace the output file specification.
8950     link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8951     # Delete the old output file.
8952     $opt_dry_run || $RM $output
8953     # Link the executable and exit
8954     func_show_eval "$link_command" 'exit $?'
8955
8956     if test -n "$postlink_cmds"; then
8957       func_to_tool_file "$output"
8958       postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8959       func_execute_cmds "$postlink_cmds" 'exit $?'
8960     fi
8961
8962     exit $EXIT_SUCCESS
8963       fi
8964
8965       if test "$hardcode_action" = relink; then
8966     # Fast installation is not supported
8967     link_command="$compile_var$compile_command$compile_rpath"
8968     relink_command="$finalize_var$finalize_command$finalize_rpath"
8969
8970     func_warning "this platform does not like uninstalled shared libraries"
8971     func_warning "\`$output' will be relinked during installation"
8972       else
8973     if test "$fast_install" != no; then
8974       link_command="$finalize_var$compile_command$finalize_rpath"
8975       if test "$fast_install" = yes; then
8976         relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8977       else
8978         # fast_install is set to needless
8979         relink_command=
8980       fi
8981     else
8982       link_command="$compile_var$compile_command$compile_rpath"
8983       relink_command="$finalize_var$finalize_command$finalize_rpath"
8984     fi
8985       fi
8986
8987       # Replace the output file specification.
8988       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8989
8990       # Delete the old output files.
8991       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8992
8993       func_show_eval "$link_command" 'exit $?'
8994
8995       if test -n "$postlink_cmds"; then
8996     func_to_tool_file "$output_objdir/$outputname"
8997     postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8998     func_execute_cmds "$postlink_cmds" 'exit $?'
8999       fi
9000
9001       # Now create the wrapper script.
9002       func_verbose "creating $output"
9003
9004       # Quote the relink command for shipping.
9005       if test -n "$relink_command"; then
9006     # Preserve any variables that may affect compiler behavior
9007     for var in $variables_saved_for_relink; do
9008       if eval test -z \"\${$var+set}\"; then
9009         relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9010       elif eval var_value=\$$var; test -z "$var_value"; then
9011         relink_command="$var=; export $var; $relink_command"
9012       else
9013         func_quote_for_eval "$var_value"
9014         relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9015       fi
9016     done
9017     relink_command="(cd `pwd`; $relink_command)"
9018     relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9019       fi
9020
9021       # Only actually do things if not in dry run mode.
9022       $opt_dry_run || {
9023     # win32 will think the script is a binary if it has
9024     # a .exe suffix, so we strip it off here.
9025     case $output in
9026       *.exe) func_stripname '' '.exe' "$output"
9027              output=$func_stripname_result ;;
9028     esac
9029     # test for cygwin because mv fails w/o .exe extensions
9030     case $host in
9031       *cygwin*)
9032         exeext=.exe
9033         func_stripname '' '.exe' "$outputname"
9034         outputname=$func_stripname_result ;;
9035       *) exeext= ;;
9036     esac
9037     case $host in
9038       *cygwin* | *mingw* )
9039         func_dirname_and_basename "$output" "" "."
9040         output_name=$func_basename_result
9041         output_path=$func_dirname_result
9042         cwrappersource="$output_path/$objdir/lt-$output_name.c"
9043         cwrapper="$output_path/$output_name.exe"
9044         $RM $cwrappersource $cwrapper
9045         trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9046
9047         func_emit_cwrapperexe_src > $cwrappersource
9048
9049         # The wrapper executable is built using the $host compiler,
9050         # because it contains $host paths and files. If cross-
9051         # compiling, it, like the target executable, must be
9052         # executed on the $host or under an emulation environment.
9053         $opt_dry_run || {
9054           $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9055           $STRIP $cwrapper
9056         }
9057
9058         # Now, create the wrapper script for func_source use:
9059         func_ltwrapper_scriptname $cwrapper
9060         $RM $func_ltwrapper_scriptname_result
9061         trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9062         $opt_dry_run || {
9063           # note: this script will not be executed, so do not chmod.
9064           if test "x$build" = "x$host" ; then
9065         $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9066           else
9067         func_emit_wrapper no > $func_ltwrapper_scriptname_result
9068           fi
9069         }
9070       ;;
9071       * )
9072         $RM $output
9073         trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9074
9075         func_emit_wrapper no > $output
9076         chmod +x $output
9077       ;;
9078     esac
9079       }
9080       exit $EXIT_SUCCESS
9081       ;;
9082     esac
9083
9084     # See if we need to build an old-fashioned archive.
9085     for oldlib in $oldlibs; do
9086
9087       if test "$build_libtool_libs" = convenience; then
9088     oldobjs="$libobjs_save $symfileobj"
9089     addlibs="$convenience"
9090     build_libtool_libs=no
9091       else
9092     if test "$build_libtool_libs" = module; then
9093       oldobjs="$libobjs_save"
9094       build_libtool_libs=no
9095     else
9096       oldobjs="$old_deplibs $non_pic_objects"
9097       if test "$preload" = yes && test -f "$symfileobj"; then
9098         func_append oldobjs " $symfileobj"
9099       fi
9100     fi
9101     addlibs="$old_convenience"
9102       fi
9103
9104       if test -n "$addlibs"; then
9105     gentop="$output_objdir/${outputname}x"
9106     func_append generated " $gentop"
9107
9108     func_extract_archives $gentop $addlibs
9109     func_append oldobjs " $func_extract_archives_result"
9110       fi
9111
9112       # Do each command in the archive commands.
9113       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9114     cmds=$old_archive_from_new_cmds
9115       else
9116
9117     # Add any objects from preloaded convenience libraries
9118     if test -n "$dlprefiles"; then
9119       gentop="$output_objdir/${outputname}x"
9120       func_append generated " $gentop"
9121
9122       func_extract_archives $gentop $dlprefiles
9123       func_append oldobjs " $func_extract_archives_result"
9124     fi
9125
9126     # POSIX demands no paths to be encoded in archives.  We have
9127     # to avoid creating archives with duplicate basenames if we
9128     # might have to extract them afterwards, e.g., when creating a
9129     # static archive out of a convenience library, or when linking
9130     # the entirety of a libtool archive into another (currently
9131     # not supported by libtool).
9132     if (for obj in $oldobjs
9133         do
9134           func_basename "$obj"
9135           $ECHO "$func_basename_result"
9136         done | sort | sort -uc >/dev/null 2>&1); then
9137       :
9138     else
9139       echo "copying selected object files to avoid basename conflicts..."
9140       gentop="$output_objdir/${outputname}x"
9141       func_append generated " $gentop"
9142       func_mkdir_p "$gentop"
9143       save_oldobjs=$oldobjs
9144       oldobjs=
9145       counter=1
9146       for obj in $save_oldobjs
9147       do
9148         func_basename "$obj"
9149         objbase="$func_basename_result"
9150         case " $oldobjs " in
9151         " ") oldobjs=$obj ;;
9152         *[\ /]"$objbase "*)
9153           while :; do
9154         # Make sure we don't pick an alternate name that also
9155         # overlaps.
9156         newobj=lt$counter-$objbase
9157         func_arith $counter + 1
9158         counter=$func_arith_result
9159         case " $oldobjs " in
9160         *[\ /]"$newobj "*) ;;
9161         *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9162         esac
9163           done
9164           func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9165           func_append oldobjs " $gentop/$newobj"
9166           ;;
9167         *) func_append oldobjs " $obj" ;;
9168         esac
9169       done
9170     fi
9171     func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9172     tool_oldlib=$func_to_tool_file_result
9173     eval cmds=\"$old_archive_cmds\"
9174
9175     func_len " $cmds"
9176     len=$func_len_result
9177     if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9178       cmds=$old_archive_cmds
9179     elif test -n "$archiver_list_spec"; then
9180       func_verbose "using command file archive linking..."
9181       for obj in $oldobjs
9182       do
9183         func_to_tool_file "$obj"
9184         $ECHO "$func_to_tool_file_result"
9185       done > $output_objdir/$libname.libcmd
9186       func_to_tool_file "$output_objdir/$libname.libcmd"
9187       oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9188       cmds=$old_archive_cmds
9189     else
9190       # the command line is too long to link in one step, link in parts
9191       func_verbose "using piecewise archive linking..."
9192       save_RANLIB=$RANLIB
9193       RANLIB=:
9194       objlist=
9195       concat_cmds=
9196       save_oldobjs=$oldobjs
9197       oldobjs=
9198       # Is there a better way of finding the last object in the list?
9199       for obj in $save_oldobjs
9200       do
9201         last_oldobj=$obj
9202       done
9203       eval test_cmds=\"$old_archive_cmds\"
9204       func_len " $test_cmds"
9205       len0=$func_len_result
9206       len=$len0
9207       for obj in $save_oldobjs
9208       do
9209         func_len " $obj"
9210         func_arith $len + $func_len_result
9211         len=$func_arith_result
9212         func_append objlist " $obj"
9213         if test "$len" -lt "$max_cmd_len"; then
9214           :
9215         else
9216           # the above command should be used before it gets too long
9217           oldobjs=$objlist
9218           if test "$obj" = "$last_oldobj" ; then
9219         RANLIB=$save_RANLIB
9220           fi
9221           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9222           eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9223           objlist=
9224           len=$len0
9225         fi
9226       done
9227       RANLIB=$save_RANLIB
9228       oldobjs=$objlist
9229       if test "X$oldobjs" = "X" ; then
9230         eval cmds=\"\$concat_cmds\"
9231       else
9232         eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9233       fi
9234     fi
9235       fi
9236       func_execute_cmds "$cmds" 'exit $?'
9237     done
9238
9239     test -n "$generated" && \
9240       func_show_eval "${RM}r$generated"
9241
9242     # Now create the libtool archive.
9243     case $output in
9244     *.la)
9245       old_library=
9246       test "$build_old_libs" = yes && old_library="$libname.$libext"
9247       func_verbose "creating $output"
9248
9249       # Preserve any variables that may affect compiler behavior
9250       for var in $variables_saved_for_relink; do
9251     if eval test -z \"\${$var+set}\"; then
9252       relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9253     elif eval var_value=\$$var; test -z "$var_value"; then
9254       relink_command="$var=; export $var; $relink_command"
9255     else
9256       func_quote_for_eval "$var_value"
9257       relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9258     fi
9259       done
9260       # Quote the link command for shipping.
9261       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9262       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9263       if test "$hardcode_automatic" = yes ; then
9264     relink_command=
9265       fi
9266
9267       # Only create the output if not a dry run.
9268       $opt_dry_run || {
9269     for installed in no yes; do
9270       if test "$installed" = yes; then
9271         if test -z "$install_libdir"; then
9272           break
9273         fi
9274         output="$output_objdir/$outputname"i
9275         # Replace all uninstalled libtool libraries with the installed ones
9276         newdependency_libs=
9277         for deplib in $dependency_libs; do
9278           case $deplib in
9279           *.la)
9280         func_basename "$deplib"
9281         name="$func_basename_result"
9282         func_resolve_sysroot "$deplib"
9283         eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9284         test -z "$libdir" && \
9285           func_fatal_error "\`$deplib' is not a valid libtool archive"
9286         func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9287         ;;
9288           -L*)
9289         func_stripname -L '' "$deplib"
9290         func_replace_sysroot "$func_stripname_result"
9291         func_append newdependency_libs " -L$func_replace_sysroot_result"
9292         ;;
9293           -R*)
9294         func_stripname -R '' "$deplib"
9295         func_replace_sysroot "$func_stripname_result"
9296         func_append newdependency_libs " -R$func_replace_sysroot_result"
9297         ;;
9298           *) func_append newdependency_libs " $deplib" ;;
9299           esac
9300         done
9301         dependency_libs="$newdependency_libs"
9302         newdlfiles=
9303
9304         for lib in $dlfiles; do
9305           case $lib in
9306           *.la)
9307             func_basename "$lib"
9308         name="$func_basename_result"
9309         eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310         test -z "$libdir" && \
9311           func_fatal_error "\`$lib' is not a valid libtool archive"
9312         func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9313         ;;
9314           *) func_append newdlfiles " $lib" ;;
9315           esac
9316         done
9317         dlfiles="$newdlfiles"
9318         newdlprefiles=
9319         for lib in $dlprefiles; do
9320           case $lib in
9321           *.la)
9322         # Only pass preopened files to the pseudo-archive (for
9323         # eventual linking with the app. that links it) if we
9324         # didn't already link the preopened objects directly into
9325         # the library:
9326         func_basename "$lib"
9327         name="$func_basename_result"
9328         eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9329         test -z "$libdir" && \
9330           func_fatal_error "\`$lib' is not a valid libtool archive"
9331         func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9332         ;;
9333           esac
9334         done
9335         dlprefiles="$newdlprefiles"
9336       else
9337         newdlfiles=
9338         for lib in $dlfiles; do
9339           case $lib in
9340         [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9341         *) abs=`pwd`"/$lib" ;;
9342           esac
9343           func_append newdlfiles " $abs"
9344         done
9345         dlfiles="$newdlfiles"
9346         newdlprefiles=
9347         for lib in $dlprefiles; do
9348           case $lib in
9349         [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9350         *) abs=`pwd`"/$lib" ;;
9351           esac
9352           func_append newdlprefiles " $abs"
9353         done
9354         dlprefiles="$newdlprefiles"
9355       fi
9356       $RM $output
9357       # place dlname in correct position for cygwin
9358       # In fact, it would be nice if we could use this code for all target
9359       # systems that can't hard-code library paths into their executables
9360       # and that have no shared library path variable independent of PATH,
9361       # but it turns out we can't easily determine that from inspecting
9362       # libtool variables, so we have to hard-code the OSs to which it
9363       # applies here; at the moment, that means platforms that use the PE
9364       # object format with DLL files.  See the long comment at the top of
9365       # tests/bindir.at for full details.
9366       tdlname=$dlname
9367       case $host,$output,$installed,$module,$dlname in
9368         *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9369           # If a -bindir argument was supplied, place the dll there.
9370           if test "x$bindir" != x ;
9371           then
9372         func_relative_path "$install_libdir" "$bindir"
9373         tdlname=$func_relative_path_result$dlname
9374           else
9375         # Otherwise fall back on heuristic.
9376         tdlname=../bin/$dlname
9377           fi
9378           ;;
9379       esac
9380       $ECHO > $output "\
9381 # $outputname - a libtool library file
9382 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9383 #
9384 # Please DO NOT delete this file!
9385 # It is necessary for linking the library.
9386
9387 # The name that we can dlopen(3).
9388 dlname='$tdlname'
9389
9390 # Names of this library.
9391 library_names='$library_names'
9392
9393 # The name of the static archive.
9394 old_library='$old_library'
9395
9396 # Linker flags that can not go in dependency_libs.
9397 inherited_linker_flags='$new_inherited_linker_flags'
9398
9399 # Libraries that this one depends upon.
9400 dependency_libs='$dependency_libs'
9401
9402 # Names of additional weak libraries provided by this library
9403 weak_library_names='$weak_libs'
9404
9405 # Version information for $libname.
9406 current=$current
9407 age=$age
9408 revision=$revision
9409
9410 # Is this an already installed library?
9411 installed=$installed
9412
9413 # Should we warn about portability when linking against -modules?
9414 shouldnotlink=$module
9415
9416 # Files to dlopen/dlpreopen
9417 dlopen='$dlfiles'
9418 dlpreopen='$dlprefiles'
9419
9420 # Directory that this library needs to be installed in:
9421 libdir='$install_libdir'"
9422       if test "$installed" = no && test "$need_relink" = yes; then
9423         $ECHO >> $output "\
9424 relink_command=\"$relink_command\""
9425       fi
9426     done
9427       }
9428
9429       # Do a symbolic link so that the libtool archive can be found in
9430       # LD_LIBRARY_PATH before the program is installed.
9431       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9432       ;;
9433     esac
9434     exit $EXIT_SUCCESS
9435 }
9436
9437 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9438     func_mode_link ${1+"$@"}
9439
9440
9441 # func_mode_uninstall arg...
9442 func_mode_uninstall ()
9443 {
9444     $opt_debug
9445     RM="$nonopt"
9446     files=
9447     rmforce=
9448     exit_status=0
9449
9450     # This variable tells wrapper scripts just to set variables rather
9451     # than running their programs.
9452     libtool_install_magic="$magic"
9453
9454     for arg
9455     do
9456       case $arg in
9457       -f) func_append RM " $arg"; rmforce=yes ;;
9458       -*) func_append RM " $arg" ;;
9459       *) func_append files " $arg" ;;
9460       esac
9461     done
9462
9463     test -z "$RM" && \
9464       func_fatal_help "you must specify an RM program"
9465
9466     rmdirs=
9467
9468     for file in $files; do
9469       func_dirname "$file" "" "."
9470       dir="$func_dirname_result"
9471       if test "X$dir" = X.; then
9472     odir="$objdir"
9473       else
9474     odir="$dir/$objdir"
9475       fi
9476       func_basename "$file"
9477       name="$func_basename_result"
9478       test "$opt_mode" = uninstall && odir="$dir"
9479
9480       # Remember odir for removal later, being careful to avoid duplicates
9481       if test "$opt_mode" = clean; then
9482     case " $rmdirs " in
9483       *" $odir "*) ;;
9484       *) func_append rmdirs " $odir" ;;
9485     esac
9486       fi
9487
9488       # Don't error if the file doesn't exist and rm -f was used.
9489       if { test -L "$file"; } >/dev/null 2>&1 ||
9490      { test -h "$file"; } >/dev/null 2>&1 ||
9491      test -f "$file"; then
9492     :
9493       elif test -d "$file"; then
9494     exit_status=1
9495     continue
9496       elif test "$rmforce" = yes; then
9497     continue
9498       fi
9499
9500       rmfiles="$file"
9501
9502       case $name in
9503       *.la)
9504     # Possibly a libtool archive, so verify it.
9505     if func_lalib_p "$file"; then
9506       func_source $dir/$name
9507
9508       # Delete the libtool libraries and symlinks.
9509       for n in $library_names; do
9510         func_append rmfiles " $odir/$n"
9511       done
9512       test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9513
9514       case "$opt_mode" in
9515       clean)
9516         case " $library_names " in
9517         *" $dlname "*) ;;
9518         *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9519         esac
9520         test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9521         ;;
9522       uninstall)
9523         if test -n "$library_names"; then
9524           # Do each command in the postuninstall commands.
9525           func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9526         fi
9527
9528         if test -n "$old_library"; then
9529           # Do each command in the old_postuninstall commands.
9530           func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9531         fi
9532         # FIXME: should reinstall the best remaining shared library.
9533         ;;
9534       esac
9535     fi
9536     ;;
9537
9538       *.lo)
9539     # Possibly a libtool object, so verify it.
9540     if func_lalib_p "$file"; then
9541
9542       # Read the .lo file
9543       func_source $dir/$name
9544
9545       # Add PIC object to the list of files to remove.
9546       if test -n "$pic_object" &&
9547          test "$pic_object" != none; then
9548         func_append rmfiles " $dir/$pic_object"
9549       fi
9550
9551       # Add non-PIC object to the list of files to remove.
9552       if test -n "$non_pic_object" &&
9553          test "$non_pic_object" != none; then
9554         func_append rmfiles " $dir/$non_pic_object"
9555       fi
9556     fi
9557     ;;
9558
9559       *)
9560     if test "$opt_mode" = clean ; then
9561       noexename=$name
9562       case $file in
9563       *.exe)
9564         func_stripname '' '.exe' "$file"
9565         file=$func_stripname_result
9566         func_stripname '' '.exe' "$name"
9567         noexename=$func_stripname_result
9568         # $file with .exe has already been added to rmfiles,
9569         # add $file without .exe
9570         func_append rmfiles " $file"
9571         ;;
9572       esac
9573       # Do a test to see if this is a libtool program.
9574       if func_ltwrapper_p "$file"; then
9575         if func_ltwrapper_executable_p "$file"; then
9576           func_ltwrapper_scriptname "$file"
9577           relink_command=
9578           func_source $func_ltwrapper_scriptname_result
9579           func_append rmfiles " $func_ltwrapper_scriptname_result"
9580         else
9581           relink_command=
9582           func_source $dir/$noexename
9583         fi
9584
9585         # note $name still contains .exe if it was in $file originally
9586         # as does the version of $file that was added into $rmfiles
9587         func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9588         if test "$fast_install" = yes && test -n "$relink_command"; then
9589           func_append rmfiles " $odir/lt-$name"
9590         fi
9591         if test "X$noexename" != "X$name" ; then
9592           func_append rmfiles " $odir/lt-${noexename}.c"
9593         fi
9594       fi
9595     fi
9596     ;;
9597       esac
9598       func_show_eval "$RM $rmfiles" 'exit_status=1'
9599     done
9600
9601     # Try to remove the ${objdir}s in the directories where we deleted files
9602     for dir in $rmdirs; do
9603       if test -d "$dir"; then
9604     func_show_eval "rmdir $dir >/dev/null 2>&1"
9605       fi
9606     done
9607
9608     exit $exit_status
9609 }
9610
9611 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9612     func_mode_uninstall ${1+"$@"}
9613
9614 test -z "$opt_mode" && {
9615   help="$generic_help"
9616   func_fatal_help "you must specify a MODE"
9617 }
9618
9619 test -z "$exec_cmd" && \
9620   func_fatal_help "invalid operation mode \`$opt_mode'"
9621
9622 if test -n "$exec_cmd"; then
9623   eval exec "$exec_cmd"
9624   exit $EXIT_FAILURE
9625 fi
9626
9627 exit $exit_status
9628
9629
9630 # The TAGs below are defined such that we never get into a situation
9631 # in which we disable both kinds of libraries.  Given conflicting
9632 # choices, we go for a static library, that is the most portable,
9633 # since we can't tell whether shared libraries were disabled because
9634 # the user asked for that or because the platform doesn't support
9635 # them.  This is particularly important on AIX, because we don't
9636 # support having both static and shared libraries enabled at the same
9637 # time on that platform, so we default to a shared-only configuration.
9638 # If a disable-shared tag is given, we'll fallback to a static-only
9639 # configuration.  But we'll never go from static-only to shared-only.
9640
9641 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9642 build_libtool_libs=no
9643 build_old_libs=yes
9644 # ### END LIBTOOL TAG CONFIG: disable-shared
9645
9646 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9647 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9648 # ### END LIBTOOL TAG CONFIG: disable-static
9649
9650 # Local Variables:
9651 # mode:shell-script
9652 # sh-indentation:2
9653 # End:
9654 # vi:sw=2
9655