OSDN Git Service

2003-11-19 Andreas Tobler <a.tobler@schweiz.ch>
[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               eval cmds=\"$extract_expsyms_cmds\"
2110               for cmd in $cmds; do
2111                 IFS="$save_ifs"
2112                 $show "$cmd"
2113                 $run eval "$cmd" || exit $?
2114               done
2115               IFS="$save_ifs"
2116             fi
2117
2118             # Create $newlib
2119             if test -f "$output_objdir/$newlib"; then :; else
2120               $show "generating import library for \`$soname'"
2121               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2122               eval cmds=\"$old_archive_from_expsyms_cmds\"
2123               for cmd in $cmds; do
2124                 IFS="$save_ifs"
2125                 $show "$cmd"
2126                 $run eval "$cmd" || exit $?
2127               done
2128               IFS="$save_ifs"
2129             fi
2130             # make sure the library variables are pointing to the new library
2131             dir=$output_objdir
2132             linklib=$newlib
2133           fi # test -n $old_archive_from_expsyms_cmds
2134
2135           if test $linkmode = prog || test "$mode" != relink; then
2136             add_shlibpath=
2137             add_dir=
2138             add=
2139             lib_linked=yes
2140             case $hardcode_action in
2141             immediate | unsupported)
2142               if test "$hardcode_direct" = no; then
2143                 add="$dir/$linklib"
2144               elif test "$hardcode_minus_L" = no; then
2145                 case $host in
2146                 *-*-sunos*) add_shlibpath="$dir" ;;
2147                 esac
2148                 add_dir="-L$dir"
2149                 add="-l$name"
2150               elif test "$hardcode_shlibpath_var" = no; then
2151                 add_shlibpath="$dir"
2152                 add="-l$name"
2153               else
2154                 lib_linked=no
2155               fi
2156               ;;
2157             relink)
2158               if test "$hardcode_direct" = yes; then
2159                 add="$dir/$linklib"
2160               elif test "$hardcode_minus_L" = yes; then
2161                 add_dir="-L$dir"
2162                 add="-l$name"
2163               elif test "$hardcode_shlibpath_var" = yes; then
2164                 add_shlibpath="$dir"
2165                 add="-l$name"
2166               else
2167                 lib_linked=no
2168               fi
2169               ;;
2170             *) lib_linked=no ;;
2171             esac
2172
2173             if test "$lib_linked" != yes; then
2174               $echo "$modename: configuration error: unsupported hardcode properties"
2175               exit 1
2176             fi
2177
2178             if test -n "$add_shlibpath"; then
2179               case :$compile_shlibpath: in
2180               *":$add_shlibpath:"*) ;;
2181               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2182               esac
2183             fi
2184             if test $linkmode = prog; then
2185               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2186               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2187             else
2188               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2189               test -n "$add" && deplibs="$add $deplibs"
2190               if test "$hardcode_direct" != yes && \
2191                  test "$hardcode_minus_L" != yes && \
2192                  test "$hardcode_shlibpath_var" = yes; then
2193                 case :$finalize_shlibpath: in
2194                 *":$libdir:"*) ;;
2195                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2196                 esac
2197               fi
2198             fi
2199           fi
2200
2201           if test $linkmode = prog || test "$mode" = relink; then
2202             add_shlibpath=
2203             add_dir=
2204             add=
2205             # Finalize command for both is simple: just hardcode it.
2206             if test "$hardcode_direct" = yes; then
2207               add="$libdir/$linklib"
2208             elif test "$hardcode_minus_L" = yes; then
2209               add_dir="-L$libdir"
2210               add="-l$name"
2211             elif test "$hardcode_shlibpath_var" = yes; then
2212               case :$finalize_shlibpath: in
2213               *":$libdir:"*) ;;
2214               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2215               esac
2216               add="-l$name"
2217             else
2218               # We cannot seem to hardcode it, guess we'll fake it.
2219               add_dir="-L$libdir"
2220               add="-l$name"
2221             fi
2222
2223             if test $linkmode = prog; then
2224               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2225               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2226             else
2227               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2228               test -n "$add" && deplibs="$add $deplibs"
2229             fi
2230           fi
2231         elif test $linkmode = prog; then
2232           if test "$alldeplibs" = yes &&
2233              { test "$deplibs_check_method" = pass_all ||
2234                { test "$build_libtool_libs" = yes &&
2235                  test -n "$library_names"; }; }; then
2236             # We only need to search for static libraries
2237             continue
2238           fi
2239
2240           # Try to link the static library
2241           # Here we assume that one of hardcode_direct or hardcode_minus_L
2242           # is not unsupported.  This is valid on all known static and
2243           # shared platforms.
2244           if test "$hardcode_direct" != unsupported; then
2245             test -n "$old_library" && linklib="$old_library"
2246             compile_deplibs="$dir/$linklib $compile_deplibs"
2247             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2248           else
2249             compile_deplibs="-l$name -L$dir $compile_deplibs"
2250             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2251           fi
2252         elif test "$build_libtool_libs" = yes; then
2253           # Not a shared library
2254           if test "$deplibs_check_method" != pass_all; then
2255             # We're trying link a shared library against a static one
2256             # but the system doesn't support it.
2257
2258             # Just print a warning and add the library to dependency_libs so
2259             # that the program can be linked against the static library.
2260             echo
2261             echo "*** Warning: This library needs some functionality provided by $lib."
2262             echo "*** I have the capability to make that library automatically link in when"
2263             echo "*** you link to this library.  But I can only do this if you have a"
2264             echo "*** shared version of the library, which you do not appear to have."
2265             if test "$module" = yes; then
2266               echo "*** Therefore, libtool will create a static module, that should work "
2267               echo "*** as long as the dlopening application is linked with the -dlopen flag."
2268               if test -z "$global_symbol_pipe"; then
2269                 echo
2270                 echo "*** However, this would only work if libtool was able to extract symbol"
2271                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2272                 echo "*** not find such a program.  So, this module is probably useless."
2273                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
2274               fi
2275               if test "$build_old_libs" = no; then
2276                 build_libtool_libs=module
2277                 build_old_libs=yes
2278               else
2279                 build_libtool_libs=no
2280               fi
2281             fi
2282           else
2283             convenience="$convenience $dir/$old_library"
2284             old_convenience="$old_convenience $dir/$old_library"
2285             deplibs="$dir/$old_library $deplibs"
2286             link_static=yes
2287           fi
2288         fi # link shared/static library?
2289
2290         if test $linkmode = lib; then
2291           if test -n "$dependency_libs" &&
2292              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2293                test $link_static = yes; }; then
2294             # Extract -R from dependency_libs
2295             temp_deplibs=
2296             for libdir in $dependency_libs; do
2297               case $libdir in
2298               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2299                    case " $xrpath " in
2300                    *" $temp_xrpath "*) ;;
2301                    *) xrpath="$xrpath $temp_xrpath";;
2302                    esac;;
2303               *) temp_deplibs="$temp_deplibs $libdir";;
2304               esac
2305             done
2306             dependency_libs="$temp_deplibs"
2307           fi
2308
2309           newlib_search_path="$newlib_search_path $absdir"
2310           # Link against this library
2311           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2312           # ... and its dependency_libs
2313           tmp_libs=
2314           for deplib in $dependency_libs; do
2315             newdependency_libs="$deplib $newdependency_libs"
2316             case "$tmp_libs " in
2317             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2318             esac
2319             tmp_libs="$tmp_libs $deplib"
2320           done
2321
2322           if test $link_all_deplibs != no; then
2323             # Add the search paths of all dependency libraries
2324             for deplib in $dependency_libs; do
2325               case $deplib in
2326               -L*) path="$deplib" ;;
2327               *.la)
2328                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2329                 test "X$dir" = "X$deplib" && dir="."
2330                 # We need an absolute path.
2331                 case $dir in
2332                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2333                 *)
2334                   absdir=`cd "$dir" && pwd`
2335                   if test -z "$absdir"; then
2336                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2337                     absdir="$dir"
2338                   fi
2339                   ;;
2340                 esac
2341                 if grep "^installed=no" $deplib > /dev/null; then
2342                   path="-L$absdir/$objdir"
2343                 else
2344                   eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2345                   if test -z "$libdir"; then
2346                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2347                     exit 1
2348                   fi
2349                   if test "$absdir" != "$libdir"; then
2350                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2351                   fi
2352                   path="-L$absdir"
2353                 fi
2354                 ;;
2355               *) continue ;;
2356               esac
2357               case " $deplibs " in
2358               *" $path "*) ;;
2359               *) deplibs="$path $deplibs" ;;
2360               esac
2361             done
2362           fi # link_all_deplibs != no
2363         fi # linkmode = lib
2364       done # for deplib in $libs
2365       if test $pass = dlpreopen; then
2366         # Link the dlpreopened libraries before other libraries
2367         for deplib in $save_deplibs; do
2368           deplibs="$deplib $deplibs"
2369         done
2370       fi
2371       if test $pass != dlopen; then
2372         test $pass != scan && dependency_libs="$newdependency_libs"
2373         if test $pass != conv; then
2374           # Make sure lib_search_path contains only unique directories.
2375           lib_search_path=
2376           for dir in $newlib_search_path; do
2377             case "$lib_search_path " in
2378             *" $dir "*) ;;
2379             *) lib_search_path="$lib_search_path $dir" ;;
2380             esac
2381           done
2382           newlib_search_path=
2383         fi
2384
2385         if test "$linkmode,$pass" != "prog,link"; then
2386           vars="deplibs"
2387         else
2388           vars="compile_deplibs finalize_deplibs"
2389         fi
2390         for var in $vars dependency_libs; do
2391           # Add libraries to $var in reverse order
2392           eval tmp_libs=\"\$$var\"
2393           new_libs=
2394           for deplib in $tmp_libs; do
2395             case $deplib in
2396             -L*) new_libs="$deplib $new_libs" ;;
2397             *)
2398               case " $specialdeplibs " in
2399               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2400               *)
2401                 case " $new_libs " in
2402                 *" $deplib "*) ;;
2403                 *) new_libs="$deplib $new_libs" ;;
2404                 esac
2405                 ;;
2406               esac
2407               ;;
2408             esac
2409           done
2410           tmp_libs=
2411           for deplib in $new_libs; do
2412             case $deplib in
2413             -L*)
2414               case " $tmp_libs " in
2415               *" $deplib "*) ;;
2416               *) tmp_libs="$tmp_libs $deplib" ;;
2417               esac
2418               ;;
2419             *) tmp_libs="$tmp_libs $deplib" ;;
2420             esac
2421           done
2422           eval $var=\"$tmp_libs\"
2423         done # for var
2424       fi
2425       if test "$pass" = "conv" &&
2426        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2427         libs="$deplibs" # reset libs
2428         deplibs=
2429       fi
2430     done # for pass
2431     if test $linkmode = prog; then
2432       dlfiles="$newdlfiles"
2433       dlprefiles="$newdlprefiles"
2434     fi
2435
2436     case $linkmode in
2437     oldlib)
2438       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2439         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2440       fi
2441
2442       if test -n "$rpath"; then
2443         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2444       fi
2445
2446       if test -n "$xrpath"; then
2447         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2448       fi
2449
2450       if test -n "$vinfo"; then
2451         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2452       fi
2453
2454       if test -n "$release"; then
2455         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2456       fi
2457
2458       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2459         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2460       fi
2461
2462       # Now set the variables for building old libraries.
2463       build_libtool_libs=no
2464       oldlibs="$output"
2465       objs="$objs$old_deplibs"
2466       ;;
2467
2468     lib)
2469       # Make sure we only generate libraries of the form `libNAME.la'.
2470       case $outputname in
2471       lib*)
2472         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2473         eval shared_ext=\"$shrext\"
2474         eval libname=\"$libname_spec\"
2475         ;;
2476       *)
2477         if test "$module" = no; then
2478           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2479           $echo "$help" 1>&2
2480           exit 1
2481         fi
2482         if test "$need_lib_prefix" != no; then
2483           # Add the "lib" prefix for modules if required
2484           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2485           eval shared_ext=\"$shrext\"
2486           eval libname=\"$libname_spec\"
2487         else
2488           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2489         fi
2490         ;;
2491       esac
2492
2493       if test -n "$objs"; then
2494         if test "$deplibs_check_method" != pass_all; then
2495           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2496           exit 1
2497         else
2498           echo
2499           echo "*** Warning: Linking the shared library $output against the non-libtool"
2500           echo "*** objects $objs is not portable!"
2501           libobjs="$libobjs $objs"
2502         fi
2503       fi
2504
2505       if test "$dlself" != no; then
2506         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2507       fi
2508
2509       set dummy $rpath
2510       if test $# -gt 2; then
2511         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2512       fi
2513       install_libdir="$2"
2514
2515       oldlibs=
2516       if test -z "$rpath"; then
2517         if test "$build_libtool_libs" = yes; then
2518           # Building a libtool convenience library.
2519           # Some compilers have problems with a `.al' extension so
2520           # convenience libraries should have the same extension an
2521           # archive normally would.
2522           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2523           build_libtool_libs=convenience
2524           build_old_libs=yes
2525         fi
2526
2527         if test -n "$vinfo"; then
2528           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2529         fi
2530
2531         if test -n "$release"; then
2532           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2533         fi
2534       else
2535
2536         # Parse the version information argument.
2537         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2538         set dummy $vinfo 0 0 0
2539         IFS="$save_ifs"
2540
2541         if test -n "$8"; then
2542           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2543           $echo "$help" 1>&2
2544           exit 1
2545         fi
2546
2547         current="$2"
2548         revision="$3"
2549         age="$4"
2550
2551         # Check that each of the things are valid numbers.
2552         case $current in
2553         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2554         *)
2555           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2556           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2557           exit 1
2558           ;;
2559         esac
2560
2561         case $revision in
2562         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2563         *)
2564           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2565           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2566           exit 1
2567           ;;
2568         esac
2569
2570         case $age in
2571         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2572         *)
2573           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2574           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2575           exit 1
2576           ;;
2577         esac
2578
2579         if test $age -gt $current; then
2580           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2581           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2582           exit 1
2583         fi
2584
2585         # Calculate the version variables.
2586         major=
2587         versuffix=
2588         verstring=
2589         case $version_type in
2590         none) ;;
2591
2592         darwin)
2593           # Like Linux, but with the current version available in
2594           # verstring for coding it into the library header
2595           major=.`expr $current - $age`
2596           versuffix="$major.$age.$revision"
2597           # Darwin ld doesn't like 0 for these options...
2598           minor_current=`expr $current + 1`
2599           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2600           ;;
2601
2602         freebsd-aout)
2603           major=".$current"
2604           versuffix=".$current.$revision";
2605           ;;
2606
2607         freebsd-elf)
2608           major=".$current"
2609           versuffix=".$current";
2610           ;;
2611
2612         irix)
2613           major=`expr $current - $age + 1`
2614           verstring="sgi$major.$revision"
2615
2616           # Add in all the interfaces that we are compatible with.
2617           loop=$revision
2618           while test $loop != 0; do
2619             iface=`expr $revision - $loop`
2620             loop=`expr $loop - 1`
2621             verstring="sgi$major.$iface:$verstring"
2622           done
2623
2624           # Before this point, $major must not contain `.'.
2625           major=.$major
2626           versuffix="$major.$revision"
2627           ;;
2628
2629         linux)
2630           major=.`expr $current - $age`
2631           versuffix="$major.$age.$revision"
2632           ;;
2633
2634         osf)
2635           major=.`expr $current - $age`
2636           versuffix=".$current.$age.$revision"
2637           verstring="$current.$age.$revision"
2638
2639           # Add in all the interfaces that we are compatible with.
2640           loop=$age
2641           while test $loop != 0; do
2642             iface=`expr $current - $loop`
2643             loop=`expr $loop - 1`
2644             verstring="$verstring:${iface}.0"
2645           done
2646
2647           # Make executables depend on our current version.
2648           verstring="$verstring:${current}.0"
2649           ;;
2650
2651         sunos)
2652           major=".$current"
2653           versuffix=".$current.$revision"
2654           ;;
2655
2656         windows)
2657           # Use '-' rather than '.', since we only want one
2658           # extension on DOS 8.3 filesystems.
2659           major=`expr $current - $age`
2660           versuffix="-$major"
2661           ;;
2662
2663         *)
2664           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2665           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2666           exit 1
2667           ;;
2668         esac
2669
2670         # Clear the version info if we defaulted, and they specified a release.
2671         if test -z "$vinfo" && test -n "$release"; then
2672           major=
2673           case $version_type in
2674           darwin)
2675             # we can't check for "0.0" in archive_cmds due to quoting
2676             # problems, so we reset it completely
2677             verstring=
2678             ;;
2679           *)
2680             verstring="0.0"
2681             ;;
2682           esac
2683           if test "$need_version" = no; then
2684             versuffix=
2685           else
2686             versuffix=".0.0"
2687           fi
2688         fi
2689
2690         # Remove version info from name if versioning should be avoided
2691         if test "$avoid_version" = yes && test "$need_version" = no; then
2692           major=
2693           versuffix=
2694           verstring=""
2695         fi
2696
2697         # Check to see if the archive will have undefined symbols.
2698         if test "$allow_undefined" = yes; then
2699           if test "$allow_undefined_flag" = unsupported; then
2700             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2701             build_libtool_libs=no
2702             build_old_libs=yes
2703           fi
2704         else
2705           # Don't allow undefined symbols.
2706           allow_undefined_flag="$no_undefined_flag"
2707         fi
2708       fi
2709
2710       if test "$mode" != relink; then
2711         # Remove our outputs, but don't remove object files since they
2712         # may have been created when compiling PIC objects.
2713         removelist=
2714         tempremovelist=`echo "$output_objdir/*"`
2715         for p in $tempremovelist; do
2716           case $p in
2717             *.$objext)
2718                ;;
2719             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2720                removelist="$removelist $p"
2721                ;;
2722             *) ;;
2723           esac
2724         done
2725         if test -n "$removelist"; then
2726           $show "${rm}r $removelist"
2727           $run ${rm}r $removelist
2728         fi
2729       fi
2730
2731       # Now set the variables for building old libraries.
2732       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2733         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2734
2735         # Transform .lo files to .o files.
2736         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2737       fi
2738
2739       # Eliminate all temporary directories.
2740       for path in $notinst_path; do
2741         lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2742         deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2743         dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2744       done
2745
2746       if test -n "$xrpath"; then
2747         # If the user specified any rpath flags, then add them.
2748         temp_xrpath=
2749         for libdir in $xrpath; do
2750           temp_xrpath="$temp_xrpath -R$libdir"
2751           case "$finalize_rpath " in
2752           *" $libdir "*) ;;
2753           *) finalize_rpath="$finalize_rpath $libdir" ;;
2754           esac
2755         done
2756         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2757           dependency_libs="$temp_xrpath $dependency_libs"
2758         fi
2759       fi
2760
2761       # Make sure dlfiles contains only unique files that won't be dlpreopened
2762       old_dlfiles="$dlfiles"
2763       dlfiles=
2764       for lib in $old_dlfiles; do
2765         case " $dlprefiles $dlfiles " in
2766         *" $lib "*) ;;
2767         *) dlfiles="$dlfiles $lib" ;;
2768         esac
2769       done
2770
2771       # Make sure dlprefiles contains only unique files
2772       old_dlprefiles="$dlprefiles"
2773       dlprefiles=
2774       for lib in $old_dlprefiles; do
2775         case "$dlprefiles " in
2776         *" $lib "*) ;;
2777         *) dlprefiles="$dlprefiles $lib" ;;
2778         esac
2779       done
2780
2781       if test "$build_libtool_libs" = yes; then
2782         if test -n "$rpath"; then
2783           case $host in
2784           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2785             # these systems don't actually have a c library (as such)!
2786             ;;
2787           *-*-rhapsody* | *-*-darwin1.[012])
2788             # Rhapsody C library is in the System framework
2789             deplibs="$deplibs -framework System"
2790             ;;
2791           *-*-netbsd*)
2792             # Don't link with libc until the a.out ld.so is fixed.
2793             ;;
2794           *)
2795             # Add libc to deplibs on all other systems if necessary.
2796             if test $build_libtool_need_lc = "yes"; then
2797               deplibs="$deplibs -lc"
2798             fi
2799             ;;
2800           esac
2801         fi
2802
2803         # Transform deplibs into only deplibs that can be linked in shared.
2804         name_save=$name
2805         libname_save=$libname
2806         release_save=$release
2807         versuffix_save=$versuffix
2808         major_save=$major
2809         # I'm not sure if I'm treating the release correctly.  I think
2810         # release should show up in the -l (ie -lgmp5) so we don't want to
2811         # add it in twice.  Is that correct?
2812         release=""
2813         versuffix=""
2814         major=""
2815         newdeplibs=
2816         droppeddeps=no
2817         case $deplibs_check_method in
2818         pass_all)
2819           # Don't check for shared/static.  Everything works.
2820           # This might be a little naive.  We might want to check
2821           # whether the library exists or not.  But this is on
2822           # osf3 & osf4 and I'm not really sure... Just
2823           # implementing what was already the behaviour.
2824           newdeplibs=$deplibs
2825           ;;
2826         test_compile)
2827           # This code stresses the "libraries are programs" paradigm to its
2828           # limits. Maybe even breaks it.  We compile a program, linking it
2829           # against the deplibs as a proxy for the library.  Then we can check
2830           # whether they linked in statically or dynamically with ldd.
2831           $rm conftest.c
2832           cat > conftest.c <<EOF
2833           int main() { return 0; }
2834 EOF
2835           $rm conftest
2836           $LTCC -o conftest conftest.c $deplibs
2837           if test $? -eq 0 ; then
2838             ldd_output=`ldd conftest`
2839             for i in $deplibs; do
2840               name="`expr $i : '-l\(.*\)'`"
2841               # If $name is empty we are operating on a -L argument.
2842               if test -n "$name" && test "$name" != "0"; then
2843                 libname=`eval \\$echo \"$libname_spec\"`
2844                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2845                 set dummy $deplib_matches
2846                 deplib_match=$2
2847                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2848                   newdeplibs="$newdeplibs $i"
2849                 else
2850                   droppeddeps=yes
2851                   echo
2852                   echo "*** Warning: This library needs some functionality provided by $i."
2853                   echo "*** I have the capability to make that library automatically link in when"
2854                   echo "*** you link to this library.  But I can only do this if you have a"
2855                   echo "*** shared version of the library, which you do not appear to have."
2856                 fi
2857               else
2858                 newdeplibs="$newdeplibs $i"
2859               fi
2860             done
2861           else
2862             # Error occured in the first compile.  Let's try to salvage the situation:
2863             # Compile a seperate program for each library.
2864             for i in $deplibs; do
2865               name="`expr $i : '-l\(.*\)'`"
2866              # If $name is empty we are operating on a -L argument.
2867               if test -n "$name" && test "$name" != "0"; then
2868                 $rm conftest
2869                 $LTCC -o conftest conftest.c $i
2870                 # Did it work?
2871                 if test $? -eq 0 ; then
2872                   ldd_output=`ldd conftest`
2873                   libname=`eval \\$echo \"$libname_spec\"`
2874                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2875                   set dummy $deplib_matches
2876                   deplib_match=$2
2877                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2878                     newdeplibs="$newdeplibs $i"
2879                   else
2880                     droppeddeps=yes
2881                     echo
2882                     echo "*** Warning: This library needs some functionality provided by $i."
2883                     echo "*** I have the capability to make that library automatically link in when"
2884                     echo "*** you link to this library.  But I can only do this if you have a"
2885                     echo "*** shared version of the library, which you do not appear to have."
2886                   fi
2887                 else
2888                   droppeddeps=yes
2889                   echo
2890                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2891                   echo "***  make it link in!  You will probably need to install it or some"
2892                   echo "*** library that it depends on before this library will be fully"
2893                   echo "*** functional.  Installing it before continuing would be even better."
2894                 fi
2895               else
2896                 newdeplibs="$newdeplibs $i"
2897               fi
2898             done
2899           fi
2900           ;;
2901         file_magic*)
2902           set dummy $deplibs_check_method
2903           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2904           for a_deplib in $deplibs; do
2905             name="`expr $a_deplib : '-l\(.*\)'`"
2906             # If $name is empty we are operating on a -L argument.
2907             if test -n "$name" && test "$name" != "0"; then
2908               libname=`eval \\$echo \"$libname_spec\"`
2909               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2910                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2911                     for potent_lib in $potential_libs; do
2912                       # Follow soft links.
2913                       if ls -lLd "$potent_lib" 2>/dev/null \
2914                          | grep " -> " >/dev/null; then
2915                         continue
2916                       fi
2917                       # The statement above tries to avoid entering an
2918                       # endless loop below, in case of cyclic links.
2919                       # We might still enter an endless loop, since a link
2920                       # loop can be closed while we follow links,
2921                       # but so what?
2922                       potlib="$potent_lib"
2923                       while test -h "$potlib" 2>/dev/null; do
2924                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2925                         case $potliblink in
2926                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2927                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2928                         esac
2929                       done
2930                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2931                          | sed 10q \
2932                          | egrep "$file_magic_regex" > /dev/null; then
2933                         newdeplibs="$newdeplibs $a_deplib"
2934                         a_deplib=""
2935                         break 2
2936                       fi
2937                     done
2938               done
2939               if test -n "$a_deplib" ; then
2940                 droppeddeps=yes
2941                 echo
2942                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2943                 echo "*** I have the capability to make that library automatically link in when"
2944                 echo "*** you link to this library.  But I can only do this if you have a"
2945                 echo "*** shared version of the library, which you do not appear to have."
2946               fi
2947             else
2948               # Add a -L argument.
2949               newdeplibs="$newdeplibs $a_deplib"
2950             fi
2951           done # Gone through all deplibs.
2952           ;;
2953         match_pattern*)
2954           set dummy $deplibs_check_method
2955           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2956           for a_deplib in $deplibs; do
2957             name="`expr $a_deplib : '-l\(.*\)'`"
2958             # If $name is empty we are operating on a -L argument.
2959             if test -n "$name" && test "$name" != "0"; then
2960               libname=`eval \\$echo \"$libname_spec\"`
2961               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2962                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2963                 for potent_lib in $potential_libs; do
2964                   if eval echo \"$potent_lib\" 2>/dev/null \
2965                       | sed 10q \
2966                       | egrep "$match_pattern_regex" > /dev/null; then
2967                     newdeplibs="$newdeplibs $a_deplib"
2968                     a_deplib=""
2969                     break 2
2970                   fi
2971                 done
2972               done
2973               if test -n "$a_deplib" ; then
2974                 droppeddeps=yes
2975                 echo
2976                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2977                 echo "*** I have the capability to make that library automatically link in when"
2978                 echo "*** you link to this library.  But I can only do this if you have a"
2979                 echo "*** shared version of the library, which you do not appear to have."
2980               fi
2981             else
2982               # Add a -L argument.
2983               newdeplibs="$newdeplibs $a_deplib"
2984             fi
2985           done # Gone through all deplibs.
2986           ;;
2987         none | unknown | *)
2988           newdeplibs=""
2989           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2990                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2991              grep . >/dev/null; then
2992             echo
2993             if test "X$deplibs_check_method" = "Xnone"; then
2994               echo "*** Warning: inter-library dependencies are not supported in this platform."
2995             else
2996               echo "*** Warning: inter-library dependencies are not known to be supported."
2997             fi
2998             echo "*** All declared inter-library dependencies are being dropped."
2999             droppeddeps=yes
3000           fi
3001           ;;
3002         esac
3003         versuffix=$versuffix_save
3004         major=$major_save
3005         release=$release_save
3006         libname=$libname_save
3007         name=$name_save
3008
3009         case $host in
3010         *-*-rhapsody* | *-*-darwin1.[012])
3011           # On Rhapsody replace the C library is the System framework
3012           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3013           ;;
3014         esac
3015
3016         if test "$droppeddeps" = yes; then
3017           if test "$module" = yes; then
3018             echo
3019             echo "*** Warning: libtool could not satisfy all declared inter-library"
3020             echo "*** dependencies of module $libname.  Therefore, libtool will create"
3021             echo "*** a static module, that should work as long as the dlopening"
3022             echo "*** application is linked with the -dlopen flag."
3023             if test -z "$global_symbol_pipe"; then
3024               echo
3025               echo "*** However, this would only work if libtool was able to extract symbol"
3026               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3027               echo "*** not find such a program.  So, this module is probably useless."
3028               echo "*** \`nm' from GNU binutils and a full rebuild may help."
3029             fi
3030             if test "$build_old_libs" = no; then
3031               oldlibs="$output_objdir/$libname.$libext"
3032               build_libtool_libs=module
3033               build_old_libs=yes
3034             else
3035               build_libtool_libs=no
3036             fi
3037           else
3038             echo "*** The inter-library dependencies that have been dropped here will be"
3039             echo "*** automatically added whenever a program is linked with this library"
3040             echo "*** or is declared to -dlopen it."
3041
3042             if test $allow_undefined = no; then
3043               echo
3044               echo "*** Since this library must not contain undefined symbols,"
3045               echo "*** because either the platform does not support them or"
3046               echo "*** it was explicitly requested with -no-undefined,"
3047               echo "*** libtool will only create a static version of it."
3048               if test "$build_old_libs" = no; then
3049                 oldlibs="$output_objdir/$libname.$libext"
3050                 build_libtool_libs=module
3051                 build_old_libs=yes
3052               else
3053                 build_libtool_libs=no
3054               fi
3055             fi
3056           fi
3057         fi
3058         # Time to change all our "foo.framework" stuff back to "-framework foo"
3059         case $host in
3060             *-*-darwin*)
3061                 newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3062                 dependency_libs=`$echo "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3063                 ;;
3064         esac
3065         # Done checking deplibs!
3066         # Done checking deplibs!
3067         deplibs=$newdeplibs
3068       fi
3069
3070       # All the library-specific variables (install_libdir is set above).
3071       library_names=
3072       old_library=
3073       dlname=
3074
3075       # Test again, we may have decided not to build it any more
3076       if test "$build_libtool_libs" = yes; then
3077         if test $hardcode_into_libs = yes; then
3078           # Hardcode the library paths
3079           hardcode_libdirs=
3080           dep_rpath=
3081           rpath="$finalize_rpath"
3082           test "$mode" != relink && rpath="$compile_rpath$rpath"
3083           for libdir in $rpath; do
3084             if test -n "$hardcode_libdir_flag_spec"; then
3085               if test -n "$hardcode_libdir_separator"; then
3086                 if test -z "$hardcode_libdirs"; then
3087                   hardcode_libdirs="$libdir"
3088                 else
3089                   # Just accumulate the unique libdirs.
3090                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3091                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3092                     ;;
3093                   *)
3094                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3095                     ;;
3096                   esac
3097                 fi
3098               else
3099                 eval flag=\"$hardcode_libdir_flag_spec\"
3100                 dep_rpath="$dep_rpath $flag"
3101               fi
3102             elif test -n "$runpath_var"; then
3103               case "$perm_rpath " in
3104               *" $libdir "*) ;;
3105               *) perm_rpath="$perm_rpath $libdir" ;;
3106               esac
3107             fi
3108           done
3109           # Substitute the hardcoded libdirs into the rpath.
3110           if test -n "$hardcode_libdir_separator" &&
3111              test -n "$hardcode_libdirs"; then
3112             libdir="$hardcode_libdirs"
3113             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3114           fi
3115           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3116             # We should set the runpath_var.
3117             rpath=
3118             for dir in $perm_rpath; do
3119               rpath="$rpath$dir:"
3120             done
3121             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3122           fi
3123           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3124         fi
3125
3126         shlibpath="$finalize_shlibpath"
3127         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3128         if test -n "$shlibpath"; then
3129           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3130         fi
3131
3132         # Get the real and link names of the library.
3133         eval library_names=\"$library_names_spec\"
3134         eval shared_ext=\"$shrext\"
3135         set dummy $library_names
3136         realname="$2"
3137         shift; shift
3138
3139         if test -n "$soname_spec"; then
3140           eval soname=\"$soname_spec\"
3141         else
3142           soname="$realname"
3143         fi
3144         test -z "$dlname" && dlname=$soname
3145
3146         lib="$output_objdir/$realname"
3147         for link
3148         do
3149           linknames="$linknames $link"
3150         done
3151
3152 #       # Ensure that we have .o objects for linkers which dislike .lo
3153 #       # (e.g. aix) in case we are running --disable-static
3154 #       for obj in $libobjs; do
3155 #         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3156 #         if test "X$xdir" = "X$obj"; then
3157 #           xdir="."
3158 #         else
3159 #           xdir="$xdir"
3160 #         fi
3161 #         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3162 #         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3163 #         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3164 #           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3165 #           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3166 #         fi
3167 #       done
3168
3169         # Use standard objects if they are pic
3170         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3171
3172         # Prepare the list of exported symbols
3173         if test -z "$export_symbols"; then
3174           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3175             $show "generating symbol list for \`$libname.la'"
3176             export_symbols="$output_objdir/$libname.exp"
3177             $run $rm $export_symbols
3178             eval cmds=\"$export_symbols_cmds\"
3179             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3180             for cmd in $cmds; do
3181               IFS="$save_ifs"
3182               $show "$cmd"
3183               $run eval "$cmd" || exit $?
3184             done
3185             IFS="$save_ifs"
3186             if test -n "$export_symbols_regex"; then
3187               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3188               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3189               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3190               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3191             fi
3192           fi
3193         fi
3194
3195         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3196           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3197         fi
3198
3199         if test -n "$convenience"; then
3200           if test -n "$whole_archive_flag_spec"; then
3201             save_libobjs=$libobjs
3202             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3203           else
3204             gentop="$output_objdir/${outputname}x"
3205             $show "${rm}r $gentop"
3206             $run ${rm}r "$gentop"
3207             $show "$mkdir $gentop"
3208             $run $mkdir "$gentop"
3209             status=$?
3210             if test $status -ne 0 && test ! -d "$gentop"; then
3211               exit $status
3212             fi
3213             generated="$generated $gentop"
3214
3215             for xlib in $convenience; do
3216               # Extract the objects.
3217               case $xlib in
3218               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3219               *) xabs=`pwd`"/$xlib" ;;
3220               esac
3221               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3222               xdir="$gentop/$xlib"
3223
3224               $show "${rm}r $xdir"
3225               $run ${rm}r "$xdir"
3226               $show "$mkdir $xdir"
3227               $run $mkdir "$xdir"
3228               status=$?
3229               if test $status -ne 0 && test ! -d "$xdir"; then
3230                 exit $status
3231               fi
3232               $show "(cd $xdir && $AR x $xabs)"
3233               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3234
3235               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3236             done
3237           fi
3238         fi
3239
3240         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3241           eval flag=\"$thread_safe_flag_spec\"
3242           linker_flags="$linker_flags $flag"
3243         fi
3244
3245         # Make a backup of the uninstalled library when relinking
3246         if test "$mode" = relink; then
3247           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3248         fi
3249
3250         # Do each of the archive commands.
3251         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3252           eval cmds=\"$archive_expsym_cmds\"
3253         else
3254           eval cmds=\"$archive_cmds\"
3255         fi
3256         if len=`expr "X$cmds" : ".*"` &&
3257            test $len -le $max_cmd_len; then
3258           :
3259         else
3260           # The command line is too long to link in one step, link piecewise.
3261           $echo "creating reloadable object files..."
3262
3263           # Save the value of $output and $libobjs because we want to
3264           # use them later.  If we have whole_archive_flag_spec, we
3265           # want to use save_libobjs as it was before
3266           # whole_archive_flag_spec was expanded, because we can't
3267           # assume the linker understands whole_archive_flag_spec.
3268           # This may have to be revisited, in case too many
3269           # convenience libraries get linked in and end up exceeding
3270           # the spec.
3271           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3272             save_libobjs=$libobjs
3273           fi
3274           save_output=$output
3275
3276           # Clear the reloadable object creation command queue and
3277           # initialize k to one.
3278           test_cmds=
3279           concat_cmds=
3280           objlist=
3281           delfiles=
3282           last_robj=
3283           k=1
3284           output=$output_objdir/$save_output-${k}.$objext
3285           # Loop over the list of objects to be linked.
3286           for obj in $save_libobjs
3287           do
3288             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3289             if test "X$objlist" = X ||
3290                { len=`expr "X$test_cmds" : ".*"` &&
3291                  test $len -le $max_cmd_len; }; then
3292               objlist="$objlist $obj"
3293             else
3294               # The command $test_cmds is almost too long, add a
3295               # command to the queue.
3296               if test $k -eq 1 ; then
3297                 # The first file doesn't have a previous command to add.
3298                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3299               else
3300                 # All subsequent reloadable object files will link in
3301                 # the last one created.
3302                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3303               fi
3304               last_robj=$output_objdir/$save_output-${k}.$objext
3305               k=`expr $k + 1`
3306               output=$output_objdir/$save_output-${k}.$objext
3307               objlist=$obj
3308               len=1
3309             fi
3310           done
3311           # Handle the remaining objects by creating one last
3312           # reloadable object file.  All subsequent reloadable object
3313           # files will link in the last one created.
3314           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3315           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3316
3317           # Set up a command to remove the reloadale object files
3318           # after they are used.
3319           i=0
3320           while test $i -lt $k
3321           do
3322             i=`expr $i + 1`
3323             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3324           done
3325
3326           $echo "creating a temporary reloadable object file: $output"
3327
3328           # Loop through the commands generated above and execute them.
3329           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3330           for cmd in $concat_cmds; do
3331             IFS="$save_ifs"
3332             $show "$cmd"
3333             $run eval "$cmd" || exit $?
3334           done
3335           IFS="$save_ifs"
3336
3337           libobjs=$output
3338           # Restore the value of output.
3339           output=$save_output
3340
3341           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3342             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3343           fi
3344           # Expand the library linking commands again to reset the
3345           # value of $libobjs for piecewise linking.
3346
3347           # Do each of the archive commands.
3348           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3349             eval cmds=\"$archive_expsym_cmds\"
3350           else
3351             eval cmds=\"$archive_cmds\"
3352           fi
3353
3354           # Append the command to remove the reloadable object files
3355           # to the just-reset $cmds.
3356           eval cmds=\"\$cmds~$rm $delfiles\"
3357         fi
3358         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3359         for cmd in $cmds; do
3360           IFS="$save_ifs"
3361           $show "$cmd"
3362           $run eval "$cmd" || exit $?
3363         done
3364         IFS="$save_ifs"
3365
3366         # Restore the uninstalled library and exit
3367         if test "$mode" = relink; then
3368           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3369           exit 0
3370         fi
3371
3372         # Create links to the real library.
3373         for linkname in $linknames; do
3374           if test "$realname" != "$linkname"; then
3375             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3376             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3377           fi
3378         done
3379
3380         # If -module or -export-dynamic was specified, set the dlname.
3381         if test "$module" = yes || test "$export_dynamic" = yes; then
3382           # On all known operating systems, these are identical.
3383           dlname="$soname"
3384         fi
3385       fi
3386       ;;
3387
3388     obj)
3389       if test -n "$deplibs"; then
3390         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3391       fi
3392
3393       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3394         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3395       fi
3396
3397       if test -n "$rpath"; then
3398         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3399       fi
3400
3401       if test -n "$xrpath"; then
3402         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3403       fi
3404
3405       if test -n "$vinfo"; then
3406         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3407       fi
3408
3409       if test -n "$release"; then
3410         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3411       fi
3412
3413       case $output in
3414       *.lo)
3415         if test -n "$objs$old_deplibs"; then
3416           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3417           exit 1
3418         fi
3419         libobj="$output"
3420         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3421         ;;
3422       *)
3423         libobj=
3424         obj="$output"
3425         ;;
3426       esac
3427
3428       # Delete the old objects.
3429       $run $rm $obj $libobj
3430
3431       # Objects from convenience libraries.  This assumes
3432       # single-version convenience libraries.  Whenever we create
3433       # different ones for PIC/non-PIC, this we'll have to duplicate
3434       # the extraction.
3435       reload_conv_objs=
3436       gentop=
3437       # reload_cmds runs $LD directly, so let us get rid of
3438       # -Wl from whole_archive_flag_spec
3439       wl=
3440
3441       if test -n "$convenience"; then
3442         if test -n "$whole_archive_flag_spec"; then
3443           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3444         else
3445           gentop="$output_objdir/${obj}x"
3446           $show "${rm}r $gentop"
3447           $run ${rm}r "$gentop"
3448           $show "$mkdir $gentop"
3449           $run $mkdir "$gentop"
3450           status=$?
3451           if test $status -ne 0 && test ! -d "$gentop"; then
3452             exit $status
3453           fi
3454           generated="$generated $gentop"
3455
3456           for xlib in $convenience; do
3457             # Extract the objects.
3458             case $xlib in
3459             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3460             *) xabs=`pwd`"/$xlib" ;;
3461             esac
3462             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3463             xdir="$gentop/$xlib"
3464
3465             $show "${rm}r $xdir"
3466             $run ${rm}r "$xdir"
3467             $show "$mkdir $xdir"
3468             $run $mkdir "$xdir"
3469             status=$?
3470             if test $status -ne 0 && test ! -d "$xdir"; then
3471               exit $status
3472             fi
3473             $show "(cd $xdir && $AR x $xabs)"
3474             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3475
3476             reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3477           done
3478         fi
3479       fi
3480
3481       # Create the old-style object.
3482       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
3483
3484       output="$obj"
3485       eval cmds=\"$reload_cmds\"
3486       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3487       for cmd in $cmds; do
3488         IFS="$save_ifs"
3489         $show "$cmd"
3490         $run eval "$cmd" || exit $?
3491       done
3492       IFS="$save_ifs"
3493
3494       # Exit if we aren't doing a library object file.
3495       if test -z "$libobj"; then
3496         if test -n "$gentop"; then
3497           $show "${rm}r $gentop"
3498           $run ${rm}r $gentop
3499         fi
3500
3501         exit 0
3502       fi
3503
3504       if test "$build_libtool_libs" != yes; then
3505         if test -n "$gentop"; then
3506           $show "${rm}r $gentop"
3507           $run ${rm}r $gentop
3508         fi
3509
3510         # Create an invalid libtool object if no PIC, so that we don't
3511         # accidentally link it into a program.
3512         # $show "echo timestamp > $libobj"
3513         # $run eval "echo timestamp > $libobj" || exit $?
3514         exit 0
3515       fi
3516
3517       if test -n "$pic_flag" || test "$pic_mode" != default; then
3518         # Only do commands if we really have different PIC objects.
3519         reload_objs="$libobjs $reload_conv_objs"
3520         output="$libobj"
3521         eval cmds=\"$reload_cmds\"
3522         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3523         for cmd in $cmds; do
3524           IFS="$save_ifs"
3525           $show "$cmd"
3526           $run eval "$cmd" || exit $?
3527         done
3528         IFS="$save_ifs"
3529 #     else
3530 #       # Just create a symlink.
3531 #       $show $rm $libobj
3532 #       $run $rm $libobj
3533 #       xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
3534 #       if test "X$xdir" = "X$libobj"; then
3535 #         xdir="."
3536 #       else
3537 #         xdir="$xdir"
3538 #       fi
3539 #       baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
3540 #       oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3541 #       $show "(cd $xdir && $LN_S $oldobj $baseobj)"
3542 #       $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
3543       fi
3544
3545       if test -n "$gentop"; then
3546         $show "${rm}r $gentop"
3547         $run ${rm}r $gentop
3548       fi
3549
3550       exit 0
3551       ;;
3552
3553     prog)
3554       case $host in
3555         *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
3556       esac
3557       if test -n "$vinfo"; then
3558         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
3559       fi
3560
3561       if test -n "$release"; then
3562         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
3563       fi
3564
3565       if test "$preload" = yes; then
3566         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
3567            test "$dlopen_self_static" = unknown; then
3568           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
3569         fi
3570       fi
3571
3572       case $host in
3573       *-*-rhapsody* | *-*-darwin1.[012])
3574         # On Rhapsody replace the C library is the System framework
3575         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3576         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3577         ;;
3578       esac
3579
3580       case $host in
3581       *-*-darwin*)
3582       # Don't allow lazy linking, it breaks C++ global constructors
3583         if test "$tagname" = CXX ; then
3584            compile_command="$compile_command ${wl}-bind_at_load"
3585            finalize_command="$finalize_command ${wl}-bind_at_load"
3586         fi
3587       # Time to change all our "foo.framework" stuff back to "-framework foo"
3588         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3589         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3590         ;;
3591       esac
3592
3593       compile_command="$compile_command $compile_deplibs"
3594       finalize_command="$finalize_command $finalize_deplibs"
3595
3596       if test -n "$rpath$xrpath"; then
3597         # If the user specified any rpath flags, then add them.
3598         for libdir in $rpath $xrpath; do
3599           # This is the magic to use -rpath.
3600           case "$finalize_rpath " in
3601           *" $libdir "*) ;;
3602           *) finalize_rpath="$finalize_rpath $libdir" ;;
3603           esac
3604         done
3605       fi
3606
3607       # Now hardcode the library paths
3608       rpath=
3609       hardcode_libdirs=
3610       for libdir in $compile_rpath $finalize_rpath; do
3611         if test -n "$hardcode_libdir_flag_spec"; then
3612           if test -n "$hardcode_libdir_separator"; then
3613             if test -z "$hardcode_libdirs"; then
3614               hardcode_libdirs="$libdir"
3615             else
3616               # Just accumulate the unique libdirs.
3617               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3618               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3619                 ;;
3620               *)
3621                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3622                 ;;
3623               esac
3624             fi
3625           else
3626             eval flag=\"$hardcode_libdir_flag_spec\"
3627             rpath="$rpath $flag"
3628           fi
3629         elif test -n "$runpath_var"; then
3630           case "$perm_rpath " in
3631           *" $libdir "*) ;;
3632           *) perm_rpath="$perm_rpath $libdir" ;;
3633           esac
3634         fi
3635         case $host in
3636         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3637           case :$dllsearchpath: in
3638           *":$libdir:"*) ;;
3639           *) dllsearchpath="$dllsearchpath:$libdir";;
3640           esac
3641           ;;
3642         esac
3643       done
3644       # Substitute the hardcoded libdirs into the rpath.
3645       if test -n "$hardcode_libdir_separator" &&
3646          test -n "$hardcode_libdirs"; then
3647         libdir="$hardcode_libdirs"
3648         eval rpath=\" $hardcode_libdir_flag_spec\"
3649       fi
3650       compile_rpath="$rpath"
3651
3652       rpath=
3653       hardcode_libdirs=
3654       for libdir in $finalize_rpath; do
3655         if test -n "$hardcode_libdir_flag_spec"; then
3656           if test -n "$hardcode_libdir_separator"; then
3657             if test -z "$hardcode_libdirs"; then
3658               hardcode_libdirs="$libdir"
3659             else
3660               # Just accumulate the unique libdirs.
3661               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3662               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3663                 ;;
3664               *)
3665                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3666                 ;;
3667               esac
3668             fi
3669           else
3670             eval flag=\"$hardcode_libdir_flag_spec\"
3671             rpath="$rpath $flag"
3672           fi
3673         elif test -n "$runpath_var"; then
3674           case "$finalize_perm_rpath " in
3675           *" $libdir "*) ;;
3676           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
3677           esac
3678         fi
3679       done
3680       # Substitute the hardcoded libdirs into the rpath.
3681       if test -n "$hardcode_libdir_separator" &&
3682          test -n "$hardcode_libdirs"; then
3683         libdir="$hardcode_libdirs"
3684         eval rpath=\" $hardcode_libdir_flag_spec\"
3685       fi
3686       finalize_rpath="$rpath"
3687
3688       dlsyms=
3689       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3690         if test -n "$NM" && test -n "$global_symbol_pipe"; then
3691           dlsyms="${outputname}S.c"
3692         else
3693           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
3694         fi
3695       fi
3696
3697       if test -n "$dlsyms"; then
3698         case $dlsyms in
3699         "") ;;
3700         *.c)
3701           # Discover the nlist of each of the dlfiles.
3702           nlist="$output_objdir/${outputname}.nm"
3703
3704           $show "$rm $nlist ${nlist}S ${nlist}T"
3705           $run $rm "$nlist" "${nlist}S" "${nlist}T"
3706
3707           # Parse the name list into a source file.
3708           $show "creating $output_objdir/$dlsyms"
3709
3710           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
3711 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
3712 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
3713
3714 #ifdef __cplusplus
3715 extern \"C\" {
3716 #endif
3717
3718 /* Prevent the only kind of declaration conflicts we can make. */
3719 #define lt_preloaded_symbols some_other_symbol
3720
3721 /* External symbol declarations for the compiler. */\
3722 "
3723
3724           if test "$dlself" = yes; then
3725             $show "generating symbol list for \`$output'"
3726
3727             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
3728
3729             # Add our own program objects to the symbol list.
3730             progfiles="$objs$old_deplibs"
3731             for arg in $progfiles; do
3732               $show "extracting global C symbols from \`$arg'"
3733               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3734             done
3735
3736             if test -n "$exclude_expsyms"; then
3737               $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3738               $run eval '$mv "$nlist"T "$nlist"'
3739             fi
3740
3741             if test -n "$export_symbols_regex"; then
3742               $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3743               $run eval '$mv "$nlist"T "$nlist"'
3744             fi
3745
3746             # Prepare the list of exported symbols
3747             if test -z "$export_symbols"; then
3748               export_symbols="$output_objdir/$output.exp"
3749               $run $rm $export_symbols
3750               $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3751             else
3752               $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
3753               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
3754               $run eval 'mv "$nlist"T "$nlist"'
3755             fi
3756           fi
3757
3758           for arg in $dlprefiles; do
3759             $show "extracting global C symbols from \`$arg'"
3760             name=`echo "$arg" | sed -e 's%^.*/%%'`
3761             $run eval 'echo ": $name " >> "$nlist"'
3762             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3763           done
3764
3765           if test -z "$run"; then
3766             # Make sure we have at least an empty file.
3767             test -f "$nlist" || : > "$nlist"
3768
3769             if test -n "$exclude_expsyms"; then
3770               egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3771               $mv "$nlist"T "$nlist"
3772             fi
3773
3774             # Try sorting and uniquifying the output.
3775             if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
3776               :
3777             else
3778               grep -v "^: " < "$nlist" > "$nlist"S
3779             fi
3780
3781             if test -f "$nlist"S; then
3782               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
3783             else
3784               echo '/* NONE */' >> "$output_objdir/$dlsyms"
3785             fi
3786
3787             $echo >> "$output_objdir/$dlsyms" "\
3788
3789 #undef lt_preloaded_symbols
3790
3791 #if defined (__STDC__) && __STDC__
3792 # define lt_ptr_t void *
3793 #else
3794 # define lt_ptr_t char *
3795 # define const
3796 #endif
3797
3798 /* The mapping between symbol names and symbols. */
3799 const struct {
3800   const char *name;
3801   lt_ptr_t address;
3802 }
3803 lt_preloaded_symbols[] =
3804 {\
3805 "
3806
3807             sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
3808                 -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
3809                   < "$nlist" >> "$output_objdir/$dlsyms"
3810
3811             $echo >> "$output_objdir/$dlsyms" "\
3812   {0, (lt_ptr_t) 0}
3813 };
3814
3815 /* This works around a problem in FreeBSD linker */
3816 #ifdef FREEBSD_WORKAROUND
3817 static const void *lt_preloaded_setup() {
3818   return lt_preloaded_symbols;
3819 }
3820 #endif
3821
3822 #ifdef __cplusplus
3823 }
3824 #endif\
3825 "
3826           fi
3827
3828           pic_flag_for_symtable=
3829           case $host in
3830           # compiling the symbol table file with pic_flag works around
3831           # a FreeBSD bug that causes programs to crash when -lm is
3832           # linked before any other PIC object.  But we must not use
3833           # pic_flag when linking with -static.  The problem exists in
3834           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3835           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3836             case "$compile_command " in
3837             *" -static "*) ;;
3838             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
3839             esac;;
3840           *-*-hpux*)
3841             case "$compile_command " in
3842             *" -static "*) ;;
3843             *) pic_flag_for_symtable=" $pic_flag";;
3844             esac
3845           esac
3846
3847           # Now compile the dynamic symbol file.
3848           $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
3849           $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
3850
3851           # Clean up the generated files.
3852           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
3853           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
3854
3855           # Transform the symbol file into the correct name.
3856           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3857           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3858           ;;
3859         *)
3860           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
3861           exit 1
3862           ;;
3863         esac
3864       else
3865         # We keep going just in case the user didn't refer to
3866         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3867         # really was required.
3868
3869         # Nullify the symbol file.
3870         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3871         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3872       fi
3873
3874       if test $need_relink = no || test "$build_libtool_libs" != yes; then
3875         # Replace the output file specification.
3876         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3877         link_command="$compile_command$compile_rpath"
3878
3879         # We have no uninstalled library dependencies, so finalize right now.
3880         $show "$link_command"
3881         $run eval "$link_command"
3882         status=$?
3883
3884         # Delete the generated files.
3885         if test -n "$dlsyms"; then
3886           $show "$rm $output_objdir/${outputname}S.${objext}"
3887           $run $rm "$output_objdir/${outputname}S.${objext}"
3888         fi
3889
3890         exit $status
3891       fi
3892
3893       if test -n "$shlibpath_var"; then
3894         # We should set the shlibpath_var
3895         rpath=
3896         for dir in $temp_rpath; do
3897           case $dir in
3898           [\\/]* | [A-Za-z]:[\\/]*)
3899             # Absolute path.
3900             rpath="$rpath$dir:"
3901             ;;
3902           *)
3903             # Relative path: add a thisdir entry.
3904             rpath="$rpath\$thisdir/$dir:"
3905             ;;
3906           esac
3907         done
3908         temp_rpath="$rpath"
3909       fi
3910
3911       if test -n "$compile_shlibpath$finalize_shlibpath"; then
3912         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
3913       fi
3914       if test -n "$finalize_shlibpath"; then
3915         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
3916       fi
3917
3918       compile_var=
3919       finalize_var=
3920       if test -n "$runpath_var"; then
3921         if test -n "$perm_rpath"; then
3922           # We should set the runpath_var.
3923           rpath=
3924           for dir in $perm_rpath; do
3925             rpath="$rpath$dir:"
3926           done
3927           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
3928         fi
3929         if test -n "$finalize_perm_rpath"; then
3930           # We should set the runpath_var.
3931           rpath=
3932           for dir in $finalize_perm_rpath; do
3933             rpath="$rpath$dir:"
3934           done
3935           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
3936         fi
3937       fi
3938
3939       if test "$no_install" = yes; then
3940         # We don't need to create a wrapper script.
3941         link_command="$compile_var$compile_command$compile_rpath"
3942         # Replace the output file specification.
3943         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3944         # Delete the old output file.
3945         $run $rm $output
3946         # Link the executable and exit
3947         $show "$link_command"
3948         $run eval "$link_command" || exit $?
3949         exit 0
3950       fi
3951
3952       if test "$hardcode_action" = relink; then
3953         # Fast installation is not supported
3954         link_command="$compile_var$compile_command$compile_rpath"
3955         relink_command="$finalize_var$finalize_command$finalize_rpath"
3956
3957         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
3958         $echo "$modename: \`$output' will be relinked during installation" 1>&2
3959       else
3960         if test "$fast_install" != no; then
3961