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