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