OSDN Git Service

837902e658ce096148091f8433466872c663a5d4
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 #
22 # As a special exception to the GNU General Public License, if you
23 # distribute this file as part of a program that contains a
24 # configuration script generated by Autoconf, you may include it under
25 # the same distribution terms that you use for the rest of that program.
26
27 # 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                 else
1045                   # If the PIC object exists, use it instead.
1046                   # $xdir was prepended to $pic_object above.
1047                   non_pic_object="$pic_object"
1048                   non_pic_objects="$non_pic_objects $non_pic_object"
1049                 fi
1050               else
1051                 # Only an error if not doing a dry-run.
1052                 if test -z "$run"; then
1053                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1054                   exit 1
1055                 else
1056                   # Dry-run case.
1057
1058                   # Extract subdirectory from the argument.
1059                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1060                   if test "X$xdir" = "X$arg"; then
1061                     xdir=
1062                   else
1063                     xdir="$xdir/"
1064                   fi
1065
1066                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1067                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1068                   libobjs="$libobjs $pic_object"
1069                   non_pic_objects="$non_pic_objects $non_pic_object"
1070                 fi
1071               fi
1072             done
1073           else
1074             $echo "$modename: link input file \`$save_arg' does not exist"
1075             exit 1
1076           fi
1077           arg=$save_arg
1078           prev=
1079           continue
1080           ;;
1081         rpath | xrpath)
1082           # We need an absolute path.
1083           case $arg in
1084           [\\/]* | [A-Za-z]:[\\/]*) ;;
1085           *)
1086             $echo "$modename: only absolute run-paths are allowed" 1>&2
1087             exit 1
1088             ;;
1089           esac
1090           if test "$prev" = rpath; then
1091             case "$rpath " in
1092             *" $arg "*) ;;
1093             *) rpath="$rpath $arg" ;;
1094             esac
1095           else
1096             case "$xrpath " in
1097             *" $arg "*) ;;
1098             *) xrpath="$xrpath $arg" ;;
1099             esac
1100           fi
1101           prev=
1102           continue
1103           ;;
1104         xcompiler)
1105           compiler_flags="$compiler_flags $qarg"
1106           prev=
1107           compile_command="$compile_command $qarg"
1108           finalize_command="$finalize_command $qarg"
1109           continue
1110           ;;
1111         xlinker)
1112           linker_flags="$linker_flags $qarg"
1113           compiler_flags="$compiler_flags $wl$qarg"
1114           prev=
1115           compile_command="$compile_command $wl$qarg"
1116           finalize_command="$finalize_command $wl$qarg"
1117           continue
1118           ;;
1119         framework)
1120           case $host in
1121            *-*-darwin*)
1122              case "$deplibs " in
1123                *" $qarg.framework "*) ;;
1124                *) deplibs="$deplibs $qarg.framework" # this is fixed later
1125                   ;;
1126              esac
1127              ;;
1128           esac
1129           prev=
1130           continue
1131           ;;
1132         *)
1133           eval "$prev=\"\$arg\""
1134           prev=
1135           continue
1136           ;;
1137         esac
1138       fi # test -n $prev
1139
1140       prevarg="$arg"
1141
1142       case $arg in
1143       -all-static)
1144         if test -n "$link_static_flag"; then
1145           compile_command="$compile_command $link_static_flag"
1146           finalize_command="$finalize_command $link_static_flag"
1147         fi
1148         continue
1149         ;;
1150
1151       -allow-undefined)
1152         # FIXME: remove this flag sometime in the future.
1153         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1154         continue
1155         ;;
1156
1157       -avoid-version)
1158         avoid_version=yes
1159         continue
1160         ;;
1161
1162       -dlopen)
1163         prev=dlfiles
1164         continue
1165         ;;
1166
1167       -dlpreopen)
1168         prev=dlprefiles
1169         continue
1170         ;;
1171
1172       -export-dynamic)
1173         export_dynamic=yes
1174         continue
1175         ;;
1176
1177       -export-symbols | -export-symbols-regex)
1178         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1179           $echo "$modename: more than one -exported-symbols argument is not allowed"
1180           exit 1
1181         fi
1182         if test "X$arg" = "X-export-symbols"; then
1183           prev=expsyms
1184         else
1185           prev=expsyms_regex
1186         fi
1187         continue
1188         ;;
1189
1190       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1191       # so, if we see these flags be careful not to treat them like -L
1192       -L[A-Z][A-Z]*:*)
1193         case $with_gcc/$host in
1194         no/*-*-irix*)
1195           compile_command="$compile_command $arg"
1196           finalize_command="$finalize_command $arg"
1197           ;;
1198         esac
1199         continue
1200         ;;
1201
1202       -L*)
1203         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1204         # We need an absolute path.
1205         case $dir in
1206         [\\/]* | [A-Za-z]:[\\/]*) ;;
1207         *)
1208           absdir=`cd "$dir" && pwd`
1209           if test -z "$absdir"; then
1210             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1211             exit 1
1212           fi
1213           dir="$absdir"
1214           ;;
1215         esac
1216         case "$deplibs " in
1217         *" -L$dir "*) ;;
1218         *)
1219           deplibs="$deplibs -L$dir"
1220           lib_search_path="$lib_search_path $dir"
1221           ;;
1222         esac
1223         case $host in
1224         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1225           case :$dllsearchpath: in
1226           *":$dir:"*) ;;
1227           *) dllsearchpath="$dllsearchpath:$dir";;
1228           esac
1229           ;;
1230         esac
1231         continue
1232         ;;
1233
1234       -l*)
1235         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1236           case $host in
1237           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1238             # These systems don't actually have a C or math library (as such)
1239             continue
1240             ;;
1241           *-*-mingw* | *-*-os2*)
1242             # These systems don't actually have a C library (as such)
1243             test "X$arg" = "X-lc" && continue
1244             ;;
1245           esac
1246         fi
1247         deplibs="$deplibs $arg"
1248         continue
1249         ;;
1250
1251       -module)
1252         module=yes
1253         continue
1254         ;;
1255
1256       -no-fast-install)
1257         fast_install=no
1258         continue
1259         ;;
1260
1261       -no-install)
1262         case $host in
1263         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1264           # The PATH hackery in wrapper scripts is required on Windows
1265           # in order for the loader to find any dlls it needs.
1266           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1267           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1268           fast_install=no
1269           ;;
1270         *) no_install=yes ;;
1271         esac
1272         continue
1273         ;;
1274
1275       -no-undefined)
1276         allow_undefined=no
1277         continue
1278         ;;
1279
1280       -objectlist)
1281         prev=objectlist
1282         continue
1283         ;;
1284
1285       -o) prev=output ;;
1286
1287       -release)
1288         prev=release
1289         continue
1290         ;;
1291
1292       -rpath)
1293         prev=rpath
1294         continue
1295         ;;
1296
1297       -R)
1298         prev=xrpath
1299         continue
1300         ;;
1301
1302       -R*)
1303         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1304         # We need an absolute path.
1305         case $dir in
1306         [\\/]* | [A-Za-z]:[\\/]*) ;;
1307         *)
1308           $echo "$modename: only absolute run-paths are allowed" 1>&2
1309           exit 1
1310           ;;
1311         esac
1312         case "$xrpath " in
1313         *" $dir "*) ;;
1314         *) xrpath="$xrpath $dir" ;;
1315         esac
1316         continue
1317         ;;
1318
1319       -static)
1320         # The effects of -static are defined in a previous loop.
1321         # We used to do the same as -all-static on platforms that
1322         # didn't have a PIC flag, but the assumption that the effects
1323         # would be equivalent was wrong.  It would break on at least
1324         # Digital Unix and AIX.
1325         continue
1326         ;;
1327
1328       -thread-safe)
1329         thread_safe=yes
1330         continue
1331         ;;
1332
1333       -version-info)
1334         prev=vinfo
1335         continue
1336         ;;
1337
1338       -Wc,*)
1339         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1340         arg=
1341         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1342         for flag in $args; do
1343           IFS="$save_ifs"
1344           case $flag in
1345             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1346             flag="\"$flag\""
1347             ;;
1348           esac
1349           arg="$arg $wl$flag"
1350           compiler_flags="$compiler_flags $flag"
1351         done
1352         IFS="$save_ifs"
1353         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1354         ;;
1355
1356       -Wl,*)
1357         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1358         arg=
1359         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1360         for flag in $args; do
1361           IFS="$save_ifs"
1362           case $flag in
1363             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1364             flag="\"$flag\""
1365             ;;
1366           esac
1367           arg="$arg $wl$flag"
1368           compiler_flags="$compiler_flags $wl$flag"
1369           linker_flags="$linker_flags $flag"
1370         done
1371         IFS="$save_ifs"
1372         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1373         ;;
1374
1375       -Xcompiler)
1376         prev=xcompiler
1377         continue
1378         ;;
1379
1380       -Xlinker)
1381         prev=xlinker
1382         continue
1383         ;;
1384       -framework)
1385         prev=framework
1386         continue
1387         ;;
1388
1389       # Some other compiler flag.
1390       -* | +*)
1391         # Unknown arguments in both finalize_command and compile_command need
1392         # to be aesthetically quoted because they are evaled later.
1393         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1394         case $arg in
1395         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1396           arg="\"$arg\""
1397           ;;
1398         esac
1399         ;;
1400
1401       *.$objext)
1402         # A standard object.
1403         objs="$objs $arg"
1404         ;;
1405
1406       *.lo)
1407         # A libtool-controlled object.
1408
1409         # Check to see that this really is a libtool object.
1410         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1411           pic_object=
1412           non_pic_object=
1413
1414           # Read the .lo file
1415           # If there is no directory component, then add one.
1416           case $arg in
1417           */* | *\\*) . $arg ;;
1418           *) . ./$arg ;;
1419           esac
1420
1421           if test -z "$pic_object" || \
1422              test -z "$non_pic_object" ||
1423              test "$pic_object" = none && \
1424              test "$non_pic_object" = none; then
1425             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1426             exit 1
1427           fi
1428
1429           # Extract subdirectory from the argument.
1430           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1431           if test "X$xdir" = "X$arg"; then
1432             xdir=
1433           else
1434             xdir="$xdir/"
1435           fi
1436
1437           if test "$pic_object" != none; then
1438             # Prepend the subdirectory the object is found in.
1439             pic_object="$xdir$pic_object"
1440
1441             if test "$prev" = dlfiles; then
1442               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1443                 dlfiles="$dlfiles $pic_object"
1444                 prev=
1445                 continue
1446               else
1447                 # If libtool objects are unsupported, then we need to preload.
1448                 prev=dlprefiles
1449               fi
1450             fi
1451
1452             # CHECK ME:  I think I busted this.  -Ossama
1453             if test "$prev" = dlprefiles; then
1454               # Preload the old-style object.
1455               dlprefiles="$dlprefiles $pic_object"
1456               prev=
1457             fi
1458
1459             # A PIC object.
1460             libobjs="$libobjs $pic_object"
1461             arg="$pic_object"
1462           fi
1463
1464           # Non-PIC object.
1465           if test "$non_pic_object" != none; then
1466             # Prepend the subdirectory the object is found in.
1467             non_pic_object="$xdir$non_pic_object"
1468
1469             # A standard non-PIC object
1470             non_pic_objects="$non_pic_objects $non_pic_object"
1471             if test -z "$pic_object" || test "$pic_object" = none ; then
1472               arg="$non_pic_object"
1473             fi
1474           else
1475             # If the PIC object exists, use it instead.
1476             # $xdir was prepended to $pic_object above.
1477             non_pic_object="$pic_object"
1478             non_pic_objects="$non_pic_objects $non_pic_object"
1479           fi
1480         else
1481           # Only an error if not doing a dry-run.
1482           if test -z "$run"; then
1483             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1484             exit 1
1485           else
1486             # Dry-run case.
1487
1488             # Extract subdirectory from the argument.
1489             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1490             if test "X$xdir" = "X$arg"; then
1491               xdir=
1492             else
1493               xdir="$xdir/"
1494             fi
1495
1496             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1497             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1498             libobjs="$libobjs $pic_object"
1499             non_pic_objects="$non_pic_objects $non_pic_object"
1500           fi
1501         fi
1502         ;;
1503
1504       *.$libext)
1505         # An archive.
1506         deplibs="$deplibs $arg"
1507         old_deplibs="$old_deplibs $arg"
1508         continue
1509         ;;
1510
1511       *.la)
1512         # A libtool-controlled library.
1513
1514         if test "$prev" = dlfiles; then
1515           # This library was specified with -dlopen.
1516           dlfiles="$dlfiles $arg"
1517           prev=
1518         elif test "$prev" = dlprefiles; then
1519           # The library was specified with -dlpreopen.
1520           dlprefiles="$dlprefiles $arg"
1521           prev=
1522         else
1523           deplibs="$deplibs $arg"
1524         fi
1525         continue
1526         ;;
1527
1528       # Some other compiler argument.
1529       *)
1530         # Unknown arguments in both finalize_command and compile_command need
1531         # to be aesthetically quoted because they are evaled later.
1532         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1533         case $arg in
1534         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1535           arg="\"$arg\""
1536           ;;
1537         esac
1538         ;;
1539       esac # arg
1540
1541       # Now actually substitute the argument into the commands.
1542       if test -n "$arg"; then
1543         compile_command="$compile_command $arg"
1544         finalize_command="$finalize_command $arg"
1545       fi
1546     done # argument parsing loop
1547
1548     if test -n "$prev"; then
1549       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1550       $echo "$help" 1>&2
1551       exit 1
1552     fi
1553
1554     # Infer tagged configuration to use if any are available and
1555     # if one wasn't chosen via the "--tag" command line option.
1556     # Only attempt this if the compiler in the base link
1557     # command doesn't match the default compiler.
1558     if test -n "$available_tags" && test -z "$tagname"; then
1559       case $base_compile in
1560       "$CC "*) ;;
1561       # Blanks in the command may have been stripped by the calling shell,
1562       # but not from the CC environment variable when ltconfig was run.
1563       "`$echo $CC` "*) ;;
1564       *)
1565         for z in $available_tags; do
1566           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1567             # Evaluate the configuration.
1568             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1569             case $base_compile in
1570             "$CC "*)
1571               # The compiler in $compile_command matches
1572               # the one in the tagged configuration.
1573               # Assume this is the tagged configuration we want.
1574               tagname=$z
1575               break
1576               ;;
1577             "`$echo $CC` "*)
1578               tagname=$z
1579               break
1580               ;;
1581             esac
1582           fi
1583         done
1584         # If $tagname still isn't set, then no tagged configuration
1585         # was found and let the user know that the "--tag" command
1586         # line option must be used.
1587         if test -z "$tagname"; then
1588           echo "$modename: unable to infer tagged configuration"
1589           echo "$modename: specify a tag with \`--tag'" 1>&2
1590           exit 1
1591 #       else
1592 #         echo "$modename: using $tagname tagged configuration"
1593         fi
1594         ;;
1595       esac
1596     fi
1597
1598     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1599       eval arg=\"$export_dynamic_flag_spec\"
1600       compile_command="$compile_command $arg"
1601       finalize_command="$finalize_command $arg"
1602     fi
1603
1604     # calculate the name of the file, without its directory
1605     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1606     libobjs_save="$libobjs"
1607
1608     if test -n "$shlibpath_var"; then
1609       # get the directories listed in $shlibpath_var
1610       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1611     else
1612       shlib_search_path=
1613     fi
1614     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1615     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1616
1617     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1618     if test "X$output_objdir" = "X$output"; then
1619       output_objdir="$objdir"
1620     else
1621       output_objdir="$output_objdir/$objdir"
1622     fi
1623     # Create the object directory.
1624     if test ! -d $output_objdir; then
1625       $show "$mkdir $output_objdir"
1626       $run $mkdir $output_objdir
1627       status=$?
1628       if test $status -ne 0 && test ! -d $output_objdir; then
1629         exit $status
1630       fi
1631     fi
1632
1633     # Determine the type of output
1634     case $output in
1635     "")
1636       $echo "$modename: you must specify an output file" 1>&2
1637       $echo "$help" 1>&2
1638       exit 1
1639       ;;
1640     *.$libext) linkmode=oldlib ;;
1641     *.lo | *.$objext) linkmode=obj ;;
1642     *.la) linkmode=lib ;;
1643     *) linkmode=prog ;; # Anything else should be a program.
1644     esac
1645
1646     specialdeplibs=
1647     libs=
1648     # Find all interdependent deplibs by searching for libraries
1649     # that are linked more than once (e.g. -la -lb -la)
1650     for deplib in $deplibs; do
1651       case "$libs " in
1652       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1653       esac
1654       libs="$libs $deplib"
1655     done
1656
1657     if test $linkmode = lib; then
1658       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1659
1660       # Compute libraries that are listed more than once in $predeps
1661       # $postdeps and mark them as special (i.e., whose duplicates are
1662       # not to be eliminated).
1663       pre_post_deps=
1664       for pre_post_dep in $predeps $postdeps; do
1665         case "$pre_post_deps " in
1666         *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1667         esac
1668         pre_post_deps="$pre_post_deps $pre_post_dep"
1669       done
1670       pre_post_deps=
1671     fi
1672
1673     deplibs=
1674     newdependency_libs=
1675     newlib_search_path=
1676     need_relink=no # whether we're linking any uninstalled libtool libraries
1677     notinst_deplibs= # not-installed libtool libraries
1678     notinst_path= # paths that contain not-installed libtool libraries
1679     case $linkmode in
1680     lib)
1681         passes="conv link"
1682         for file in $dlfiles $dlprefiles; do
1683           case $file in
1684           *.la) ;;
1685           *)
1686             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1687             exit 1
1688             ;;
1689           esac
1690         done
1691         ;;
1692     prog)
1693         compile_deplibs=
1694         finalize_deplibs=
1695         alldeplibs=no
1696         newdlfiles=
1697         newdlprefiles=
1698         passes="conv scan dlopen dlpreopen link"
1699         ;;
1700     *)  passes="conv"
1701         ;;
1702     esac
1703     for pass in $passes; do
1704       if test $linkmode = prog; then
1705         # Determine which files to process
1706         case $pass in
1707         dlopen)
1708           libs="$dlfiles"
1709           save_deplibs="$deplibs" # Collect dlpreopened libraries
1710           deplibs=
1711           ;;
1712         dlpreopen) libs="$dlprefiles" ;;
1713         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1714         esac
1715       fi
1716       for deplib in $libs; do
1717         lib=
1718         found=no
1719         case $deplib in
1720         -l*)
1721           if test $linkmode = oldlib && test $linkmode = obj; then
1722             $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1723             continue
1724           fi
1725           if test $pass = conv; then
1726             deplibs="$deplib $deplibs"
1727             continue
1728           fi
1729           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1730           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1731             # Search the libtool library
1732             lib="$searchdir/lib${name}.la"
1733             if test -f "$lib"; then
1734               found=yes
1735               break
1736             fi
1737           done
1738           if test "$found" != yes; then
1739             # deplib doesn't seem to be a libtool library
1740             if test "$linkmode,$pass" = "prog,link"; then
1741               compile_deplibs="$deplib $compile_deplibs"
1742               finalize_deplibs="$deplib $finalize_deplibs"
1743             else
1744               deplibs="$deplib $deplibs"
1745               test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1746             fi
1747             continue
1748           fi
1749           ;; # -l
1750         -L*)
1751           case $linkmode in
1752           lib)
1753             deplibs="$deplib $deplibs"
1754             test $pass = conv && continue
1755             newdependency_libs="$deplib $newdependency_libs"
1756             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1757             ;;
1758           prog)
1759             if test $pass = conv; then
1760               deplibs="$deplib $deplibs"
1761               continue
1762             fi
1763             if test $pass = scan; then
1764               deplibs="$deplib $deplibs"
1765               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1766             else
1767               compile_deplibs="$deplib $compile_deplibs"
1768               finalize_deplibs="$deplib $finalize_deplibs"
1769             fi
1770             ;;
1771           *)
1772             $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1773             ;;
1774           esac # linkmode
1775           continue
1776           ;; # -L
1777         -R*)
1778           if test $pass = link; then
1779             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1780             # Make sure the xrpath contains only unique directories.
1781             case "$xrpath " in
1782             *" $dir "*) ;;
1783             *) xrpath="$xrpath $dir" ;;
1784             esac
1785           fi
1786           deplibs="$deplib $deplibs"
1787           continue
1788           ;;
1789         *.la) lib="$deplib" ;;
1790         *.$libext)
1791           if test $pass = conv; then
1792             deplibs="$deplib $deplibs"
1793             continue
1794           fi
1795           case $linkmode in
1796           lib)
1797             if test "$deplibs_check_method" != pass_all; then
1798               echo
1799               echo "*** Warning: This library needs some functionality provided by $deplib."
1800               echo "*** I have the capability to make that library automatically link in when"
1801               echo "*** you link to this library.  But I can only do this if you have a"
1802               echo "*** shared version of the library, which you do not appear to have."
1803             else
1804               echo
1805               echo "*** Warning: Linking the shared library $output against the"
1806               echo "*** static library $deplib is not portable!"
1807               deplibs="$deplib $deplibs"
1808             fi
1809             continue
1810             ;;
1811           prog)
1812             if test $pass != link; then
1813               deplibs="$deplib $deplibs"
1814             else
1815               compile_deplibs="$deplib $compile_deplibs"
1816               finalize_deplibs="$deplib $finalize_deplibs"
1817             fi
1818             continue
1819             ;;
1820           esac # linkmode
1821           ;; # *.$libext
1822         *.lo | *.$objext)
1823           if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1824             # If there is no dlopen support or we're linking statically,
1825             # we need to preload.
1826             newdlprefiles="$newdlprefiles $deplib"
1827             compile_deplibs="$deplib $compile_deplibs"
1828             finalize_deplibs="$deplib $finalize_deplibs"
1829           else
1830             newdlfiles="$newdlfiles $deplib"
1831           fi
1832           continue
1833           ;;
1834         %DEPLIBS%)
1835           alldeplibs=yes
1836           continue
1837           ;;
1838         esac # case $deplib
1839         if test $found = yes || test -f "$lib"; then :
1840         else
1841           $echo "$modename: cannot find the library \`$lib'" 1>&2
1842           exit 1
1843         fi
1844
1845         # Check to see that this really is a libtool archive.
1846         if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1847         else
1848           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1849           exit 1
1850         fi
1851
1852         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1853         test "X$ladir" = "X$lib" && ladir="."
1854
1855         dlname=
1856         dlopen=
1857         dlpreopen=
1858         libdir=
1859         library_names=
1860         old_library=
1861         # If the library was installed with an old release of libtool,
1862         # it will not redefine variable installed.
1863         installed=yes
1864
1865         # Read the .la file
1866         case $lib in
1867         */* | *\\*) . $lib ;;
1868         *) . ./$lib ;;
1869         esac
1870
1871         case $host in
1872             *-*-darwin*)
1873           # Convert "-framework foo" to "foo.framework" in dependency_libs
1874                 test -n "$dependency_libs" && dependency_libs=`$echo "X$dependency_libs" | $Xsed -e 's/-framework \([^ $]*\)/\1.framework/g'`
1875                 ;;
1876         esac
1877
1878         if test "$linkmode,$pass" = "lib,link" ||
1879            test "$linkmode,$pass" = "prog,scan" ||
1880            { test $linkmode = oldlib && test $linkmode = obj; }; then
1881            # Add dl[pre]opened files of deplib
1882           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1883           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1884         fi
1885
1886         if test $pass = conv; then
1887           # Only check for convenience libraries
1888           deplibs="$lib $deplibs"
1889           if test -z "$libdir"; then
1890             if test -z "$old_library"; then
1891               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1892               exit 1
1893             fi
1894             # It is a libtool convenience library, so add in its objects.
1895             convenience="$convenience $ladir/$objdir/$old_library"
1896             old_convenience="$old_convenience $ladir/$objdir/$old_library"
1897             tmp_libs=
1898             for deplib in $dependency_libs; do
1899               deplibs="$deplib $deplibs"
1900               case "$tmp_libs " in
1901               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1902               esac
1903               tmp_libs="$tmp_libs $deplib"
1904             done
1905           elif test $linkmode != prog && test $linkmode != lib; then
1906             $echo "$modename: \`$lib' is not a convenience library" 1>&2
1907             exit 1
1908           fi
1909           continue
1910         fi # $pass = conv
1911
1912         # Get the name of the library we link against.
1913         linklib=
1914         for l in $old_library $library_names; do
1915           linklib="$l"
1916         done
1917         if test -z "$linklib"; then
1918           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1919           exit 1
1920         fi
1921
1922         # This library was specified with -dlopen.
1923         if test $pass = dlopen; then
1924           if test -z "$libdir"; then
1925             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1926             exit 1
1927           fi
1928           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1929             # If there is no dlname, no dlopen support or we're linking
1930             # statically, we need to preload.
1931             dlprefiles="$dlprefiles $lib"
1932           else
1933             newdlfiles="$newdlfiles $lib"
1934           fi
1935           continue
1936         fi # $pass = dlopen
1937
1938         # We need an absolute path.
1939         case $ladir in
1940         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1941         *)
1942           abs_ladir=`cd "$ladir" && pwd`
1943           if test -z "$abs_ladir"; then
1944             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1945             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1946             abs_ladir="$ladir"
1947           fi
1948           ;;
1949         esac
1950         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1951
1952         # Find the relevant object directory and library name.
1953         if test "X$installed" = Xyes; then
1954           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1955             $echo "$modename: warning: library \`$lib' was moved." 1>&2
1956             dir="$ladir"
1957             absdir="$abs_ladir"
1958             libdir="$abs_ladir"
1959           else
1960             dir="$libdir"
1961             absdir="$libdir"
1962           fi
1963         else
1964           dir="$ladir/$objdir"
1965           absdir="$abs_ladir/$objdir"
1966           # Remove this search path later
1967           notinst_path="$notinst_path $abs_ladir"
1968         fi # $installed = yes
1969         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1970
1971         # This library was specified with -dlpreopen.
1972         if test $pass = dlpreopen; then
1973           if test -z "$libdir"; then
1974             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1975             exit 1
1976           fi
1977           # Prefer using a static library (so that no silly _DYNAMIC symbols
1978           # are required to link).
1979           if test -n "$old_library"; then
1980             newdlprefiles="$newdlprefiles $dir/$old_library"
1981           # Otherwise, use the dlname, so that lt_dlopen finds it.
1982           elif test -n "$dlname"; then
1983             newdlprefiles="$newdlprefiles $dir/$dlname"
1984           else
1985             newdlprefiles="$newdlprefiles $dir/$linklib"
1986           fi
1987         fi # $pass = dlpreopen
1988
1989         if test -z "$libdir"; then
1990           # Link the convenience library
1991           if test $linkmode = lib; then
1992             deplibs="$dir/$old_library $deplibs"
1993           elif test "$linkmode,$pass" = "prog,link"; then
1994             compile_deplibs="$dir/$old_library $compile_deplibs"
1995             finalize_deplibs="$dir/$old_library $finalize_deplibs"
1996           else
1997             deplibs="$lib $deplibs"
1998           fi
1999           continue
2000         fi
2001
2002         if test $linkmode = prog && test $pass != link; then
2003           newlib_search_path="$newlib_search_path $ladir"
2004           deplibs="$lib $deplibs"
2005
2006           linkalldeplibs=no
2007           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2008              test "$build_libtool_libs" = no; then
2009             linkalldeplibs=yes
2010           fi
2011
2012           tmp_libs=
2013           for deplib in $dependency_libs; do
2014             case $deplib in
2015             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2016             esac
2017             # Need to link against all dependency_libs?
2018             if test $linkalldeplibs = yes; then
2019               deplibs="$deplib $deplibs"
2020             else
2021               # Need to hardcode shared library paths
2022               # or/and link against static libraries
2023               newdependency_libs="$deplib $newdependency_libs"
2024             fi
2025             case "$tmp_libs " in
2026             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2027             esac
2028             tmp_libs="$tmp_libs $deplib"
2029           done # for deplib
2030           continue
2031         fi # $linkmode = prog...
2032
2033         link_static=no # Whether the deplib will be linked statically
2034         if test -n "$library_names" &&
2035            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2036           # Link against this shared library
2037
2038           if test "$linkmode,$pass" = "prog,link" ||
2039            { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
2040             # Hardcode the library path.
2041             # Skip directories that are in the system default run-time
2042             # search path.
2043             case " $sys_lib_dlsearch_path " in
2044             *" $absdir "*) ;;
2045             *)
2046               case "$compile_rpath " in
2047               *" $absdir "*) ;;
2048               *) compile_rpath="$compile_rpath $absdir"
2049               esac
2050               ;;
2051             esac
2052             case " $sys_lib_dlsearch_path " in
2053             *" $libdir "*) ;;
2054             *)
2055               case "$finalize_rpath " in
2056               *" $libdir "*) ;;
2057               *) finalize_rpath="$finalize_rpath $libdir"
2058               esac
2059               ;;
2060             esac
2061             if test $linkmode = prog; then
2062               # We need to hardcode the library path
2063               if test -n "$shlibpath_var"; then
2064                 # Make sure the rpath contains only unique directories.
2065                 case "$temp_rpath " in
2066                 *" $dir "*) ;;
2067                 *" $absdir "*) ;;
2068                 *) temp_rpath="$temp_rpath $dir" ;;
2069                 esac
2070               fi
2071             fi
2072           fi # $linkmode,$pass = prog,link...
2073
2074           if test "$alldeplibs" = yes &&
2075              { test "$deplibs_check_method" = pass_all ||
2076                { test "$build_libtool_libs" = yes &&
2077                  test -n "$library_names"; }; }; then
2078             # We only need to search for static libraries
2079             continue
2080           fi
2081
2082           if test "$installed" = no; then
2083             notinst_deplibs="$notinst_deplibs $lib"
2084             need_relink=yes
2085           fi
2086
2087           if test -n "$old_archive_from_expsyms_cmds"; then
2088             # figure out the soname
2089             set dummy $library_names
2090             realname="$2"
2091             shift; shift
2092             libname=`eval \\$echo \"$libname_spec\"`
2093             # use dlname if we got it. it's perfectly good, no?
2094             if test -n "$dlname"; then
2095               soname="$dlname"
2096             elif test -n "$soname_spec"; then
2097               # bleh windows
2098               case $host in
2099               *cygwin*)
2100                 major=`expr $current - $age`
2101                 versuffix="-$major"
2102                 ;;
2103               esac
2104               eval soname=\"$soname_spec\"
2105             else
2106               soname="$realname"
2107             fi
2108
2109             # Make a new name for the extract_expsyms_cmds to use
2110             soroot="$soname"
2111             soname=`echo $soroot | sed -e 's/^.*\///'`
2112             newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
2113
2114             # If the library has no export list, then create one now
2115             if test -f "$output_objdir/$soname-def"; then :
2116             else
2117               $show "extracting exported symbol list from \`$soname'"
2118               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2119               cmds=$extract_expsyms_cmds
2120               for cmd in $cmds; do
2121                 IFS="$save_ifs"
2122                 eval cmd=\"$cmd\"
2123                 $show "$cmd"
2124                 $run eval "$cmd" || exit $?
2125               done
2126               IFS="$save_ifs"
2127             fi
2128
2129             # Create $newlib
2130             if test -f "$output_objdir/$newlib"; then :; else
2131               $show "generating import library for \`$soname'"
2132               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2133               cmds=$old_archive_from_expsyms_cmds
2134               for cmd in $cmds; do
2135                 IFS="$save_ifs"
2136                 eval cmd=\"$cmd\"
2137                 $show "$cmd"
2138                 $run eval "$cmd" || exit $?
2139               done
2140               IFS="$save_ifs"
2141             fi
2142             # make sure the library variables are pointing to the new library
2143             dir=$output_objdir
2144             linklib=$newlib
2145           fi # test -n $old_archive_from_expsyms_cmds
2146
2147           if test $linkmode = prog || test "$mode" != relink; then
2148             add_shlibpath=
2149             add_dir=
2150             add=
2151             lib_linked=yes
2152             case $hardcode_action in
2153             immediate | unsupported)
2154               if test "$hardcode_direct" = no; then
2155                 add="$dir/$linklib"
2156               elif test "$hardcode_minus_L" = no; then
2157                 case $host in
2158                 *-*-sunos*) add_shlibpath="$dir" ;;
2159                 esac
2160                 add_dir="-L$dir"
2161                 add="-l$name"
2162               elif test "$hardcode_shlibpath_var" = no; then
2163                 add_shlibpath="$dir"
2164                 add="-l$name"
2165               else
2166                 lib_linked=no
2167               fi
2168               ;;
2169             relink)
2170               if test "$hardcode_direct" = yes; then
2171                 add="$dir/$linklib"
2172               elif test "$hardcode_minus_L" = yes; then
2173                 add_dir="-L$dir"
2174                 add="-l$name"
2175               elif test "$hardcode_shlibpath_var" = yes; then
2176                 add_shlibpath="$dir"
2177                 add="-l$name"
2178               else
2179                 lib_linked=no
2180               fi
2181               ;;
2182             *) lib_linked=no ;;
2183             esac
2184
2185             if test "$lib_linked" != yes; then
2186               $echo "$modename: configuration error: unsupported hardcode properties"
2187               exit 1
2188             fi
2189
2190             if test -n "$add_shlibpath"; then
2191               case :$compile_shlibpath: in
2192               *":$add_shlibpath:"*) ;;
2193               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2194               esac
2195             fi
2196             if test $linkmode = prog; then
2197               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2198               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2199             else
2200               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2201               test -n "$add" && deplibs="$add $deplibs"
2202               if test "$hardcode_direct" != yes && \
2203                  test "$hardcode_minus_L" != yes && \
2204                  test "$hardcode_shlibpath_var" = yes; then
2205                 case :$finalize_shlibpath: in
2206                 *":$libdir:"*) ;;
2207                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2208                 esac
2209               fi
2210             fi
2211           fi
2212
2213           if test $linkmode = prog || test "$mode" = relink; then
2214             add_shlibpath=
2215             add_dir=
2216             add=
2217             # Finalize command for both is simple: just hardcode it.
2218             if test "$hardcode_direct" = yes; then
2219               add="$libdir/$linklib"
2220             elif test "$hardcode_minus_L" = yes; then
2221               add_dir="-L$libdir"
2222               add="-l$name"
2223             elif test "$hardcode_shlibpath_var" = yes; then
2224               case :$finalize_shlibpath: in
2225               *":$libdir:"*) ;;
2226               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2227               esac
2228               add="-l$name"
2229             else
2230               # We cannot seem to hardcode it, guess we'll fake it.
2231               add_dir="-L$libdir"
2232               add="-l$name"
2233             fi
2234
2235             if test $linkmode = prog; then
2236               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2237               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2238             else
2239               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2240               test -n "$add" && deplibs="$add $deplibs"
2241             fi
2242           fi
2243         elif test $linkmode = prog; then
2244           if test "$alldeplibs" = yes &&
2245              { test "$deplibs_check_method" = pass_all ||
2246                { test "$build_libtool_libs" = yes &&
2247                  test -n "$library_names"; }; }; then
2248             # We only need to search for static libraries
2249             continue
2250           fi
2251
2252           # Try to link the static library
2253           # Here we assume that one of hardcode_direct or hardcode_minus_L
2254           # is not unsupported.  This is valid on all known static and
2255           # shared platforms.
2256           if test "$hardcode_direct" != unsupported; then
2257             test -n "$old_library" && linklib="$old_library"
2258             compile_deplibs="$dir/$linklib $compile_deplibs"
2259             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2260           else
2261             compile_deplibs="-l$name -L$dir $compile_deplibs"
2262             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2263           fi
2264         elif test "$build_libtool_libs" = yes; then
2265           # Not a shared library
2266           if test "$deplibs_check_method" != pass_all; then
2267             # We're trying link a shared library against a static one
2268             # but the system doesn't support it.
2269
2270             # Just print a warning and add the library to dependency_libs so
2271             # that the program can be linked against the static library.
2272             echo
2273             echo "*** Warning: This library needs some functionality provided by $lib."
2274             echo "*** I have the capability to make that library automatically link in when"
2275             echo "*** you link to this library.  But I can only do this if you have a"
2276             echo "*** shared version of the library, which you do not appear to have."
2277             if test "$module" = yes; then
2278               echo "*** Therefore, libtool will create a static module, that should work "
2279               echo "*** as long as the dlopening application is linked with the -dlopen flag."
2280               if test -z "$global_symbol_pipe"; then
2281                 echo
2282                 echo "*** However, this would only work if libtool was able to extract symbol"
2283                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2284                 echo "*** not find such a program.  So, this module is probably useless."
2285                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
2286               fi
2287               if test "$build_old_libs" = no; then
2288                 build_libtool_libs=module
2289                 build_old_libs=yes
2290               else
2291                 build_libtool_libs=no
2292               fi
2293             fi
2294           else
2295             convenience="$convenience $dir/$old_library"
2296             old_convenience="$old_convenience $dir/$old_library"
2297             deplibs="$dir/$old_library $deplibs"
2298             link_static=yes
2299           fi
2300         fi # link shared/static library?
2301
2302         if test $linkmode = lib; then
2303           if test -n "$dependency_libs" &&
2304              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2305                test $link_static = yes; }; then
2306             # Extract -R from dependency_libs
2307             temp_deplibs=
2308             for libdir in $dependency_libs; do
2309               case $libdir in
2310               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2311                    case " $xrpath " in
2312                    *" $temp_xrpath "*) ;;
2313                    *) xrpath="$xrpath $temp_xrpath";;
2314                    esac;;
2315               *) temp_deplibs="$temp_deplibs $libdir";;
2316               esac
2317             done
2318             dependency_libs="$temp_deplibs"
2319           fi
2320
2321           newlib_search_path="$newlib_search_path $absdir"
2322           # Link against this library
2323           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2324           # ... and its dependency_libs
2325           tmp_libs=
2326           for deplib in $dependency_libs; do
2327             newdependency_libs="$deplib $newdependency_libs"
2328             case "$tmp_libs " in
2329             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2330             esac
2331             tmp_libs="$tmp_libs $deplib"
2332           done
2333
2334           if test $link_all_deplibs != no; then
2335             # Add the search paths of all dependency libraries
2336             for deplib in $dependency_libs; do
2337               case $deplib in
2338               -L*) path="$deplib" ;;
2339               *.la)
2340                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2341                 test "X$dir" = "X$deplib" && dir="."
2342                 # We need an absolute path.
2343                 case $dir in
2344                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2345                 *)
2346                   absdir=`cd "$dir" && pwd`
2347                   if test -z "$absdir"; then
2348                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2349                     absdir="$dir"
2350                   fi
2351                   ;;
2352                 esac
2353                 if grep "^installed=no" $deplib > /dev/null; then
2354                   path="-L$absdir/$objdir"
2355                 else
2356                   eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2357                   if test -z "$libdir"; then
2358                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2359                     exit 1
2360                   fi
2361                   if test "$absdir" != "$libdir"; then
2362                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2363                   fi
2364                   path="-L$absdir"
2365                 fi
2366                 ;;
2367               *) continue ;;
2368               esac
2369               case " $deplibs " in
2370               *" $path "*) ;;
2371               *) deplibs="$path $deplibs" ;;
2372               esac
2373             done
2374           fi # link_all_deplibs != no
2375         fi # linkmode = lib
2376       done # for deplib in $libs
2377       if test $pass = dlpreopen; then
2378         # Link the dlpreopened libraries before other libraries
2379         for deplib in $save_deplibs; do
2380           deplibs="$deplib $deplibs"
2381         done
2382       fi
2383       if test $pass != dlopen; then
2384         test $pass != scan && dependency_libs="$newdependency_libs"
2385         if test $pass != conv; then
2386           # Make sure lib_search_path contains only unique directories.
2387           lib_search_path=
2388           for dir in $newlib_search_path; do
2389             case "$lib_search_path " in
2390             *" $dir "*) ;;
2391             *) lib_search_path="$lib_search_path $dir" ;;
2392             esac
2393           done
2394           newlib_search_path=
2395         fi
2396
2397         if test "$linkmode,$pass" != "prog,link"; then
2398           vars="deplibs"
2399         else
2400           vars="compile_deplibs finalize_deplibs"
2401         fi
2402         for var in $vars dependency_libs; do
2403           # Add libraries to $var in reverse order
2404           eval tmp_libs=\"\$$var\"
2405           new_libs=
2406           for deplib in $tmp_libs; do
2407             case $deplib in
2408             -L*) new_libs="$deplib $new_libs" ;;
2409             *)
2410               case " $specialdeplibs " in
2411               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2412               *)
2413                 case " $new_libs " in
2414                 *" $deplib "*) ;;
2415                 *) new_libs="$deplib $new_libs" ;;
2416                 esac
2417                 ;;
2418               esac
2419               ;;
2420             esac
2421           done
2422           tmp_libs=
2423           for deplib in $new_libs; do
2424             case $deplib in
2425             -L*)
2426               case " $tmp_libs " in
2427               *" $deplib "*) ;;
2428               *) tmp_libs="$tmp_libs $deplib" ;;
2429               esac
2430               ;;
2431             *) tmp_libs="$tmp_libs $deplib" ;;
2432             esac
2433           done
2434           eval $var=\"$tmp_libs\"
2435         done # for var
2436       fi
2437       if test "$pass" = "conv" &&
2438        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2439         libs="$deplibs" # reset libs
2440         deplibs=
2441       fi
2442     done # for pass
2443     if test $linkmode = prog; then
2444       dlfiles="$newdlfiles"
2445       dlprefiles="$newdlprefiles"
2446     fi
2447
2448     case $linkmode in
2449     oldlib)
2450       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2451         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2452       fi
2453
2454       if test -n "$rpath"; then
2455         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2456       fi
2457
2458       if test -n "$xrpath"; then
2459         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2460       fi
2461
2462       if test -n "$vinfo"; then
2463         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2464       fi
2465
2466       if test -n "$release"; then
2467         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2468       fi
2469
2470       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2471         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2472       fi
2473
2474       # Now set the variables for building old libraries.
2475       build_libtool_libs=no
2476       oldlibs="$output"
2477       objs="$objs$old_deplibs"
2478       ;;
2479
2480     lib)
2481       # Make sure we only generate libraries of the form `libNAME.la'.
2482       case $outputname in
2483       lib*)
2484         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2485         eval shared_ext=\"$shrext\"
2486         eval libname=\"$libname_spec\"
2487         ;;
2488       *)
2489         if test "$module" = no; then
2490           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2491           $echo "$help" 1>&2
2492           exit 1
2493         fi
2494         if test "$need_lib_prefix" != no; then
2495           # Add the "lib" prefix for modules if required
2496           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2497           eval shared_ext=\"$shrext\"
2498           eval libname=\"$libname_spec\"
2499         else
2500           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2501         fi
2502         ;;
2503       esac
2504
2505       if test -n "$objs"; then
2506         if test "$deplibs_check_method" != pass_all; then
2507           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2508           exit 1
2509         else
2510           echo
2511           echo "*** Warning: Linking the shared library $output against the non-libtool"
2512           echo "*** objects $objs is not portable!"
2513           libobjs="$libobjs $objs"
2514         fi
2515       fi
2516
2517       if test "$dlself" != no; then
2518         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2519       fi
2520
2521       set dummy $rpath
2522       if test $# -gt 2; then
2523         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2524       fi
2525       install_libdir="$2"
2526
2527       oldlibs=
2528       if test -z "$rpath"; then
2529         if test "$build_libtool_libs" = yes; then
2530           # Building a libtool convenience library.
2531           # Some compilers have problems with a `.al' extension so
2532           # convenience libraries should have the same extension an
2533           # archive normally would.
2534           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2535           build_libtool_libs=convenience
2536           build_old_libs=yes
2537         fi
2538
2539         if test -n "$vinfo"; then
2540           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2541         fi
2542
2543         if test -n "$release"; then
2544           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2545         fi
2546       else
2547
2548         # Parse the version information argument.
2549         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2550         set dummy $vinfo 0 0 0
2551         IFS="$save_ifs"
2552
2553         if test -n "$8"; then
2554           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2555           $echo "$help" 1>&2
2556           exit 1
2557         fi
2558
2559         current="$2"
2560         revision="$3"
2561         age="$4"
2562
2563         # Check that each of the things are valid numbers.
2564         case $current in
2565         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2566         *)
2567           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2568           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2569           exit 1
2570           ;;
2571         esac
2572
2573         case $revision in
2574         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2575         *)
2576           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2577           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2578           exit 1
2579           ;;
2580         esac
2581
2582         case $age in
2583         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2584         *)
2585           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2586           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2587           exit 1
2588           ;;
2589         esac
2590
2591         if test $age -gt $current; then
2592           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2593           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2594           exit 1
2595         fi
2596
2597         # Calculate the version variables.
2598         major=
2599         versuffix=
2600         verstring=
2601         case $version_type in
2602         none) ;;
2603
2604         darwin)
2605           # Like Linux, but with the current version available in
2606           # verstring for coding it into the library header
2607           major=.`expr $current - $age`
2608           versuffix="$major.$age.$revision"
2609           # Darwin ld doesn't like 0 for these options...
2610           minor_current=`expr $current + 1`
2611           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2612           ;;
2613
2614         freebsd-aout)
2615           major=".$current"
2616           versuffix=".$current.$revision";
2617           ;;
2618
2619         freebsd-elf)
2620           major=".$current"
2621           versuffix=".$current";
2622           ;;
2623
2624         irix)
2625           major=`expr $current - $age + 1`
2626           verstring="sgi$major.$revision"
2627
2628           # Add in all the interfaces that we are compatible with.
2629           loop=$revision
2630           while test $loop != 0; do
2631             iface=`expr $revision - $loop`
2632             loop=`expr $loop - 1`
2633             verstring="sgi$major.$iface:$verstring"
2634           done
2635
2636           # Before this point, $major must not contain `.'.
2637           major=.$major
2638           versuffix="$major.$revision"
2639           ;;
2640
2641         linux)
2642           major=.`expr $current - $age`
2643           versuffix="$major.$age.$revision"
2644           ;;
2645
2646         osf)
2647           major=.`expr $current - $age`
2648           versuffix=".$current.$age.$revision"
2649           verstring="$current.$age.$revision"
2650
2651           # Add in all the interfaces that we are compatible with.
2652           loop=$age
2653           while test $loop != 0; do
2654             iface=`expr $current - $loop`
2655             loop=`expr $loop - 1`
2656             verstring="$verstring:${iface}.0"
2657           done
2658
2659           # Make executables depend on our current version.
2660           verstring="$verstring:${current}.0"
2661           ;;
2662
2663         sunos)
2664           major=".$current"
2665           versuffix=".$current.$revision"
2666           ;;
2667
2668         windows)
2669           # Use '-' rather than '.', since we only want one
2670           # extension on DOS 8.3 filesystems.
2671           major=`expr $current - $age`
2672           versuffix="-$major"
2673           ;;
2674
2675         *)
2676           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2677           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2678           exit 1
2679           ;;
2680         esac
2681
2682         # Clear the version info if we defaulted, and they specified a release.
2683         if test -z "$vinfo" && test -n "$release"; then
2684           major=
2685           case $version_type in
2686           darwin)
2687             # we can't check for "0.0" in archive_cmds due to quoting
2688             # problems, so we reset it completely
2689             verstring=
2690             ;;
2691           *)
2692             verstring="0.0"
2693             ;;
2694           esac
2695           if test "$need_version" = no; then
2696             versuffix=
2697           else
2698             versuffix=".0.0"
2699           fi
2700         fi
2701
2702         # Remove version info from name if versioning should be avoided
2703         if test "$avoid_version" = yes && test "$need_version" = no; then
2704           major=
2705           versuffix=
2706           verstring=""
2707         fi
2708
2709         # Check to see if the archive will have undefined symbols.
2710         if test "$allow_undefined" = yes; then
2711           if test "$allow_undefined_flag" = unsupported; then
2712             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2713             build_libtool_libs=no
2714             build_old_libs=yes
2715           fi
2716         else
2717           # Don't allow undefined symbols.
2718           allow_undefined_flag="$no_undefined_flag"
2719         fi
2720       fi
2721
2722       if test "$mode" != relink; then
2723         # Remove our outputs, but don't remove object files since they
2724         # may have been created when compiling PIC objects.
2725         removelist=
2726         tempremovelist=`echo "$output_objdir/*"`
2727         for p in $tempremovelist; do
2728           case $p in
2729             *.$objext)
2730                ;;
2731             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2732                removelist="$removelist $p"
2733                ;;
2734             *) ;;
2735           esac
2736         done
2737         if test -n "$removelist"; then
2738           $show "${rm}r $removelist"
2739           $run ${rm}r $removelist
2740         fi
2741       fi
2742
2743       # Now set the variables for building old libraries.
2744       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2745         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2746
2747         # Transform .lo files to .o files.
2748         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2749       fi
2750
2751       # Eliminate all temporary directories.
2752       for path in $notinst_path; do
2753         lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2754         deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2755         dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2756       done
2757
2758       if test -n "$xrpath"; then
2759         # If the user specified any rpath flags, then add them.
2760         temp_xrpath=
2761         for libdir in $xrpath; do
2762           temp_xrpath="$temp_xrpath -R$libdir"
2763           case "$finalize_rpath " in
2764           *" $libdir "*) ;;
2765           *) finalize_rpath="$finalize_rpath $libdir" ;;
2766           esac
2767         done
2768         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2769           dependency_libs="$temp_xrpath $dependency_libs"
2770         fi
2771       fi
2772
2773       # Make sure dlfiles contains only unique files that won't be dlpreopened
2774       old_dlfiles="$dlfiles"
2775       dlfiles=
2776       for lib in $old_dlfiles; do
2777         case " $dlprefiles $dlfiles " in
2778         *" $lib "*) ;;
2779         *) dlfiles="$dlfiles $lib" ;;
2780         esac
2781       done
2782
2783       # Make sure dlprefiles contains only unique files
2784       old_dlprefiles="$dlprefiles"
2785       dlprefiles=
2786       for lib in $old_dlprefiles; do
2787         case "$dlprefiles " in
2788         *" $lib "*) ;;
2789         *) dlprefiles="$dlprefiles $lib" ;;
2790         esac
2791       done
2792
2793       if test "$build_libtool_libs" = yes; then
2794         if test -n "$rpath"; then
2795           case $host in
2796           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2797             # these systems don't actually have a c library (as such)!
2798             ;;
2799           *-*-rhapsody* | *-*-darwin1.[012])
2800             # Rhapsody C library is in the System framework
2801             deplibs="$deplibs -framework System"
2802             ;;
2803           *-*-netbsd*)
2804             # Don't link with libc until the a.out ld.so is fixed.
2805             ;;
2806           *)
2807             # Add libc to deplibs on all other systems if necessary.
2808             if test $build_libtool_need_lc = "yes"; then
2809               deplibs="$deplibs -lc"
2810             fi
2811             ;;
2812           esac
2813         fi
2814
2815         # Transform deplibs into only deplibs that can be linked in shared.
2816         name_save=$name
2817         libname_save=$libname
2818         release_save=$release
2819         versuffix_save=$versuffix
2820         major_save=$major
2821         # I'm not sure if I'm treating the release correctly.  I think
2822         # release should show up in the -l (ie -lgmp5) so we don't want to
2823         # add it in twice.  Is that correct?
2824         release=""
2825         versuffix=""
2826         major=""
2827         newdeplibs=
2828         droppeddeps=no
2829         case $deplibs_check_method in
2830         pass_all)
2831           # Don't check for shared/static.  Everything works.
2832           # This might be a little naive.  We might want to check
2833           # whether the library exists or not.  But this is on
2834           # osf3 & osf4 and I'm not really sure... Just
2835           # implementing what was already the behaviour.
2836           newdeplibs=$deplibs
2837           ;;
2838         test_compile)
2839           # This code stresses the "libraries are programs" paradigm to its
2840           # limits. Maybe even breaks it.  We compile a program, linking it
2841           # against the deplibs as a proxy for the library.  Then we can check
2842           # whether they linked in statically or dynamically with ldd.
2843           $rm conftest.c
2844           cat > conftest.c <<EOF
2845           int main() { return 0; }
2846 EOF
2847           $rm conftest
2848           $LTCC -o conftest conftest.c $deplibs
2849           if test $? -eq 0 ; then
2850             ldd_output=`ldd conftest`
2851             for i in $deplibs; do
2852               name="`expr $i : '-l\(.*\)'`"
2853               # If $name is empty we are operating on a -L argument.
2854               if test -n "$name" && test "$name" != "0"; then
2855                 libname=`eval \\$echo \"$libname_spec\"`
2856                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2857                 set dummy $deplib_matches
2858                 deplib_match=$2
2859                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2860                   newdeplibs="$newdeplibs $i"
2861                 else
2862                   droppeddeps=yes
2863                   echo
2864                   echo "*** Warning: This library needs some functionality provided by $i."
2865                   echo "*** I have the capability to make that library automatically link in when"
2866                   echo "*** you link to this library.  But I can only do this if you have a"
2867                   echo "*** shared version of the library, which you do not appear to have."
2868                 fi
2869               else
2870                 newdeplibs="$newdeplibs $i"
2871               fi
2872             done
2873           else
2874             # Error occured in the first compile.  Let's try to salvage the situation:
2875             # Compile a seperate program for each library.
2876             for i in $deplibs; do
2877               name="`expr $i : '-l\(.*\)'`"
2878              # If $name is empty we are operating on a -L argument.
2879               if test -n "$name" && test "$name" != "0"; then
2880                 $rm conftest
2881                 $LTCC -o conftest conftest.c $i
2882                 # Did it work?
2883                 if test $? -eq 0 ; then
2884                   ldd_output=`ldd conftest`
2885                   libname=`eval \\$echo \"$libname_spec\"`
2886                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2887                   set dummy $deplib_matches
2888                   deplib_match=$2
2889                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2890                     newdeplibs="$newdeplibs $i"
2891                   else
2892                     droppeddeps=yes
2893                     echo
2894                     echo "*** Warning: This library needs some functionality provided by $i."
2895                     echo "*** I have the capability to make that library automatically link in when"
2896                     echo "*** you link to this library.  But I can only do this if you have a"
2897                     echo "*** shared version of the library, which you do not appear to have."
2898                   fi
2899                 else
2900                   droppeddeps=yes
2901                   echo
2902                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2903                   echo "***  make it link in!  You will probably need to install it or some"
2904                   echo "*** library that it depends on before this library will be fully"
2905                   echo "*** functional.  Installing it before continuing would be even better."
2906                 fi
2907               else
2908                 newdeplibs="$newdeplibs $i"
2909               fi
2910             done
2911           fi
2912           ;;
2913         file_magic*)
2914           set dummy $deplibs_check_method
2915           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2916           for a_deplib in $deplibs; do
2917             name="`expr $a_deplib : '-l\(.*\)'`"
2918             # If $name is empty we are operating on a -L argument.
2919             if test -n "$name" && test "$name" != "0"; then
2920               libname=`eval \\$echo \"$libname_spec\"`
2921               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2922                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2923                     for potent_lib in $potential_libs; do
2924                       # Follow soft links.
2925                       if ls -lLd "$potent_lib" 2>/dev/null \
2926                          | grep " -> " >/dev/null; then
2927                         continue
2928                       fi
2929                       # The statement above tries to avoid entering an
2930                       # endless loop below, in case of cyclic links.
2931                       # We might still enter an endless loop, since a link
2932                       # loop can be closed while we follow links,
2933                       # but so what?
2934                       potlib="$potent_lib"
2935                       while test -h "$potlib" 2>/dev/null; do
2936                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2937                         case $potliblink in
2938                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2939                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2940                         esac
2941                       done
2942                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2943                          | sed 10q \
2944                          | egrep "$file_magic_regex" > /dev/null; then
2945                         newdeplibs="$newdeplibs $a_deplib"
2946                         a_deplib=""
2947                         break 2
2948                       fi
2949                     done
2950               done
2951               if test -n "$a_deplib" ; then
2952                 droppeddeps=yes
2953                 echo
2954                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2955                 echo "*** I have the capability to make that library automatically link in when"
2956                 echo "*** you link to this library.  But I can only do this if you have a"
2957                 echo "*** shared version of the library, which you do not appear to have."
2958               fi
2959             else
2960               # Add a -L argument.
2961               newdeplibs="$newdeplibs $a_deplib"
2962             fi
2963           done # Gone through all deplibs.
2964           ;;
2965         match_pattern*)
2966           set dummy $deplibs_check_method
2967           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2968           for a_deplib in $deplibs; do
2969             name="`expr $a_deplib : '-l\(.*\)'`"
2970             # If $name is empty we are operating on a -L argument.
2971             if test -n "$name" && test "$name" != "0"; then
2972               libname=`eval \\$echo \"$libname_spec\"`
2973               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2974                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2975                 for potent_lib in $potential_libs; do
2976                   if eval echo \"$potent_lib\" 2>/dev/null \
2977                       | sed 10q \
2978                       | egrep "$match_pattern_regex" > /dev/null; then
2979                     newdeplibs="$newdeplibs $a_deplib"
2980                     a_deplib=""
2981                     break 2
2982                   fi
2983                 done
2984               done
2985               if test -n "$a_deplib" ; then
2986                 droppeddeps=yes
2987                 echo
2988                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2989                 echo "*** I have the capability to make that library automatically link in when"
2990                 echo "*** you link to this library.  But I can only do this if you have a"
2991                 echo "*** shared version of the library, which you do not appear to have."
2992               fi
2993             else
2994               # Add a -L argument.
2995               newdeplibs="$newdeplibs $a_deplib"
2996             fi
2997           done # Gone through all deplibs.
2998           ;;
2999         none | unknown | *)
3000           newdeplibs=""
3001           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3002                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
3003              grep . >/dev/null; then
3004             echo
3005             if test "X$deplibs_check_method" = "Xnone"; then
3006               echo "*** Warning: inter-library dependencies are not supported in this platform."
3007             else
3008               echo "*** Warning: inter-library dependencies are not known to be supported."
3009             fi
3010             echo "*** All declared inter-library dependencies are being dropped."
3011             droppeddeps=yes
3012           fi
3013           ;;
3014         esac
3015         versuffix=$versuffix_save
3016         major=$major_save
3017         release=$release_save
3018         libname=$libname_save
3019         name=$name_save
3020
3021         case $host in
3022         *-*-rhapsody* | *-*-darwin1.[012])
3023           # On Rhapsody replace the C library is the System framework
3024           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3025           ;;
3026         esac
3027
3028         if test "$droppeddeps" = yes; then
3029           if test "$module" = yes; then
3030             echo
3031             echo "*** Warning: libtool could not satisfy all declared inter-library"
3032             echo "*** dependencies of module $libname.  Therefore, libtool will create"
3033             echo "*** a static module, that should work as long as the dlopening"
3034             echo "*** application is linked with the -dlopen flag."
3035             if test -z "$global_symbol_pipe"; then
3036               echo
3037               echo "*** However, this would only work if libtool was able to extract symbol"
3038               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3039               echo "*** not find such a program.  So, this module is probably useless."
3040               echo "*** \`nm' from GNU binutils and a full rebuild may help."
3041             fi
3042             if test "$build_old_libs" = no; then
3043               oldlibs="$output_objdir/$libname.$libext"
3044               build_libtool_libs=module
3045               build_old_libs=yes
3046             else
3047               build_libtool_libs=no
3048             fi
3049           else
3050             echo "*** The inter-library dependencies that have been dropped here will be"
3051             echo "*** automatically added whenever a program is linked with this library"
3052             echo "*** or is declared to -dlopen it."
3053
3054             if test $allow_undefined = no; then
3055               echo
3056               echo "*** Since this library must not contain undefined symbols,"
3057               echo "*** because either the platform does not support them or"
3058               echo "*** it was explicitly requested with -no-undefined,"
3059               echo "*** libtool will only create a static version of it."
3060               if test "$build_old_libs" = no; then
3061                 oldlibs="$output_objdir/$libname.$libext"
3062                 build_libtool_libs=module
3063                 build_old_libs=yes
3064               else
3065                 build_libtool_libs=no
3066               fi
3067             fi
3068           fi
3069         fi
3070         # Time to change all our "foo.framework" stuff back to "-framework foo"
3071         case $host in
3072             *-*-darwin*)
3073                 newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3074                 dependency_libs=`$echo "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3075                 ;;
3076         esac
3077         # Done checking deplibs!
3078         # Done checking deplibs!
3079         deplibs=$newdeplibs
3080       fi
3081
3082       # All the library-specific variables (install_libdir is set above).
3083       library_names=
3084       old_library=
3085       dlname=
3086
3087       # Test again, we may have decided not to build it any more
3088       if test "$build_libtool_libs" = yes; then
3089         if test $hardcode_into_libs = yes; then
3090           # Hardcode the library paths
3091           hardcode_libdirs=
3092           dep_rpath=
3093           rpath="$finalize_rpath"
3094           test "$mode" != relink && rpath="$compile_rpath$rpath"
3095           for libdir in $rpath; do
3096             if test -n "$hardcode_libdir_flag_spec"; then
3097               if test -n "$hardcode_libdir_separator"; then
3098                 if test -z "$hardcode_libdirs"; then
3099                   hardcode_libdirs="$libdir"
3100                 else
3101                   # Just accumulate the unique libdirs.
3102                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3103                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3104                     ;;
3105                   *)
3106                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3107                     ;;
3108                   esac
3109                 fi
3110               else
3111                 eval flag=\"$hardcode_libdir_flag_spec\"
3112                 dep_rpath="$dep_rpath $flag"
3113               fi
3114             elif test -n "$runpath_var"; then
3115               case "$perm_rpath " in
3116               *" $libdir "*) ;;
3117               *) perm_rpath="$perm_rpath $libdir" ;;
3118               esac
3119             fi
3120           done
3121           # Substitute the hardcoded libdirs into the rpath.
3122           if test -n "$hardcode_libdir_separator" &&
3123              test -n "$hardcode_libdirs"; then
3124             libdir="$hardcode_libdirs"
3125             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3126           fi
3127           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3128             # We should set the runpath_var.
3129             rpath=
3130             for dir in $perm_rpath; do
3131               rpath="$rpath$dir:"
3132             done
3133             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3134           fi
3135           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3136         fi
3137
3138         shlibpath="$finalize_shlibpath"
3139         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3140         if test -n "$shlibpath"; then
3141           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3142         fi
3143
3144         # Get the real and link names of the library.
3145         eval library_names=\"$library_names_spec\"
3146         eval shared_ext=\"$shrext\"
3147         set dummy $library_names
3148         realname="$2"
3149         shift; shift
3150
3151         if test -n "$soname_spec"; then
3152           eval soname=\"$soname_spec\"
3153         else
3154           soname="$realname"
3155         fi
3156         test -z "$dlname" && dlname=$soname
3157
3158         lib="$output_objdir/$realname"
3159         for link
3160         do
3161           linknames="$linknames $link"
3162         done
3163
3164 #       # Ensure that we have .o objects for linkers which dislike .lo
3165 #       # (e.g. aix) in case we are running --disable-static
3166 #       for obj in $libobjs; do
3167 #         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3168 #         if test "X$xdir" = "X$obj"; then
3169 #           xdir="."
3170 #         else
3171 #           xdir="$xdir"
3172 #         fi
3173 #         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3174 #         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3175 #         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3176 #           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3177 #           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3178 #         fi
3179 #       done
3180
3181         # Use standard objects if they are pic
3182         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3183
3184         # Prepare the list of exported symbols
3185         if test -z "$export_symbols"; then
3186           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3187             $show "generating symbol list for \`$libname.la'"
3188             export_symbols="$output_objdir/$libname.exp"
3189             $run $rm $export_symbols
3190             eval cmds=\"$export_symbols_cmds\"
3191             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3192             for cmd in $cmds; do
3193               IFS="$save_ifs"
3194               $show "$cmd"
3195               $run eval "$cmd" || exit $?
3196             done
3197             IFS="$save_ifs"
3198             if test -n "$export_symbols_regex"; then
3199               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3200               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3201               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3202               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3203             fi
3204           fi
3205         fi
3206
3207         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3208           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3209         fi
3210
3211         if test -n "$convenience"; then
3212           if test -n "$whole_archive_flag_spec"; then
3213             save_libobjs=$libobjs
3214             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3215           else
3216             gentop="$output_objdir/${outputname}x"
3217             $show "${rm}r $gentop"
3218             $run ${rm}r "$gentop"
3219             $show "$mkdir $gentop"
3220             $run $mkdir "$gentop"
3221             status=$?
3222             if test $status -ne 0 && test ! -d "$gentop"; then
3223               exit $status
3224             fi
3225             generated="$generated $gentop"
3226
3227             for xlib in $convenience; do
3228               # Extract the objects.
3229               case $xlib in
3230               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3231               *) xabs=`pwd`"/$xlib" ;;
3232               esac
3233               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3234               xdir="$gentop/$xlib"
3235
3236               $show "${rm}r $xdir"
3237               $run ${rm}r "$xdir"
3238               $show "$mkdir $xdir"
3239               $run $mkdir "$xdir"
3240               status=$?
3241               if test $status -ne 0 && test ! -d "$xdir"; then
3242                 exit $status
3243               fi
3244               $show "(cd $xdir && $AR x $xabs)"
3245               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3246
3247               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3248             done
3249           fi
3250         fi
3251
3252         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3253           eval flag=\"$thread_safe_flag_spec\"
3254           linker_flags="$linker_flags $flag"
3255         fi
3256
3257         # Make a backup of the uninstalled library when relinking
3258         if test "$mode" = relink; then
3259           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3260         fi
3261
3262         # Do each of the archive commands.
3263         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3264           eval test_cmds=\"$archive_expsym_cmds\"
3265           cmds=$archive_expsym_cmds
3266         else
3267           eval test_cmds=\"$archive_cmds\"
3268           cmds=$archive_cmds
3269         fi
3270         if len=`expr "X$test_cmds" : ".*"` &&
3271            test $len -le $max_cmd_len; then
3272           :
3273         else
3274           # The command line is too long to link in one step, link piecewise.
3275
3276           # Save the value of $output and $libobjs because we want to
3277           # use them later.  If we have whole_archive_flag_spec, we
3278           # want to use save_libobjs as it was before
3279           # whole_archive_flag_spec was expanded, because we can't
3280           # assume the linker understands whole_archive_flag_spec.
3281           # This may have to be revisited, in case too many
3282           # convenience libraries get linked in and end up exceeding
3283           # the spec.
3284           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3285             save_libobjs=$libobjs
3286           fi
3287           save_output=$output
3288           output_la=`$echo "X$output" | $Xsed -e "s,^.*/,,"`
3289
3290           # Clear the reloadable object creation command queue and
3291           # initialize k to one.
3292           test_cmds=
3293           concat_cmds=
3294           objlist=
3295           delfiles=
3296           last_robj=
3297           k=1
3298
3299           if test "$with_gnu_ld" = yes; then
3300             output=${output_objdir}/${output_la}.lnkscript
3301             $echo "creating GNU ld script: $output"
3302             $echo 'INPUT (' > $output
3303             for obj in $save_libobjs
3304             do
3305               $echo \""$obj"\" >> $output
3306             done
3307             $echo ')' >> $output
3308             delfiles="$delfiles $output"
3309           elif test "X$file_list_spec" != X; then
3310             output=${output_objdir}/${output_la}.lnk
3311             $echo "creating linker input file list: $output"
3312             : > $output
3313             for obj in $save_libobjs
3314             do
3315               $echo "$obj" >> $output
3316             done
3317             delfiles="$delfiles $output"
3318             output=\"$file_list_spec$output\"
3319           else
3320             $echo "creating reloadable object files..."
3321             output=$output_objdir/$save_output-${k}.$objext
3322             # Loop over the list of objects to be linked.
3323             for obj in $save_libobjs
3324             do
3325               eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3326               if test "X$objlist" = X ||
3327                  { len=`expr "X$test_cmds" : ".*"` &&
3328                    test $len -le $max_cmd_len; }; then
3329                 objlist="$objlist $obj"
3330               else
3331                 # The command $test_cmds is almost too long, add a
3332                 # command to the queue.
3333                 if test $k -eq 1 ; then
3334                   # The first file doesn't have a previous command to add.
3335                   eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3336                 else
3337                   # All subsequent reloadable object files will link in
3338                   # the last one created.
3339                   eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3340                 fi
3341                 last_robj=$output_objdir/$save_output-${k}.$objext
3342                 k=`expr $k + 1`
3343                 output=$output_objdir/$save_output-${k}.$objext
3344                 objlist=$obj
3345                 len=1
3346               fi
3347             done
3348             # Handle the remaining objects by creating one last
3349             # reloadable object file.  All subsequent reloadable object
3350             # files will link in the last one created.
3351             test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3352             eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3353
3354             # Set up a command to remove the reloadale object files
3355             # after they are used.
3356             i=0
3357             while test $i -lt $k
3358             do
3359               i=`expr $i + 1`
3360               delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3361             done
3362
3363             $echo "creating a temporary reloadable object file: $output"
3364
3365             # Loop through the commands generated above and execute them.
3366             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3367             for cmd in $concat_cmds; do
3368               IFS="$save_ifs"
3369               eval cmd=\"$cmd\"
3370               $show "$cmd"
3371               $run eval "$cmd" || exit $?
3372             done
3373             IFS="$save_ifs"
3374           fi
3375
3376           libobjs=$output
3377           # Restore the value of output.
3378           output=$save_output
3379
3380           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3381             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3382           fi
3383           # Expand the library linking commands again to reset the
3384           # value of $libobjs for piecewise linking.
3385
3386           # Do each of the archive commands.
3387           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3388             cmds=$archive_expsym_cmds
3389           else
3390             cmds=$archive_cmds
3391           fi
3392
3393           # Append the command to remove the reloadable object files
3394           # to the just-reset $cmds.
3395           eval cmds=\"\$cmds~$rm $delfiles\"
3396         fi
3397         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3398         for cmd in $cmds; do
3399           IFS="$save_ifs"
3400           eval cmd=\"$cmd\"
3401           $show "$cmd"