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