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