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