improve behaviour on SunOS
[external/binutils.git] / ltmain.sh
1 # ltmain.sh - Provide generalized library-building support services.
2 # NOTE: Changing this file will not affect anything until you rerun ltconfig.
3 #
4 # Copyright (C) 1996-1998 Free Software Foundation, Inc.
5 # Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
6 #
7 # This program is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 2 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful, but
13 # WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 # General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with this program; if not, write to the Free Software
19 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 #
21 # As a special exception to the GNU General Public License, if you
22 # distribute this file as part of a program that contains a
23 # configuration script generated by Autoconf, you may include it under
24 # the same distribution terms that you use for the rest of that program.
25
26 # Check that we have a working $echo.
27 if test "X$1" = X--no-reexec; then
28   # Discard the --no-reexec flag, and continue.
29   shift
30 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
31   # Yippee, $echo works!
32   :
33 else
34   # Restart under the correct shell, and then maybe $echo will work.
35   exec $SHELL "$0" --no-reexec ${1+"$@"}
36 fi
37
38 # The name of this program.
39 progname=`$echo "$0" | sed 's%^.*/%%'`
40 modename="$progname"
41
42 # Constants.
43 PROGRAM=ltmain.sh
44 PACKAGE=libtool
45 VERSION=1.2b
46
47 default_mode=
48 help="Try \`$progname --help' for more information."
49 magic="%%%MAGIC variable%%%"
50 mkdir="mkdir"
51 mv="mv -f"
52 rm="rm -f"
53
54 # Sed substitution that helps us do robust quoting.  It backslashifies
55 # metacharacters that are still active within double-quoted strings.
56 Xsed='sed -e s/^X//'
57 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
58
59 # NLS nuisances.
60 # Only set LANG and LC_ALL to C if already set.
61 # These must not be set unconditionally because not all systems understand
62 # e.g. LANG=C (notably SCO).
63 # We save the old values to restore during execute mode.
64 if test "${LC_ALL+set}" = set; then
65   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
66 fi
67 if test "${LANG+set}" = set; then
68   save_LANG="$LANG"; LANG=C; export LANG
69 fi
70
71 if test "$LTCONFIG_VERSION" != "$VERSION"; then
72   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
73   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
74   exit 1
75 fi
76
77 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
78   echo "$modename: not configured to build any kind of library" 1>&2
79   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
80   exit 1
81 fi
82
83 # Global variables.
84 mode=$default_mode
85 nonopt=
86 prev=
87 prevopt=
88 run=
89 show="$echo"
90 show_help=
91 execute_dlfiles=
92 lo2o="s/\\.lo\$/.${objext}/"
93 los2o="s/\\.lo /.${objext} /g"
94
95 # Parse our command line options once, thoroughly.
96 while test $# -gt 0
97 do
98   arg="$1"
99   shift
100
101   case "$arg" in
102   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
103   *) optarg= ;;
104   esac
105
106   # If the previous option needs an argument, assign it.
107   if test -n "$prev"; then
108     case "$prev" in
109     execute_dlfiles)
110       eval "$prev=\"\$$prev \$arg\""
111       ;;
112     *)
113       eval "$prev=\$arg"
114       ;;
115     esac
116
117     prev=
118     prevopt=
119     continue
120   fi
121
122   # Have we seen a non-optional argument yet?
123   case "$arg" in
124   --help)
125     show_help=yes
126     ;;
127
128   --version)
129     echo "$PROGRAM (GNU $PACKAGE) $VERSION"
130     exit 0
131     ;;
132
133   --config)
134     sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
135     exit 0
136     ;;
137
138   --debug)
139     echo "$progname: enabling shell trace mode"
140     set -x
141     ;;
142
143   --dry-run | -n)
144     run=:
145     ;;
146
147   --features)
148     echo "host: $host"
149     if test "$build_libtool_libs" = yes; then
150       echo "enable shared libraries"
151     else
152       echo "disable shared libraries"
153     fi
154     if test "$build_old_libs" = yes; then
155       echo "enable static libraries"
156     else
157       echo "disable static libraries"
158     fi
159     exit 0
160     ;;
161
162   --finish) mode="finish" ;;
163
164   --mode) prevopt="--mode" prev=mode ;;
165   --mode=*) mode="$optarg" ;;
166
167   --quiet | --silent)
168     show=:
169     ;;
170
171   -dlopen)
172     prevopt="-dlopen"
173     prev=execute_dlfiles
174     ;;
175
176   -*)
177     $echo "$modename: unrecognized option \`$arg'" 1>&2
178     $echo "$help" 1>&2
179     exit 1
180     ;;
181
182   *)
183     nonopt="$arg"
184     break
185     ;;
186   esac
187 done
188
189 if test -n "$prevopt"; then
190   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
191   $echo "$help" 1>&2
192   exit 1
193 fi
194
195 if test -z "$show_help"; then
196
197   # Infer the operation mode.
198   if test -z "$mode"; then
199     case "$nonopt" in
200     *cc | *++ | gcc* | *-gcc*)
201       mode=link
202       for arg
203       do
204         case "$arg" in
205         -c)
206            mode=compile
207            break
208            ;;
209         esac
210       done
211       ;;
212     *db | *dbx | *strace | *truss)
213       mode=execute
214       ;;
215     *install*|cp|mv)
216       mode=install
217       ;;
218     *rm)
219       mode=uninstall
220       ;;
221     *)
222       # If we have no mode, but dlfiles were specified, then do execute mode.
223       test -n "$execute_dlfiles" && mode=execute
224
225       # Just use the default operation mode.
226       if test -z "$mode"; then
227         if test -n "$nonopt"; then
228           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
229         else
230           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
231         fi
232       fi
233       ;;
234     esac
235   fi
236
237   # Only execute mode is allowed to have -dlopen flags.
238   if test -n "$execute_dlfiles" && test "$mode" != execute; then
239     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
240     $echo "$help" 1>&2
241     exit 1
242   fi
243
244   # Change the help message to a mode-specific one.
245   generic_help="$help"
246   help="Try \`$modename --help --mode=$mode' for more information."
247
248   # These modes are in order of execution frequency so that they run quickly.
249   case "$mode" in
250   # libtool compile mode
251   compile)
252     modename="$modename: compile"
253     # Get the compilation command and the source file.
254     base_compile=
255     lastarg=
256     srcfile="$nonopt"
257     suppress_output=
258
259     for arg
260     do
261       # Accept any command-line options.
262       case "$arg" in
263       -o)
264         $echo "$modename: you cannot specify the output filename with \`-o'" 1>&2
265         $echo "$help" 1>&2
266         exit 1
267         ;;
268
269       -static)
270         build_old_libs=yes
271         continue
272         ;;
273       esac
274
275       # Accept the current argument as the source file.
276       lastarg="$srcfile"
277       srcfile="$arg"
278
279       # Aesthetically quote the previous argument.
280
281       # Backslashify any backslashes, double quotes, and dollar signs.
282       # These are the only characters that are still specially
283       # interpreted inside of double-quoted scrings.
284       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
285
286       # Double-quote args containing other shell metacharacters.
287       # Many Bourne shells cannot handle close brackets correctly in scan
288       # sets, so we specify it separately.
289       case "$lastarg" in
290       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
291         lastarg="\"$lastarg\""
292         ;;
293       esac
294
295       # Add the previous argument to base_compile.
296       if test -z "$base_compile"; then
297         base_compile="$lastarg"
298       else
299         base_compile="$base_compile $lastarg"
300       fi
301     done
302
303     # Get the name of the library object.
304     libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
305
306     # Recognize several different file suffixes.
307     xform='[cCFSfms]'
308     case "$libobj" in
309     *.ada) xform=ada ;;
310     *.adb) xform=adb ;;
311     *.ads) xform=ads ;;
312     *.asm) xform=asm ;;
313     *.c++) xform=c++ ;;
314     *.cc) xform=cc ;;
315     *.cpp) xform=cpp ;;
316     *.cxx) xform=cxx ;;
317     *.f90) xform=f90 ;;
318     *.for) xform=for ;;
319     esac
320
321     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
322
323     case "$libobj" in
324     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
325     *)
326       $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2
327       exit 1
328       ;;
329     esac
330
331     if test -z "$base_compile"; then
332       $echo "$modename: you must specify a compilation command" 1>&2
333       $echo "$help" 1>&2
334       exit 1
335     fi
336
337     # Delete any leftover library objects.
338     if test "$build_old_libs" = yes; then
339       $run $rm $obj $libobj
340       trap "$run $rm $obj $libobj; exit 1" 1 2 15
341     else
342       $run $rm $libobj
343       trap "$run $rm $libobj; exit 1" 1 2 15
344     fi
345
346     if test -n "$fix_srcfile_path"; then
347       eval srcfile=\"$fix_srcfile_path\"
348     fi
349
350     # Only build a PIC object if we are building libtool libraries.
351     if test "$build_libtool_libs" = yes; then
352       # Without this assignment, base_compile gets emptied.
353       fbsd_hideous_sh_bug=$base_compile
354
355       # All platforms use -DPIC, to notify preprocessed assembler code.
356       $show "$base_compile$pic_flag -DPIC $srcfile"
357       if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then :
358       else
359         test -n "$obj" && $run $rm $obj
360         exit 1
361       fi
362
363       # If we have no pic_flag, then copy the object into place and finish.
364       if test -z "$pic_flag"; then
365         $show "$LN_S $obj $libobj"
366         $run $LN_S $obj $libobj
367         exit $?
368       fi
369
370       # Just move the object, then go on to compile the next one
371       $show "$mv $obj $libobj"
372       $run $mv $obj $libobj || exit $?
373
374       # Allow error messages only from the first compilation.
375       suppress_output=' >/dev/null 2>&1'
376     fi
377
378     # Only build a position-dependent object if we build old libraries.
379     if test "$build_old_libs" = yes; then
380       # Suppress compiler output if we already did a PIC compilation.
381       $show "$base_compile $srcfile$suppress_output"
382       if $run eval "$base_compile \$srcfile$suppress_output"; then :
383       else
384         $run $rm $obj $libobj
385         exit 1
386       fi
387     fi
388
389     # Create an invalid libtool object if no PIC, so that we do not
390     # accidentally link it into a program.
391     if test "$build_libtool_libs" != yes; then
392       $show "echo timestamp > $libobj"
393       $run eval "echo timestamp > \$libobj" || exit $?
394     fi
395
396     exit 0
397     ;;
398
399   # libtool link mode
400   link)
401     modename="$modename: link"
402     CC="$nonopt"
403     allow_undefined=yes
404     compile_command="$CC"
405     finalize_command="$CC"
406
407     compile_shlibpath=
408     finalize_shlibpath=
409     convenience=
410     old_convenience=
411     deplibs=
412     dlfiles=
413     dlprefiles=
414     export_dynamic=no
415     generated=
416     hardcode_libdirs=
417     libobjs=
418     link_against_libtool_libs=
419     ltlibs=
420     objs=
421     prev=
422     prevarg=
423     release=
424     rpath=
425     perm_rpath=
426     temp_rpath=
427     vinfo=
428
429     # We need to know -static, to get the right output filenames.
430     for arg
431     do
432       case "$arg" in
433       -all-static | -static)
434         if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
435             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
436         fi
437         build_libtool_libs=no
438         build_old_libs=yes
439         break
440         ;;
441       esac
442     done
443
444     # See if our shared archives depend on static archives.
445     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
446
447     # Go through the arguments, transforming them on the way.
448     while test $# -gt 0; do
449       arg="$1"
450       shift
451
452       # If the previous option needs an argument, assign it.
453       if test -n "$prev"; then
454         case "$prev" in
455         output)
456           compile_command="$compile_command @OUTPUT@"
457           finalize_command="$finalize_command @OUTPUT@"
458           ;;
459         esac
460
461         case "$prev" in
462         dlfiles|dlprefiles)
463           case "$arg" in
464           *.la | *.lo) ;;  # We handle these cases below.
465           *)
466             dlprefiles="$dlprefiles $arg"
467             test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
468             prev=
469             ;;
470           esac
471           ;;
472         release)
473           release="-$arg"
474           prev=
475           continue
476           ;;
477         rpath)
478           rpath="$rpath $arg"
479           prev=
480           continue
481           ;;
482         *)
483           eval "$prev=\"\$arg\""
484           prev=
485           continue
486           ;;
487         esac
488       fi
489
490       prevarg="$arg"
491
492       case "$arg" in
493       -all-static)
494         if test -n "$link_static_flag"; then
495           compile_command="$compile_command $link_static_flag"
496           finalize_command="$finalize_command $link_static_flag"
497         fi
498         continue
499         ;;
500
501       -allow-undefined)
502         # FIXME: remove this flag sometime in the future.
503         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
504         continue
505         ;;
506
507       -dlopen)
508         prev=dlfiles
509         continue
510         ;;
511
512       -dlpreopen)
513         prev=dlprefiles
514         continue
515         ;;
516
517       -export-dynamic)
518         if test "$export_dynamic" != yes; then
519           export_dynamic=yes
520           if test -n "$export_dynamic_flag_spec"; then
521             eval arg=\"$export_dynamic_flag_spec\"
522           else
523             arg=
524           fi
525
526           # Add the symbol object into the linking commands.
527           compile_command="$compile_command @SYMFILE@"
528           finalize_command="$finalize_command @SYMFILE@"
529         fi
530         ;;
531
532       -L*)
533         dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
534         case "$dir" in
535         /* | [A-Za-z]:[/\\]*)
536           # Add the corresponding hardcode_libdir_flag, if it is not identical.
537           ;;
538         *)
539           $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
540           exit 1
541           ;;
542         esac
543         deplibs="$deplibs $arg"
544         ;;
545
546       -l*) deplibs="$deplibs $arg" ;;
547
548       -no-undefined)
549         allow_undefined=no
550         continue
551         ;;
552
553       -o) prev=output ;;
554
555       -release)
556         prev=release
557         continue
558         ;;
559
560       -rpath)
561         prev=rpath
562         continue
563         ;;
564
565       -static)
566         # If we have no pic_flag, then this is the same as -all-static.
567         if test -z "$pic_flag" && test -n "$link_static_flag"; then
568           compile_command="$compile_command $link_static_flag"
569           finalize_command="$finalize_command $link_static_flag"
570         fi
571         continue
572         ;;
573
574       -version-info)
575         prev=vinfo
576         continue
577         ;;
578
579       # Some other compiler flag.
580       -* | +*)
581         # Unknown arguments in both finalize_command and compile_command need
582         # to be aesthetically quoted because they are evaled later.
583         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
584         case "$arg" in
585         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
586           arg="\"$arg\""
587           ;;
588         esac
589         ;;
590
591       *.o | *.obj | *.a | *.lib)
592         # A standard object.
593         objs="$objs $arg"
594         ;;
595
596       *.lo)
597         # A library object.
598         if test "$prev" = dlfiles; then
599           dlfiles="$dlfiles $arg"
600           if test "$build_libtool_libs" = yes; then
601             prev=
602             continue
603           else
604             # If libtool objects are unsupported, then we need to preload.
605             prev=dlprefiles
606           fi
607         fi
608
609         if test "$prev" = dlprefiles; then
610           # Preload the old-style object.
611           dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
612           prev=
613         fi
614         libobjs="$libobjs $arg"
615         ;;
616
617       *.la)
618         # A libtool-controlled library.
619
620         dlname=
621         libdir=
622         library_names=
623         old_library=
624
625         # Check to see that this really is a libtool archive.
626         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
627         else
628           $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
629           exit 1
630         fi
631
632         # If there is no directory component, then add one.
633         case "$arg" in
634         */* | *\\*) . $arg ;;
635         *) . ./$arg ;;
636         esac
637
638         # Get the name of the library we link against.
639         linklib=
640         for l in $old_library $library_names; do
641           linklib="$l"
642         done
643
644         if test -z "$linklib"; then
645           $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
646           exit 1
647         fi
648
649         # Find the relevant object directory and library name.
650         name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
651         dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
652         if test "X$dir" = "X$arg"; then
653           dir="$objdir"
654         else
655           dir="$dir/$objdir"
656         fi
657
658         if test -z "$libdir"; then
659           # It is a libtool convenience library, so add in its objects.
660           convenience="$convenience $dir/$old_library"l
661           old_convenience="$old_convenience $dir/$old_library"
662           compile_command="$compile_command $dir/$old_library"
663           finalize_command="$finalize_command $dir/$old_library"
664           continue
665         fi
666
667         # This library was specified with -dlopen.
668         if test "$prev" = dlfiles; then
669           dlfiles="$dlfiles $arg"
670           if test -z "$dlname"; then
671             # If there is no dlname, we need to preload.
672             prev=dlprefiles
673           else
674             # We should not create a dependency on this library, but we
675             # may need any libraries it requires.
676             compile_command="$compile_command$dependency_libs"
677             finalize_command="$finalize_command$dependency_libs"
678             prev=
679             continue
680           fi
681         fi
682
683         # The library was specified with -dlpreopen.
684         if test "$prev" = dlprefiles; then
685           # Prefer using a static library (so that no silly _DYNAMIC symbols
686           # are required to link).
687           if test -n "$old_library"; then
688             dlprefiles="$dlprefiles $dir/$old_library"
689           else
690             dlprefiles="$dlprefiles $dir/$linklib"
691           fi
692           prev=
693         fi
694
695         if test "$build_libtool_libs" = yes && test -n "$library_names"; then
696           link_against_libtool_libs="$link_against_libtool_libs $arg"
697           if test -n "$shlibpath_var"; then
698             # Make sure the rpath contains only unique directories.
699             case "$temp_rpath " in
700             *" $dir "*) ;;
701             *) temp_rpath="$temp_rpath $dir" ;;
702             esac
703           fi
704
705           # This is the magic to use -rpath.
706           if test -n "$hardcode_libdir_flag_spec"; then
707             if test -n "$hardcode_libdir_separator"; then
708               if test -z "$hardcode_libdirs"; then
709                 # Put the magic libdir with the hardcode flag.
710                 hardcode_libdirs="$libdir"
711                 libdir="@HARDCODE_LIBDIRS@"
712               else
713                 # Just accumulate the unique libdirs.
714                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
715                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
716                   ;;
717                 *)
718                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
719                   ;;
720                 esac
721                 libdir=
722               fi
723             fi
724
725             if test -n "$libdir"; then
726               eval flag=\"$hardcode_libdir_flag_spec\"
727
728               compile_command="$compile_command $flag"
729               finalize_command="$finalize_command $flag"
730             fi
731           elif test -n "$runpath_var"; then
732             # Do the same for the permanent run path.
733             case "$perm_rpath " in
734             *" $libdir "*) ;;
735             *) perm_rpath="$perm_rpath $libdir" ;;
736             esac
737           fi
738
739
740           lib_linked=yes
741           case "$hardcode_action" in
742           immediate | unsupported)
743             if test "$hardcode_direct" = no; then
744               compile_command="$compile_command $dir/$linklib"
745             elif test "$hardcode_minus_L" = no; then
746               compile_command="$compile_command -L$dir -l$name"
747             elif test "$hardcode_shlibpath_var" = no; then
748               compile_shlibpath="$compile_shlibpath$dir:"
749               compile_command="$compile_command -l$name"
750             else
751               lib_linked=no
752             fi
753             ;;
754
755           relink)
756             # We need an absolute path.
757             case "$dir" in
758             /* | [A-Za-z]:[/\\]*) ;;
759             *)
760               absdir=`cd "$dir" && pwd`
761               if test -z "$absdir"; then
762                 $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
763                 exit 1
764               fi
765               dir="$absdir"
766               ;;
767             esac
768
769             if test "$hardcode_direct" = yes; then
770               compile_command="$compile_command $dir/$linklib"
771             elif test "$hardcode_minus_L" = yes; then
772               compile_command="$compile_command -L$dir -l$name"
773             elif test "$hardcode_shlibpath_var" = yes; then
774               compile_shlibpath="$compile_shlibpath$dir:"
775               compile_command="$compile_command -l$name"
776             else
777               lib_linked=no
778             fi
779             ;;
780
781           *)
782             lib_linked=no
783             ;;
784           esac
785
786           if test "$lib_linked" != yes; then
787             $echo "$modename: configuration error: unsupported hardcode properties"
788             exit 1
789           fi
790
791           # Finalize command for both is simple: just hardcode it.
792           if test "$hardcode_direct" = yes; then
793             finalize_command="$finalize_command $libdir/$linklib"
794           elif test "$hardcode_minus_L" = yes; then
795             finalize_command="$finalize_command -L$libdir -l$name"
796           elif test "$hardcode_shlibpath_var" = yes; then
797             finalize_shlibpath="$finalize_shlibpath$libdir:"
798             finalize_command="$finalize_command -l$name"
799           else
800             # We cannot seem to hardcode it, guess we'll fake it.
801             finalize_command="$finalize_command -L$libdir -l$name"
802           fi
803         else
804           # Transform directly to old archives if we don't build new libraries.
805           if test -n "$pic_flag" && test -z "$old_library"; then
806             $echo "$modename: cannot find static library for \`$arg'" 1>&2
807             exit 1
808           fi
809
810           # Here we assume that one of hardcode_direct or hardcode_minus_L
811           # is not unsupported.  This is valid on all known static and
812           # shared platforms.
813           if test "$hardcode_direct" != unsupported; then
814             test -n "$old_library" && linklib="$old_library"
815             compile_command="$compile_command $dir/$linklib"
816             finalize_command="$finalize_command $dir/$linklib"
817           else
818             compile_command="$compile_command -L$dir -l$name"
819             finalize_command="$finalize_command -L$dir -l$name"
820           fi
821         fi
822
823         # Add in any libraries that this one depends upon.
824         compile_command="$compile_command$dependency_libs"
825         finalize_command="$finalize_command$dependency_libs"
826         continue
827         ;;
828
829       # Some other compiler argument.
830       *)
831         # Unknown arguments in both finalize_command and compile_command need
832         # to be aesthetically quoted because they are evaled later.
833         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
834         case "$arg" in
835         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
836           arg="\"$arg\""
837           ;;
838         esac
839         ;;
840       esac
841
842       # Now actually substitute the argument into the commands.
843       if test -n "$arg"; then
844         compile_command="$compile_command $arg"
845         finalize_command="$finalize_command $arg"
846       fi
847     done
848
849     if test -n "$prev"; then
850       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
851       $echo "$help" 1>&2
852       exit 1
853     fi
854
855     oldlibs=
856     case "$output" in
857     "")
858       $echo "$modename: you must specify an output file" 1>&2
859       $echo "$help" 1>&2
860       exit 1
861       ;;
862
863     */* | *\\*)
864       $echo "$modename: output file \`$output' must have no directory components" 1>&2
865       $echo "$help" 1>&2
866       exit 1
867       ;;
868
869     *.a | *.lib)
870       if test -n "$link_against_libtool_libs"; then
871         $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
872         exit 1
873       fi
874
875       if test -n "$deplibs"; then
876         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
877       fi
878
879       if test -n "$dlfiles$dlprefiles"; then
880         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
881       fi
882
883       if test -n "$rpath"; then
884         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
885       fi
886
887       if test -n "$vinfo"; then
888         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
889       fi
890
891       if test -n "$release"; then
892         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
893       fi
894
895       # Now set the variables for building old libraries.
896       build_libtool_libs=no
897       oldlibs="$output"
898       ;;
899
900     *.la)
901       # Make sure we only generate libraries of the form `libNAME.la'.
902       case "$output" in
903       lib*) ;;
904       *)
905         $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
906         $echo "$help" 1>&2
907         exit 1
908         ;;
909       esac
910
911       name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
912       eval libname=\"$libname_spec\"
913
914       # All the library-specific variables (install_libdir is set above).
915       library_names=
916       old_library=
917       dlname=
918
919       if test -n "$objs"; then
920         $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
921         exit 1
922       fi
923
924       # How the heck are we supposed to write a wrapper for a shared library?
925       if test -n "$link_against_libtool_libs"; then
926         $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
927         exit 1
928       fi
929
930       if test -n "$dlfiles$dlprefiles"; then
931         $echo "$modename: warning: \`-dlopen' is ignored for libtool libraries" 1>&2
932       fi
933
934       set dummy $rpath
935       if test $# -gt 2; then
936         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
937       fi
938       install_libdir="$2"
939
940       # Now set the variables for building old libraries.
941       oldlibs="$objdir/$libname.$libext"
942       if test -z "$rpath"; then
943         # Building a libtool convenience library.
944         oldlibs="$objdir/$libname.al $oldlibs"
945         build_libtool_libs=convenience
946
947         if test -n "$vinfo"; then
948           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
949         fi
950
951         if test -n "$release"; then
952           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
953         fi
954       else
955
956         # Parse the version information argument.
957         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
958         set dummy $vinfo 0 0 0
959         IFS="$save_ifs"
960
961         if test -n "$8"; then
962           $echo "$modename: too many parameters to \`-version-info'" 1>&2
963           $echo "$help" 1>&2
964           exit 1
965         fi
966
967         current="$2"
968         revision="$3"
969         age="$4"
970
971         # Check that each of the things are valid numbers.
972         case "$current" in
973         0 | [1-9] | [1-9][0-9]*) ;;
974         *)
975           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
976           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
977           exit 1
978           ;;
979         esac
980
981         case "$revision" in
982         0 | [1-9] | [1-9][0-9]*) ;;
983         *)
984           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
985           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
986           exit 1
987           ;;
988         esac
989
990         case "$age" in
991         0 | [1-9] | [1-9][0-9]*) ;;
992         *)
993           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
994           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
995           exit 1
996           ;;
997         esac
998
999         if test $age -gt $current; then
1000           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
1001           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1002           exit 1
1003         fi
1004
1005         # Calculate the version variables.
1006         major=
1007         versuffix=
1008         verstring=
1009         case "$version_type" in
1010         none) ;;
1011
1012         linux)
1013           major=.`expr $current - $age`
1014           versuffix="$major.$age.$revision"
1015           ;;
1016
1017         osf)
1018           major=`expr $current - $age`
1019           versuffix=".$current.$age.$revision"
1020           verstring="$current.$age.$revision"
1021
1022           # Add in all the interfaces that we are compatible with.
1023           loop=$age
1024           while test $loop != 0; do
1025             iface=`expr $current - $loop`
1026             loop=`expr $loop - 1`
1027             verstring="$verstring:${iface}.0"
1028           done
1029
1030           # Make executables depend on our current version.
1031           verstring="$verstring:${current}.0"
1032           ;;
1033
1034         sunos)
1035           major=".$current"
1036           versuffix=".$current.$revision"
1037           ;;
1038
1039         windows)
1040           # Like Linux, but with '-' rather than '.', since we only
1041           # want one extension on Windows 95.
1042           major=`expr $current - $age`
1043           versuffix="-$major-$age-$revision"
1044           ;;
1045
1046         *)
1047           $echo "$modename: unknown library version type \`$version_type'" 1>&2
1048           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
1049           exit 1
1050           ;;
1051         esac
1052
1053         # Clear the version info if we defaulted, and they specified a release.
1054         if test -z "$vinfo" && test -n "$release"; then
1055           major=
1056           versuffix=
1057           verstring="0.0"
1058           case "$version_type" in
1059           sunos)
1060             versuffix=".0.0"
1061             ;;
1062           esac
1063         fi
1064
1065         # Check to see if the archive will have undefined symbols.
1066         if test "$allow_undefined" = yes; then
1067           if test "$allow_undefined_flag" = unsupported; then
1068             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
1069             build_libtool_libs=no
1070             build_old_libs=yes
1071           fi
1072         else
1073           # Don't allow undefined symbols.
1074           allow_undefined_flag="$no_undefined_flag"
1075         fi
1076
1077         # Add libc to deplibs on all systems.
1078         dependency_libs="$deplibs"
1079         deplibs="$deplibs -lc"
1080       fi
1081
1082       # Create the output directory, or remove our outputs if we need to.
1083       if test -d $objdir; then
1084         $show "${rm}r $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*"
1085         $run ${rm}r $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*
1086       else
1087         $show "$mkdir $objdir"
1088         $run $mkdir $objdir
1089         status=$?
1090         if test $status -ne 0 && test ! -d $objdir; then
1091           exit $status
1092         fi
1093       fi
1094
1095       if test "$build_libtool_libs" = yes; then
1096         # Get the real and link names of the library.
1097         eval library_names=\"$library_names_spec\"
1098         set dummy $library_names
1099         realname="$2"
1100         shift; shift
1101
1102         if test -n "$soname_spec"; then
1103           eval soname=\"$soname_spec\"
1104         else
1105           soname="$realname"
1106         fi
1107
1108         lib="$objdir/$realname"
1109         for link
1110         do
1111           linknames="$linknames $link"
1112         done
1113
1114         # Use standard objects if they are PIC.
1115         test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e "$los2o" -e 's/ $//g'`
1116
1117         # Transform .lo files to .o files.
1118         test "$build_old_libs" = yes && oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^   ]*\.a //g' -e 's/[^   ]*\.lib //g' -e "$los2o" -e 's/ $//g'`
1119
1120         if test -n "$whole_archive_flag_spec"; then
1121           if test -n "$convenience"; then
1122             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
1123           fi
1124         else
1125           for xlib in $convenience; do
1126             # Extract the objects.
1127             xdir="$xlib"x
1128             generated="$generated $xdir"
1129             xlib=`echo "$xlib" | $Xsed -e 's%^.*/%%'`
1130
1131             $show "${rm}r $xdir"
1132             $run ${rm}r "$xdir"
1133             $show "mkdir $xdir"
1134             $run mkdir "$xdir"
1135             status=$?
1136             if test $status -ne 0 && test ! -d "$xdir"; then
1137               exit $status
1138             fi
1139             $show "(cd $xdir && $AR x ../$xlib)"
1140             $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
1141
1142             libobjs="$libobjs `echo $xdir/*`"
1143           done
1144         fi
1145
1146         # Do each of the archive commands.
1147         eval cmds=\"$archive_cmds\"
1148         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1149         for cmd in $cmds; do
1150           IFS="$save_ifs"
1151           $show "$cmd"
1152           $run eval "$cmd" || exit $?
1153         done
1154         IFS="$save_ifs"
1155
1156         # Create links to the real library.
1157         for linkname in $linknames; do
1158           if test "$realname" != "$linkname"; then
1159             $show "(cd $objdir && $LN_S $realname $linkname)"
1160             $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $?
1161           fi
1162         done
1163
1164         # If -export-dynamic was specified, set the dlname.
1165         if test "$export_dynamic" = yes; then
1166           # On all known operating systems, these are identical.
1167           dlname="$soname"
1168         fi
1169       fi
1170       ;;
1171
1172     *.lo | *.o | *.obj)
1173       if test -n "$link_against_libtool_libs"; then
1174         $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
1175         exit 1
1176       fi
1177
1178       if test -n "$deplibs"; then
1179         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
1180       fi
1181
1182       if test -n "$dlfiles$dlprefiles"; then
1183         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
1184       fi
1185
1186       if test -n "$rpath"; then
1187         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
1188       fi
1189
1190       if test -n "$vinfo"; then
1191         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
1192       fi
1193
1194       if test -n "$release"; then
1195         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
1196       fi
1197
1198       case "$output" in
1199       *.lo)
1200         if test -n "$objs"; then
1201           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
1202           exit 1
1203         fi
1204         libobj="$output"
1205         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
1206         ;;
1207       *)
1208         libobj=
1209         obj="$output"
1210         ;;
1211       esac
1212
1213       # Delete the old objects.
1214       $run $rm $obj $libobj
1215
1216       # Create the old-style object.
1217       reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^       ]*\.a //g' -e 's/[^       ]*\.lib //g' -e "$los2o" -e 's/ $//g'`
1218
1219       output="$obj"
1220       eval cmds=\"$reload_cmds\"
1221       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1222       for cmd in $cmds; do
1223         IFS="$save_ifs"
1224         $show "$cmd"
1225         $run eval "$cmd" || exit $?
1226       done
1227       IFS="$save_ifs"
1228
1229       # Exit if we aren't doing a library object file.
1230       test -z "$libobj" && exit 0
1231
1232       if test "$build_libtool_libs" != yes; then
1233         # Create an invalid libtool object if no PIC, so that we don't
1234         # accidentally link it into a program.
1235         $show "echo timestamp > $libobj"
1236         $run eval "echo timestamp > $libobj" || exit $?
1237         exit 0
1238       fi
1239
1240       if test -n "$pic_flag"; then
1241         # Only do commands if we really have different PIC objects.
1242         reload_objs="$libobjs"
1243         output="$libobj"
1244         eval cmds=\"$reload_cmds\"
1245         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1246         for cmd in $cmds; do
1247           IFS="$save_ifs"
1248           $show "$cmd"
1249           $run eval "$cmd" || exit $?
1250         done
1251         IFS="$save_ifs"
1252       else
1253         # Just create a symlink.
1254         $show "$LN_S $obj $libobj"
1255         $run $LN_S $obj $libobj || exit $?
1256       fi
1257
1258       exit 0
1259       ;;
1260
1261     *)
1262       if test -n "$vinfo"; then
1263         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
1264       fi
1265
1266       if test -n "$release"; then
1267         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
1268       fi
1269
1270       if test -n "$rpath"; then
1271         # If the user specified any rpath flags, then add them.
1272         for libdir in $rpath; do
1273           if test -n "$hardcode_libdir_flag_spec"; then
1274             if test -n "$hardcode_libdir_separator"; then
1275               if test -z "$hardcode_libdirs"; then
1276                 # Put the magic libdir with the hardcode flag.
1277                 hardcode_libdirs="$libdir"
1278                 libdir="@HARDCODE_LIBDIRS@"
1279               else
1280                 # Just accumulate the unique libdirs.
1281                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
1282                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
1283                   ;;
1284                 *)
1285                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
1286                   ;;
1287                 esac
1288                 libdir=
1289               fi
1290             fi
1291
1292             if test -n "$libdir"; then
1293               eval flag=\"$hardcode_libdir_flag_spec\"
1294
1295               compile_command="$compile_command $flag"
1296               finalize_command="$finalize_command $flag"
1297             fi
1298           elif test -n "$runpath_var"; then
1299             case "$perm_rpath " in
1300             *" $libdir "*) ;;
1301             *) perm_rpath="$perm_rpath $libdir" ;;
1302             esac
1303           fi
1304         done
1305       fi
1306
1307       # Substitute the hardcoded libdirs into the compile commands.
1308       if test -n "$hardcode_libdir_separator"; then
1309         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1310         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1311       fi
1312
1313       if test -n "$libobjs" && test "$build_old_libs" = yes; then
1314         # Transform all the library objects into standard objects.
1315         compile_command=`$echo "X$compile_command " | $Xsed -e "$los2o" -e 's/ $//'`
1316         finalize_command=`$echo "X$finalize_command " | $Xsed -e "$los2o" -e 's/ $//'`
1317       fi
1318
1319       if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then
1320         dlsyms="${output}S.c"
1321       else
1322         dlsyms=
1323       fi
1324
1325       if test -n "$dlsyms"; then
1326         # Add our own program objects to the preloaded list.
1327         dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e "$los2o" -e 's/ $//'`
1328
1329         # Discover the nlist of each of the dlfiles.
1330         nlist="$objdir/${output}.nm"
1331
1332         if test -d $objdir; then
1333           $show "$rm $nlist ${nlist}T"
1334           $run $rm "$nlist" "${nlist}T"
1335         else
1336           $show "$mkdir $objdir"
1337           $run $mkdir $objdir
1338           status=$?
1339           if test $status -ne 0 && test ! -d $objdir; then
1340             exit $status
1341           fi
1342         fi
1343
1344         for arg in $dlprefiles; do
1345           $show "extracting global C symbols from \`$arg'"
1346           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
1347         done
1348
1349         # Parse the name list into a source file.
1350         $show "creating $objdir/$dlsyms"
1351         if test -z "$run"; then
1352           # Make sure we at least have an empty file.
1353           test -f "$nlist" || : > "$nlist"
1354
1355           # Try sorting and uniquifying the output.
1356           if sort "$nlist" | uniq > "$nlist"T; then
1357             mv -f "$nlist"T "$nlist"
1358             wcout=`wc "$nlist" 2>/dev/null`
1359             count=`echo "X$wcout" | $Xsed -e 's/^[      ]*\([0-9][0-9]*\).*$/\1/'`
1360             (test "$count" -ge 0) 2>/dev/null || count=-1
1361           else
1362             $rm "$nlist"T
1363             count=-1
1364           fi
1365
1366           case "$dlsyms" in
1367           "") ;;
1368           *.c)
1369             $echo > "$objdir/$dlsyms" "\
1370 /* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */
1371 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */
1372
1373 #ifdef __cplusplus
1374 extern \"C\" {
1375 #endif
1376
1377 /* Prevent the only kind of declaration conflicts we can make. */
1378 #define dld_preloaded_symbol_count some_other_symbol
1379 #define dld_preloaded_symbols some_other_symbol
1380
1381 /* External symbol declarations for the compiler. */\
1382 "
1383
1384             if test -f "$nlist"; then
1385               sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms"
1386             else
1387               echo '/* NONE */' >> "$objdir/$dlsyms"
1388             fi
1389
1390             $echo >> "$objdir/$dlsyms" "\
1391
1392 #undef dld_preloaded_symbol_count
1393 #undef dld_preloaded_symbols
1394
1395 #if defined (__STDC__) && __STDC__
1396 # define __ptr_t void *
1397 #else
1398 # define __ptr_t char *
1399 #endif
1400
1401 /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */
1402 int dld_preloaded_symbol_count = $count;
1403
1404 /* The mapping between symbol names and symbols. */
1405 struct {
1406   char *name;
1407   __ptr_t address;
1408 }
1409 dld_preloaded_symbols[] =
1410 {\
1411 "
1412
1413             if test -f "$nlist"; then
1414               sed 's/^\(.*\) \(.*\)$/  {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms"
1415             fi
1416
1417             $echo >> "$objdir/$dlsyms" "\
1418   {0, (__ptr_t) 0}
1419 };
1420
1421 #ifdef __cplusplus
1422 }
1423 #endif\
1424 "
1425             ;;
1426
1427           *)
1428             $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
1429             exit 1
1430             ;;
1431           esac
1432         fi
1433
1434         # Now compile the dynamic symbol file.
1435         $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")"
1436         $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $?
1437
1438         # Transform the symbol file into the correct name.
1439         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
1440         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
1441       elif test "$export_dynamic" != yes; then
1442         test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2
1443       else
1444         # We keep going just in case the user didn't refer to
1445         # dld_preloaded_symbols.  The linker will fail if global_symbol_pipe
1446         # really was required.
1447         $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
1448
1449         # Nullify the symbol file.
1450         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1451         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1452       fi
1453
1454       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
1455         # Replace the output file specification.
1456         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1457         finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1458
1459         # We have no uninstalled library dependencies, so finalize right now.
1460         $show "$compile_command"
1461         $run eval "$compile_command"
1462         exit $?
1463       fi
1464
1465       # Replace the output file specification.
1466       compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'`
1467       finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'`
1468
1469       # Create the binary in the object directory, then wrap it.
1470       if test ! -d $objdir; then
1471         $show "$mkdir $objdir"
1472         $run $mkdir $objdir
1473         status=$?
1474         if test $status -ne 0 && test ! -d $objdir; then
1475           exit $status
1476         fi
1477       fi
1478
1479       if test -n "$shlibpath_var"; then
1480         # We should set the shlibpath_var
1481         rpath=
1482         for dir in $temp_rpath; do
1483           case "$dir" in
1484           /* | [A-Za-z]:[/\\]*)
1485             # Absolute path.
1486             rpath="$rpath$dir:"
1487             ;;
1488           *)
1489             # Relative path: add a thisdir entry.
1490             rpath="$rpath\$thisdir/$dir:"
1491             ;;
1492           esac
1493         done
1494         temp_rpath="$rpath"
1495       fi
1496
1497       # Delete the old output file.
1498       $run $rm $output
1499
1500       if test -n "$compile_shlibpath"; then
1501         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
1502       fi
1503       if test -n "$finalize_shlibpath"; then
1504         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
1505       fi
1506
1507       if test -n "$runpath_var" && test -n "$perm_rpath"; then
1508         # We should set the runpath_var.
1509         rpath=
1510         for dir in $perm_rpath; do
1511           rpath="$rpath$dir:"
1512         done
1513         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
1514         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
1515       fi
1516
1517       if test "$hardcode_action" = relink; then
1518         # AGH! Flame the AIX and HP-UX people for me, will ya?
1519         $echo "$modename: warning: using a buggy system linker" 1>&2
1520         $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2
1521       fi
1522
1523       $show "$compile_command"
1524       $run eval "$compile_command" || exit $?
1525
1526       # Now create the wrapper script.
1527       $show "creating $output"
1528
1529       # Quote the finalize command for shipping.
1530       finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"`
1531
1532       # Quote $echo for shipping.
1533       qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
1534
1535       # Only actually do things if our run command is non-null.
1536       if test -z "$run"; then
1537         $rm $output
1538         trap "$rm $output; exit 1" 1 2 15
1539
1540         $echo > $output "\
1541 #! $SHELL
1542
1543 # $output - temporary wrapper script for $objdir/$output
1544 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
1545 #
1546 # The $output program cannot be directly executed until all the libtool
1547 # libraries that it depends on are installed.
1548 #
1549 # This wrapper script should never be moved out of \``pwd`'.
1550 # If it is, it will not operate correctly.
1551
1552 # Sed substitution that helps us do robust quoting.  It backslashifies
1553 # metacharacters that are still active within double-quoted strings.
1554 Xsed='sed -e s/^X//'
1555 sed_quote_subst='$sed_quote_subst'
1556
1557 # The HP-UX ksh and POSIX shell print the target directory to stdout
1558 # if CDPATH is set.
1559 if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi
1560
1561 # This environment variable determines our operation mode.
1562 if test \"\$libtool_install_magic\" = \"$magic\"; then
1563   # install mode needs the following variables:
1564   link_against_libtool_libs='$link_against_libtool_libs'
1565   finalize_command=\"$finalize_command\"
1566 else
1567   # When we are sourced in execute mode, \$file and \$echo are already set.
1568   if test \"\$libtool_execute_magic\" != \"$magic\"; then
1569     echo=\"$qecho\"
1570     file=\"\$0\"
1571     # Make sure echo works.
1572     if test \"X\$1\" = X--no-reexec; then
1573       # Discard the --no-reexec flag, and continue.
1574       shift
1575     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
1576       # Yippee, \$echo works!
1577       :
1578     else
1579       # Restart under the correct shell, and then maybe \$echo will work.
1580       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
1581     fi
1582   fi\
1583 "
1584         $echo >> $output "\
1585
1586   # Find the directory that this script lives in.
1587   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
1588   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
1589
1590   # Follow symbolic links until we get to the real thisdir.
1591   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
1592   while test -n \"\$file\"; do
1593     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
1594
1595     # If there was a directory component, then change thisdir.
1596     if test \"x\$destdir\" != \"x\$file\"; then
1597       case \"\$destdir\" in
1598       /* | [A-Za-z]:[/\\]*) thisdir=\"\$destdir\" ;;
1599       *) thisdir=\"\$thisdir/\$destdir\" ;;
1600       esac
1601     fi
1602
1603     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
1604     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
1605   done
1606
1607   # Try to get the absolute directory name.
1608   absdir=\`cd \"\$thisdir\" && pwd\`
1609   test -n \"\$absdir\" && thisdir=\"\$absdir\"
1610
1611   progdir=\"\$thisdir/$objdir\"
1612   program='$output'
1613
1614   if test -f \"\$progdir/\$program\"; then"
1615
1616         # Export our shlibpath_var if we have one.
1617         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
1618           $echo >> $output "\
1619     # Add our own library path to $shlibpath_var
1620     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
1621
1622     # Some systems cannot cope with colon-terminated $shlibpath_var
1623     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\`
1624
1625     export $shlibpath_var
1626 "
1627         fi
1628
1629         $echo >> $output "\
1630     if test \"\$libtool_execute_magic\" != \"$magic\"; then
1631       # Run the actual program with our arguments.
1632
1633       # Export the path to the program.
1634       PATH=\"\$progdir:\$PATH\"
1635       export PATH
1636
1637       exec \$program \${1+\"\$@\"}
1638
1639       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
1640       exit 1
1641     fi
1642   else
1643     # The program doesn't exist.
1644     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
1645     \$echo \"This script is just a wrapper for \$program.\" 1>&2
1646     echo \"See the $PACKAGE documentation for more information.\" 1>&2
1647     exit 1
1648   fi
1649 fi\
1650 "
1651         chmod +x $output
1652       fi
1653       exit 0
1654       ;;
1655     esac
1656
1657     # See if we need to build an old-fashioned archive.
1658     for oldlib in $oldlibs; do
1659
1660       if test "$build_libtool_libs" = convenience; then
1661         oldobjs="$libobjs"
1662         addlibs="$convenience"
1663         build_libtool_libs=no
1664       else
1665         addlibs="$old_convenience"
1666       fi
1667
1668       # Add in members from convenience archives.
1669       for xlib in $addlibs; do
1670         # Extract the objects.
1671         xdir="$xlib"x
1672         generated="$generated $xdir"
1673         xlib=`echo "$xlib" | $Xsed -e 's%^.*/%%'`
1674
1675         $show "${rm}r $xdir"
1676         $run ${rm}r "$xdir"
1677         $show "mkdir $xdir"
1678         $run mkdir "$xdir"
1679         status=$?
1680         if test $status -ne 0 && test ! -d "$xdir"; then
1681           exit $status
1682         fi
1683         $show "(cd $xdir && $AR x ../$xlib)"
1684         $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
1685
1686         oldobjs="$oldobjs `echo $xdir/*`"
1687       done
1688
1689       # Do each command in the archive commands.
1690       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
1691         eval cmds=\"$old_archive_from_new_cmds\"
1692       else
1693         eval cmds=\"$old_archive_cmds\"
1694       fi
1695       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1696       for cmd in $cmds; do
1697         IFS="$save_ifs"
1698         $show "$cmd"
1699         $run eval "$cmd" || exit $?
1700       done
1701       IFS="$save_ifs"
1702     done
1703
1704     if test -n "$generated"; then
1705       $show "${rm}r$generated"
1706       $run ${rm}r$generated
1707     fi
1708
1709     # Now create the libtool archive.
1710     case "$output" in
1711     *.la)
1712       old_library=
1713       test "$build_old_libs" = yes && old_library="$libname.$libext"
1714       $show "creating $output"
1715
1716       # Only create the output if not a dry run.
1717       if test -z "$run"; then
1718         $echo > $output "\
1719 # $output - a libtool library file
1720 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
1721
1722 # The name that we can dlopen(3).
1723 dlname='$dlname'
1724
1725 # Names of this library.
1726 library_names='$library_names'
1727
1728 # The name of the static archive.
1729 old_library='$old_library'
1730
1731 # Libraries that this one depends upon.
1732 dependency_libs='$dependency_libs'
1733
1734 # Version information for $libname.
1735 current=$current
1736 age=$age
1737 revision=$revision
1738
1739 # Directory that this library needs to be installed in:
1740 libdir='$install_libdir'\
1741 "
1742       fi
1743
1744       # Do a symbolic link so that the libtool archive can be found in
1745       # LD_LIBRARY_PATH before the program is installed.
1746       $show "(cd $objdir && $LN_S ../$output $output)"
1747       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit $?
1748       ;;
1749     esac
1750     exit 0
1751     ;;
1752
1753   # libtool install mode
1754   install)
1755     modename="$modename: install"
1756
1757     # There may be an optional sh(1) argument at the beginning of
1758     # install_prog (especially on Windows NT).
1759     if test "$nonopt" = "$SHELL"; then
1760       # Aesthetically quote it.
1761       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
1762       case "$arg" in
1763       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1764         arg="\"$arg\""
1765         ;;
1766       esac
1767       install_prog="$arg "
1768       arg="$1"
1769       shift
1770     else
1771       install_prog=
1772       arg="$nonopt"
1773     fi
1774
1775     # The real first argument should be the name of the installation program.
1776     # Aesthetically quote it.
1777     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1778     case "$arg" in
1779     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
1780       arg="\"$arg\""
1781       ;;
1782     esac
1783     install_prog="$install_prog$arg"
1784
1785     # We need to accept at least all the BSD install flags.
1786     dest=
1787     files=
1788     opts=
1789     prev=
1790     install_type=
1791     isdir=no
1792     stripme=
1793     for arg
1794     do
1795       if test -n "$dest"; then
1796         files="$files $dest"
1797         dest="$arg"
1798         continue
1799       fi
1800
1801       case "$arg" in
1802       -d) isdir=yes ;;
1803       -f) prev="-f" ;;
1804       -g) prev="-g" ;;
1805       -m) prev="-m" ;;
1806       -o) prev="-o" ;;
1807       -s)
1808         stripme=" -s"
1809         continue
1810         ;;
1811       -*) ;;
1812
1813       *)
1814         # If the previous option needed an argument, then skip it.
1815         if test -n "$prev"; then
1816           prev=
1817         else
1818           dest="$arg"
1819           continue
1820         fi
1821         ;;
1822       esac
1823
1824       # Aesthetically quote the argument.
1825       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1826       case "$arg" in
1827       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1828         arg="\"$arg\""
1829         ;;
1830       esac
1831       install_prog="$install_prog $arg"
1832     done
1833
1834     if test -z "$install_prog"; then
1835       $echo "$modename: you must specify an install program" 1>&2
1836       $echo "$help" 1>&2
1837       exit 1
1838     fi
1839
1840     if test -n "$prev"; then
1841       $echo "$modename: the \`$prev' option requires an argument" 1>&2
1842       $echo "$help" 1>&2
1843       exit 1
1844     fi
1845
1846     if test -z "$files"; then
1847       if test -z "$dest"; then
1848         $echo "$modename: no file or destination specified" 1>&2
1849       else
1850         $echo "$modename: you must specify a destination" 1>&2
1851       fi
1852       $echo "$help" 1>&2
1853       exit 1
1854     fi
1855
1856     # Strip any trailing slash from the destination.
1857     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
1858
1859     # Check to see that the destination is a directory.
1860     test -d "$dest" && isdir=yes
1861     if test "$isdir" = yes; then
1862       destdir="$dest"
1863       destname=
1864     else
1865       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
1866       test "X$destdir" = "X$dest" && destdir=.
1867       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
1868
1869       # Not a directory, so check to see that there is only one file specified.
1870       set dummy $files
1871       if test $# -gt 2; then
1872         $echo "$modename: \`$dest' is not a directory" 1>&2
1873         $echo "$help" 1>&2
1874         exit 1
1875       fi
1876     fi
1877     case "$destdir" in
1878     /* | [A-Za-z]:[/\\]*) ;;
1879     *)
1880       for file in $files; do
1881         case "$file" in
1882         *.lo) ;;
1883         *)
1884           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
1885           $echo "$help" 1>&2
1886           exit 1
1887           ;;
1888         esac
1889       done
1890       ;;
1891     esac
1892
1893     # This variable tells wrapper scripts just to set variables rather
1894     # than running their programs.
1895     libtool_install_magic="$magic"
1896
1897     staticlibs=
1898     future_libdirs=
1899     current_libdirs=
1900     for file in $files; do
1901
1902       # Do each installation.
1903       case "$file" in
1904       *.a | *.lib)
1905         # Do the static libraries later.
1906         staticlibs="$staticlibs $file"
1907         ;;
1908
1909       *.la)
1910         # Check to see that this really is a libtool archive.
1911         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1912         else
1913           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
1914           $echo "$help" 1>&2
1915           exit 1
1916         fi
1917
1918         library_names=
1919         old_library=
1920         # If there is no directory component, then add one.
1921         case "$file" in
1922         */* | *\\*) . $file ;;
1923         *) . ./$file ;;
1924         esac
1925
1926         # Add the libdir to current_libdirs if it is the destination.
1927         if test "X$destdir" = "X$libdir"; then
1928           case "$current_libdirs " in
1929           *" $libdir "*) ;;
1930           *) current_libdirs="$current_libdirs $libdir" ;;
1931           esac
1932         else
1933           # Note the libdir as a future libdir.
1934           case "$future_libdirs " in
1935           *" $libdir "*) ;;
1936           *) future_libdirs="$future_libdirs $libdir" ;;
1937           esac
1938         fi
1939
1940         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
1941         test "X$dir" = "X$file/" && dir=
1942         dir="$dir$objdir"
1943
1944         # See the names of the shared library.
1945         set dummy $library_names
1946         if test -n "$2"; then
1947           realname="$2"
1948           shift
1949           shift
1950
1951           # Install the shared library and build the symlinks.
1952           $show "$install_prog $dir/$realname $destdir/$realname"
1953           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
1954           test "X$dlname" = "X$realname" && dlname=
1955
1956           if test $# -gt 0; then
1957             # Delete the old symlinks.
1958             rmcmd="$rm"
1959             for linkname
1960             do
1961               if test "X$linkname" != "X$realname"; then
1962                 rmcmd="$rmcmd $destdir/$linkname"
1963               fi
1964             done
1965             $show "$rmcmd"
1966             $run $rmcmd
1967
1968             # ... and create new ones.
1969             for linkname
1970             do
1971               if test "X$linkname" != "X$realname"; then
1972                 test "X$dlname" = "X$linkname" && dlname=
1973                 $show "(cd $destdir && $LN_S $realname $linkname)"
1974                 $run eval "(cd $destdir && $LN_S $realname $linkname)"
1975               fi
1976             done
1977           fi
1978
1979           if test -n "$dlname"; then
1980             # Install the dynamically-loadable library.
1981             $show "$install_prog $dir/$dlname $destdir/$dlname"
1982             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1983           fi
1984
1985           # Do each command in the postinstall commands.
1986           lib="$destdir/$realname"
1987           eval cmds=\"$postinstall_cmds\"
1988           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1989           for cmd in $cmds; do
1990             IFS="$save_ifs"
1991             $show "$cmd"
1992             $run eval "$cmd" || exit $?
1993           done
1994           IFS="$save_ifs"
1995         fi
1996
1997         # Install the pseudo-library for information purposes.
1998         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1999         $show "$install_prog $file $destdir/$name"
2000         $run eval "$install_prog $file $destdir/$name" || exit $?
2001
2002         # Maybe install the static library, too.
2003         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2004         ;;
2005
2006       *.lo)
2007         # Install (i.e. copy) a libtool object.
2008
2009         # Figure out destination file name, if it wasn't already specified.
2010         if test -n "$destname"; then
2011           destfile="$destdir/$destname"
2012         else
2013           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2014           destfile="$destdir/$destfile"
2015         fi
2016
2017         # Deduce the name of the destination old-style object file.
2018         case "$destfile" in
2019         *.lo)
2020           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
2021           ;;
2022         *.o | *.obj)
2023           staticdest="$destfile"
2024           destfile=
2025           ;;
2026         *)
2027           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
2028           $echo "$help" 1>&2
2029           exit 1
2030           ;;
2031         esac
2032
2033         # Install the libtool object if requested.
2034         if test -n "$destfile"; then
2035           $show "$install_prog $file $destfile"
2036           $run eval "$install_prog $file $destfile" || exit $?
2037         fi
2038
2039         # Install the old object if enabled.
2040         if test "$build_old_libs" = yes; then
2041           # Deduce the name of the old-style object file.
2042           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
2043
2044           $show "$install_prog $staticobj $staticdest"
2045           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
2046         fi
2047         exit 0
2048         ;;
2049
2050       *)
2051         # Figure out destination file name, if it wasn't already specified.
2052         if test -n "$destname"; then
2053           destfile="$destdir/$destname"
2054         else
2055           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2056           destfile="$destdir/$destfile"
2057         fi
2058
2059         # Do a test to see if this is really a libtool program.
2060         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2061           link_against_libtool_libs=
2062           finalize_command=
2063
2064           # If there is no directory component, then add one.
2065           case "$file" in
2066           */* | *\\*) . $file ;;
2067           *) . ./$file ;;
2068           esac
2069
2070           # Check the variables that should have been set.
2071           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
2072             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
2073             exit 1
2074           fi
2075
2076           finalize=yes
2077           for lib in $link_against_libtool_libs; do
2078             # Check to see that each library is installed.
2079             libdir=
2080             if test -f "$lib"; then
2081               # If there is no directory component, then add one.
2082               case "$lib" in
2083               */* | *\\*) . $lib ;;
2084               *) . ./$lib ;;
2085               esac
2086             fi
2087             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
2088             if test -n "$libdir" && test ! -f "$libfile"; then
2089               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
2090               finalize=no
2091             fi
2092           done
2093
2094           if test "$hardcode_action" = relink; then
2095             if test "$finalize" = yes; then
2096               $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
2097               $show "$finalize_command"
2098               if $run eval "$finalize_command"; then :
2099               else
2100                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
2101                 continue
2102               fi
2103               file="$objdir/$file"T
2104             else
2105               $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
2106             fi
2107           else
2108             # Install the binary that we compiled earlier.
2109             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2110           fi
2111         fi
2112
2113         $show "$install_prog$stripme $file $destfile"
2114         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
2115         ;;
2116       esac
2117     done
2118
2119     for file in $staticlibs; do
2120       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2121
2122       # Set up the ranlib parameters.
2123       oldlib="$destdir/$name"
2124
2125       $show "$install_prog $file $oldlib"
2126       $run eval "$install_prog \$file \$oldlib" || exit $?
2127
2128       # Do each command in the postinstall commands.
2129       eval cmds=\"$old_postinstall_cmds\"
2130       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
2131       for cmd in $cmds; do
2132         IFS="$save_ifs"
2133         $show "$cmd"
2134         $run eval "$cmd" || exit $?
2135       done
2136       IFS="$save_ifs"
2137     done
2138
2139     if test -n "$future_libdirs"; then
2140       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
2141     fi
2142
2143     if test -n "$current_libdirs"; then
2144       # Maybe just do a dry run.
2145       test -n "$run" && current_libdirs=" -n$current_libdirs"
2146       exec $SHELL $0 --finish$current_libdirs
2147       exit 1
2148     fi
2149
2150     exit 0
2151     ;;
2152
2153   # libtool finish mode
2154   finish)
2155     modename="$modename: finish"
2156     libdirs="$nonopt"
2157     admincmds=
2158
2159     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2160       for dir
2161       do
2162         libdirs="$libdirs $dir"
2163       done
2164
2165       for libdir in $libdirs; do
2166         if test -n "$finish_cmds"; then
2167           # Do each command in the finish commands.
2168           eval cmds=\"$finish_cmds\"
2169           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
2170           for cmd in $cmds; do
2171             IFS="$save_ifs"
2172             $show "$cmd"
2173             $run eval "$cmd" || admincmds="$admincmds
2174        $cmd"
2175           done
2176           IFS="$save_ifs"
2177         fi
2178         if test -n "$finish_eval"; then
2179           # Do the single finish_eval.
2180           eval cmds=\"$finish_eval\"
2181           $run eval "$cmds" || admincmds="$admincmds
2182        $cmds"
2183         fi
2184       done
2185     fi
2186
2187     echo "----------------------------------------------------------------------"
2188     echo "Libraries have been installed in:"
2189     for libdir in $libdirs; do
2190       echo "   $libdir"
2191     done
2192     echo
2193     echo "To link against installed libraries in a given directory, LIBDIR,"
2194     echo "you must use the \`-LLIBDIR' flag during linking."
2195     echo
2196     echo " You will also need to do at least one of the following:"
2197     if test -n "$shlibpath_var"; then
2198       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2199       echo "     during execution"
2200     fi
2201     if test -n "$runpath_var"; then
2202       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2203       echo "     during linking"
2204     fi
2205     if test -n "$hardcode_libdir_flag_spec"; then
2206       libdir=LIBDIR
2207       eval flag=\"$hardcode_libdir_flag_spec\"
2208
2209       echo "   - use the \`$flag' linker flag"
2210     fi
2211     if test -n "$admincmds"; then
2212       echo "   - have your system administrator run these commands:$admincmds"
2213     fi
2214     if test -f /etc/ld.so.conf; then
2215       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2216     fi
2217     echo
2218     echo "See any operating system documentation about shared libraries for"
2219     echo "more information, such as the ld(1) and ld.so(8) manual pages."
2220     echo "----------------------------------------------------------------------"
2221     exit 0
2222     ;;
2223
2224   # libtool execute mode
2225   execute)
2226     modename="$modename: execute"
2227
2228     # The first argument is the command name.
2229     cmd="$nonopt"
2230     if test -z "$cmd"; then
2231       $echo "$modename: you must specify a COMMAND" 1>&2
2232       $echo "$help"
2233       exit 1
2234     fi
2235
2236     # Handle -dlopen flags immediately.
2237     for file in $execute_dlfiles; do
2238       if test ! -f "$file"; then
2239         $echo "$modename: \`$file' is not a file" 1>&2
2240         $echo "$help" 1>&2
2241         exit 1
2242       fi
2243
2244       dir=
2245       case "$file" in
2246       *.la)
2247         # Check to see that this really is a libtool archive.
2248         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2249         else
2250           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2251           $echo "$help" 1>&2
2252           exit 1
2253         fi
2254
2255         # Read the libtool library.
2256         dlname=
2257         library_names=
2258
2259         # If there is no directory component, then add one.
2260         case "$file" in
2261         */* | *\\*) . $file ;;
2262         *) . ./$file ;;
2263         esac
2264
2265         # Skip this library if it cannot be dlopened.
2266         if test -z "$dlname"; then
2267           # Warn if it was a shared library.
2268           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
2269           continue
2270         fi
2271
2272         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2273         test "X$dir" = "X$file" && dir=.
2274
2275         if test -f "$dir/$objdir/$dlname"; then
2276           dir="$dir/$objdir"
2277         else
2278           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
2279           exit 1
2280         fi
2281         ;;
2282
2283       *.lo)
2284         # Just add the directory containing the .lo file.
2285         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2286         test "X$dir" = "X$file" && dir=.
2287         ;;
2288
2289       *)
2290         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
2291         continue
2292         ;;
2293       esac
2294
2295       # Get the absolute pathname.
2296       absdir=`cd "$dir" && pwd`
2297       test -n "$absdir" && dir="$absdir"
2298
2299       # Now add the directory to shlibpath_var.
2300       if eval "test -z \"\$$shlibpath_var\""; then
2301         eval "$shlibpath_var=\"\$dir\""
2302       else
2303         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2304       fi
2305     done
2306
2307     # This variable tells wrapper scripts just to set shlibpath_var
2308     # rather than running their programs.
2309     libtool_execute_magic="$magic"
2310
2311     # Check if any of the arguments is a wrapper script.
2312     args=
2313     for file
2314     do
2315       case "$file" in
2316       -*) ;;
2317       *)
2318         # Do a test to see if this is really a libtool program.
2319         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2320           # If there is no directory component, then add one.
2321           case "$file" in
2322           */* | *\\*) . $file ;;
2323           *) . ./$file ;;
2324           esac
2325
2326           # Transform arg to wrapped name.
2327           file="$progdir/$program"
2328         fi
2329         ;;
2330       esac
2331       # Quote arguments (to preserve shell metacharacters).
2332       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
2333       args="$args \"$file\""
2334     done
2335
2336     if test -z "$run"; then
2337       # Export the shlibpath_var.
2338       eval "export $shlibpath_var"
2339
2340       # Restore saved enviroment variables
2341       if test "${save_LC_ALL+set}" = set; then
2342         LC_ALL="$save_LC_ALL"; export LC_ALL
2343       fi
2344       if test "${save_LANG+set}" = set; then
2345         LANG="$save_LANG"; export LANG
2346       fi
2347
2348       # Now actually exec the command.
2349       eval "exec \$cmd$args"
2350
2351       $echo "$modename: cannot exec \$cmd$args"
2352       exit 1
2353     else
2354       # Display what would be done.
2355       eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
2356       $echo "export $shlibpath_var"
2357       $echo "$cmd$args"
2358       exit 0
2359     fi
2360     ;;
2361
2362   # libtool uninstall mode
2363   uninstall)
2364     modename="$modename: uninstall"
2365     rm="$nonopt"
2366     files=
2367
2368     for arg
2369     do
2370       case "$arg" in
2371       -*) rm="$rm $arg" ;;
2372       *) files="$files $arg" ;;
2373       esac
2374     done
2375
2376     if test -z "$rm"; then
2377       $echo "$modename: you must specify an RM program" 1>&2
2378       $echo "$help" 1>&2
2379       exit 1
2380     fi
2381
2382     for file in $files; do
2383       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2384       test "X$dir" = "X$file" && dir=.
2385       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2386
2387       rmfiles="$file"
2388
2389       case "$name" in
2390       *.la)
2391         # Possibly a libtool archive, so verify it.
2392         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2393           . $dir/$name
2394
2395           # Delete the libtool libraries and symlinks.
2396           for n in $library_names; do
2397             rmfiles="$rmfiles $dir/$n"
2398             test "X$n" = "X$dlname" && dlname=
2399           done
2400           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
2401           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
2402
2403           $show "$rm $rmfiles"
2404           $run $rm $rmfiles
2405
2406           if test -n "$library_names"; then
2407             # Do each command in the postuninstall commands.
2408             eval cmds=\"$postuninstall_cmds\"
2409             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2410             for cmd in $cmds; do
2411               IFS="$save_ifs"
2412               $show "$cmd"
2413               $run eval "$cmd"
2414             done
2415             IFS="$save_ifs"
2416           fi
2417
2418           if test -n "$old_library"; then
2419             # Do each command in the old_postuninstall commands.
2420             eval cmds=\"$old_postuninstall_cmds\"
2421             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2422             for cmd in $cmds; do
2423               IFS="$save_ifs"
2424               $show "$cmd"
2425               $run eval "$cmd"
2426             done
2427             IFS="$save_ifs"
2428           fi
2429
2430           # FIXME: should reinstall the best remaining shared library.
2431         fi
2432         ;;
2433
2434       *.lo)
2435         if test "$build_old_libs" = yes; then
2436           oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
2437           rmfiles="$rmfiles $dir/$oldobj"
2438         fi
2439         $show "$rm $rmfiles"
2440         $run $rm $rmfiles
2441         ;;
2442
2443       *)
2444         $show "$rm $rmfiles"
2445         $run $rm $rmfiles
2446         ;;
2447       esac
2448     done
2449     exit 0
2450     ;;
2451
2452   "")
2453     $echo "$modename: you must specify a MODE" 1>&2
2454     $echo "$generic_help" 1>&2
2455     exit 1
2456     ;;
2457   esac
2458
2459   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2460   $echo "$generic_help" 1>&2
2461   exit 1
2462 fi # test -z "$show_help"
2463
2464 # We need to display help for each of the modes.
2465 case "$mode" in
2466 "") $echo \
2467 "Usage: $modename [OPTION]... [MODE-ARG]...
2468
2469 Provide generalized library-building support services.
2470
2471     --config          show all configuration variables
2472     --debug           enable verbose shell tracing
2473 -n, --dry-run         display commands without modifying any files
2474     --features        display basic configuration information and exit
2475     --finish          same as \`--mode=finish'
2476     --help            display this help message and exit
2477     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
2478     --quiet           same as \`--silent'
2479     --silent          don't print informational messages
2480     --version         print version information
2481
2482 MODE must be one of the following:
2483
2484       compile         compile a source file into a libtool object
2485       execute         automatically set library path, then run a program
2486       finish          complete the installation of libtool libraries
2487       install         install libraries or executables
2488       link            create a library or an executable
2489       uninstall       remove libraries from an installed directory
2490
2491 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
2492 a more detailed description of MODE."
2493   exit 0
2494   ;;
2495
2496 compile)
2497   $echo \
2498 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2499
2500 Compile a source file into a libtool library object.
2501
2502 This mode accepts the following additional options:
2503
2504   -static           always build a \`.o' file suitable for static linking
2505
2506 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2507 from the given SOURCEFILE.
2508
2509 The output file name is determined by removing the directory component from
2510 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2511 library object suffix, \`.lo'."
2512   ;;
2513
2514 execute)
2515   $echo \
2516 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
2517
2518 Automatically set library path, then run a program.
2519
2520 This mode accepts the following additional options:
2521
2522   -dlopen FILE      add the directory containing FILE to the library path
2523
2524 This mode sets the library path environment variable according to \`-dlopen'
2525 flags.
2526
2527 If any of the ARGS are libtool executable wrappers, then they are translated
2528 into their corresponding uninstalled binary, and any of their required library
2529 directories are added to the library path.
2530
2531 Then, COMMAND is executed, with ARGS as arguments."
2532   ;;
2533
2534 finish)
2535   $echo \
2536 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
2537
2538 Complete the installation of libtool libraries.
2539
2540 Each LIBDIR is a directory that contains libtool libraries.
2541
2542 The commands that this mode executes may require superuser privileges.  Use
2543 the \`--dry-run' option if you just want to see what would be executed."
2544   ;;
2545
2546 install)
2547   $echo \
2548 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
2549
2550 Install executables or libraries.
2551
2552 INSTALL-COMMAND is the installation command.  The first component should be
2553 either the \`install' or \`cp' program.
2554
2555 The rest of the components are interpreted as arguments to that command (only
2556 BSD-compatible install options are recognized)."
2557   ;;
2558
2559 link)
2560   $echo \
2561 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
2562
2563 Link object files or libraries together to form another library, or to
2564 create an executable program.
2565
2566 LINK-COMMAND is a command using the C compiler that you would use to create
2567 a program from several object files.
2568
2569 The following components of LINK-COMMAND are treated specially:
2570
2571   -all-static       do not do any dynamic linking at all
2572   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2573   -dlpreopen FILE   link in FILE and add its symbols to dld_preloaded_symbols
2574   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2575   -LLIBDIR          search LIBDIR for required installed libraries
2576   -lNAME            OUTPUT-FILE requires the installed library libNAME
2577   -no-undefined     declare that a library does not refer to external symbols
2578   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2579   -release RELEASE  specify package release information
2580   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2581   -static           do not do any dynamic linking of libtool libraries
2582   -version-info CURRENT[:REVISION[:AGE]]
2583                     specify library version info [each variable defaults to 0]
2584
2585 All other options (arguments beginning with \`-') are ignored.
2586
2587 Every other argument is treated as a filename.  Files ending in \`.la' are
2588 treated as uninstalled libtool libraries, other files are standard or library
2589 object files.
2590
2591 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
2592 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
2593
2594 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2595 using \`ar' and \`ranlib', or on WIndows using \`lib'.
2596
2597 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2598 is created, otherwise an executable program is created."
2599   ;;
2600
2601 uninstall)
2602   $echo
2603 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2604
2605 Remove libraries from an installation directory.
2606
2607 RM is the name of the program to use to delete files associated with each FILE
2608 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2609 to RM.
2610
2611 If FILE is a libtool library, all the files associated with it are deleted.
2612 Otherwise, only FILE itself is deleted using RM."
2613   ;;
2614
2615 *)
2616   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2617   $echo "$help" 1>&2
2618   exit 1
2619   ;;
2620 esac
2621
2622 echo
2623 $echo "Try \`$modename --help' for more information about other modes."
2624
2625 exit 0
2626
2627 # Local Variables:
2628 # mode:shell-script
2629 # sh-indentation:2
2630 # End: