Logo AND Algorithmique Numérique Distribuée

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