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