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