Update copyright annotations and license boilerplates to correspond with SGI Legals...
[xfstests-dev.git] / dmapi / ltmain.sh
1 # ltmain.sh - Provide generalized library-building support services.
2 # NOTE: Changing this file will not affect anything until you rerun configure.
3 #
4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
5 # Free Software Foundation, Inc.
6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #
13 # This program is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 # General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #
22 # As a special exception to the GNU General Public License, if you
23 # distribute this file as part of a program that contains a
24 # configuration script generated by Autoconf, you may include it under
25 # the same distribution terms that you use for the rest of that program.
26
27 basename="s,^.*/,,g"
28
29 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
30 # is ksh but when the shell is invoked as "sh" and the current value of
31 # the _XPG environment variable is not equal to 1 (one), the special
32 # positional parameter $0, within a function call, is the name of the
33 # function.
34 progpath="$0"
35
36 # The name of this program:
37 progname=`echo "$progpath" | $SED $basename`
38 modename="$progname"
39
40 # Global variables:
41 EXIT_SUCCESS=0
42 EXIT_FAILURE=1
43
44 PROGRAM=ltmain.sh
45 PACKAGE=libtool
46 VERSION=1.5.8
47 TIMESTAMP=" (1.1220.2.118 2004/08/07 12:24:38)"
48
49 # See if we are running on zsh, and set the options which allow our
50 # commands through without removal of \ escapes.
51 if test -n "${ZSH_VERSION+set}" ; then
52   setopt NO_GLOB_SUBST
53 fi
54
55 # Check that we have a working $echo.
56 if test "X$1" = X--no-reexec; then
57   # Discard the --no-reexec flag, and continue.
58   shift
59 elif test "X$1" = X--fallback-echo; then
60   # Avoid inline document here, it may be left over
61   :
62 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
63   # Yippee, $echo works!
64   :
65 else
66   # Restart under the correct shell, and then maybe $echo will work.
67   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
68 fi
69
70 if test "X$1" = X--fallback-echo; then
71   # used as fallback echo
72   shift
73   cat <<EOF
74 $*
75 EOF
76   exit $EXIT_SUCCESS
77 fi
78
79 default_mode=
80 help="Try \`$progname --help' for more information."
81 magic="%%%MAGIC variable%%%"
82 mkdir="mkdir"
83 mv="mv -f"
84 rm="rm -f"
85
86 # Sed substitution that helps us do robust quoting.  It backslashifies
87 # metacharacters that are still active within double-quoted strings.
88 Xsed="${SED}"' -e 1s/^X//'
89 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
90 # test EBCDIC or ASCII
91 case `echo A|tr A '\301'` in
92  A) # EBCDIC based system
93   SP2NL="tr '\100' '\n'"
94   NL2SP="tr '\r\n' '\100\100'"
95   ;;
96  *) # Assume ASCII based system
97   SP2NL="tr '\040' '\012'"
98   NL2SP="tr '\015\012' '\040\040'"
99   ;;
100 esac
101
102 # NLS nuisances.
103 # Only set LANG and LC_ALL to C if already set.
104 # These must not be set unconditionally because not all systems understand
105 # e.g. LANG=C (notably SCO).
106 # We save the old values to restore during execute mode.
107 if test "${LC_ALL+set}" = set; then
108   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
109 fi
110 if test "${LANG+set}" = set; then
111   save_LANG="$LANG"; LANG=C; export LANG
112 fi
113
114 # Make sure IFS has a sensible default
115 : ${IFS="       
116 "}
117
118 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
119   $echo "$modename: not configured to build any kind of library" 1>&2
120   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
121   exit $EXIT_FAILURE
122 fi
123
124 # Global variables.
125 mode=$default_mode
126 nonopt=
127 prev=
128 prevopt=
129 run=
130 show="$echo"
131 show_help=
132 execute_dlfiles=
133 lo2o="s/\\.lo\$/.${objext}/"
134 o2lo="s/\\.${objext}\$/.lo/"
135
136 #####################################
137 # Shell function definitions:
138 # This seems to be the best place for them
139
140 # func_win32_libid arg
141 # return the library type of file 'arg'
142 #
143 # Need a lot of goo to handle *both* DLLs and import libs
144 # Has to be a shell function in order to 'eat' the argument
145 # that is supplied when $file_magic_command is called.
146 func_win32_libid () {
147   win32_libid_type="unknown"
148   win32_fileres=`file -L $1 2>/dev/null`
149   case $win32_fileres in
150   *ar\ archive\ import\ library*) # definitely import
151     win32_libid_type="x86 archive import"
152     ;;
153   *ar\ archive*) # could be an import, or static
154     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
155       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
156       win32_nmres=`eval $NM -f posix -A $1 | \
157         sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
158       if test "X$win32_nmres" = "Ximport" ; then
159         win32_libid_type="x86 archive import"
160       else
161         win32_libid_type="x86 archive static"
162       fi
163     fi
164     ;;
165   *DLL*)
166     win32_libid_type="x86 DLL"
167     ;;
168   *executable*) # but shell scripts are "executable" too...
169     case $win32_fileres in
170     *MS\ Windows\ PE\ Intel*)
171       win32_libid_type="x86 DLL"
172       ;;
173     esac
174     ;;
175   esac
176   $echo $win32_libid_type
177 }
178
179
180 # func_infer_tag arg
181 # Infer tagged configuration to use if any are available and
182 # if one wasn't chosen via the "--tag" command line option.
183 # Only attempt this if the compiler in the base compile
184 # command doesn't match the default compiler.
185 # arg is usually of the form 'gcc ...'
186 func_infer_tag () {
187     if test -n "$available_tags" && test -z "$tagname"; then
188       CC_quoted=
189       for arg in $CC; do
190         case $arg in
191           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
192           arg="\"$arg\""
193           ;;
194         esac
195         CC_quoted="$CC_quoted $arg"
196       done
197       case $@ in
198       # Blanks in the command may have been stripped by the calling shell,
199       # but not from the CC environment variable when configure was run.
200       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
201       # Blanks at the start of $base_compile will cause this to fail
202       # if we don't check for them as well.
203       *)
204         for z in $available_tags; do
205           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
206             # Evaluate the configuration.
207             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
208             CC_quoted=
209             for arg in $CC; do
210             # Double-quote args containing other shell metacharacters.
211             case $arg in
212               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
213               arg="\"$arg\""
214               ;;
215             esac
216             CC_quoted="$CC_quoted $arg"
217           done
218             case "$@ " in
219               " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
220               # The compiler in the base compile command matches
221               # the one in the tagged configuration.
222               # Assume this is the tagged configuration we want.
223               tagname=$z
224               break
225               ;;
226             esac
227           fi
228         done
229         # If $tagname still isn't set, then no tagged configuration
230         # was found and let the user know that the "--tag" command
231         # line option must be used.
232         if test -z "$tagname"; then
233           $echo "$modename: unable to infer tagged configuration"
234           $echo "$modename: specify a tag with \`--tag'" 1>&2
235           exit $EXIT_FAILURE
236 #        else
237 #          $echo "$modename: using $tagname tagged configuration"
238         fi
239         ;;
240       esac
241     fi
242 }
243
244
245 # func_extract_archives gentop oldlib ...
246 func_extract_archives () {
247     my_gentop="$1"; shift
248     my_oldlibs=${1+"$@"}
249     my_oldobjs=""
250     my_xlib=""
251     my_xabs=""
252     my_xdir=""
253     my_status=""
254
255     $show "${rm}r $my_gentop"
256     $run ${rm}r "$my_gentop"
257     $show "$mkdir $my_gentop"
258     $run $mkdir "$my_gentop"
259     my_status=$?
260     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
261       exit $my_status
262     fi
263
264     for my_xlib in $my_oldlibs; do
265       # Extract the objects.
266       case $my_xlib in
267         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
268         *) my_xabs=`pwd`"/$my_xlib" ;;
269       esac
270       my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
271       my_xdir="$my_gentop/$my_xlib"
272
273       $show "${rm}r $my_xdir"
274       $run ${rm}r "$my_xdir"
275       $show "$mkdir $my_xdir"
276       $run $mkdir "$my_xdir"
277       status=$?
278       if test "$status" -ne 0 && test ! -d "$my_xdir"; then
279         exit $status
280       fi
281       case $host in
282       *-darwin*)
283         $show "Extracting $my_xabs"
284         # Do not bother doing anything if just a dry run
285         if test -z "$run"; then
286           darwin_orig_dir=`pwd`
287           cd $my_xdir || exit $?
288           darwin_archive=$my_xabs
289           darwin_curdir=`pwd`
290           darwin_base_archive=`basename $darwin_archive`
291           darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
292           if test -n "$darwin_arches"; then 
293             darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
294             darwin_arch=
295             $show "$darwin_base_archive has multiple architectures $darwin_arches"
296             for darwin_arch in  $darwin_arches ; do
297               mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
298               lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
299               # Remove the table of contents from the thin files.
300               $AR -d "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" __.SYMDEF 2>/dev/null || true
301               $AR -d "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" __.SYMDEF\ SORTED 2>/dev/null || true
302               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
303               $AR -xo "${darwin_base_archive}"
304               rm "${darwin_base_archive}"
305               cd "$darwin_curdir"
306             done # $darwin_arches
307       ## Okay now we have a bunch of thin objects, gotta fatten them up :)
308             darwin_filelist=`find unfat-$$ -type f | xargs basename | sort -u | $NL2SP`
309             darwin_file=
310             darwin_files=
311             for darwin_file in $darwin_filelist; do
312               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
313               lipo -create -output "$darwin_file" $darwin_files
314             done # $darwin_filelist
315             rm -rf unfat-$$
316             cd "$darwin_orig_dir"
317           else
318             cd $darwin_orig_dir
319             (cd $my_xdir && $AR x $my_xabs) || exit $?
320           fi # $darwin_arches
321         fi # $run
322       ;;
323       *)
324         # We will extract separately just the conflicting names and we will
325         # no longer touch any unique names. It is faster to leave these
326         # extract automatically by $AR in one run.
327         $show "(cd $my_xdir && $AR x $my_xabs)"
328         $run eval "(cd \$my_xdir && $AR x \$my_xabs)" || exit $?
329         if ($AR t "$my_xabs" | sort | sort -uc >/dev/null 2>&1); then
330           :
331         else
332           $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
333           $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
334           $AR t "$my_xabs" | sort | uniq -cd | while read -r count name
335           do
336             i=1
337             while test "$i" -le "$count"
338             do
339               # Put our $i before any first dot (extension)
340               # Never overwrite any file
341               name_to="$name"
342               while test "X$name_to" = "X$name" || test -f "$my_xdir/$name_to"
343               do
344                 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
345               done
346               $show "(cd $my_xdir && $AR xN $i $my_xabs '$name' && $mv '$name' '$name_to')"
347               $run eval "(cd \$my_xdir && $AR xN $i \$my_xabs '$name' && $mv '$name' '$name_to')" || exit $?
348               i=`expr $i + 1`
349             done
350           done
351         fi
352         ;;
353       esac
354       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
355     done
356
357     func_extract_archives_result="$my_oldobjs"
358 }
359 # End of Shell function definitions
360 #####################################
361
362 # Darwin sucks
363 eval std_shrext=\"$shrext_cmds\"
364
365 # Parse our command line options once, thoroughly.
366 while test "$#" -gt 0
367 do
368   arg="$1"
369   shift
370
371   case $arg in
372   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
373   *) optarg= ;;
374   esac
375
376   # If the previous option needs an argument, assign it.
377   if test -n "$prev"; then
378     case $prev in
379     execute_dlfiles)
380       execute_dlfiles="$execute_dlfiles $arg"
381       ;;
382     tag)
383       tagname="$arg"
384       preserve_args="${preserve_args}=$arg"
385
386       # Check whether tagname contains only valid characters
387       case $tagname in
388       *[!-_A-Za-z0-9,/]*)
389         $echo "$progname: invalid tag name: $tagname" 1>&2
390         exit $EXIT_FAILURE
391         ;;
392       esac
393
394       case $tagname in
395       CC)
396         # Don't test for the "default" C tag, as we know, it's there, but
397         # not specially marked.
398         ;;
399       *)
400         if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
401           taglist="$taglist $tagname"
402           # Evaluate the configuration.
403           eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
404         else
405           $echo "$progname: ignoring unknown tag $tagname" 1>&2
406         fi
407         ;;
408       esac
409       ;;
410     *)
411       eval "$prev=\$arg"
412       ;;
413     esac
414
415     prev=
416     prevopt=
417     continue
418   fi
419
420   # Have we seen a non-optional argument yet?
421   case $arg in
422   --help)
423     show_help=yes
424     ;;
425
426   --version)
427     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
428     $echo
429     $echo "Copyright (C) 2003  Free Software Foundation, Inc."
430     $echo "This is free software; see the source for copying conditions.  There is NO"
431     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
432     exit $EXIT_SUCCESS
433     ;;
434
435   --config)
436     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
437     # Now print the configurations for the tags.
438     for tagname in $taglist; do
439       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
440     done
441     exit $EXIT_SUCCESS
442     ;;
443
444   --debug)
445     $echo "$progname: enabling shell trace mode"
446     set -x
447     preserve_args="$preserve_args $arg"
448     ;;
449
450   --dry-run | -n)
451     run=:
452     ;;
453
454   --features)
455     $echo "host: $host"
456     if test "$build_libtool_libs" = yes; then
457       $echo "enable shared libraries"
458     else
459       $echo "disable shared libraries"
460     fi
461     if test "$build_old_libs" = yes; then
462       $echo "enable static libraries"
463     else
464       $echo "disable static libraries"
465     fi
466     exit $EXIT_SUCCESS
467     ;;
468
469   --finish) mode="finish" ;;
470
471   --mode) prevopt="--mode" prev=mode ;;
472   --mode=*) mode="$optarg" ;;
473
474   --preserve-dup-deps) duplicate_deps="yes" ;;
475
476   --quiet | --silent)
477     show=:
478     preserve_args="$preserve_args $arg"
479     ;;
480
481   --tag) prevopt="--tag" prev=tag ;;
482   --tag=*)
483     set tag "$optarg" ${1+"$@"}
484     shift
485     prev=tag
486     preserve_args="$preserve_args --tag"
487     ;;
488
489   -dlopen)
490     prevopt="-dlopen"
491     prev=execute_dlfiles
492     ;;
493
494   -*)
495     $echo "$modename: unrecognized option \`$arg'" 1>&2
496     $echo "$help" 1>&2
497     exit $EXIT_FAILURE
498     ;;
499
500   *)
501     nonopt="$arg"
502     break
503     ;;
504   esac
505 done
506
507 if test -n "$prevopt"; then
508   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
509   $echo "$help" 1>&2
510   exit $EXIT_FAILURE
511 fi
512
513 # If this variable is set in any of the actions, the command in it
514 # will be execed at the end.  This prevents here-documents from being
515 # left over by shells.
516 exec_cmd=
517
518 if test -z "$show_help"; then
519
520   # Infer the operation mode.
521   if test -z "$mode"; then
522     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
523     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
524     case $nonopt in
525     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
526       mode=link
527       for arg
528       do
529         case $arg in
530         -c)
531            mode=compile
532            break
533            ;;
534         esac
535       done
536       ;;
537     *db | *dbx | *strace | *truss)
538       mode=execute
539       ;;
540     *install*|cp|mv)
541       mode=install
542       ;;
543     *rm)
544       mode=uninstall
545       ;;
546     *)
547       # If we have no mode, but dlfiles were specified, then do execute mode.
548       test -n "$execute_dlfiles" && mode=execute
549
550       # Just use the default operation mode.
551       if test -z "$mode"; then
552         if test -n "$nonopt"; then
553           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
554         else
555           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
556         fi
557       fi
558       ;;
559     esac
560   fi
561
562   # Only execute mode is allowed to have -dlopen flags.
563   if test -n "$execute_dlfiles" && test "$mode" != execute; then
564     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
565     $echo "$help" 1>&2
566     exit $EXIT_FAILURE
567   fi
568
569   # Change the help message to a mode-specific one.
570   generic_help="$help"
571   help="Try \`$modename --help --mode=$mode' for more information."
572
573   # These modes are in order of execution frequency so that they run quickly.
574   case $mode in
575   # libtool compile mode
576   compile)
577     modename="$modename: compile"
578     # Get the compilation command and the source file.
579     base_compile=
580     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
581     suppress_opt=yes
582     suppress_output=
583     arg_mode=normal
584     libobj=
585     later=
586
587     for arg
588     do
589       case "$arg_mode" in
590       arg  )
591         # do not "continue".  Instead, add this to base_compile
592         lastarg="$arg"
593         arg_mode=normal
594         ;;
595
596       target )
597         libobj="$arg"
598         arg_mode=normal
599         continue
600         ;;
601
602       normal )
603         # Accept any command-line options.
604         case $arg in
605         -o)
606           if test -n "$libobj" ; then
607             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
608             exit $EXIT_FAILURE
609           fi
610           arg_mode=target
611           continue
612           ;;
613
614         -static | -prefer-pic | -prefer-non-pic)
615           later="$later $arg"
616           continue
617           ;;
618
619         -no-suppress)
620           suppress_opt=no
621           continue
622           ;;
623
624         -Xcompiler)
625           arg_mode=arg  #  the next one goes into the "base_compile" arg list
626           continue      #  The current "srcfile" will either be retained or
627           ;;            #  replaced later.  I would guess that would be a bug.
628
629         -Wc,*)
630           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
631           lastarg=
632           save_ifs="$IFS"; IFS=','
633           for arg in $args; do
634             IFS="$save_ifs"
635
636             # Double-quote args containing other shell metacharacters.
637             # Many Bourne shells cannot handle close brackets correctly
638             # in scan sets, so we specify it separately.
639             case $arg in
640               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
641               arg="\"$arg\""
642               ;;
643             esac
644             lastarg="$lastarg $arg"
645           done
646           IFS="$save_ifs"
647           lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
648
649           # Add the arguments to base_compile.
650           base_compile="$base_compile $lastarg"
651           continue
652           ;;
653
654         * )
655           # Accept the current argument as the source file.
656           # The previous "srcfile" becomes the current argument.
657           #
658           lastarg="$srcfile"
659           srcfile="$arg"
660           ;;
661         esac  #  case $arg
662         ;;
663       esac    #  case $arg_mode
664
665       # Aesthetically quote the previous argument.
666       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
667
668       case $lastarg in
669       # Double-quote args containing other shell metacharacters.
670       # Many Bourne shells cannot handle close brackets correctly
671       # in scan sets, so we specify it separately.
672       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
673         lastarg="\"$lastarg\""
674         ;;
675       esac
676
677       base_compile="$base_compile $lastarg"
678     done # for arg
679
680     case $arg_mode in
681     arg)
682       $echo "$modename: you must specify an argument for -Xcompile"
683       exit $EXIT_FAILURE
684       ;;
685     target)
686       $echo "$modename: you must specify a target with \`-o'" 1>&2
687       exit $EXIT_FAILURE
688       ;;
689     *)
690       # Get the name of the library object.
691       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
692       ;;
693     esac
694
695     # Recognize several different file suffixes.
696     # If the user specifies -o file.o, it is replaced with file.lo
697     xform='[cCFSifmso]'
698     case $libobj in
699     *.ada) xform=ada ;;
700     *.adb) xform=adb ;;
701     *.ads) xform=ads ;;
702     *.asm) xform=asm ;;
703     *.c++) xform=c++ ;;
704     *.cc) xform=cc ;;
705     *.ii) xform=ii ;;
706     *.class) xform=class ;;
707     *.cpp) xform=cpp ;;
708     *.cxx) xform=cxx ;;
709     *.f90) xform=f90 ;;
710     *.for) xform=for ;;
711     *.java) xform=java ;;
712     esac
713
714     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
715
716     case $libobj in
717     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
718     *)
719       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
720       exit $EXIT_FAILURE
721       ;;
722     esac
723
724     func_infer_tag $base_compile
725
726     for arg in $later; do
727       case $arg in
728       -static)
729         build_old_libs=yes
730         continue
731         ;;
732
733       -prefer-pic)
734         pic_mode=yes
735         continue
736         ;;
737
738       -prefer-non-pic)
739         pic_mode=no
740         continue
741         ;;
742       esac
743     done
744
745     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
746     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
747     if test "X$xdir" = "X$obj"; then
748       xdir=
749     else
750       xdir=$xdir/
751     fi
752     lobj=${xdir}$objdir/$objname
753
754     if test -z "$base_compile"; then
755       $echo "$modename: you must specify a compilation command" 1>&2
756       $echo "$help" 1>&2
757       exit $EXIT_FAILURE
758     fi
759
760     # Delete any leftover library objects.
761     if test "$build_old_libs" = yes; then
762       removelist="$obj $lobj $libobj ${libobj}T"
763     else
764       removelist="$lobj $libobj ${libobj}T"
765     fi
766
767     $run $rm $removelist
768     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
769
770     # On Cygwin there's no "real" PIC flag so we must build both object types
771     case $host_os in
772     cygwin* | mingw* | pw32* | os2*)
773       pic_mode=default
774       ;;
775     esac
776     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
777       # non-PIC code in shared libraries is not supported
778       pic_mode=default
779     fi
780
781     # Calculate the filename of the output object if compiler does
782     # not support -o with -c
783     if test "$compiler_c_o" = no; then
784       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
785       lockfile="$output_obj.lock"
786       removelist="$removelist $output_obj $lockfile"
787       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
788     else
789       output_obj=
790       need_locks=no
791       lockfile=
792     fi
793
794     # Lock this critical section if it is needed
795     # We use this script file to make the link, it avoids creating a new file
796     if test "$need_locks" = yes; then
797       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
798         $show "Waiting for $lockfile to be removed"
799         sleep 2
800       done
801     elif test "$need_locks" = warn; then
802       if test -f "$lockfile"; then
803         $echo "\
804 *** ERROR, $lockfile exists and contains:
805 `cat $lockfile 2>/dev/null`
806
807 This indicates that another process is trying to use the same
808 temporary object file, and libtool could not work around it because
809 your compiler does not support \`-c' and \`-o' together.  If you
810 repeat this compilation, it may succeed, by chance, but you had better
811 avoid parallel builds (make -j) in this platform, or get a better
812 compiler."
813
814         $run $rm $removelist
815         exit $EXIT_FAILURE
816       fi
817       $echo $srcfile > "$lockfile"
818     fi
819
820     if test -n "$fix_srcfile_path"; then
821       eval srcfile=\"$fix_srcfile_path\"
822     fi
823
824     $run $rm "$libobj" "${libobj}T"
825
826     # Create a libtool object file (analogous to a ".la" file),
827     # but don't create it if we're doing a dry run.
828     test -z "$run" && cat > ${libobj}T <<EOF
829 # $libobj - a libtool object file
830 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
831 #
832 # Please DO NOT delete this file!
833 # It is necessary for linking the library.
834
835 # Name of the PIC object.
836 EOF
837
838     # Only build a PIC object if we are building libtool libraries.
839     if test "$build_libtool_libs" = yes; then
840       # Without this assignment, base_compile gets emptied.
841       fbsd_hideous_sh_bug=$base_compile
842
843       if test "$pic_mode" != no; then
844         command="$base_compile $srcfile $pic_flag"
845       else
846         # Don't build PIC code
847         command="$base_compile $srcfile"
848       fi
849
850       if test ! -d "${xdir}$objdir"; then
851         $show "$mkdir ${xdir}$objdir"
852         $run $mkdir ${xdir}$objdir
853         status=$?
854         if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
855           exit $status
856         fi
857       fi
858
859       if test -z "$output_obj"; then
860         # Place PIC objects in $objdir
861         command="$command -o $lobj"
862       fi
863
864       $run $rm "$lobj" "$output_obj"
865
866       $show "$command"
867       if $run eval "$command"; then :
868       else
869         test -n "$output_obj" && $run $rm $removelist
870         exit $EXIT_FAILURE
871       fi
872
873       if test "$need_locks" = warn &&
874          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
875         $echo "\
876 *** ERROR, $lockfile contains:
877 `cat $lockfile 2>/dev/null`
878
879 but it should contain:
880 $srcfile
881
882 This indicates that another process is trying to use the same
883 temporary object file, and libtool could not work around it because
884 your compiler does not support \`-c' and \`-o' together.  If you
885 repeat this compilation, it may succeed, by chance, but you had better
886 avoid parallel builds (make -j) in this platform, or get a better
887 compiler."
888
889         $run $rm $removelist
890         exit $EXIT_FAILURE
891       fi
892
893       # Just move the object if needed, then go on to compile the next one
894       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
895         $show "$mv $output_obj $lobj"
896         if $run $mv $output_obj $lobj; then :
897         else
898           error=$?
899           $run $rm $removelist
900           exit $error
901         fi
902       fi
903
904       # Append the name of the PIC object to the libtool object file.
905       test -z "$run" && cat >> ${libobj}T <<EOF
906 pic_object='$objdir/$objname'
907
908 EOF
909
910       # Allow error messages only from the first compilation.
911       if test "$suppress_opt" = yes; then
912         suppress_output=' >/dev/null 2>&1'
913       fi
914     else
915       # No PIC object so indicate it doesn't exist in the libtool
916       # object file.
917       test -z "$run" && cat >> ${libobj}T <<EOF
918 pic_object=none
919
920 EOF
921     fi
922
923     # Only build a position-dependent object if we build old libraries.
924     if test "$build_old_libs" = yes; then
925       if test "$pic_mode" != yes; then
926         # Don't build PIC code
927         command="$base_compile $srcfile"
928       else
929         command="$base_compile $srcfile $pic_flag"
930       fi
931       if test "$compiler_c_o" = yes; then
932         command="$command -o $obj"
933       fi
934
935       # Suppress compiler output if we already did a PIC compilation.
936       command="$command$suppress_output"
937       $run $rm "$obj" "$output_obj"
938       $show "$command"
939       if $run eval "$command"; then :
940       else
941         $run $rm $removelist
942         exit $EXIT_FAILURE
943       fi
944
945       if test "$need_locks" = warn &&
946          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
947         $echo "\
948 *** ERROR, $lockfile contains:
949 `cat $lockfile 2>/dev/null`
950
951 but it should contain:
952 $srcfile
953
954 This indicates that another process is trying to use the same
955 temporary object file, and libtool could not work around it because
956 your compiler does not support \`-c' and \`-o' together.  If you
957 repeat this compilation, it may succeed, by chance, but you had better
958 avoid parallel builds (make -j) in this platform, or get a better
959 compiler."
960
961         $run $rm $removelist
962         exit $EXIT_FAILURE
963       fi
964
965       # Just move the object if needed
966       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
967         $show "$mv $output_obj $obj"
968         if $run $mv $output_obj $obj; then :
969         else
970           error=$?
971           $run $rm $removelist
972           exit $error
973         fi
974       fi
975
976       # Append the name of the non-PIC object the libtool object file.
977       # Only append if the libtool object file exists.
978       test -z "$run" && cat >> ${libobj}T <<EOF
979 # Name of the non-PIC object.
980 non_pic_object='$objname'
981
982 EOF
983     else
984       # Append the name of the non-PIC object the libtool object file.
985       # Only append if the libtool object file exists.
986       test -z "$run" && cat >> ${libobj}T <<EOF
987 # Name of the non-PIC object.
988 non_pic_object=none
989
990 EOF
991     fi
992
993     $run $mv "${libobj}T" "${libobj}"
994
995     # Unlock the critical section if it was locked
996     if test "$need_locks" != no; then
997       $run $rm "$lockfile"
998     fi
999
1000     exit $EXIT_SUCCESS
1001     ;;
1002
1003   # libtool link mode
1004   link | relink)
1005     modename="$modename: link"
1006     case $host in
1007     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1008       # It is impossible to link a dll without this setting, and
1009       # we shouldn't force the makefile maintainer to figure out
1010       # which system we are compiling for in order to pass an extra
1011       # flag for every libtool invocation.
1012       # allow_undefined=no
1013
1014       # FIXME: Unfortunately, there are problems with the above when trying
1015       # to make a dll which has undefined symbols, in which case not
1016       # even a static library is built.  For now, we need to specify
1017       # -no-undefined on the libtool link line when we can be certain
1018       # that all symbols are satisfied, otherwise we get a static library.
1019       allow_undefined=yes
1020       ;;
1021     *)
1022       allow_undefined=yes
1023       ;;
1024     esac
1025     libtool_args="$nonopt"
1026     base_compile="$nonopt $@"
1027     compile_command="$nonopt"
1028     finalize_command="$nonopt"
1029
1030     compile_rpath=
1031     finalize_rpath=
1032     compile_shlibpath=
1033     finalize_shlibpath=
1034     convenience=
1035     old_convenience=
1036     deplibs=
1037     old_deplibs=
1038     compiler_flags=
1039     linker_flags=
1040     dllsearchpath=
1041     lib_search_path=`pwd`
1042     inst_prefix_dir=
1043
1044     avoid_version=no
1045     dlfiles=
1046     dlprefiles=
1047     dlself=no
1048     export_dynamic=no
1049     export_symbols=
1050     export_symbols_regex=
1051     generated=
1052     libobjs=
1053     ltlibs=
1054     module=no
1055     no_install=no
1056     objs=
1057     non_pic_objects=
1058     precious_files_regex=
1059     prefer_static_libs=no
1060     preload=no
1061     prev=
1062     prevarg=
1063     release=
1064     rpath=
1065     xrpath=
1066     perm_rpath=
1067     temp_rpath=
1068     thread_safe=no
1069     vinfo=
1070     vinfo_number=no
1071
1072     func_infer_tag $base_compile
1073
1074     # We need to know -static, to get the right output filenames.
1075     for arg
1076     do
1077       case $arg in
1078       -all-static | -static)
1079         if test "X$arg" = "X-all-static"; then
1080           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1081             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1082           fi
1083           if test -n "$link_static_flag"; then
1084             dlopen_self=$dlopen_self_static
1085           fi
1086         else
1087           if test -z "$pic_flag" && test -n "$link_static_flag"; then
1088             dlopen_self=$dlopen_self_static
1089           fi
1090         fi
1091         build_libtool_libs=no
1092         build_old_libs=yes
1093         prefer_static_libs=yes
1094         break
1095         ;;
1096       esac
1097     done
1098
1099     # See if our shared archives depend on static archives.
1100     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1101
1102     # Go through the arguments, transforming them on the way.
1103     while test "$#" -gt 0; do
1104       arg="$1"
1105       shift
1106       case $arg in
1107       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1108         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1109         ;;
1110       *) qarg=$arg ;;
1111       esac
1112       libtool_args="$libtool_args $qarg"
1113
1114       # If the previous option needs an argument, assign it.
1115       if test -n "$prev"; then
1116         case $prev in
1117         output)
1118           compile_command="$compile_command @OUTPUT@"
1119           finalize_command="$finalize_command @OUTPUT@"
1120           ;;
1121         esac
1122
1123         case $prev in
1124         dlfiles|dlprefiles)
1125           if test "$preload" = no; then
1126             # Add the symbol object into the linking commands.
1127             compile_command="$compile_command @SYMFILE@"
1128             finalize_command="$finalize_command @SYMFILE@"
1129             preload=yes
1130           fi
1131           case $arg in
1132           *.la | *.lo) ;;  # We handle these cases below.
1133           force)
1134             if test "$dlself" = no; then
1135               dlself=needless
1136               export_dynamic=yes
1137             fi
1138             prev=
1139             continue
1140             ;;
1141           self)
1142             if test "$prev" = dlprefiles; then
1143               dlself=yes
1144             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1145               dlself=yes
1146             else
1147               dlself=needless
1148               export_dynamic=yes
1149             fi
1150             prev=
1151             continue
1152             ;;
1153           *)
1154             if test "$prev" = dlfiles; then
1155               dlfiles="$dlfiles $arg"
1156             else
1157               dlprefiles="$dlprefiles $arg"
1158             fi
1159             prev=
1160             continue
1161             ;;
1162           esac
1163           ;;
1164         expsyms)
1165           export_symbols="$arg"
1166           if test ! -f "$arg"; then
1167             $echo "$modename: symbol file \`$arg' does not exist"
1168             exit $EXIT_FAILURE
1169           fi
1170           prev=
1171           continue
1172           ;;
1173         expsyms_regex)
1174           export_symbols_regex="$arg"
1175           prev=
1176           continue
1177           ;;
1178         inst_prefix)
1179           inst_prefix_dir="$arg"
1180           prev=
1181           continue
1182           ;;
1183         precious_regex)
1184           precious_files_regex="$arg"
1185           prev=
1186           continue
1187           ;;
1188         release)
1189           release="-$arg"
1190           prev=
1191           continue
1192           ;;
1193         objectlist)
1194           if test -f "$arg"; then
1195             save_arg=$arg
1196             moreargs=
1197             for fil in `cat $save_arg`
1198             do
1199 #             moreargs="$moreargs $fil"
1200               arg=$fil
1201               # A libtool-controlled object.
1202
1203               # Check to see that this really is a libtool object.
1204               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1205                 pic_object=
1206                 non_pic_object=
1207
1208                 # Read the .lo file
1209                 # If there is no directory component, then add one.
1210                 case $arg in
1211                 */* | *\\*) . $arg ;;
1212                 *) . ./$arg ;;
1213                 esac
1214
1215                 if test -z "$pic_object" || \
1216                    test -z "$non_pic_object" ||
1217                    test "$pic_object" = none && \
1218                    test "$non_pic_object" = none; then
1219                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1220                   exit $EXIT_FAILURE
1221                 fi
1222
1223                 # Extract subdirectory from the argument.
1224                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1225                 if test "X$xdir" = "X$arg"; then
1226                   xdir=
1227                 else
1228                   xdir="$xdir/"
1229                 fi
1230
1231                 if test "$pic_object" != none; then
1232                   # Prepend the subdirectory the object is found in.
1233                   pic_object="$xdir$pic_object"
1234
1235                   if test "$prev" = dlfiles; then
1236                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1237                       dlfiles="$dlfiles $pic_object"
1238                       prev=
1239                       continue
1240                     else
1241                       # If libtool objects are unsupported, then we need to preload.
1242                       prev=dlprefiles
1243                     fi
1244                   fi
1245
1246                   # CHECK ME:  I think I busted this.  -Ossama
1247                   if test "$prev" = dlprefiles; then
1248                     # Preload the old-style object.
1249                     dlprefiles="$dlprefiles $pic_object"
1250                     prev=
1251                   fi
1252
1253                   # A PIC object.
1254                   libobjs="$libobjs $pic_object"
1255                   arg="$pic_object"
1256                 fi
1257
1258                 # Non-PIC object.
1259                 if test "$non_pic_object" != none; then
1260                   # Prepend the subdirectory the object is found in.
1261                   non_pic_object="$xdir$non_pic_object"
1262
1263                   # A standard non-PIC object
1264                   non_pic_objects="$non_pic_objects $non_pic_object"
1265                   if test -z "$pic_object" || test "$pic_object" = none ; then
1266                     arg="$non_pic_object"
1267                   fi
1268                 fi
1269               else
1270                 # Only an error if not doing a dry-run.
1271                 if test -z "$run"; then
1272                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1273                   exit $EXIT_FAILURE
1274                 else
1275                   # Dry-run case.
1276
1277                   # Extract subdirectory from the argument.
1278                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1279                   if test "X$xdir" = "X$arg"; then
1280                     xdir=
1281                   else
1282                     xdir="$xdir/"
1283                   fi
1284
1285                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1286                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1287                   libobjs="$libobjs $pic_object"
1288                   non_pic_objects="$non_pic_objects $non_pic_object"
1289                 fi
1290               fi
1291             done
1292           else
1293             $echo "$modename: link input file \`$save_arg' does not exist"
1294             exit $EXIT_FAILURE
1295           fi
1296           arg=$save_arg
1297           prev=
1298           continue
1299           ;;
1300         rpath | xrpath)
1301           # We need an absolute path.
1302           case $arg in
1303           [\\/]* | [A-Za-z]:[\\/]*) ;;
1304           *)
1305             $echo "$modename: only absolute run-paths are allowed" 1>&2
1306             exit $EXIT_FAILURE
1307             ;;
1308           esac
1309           if test "$prev" = rpath; then
1310             case "$rpath " in
1311             *" $arg "*) ;;
1312             *) rpath="$rpath $arg" ;;
1313             esac
1314           else
1315             case "$xrpath " in
1316             *" $arg "*) ;;
1317             *) xrpath="$xrpath $arg" ;;
1318             esac
1319           fi
1320           prev=
1321           continue
1322           ;;
1323         xcompiler)
1324           compiler_flags="$compiler_flags $qarg"
1325           prev=
1326           compile_command="$compile_command $qarg"
1327           finalize_command="$finalize_command $qarg"
1328           continue
1329           ;;
1330         xlinker)
1331           linker_flags="$linker_flags $qarg"
1332           compiler_flags="$compiler_flags $wl$qarg"
1333           prev=
1334           compile_command="$compile_command $wl$qarg"
1335           finalize_command="$finalize_command $wl$qarg"
1336           continue
1337           ;;
1338         xcclinker)
1339           linker_flags="$linker_flags $qarg"
1340           compiler_flags="$compiler_flags $qarg"
1341           prev=
1342           compile_command="$compile_command $qarg"
1343           finalize_command="$finalize_command $qarg"
1344           continue
1345           ;;
1346         shrext)
1347           shrext_cmds="$arg"
1348           prev=
1349           continue
1350           ;;
1351         *)
1352           eval "$prev=\"\$arg\""
1353           prev=
1354           continue
1355           ;;
1356         esac
1357       fi # test -n "$prev"
1358
1359       prevarg="$arg"
1360
1361       case $arg in
1362       -all-static)
1363         if test -n "$link_static_flag"; then
1364           compile_command="$compile_command $link_static_flag"
1365           finalize_command="$finalize_command $link_static_flag"
1366         fi
1367         continue
1368         ;;
1369
1370       -allow-undefined)
1371         # FIXME: remove this flag sometime in the future.
1372         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1373         continue
1374         ;;
1375
1376       -avoid-version)
1377         avoid_version=yes
1378         continue
1379         ;;
1380
1381       -dlopen)
1382         prev=dlfiles
1383         continue
1384         ;;
1385
1386       -dlpreopen)
1387         prev=dlprefiles
1388         continue
1389         ;;
1390
1391       -export-dynamic)
1392         export_dynamic=yes
1393         continue
1394         ;;
1395
1396       -export-symbols | -export-symbols-regex)
1397         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1398           $echo "$modename: more than one -exported-symbols argument is not allowed"
1399           exit $EXIT_FAILURE
1400         fi
1401         if test "X$arg" = "X-export-symbols"; then
1402           prev=expsyms
1403         else
1404           prev=expsyms_regex
1405         fi
1406         continue
1407         ;;
1408
1409       -inst-prefix-dir)
1410         prev=inst_prefix
1411         continue
1412         ;;
1413
1414       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1415       # so, if we see these flags be careful not to treat them like -L
1416       -L[A-Z][A-Z]*:*)
1417         case $with_gcc/$host in
1418         no/*-*-irix* | /*-*-irix*)
1419           compile_command="$compile_command $arg"
1420           finalize_command="$finalize_command $arg"
1421           ;;
1422         esac
1423         continue
1424         ;;
1425
1426       -L*)
1427         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1428         # We need an absolute path.
1429         case $dir in
1430         [\\/]* | [A-Za-z]:[\\/]*) ;;
1431         *)
1432           absdir=`cd "$dir" && pwd`
1433           if test -z "$absdir"; then
1434             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1435             exit $EXIT_FAILURE
1436           fi
1437           dir="$absdir"
1438           ;;
1439         esac
1440         case "$deplibs " in
1441         *" -L$dir "*) ;;
1442         *)
1443           deplibs="$deplibs -L$dir"
1444           lib_search_path="$lib_search_path $dir"
1445           ;;
1446         esac
1447         case $host in
1448         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1449           case :$dllsearchpath: in
1450           *":$dir:"*) ;;
1451           *) dllsearchpath="$dllsearchpath:$dir";;
1452           esac
1453           ;;
1454         esac
1455         continue
1456         ;;
1457
1458       -l*)
1459         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1460           case $host in
1461           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1462             # These systems don't actually have a C or math library (as such)
1463             continue
1464             ;;
1465           *-*-mingw* | *-*-os2*)
1466             # These systems don't actually have a C library (as such)
1467             test "X$arg" = "X-lc" && continue
1468             ;;
1469           *-*-openbsd* | *-*-freebsd*)
1470             # Do not include libc due to us having libc/libc_r.
1471             test "X$arg" = "X-lc" && continue
1472             ;;
1473           *-*-rhapsody* | *-*-darwin1.[012])
1474             # Rhapsody C and math libraries are in the System framework
1475             deplibs="$deplibs -framework System"
1476             continue
1477           esac
1478         elif test "X$arg" = "X-lc_r"; then
1479          case $host in
1480          *-*-openbsd* | *-*-freebsd*)
1481            # Do not include libc_r directly, use -pthread flag.
1482            continue
1483            ;;
1484          esac
1485         fi
1486         deplibs="$deplibs $arg"
1487         continue
1488         ;;
1489
1490      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1491         deplibs="$deplibs $arg"
1492         continue
1493         ;;
1494
1495       -module)
1496         module=yes
1497         continue
1498         ;;
1499
1500       # gcc -m* arguments should be passed to the linker via $compiler_flags
1501       # in order to pass architecture information to the linker
1502       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1503       # but this is not reliable with gcc because gcc may use -mfoo to
1504       # select a different linker, different libraries, etc, while
1505       # -Wl,-mfoo simply passes -mfoo to the linker.
1506       -m*)
1507         # Unknown arguments in both finalize_command and compile_command need
1508         # to be aesthetically quoted because they are evaled later.
1509         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1510         case $arg in
1511         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1512           arg="\"$arg\""
1513           ;;
1514         esac
1515         compile_command="$compile_command $arg"
1516         finalize_command="$finalize_command $arg"
1517         if test "$with_gcc" = "yes" ; then
1518           compiler_flags="$compiler_flags $arg"
1519         fi
1520         continue
1521         ;;
1522
1523       -shrext)
1524         prev=shrext
1525         continue
1526         ;;
1527
1528       -no-fast-install)
1529         fast_install=no
1530         continue
1531         ;;
1532
1533       -no-install)
1534         case $host in
1535         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1536           # The PATH hackery in wrapper scripts is required on Windows
1537           # in order for the loader to find any dlls it needs.
1538           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1539           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1540           fast_install=no
1541           ;;
1542         *) no_install=yes ;;
1543         esac
1544         continue
1545         ;;
1546
1547       -no-undefined)
1548         allow_undefined=no
1549         continue
1550         ;;
1551
1552       -objectlist)
1553         prev=objectlist
1554         continue
1555         ;;
1556
1557       -o) prev=output ;;
1558
1559       -precious-files-regex)
1560         prev=precious_regex
1561         continue
1562         ;;
1563
1564       -release)
1565         prev=release
1566         continue
1567         ;;
1568
1569       -rpath)
1570         prev=rpath
1571         continue
1572         ;;
1573
1574       -R)
1575         prev=xrpath
1576         continue
1577         ;;
1578
1579       -R*)
1580         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1581         # We need an absolute path.
1582         case $dir in
1583         [\\/]* | [A-Za-z]:[\\/]*) ;;
1584         *)
1585           $echo "$modename: only absolute run-paths are allowed" 1>&2
1586           exit $EXIT_FAILURE
1587           ;;
1588         esac
1589         case "$xrpath " in
1590         *" $dir "*) ;;
1591         *) xrpath="$xrpath $dir" ;;
1592         esac
1593         continue
1594         ;;
1595
1596       -static)
1597         # The effects of -static are defined in a previous loop.
1598         # We used to do the same as -all-static on platforms that
1599         # didn't have a PIC flag, but the assumption that the effects
1600         # would be equivalent was wrong.  It would break on at least
1601         # Digital Unix and AIX.
1602         continue
1603         ;;
1604
1605       -thread-safe)
1606         thread_safe=yes
1607         continue
1608         ;;
1609
1610       -version-info)
1611         prev=vinfo
1612         continue
1613         ;;
1614       -version-number)
1615         prev=vinfo
1616         vinfo_number=yes
1617         continue
1618         ;;
1619
1620       -Wc,*)
1621         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1622         arg=
1623         save_ifs="$IFS"; IFS=','
1624         for flag in $args; do
1625           IFS="$save_ifs"
1626           case $flag in
1627             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1628             flag="\"$flag\""
1629             ;;
1630           esac
1631           arg="$arg $wl$flag"
1632           compiler_flags="$compiler_flags $flag"
1633         done
1634         IFS="$save_ifs"
1635         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1636         ;;
1637
1638       -Wl,*)
1639         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1640         arg=
1641         save_ifs="$IFS"; IFS=','
1642         for flag in $args; do
1643           IFS="$save_ifs"
1644           case $flag in
1645             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1646             flag="\"$flag\""
1647             ;;
1648           esac
1649           arg="$arg $wl$flag"
1650           compiler_flags="$compiler_flags $wl$flag"
1651           linker_flags="$linker_flags $flag"
1652         done
1653         IFS="$save_ifs"
1654         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1655         ;;
1656
1657       -Xcompiler)
1658         prev=xcompiler
1659         continue
1660         ;;
1661
1662       -Xlinker)
1663         prev=xlinker
1664         continue
1665         ;;
1666
1667       -XCClinker)
1668         prev=xcclinker
1669         continue
1670         ;;
1671
1672       # Some other compiler flag.
1673       -* | +*)
1674         # Unknown arguments in both finalize_command and compile_command need
1675         # to be aesthetically quoted because they are evaled later.
1676         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1677         case $arg in
1678         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1679           arg="\"$arg\""
1680           ;;
1681         esac
1682         ;;
1683
1684       *.$objext)
1685         # A standard object.
1686         objs="$objs $arg"
1687         ;;
1688
1689       *.lo)
1690         # A libtool-controlled object.
1691
1692         # Check to see that this really is a libtool object.
1693         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1694           pic_object=
1695           non_pic_object=
1696
1697           # Read the .lo file
1698           # If there is no directory component, then add one.
1699           case $arg in
1700           */* | *\\*) . $arg ;;
1701           *) . ./$arg ;;
1702           esac
1703
1704           if test -z "$pic_object" || \
1705              test -z "$non_pic_object" ||
1706              test "$pic_object" = none && \
1707              test "$non_pic_object" = none; then
1708             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1709             exit $EXIT_FAILURE
1710           fi
1711
1712           # Extract subdirectory from the argument.
1713           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1714           if test "X$xdir" = "X$arg"; then
1715             xdir=
1716           else
1717             xdir="$xdir/"
1718           fi
1719
1720           if test "$pic_object" != none; then
1721             # Prepend the subdirectory the object is found in.
1722             pic_object="$xdir$pic_object"
1723
1724             if test "$prev" = dlfiles; then
1725               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1726                 dlfiles="$dlfiles $pic_object"
1727                 prev=
1728                 continue
1729               else
1730                 # If libtool objects are unsupported, then we need to preload.
1731                 prev=dlprefiles
1732               fi
1733             fi
1734
1735             # CHECK ME:  I think I busted this.  -Ossama
1736             if test "$prev" = dlprefiles; then
1737               # Preload the old-style object.
1738               dlprefiles="$dlprefiles $pic_object"
1739               prev=
1740             fi
1741
1742             # A PIC object.
1743             libobjs="$libobjs $pic_object"
1744             arg="$pic_object"
1745           fi
1746
1747           # Non-PIC object.
1748           if test "$non_pic_object" != none; then
1749             # Prepend the subdirectory the object is found in.
1750             non_pic_object="$xdir$non_pic_object"
1751
1752             # A standard non-PIC object
1753             non_pic_objects="$non_pic_objects $non_pic_object"
1754             if test -z "$pic_object" || test "$pic_object" = none ; then
1755               arg="$non_pic_object"
1756             fi
1757           fi
1758         else
1759           # Only an error if not doing a dry-run.
1760           if test -z "$run"; then
1761             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1762             exit $EXIT_FAILURE
1763           else
1764             # Dry-run case.
1765
1766             # Extract subdirectory from the argument.
1767             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1768             if test "X$xdir" = "X$arg"; then
1769               xdir=
1770             else
1771               xdir="$xdir/"
1772             fi
1773
1774             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1775             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1776             libobjs="$libobjs $pic_object"
1777             non_pic_objects="$non_pic_objects $non_pic_object"
1778           fi
1779         fi
1780         ;;
1781
1782       *.$libext)
1783         # An archive.
1784         deplibs="$deplibs $arg"
1785         old_deplibs="$old_deplibs $arg"
1786         continue
1787         ;;
1788
1789       *.la)
1790         # A libtool-controlled library.
1791
1792         if test "$prev" = dlfiles; then
1793           # This library was specified with -dlopen.
1794           dlfiles="$dlfiles $arg"
1795           prev=
1796         elif test "$prev" = dlprefiles; then
1797           # The library was specified with -dlpreopen.
1798           dlprefiles="$dlprefiles $arg"
1799           prev=
1800         else
1801           deplibs="$deplibs $arg"
1802         fi
1803         continue
1804         ;;
1805
1806       # Some other compiler argument.
1807       *)
1808         # Unknown arguments in both finalize_command and compile_command need
1809         # to be aesthetically quoted because they are evaled later.
1810         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1811         case $arg in
1812         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1813           arg="\"$arg\""
1814           ;;
1815         esac
1816         ;;
1817       esac # arg
1818
1819       # Now actually substitute the argument into the commands.
1820       if test -n "$arg"; then
1821         compile_command="$compile_command $arg"
1822         finalize_command="$finalize_command $arg"
1823       fi
1824     done # argument parsing loop
1825
1826     if test -n "$prev"; then
1827       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1828       $echo "$help" 1>&2
1829       exit $EXIT_FAILURE
1830     fi
1831
1832     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1833       eval arg=\"$export_dynamic_flag_spec\"
1834       compile_command="$compile_command $arg"
1835       finalize_command="$finalize_command $arg"
1836     fi
1837
1838     oldlibs=
1839     # calculate the name of the file, without its directory
1840     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1841     libobjs_save="$libobjs"
1842
1843     if test -n "$shlibpath_var"; then
1844       # get the directories listed in $shlibpath_var
1845       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1846     else
1847       shlib_search_path=
1848     fi
1849     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1850     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1851
1852     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1853     if test "X$output_objdir" = "X$output"; then
1854       output_objdir="$objdir"
1855     else
1856       output_objdir="$output_objdir/$objdir"
1857     fi
1858     # Create the object directory.
1859     if test ! -d "$output_objdir"; then
1860       $show "$mkdir $output_objdir"
1861       $run $mkdir $output_objdir
1862       status=$?
1863       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1864         exit $status
1865       fi
1866     fi
1867
1868     # Determine the type of output
1869     case $output in
1870     "")
1871       $echo "$modename: you must specify an output file" 1>&2
1872       $echo "$help" 1>&2
1873       exit $EXIT_FAILURE
1874       ;;
1875     *.$libext) linkmode=oldlib ;;
1876     *.lo | *.$objext) linkmode=obj ;;
1877     *.la) linkmode=lib ;;
1878     *) linkmode=prog ;; # Anything else should be a program.
1879     esac
1880
1881     case $host in
1882     *cygwin* | *mingw* | *pw32*)
1883       # don't eliminate duplications in $postdeps and $predeps
1884       duplicate_compiler_generated_deps=yes
1885       ;;
1886     *)
1887       duplicate_compiler_generated_deps=$duplicate_deps
1888       ;;
1889     esac
1890     specialdeplibs=
1891
1892     libs=
1893     # Find all interdependent deplibs by searching for libraries
1894     # that are linked more than once (e.g. -la -lb -la)
1895     for deplib in $deplibs; do
1896       if test "X$duplicate_deps" = "Xyes" ; then
1897         case "$libs " in
1898         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1899         esac
1900       fi
1901       libs="$libs $deplib"
1902     done
1903
1904     if test "$linkmode" = lib; then
1905       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1906
1907       # Compute libraries that are listed more than once in $predeps
1908       # $postdeps and mark them as special (i.e., whose duplicates are
1909       # not to be eliminated).
1910       pre_post_deps=
1911       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1912         for pre_post_dep in $predeps $postdeps; do
1913           case "$pre_post_deps " in
1914           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1915           esac
1916           pre_post_deps="$pre_post_deps $pre_post_dep"
1917         done
1918       fi
1919       pre_post_deps=
1920     fi
1921
1922     deplibs=
1923     newdependency_libs=
1924     newlib_search_path=
1925     need_relink=no # whether we're linking any uninstalled libtool libraries
1926     notinst_deplibs= # not-installed libtool libraries
1927     notinst_path= # paths that contain not-installed libtool libraries
1928     case $linkmode in
1929     lib)
1930         passes="conv link"
1931         for file in $dlfiles $dlprefiles; do
1932           case $file in
1933           *.la) ;;
1934           *)
1935             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1936             exit $EXIT_FAILURE
1937             ;;
1938           esac
1939         done
1940         ;;
1941     prog)
1942         compile_deplibs=
1943         finalize_deplibs=
1944         alldeplibs=no
1945         newdlfiles=
1946         newdlprefiles=
1947         passes="conv scan dlopen dlpreopen link"
1948         ;;
1949     *)  passes="conv"
1950         ;;
1951     esac
1952     for pass in $passes; do
1953       if test "$linkmode,$pass" = "lib,link" ||
1954          test "$linkmode,$pass" = "prog,scan"; then
1955         libs="$deplibs"
1956         deplibs=
1957       fi
1958       if test "$linkmode" = prog; then
1959         case $pass in
1960         dlopen) libs="$dlfiles" ;;
1961         dlpreopen) libs="$dlprefiles" ;;
1962         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1963         esac
1964       fi
1965       if test "$pass" = dlopen; then
1966         # Collect dlpreopened libraries
1967         save_deplibs="$deplibs"
1968         deplibs=
1969       fi
1970       for deplib in $libs; do
1971         lib=
1972         found=no
1973         case $deplib in
1974         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1975           if test "$linkmode,$pass" = "prog,link"; then
1976             compile_deplibs="$deplib $compile_deplibs"
1977             finalize_deplibs="$deplib $finalize_deplibs"
1978           else
1979             deplibs="$deplib $deplibs"
1980           fi
1981           continue
1982           ;;
1983         -l*)
1984           if test "$linkmode" != lib && test "$linkmode" != prog; then
1985             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1986             continue
1987           fi
1988           if test "$pass" = conv; then
1989             deplibs="$deplib $deplibs"
1990             continue
1991           fi
1992           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1993           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1994             for search_ext in .la $std_shrext .so .a; do
1995               # Search the libtool library
1996               lib="$searchdir/lib${name}${search_ext}"
1997               if test -f "$lib"; then
1998                 if test "$search_ext" = ".la"; then
1999                   found=yes
2000                 else
2001                   found=no
2002                 fi
2003                 break 2
2004               fi
2005             done
2006           done
2007           if test "$found" != yes; then
2008             # deplib doesn't seem to be a libtool library
2009             if test "$linkmode,$pass" = "prog,link"; then
2010               compile_deplibs="$deplib $compile_deplibs"
2011               finalize_deplibs="$deplib $finalize_deplibs"
2012             else
2013               deplibs="$deplib $deplibs"
2014               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2015             fi
2016             continue
2017           else # deplib is a libtool library
2018             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2019             # We need to do some special things here, and not later.
2020             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2021               case " $predeps $postdeps " in
2022               *" $deplib "*)
2023                 if (${SED} -e '2q' $lib |
2024                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2025                   library_names=
2026                   old_library=
2027                   case $lib in
2028                   */* | *\\*) . $lib ;;
2029                   *) . ./$lib ;;
2030                   esac
2031                   for l in $old_library $library_names; do
2032                     ll="$l"
2033                   done
2034                   if test "X$ll" = "X$old_library" ; then # only static version available
2035                     found=no
2036                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2037                     test "X$ladir" = "X$lib" && ladir="."
2038                     lib=$ladir/$old_library
2039                     if test "$linkmode,$pass" = "prog,link"; then
2040                       compile_deplibs="$deplib $compile_deplibs"
2041                       finalize_deplibs="$deplib $finalize_deplibs"
2042                     else
2043                       deplibs="$deplib $deplibs"
2044                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2045                     fi
2046                     continue
2047                   fi
2048                 fi
2049                 ;;
2050               *) ;;
2051               esac
2052             fi
2053           fi
2054           ;; # -l
2055         -L*)
2056           case $linkmode in
2057           lib)
2058             deplibs="$deplib $deplibs"
2059             test "$pass" = conv && continue
2060             newdependency_libs="$deplib $newdependency_libs"
2061             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2062             ;;
2063           prog)
2064             if test "$pass" = conv; then
2065               deplibs="$deplib $deplibs"
2066               continue
2067             fi
2068             if test "$pass" = scan; then
2069               deplibs="$deplib $deplibs"
2070             else
2071               compile_deplibs="$deplib $compile_deplibs"
2072               finalize_deplibs="$deplib $finalize_deplibs"
2073             fi
2074             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2075             ;;
2076           *)
2077             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2078             ;;
2079           esac # linkmode
2080           continue
2081           ;; # -L
2082         -R*)
2083           if test "$pass" = link; then
2084             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2085             # Make sure the xrpath contains only unique directories.
2086             case "$xrpath " in
2087             *" $dir "*) ;;
2088             *) xrpath="$xrpath $dir" ;;
2089             esac
2090           fi
2091           deplibs="$deplib $deplibs"
2092           continue
2093           ;;
2094         *.la) lib="$deplib" ;;
2095         *.$libext)
2096           if test "$pass" = conv; then
2097             deplibs="$deplib $deplibs"
2098             continue
2099           fi
2100           case $linkmode in
2101           lib)
2102             valid_a_lib=no
2103             case $deplibs_check_method in
2104               match_pattern*)
2105                 set dummy $deplibs_check_method
2106                 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2107                 if eval $echo \"$deplib\" 2>/dev/null \
2108                     | $SED 10q \
2109                     | $EGREP "$match_pattern_regex" > /dev/null; then
2110                   valid_a_lib=yes
2111                 fi
2112                 ;;
2113               pass_all)
2114                 valid_a_lib=yes
2115                 ;;
2116             esac
2117             if test "$valid_a_lib" != yes; then
2118               $echo
2119               $echo "*** Warning: Trying to link with static lib archive $deplib."
2120               $echo "*** I have the capability to make that library automatically link in when"
2121               $echo "*** you link to this library.  But I can only do this if you have a"
2122               $echo "*** shared version of the library, which you do not appear to have"
2123               $echo "*** because the file extensions .$libext of this argument makes me believe"
2124               $echo "*** that it is just a static archive that I should not used here."
2125             else
2126               $echo
2127               $echo "*** Warning: Linking the shared library $output against the"
2128               $echo "*** static library $deplib is not portable!"
2129               deplibs="$deplib $deplibs"
2130             fi
2131             continue
2132             ;;
2133           prog)
2134             if test "$pass" != link; then
2135               deplibs="$deplib $deplibs"
2136             else
2137               compile_deplibs="$deplib $compile_deplibs"
2138               finalize_deplibs="$deplib $finalize_deplibs"
2139             fi
2140             continue
2141             ;;
2142           esac # linkmode
2143           ;; # *.$libext
2144         *.lo | *.$objext)
2145           if test "$pass" = conv; then
2146             deplibs="$deplib $deplibs"
2147           elif test "$linkmode" = prog; then
2148             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2149               # If there is no dlopen support or we're linking statically,
2150               # we need to preload.
2151               newdlprefiles="$newdlprefiles $deplib"
2152               compile_deplibs="$deplib $compile_deplibs"
2153               finalize_deplibs="$deplib $finalize_deplibs"
2154             else
2155               newdlfiles="$newdlfiles $deplib"
2156             fi
2157           fi
2158           continue
2159           ;;
2160         %DEPLIBS%)
2161           alldeplibs=yes
2162           continue
2163           ;;
2164         esac # case $deplib
2165         if test "$found" = yes || test -f "$lib"; then :
2166         else
2167           $echo "$modename: cannot find the library \`$lib'" 1>&2
2168           exit $EXIT_FAILURE
2169         fi
2170
2171         # Check to see that this really is a libtool archive.
2172         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2173         else
2174           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2175           exit $EXIT_FAILURE
2176         fi
2177
2178         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2179         test "X$ladir" = "X$lib" && ladir="."
2180
2181         dlname=
2182         dlopen=
2183         dlpreopen=
2184         libdir=
2185         library_names=
2186         old_library=
2187         # If the library was installed with an old release of libtool,
2188         # it will not redefine variables installed, or shouldnotlink
2189         installed=yes
2190         shouldnotlink=no
2191
2192         # Read the .la file
2193         case $lib in
2194         */* | *\\*) . $lib ;;
2195         *) . ./$lib ;;
2196         esac
2197
2198         if test "$linkmode,$pass" = "lib,link" ||
2199            test "$linkmode,$pass" = "prog,scan" ||
2200            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2201           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2202           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2203         fi
2204
2205         if test "$pass" = conv; then
2206           # Only check for convenience libraries
2207           deplibs="$lib $deplibs"
2208           if test -z "$libdir"; then
2209             if test -z "$old_library"; then
2210               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2211               exit $EXIT_FAILURE
2212             fi
2213             # It is a libtool convenience library, so add in its objects.
2214             convenience="$convenience $ladir/$objdir/$old_library"
2215             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2216             tmp_libs=
2217             for deplib in $dependency_libs; do
2218               deplibs="$deplib $deplibs"
2219               if test "X$duplicate_deps" = "Xyes" ; then
2220                 case "$tmp_libs " in
2221                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2222                 esac
2223               fi
2224               tmp_libs="$tmp_libs $deplib"
2225             done
2226           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2227             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2228             exit $EXIT_FAILURE
2229           fi
2230           continue
2231         fi # $pass = conv
2232
2233
2234         # Get the name of the library we link against.
2235         linklib=
2236         for l in $old_library $library_names; do
2237           linklib="$l"
2238         done
2239         if test -z "$linklib"; then
2240           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2241           exit $EXIT_FAILURE
2242         fi
2243
2244         # This library was specified with -dlopen.
2245         if test "$pass" = dlopen; then
2246           if test -z "$libdir"; then
2247             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2248             exit $EXIT_FAILURE
2249           fi
2250           if test -z "$dlname" ||
2251              test "$dlopen_support" != yes ||
2252              test "$build_libtool_libs" = no; then
2253             # If there is no dlname, no dlopen support or we're linking
2254             # statically, we need to preload.  We also need to preload any
2255             # dependent libraries so libltdl's deplib preloader doesn't
2256             # bomb out in the load deplibs phase.
2257             dlprefiles="$dlprefiles $lib $dependency_libs"
2258           else
2259             newdlfiles="$newdlfiles $lib"
2260           fi
2261           continue
2262         fi # $pass = dlopen
2263
2264         # We need an absolute path.
2265         case $ladir in
2266         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2267         *)
2268           abs_ladir=`cd "$ladir" && pwd`
2269           if test -z "$abs_ladir"; then
2270             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2271             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2272             abs_ladir="$ladir"
2273           fi
2274           ;;
2275         esac
2276         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2277
2278         # Find the relevant object directory and library name.
2279         if test "X$installed" = Xyes; then
2280           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2281             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2282             dir="$ladir"
2283             absdir="$abs_ladir"
2284             libdir="$abs_ladir"
2285           else
2286             dir="$libdir"
2287             absdir="$libdir"
2288           fi
2289         else
2290           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2291             dir="$ladir"
2292             absdir="$abs_ladir"
2293             # Remove this search path later
2294             notinst_path="$notinst_path $abs_ladir"
2295           else
2296             dir="$ladir/$objdir"
2297             absdir="$abs_ladir/$objdir"
2298             # Remove this search path later
2299             notinst_path="$notinst_path $abs_ladir"
2300           fi
2301         fi # $installed = yes
2302         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2303
2304         # This library was specified with -dlpreopen.
2305         if test "$pass" = dlpreopen; then
2306           if test -z "$libdir"; then
2307             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2308             exit $EXIT_FAILURE
2309           fi
2310           # Prefer using a static library (so that no silly _DYNAMIC symbols
2311           # are required to link).
2312           if test -n "$old_library"; then
2313             newdlprefiles="$newdlprefiles $dir/$old_library"
2314           # Otherwise, use the dlname, so that lt_dlopen finds it.
2315           elif test -n "$dlname"; then
2316             newdlprefiles="$newdlprefiles $dir/$dlname"
2317           else
2318             newdlprefiles="$newdlprefiles $dir/$linklib"
2319           fi
2320         fi # $pass = dlpreopen
2321
2322         if test -z "$libdir"; then
2323           # Link the convenience library
2324           if test "$linkmode" = lib; then
2325             deplibs="$dir/$old_library $deplibs"
2326           elif test "$linkmode,$pass" = "prog,link"; then
2327             compile_deplibs="$dir/$old_library $compile_deplibs"
2328             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2329           else
2330             deplibs="$lib $deplibs" # used for prog,scan pass
2331           fi
2332           continue
2333         fi
2334
2335
2336         if test "$linkmode" = prog && test "$pass" != link; then
2337           newlib_search_path="$newlib_search_path $ladir"
2338           deplibs="$lib $deplibs"
2339
2340           linkalldeplibs=no
2341           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2342              test "$build_libtool_libs" = no; then
2343             linkalldeplibs=yes
2344           fi
2345
2346           tmp_libs=
2347           for deplib in $dependency_libs; do
2348             case $deplib in
2349             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2350             esac
2351             # Need to link against all dependency_libs?
2352             if test "$linkalldeplibs" = yes; then
2353               deplibs="$deplib $deplibs"
2354             else
2355               # Need to hardcode shared library paths
2356               # or/and link against static libraries
2357               newdependency_libs="$deplib $newdependency_libs"
2358             fi
2359             if test "X$duplicate_deps" = "Xyes" ; then
2360               case "$tmp_libs " in
2361               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2362               esac
2363             fi
2364             tmp_libs="$tmp_libs $deplib"
2365           done # for deplib
2366           continue
2367         fi # $linkmode = prog...
2368
2369         if test "$linkmode,$pass" = "prog,link"; then
2370           if test -n "$library_names" &&
2371              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2372             # We need to hardcode the library path
2373             if test -n "$shlibpath_var"; then
2374               # Make sure the rpath contains only unique directories.
2375               case "$temp_rpath " in
2376               *" $dir "*) ;;
2377               *" $absdir "*) ;;
2378               *) temp_rpath="$temp_rpath $dir" ;;
2379               esac
2380             fi
2381
2382             # Hardcode the library path.
2383             # Skip directories that are in the system default run-time
2384             # search path.
2385             case " $sys_lib_dlsearch_path " in
2386             *" $absdir "*) ;;
2387             *)
2388               case "$compile_rpath " in
2389               *" $absdir "*) ;;
2390               *) compile_rpath="$compile_rpath $absdir"
2391               esac
2392               ;;
2393             esac
2394             case " $sys_lib_dlsearch_path " in
2395             *" $libdir "*) ;;
2396             *)
2397               case "$finalize_rpath " in
2398               *" $libdir "*) ;;
2399               *) finalize_rpath="$finalize_rpath $libdir"
2400               esac
2401               ;;
2402             esac
2403           fi # $linkmode,$pass = prog,link...
2404
2405           if test "$alldeplibs" = yes &&
2406              { test "$deplibs_check_method" = pass_all ||
2407                { test "$build_libtool_libs" = yes &&
2408                  test -n "$library_names"; }; }; then
2409             # We only need to search for static libraries
2410             continue
2411           fi
2412         fi
2413
2414         link_static=no # Whether the deplib will be linked statically
2415         if test -n "$library_names" &&
2416            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2417           if test "$installed" = no; then
2418             notinst_deplibs="$notinst_deplibs $lib"
2419             need_relink=yes
2420           fi
2421           # This is a shared library
2422
2423           # Warn about portability, can't link against -module's on
2424           # some systems (darwin)
2425           if test "$shouldnotlink" = yes && test "$pass" = link ; then
2426             $echo
2427             if test "$linkmode" = prog; then
2428               $echo "*** Warning: Linking the executable $output against the loadable module"
2429             else
2430               $echo "*** Warning: Linking the shared library $output against the loadable module"
2431             fi
2432             $echo "*** $linklib is not portable!"
2433           fi
2434           if test "$linkmode" = lib &&
2435              test "$hardcode_into_libs" = yes; then
2436             # Hardcode the library path.
2437             # Skip directories that are in the system default run-time
2438             # search path.
2439             case " $sys_lib_dlsearch_path " in
2440             *" $absdir "*) ;;
2441             *)
2442               case "$compile_rpath " in
2443               *" $absdir "*) ;;
2444               *) compile_rpath="$compile_rpath $absdir"
2445               esac
2446               ;;
2447             esac
2448             case " $sys_lib_dlsearch_path " in
2449             *" $libdir "*) ;;
2450             *)
2451               case "$finalize_rpath " in
2452               *" $libdir "*) ;;
2453               *) finalize_rpath="$finalize_rpath $libdir"
2454               esac
2455               ;;
2456             esac
2457           fi
2458
2459           if test -n "$old_archive_from_expsyms_cmds"; then
2460             # figure out the soname
2461             set dummy $library_names
2462             realname="$2"
2463             shift; shift
2464             libname=`eval \\$echo \"$libname_spec\"`
2465             # use dlname if we got it. it's perfectly good, no?
2466             if test -n "$dlname"; then
2467               soname="$dlname"
2468             elif test -n "$soname_spec"; then
2469               # bleh windows
2470               case $host in
2471               *cygwin* | mingw*)
2472                 major=`expr $current - $age`
2473                 versuffix="-$major"
2474                 ;;
2475               esac
2476               eval soname=\"$soname_spec\"
2477             else
2478               soname="$realname"
2479             fi
2480
2481             # Make a new name for the extract_expsyms_cmds to use
2482             soroot="$soname"
2483             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2484             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2485
2486             # If the library has no export list, then create one now
2487             if test -f "$output_objdir/$soname-def"; then :
2488             else
2489               $show "extracting exported symbol list from \`$soname'"
2490               save_ifs="$IFS"; IFS='~'
2491               cmds=$extract_expsyms_cmds
2492               for cmd in $cmds; do
2493                 IFS="$save_ifs"
2494                 eval cmd=\"$cmd\"
2495                 $show "$cmd"
2496                 $run eval "$cmd" || exit $?
2497               done
2498               IFS="$save_ifs"
2499             fi
2500
2501             # Create $newlib
2502             if test -f "$output_objdir/$newlib"; then :; else
2503               $show "generating import library for \`$soname'"
2504               save_ifs="$IFS"; IFS='~'
2505               cmds=$old_archive_from_expsyms_cmds
2506               for cmd in $cmds; do
2507                 IFS="$save_ifs"
2508                 eval cmd=\"$cmd\"
2509                 $show "$cmd"
2510                 $run eval "$cmd" || exit $?
2511               done
2512               IFS="$save_ifs"
2513             fi
2514             # make sure the library variables are pointing to the new library
2515             dir=$output_objdir
2516             linklib=$newlib
2517           fi # test -n "$old_archive_from_expsyms_cmds"
2518
2519           if test "$linkmode" = prog || test "$mode" != relink; then
2520             add_shlibpath=
2521             add_dir=
2522             add=
2523             lib_linked=yes
2524             case $hardcode_action in
2525             immediate | unsupported)
2526               if test "$hardcode_direct" = no; then
2527                 add="$dir/$linklib"
2528                 case $host in
2529                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2530                   *-*-darwin* )
2531                     # if the lib is a module then we can not link against
2532                     # it, someone is ignoring the new warnings I added
2533                     if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2534                       $echo "** Warning, lib $linklib is a module, not a shared library"
2535                       if test -z "$old_library" ; then
2536                         $echo
2537                         $echo "** And there doesn't seem to be a static archive available"
2538                         $echo "** The link will probably fail, sorry"
2539                       else
2540                         add="$dir/$old_library"
2541                       fi
2542                     fi
2543                 esac
2544               elif test "$hardcode_minus_L" = no; then
2545                 case $host in
2546                 *-*-sunos*) add_shlibpath="$dir" ;;
2547                 esac
2548                 add_dir="-L$dir"
2549                 add="-l$name"
2550               elif test "$hardcode_shlibpath_var" = no; then
2551                 add_shlibpath="$dir"
2552                 add="-l$name"
2553               else
2554                 lib_linked=no
2555               fi
2556               ;;
2557             relink)
2558               if test "$hardcode_direct" = yes; then
2559                 add="$dir/$linklib"
2560               elif test "$hardcode_minus_L" = yes; then
2561                 add_dir="-L$dir"
2562                 # Try looking first in the location we're being installed to.
2563                 if test -n "$inst_prefix_dir"; then
2564                   case "$libdir" in
2565                     [\\/]*)
2566                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2567                       ;;
2568                   esac
2569                 fi
2570                 add="-l$name"
2571               elif test "$hardcode_shlibpath_var" = yes; then
2572                 add_shlibpath="$dir"
2573                 add="-l$name"
2574               else
2575                 lib_linked=no
2576               fi
2577               ;;
2578             *) lib_linked=no ;;
2579             esac
2580
2581             if test "$lib_linked" != yes; then
2582               $echo "$modename: configuration error: unsupported hardcode properties"
2583               exit $EXIT_FAILURE
2584             fi
2585
2586             if test -n "$add_shlibpath"; then
2587               case :$compile_shlibpath: in
2588               *":$add_shlibpath:"*) ;;
2589               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2590               esac
2591             fi
2592             if test "$linkmode" = prog; then
2593               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2594               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2595             else
2596               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2597               test -n "$add" && deplibs="$add $deplibs"
2598               if test "$hardcode_direct" != yes && \
2599                  test "$hardcode_minus_L" != yes && \
2600                  test "$hardcode_shlibpath_var" = yes; then
2601                 case :$finalize_shlibpath: in
2602                 *":$libdir:"*) ;;
2603                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2604                 esac
2605               fi
2606             fi
2607           fi
2608
2609           if test "$linkmode" = prog || test "$mode" = relink; then
2610             add_shlibpath=
2611             add_dir=
2612             add=
2613             # Finalize command for both is simple: just hardcode it.
2614             if test "$hardcode_direct" = yes; then
2615               add="$libdir/$linklib"
2616             elif test "$hardcode_minus_L" = yes; then
2617               add_dir="-L$libdir"
2618               add="-l$name"
2619             elif test "$hardcode_shlibpath_var" = yes; then
2620               case :$finalize_shlibpath: in
2621               *":$libdir:"*) ;;
2622               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2623               esac
2624               add="-l$name"
2625             elif test "$hardcode_automatic" = yes; then
2626               if test -n "$inst_prefix_dir" &&
2627                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
2628                 add="$inst_prefix_dir$libdir/$linklib"
2629               else
2630                 add="$libdir/$linklib"
2631               fi
2632             else
2633               # We cannot seem to hardcode it, guess we'll fake it.
2634               add_dir="-L$libdir"
2635               # Try looking first in the location we're being installed to.
2636               if test -n "$inst_prefix_dir"; then
2637                 case "$libdir" in
2638                   [\\/]*)
2639                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2640                     ;;
2641                 esac
2642               fi
2643               add="-l$name"
2644             fi
2645
2646             if test "$linkmode" = prog; then
2647               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2648               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2649             else
2650               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2651               test -n "$add" && deplibs="$add $deplibs"
2652             fi
2653           fi
2654         elif test "$linkmode" = prog; then
2655           # Here we assume that one of hardcode_direct or hardcode_minus_L
2656           # is not unsupported.  This is valid on all known static and
2657           # shared platforms.
2658           if test "$hardcode_direct" != unsupported; then
2659             test -n "$old_library" && linklib="$old_library"
2660             compile_deplibs="$dir/$linklib $compile_deplibs"
2661             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2662           else
2663             compile_deplibs="-l$name -L$dir $compile_deplibs"
2664             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2665           fi
2666         elif test "$build_libtool_libs" = yes; then
2667           # Not a shared library
2668           if test "$deplibs_check_method" != pass_all; then
2669             # We're trying link a shared library against a static one
2670             # but the system doesn't support it.
2671
2672             # Just print a warning and add the library to dependency_libs so
2673             # that the program can be linked against the static library.
2674             $echo
2675             $echo "*** Warning: This system can not link to static lib archive $lib."
2676             $echo "*** I have the capability to make that library automatically link in when"
2677             $echo "*** you link to this library.  But I can only do this if you have a"
2678             $echo "*** shared version of the library, which you do not appear to have."
2679             if test "$module" = yes; then
2680               $echo "*** But as you try to build a module library, libtool will still create "
2681               $echo "*** a static module, that should work as long as the dlopening application"
2682               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2683               if test -z "$global_symbol_pipe"; then
2684                 $echo
2685                 $echo "*** However, this would only work if libtool was able to extract symbol"
2686                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2687                 $echo "*** not find such a program.  So, this module is probably useless."
2688                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2689               fi
2690               if test "$build_old_libs" = no; then
2691                 build_libtool_libs=module
2692                 build_old_libs=yes
2693               else
2694                 build_libtool_libs=no
2695               fi
2696             fi
2697           else
2698             convenience="$convenience $dir/$old_library"
2699             old_convenience="$old_convenience $dir/$old_library"
2700             deplibs="$dir/$old_library $deplibs"
2701             link_static=yes
2702           fi
2703         fi # link shared/static library?
2704
2705         if test "$linkmode" = lib; then
2706           if test -n "$dependency_libs" &&
2707              { test "$hardcode_into_libs" != yes ||
2708                test "$build_old_libs" = yes ||
2709                test "$link_static" = yes; }; then
2710             # Extract -R from dependency_libs
2711             temp_deplibs=
2712             for libdir in $dependency_libs; do
2713               case $libdir in
2714               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2715                    case " $xrpath " in
2716                    *" $temp_xrpath "*) ;;
2717                    *) xrpath="$xrpath $temp_xrpath";;
2718                    esac;;
2719               *) temp_deplibs="$temp_deplibs $libdir";;
2720               esac
2721             done
2722             dependency_libs="$temp_deplibs"
2723           fi
2724
2725           newlib_search_path="$newlib_search_path $absdir"
2726           # Link against this library
2727           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2728           # ... and its dependency_libs
2729           tmp_libs=
2730           for deplib in $dependency_libs; do
2731             newdependency_libs="$deplib $newdependency_libs"
2732             if test "X$duplicate_deps" = "Xyes" ; then
2733               case "$tmp_libs " in
2734               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2735               esac
2736             fi
2737             tmp_libs="$tmp_libs $deplib"
2738           done
2739
2740           if test "$link_all_deplibs" != no; then
2741             # Add the search paths of all dependency libraries
2742             for deplib in $dependency_libs; do
2743               case $deplib in
2744               -L*) path="$deplib" ;;
2745               *.la)
2746                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2747                 test "X$dir" = "X$deplib" && dir="."
2748                 # We need an absolute path.
2749                 case $dir in
2750                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2751                 *)
2752                   absdir=`cd "$dir" && pwd`
2753                   if test -z "$absdir"; then
2754                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2755                     absdir="$dir"
2756                   fi
2757                   ;;
2758                 esac
2759                 if grep "^installed=no" $deplib > /dev/null; then
2760                   path="$absdir/$objdir"
2761                 else
2762                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2763                   if test -z "$libdir"; then
2764                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2765                     exit $EXIT_FAILURE
2766                   fi
2767                   if test "$absdir" != "$libdir"; then
2768                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2769                   fi
2770                   path="$absdir"
2771                 fi
2772                 depdepl=
2773                 case $host in
2774                 *-*-darwin*)
2775                   # we do not want to link against static libs,
2776                   # but need to link against shared
2777                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2778                   if test -n "$deplibrary_names" ; then
2779                     for tmp in $deplibrary_names ; do
2780                       depdepl=$tmp
2781                     done
2782                     if test -f "$path/$depdepl" ; then
2783                       depdepl="$path/$depdepl"
2784                     fi
2785                     # do not add paths which are already there
2786                     case " $newlib_search_path " in
2787                     *" $path "*) ;;
2788                     *) newlib_search_path="$newlib_search_path $path";;
2789                     esac
2790                   fi
2791                   path=""
2792                   ;;
2793                 *)
2794                   path="-L$path"
2795                   ;;
2796                 esac
2797                 ;;
2798               -l*)
2799                 case $host in
2800                 *-*-darwin*)
2801                   # Again, we only want to link against shared libraries
2802                   eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2803                   for tmp in $newlib_search_path ; do
2804                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2805                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2806                       break
2807                     fi
2808                   done
2809                   path=""
2810                   ;;
2811                 *) continue ;;
2812                 esac
2813                 ;;
2814               *) continue ;;
2815               esac
2816               case " $deplibs " in
2817               *" $depdepl "*) ;;
2818               *) deplibs="$depdepl $deplibs" ;;
2819               esac
2820               case " $deplibs " in
2821               *" $path "*) ;;
2822               *) deplibs="$deplibs $path" ;;
2823               esac
2824             done
2825           fi # link_all_deplibs != no
2826         fi # linkmode = lib
2827       done # for deplib in $libs
2828       dependency_libs="$newdependency_libs"
2829       if test "$pass" = dlpreopen; then
2830         # Link the dlpreopened libraries before other libraries
2831         for deplib in $save_deplibs; do
2832           deplibs="$deplib $deplibs"
2833         done
2834       fi
2835       if test "$pass" != dlopen; then
2836         if test "$pass" != conv; then
2837           # Make sure lib_search_path contains only unique directories.
2838           lib_search_path=
2839           for dir in $newlib_search_path; do
2840             case "$lib_search_path " in
2841             *" $dir "*) ;;
2842             *) lib_search_path="$lib_search_path $dir" ;;
2843             esac
2844           done
2845           newlib_search_path=
2846         fi
2847
2848         if test "$linkmode,$pass" != "prog,link"; then
2849           vars="deplibs"
2850         else
2851           vars="compile_deplibs finalize_deplibs"
2852         fi
2853         for var in $vars dependency_libs; do
2854           # Add libraries to $var in reverse order
2855           eval tmp_libs=\"\$$var\"
2856           new_libs=
2857           for deplib in $tmp_libs; do
2858             # FIXME: Pedantically, this is the right thing to do, so
2859             #        that some nasty dependency loop isn't accidentally
2860             #        broken:
2861             #new_libs="$deplib $new_libs"
2862             # Pragmatically, this seems to cause very few problems in
2863             # practice:
2864             case $deplib in
2865             -L*) new_libs="$deplib $new_libs" ;;
2866             -R*) ;;
2867             *)
2868               # And here is the reason: when a library appears more
2869               # than once as an explicit dependence of a library, or
2870               # is implicitly linked in more than once by the
2871               # compiler, it is considered special, and multiple
2872               # occurrences thereof are not removed.  Compare this
2873               # with having the same library being listed as a
2874               # dependency of multiple other libraries: in this case,
2875               # we know (pedantically, we assume) the library does not
2876               # need to be listed more than once, so we keep only the
2877               # last copy.  This is not always right, but it is rare
2878               # enough that we require users that really mean to play
2879               # such unportable linking tricks to link the library
2880               # using -Wl,-lname, so that libtool does not consider it
2881               # for duplicate removal.
2882               case " $specialdeplibs " in
2883               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2884               *)
2885                 case " $new_libs " in
2886                 *" $deplib "*) ;;
2887                 *) new_libs="$deplib $new_libs" ;;
2888                 esac
2889                 ;;
2890               esac
2891               ;;
2892             esac
2893           done
2894           tmp_libs=
2895           for deplib in $new_libs; do
2896             case $deplib in
2897             -L*)
2898               case " $tmp_libs " in
2899               *" $deplib "*) ;;
2900               *) tmp_libs="$tmp_libs $deplib" ;;
2901               esac
2902               ;;
2903             *) tmp_libs="$tmp_libs $deplib" ;;
2904             esac
2905           done
2906           eval $var=\"$tmp_libs\"
2907         done # for var
2908       fi
2909       # Last step: remove runtime libs from dependency_libs
2910       # (they stay in deplibs)
2911       tmp_libs=
2912       for i in $dependency_libs ; do
2913         case " $predeps $postdeps $compiler_lib_search_path " in
2914         *" $i "*)
2915           i=""
2916           ;;
2917         esac
2918         if test -n "$i" ; then
2919           tmp_libs="$tmp_libs $i"
2920         fi
2921       done
2922       dependency_libs=$tmp_libs
2923     done # for pass
2924     if test "$linkmode" = prog; then
2925       dlfiles="$newdlfiles"
2926       dlprefiles="$newdlprefiles"
2927     fi
2928
2929     case $linkmode in
2930     oldlib)
2931       if test -n "$deplibs"; then
2932         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2933       fi
2934
2935       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2936         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2937       fi
2938
2939       if test -n "$rpath"; then
2940         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2941       fi
2942
2943       if test -n "$xrpath"; then
2944         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2945       fi
2946
2947       if test -n "$vinfo"; then
2948         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2949       fi
2950
2951       if test -n "$release"; then
2952         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2953       fi
2954
2955       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2956         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2957       fi
2958
2959       # Now set the variables for building old libraries.
2960       build_libtool_libs=no
2961       oldlibs="$output"
2962       objs="$objs$old_deplibs"
2963       ;;
2964
2965     lib)
2966       # Make sure we only generate libraries of the form `libNAME.la'.
2967       case $outputname in
2968       lib*)
2969         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2970         eval shared_ext=\"$shrext_cmds\"
2971         eval libname=\"$libname_spec\"
2972         ;;
2973       *)
2974         if test "$module" = no; then
2975           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2976           $echo "$help" 1>&2
2977           exit $EXIT_FAILURE
2978         fi
2979         if test "$need_lib_prefix" != no; then
2980           # Add the "lib" prefix for modules if required
2981           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2982           eval shared_ext=\"$shrext_cmds\"
2983           eval libname=\"$libname_spec\"
2984         else
2985           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2986         fi
2987         ;;
2988       esac
2989
2990       if test -n "$objs"; then
2991         if test "$deplibs_check_method" != pass_all; then
2992           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2993           exit $EXIT_FAILURE
2994         else
2995           $echo
2996           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2997           $echo "*** objects $objs is not portable!"
2998           libobjs="$libobjs $objs"
2999         fi
3000       fi
3001
3002       if test "$dlself" != no; then
3003         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3004       fi
3005
3006       set dummy $rpath
3007       if test "$#" -gt 2; then
3008         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3009       fi
3010       install_libdir="$2"
3011
3012       oldlibs=
3013       if test -z "$rpath"; then
3014         if test "$build_libtool_libs" = yes; then
3015           # Building a libtool convenience library.
3016           # Some compilers have problems with a `.al' extension so
3017           # convenience libraries should have the same extension an
3018           # archive normally would.
3019           oldlibs="$output_objdir/$libname.$libext $oldlibs"
3020           build_libtool_libs=convenience
3021           build_old_libs=yes
3022         fi
3023
3024         if test -n "$vinfo"; then
3025           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3026         fi
3027
3028         if test -n "$release"; then
3029           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3030         fi
3031       else
3032
3033         # Parse the version information argument.
3034         save_ifs="$IFS"; IFS=':'
3035         set dummy $vinfo 0 0 0
3036         IFS="$save_ifs"
3037
3038         if test -n "$8"; then
3039           $echo "$modename: too many parameters to \`-version-info'" 1>&2
3040           $echo "$help" 1>&2
3041           exit $EXIT_FAILURE
3042         fi
3043
3044         # convert absolute version numbers to libtool ages
3045         # this retains compatibility with .la files and attempts
3046         # to make the code below a bit more comprehensible
3047
3048         case $vinfo_number in
3049         yes)
3050           number_major="$2"
3051           number_minor="$3"
3052           number_revision="$4"
3053           #
3054           # There are really only two kinds -- those that
3055           # use the current revision as the major version
3056           # and those that subtract age and use age as
3057           # a minor version.  But, then there is irix
3058           # which has an extra 1 added just for fun
3059           #
3060           case $version_type in
3061           darwin|linux|osf|windows)
3062             current=`expr $number_major + $number_minor`
3063             age="$number_minor"
3064             revision="$number_revision"
3065             ;;
3066           freebsd-aout|freebsd-elf|sunos)
3067             current="$number_major"
3068             revision="$number_minor"
3069             age="0"
3070             ;;
3071           irix|nonstopux)
3072             current=`expr $number_major + $number_minor - 1`
3073             age="$number_minor"
3074             revision="$number_minor"
3075             ;;
3076           esac
3077           ;;
3078         no)
3079           current="$2"
3080           revision="$3"
3081           age="$4"
3082           ;;
3083         esac
3084
3085         # Check that each of the things are valid numbers.
3086         case $current in
3087         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3088         *)
3089           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
3090           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3091           exit $EXIT_FAILURE
3092           ;;
3093         esac
3094
3095         case $revision in
3096         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3097         *)
3098           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
3099           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3100           exit $EXIT_FAILURE
3101           ;;
3102         esac
3103
3104         case $age in
3105         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3106         *)
3107           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
3108           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3109           exit $EXIT_FAILURE
3110           ;;
3111         esac
3112
3113         if test "$age" -gt "$current"; then
3114           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3115           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3116           exit $EXIT_FAILURE
3117         fi
3118
3119         # Calculate the version variables.
3120         major=
3121         versuffix=
3122         verstring=
3123         case $version_type in
3124         none) ;;
3125
3126         darwin)
3127           # Like Linux, but with the current version available in
3128           # verstring for coding it into the library header
3129           major=.`expr $current - $age`
3130           versuffix="$major.$age.$revision"
3131           # Darwin ld doesn't like 0 for these options...
3132           minor_current=`expr $current + 1`
3133           verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3134           ;;
3135
3136         freebsd-aout)
3137           major=".$current"
3138           versuffix=".$current.$revision";
3139           ;;
3140
3141         freebsd-elf)
3142           major=".$current"
3143           versuffix=".$current";
3144           ;;
3145
3146         irix | nonstopux)
3147           major=`expr $current - $age + 1`
3148
3149           case $version_type in
3150             nonstopux) verstring_prefix=nonstopux ;;
3151             *)         verstring_prefix=sgi ;;
3152           esac
3153           verstring="$verstring_prefix$major.$revision"
3154
3155           # Add in all the interfaces that we are compatible with.
3156           loop=$revision
3157           while test "$loop" -ne 0; do
3158             iface=`expr $revision - $loop`
3159             loop=`expr $loop - 1`
3160             verstring="$verstring_prefix$major.$iface:$verstring"
3161           done
3162
3163           # Before this point, $major must not contain `.'.
3164           major=.$major
3165           versuffix="$major.$revision"
3166           ;;
3167
3168         linux)
3169           major=.`expr $current - $age`
3170           versuffix="$major.$age.$revision"
3171           ;;
3172
3173         osf)
3174           major=.`expr $current - $age`
3175           versuffix=".$current.$age.$revision"
3176           verstring="$current.$age.$revision"
3177
3178           # Add in all the interfaces that we are compatible with.
3179           loop=$age
3180           while test "$loop" -ne 0; do
3181             iface=`expr $current - $loop`
3182             loop=`expr $loop - 1`
3183             verstring="$verstring:${iface}.0"
3184           done
3185
3186           # Make executables depend on our current version.
3187           verstring="$verstring:${current}.0"
3188           ;;
3189
3190         sunos)
3191           major=".$current"
3192           versuffix=".$current.$revision"
3193           ;;
3194
3195         windows)
3196           # Use '-' rather than '.', since we only want one
3197           # extension on DOS 8.3 filesystems.
3198           major=`expr $current - $age`
3199           versuffix="-$major"
3200           ;;
3201
3202         *)
3203           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3204           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3205           exit $EXIT_FAILURE
3206           ;;
3207         esac
3208
3209         # Clear the version info if we defaulted, and they specified a release.
3210         if test -z "$vinfo" && test -n "$release"; then
3211           major=
3212           case $version_type in
3213           darwin)
3214             # we can't check for "0.0" in archive_cmds due to quoting
3215             # problems, so we reset it completely
3216             verstring=
3217             ;;
3218           *)
3219             verstring="0.0"
3220             ;;
3221           esac
3222           if test "$need_version" = no; then
3223             versuffix=
3224           else
3225             versuffix=".0.0"
3226           fi
3227         fi
3228
3229         # Remove version info from name if versioning should be avoided
3230         if test "$avoid_version" = yes && test "$need_version" = no; then
3231           major=
3232           versuffix=
3233           verstring=""
3234         fi
3235
3236         # Check to see if the archive will have undefined symbols.
3237         if test "$allow_undefined" = yes; then
3238           if test "$allow_undefined_flag" = unsupported; then
3239             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3240             build_libtool_libs=no
3241             build_old_libs=yes
3242           fi
3243         else
3244           # Don't allow undefined symbols.
3245           allow_undefined_flag="$no_undefined_flag"
3246         fi
3247       fi
3248
3249       if test "$mode" != relink; then
3250         # Remove our outputs, but don't remove object files since they
3251         # may have been created when compiling PIC objects.
3252         removelist=
3253         tempremovelist=`$echo "$output_objdir/*"`
3254         for p in $tempremovelist; do
3255           case $p in
3256             *.$objext)
3257                ;;
3258             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3259                if test "X$precious_files_regex" != "X"; then
3260                  if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3261                  then
3262                    continue
3263                  fi
3264                fi
3265                removelist="$removelist $p"
3266                ;;
3267             *) ;;
3268           esac
3269         done
3270         if test -n "$removelist"; then
3271           $show "${rm}r $removelist"
3272           $run ${rm}r $removelist
3273         fi
3274       fi
3275
3276       # Now set the variables for building old libraries.
3277       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3278         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3279
3280         # Transform .lo files to .o files.
3281         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3282       fi
3283
3284       # Eliminate all temporary directories.
3285       for path in $notinst_path; do
3286         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3287         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3288         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3289       done
3290
3291       if test -n "$xrpath"; then
3292         # If the user specified any rpath flags, then add them.
3293         temp_xrpath=
3294         for libdir in $xrpath; do
3295           temp_xrpath="$temp_xrpath -R$libdir"
3296           case "$finalize_rpath " in
3297           *" $libdir "*) ;;
3298           *) finalize_rpath="$finalize_rpath $libdir" ;;
3299           esac
3300         done
3301         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3302           dependency_libs="$temp_xrpath $dependency_libs"
3303         fi
3304       fi
3305
3306       # Make sure dlfiles contains only unique files that won't be dlpreopened
3307       old_dlfiles="$dlfiles"
3308       dlfiles=
3309       for lib in $old_dlfiles; do
3310         case " $dlprefiles $dlfiles " in
3311         *" $lib "*) ;;
3312         *) dlfiles="$dlfiles $lib" ;;
3313         esac
3314       done
3315
3316       # Make sure dlprefiles contains only unique files
3317       old_dlprefiles="$dlprefiles"
3318       dlprefiles=
3319       for lib in $old_dlprefiles; do
3320         case "$dlprefiles " in
3321         *" $lib "*) ;;
3322         *) dlprefiles="$dlprefiles $lib" ;;
3323         esac
3324       done
3325
3326       if test "$build_libtool_libs" = yes; then
3327         if test -n "$rpath"; then
3328           case $host in
3329           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3330             # these systems don't actually have a c library (as such)!
3331             ;;
3332           *-*-rhapsody* | *-*-darwin1.[012])
3333             # Rhapsody C library is in the System framework
3334             deplibs="$deplibs -framework System"
3335             ;;
3336           *-*-netbsd*)
3337             # Don't link with libc until the a.out ld.so is fixed.
3338             ;;
3339           *-*-openbsd* | *-*-freebsd*)
3340             # Do not include libc due to us having libc/libc_r.
3341             test "X$arg" = "X-lc" && continue
3342             ;;
3343           *)
3344             # Add libc to deplibs on all other systems if necessary.
3345             if test "$build_libtool_need_lc" = "yes"; then
3346               deplibs="$deplibs -lc"
3347             fi
3348             ;;
3349           esac
3350         fi
3351
3352         # Transform deplibs into only deplibs that can be linked in shared.
3353         name_save=$name
3354         libname_save=$libname
3355         release_save=$release
3356         versuffix_save=$versuffix
3357         major_save=$major
3358         # I'm not sure if I'm treating the release correctly.  I think
3359         # release should show up in the -l (ie -lgmp5) so we don't want to
3360         # add it in twice.  Is that correct?
3361         release=""
3362         versuffix=""
3363         major=""
3364         newdeplibs=
3365         droppeddeps=no
3366         case $deplibs_check_method in
3367         pass_all)
3368           # Don't check for shared/static.  Everything works.
3369           # This might be a little naive.  We might want to check
3370           # whether the library exists or not.  But this is on
3371           # osf3 & osf4 and I'm not really sure... Just
3372           # implementing what was already the behavior.
3373           newdeplibs=$deplibs
3374           ;;
3375         test_compile)
3376           # This code stresses the "libraries are programs" paradigm to its
3377           # limits. Maybe even breaks it.  We compile a program, linking it
3378           # against the deplibs as a proxy for the library.  Then we can check
3379           # whether they linked in statically or dynamically with ldd.
3380           $rm conftest.c
3381           cat > conftest.c <<EOF
3382           int main() { return 0; }
3383 EOF
3384           $rm conftest
3385           $LTCC -o conftest conftest.c $deplibs
3386           if test "$?" -eq 0 ; then
3387             ldd_output=`ldd conftest`
3388             for i in $deplibs; do
3389               name="`expr $i : '-l\(.*\)'`"
3390               # If $name is empty we are operating on a -L argument.
3391               if test "$name" != "" && test "$name" -ne "0"; then
3392                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3393                   case " $predeps $postdeps " in
3394                   *" $i "*)
3395                     newdeplibs="$newdeplibs $i"
3396                     i=""
3397                     ;;
3398                   esac
3399                 fi
3400                 if test -n "$i" ; then
3401                   libname=`eval \\$echo \"$libname_spec\"`
3402                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3403                   set dummy $deplib_matches
3404                   deplib_match=$2
3405                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3406                     newdeplibs="$newdeplibs $i"
3407                   else
3408                     droppeddeps=yes
3409                     $echo
3410                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3411                     $echo "*** I have the capability to make that library automatically link in when"
3412                     $echo "*** you link to this library.  But I can only do this if you have a"
3413                     $echo "*** shared version of the library, which I believe you do not have"
3414                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3415                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3416                   fi
3417                 fi
3418               else
3419                 newdeplibs="$newdeplibs $i"
3420               fi
3421             done
3422           else
3423             # Error occurred in the first compile.  Let's try to salvage
3424             # the situation: Compile a separate program for each library.
3425             for i in $deplibs; do
3426               name="`expr $i : '-l\(.*\)'`"
3427               # If $name is empty we are operating on a -L argument.
3428               if test "$name" != "" && test "$name" != "0"; then
3429                 $rm conftest
3430                 $LTCC -o conftest conftest.c $i
3431                 # Did it work?
3432                 if test "$?" -eq 0 ; then
3433                   ldd_output=`ldd conftest`
3434                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3435                     case " $predeps $postdeps " in
3436                     *" $i "*)
3437                       newdeplibs="$newdeplibs $i"
3438                       i=""
3439                       ;;
3440                     esac
3441                   fi
3442                   if test -n "$i" ; then
3443                     libname=`eval \\$echo \"$libname_spec\"`
3444                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3445                     set dummy $deplib_matches
3446                     deplib_match=$2
3447                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3448                       newdeplibs="$newdeplibs $i"
3449                     else
3450                       droppeddeps=yes
3451                       $echo
3452                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3453                       $echo "*** I have the capability to make that library automatically link in when"
3454                       $echo "*** you link to this library.  But I can only do this if you have a"
3455                       $echo "*** shared version of the library, which you do not appear to have"
3456                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3457                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3458                     fi
3459                   fi
3460                 else
3461                   droppeddeps=yes
3462                   $echo
3463                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3464                   $echo "***  make it link in!  You will probably need to install it or some"
3465                   $echo "*** library that it depends on before this library will be fully"
3466                   $echo "*** functional.  Installing it before continuing would be even better."
3467                 fi
3468               else
3469                 newdeplibs="$newdeplibs $i"
3470               fi
3471             done
3472           fi
3473           ;;
3474         file_magic*)
3475           set dummy $deplibs_check_method
3476           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3477           for a_deplib in $deplibs; do
3478             name="`expr $a_deplib : '-l\(.*\)'`"
3479             # If $name is empty we are operating on a -L argument.
3480             if test "$name" != "" && test  "$name" != "0"; then
3481               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3482                 case " $predeps $postdeps " in
3483                 *" $a_deplib "*)
3484                   newdeplibs="$newdeplibs $a_deplib"