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