OSDN Git Service

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