Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Initial revision
[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: 159 $"
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       base_compile="$base_compile $arg"
979       shift
980       case $arg in
981       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
982         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
983         ;;
984       *) qarg=$arg ;;
985       esac
986       libtool_args="$libtool_args $qarg"
987
988       # If the previous option needs an argument, assign it.
989       if test -n "$prev"; then
990         case $prev in
991         output)
992           compile_command="$compile_command @OUTPUT@"
993           finalize_command="$finalize_command @OUTPUT@"
994           ;;
995         esac
996
997         case $prev in
998         dlfiles|dlprefiles)
999           if test "$preload" = no; then
1000             # Add the symbol object into the linking commands.
1001             compile_command="$compile_command @SYMFILE@"
1002             finalize_command="$finalize_command @SYMFILE@"
1003             preload=yes
1004           fi
1005           case $arg in
1006           *.la | *.lo) ;;  # We handle these cases below.
1007           force)
1008             if test "$dlself" = no; then
1009               dlself=needless
1010               export_dynamic=yes
1011             fi
1012             prev=
1013             continue
1014             ;;
1015           self)
1016             if test "$prev" = dlprefiles; then
1017               dlself=yes
1018             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1019               dlself=yes
1020             else
1021               dlself=needless
1022               export_dynamic=yes
1023             fi
1024             prev=
1025             continue
1026             ;;
1027           *)
1028             if test "$prev" = dlfiles; then
1029               dlfiles="$dlfiles $arg"
1030             else
1031               dlprefiles="$dlprefiles $arg"
1032             fi
1033             prev=
1034             continue
1035             ;;
1036           esac
1037           ;;
1038         expsyms)
1039           export_symbols="$arg"
1040           if test ! -f "$arg"; then
1041             $echo "$modename: symbol file \`$arg' does not exist"
1042             exit 1
1043           fi
1044           prev=
1045           continue
1046           ;;
1047         expsyms_regex)
1048           export_symbols_regex="$arg"
1049           prev=
1050           continue
1051           ;;
1052         inst_prefix)
1053           inst_prefix_dir="$arg"
1054           prev=
1055           continue
1056           ;;
1057         release)
1058           release="-$arg"
1059           prev=
1060           continue
1061           ;;
1062         objectlist)
1063           if test -f "$arg"; then
1064             save_arg=$arg
1065             moreargs=
1066             for fil in `cat $save_arg`
1067             do
1068 #             moreargs="$moreargs $fil"
1069               arg=$fil
1070               # A libtool-controlled object.
1071
1072               # Check to see that this really is a libtool object.
1073               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1074                 pic_object=
1075                 non_pic_object=
1076
1077                 # Read the .lo file
1078                 # If there is no directory component, then add one.
1079                 case $arg in
1080                 */* | *\\*) . $arg ;;
1081                 *) . ./$arg ;;
1082                 esac
1083
1084                 if test -z "$pic_object" || \
1085                    test -z "$non_pic_object" ||
1086                    test "$pic_object" = none && \
1087                    test "$non_pic_object" = none; then
1088                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1089                   exit 1
1090                 fi
1091
1092                 # Extract subdirectory from the argument.
1093                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1094                 if test "X$xdir" = "X$arg"; then
1095                   xdir=
1096                 else
1097                   xdir="$xdir/"
1098                 fi
1099
1100                 if test "$pic_object" != none; then
1101                   # Prepend the subdirectory the object is found in.
1102                   pic_object="$xdir$pic_object"
1103
1104                   if test "$prev" = dlfiles; then
1105                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1106                       dlfiles="$dlfiles $pic_object"
1107                       prev=
1108                       continue
1109                     else
1110                       # If libtool objects are unsupported, then we need to preload.
1111                       prev=dlprefiles
1112                     fi
1113                   fi
1114
1115                   # CHECK ME:  I think I busted this.  -Ossama
1116                   if test "$prev" = dlprefiles; then
1117                     # Preload the old-style object.
1118                     dlprefiles="$dlprefiles $pic_object"
1119                     prev=
1120                   fi
1121
1122                   # A PIC object.
1123                   libobjs="$libobjs $pic_object"
1124                   arg="$pic_object"
1125                 fi
1126
1127                 # Non-PIC object.
1128                 if test "$non_pic_object" != none; then
1129                   # Prepend the subdirectory the object is found in.
1130                   non_pic_object="$xdir$non_pic_object"
1131
1132                   # A standard non-PIC object
1133                   non_pic_objects="$non_pic_objects $non_pic_object"
1134                   if test -z "$pic_object" || test "$pic_object" = none ; then
1135                     arg="$non_pic_object"
1136                   fi
1137                 fi
1138               else
1139                 # Only an error if not doing a dry-run.
1140                 if test -z "$run"; then
1141                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1142                   exit 1
1143                 else
1144                   # Dry-run case.
1145
1146                   # Extract subdirectory from the argument.
1147                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1148                   if test "X$xdir" = "X$arg"; then
1149                     xdir=
1150                   else
1151                     xdir="$xdir/"
1152                   fi
1153
1154                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1155                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1156                   libobjs="$libobjs $pic_object"
1157                   non_pic_objects="$non_pic_objects $non_pic_object"
1158                 fi
1159               fi
1160             done
1161           else
1162             $echo "$modename: link input file \`$save_arg' does not exist"
1163             exit 1
1164           fi
1165           arg=$save_arg
1166           prev=
1167           continue
1168           ;;
1169         rpath | xrpath)
1170           # We need an absolute path.
1171           case $arg in
1172           [\\/]* | [A-Za-z]:[\\/]*) ;;
1173           *)
1174             $echo "$modename: only absolute run-paths are allowed" 1>&2
1175             exit 1
1176             ;;
1177           esac
1178           if test "$prev" = rpath; then
1179             case "$rpath " in
1180             *" $arg "*) ;;
1181             *) rpath="$rpath $arg" ;;
1182             esac
1183           else
1184             case "$xrpath " in
1185             *" $arg "*) ;;
1186             *) xrpath="$xrpath $arg" ;;
1187             esac
1188           fi
1189           prev=
1190           continue
1191           ;;
1192         xcompiler)
1193           compiler_flags="$compiler_flags $qarg"
1194           prev=
1195           compile_command="$compile_command $qarg"
1196           finalize_command="$finalize_command $qarg"
1197           continue
1198           ;;
1199         xlinker)
1200           linker_flags="$linker_flags $qarg"
1201           compiler_flags="$compiler_flags $wl$qarg"
1202           prev=
1203           compile_command="$compile_command $wl$qarg"
1204           finalize_command="$finalize_command $wl$qarg"
1205           continue
1206           ;;
1207         xcclinker)
1208           linker_flags="$linker_flags $qarg"
1209           compiler_flags="$compiler_flags $qarg"
1210           prev=
1211           compile_command="$compile_command $qarg"
1212           finalize_command="$finalize_command $qarg"
1213           continue
1214           ;;
1215         *)
1216           eval "$prev=\"\$arg\""
1217           prev=
1218           continue
1219           ;;
1220         esac
1221       fi # test -n "$prev"
1222
1223       prevarg="$arg"
1224
1225       case $arg in
1226       -all-static)
1227         if test -n "$link_static_flag"; then
1228           compile_command="$compile_command $link_static_flag"
1229           finalize_command="$finalize_command $link_static_flag"
1230         fi
1231         continue
1232         ;;
1233
1234       -allow-undefined)
1235         # FIXME: remove this flag sometime in the future.
1236         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1237         continue
1238         ;;
1239
1240       -avoid-version)
1241         avoid_version=yes
1242         continue
1243         ;;
1244
1245       -dlopen)
1246         prev=dlfiles
1247         continue
1248         ;;
1249
1250       -dlpreopen)
1251         prev=dlprefiles
1252         continue
1253         ;;
1254
1255       -export-dynamic)
1256         export_dynamic=yes
1257         continue
1258         ;;
1259
1260       -export-symbols | -export-symbols-regex)
1261         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1262           $echo "$modename: more than one -exported-symbols argument is not allowed"
1263           exit 1
1264         fi
1265         if test "X$arg" = "X-export-symbols"; then
1266           prev=expsyms
1267         else
1268           prev=expsyms_regex
1269         fi
1270         continue
1271         ;;
1272
1273       -inst-prefix-dir)
1274         prev=inst_prefix
1275         continue
1276         ;;
1277
1278       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1279       # so, if we see these flags be careful not to treat them like -L
1280       -L[A-Z][A-Z]*:*)
1281         case $with_gcc/$host in
1282         no/*-*-irix* | /*-*-irix*)
1283           compile_command="$compile_command $arg"
1284           finalize_command="$finalize_command $arg"
1285           ;;
1286         esac
1287         continue
1288         ;;
1289
1290       -L*)
1291         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1292         # We need an absolute path.
1293         case $dir in
1294         [\\/]* | [A-Za-z]:[\\/]*) ;;
1295         *)
1296           absdir=`cd "$dir" && pwd`
1297           if test -z "$absdir"; then
1298             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1299             exit 1
1300           fi
1301           dir="$absdir"
1302           ;;
1303         esac
1304         case "$deplibs " in
1305         *" -L$dir "*) ;;
1306         *)
1307           deplibs="$deplibs -L$dir"
1308           lib_search_path="$lib_search_path $dir"
1309           ;;
1310         esac
1311         case $host in
1312         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1313           case :$dllsearchpath: in
1314           *":$dir:"*) ;;
1315           *) dllsearchpath="$dllsearchpath:$dir";;
1316           esac
1317           ;;
1318         esac
1319         continue
1320         ;;
1321
1322       -l*)
1323         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1324           case $host in
1325           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1326             # These systems don't actually have a C or math library (as such)
1327             continue
1328             ;;
1329           *-*-mingw* | *-*-os2*)
1330             # These systems don't actually have a C library (as such)
1331             test "X$arg" = "X-lc" && continue
1332             ;;
1333           *-*-openbsd* | *-*-freebsd*)
1334             # Do not include libc due to us having libc/libc_r.
1335             test "X$arg" = "X-lc" && continue
1336             ;;
1337           *-*-rhapsody* | *-*-darwin1.[012])
1338             # Rhapsody C and math libraries are in the System framework
1339             deplibs="$deplibs -framework System"
1340             continue
1341           esac
1342         elif test "X$arg" = "X-lc_r"; then
1343          case $host in
1344          *-*-openbsd* | *-*-freebsd*)
1345            # Do not include libc_r directly, use -pthread flag.
1346            continue
1347            ;;
1348          esac
1349         fi
1350         deplibs="$deplibs $arg"
1351         continue
1352         ;;
1353
1354      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1355         deplibs="$deplibs $arg"
1356         continue
1357         ;;
1358
1359       -module)
1360         module=yes
1361         continue
1362         ;;
1363
1364       # gcc -m* arguments should be passed to the linker via $compiler_flags
1365       # in order to pass architecture information to the linker
1366       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1367       # but this is not reliable with gcc because gcc may use -mfoo to
1368       # select a different linker, different libraries, etc, while
1369       # -Wl,-mfoo simply passes -mfoo to the linker.
1370       -m*)
1371         # Unknown arguments in both finalize_command and compile_command need
1372         # to be aesthetically quoted because they are evaled later.
1373         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1374         case $arg in
1375         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1376           arg="\"$arg\""
1377           ;;
1378         esac
1379         compile_command="$compile_command $arg"
1380         finalize_command="$finalize_command $arg"
1381         if test "$with_gcc" = "yes" ; then
1382           compiler_flags="$compiler_flags $arg"
1383         fi
1384         continue
1385         ;;
1386
1387       -shrext)
1388         prev=shrext
1389         continue
1390         ;;
1391
1392       -no-fast-install)
1393         fast_install=no
1394         continue
1395         ;;
1396
1397       -no-install)
1398         case $host in
1399         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1400           # The PATH hackery in wrapper scripts is required on Windows
1401           # in order for the loader to find any dlls it needs.
1402           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1403           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1404           fast_install=no
1405           ;;
1406         *) no_install=yes ;;
1407         esac
1408         continue
1409         ;;
1410
1411       -no-undefined)
1412         allow_undefined=no
1413         continue
1414         ;;
1415
1416       -objectlist)
1417         prev=objectlist
1418         continue
1419         ;;
1420
1421       -o) prev=output ;;
1422
1423       -release)
1424         prev=release
1425         continue
1426         ;;
1427
1428       -rpath)
1429         prev=rpath
1430         continue
1431         ;;
1432
1433       -R)
1434         prev=xrpath
1435         continue
1436         ;;
1437
1438       -R*)
1439         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1440         # We need an absolute path.
1441         case $dir in
1442         [\\/]* | [A-Za-z]:[\\/]*) ;;
1443         *)
1444           $echo "$modename: only absolute run-paths are allowed" 1>&2
1445           exit 1
1446           ;;
1447         esac
1448         case "$xrpath " in
1449         *" $dir "*) ;;
1450         *) xrpath="$xrpath $dir" ;;
1451         esac
1452         continue
1453         ;;
1454
1455       -static)
1456         # The effects of -static are defined in a previous loop.
1457         # We used to do the same as -all-static on platforms that
1458         # didn't have a PIC flag, but the assumption that the effects
1459         # would be equivalent was wrong.  It would break on at least
1460         # Digital Unix and AIX.
1461         continue
1462         ;;
1463
1464       -thread-safe)
1465         thread_safe=yes
1466         continue
1467         ;;
1468
1469       -version-info)
1470         prev=vinfo
1471         continue
1472         ;;
1473       -version-number)
1474         prev=vinfo
1475         vinfo_number=yes
1476         continue
1477         ;;
1478
1479       -Wc,*)
1480         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1481         arg=
1482         save_ifs="$IFS"; IFS=','
1483         for flag in $args; do
1484           IFS="$save_ifs"
1485           case $flag in
1486             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1487             flag="\"$flag\""
1488             ;;
1489           esac
1490           arg="$arg $wl$flag"
1491           compiler_flags="$compiler_flags $flag"
1492         done
1493         IFS="$save_ifs"
1494         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1495         ;;
1496
1497       -Wl,*)
1498         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1499         arg=
1500         save_ifs="$IFS"; IFS=','
1501         for flag in $args; do
1502           IFS="$save_ifs"
1503           case $flag in
1504             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1505             flag="\"$flag\""
1506             ;;
1507           esac
1508           arg="$arg $wl$flag"
1509           compiler_flags="$compiler_flags $wl$flag"
1510           linker_flags="$linker_flags $flag"
1511         done
1512         IFS="$save_ifs"
1513         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1514         ;;
1515
1516       -Xcompiler)
1517         prev=xcompiler
1518         continue
1519         ;;
1520
1521       -Xlinker)
1522         prev=xlinker
1523         continue
1524         ;;
1525
1526       -XCClinker)
1527         prev=xcclinker
1528         continue
1529         ;;
1530
1531       # Some other compiler flag.
1532       -* | +*)
1533         # Unknown arguments in both finalize_command and compile_command need
1534         # to be aesthetically quoted because they are evaled later.
1535         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1536         case $arg in
1537         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1538           arg="\"$arg\""
1539           ;;
1540         esac
1541         ;;
1542
1543       *.$objext)
1544         # A standard object.
1545         objs="$objs $arg"
1546         ;;
1547
1548       *.lo)
1549         # A libtool-controlled object.
1550
1551         # Check to see that this really is a libtool object.
1552         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1553           pic_object=
1554           non_pic_object=
1555
1556           # Read the .lo file
1557           # If there is no directory component, then add one.
1558           case $arg in
1559           */* | *\\*) . $arg ;;
1560           *) . ./$arg ;;
1561           esac
1562
1563           if test -z "$pic_object" || \
1564              test -z "$non_pic_object" ||
1565              test "$pic_object" = none && \
1566              test "$non_pic_object" = none; then
1567             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1568             exit 1
1569           fi
1570
1571           # Extract subdirectory from the argument.
1572           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1573           if test "X$xdir" = "X$arg"; then
1574             xdir=
1575           else
1576             xdir="$xdir/"
1577           fi
1578
1579           if test "$pic_object" != none; then
1580             # Prepend the subdirectory the object is found in.
1581             pic_object="$xdir$pic_object"
1582
1583             if test "$prev" = dlfiles; then
1584               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1585                 dlfiles="$dlfiles $pic_object"
1586                 prev=
1587                 continue
1588               else
1589                 # If libtool objects are unsupported, then we need to preload.
1590                 prev=dlprefiles
1591               fi
1592             fi
1593
1594             # CHECK ME:  I think I busted this.  -Ossama
1595             if test "$prev" = dlprefiles; then
1596               # Preload the old-style object.
1597               dlprefiles="$dlprefiles $pic_object"
1598               prev=
1599             fi
1600
1601             # A PIC object.
1602             libobjs="$libobjs $pic_object"
1603             arg="$pic_object"
1604           fi
1605
1606           # Non-PIC object.
1607           if test "$non_pic_object" != none; then
1608             # Prepend the subdirectory the object is found in.
1609             non_pic_object="$xdir$non_pic_object"
1610
1611             # A standard non-PIC object
1612             non_pic_objects="$non_pic_objects $non_pic_object"
1613             if test -z "$pic_object" || test "$pic_object" = none ; then
1614               arg="$non_pic_object"
1615             fi
1616           fi
1617         else
1618           # Only an error if not doing a dry-run.
1619           if test -z "$run"; then
1620             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1621             exit 1
1622           else
1623             # Dry-run case.
1624
1625             # Extract subdirectory from the argument.
1626             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1627             if test "X$xdir" = "X$arg"; then
1628               xdir=
1629             else
1630               xdir="$xdir/"
1631             fi
1632
1633             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1634             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1635             libobjs="$libobjs $pic_object"
1636             non_pic_objects="$non_pic_objects $non_pic_object"
1637           fi
1638         fi
1639         ;;
1640
1641       *.$libext)
1642         # An archive.
1643         deplibs="$deplibs $arg"
1644         old_deplibs="$old_deplibs $arg"
1645         continue
1646         ;;
1647
1648       *.la)
1649         # A libtool-controlled library.
1650
1651         if test "$prev" = dlfiles; then
1652           # This library was specified with -dlopen.
1653           dlfiles="$dlfiles $arg"
1654           prev=
1655         elif test "$prev" = dlprefiles; then
1656           # The library was specified with -dlpreopen.
1657           dlprefiles="$dlprefiles $arg"
1658           prev=
1659         else
1660           deplibs="$deplibs $arg"
1661         fi
1662         continue
1663         ;;
1664
1665       # Some other compiler argument.
1666       *)
1667         # Unknown arguments in both finalize_command and compile_command need
1668         # to be aesthetically quoted because they are evaled later.
1669         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1670         case $arg in
1671         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1672           arg="\"$arg\""
1673           ;;
1674         esac
1675         ;;
1676       esac # arg
1677
1678       # Now actually substitute the argument into the commands.
1679       if test -n "$arg"; then
1680         compile_command="$compile_command $arg"
1681         finalize_command="$finalize_command $arg"
1682       fi
1683     done # argument parsing loop
1684
1685     if test -n "$prev"; then
1686       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1687       $echo "$help" 1>&2
1688       exit 1
1689     fi
1690
1691     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1692       eval arg=\"$export_dynamic_flag_spec\"
1693       compile_command="$compile_command $arg"
1694       finalize_command="$finalize_command $arg"
1695     fi
1696
1697     oldlibs=
1698     # calculate the name of the file, without its directory
1699     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1700     libobjs_save="$libobjs"
1701
1702     if test -n "$shlibpath_var"; then
1703       # get the directories listed in $shlibpath_var
1704       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1705     else
1706       shlib_search_path=
1707     fi
1708     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1709     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1710
1711     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1712     if test "X$output_objdir" = "X$output"; then
1713       output_objdir="$objdir"
1714     else
1715       output_objdir="$output_objdir/$objdir"
1716     fi
1717     # Create the object directory.
1718     if test ! -d "$output_objdir"; then
1719       $show "$mkdir $output_objdir"
1720       $run $mkdir $output_objdir
1721       status=$?
1722       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1723         exit $status
1724       fi
1725     fi
1726
1727     # Determine the type of output
1728     case $output in
1729     "")
1730       $echo "$modename: you must specify an output file" 1>&2
1731       $echo "$help" 1>&2
1732       exit 1
1733       ;;
1734     *.$libext) linkmode=oldlib ;;
1735     *.lo | *.$objext) linkmode=obj ;;
1736     *.la) linkmode=lib ;;
1737     *) linkmode=prog ;; # Anything else should be a program.
1738     esac
1739
1740     case $host in
1741     *cygwin* | *mingw* | *pw32*)
1742       # don't eliminate duplcations in $postdeps and $predeps
1743       duplicate_compiler_generated_deps=yes
1744       ;;
1745     *)
1746       duplicate_compiler_generated_deps=$duplicate_deps
1747       ;;
1748     esac
1749     specialdeplibs=
1750
1751     libs=
1752     # Find all interdependent deplibs by searching for libraries
1753     # that are linked more than once (e.g. -la -lb -la)
1754     for deplib in $deplibs; do
1755       if test "X$duplicate_deps" = "Xyes" ; then
1756         case "$libs " in
1757         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1758         esac
1759       fi
1760       libs="$libs $deplib"
1761     done
1762
1763     if test "$linkmode" = lib; then
1764       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1765
1766       # Compute libraries that are listed more than once in $predeps
1767       # $postdeps and mark them as special (i.e., whose duplicates are
1768       # not to be eliminated).
1769       pre_post_deps=
1770       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1771         for pre_post_dep in $predeps $postdeps; do
1772           case "$pre_post_deps " in
1773           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1774           esac
1775           pre_post_deps="$pre_post_deps $pre_post_dep"
1776         done
1777       fi
1778       pre_post_deps=
1779     fi
1780
1781     deplibs=
1782     newdependency_libs=
1783     newlib_search_path=
1784     need_relink=no # whether we're linking any uninstalled libtool libraries
1785     notinst_deplibs= # not-installed libtool libraries
1786     notinst_path= # paths that contain not-installed libtool libraries
1787     case $linkmode in
1788     lib)
1789         passes="conv link"
1790         for file in $dlfiles $dlprefiles; do
1791           case $file in
1792           *.la) ;;
1793           *)
1794             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1795             exit 1
1796             ;;
1797           esac
1798         done
1799         ;;
1800     prog)
1801         compile_deplibs=
1802         finalize_deplibs=
1803         alldeplibs=no
1804         newdlfiles=
1805         newdlprefiles=
1806         passes="conv scan dlopen dlpreopen link"
1807         ;;
1808     *)  passes="conv"
1809         ;;
1810     esac
1811     for pass in $passes; do
1812       if test "$linkmode,$pass" = "lib,link" ||
1813          test "$linkmode,$pass" = "prog,scan"; then
1814         libs="$deplibs"
1815         deplibs=
1816       fi
1817       if test "$linkmode" = prog; then
1818         case $pass in
1819         dlopen) libs="$dlfiles" ;;
1820         dlpreopen) libs="$dlprefiles" ;;
1821         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1822         esac
1823       fi
1824       if test "$pass" = dlopen; then
1825         # Collect dlpreopened libraries
1826         save_deplibs="$deplibs"
1827         deplibs=
1828       fi
1829       for deplib in $libs; do
1830         lib=
1831         found=no
1832         case $deplib in
1833         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1834           if test "$linkmode,$pass" = "prog,link"; then
1835             compile_deplibs="$deplib $compile_deplibs"
1836             finalize_deplibs="$deplib $finalize_deplibs"
1837           else
1838             deplibs="$deplib $deplibs"
1839           fi
1840           continue
1841           ;;
1842         -l*)
1843           if test "$linkmode" != lib && test "$linkmode" != prog; then
1844             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1845             continue
1846           fi
1847           if test "$pass" = conv; then
1848             deplibs="$deplib $deplibs"
1849             continue
1850           fi
1851           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1852           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1853             for search_ext in .la $shrext .so .a; do
1854               # Search the libtool library
1855               lib="$searchdir/lib${name}${search_ext}"
1856               if test -f "$lib"; then
1857                 if test "$search_ext" = ".la"; then
1858                   found=yes
1859                 else
1860                   found=no
1861                 fi
1862                 break 2
1863               fi
1864             done
1865           done
1866           if test "$found" != yes; then
1867             # deplib doesn't seem to be a libtool library
1868             if test "$linkmode,$pass" = "prog,link"; then
1869               compile_deplibs="$deplib $compile_deplibs"
1870               finalize_deplibs="$deplib $finalize_deplibs"
1871             else
1872               deplibs="$deplib $deplibs"
1873               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1874             fi
1875             continue
1876           else # deplib is a libtool library
1877             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1878             # We need to do some special things here, and not later.
1879             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1880               case " $predeps $postdeps " in
1881               *" $deplib "*)
1882                 if (${SED} -e '2q' $lib |
1883                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1884                   library_names=
1885                   old_library=
1886                   case $lib in
1887                   */* | *\\*) . $lib ;;
1888                   *) . ./$lib ;;
1889                   esac
1890                   for l in $old_library $library_names; do
1891                     ll="$l"
1892                   done
1893                   if test "X$ll" = "X$old_library" ; then # only static version available
1894                     found=no
1895                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1896                     test "X$ladir" = "X$lib" && ladir="."
1897                     lib=$ladir/$old_library
1898                     if test "$linkmode,$pass" = "prog,link"; then
1899                       compile_deplibs="$deplib $compile_deplibs"
1900                       finalize_deplibs="$deplib $finalize_deplibs"
1901                     else
1902                       deplibs="$deplib $deplibs"
1903                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1904                     fi
1905                     continue
1906                   fi
1907                 fi
1908                 ;;
1909               *) ;;
1910               esac
1911             fi
1912           fi
1913           ;; # -l
1914         -L*)
1915           case $linkmode in
1916           lib)
1917             deplibs="$deplib $deplibs"
1918             test "$pass" = conv && continue
1919             newdependency_libs="$deplib $newdependency_libs"
1920             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1921             ;;
1922           prog)
1923             if test "$pass" = conv; then
1924               deplibs="$deplib $deplibs"
1925               continue
1926             fi
1927             if test "$pass" = scan; then
1928               deplibs="$deplib $deplibs"
1929               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1930             else
1931               compile_deplibs="$deplib $compile_deplibs"
1932               finalize_deplibs="$deplib $finalize_deplibs"
1933             fi
1934             ;;
1935           *)
1936             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1937             ;;
1938           esac # linkmode
1939           continue
1940           ;; # -L
1941         -R*)
1942           if test "$pass" = link; then
1943             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1944             # Make sure the xrpath contains only unique directories.
1945             case "$xrpath " in
1946             *" $dir "*) ;;
1947             *) xrpath="$xrpath $dir" ;;
1948             esac
1949           fi
1950           deplibs="$deplib $deplibs"
1951           continue
1952           ;;
1953         *.la) lib="$deplib" ;;
1954         *.$libext)
1955           if test "$pass" = conv; then
1956             deplibs="$deplib $deplibs"
1957             continue
1958           fi
1959           case $linkmode in
1960           lib)
1961             if test "$deplibs_check_method" != pass_all; then
1962               $echo
1963               $echo "*** Warning: Trying to link with static lib archive $deplib."
1964               $echo "*** I have the capability to make that library automatically link in when"
1965               $echo "*** you link to this library.  But I can only do this if you have a"
1966               $echo "*** shared version of the library, which you do not appear to have"
1967               $echo "*** because the file extensions .$libext of this argument makes me believe"
1968               $echo "*** that it is just a static archive that I should not used here."
1969             else
1970               $echo
1971               $echo "*** Warning: Linking the shared library $output against the"
1972               $echo "*** static library $deplib is not portable!"
1973               deplibs="$deplib $deplibs"
1974             fi
1975             continue
1976             ;;
1977           prog)
1978             if test "$pass" != link; then
1979               deplibs="$deplib $deplibs"
1980             else
1981               compile_deplibs="$deplib $compile_deplibs"
1982               finalize_deplibs="$deplib $finalize_deplibs"
1983             fi
1984             continue
1985             ;;
1986           esac # linkmode
1987           ;; # *.$libext
1988         *.lo | *.$objext)
1989           if test "$pass" = conv; then
1990             deplibs="$deplib $deplibs"
1991           elif test "$linkmode" = prog; then
1992             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1993               # If there is no dlopen support or we're linking statically,
1994               # we need to preload.
1995               newdlprefiles="$newdlprefiles $deplib"
1996               compile_deplibs="$deplib $compile_deplibs"
1997               finalize_deplibs="$deplib $finalize_deplibs"
1998             else
1999               newdlfiles="$newdlfiles $deplib"
2000             fi
2001           fi
2002           continue
2003           ;;
2004         %DEPLIBS%)
2005           alldeplibs=yes
2006           continue
2007           ;;
2008         esac # case $deplib
2009         if test "$found" = yes || test -f "$lib"; then :
2010         else
2011           $echo "$modename: cannot find the library \`$lib'" 1>&2
2012           exit 1
2013         fi
2014
2015         # Check to see that this really is a libtool archive.
2016         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2017         else
2018           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2019           exit 1
2020         fi
2021
2022         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2023         test "X$ladir" = "X$lib" && ladir="."
2024
2025         dlname=
2026         dlopen=
2027         dlpreopen=
2028         libdir=
2029         library_names=
2030         old_library=
2031         # If the library was installed with an old release of libtool,
2032         # it will not redefine variables installed, or shouldnotlink
2033         installed=yes
2034         shouldnotlink=no
2035
2036         # Read the .la file
2037         case $lib in
2038         */* | *\\*) . $lib ;;
2039         *) . ./$lib ;;
2040         esac
2041
2042         if test "$linkmode,$pass" = "lib,link" ||
2043            test "$linkmode,$pass" = "prog,scan" ||
2044            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2045           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2046           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2047         fi
2048
2049         if test "$pass" = conv; then
2050           # Only check for convenience libraries
2051           deplibs="$lib $deplibs"
2052           if test -z "$libdir"; then
2053             if test -z "$old_library"; then
2054               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2055               exit 1
2056             fi
2057             # It is a libtool convenience library, so add in its objects.
2058             convenience="$convenience $ladir/$objdir/$old_library"
2059             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2060             tmp_libs=
2061             for deplib in $dependency_libs; do
2062               deplibs="$deplib $deplibs"
2063               if test "X$duplicate_deps" = "Xyes" ; then
2064                 case "$tmp_libs " in
2065                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2066                 esac
2067               fi
2068               tmp_libs="$tmp_libs $deplib"
2069             done
2070           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2071             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2072             exit 1
2073           fi
2074           continue
2075         fi # $pass = conv
2076
2077     
2078         # Get the name of the library we link against.
2079         linklib=
2080         for l in $old_library $library_names; do
2081           linklib="$l"
2082         done
2083         if test -z "$linklib"; then
2084           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2085           exit 1
2086         fi
2087
2088         # This library was specified with -dlopen.
2089         if test "$pass" = dlopen; then
2090           if test -z "$libdir"; then
2091             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2092             exit 1
2093           fi
2094           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2095             # If there is no dlname, no dlopen support or we're linking
2096             # statically, we need to preload.  We also need to preload any
2097             # dependent libraries so libltdl's deplib preloader doesn't
2098             # bomb out in the load deplibs phase.
2099             dlprefiles="$dlprefiles $lib $dependency_libs"
2100           else
2101             newdlfiles="$newdlfiles $lib"
2102           fi
2103           continue
2104         fi # $pass = dlopen
2105
2106         # We need an absolute path.
2107         case $ladir in
2108         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2109         *)
2110           abs_ladir=`cd "$ladir" && pwd`
2111           if test -z "$abs_ladir"; then
2112             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2113             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2114             abs_ladir="$ladir"
2115           fi
2116           ;;
2117         esac
2118         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2119
2120         # Find the relevant object directory and library name.
2121         if test "X$installed" = Xyes; then
2122           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2123             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2124             dir="$ladir"
2125             absdir="$abs_ladir"
2126             libdir="$abs_ladir"
2127           else
2128             dir="$libdir"
2129             absdir="$libdir"
2130           fi
2131         else
2132           dir="$ladir/$objdir"
2133           absdir="$abs_ladir/$objdir"
2134           # Remove this search path later
2135           notinst_path="$notinst_path $abs_ladir"
2136         fi # $installed = yes
2137         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2138
2139         # This library was specified with -dlpreopen.
2140         if test "$pass" = dlpreopen; then
2141           if test -z "$libdir"; then
2142             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2143             exit 1
2144           fi
2145           # Prefer using a static library (so that no silly _DYNAMIC symbols
2146           # are required to link).
2147           if test -n "$old_library"; then
2148             newdlprefiles="$newdlprefiles $dir/$old_library"
2149           # Otherwise, use the dlname, so that lt_dlopen finds it.
2150           elif test -n "$dlname"; then
2151             newdlprefiles="$newdlprefiles $dir/$dlname"
2152           else
2153             newdlprefiles="$newdlprefiles $dir/$linklib"
2154           fi
2155         fi # $pass = dlpreopen
2156
2157         if test -z "$libdir"; then
2158           # Link the convenience library
2159           if test "$linkmode" = lib; then
2160             deplibs="$dir/$old_library $deplibs"
2161           elif test "$linkmode,$pass" = "prog,link"; then
2162             compile_deplibs="$dir/$old_library $compile_deplibs"
2163             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2164           else
2165             deplibs="$lib $deplibs" # used for prog,scan pass
2166           fi
2167           continue
2168         fi
2169
2170     
2171         if test "$linkmode" = prog && test "$pass" != link; then
2172           newlib_search_path="$newlib_search_path $ladir"
2173           deplibs="$lib $deplibs"
2174
2175           linkalldeplibs=no
2176           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2177              test "$build_libtool_libs" = no; then
2178             linkalldeplibs=yes
2179           fi
2180
2181           tmp_libs=
2182           for deplib in $dependency_libs; do
2183             case $deplib in
2184             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2185             esac
2186             # Need to link against all dependency_libs?
2187             if test "$linkalldeplibs" = yes; then
2188               deplibs="$deplib $deplibs"
2189             else
2190               # Need to hardcode shared library paths
2191               # or/and link against static libraries
2192               newdependency_libs="$deplib $newdependency_libs"
2193             fi
2194             if test "X$duplicate_deps" = "Xyes" ; then
2195               case "$tmp_libs " in
2196               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2197               esac
2198             fi
2199             tmp_libs="$tmp_libs $deplib"
2200           done # for deplib
2201           continue
2202         fi # $linkmode = prog...
2203
2204         if test "$linkmode,$pass" = "prog,link"; then
2205           if test -n "$library_names" &&
2206              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2207             # We need to hardcode the library path
2208             if test -n "$shlibpath_var"; then
2209               # Make sure the rpath contains only unique directories.
2210               case "$temp_rpath " in
2211               *" $dir "*) ;;
2212               *" $absdir "*) ;;
2213               *) temp_rpath="$temp_rpath $dir" ;;
2214               esac
2215             fi
2216
2217             # Hardcode the library path.
2218             # Skip directories that are in the system default run-time
2219             # search path.
2220             case " $sys_lib_dlsearch_path " in
2221             *" $absdir "*) ;;
2222             *)
2223               case "$compile_rpath " in
2224               *" $absdir "*) ;;
2225               *) compile_rpath="$compile_rpath $absdir"
2226               esac
2227               ;;
2228             esac
2229             case " $sys_lib_dlsearch_path " in
2230             *" $libdir "*) ;;
2231             *)
2232               case "$finalize_rpath " in
2233               *" $libdir "*) ;;
2234               *) finalize_rpath="$finalize_rpath $libdir"
2235               esac
2236               ;;
2237             esac
2238           fi # $linkmode,$pass = prog,link...
2239
2240           if test "$alldeplibs" = yes &&
2241              { test "$deplibs_check_method" = pass_all ||
2242                { test "$build_libtool_libs" = yes &&
2243                  test -n "$library_names"; }; }; then
2244             # We only need to search for static libraries
2245             continue
2246           fi
2247         fi
2248
2249         link_static=no # Whether the deplib will be linked statically
2250         if test -n "$library_names" &&
2251            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2252           if test "$installed" = no; then
2253             notinst_deplibs="$notinst_deplibs $lib"
2254             need_relink=yes
2255           fi
2256           # This is a shared library
2257         
2258       # Warn about portability, can't link against -module's on some systems (darwin)
2259       if test "$shouldnotlink" = yes && test "$pass" = link ; then
2260             $echo
2261             if test "$linkmode" = prog; then
2262               $echo "*** Warning: Linking the executable $output against the loadable module"
2263             else
2264               $echo "*** Warning: Linking the shared library $output against the loadable module"
2265             fi
2266             $echo "*** $linklib is not portable!"    
2267       fi          
2268           if test "$linkmode" = lib &&
2269              test "$hardcode_into_libs" = yes; then
2270             # Hardcode the library path.
2271             # Skip directories that are in the system default run-time
2272             # search path.
2273             case " $sys_lib_dlsearch_path " in
2274             *" $absdir "*) ;;
2275             *)
2276               case "$compile_rpath " in
2277               *" $absdir "*) ;;
2278               *) compile_rpath="$compile_rpath $absdir"
2279               esac
2280               ;;
2281             esac
2282             case " $sys_lib_dlsearch_path " in
2283             *" $libdir "*) ;;
2284             *)
2285               case "$finalize_rpath " in
2286               *" $libdir "*) ;;
2287               *) finalize_rpath="$finalize_rpath $libdir"
2288               esac
2289               ;;
2290             esac
2291           fi
2292
2293           if test -n "$old_archive_from_expsyms_cmds"; then
2294             # figure out the soname
2295             set dummy $library_names
2296             realname="$2"
2297             shift; shift
2298             libname=`eval \\$echo \"$libname_spec\"`
2299             # use dlname if we got it. it's perfectly good, no?
2300             if test -n "$dlname"; then
2301               soname="$dlname"
2302             elif test -n "$soname_spec"; then
2303               # bleh windows
2304               case $host in
2305               *cygwin* | mingw*)
2306                 major=`expr $current - $age`
2307                 versuffix="-$major"
2308                 ;;
2309               esac
2310               eval soname=\"$soname_spec\"
2311             else
2312               soname="$realname"
2313             fi
2314
2315             # Make a new name for the extract_expsyms_cmds to use
2316             soroot="$soname"
2317             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2318             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2319
2320             # If the library has no export list, then create one now
2321             if test -f "$output_objdir/$soname-def"; then :
2322             else
2323               $show "extracting exported symbol list from \`$soname'"
2324               save_ifs="$IFS"; IFS='~'
2325               eval cmds=\"$extract_expsyms_cmds\"
2326               for cmd in $cmds; do
2327                 IFS="$save_ifs"
2328                 $show "$cmd"
2329                 $run eval "$cmd" || exit $?
2330               done
2331               IFS="$save_ifs"
2332             fi
2333
2334             # Create $newlib
2335             if test -f "$output_objdir/$newlib"; then :; else
2336               $show "generating import library for \`$soname'"
2337               save_ifs="$IFS"; IFS='~'
2338               eval cmds=\"$old_archive_from_expsyms_cmds\"
2339               for cmd in $cmds; do
2340                 IFS="$save_ifs"
2341                 $show "$cmd"
2342                 $run eval "$cmd" || exit $?
2343               done
2344               IFS="$save_ifs"
2345             fi
2346             # make sure the library variables are pointing to the new library
2347             dir=$output_objdir
2348             linklib=$newlib
2349           fi # test -n "$old_archive_from_expsyms_cmds"
2350
2351           if test "$linkmode" = prog || test "$mode" != relink; then
2352             add_shlibpath=
2353             add_dir=
2354             add=
2355             lib_linked=yes
2356             case $hardcode_action in
2357             immediate | unsupported)
2358               if test "$hardcode_direct" = no; then
2359                 add="$dir/$linklib"
2360                 case $host in
2361                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2362                   *-*-darwin* )
2363                     # if the lib is a module then we can not link against it, someone
2364                     # is ignoring the new warnings I added
2365                     if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
2366                       $echo "** Warning, lib $linklib is a module, not a shared library"
2367                       if test -z "$old_library" ; then
2368                         $echo
2369                         $echo "** And there doesn't seem to be a static archive available"
2370                         $echo "** The link will probably fail, sorry"
2371                       else
2372                         add="$dir/$old_library"
2373                       fi 
2374                     fi
2375                 esac
2376               elif test "$hardcode_minus_L" = no; then
2377                 case $host in
2378                 *-*-sunos*) add_shlibpath="$dir" ;;
2379                 esac
2380                 add_dir="-L$dir"
2381                 add="-l$name"
2382               elif test "$hardcode_shlibpath_var" = no; then
2383                 add_shlibpath="$dir"
2384                 add="-l$name"
2385               else
2386                 lib_linked=no
2387               fi
2388               ;;
2389             relink)
2390               if test "$hardcode_direct" = yes; then
2391                 add="$dir/$linklib"
2392               elif test "$hardcode_minus_L" = yes; then
2393                 add_dir="-L$dir"
2394                 # Try looking first in the location we're being installed to.
2395                 if test -n "$inst_prefix_dir"; then
2396                   case "$libdir" in
2397                     [\\/]*)
2398                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2399                       ;;
2400                   esac
2401                 fi
2402                 add="-l$name"
2403               elif test "$hardcode_shlibpath_var" = yes; then
2404                 add_shlibpath="$dir"
2405                 add="-l$name"
2406               else
2407                 lib_linked=no
2408               fi
2409               ;;
2410             *) lib_linked=no ;;
2411             esac
2412
2413             if test "$lib_linked" != yes; then
2414               $echo "$modename: configuration error: unsupported hardcode properties"
2415               exit 1
2416             fi
2417
2418             if test -n "$add_shlibpath"; then
2419               case :$compile_shlibpath: in
2420               *":$add_shlibpath:"*) ;;
2421               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2422               esac
2423             fi
2424             if test "$linkmode" = prog; then
2425               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2426               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2427             else
2428               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2429               test -n "$add" && deplibs="$add $deplibs"
2430               if test "$hardcode_direct" != yes && \
2431                  test "$hardcode_minus_L" != yes && \
2432                  test "$hardcode_shlibpath_var" = yes; then
2433                 case :$finalize_shlibpath: in
2434                 *":$libdir:"*) ;;
2435                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2436                 esac
2437               fi
2438             fi
2439           fi
2440
2441           if test "$linkmode" = prog || test "$mode" = relink; then
2442             add_shlibpath=
2443             add_dir=
2444             add=
2445             # Finalize command for both is simple: just hardcode it.
2446             if test "$hardcode_direct" = yes; then
2447               add="$libdir/$linklib"
2448             elif test "$hardcode_minus_L" = yes; then
2449               add_dir="-L$libdir"
2450               add="-l$name"
2451             elif test "$hardcode_shlibpath_var" = yes; then
2452               case :$finalize_shlibpath: in
2453               *":$libdir:"*) ;;
2454               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2455               esac
2456               add="-l$name"
2457             elif test "$hardcode_automatic" = yes; then
2458               if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
2459                 add="$inst_prefix_dir$libdir/$linklib"
2460               else
2461                 add="$libdir/$linklib"
2462               fi
2463             else
2464               # We cannot seem to hardcode it, guess we'll fake it.
2465               add_dir="-L$libdir"
2466               # Try looking first in the location we're being installed to.
2467               if test -n "$inst_prefix_dir"; then
2468                 case "$libdir" in
2469                   [\\/]*)
2470                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2471                     ;;
2472                 esac
2473               fi
2474               add="-l$name"
2475             fi
2476
2477             if test "$linkmode" = prog; then
2478               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2479               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2480             else
2481               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2482               test -n "$add" && deplibs="$add $deplibs"
2483             fi
2484           fi
2485         elif test "$linkmode" = prog; then
2486           # Here we assume that one of hardcode_direct or hardcode_minus_L
2487           # is not unsupported.  This is valid on all known static and
2488           # shared platforms.
2489           if test "$hardcode_direct" != unsupported; then
2490             test -n "$old_library" && linklib="$old_library"
2491             compile_deplibs="$dir/$linklib $compile_deplibs"
2492             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2493           else
2494             compile_deplibs="-l$name -L$dir $compile_deplibs"
2495             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2496           fi
2497         elif test "$build_libtool_libs" = yes; then
2498           # Not a shared library
2499           if test "$deplibs_check_method" != pass_all; then
2500             # We're trying link a shared library against a static one
2501             # but the system doesn't support it.
2502
2503             # Just print a warning and add the library to dependency_libs so
2504             # that the program can be linked against the static library.
2505             $echo
2506             $echo "*** Warning: This system can not link to static lib archive $lib."
2507             $echo "*** I have the capability to make that library automatically link in when"
2508             $echo "*** you link to this library.  But I can only do this if you have a"
2509             $echo "*** shared version of the library, which you do not appear to have."
2510             if test "$module" = yes; then
2511               $echo "*** But as you try to build a module library, libtool will still create "
2512               $echo "*** a static module, that should work as long as the dlopening application"
2513               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2514               if test -z "$global_symbol_pipe"; then
2515                 $echo
2516                 $echo "*** However, this would only work if libtool was able to extract symbol"
2517                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2518                 $echo "*** not find such a program.  So, this module is probably useless."
2519                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2520               fi
2521               if test "$build_old_libs" = no; then
2522                 build_libtool_libs=module
2523                 build_old_libs=yes
2524               else
2525                 build_libtool_libs=no
2526               fi
2527             fi
2528           else
2529             convenience="$convenience $dir/$old_library"
2530             old_convenience="$old_convenience $dir/$old_library"
2531             deplibs="$dir/$old_library $deplibs"
2532             link_static=yes
2533           fi
2534         fi # link shared/static library?
2535
2536         if test "$linkmode" = lib; then
2537           if test -n "$dependency_libs" &&
2538              { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
2539                test "$link_static" = yes; }; then
2540             # Extract -R from dependency_libs
2541             temp_deplibs=
2542             for libdir in $dependency_libs; do
2543               case $libdir in
2544               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2545                    case " $xrpath " in
2546                    *" $temp_xrpath "*) ;;
2547                    *) xrpath="$xrpath $temp_xrpath";;
2548                    esac;;
2549               *) temp_deplibs="$temp_deplibs $libdir";;
2550               esac
2551             done
2552             dependency_libs="$temp_deplibs"
2553           fi
2554
2555           newlib_search_path="$newlib_search_path $absdir"
2556           # Link against this library
2557           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2558           # ... and its dependency_libs
2559           tmp_libs=
2560           for deplib in $dependency_libs; do
2561             newdependency_libs="$deplib $newdependency_libs"
2562             if test "X$duplicate_deps" = "Xyes" ; then
2563               case "$tmp_libs " in
2564               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2565               esac
2566             fi
2567             tmp_libs="$tmp_libs $deplib"
2568           done
2569
2570           if test "$link_all_deplibs" != no; then
2571             # Add the search paths of all dependency libraries
2572             for deplib in $dependency_libs; do
2573               case $deplib in
2574               -L*) path="$deplib" ;;
2575               *.la)
2576                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2577                 test "X$dir" = "X$deplib" && dir="."
2578                 # We need an absolute path.
2579                 case $dir in
2580                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2581                 *)
2582                   absdir=`cd "$dir" && pwd`
2583                   if test -z "$absdir"; then
2584                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2585                     absdir="$dir"
2586                   fi
2587                   ;;
2588                 esac
2589                 if grep "^installed=no" $deplib > /dev/null; then
2590                   path="$absdir/$objdir"
2591                 else
2592                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2593                   if test -z "$libdir"; then
2594                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2595                     exit 1
2596                   fi
2597                   if test "$absdir" != "$libdir"; then
2598                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2599                   fi
2600                   path="$absdir"
2601                 fi
2602                 depdepl=
2603                 case $host in
2604                 *-*-darwin*)
2605                   # we do not want to link against static libs, but need to link against shared
2606                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2607                   if test -n "$deplibrary_names" ; then
2608                     for tmp in $deplibrary_names ; do
2609                       depdepl=$tmp
2610                     done
2611                     if test -f "$path/$depdepl" ; then
2612                       depdepl="$path/$depdepl"
2613                    fi
2614                     # do not add paths which are already there
2615                     case " $newlib_search_path " in
2616                     *" $path "*) ;;
2617                     *) newlib_search_path="$newlib_search_path $path";;
2618                     esac
2619                     path=""
2620                   fi
2621                   ;;
2622                 *)
2623                 path="-L$path"
2624                 ;;
2625                 esac 
2626                 
2627                 ;;
2628                   -l*)
2629                 case $host in
2630                 *-*-darwin*)
2631                  # Again, we only want to link against shared libraries
2632                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2633                  for tmp in $newlib_search_path ; do
2634                      if test -f "$tmp/lib$tmp_libs.dylib" ; then
2635                        eval depdepl="$tmp/lib$tmp_libs.dylib"
2636                        break
2637                      fi  
2638          done
2639          path=""
2640                   ;;
2641                 *) continue ;;
2642                 esac              
2643                 ;;
2644               *) continue ;;
2645               esac
2646               case " $deplibs " in
2647               *" $depdepl "*) ;;
2648               *) deplibs="$deplibs $depdepl" ;;
2649               esac            
2650               case " $deplibs " in
2651               *" $path "*) ;;
2652               *) deplibs="$deplibs $path" ;;
2653               esac
2654             done
2655           fi # link_all_deplibs != no
2656         fi # linkmode = lib
2657       done # for deplib in $libs
2658       dependency_libs="$newdependency_libs"
2659       if test "$pass" = dlpreopen; then
2660         # Link the dlpreopened libraries before other libraries
2661         for deplib in $save_deplibs; do
2662           deplibs="$deplib $deplibs"
2663         done
2664       fi
2665       if test "$pass" != dlopen; then
2666         if test "$pass" != conv; then
2667           # Make sure lib_search_path contains only unique directories.
2668           lib_search_path=
2669           for dir in $newlib_search_path; do
2670             case "$lib_search_path " in
2671             *" $dir "*) ;;
2672             *) lib_search_path="$lib_search_path $dir" ;;
2673             esac
2674           done
2675           newlib_search_path=
2676         fi
2677
2678         if test "$linkmode,$pass" != "prog,link"; then
2679           vars="deplibs"
2680         else
2681           vars="compile_deplibs finalize_deplibs"
2682         fi
2683         for var in $vars dependency_libs; do
2684           # Add libraries to $var in reverse order
2685           eval tmp_libs=\"\$$var\"
2686           new_libs=
2687           for deplib in $tmp_libs; do
2688             # FIXME: Pedantically, this is the right thing to do, so
2689             #        that some nasty dependency loop isn't accidentally
2690             #        broken:
2691             #new_libs="$deplib $new_libs"
2692             # Pragmatically, this seems to cause very few problems in
2693             # practice:
2694             case $deplib in
2695             -L*) new_libs="$deplib $new_libs" ;;
2696             -R*) ;;
2697             *)
2698               # And here is the reason: when a library appears more
2699               # than once as an explicit dependence of a library, or
2700               # is implicitly linked in more than once by the
2701               # compiler, it is considered special, and multiple
2702               # occurrences thereof are not removed.  Compare this
2703               # with having the same library being listed as a
2704               # dependency of multiple other libraries: in this case,
2705               # we know (pedantically, we assume) the library does not
2706               # need to be listed more than once, so we keep only the
2707               # last copy.  This is not always right, but it is rare
2708               # enough that we require users that really mean to play
2709               # such unportable linking tricks to link the library
2710               # using -Wl,-lname, so that libtool does not consider it
2711               # for duplicate removal.
2712               case " $specialdeplibs " in
2713               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2714               *)
2715                 case " $new_libs " in
2716                 *" $deplib "*) ;;
2717                 *) new_libs="$deplib $new_libs" ;;
2718                 esac
2719                 ;;
2720               esac
2721               ;;
2722             esac
2723           done
2724           tmp_libs=
2725           for deplib in $new_libs; do
2726             case $deplib in
2727             -L*)
2728               case " $tmp_libs " in
2729               *" $deplib "*) ;;
2730               *) tmp_libs="$tmp_libs $deplib" ;;
2731               esac
2732               ;;
2733             *) tmp_libs="$tmp_libs $deplib" ;;
2734             esac
2735           done
2736           eval $var=\"$tmp_libs\"
2737         done # for var
2738       fi
2739       # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
2740       tmp_libs=
2741       for i in $dependency_libs ; do
2742         case " $predeps $postdeps $compiler_lib_search_path " in
2743         *" $i "*)
2744           i=""
2745           ;;
2746         esac
2747         if test -n "$i" ; then
2748           tmp_libs="$tmp_libs $i"
2749         fi
2750       done
2751       dependency_libs=$tmp_libs
2752     done # for pass
2753     if test "$linkmode" = prog; then
2754       dlfiles="$newdlfiles"
2755       dlprefiles="$newdlprefiles"
2756     fi
2757
2758     case $linkmode in
2759     oldlib)
2760       if test -n "$deplibs"; then
2761         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2762       fi
2763
2764       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2765         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2766       fi
2767
2768       if test -n "$rpath"; then
2769         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2770       fi
2771
2772       if test -n "$xrpath"; then
2773         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2774       fi
2775
2776       if test -n "$vinfo"; then
2777         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2778       fi
2779
2780       if test -n "$release"; then
2781         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2782       fi
2783
2784       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2785         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2786       fi
2787
2788       # Now set the variables for building old libraries.
2789       build_libtool_libs=no
2790       oldlibs="$output"
2791       objs="$objs$old_deplibs"
2792       ;;
2793
2794     lib)
2795       # Make sure we only generate libraries of the form `libNAME.la'.
2796       case $outputname in
2797       lib*)
2798         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2799         eval shared_ext=\"$shrext\"
2800         eval libname=\"$libname_spec\"
2801         ;;
2802       *)
2803         if test "$module" = no; then
2804           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2805           $echo "$help" 1>&2
2806           exit 1
2807         fi
2808         if test "$need_lib_prefix" != no; then
2809           # Add the "lib" prefix for modules if required
2810           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2811           eval shared_ext=\"$shrext\"
2812           eval libname=\"$libname_spec\"
2813         else
2814           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2815         fi
2816         ;;
2817       esac
2818
2819       if test -n "$objs"; then
2820         if test "$deplibs_check_method" != pass_all; then
2821           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2822           exit 1
2823         else
2824           $echo
2825           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2826           $echo "*** objects $objs is not portable!"
2827           libobjs="$libobjs $objs"
2828         fi
2829       fi
2830
2831       if test "$dlself" != no; then
2832         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2833       fi
2834
2835       set dummy $rpath
2836       if test "$#" -gt 2; then
2837         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2838       fi
2839       install_libdir="$2"
2840
2841       oldlibs=
2842       if test -z "$rpath"; then
2843         if test "$build_libtool_libs" = yes; then
2844           # Building a libtool convenience library.
2845           # Some compilers have problems with a `.al' extension so
2846           # convenience libraries should have the same extension an
2847           # archive normally would.
2848           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2849           build_libtool_libs=convenience
2850           build_old_libs=yes
2851         fi
2852
2853         if test -n "$vinfo"; then
2854           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2855         fi
2856
2857         if test -n "$release"; then
2858           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2859         fi
2860       else
2861
2862         # Parse the version information argument.
2863         save_ifs="$IFS"; IFS=':'
2864         set dummy $vinfo 0 0 0
2865         IFS="$save_ifs"
2866
2867         if test -n "$8"; then
2868           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2869           $echo "$help" 1>&2
2870           exit 1
2871         fi
2872
2873         # convert absolute version numbers to libtool ages
2874         # this retains compatibility with .la files and attempts
2875         # to make the code below a bit more comprehensible
2876         
2877         case $vinfo_number in
2878         yes)
2879           number_major="$2"
2880           number_minor="$3"
2881           number_revision="$4"
2882           #
2883           # There are really only two kinds -- those that
2884           # use the current revision as the major version
2885           # and those that subtract age and use age as
2886           # a minor version.  But, then there is irix
2887           # which has an extra 1 added just for fun
2888           #
2889           case $version_type in
2890           darwin|linux|osf|windows)
2891             current=`expr $number_major + $number_minor`
2892             age="$number_minor"
2893             revision="$number_revision"
2894             ;;
2895           freebsd-aout|freebsd-elf|sunos)
2896             current="$number_major"
2897             revision="$number_minor"
2898             age="0"
2899             ;;
2900           irix|nonstopux)
2901             current=`expr $number_major + $number_minor - 1`
2902             age="$number_minor"
2903             revision="$number_minor"
2904             ;;
2905           esac
2906           ;;
2907         no)
2908           current="$2"
2909           revision="$3"
2910           age="$4"
2911           ;;
2912         esac
2913
2914         # Check that each of the things are valid numbers.
2915         case $current in
2916         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2917         *)
2918           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2919           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2920           exit 1
2921           ;;
2922         esac
2923
2924         case $revision in
2925         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2926         *)
2927           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2928           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2929           exit 1
2930           ;;
2931         esac
2932
2933         case $age in
2934         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2935         *)
2936           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2937           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2938           exit 1
2939           ;;
2940         esac
2941
2942         if test "$age" -gt "$current"; then
2943           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2944           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2945           exit 1
2946         fi
2947
2948         # Calculate the version variables.
2949         major=
2950         versuffix=
2951         verstring=
2952         case $version_type in
2953         none) ;;
2954
2955         darwin)
2956           # Like Linux, but with the current version available in
2957           # verstring for coding it into the library header
2958           major=.`expr $current - $age`
2959           versuffix="$major.$age.$revision"
2960           # Darwin ld doesn't like 0 for these options...
2961           minor_current=`expr $current + 1`
2962           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2963           ;;
2964
2965         freebsd-aout)
2966           major=".$current"
2967           versuffix=".$current.$revision";
2968           ;;
2969
2970         freebsd-elf)
2971           major=".$current"
2972           versuffix=".$current";
2973           ;;
2974
2975         irix | nonstopux)
2976           major=`expr $current - $age + 1`
2977
2978           case $version_type in
2979             nonstopux) verstring_prefix=nonstopux ;;
2980             *)         verstring_prefix=sgi ;;
2981           esac
2982           verstring="$verstring_prefix$major.$revision"
2983
2984           # Add in all the interfaces that we are compatible with.
2985           loop=$revision
2986           while test "$loop" -ne 0; do
2987             iface=`expr $revision - $loop`
2988             loop=`expr $loop - 1`
2989             verstring="$verstring_prefix$major.$iface:$verstring"
2990           done
2991
2992           # Before this point, $major must not contain `.'.
2993           major=.$major
2994           versuffix="$major.$revision"
2995           ;;
2996
2997         linux)
2998           major=.`expr $current - $age`
2999           versuffix="$major.$age.$revision"
3000           ;;
3001
3002         osf)
3003           major=.`expr $current - $age`
3004           versuffix=".$current.$age.$revision"
3005           verstring="$current.$age.$revision"
3006
3007           # Add in all the interfaces that we are compatible with.
3008           loop=$age
3009           while test "$loop" -ne 0; do
3010             iface=`expr $current - $loop`
3011             loop=`expr $loop - 1`
3012             verstring="$verstring:${iface}.0"
3013           done
3014
3015           # Make executables depend on our current version.
3016           verstring="$verstring:${current}.0"
3017           ;;
3018
3019         sunos)
3020           major=".$current"
3021           versuffix=".$current.$revision"
3022           ;;
3023
3024         windows)
3025           # Use '-' rather than '.', since we only want one
3026           # extension on DOS 8.3 filesystems.
3027           major=`expr $current - $age`
3028           versuffix="-$major"
3029           ;;
3030
3031         *)
3032           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3033           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3034           exit 1
3035           ;;
3036         esac
3037
3038         # Clear the version info if we defaulted, and they specified a release.
3039         if test -z "$vinfo" && test -n "$release"; then
3040           major=
3041           case $version_type in
3042           darwin)
3043             # we can't check for "0.0" in archive_cmds due to quoting
3044             # problems, so we reset it completely
3045             verstring=
3046             ;;
3047           *)
3048             verstring="0.0"
3049             ;;
3050           esac
3051           if test "$need_version" = no; then
3052             versuffix=
3053           else
3054             versuffix=".0.0"
3055           fi
3056         fi
3057
3058         # Remove version info from name if versioning should be avoided
3059         if test "$avoid_version" = yes && test "$need_version" = no; then
3060           major=
3061           versuffix=
3062           verstring=""
3063         fi
3064
3065         # Check to see if the archive will have undefined symbols.
3066         if test "$allow_undefined" = yes; then
3067           if test "$allow_undefined_flag" = unsupported; then
3068             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3069             build_libtool_libs=no
3070             build_old_libs=yes
3071           fi
3072         else
3073           # Don't allow undefined symbols.
3074           allow_undefined_flag="$no_undefined_flag"
3075         fi
3076       fi
3077
3078       if test "$mode" != relink; then
3079         # Remove our outputs, but don't remove object files since they
3080         # may have been created when compiling PIC objects.
3081         removelist=
3082         tempremovelist=`$echo "$output_objdir/*"`
3083         for p in $tempremovelist; do
3084           case $p in
3085             *.$objext)
3086                ;;
3087             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3088                removelist="$removelist $p"
3089                ;;
3090             *) ;;
3091           esac
3092         done
3093         if test -n "$removelist"; then
3094           $show "${rm}r $removelist"
3095           $run ${rm}r $removelist
3096         fi
3097       fi
3098
3099       # Now set the variables for building old libraries.
3100       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3101         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3102
3103         # Transform .lo files to .o files.
3104         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3105       fi
3106
3107       # Eliminate all temporary directories.
3108       for path in $notinst_path; do
3109         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3110         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3111         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3112       done
3113
3114       if test -n "$xrpath"; then
3115         # If the user specified any rpath flags, then add them.
3116         temp_xrpath=
3117         for libdir in $xrpath; do
3118           temp_xrpath="$temp_xrpath -R$libdir"
3119           case "$finalize_rpath " in
3120           *" $libdir "*) ;;
3121           *) finalize_rpath="$finalize_rpath $libdir" ;;
3122           esac
3123         done
3124         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3125           dependency_libs="$temp_xrpath $dependency_libs"
3126         fi
3127       fi
3128
3129       # Make sure dlfiles contains only unique files that won't be dlpreopened
3130       old_dlfiles="$dlfiles"
3131       dlfiles=
3132       for lib in $old_dlfiles; do
3133         case " $dlprefiles $dlfiles " in
3134         *" $lib "*) ;;
3135         *) dlfiles="$dlfiles $lib" ;;
3136         esac
3137       done
3138
3139       # Make sure dlprefiles contains only unique files
3140       old_dlprefiles="$dlprefiles"
3141       dlprefiles=
3142       for lib in $old_dlprefiles; do
3143         case "$dlprefiles " in
3144         *" $lib "*) ;;
3145         *) dlprefiles="$dlprefiles $lib" ;;
3146         esac
3147       done
3148
3149       if test "$build_libtool_libs" = yes; then
3150         if test -n "$rpath"; then
3151           case $host in
3152           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3153             # these systems don't actually have a c library (as such)!
3154             ;;
3155           *-*-rhapsody* | *-*-darwin1.[012])
3156             # Rhapsody C library is in the System framework
3157             deplibs="$deplibs -framework System"
3158             ;;
3159           *-*-netbsd*)
3160             # Don't link with libc until the a.out ld.so is fixed.
3161             ;;
3162           *-*-openbsd* | *-*-freebsd*)
3163             # Do not include libc due to us having libc/libc_r.
3164             test "X$arg" = "X-lc" && continue
3165             ;;
3166           *)
3167             # Add libc to deplibs on all other systems if necessary.
3168             if test "$build_libtool_need_lc" = "yes"; then
3169               deplibs="$deplibs -lc"
3170             fi
3171             ;;
3172           esac
3173         fi
3174
3175         # Transform deplibs into only deplibs that can be linked in shared.
3176         name_save=$name
3177         libname_save=$libname
3178         release_save=$release
3179         versuffix_save=$versuffix
3180         major_save=$major
3181         # I'm not sure if I'm treating the release correctly.  I think
3182         # release should show up in the -l (ie -lgmp5) so we don't want to
3183         # add it in twice.  Is that correct?
3184         release=""
3185         versuffix=""
3186         major=""
3187         newdeplibs=
3188         droppeddeps=no
3189         case $deplibs_check_method in
3190         pass_all)
3191           # Don't check for shared/static.  Everything works.
3192           # This might be a little naive.  We might want to check
3193           # whether the library exists or not.  But this is on
3194           # osf3 & osf4 and I'm not really sure... Just
3195           # implementing what was already the behavior.
3196           newdeplibs=$deplibs
3197           ;;
3198         test_compile)
3199           # This code stresses the "libraries are programs" paradigm to its
3200           # limits. Maybe even breaks it.  We compile a program, linking it
3201           # against the deplibs as a proxy for the library.  Then we can check
3202           # whether they linked in statically or dynamically with ldd.
3203           $rm conftest.c
3204           cat > conftest.c <<EOF
3205           int main() { return 0; }
3206 EOF
3207           $rm conftest
3208           $LTCC -o conftest conftest.c $deplibs
3209           if test "$?" -eq 0 ; then
3210             ldd_output=`ldd conftest`
3211             for i in $deplibs; do
3212               name="`expr $i : '-l\(.*\)'`"
3213               # If $name is empty we are operating on a -L argument.
3214               if test "$name" != "" && test "$name" -ne "0"; then
3215                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3216                   case " $predeps $postdeps " in
3217                   *" $i "*)
3218                     newdeplibs="$newdeplibs $i"
3219                     i=""
3220                     ;;
3221                   esac
3222                 fi
3223                 if test -n "$i" ; then
3224                   libname=`eval \\$echo \"$libname_spec\"`
3225                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3226                   set dummy $deplib_matches
3227                   deplib_match=$2
3228                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3229                     newdeplibs="$newdeplibs $i"
3230                   else
3231                     droppeddeps=yes
3232                     $echo
3233                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3234                     $echo "*** I have the capability to make that library automatically link in when"
3235                     $echo "*** you link to this library.  But I can only do this if you have a"
3236                     $echo "*** shared version of the library, which I believe you do not have"
3237                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3238                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3239                   fi
3240                 fi
3241               else
3242                 newdeplibs="$newdeplibs $i"
3243               fi
3244             done
3245           else
3246             # Error occurred in the first compile.  Let's try to salvage
3247             # the situation: Compile a separate program for each library.
3248             for i in $deplibs; do
3249               name="`expr $i : '-l\(.*\)'`"
3250               # If $name is empty we are operating on a -L argument.
3251               if test "$name" != "" && test "$name" != "0"; then
3252                 $rm conftest
3253                 $LTCC -o conftest conftest.c $i
3254                 # Did it work?
3255                 if test "$?" -eq 0 ; then
3256                   ldd_output=`ldd conftest`
3257                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3258                     case " $predeps $postdeps " in
3259                     *" $i "*)
3260                       newdeplibs="$newdeplibs $i"
3261                       i=""
3262                       ;;
3263                     esac
3264                   fi
3265                   if test -n "$i" ; then
3266                     libname=`eval \\$echo \"$libname_spec\"`
3267                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3268                     set dummy $deplib_matches
3269                     deplib_match=$2
3270                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3271                       newdeplibs="$newdeplibs $i"
3272                     else
3273                       droppeddeps=yes
3274                       $echo
3275                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3276                       $echo "*** I have the capability to make that library automatically link in when"
3277                       $echo "*** you link to this library.  But I can only do this if you have a"
3278                       $echo "*** shared version of the library, which you do not appear to have"
3279                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3280                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3281                     fi
3282                   fi
3283                 else
3284                   droppeddeps=yes
3285                   $echo
3286                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3287                   $echo "***  make it link in!  You will probably need to install it or some"
3288                   $echo "*** library that it depends on before this library will be fully"
3289                   $echo "*** functional.  Installing it before continuing would be even better."
3290                 fi
3291               else
3292                 newdeplibs="$newdeplibs $i"
3293               fi
3294             done
3295           fi
3296           ;;
3297         file_magic*)
3298           set dummy $deplibs_check_method
3299           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3300           for a_deplib in $deplibs; do
3301             name="`expr $a_deplib : '-l\(.*\)'`"
3302             # If $name is empty we are operating on a -L argument.
3303             if test "$name" != "" && test  "$name" != "0"; then
3304               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3305                 case " $predeps $postdeps " in
3306                 *" $a_deplib "*)
3307                   newdeplibs="$newdeplibs $a_deplib"
3308                   a_deplib=""
3309                   ;;
3310                 esac
3311               fi
3312               if test -n "$a_deplib" ; then
3313                 libname=`eval \\$echo \"$libname_spec\"`
3314                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3315                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3316                   for potent_lib in $potential_libs; do
3317                       # Follow soft links.
3318                       if ls -lLd "$potent_lib" 2>/dev/null \
3319                          | grep " -> " >/dev/null; then
3320                         continue
3321                       fi
3322                       # The statement above tries to avoid entering an
3323                       # endless loop below, in case of cyclic links.
3324                       # We might still enter an endless loop, since a link
3325                       # loop can be closed while we follow links,
3326                       # but so what?
3327                       potlib="$potent_lib"
3328                       while test -h "$potlib" 2>/dev/null; do
3329                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3330                         case $potliblink in
3331                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3332                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3333                         esac
3334                       done
3335                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3336                          | ${SED} 10q \
3337                          | $EGREP "$file_magic_regex" > /dev/null; then
3338                         newdeplibs="$newdeplibs $a_deplib"
3339                         a_deplib=""
3340                         break 2
3341                       fi
3342                   done
3343                 done
3344               fi
3345               if test -n "$a_deplib" ; then
3346                 droppeddeps=yes
3347                 $echo
3348                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3349                 $echo "*** I have the capability to make that library automatically link in when"
3350                 $echo "*** you link to this library.  But I can only do this if you have a"
3351                 $echo "*** shared version of the library, which you do not appear to have"
3352                 $echo "*** because I did check the linker path looking for a file starting"
3353                 if test -z "$potlib" ; then
3354                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3355                 else
3356                   $echo "*** with $libname and none of the candidates passed a file format test"
3357                   $echo "*** using a file magic. Last file checked: $potlib"
3358                 fi
3359               fi
3360             else
3361               # Add a -L argument.
3362               newdeplibs="$newdeplibs $a_deplib"
3363             fi
3364           done # Gone through all deplibs.
3365           ;;
3366         match_pattern*)
3367           set dummy $deplibs_check_method
3368           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3369           for a_deplib in $deplibs; do
3370             name="`expr $a_deplib : '-l\(.*\)'`"
3371             # If $name is empty we are operating on a -L argument.
3372             if test -n "$name" && test "$name" != "0"; then
3373               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3374                 case " $predeps $postdeps " in
3375                 *" $a_deplib "*)
3376                   newdeplibs="$newdeplibs $a_deplib"
3377                   a_deplib=""
3378                   ;;
3379                 esac
3380               fi
3381               if test -n "$a_deplib" ; then
3382                 libname=`eval \\$echo \"$libname_spec\"`
3383                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3384                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3385                   for potent_lib in $potential_libs; do
3386                     potlib="$potent_lib" # see symlink-check above in file_magic test
3387                     if eval $echo \"$potent_lib\" 2>/dev/null \
3388                         | ${SED} 10q \
3389                         | $EGREP "$match_pattern_regex" > /dev/null; then
3390                       newdeplibs="$newdeplibs $a_deplib"
3391                       a_deplib=""
3392                       break 2
3393                     fi
3394                   done
3395                 done
3396               fi
3397               if test -n "$a_deplib" ; then
3398                 droppeddeps=yes
3399                 $echo
3400                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3401                 $echo "*** I have the capability to make that library automatically link in when"
3402                 $echo "*** you link to this library.  But I can only do this if you have a"
3403                 $echo "*** shared version of the library, which you do not appear to have"
3404                 $echo "*** because I did check the linker path looking for a file starting"
3405                 if test -z "$potlib" ; then
3406                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3407                 else
3408                   $echo "*** with $libname and none of the candidates passed a file format test"
3409                   $echo "*** using a regex pattern. Last file checked: $potlib"
3410                 fi
3411               fi
3412             else
3413               # Add a -L argument.
3414               newdeplibs="$newdeplibs $a_deplib"
3415             fi
3416           done # Gone through all deplibs.
3417           ;;
3418         none | unknown | *)
3419           newdeplibs=""
3420           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3421             -e 's/ -[LR][^ ]*//g'`
3422           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3423             for i in $predeps $postdeps ; do
3424               # can't use Xsed below, because $i might contain '/'
3425               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3426             done
3427           fi
3428           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3429             | grep . >/dev/null; then
3430             $echo
3431             if test "X$deplibs_check_method" = "Xnone"; then
3432               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3433             else
3434               $echo "*** Warning: inter-library dependencies are not known to be supported."
3435             fi
3436             $echo "*** All declared inter-library dependencies are being dropped."
3437             droppeddeps=yes
3438           fi
3439           ;;
3440         esac
3441         versuffix=$versuffix_save
3442         major=$major_save
3443         release=$release_save
3444         libname=$libname_save
3445         name=$name_save
3446
3447         case $host in
3448         *-*-rhapsody* | *-*-darwin1.[012])
3449           # On Rhapsody replace the C library is the System framework
3450           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3451           ;;
3452         esac
3453
3454         if test "$droppeddeps" = yes; then
3455           if test "$module" = yes; then
3456             $echo
3457             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3458             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3459             $echo "*** a static module, that should work as long as the dlopening"
3460             $echo "*** application is linked with the -dlopen flag."
3461             if test -z "$global_symbol_pipe"; then
3462               $echo
3463               $echo "*** However, this would only work if libtool was able to extract symbol"
3464               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3465               $echo "*** not find such a program.  So, this module is probably useless."
3466               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3467             fi
3468             if test "$build_old_libs" = no; then
3469               oldlibs="$output_objdir/$libname.$libext"
3470               build_libtool_libs=module
3471               build_old_libs=yes
3472             else
3473               build_libtool_libs=no
3474             fi
3475           else
3476             $echo "*** The inter-library dependencies that have been dropped here will be"
3477             $echo "*** automatically added whenever a program is linked with this library"
3478             $echo "*** or is declared to -dlopen it."
3479
3480             if test "$allow_undefined" = no; then
3481               $echo
3482               $echo "*** Since this library must not contain undefined symbols,"
3483               $echo "*** because either the platform does not support them or"
3484               $echo "*** it was explicitly requested with -no-undefined,"
3485               $echo "*** libtool will only create a static version of it."
3486               if test "$build_old_libs" = no; then
3487                 oldlibs="$output_objdir/$libname.$libext"
3488                 build_libtool_libs=module
3489                 build_old_libs=yes
3490               else
3491                 build_libtool_libs=no
3492               fi
3493             fi
3494           fi
3495         fi
3496         # Done checking deplibs!
3497         deplibs=$newdeplibs
3498       fi
3499
3500       # All the library-specific variables (install_libdir is set above).
3501       library_names=
3502       old_library=
3503       dlname=
3504
3505       # Test again, we may have decided not to build it any more
3506       if test "$build_libtool_libs" = yes; then
3507         if test "$hardcode_into_libs" = yes; then
3508           # Hardcode the library paths
3509           hardcode_libdirs=
3510           dep_rpath=
3511           rpath="$finalize_rpath"
3512           test "$mode" != relink && rpath="$compile_rpath$rpath"
3513           for libdir in $rpath; do
3514             if test -n "$hardcode_libdir_flag_spec"; then
3515               if test -n "$hardcode_libdir_separator"; then
3516                 if test -z "$hardcode_libdirs"; then
3517                   hardcode_libdirs="$libdir"
3518                 else
3519                   # Just accumulate the unique libdirs.
3520                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3521                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3522                     ;;
3523                   *)
3524                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3525                     ;;
3526                   esac
3527                 fi
3528               else
3529                 eval flag=\"$hardcode_libdir_flag_spec\"
3530                 dep_rpath="$dep_rpath $flag"
3531               fi
3532             elif test -n "$runpath_var"; then
3533               case "$perm_rpath " in
3534               *" $libdir "*) ;;
3535               *) perm_rpath="$perm_rpath $libdir" ;;
3536               esac
3537             fi
3538           done
3539           # Substitute the hardcoded libdirs into the rpath.
3540           if test -n "$hardcode_libdir_separator" &&
3541              test -n "$hardcode_libdirs"; then
3542             libdir="$hardcode_libdirs"
3543             if test -n "$hardcode_libdir_flag_spec_ld"; then
3544               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3545             else
3546               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3547             fi
3548           fi
3549           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3550             # We should set the runpath_var.
3551             rpath=
3552             for dir in $perm_rpath; do
3553               rpath="$rpath$dir:"
3554             done
3555             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3556           fi
3557           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3558         fi
3559
3560         shlibpath="$finalize_shlibpath"
3561         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3562         if test -n "$shlibpath"; then
3563           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3564         fi
3565
3566         # Get the real and link names of the library.
3567         eval shared_ext=\"$shrext\"
3568         eval library_names=\"$library_names_spec\"
3569         set dummy $library_names
3570         realname="$2"
3571         shift; shift
3572
3573         if test -n "$soname_spec"; then
3574           eval soname=\"$soname_spec\"
3575         else
3576           soname="$realname"
3577         fi
3578         if test -z "$dlname"; then
3579           dlname=$soname
3580         fi
3581
3582         lib="$output_objdir/$realname"
3583         for link
3584         do
3585           linknames="$linknames $link"
3586         done
3587
3588         # Use standard objects if they are pic
3589         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3590
3591         # Prepare the list of exported symbols
3592         if test -z "$export_symbols"; then
3593           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3594             $show "generating symbol list for \`$libname.la'"
3595             export_symbols="$output_objdir/$libname.exp"
3596             $run $rm $export_symbols
3597             eval cmds=\"$export_symbols_cmds\"
3598             save_ifs="$IFS"; IFS='~'
3599             for cmd in $cmds; do
3600               IFS="$save_ifs"
3601               if len=`expr "X$cmd" : ".*"` &&
3602                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3603                 $show "$cmd"
3604                 $run eval "$cmd" || exit $?
3605                 skipped_export=false
3606               else
3607                 # The command line is too long to execute in one step.
3608                 $show "using reloadable object file for export list..."
3609                 skipped_export=:
3610               fi
3611             done
3612             IFS="$save_ifs"
3613             if test -n "$export_symbols_regex"; then
3614               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3615               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3616               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3617               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3618             fi
3619           fi
3620         fi
3621
3622         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3623           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3624         fi
3625
3626         tmp_deplibs=
3627         for test_deplib in $deplibs; do
3628                 case " $convenience " in
3629                 *" $test_deplib "*) ;;
3630                 *) 
3631                         tmp_deplibs="$tmp_deplibs $test_deplib"
3632                         ;;
3633                 esac
3634         done
3635         deplibs="$tmp_deplibs" 
3636
3637         if test -n "$convenience"; then
3638           if test -n "$whole_archive_flag_spec"; then
3639             save_libobjs=$libobjs
3640             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3641           else
3642             gentop="$output_objdir/${outputname}x"
3643             $show "${rm}r $gentop"
3644             $run ${rm}r "$gentop"
3645             $show "$mkdir $gentop"
3646             $run $mkdir "$gentop"
3647             status=$?
3648             if test "$status" -ne 0 && test ! -d "$gentop"; then
3649               exit $status
3650             fi
3651             generated="$generated $gentop"
3652
3653             for xlib in $convenience; do
3654               # Extract the objects.
3655               case $xlib in
3656               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3657               *) xabs=`pwd`"/$xlib" ;;
3658               esac
3659               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3660               xdir="$gentop/$xlib"
3661
3662               $show "${rm}r $xdir"
3663               $run ${rm}r "$xdir"
3664               $show "$mkdir $xdir"
3665               $run $mkdir "$xdir"
3666               status=$?
3667               if test "$status" -ne 0 && test ! -d "$xdir"; then
3668                 exit $status
3669               fi
3670               # We will extract separately just the conflicting names and we will no
3671               # longer touch any unique names. It is faster to leave these extract
3672               # automatically by $AR in one run.
3673               $show "(cd $xdir && $AR x $xabs)"
3674               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3675               if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3676                 :
3677               else
3678                 $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3679                 $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3680                 $AR t "$xabs" | sort | uniq -cd | while read -r count name
3681                 do
3682                   i=1
3683                   while test "$i" -le "$count"
3684                   do
3685                    # Put our $i before any first dot (extension)
3686                    # Never overwrite any file
3687                    name_to="$name"
3688                    while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3689                    do
3690                      name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3691                    done
3692                    $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3693                    $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3694                    i=`expr $i + 1`
3695                   done
3696                 done
3697               fi
3698
3699               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3700             done
3701           fi
3702         fi
3703
3704         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3705           eval flag=\"$thread_safe_flag_spec\"
3706           linker_flags="$linker_flags $flag"
3707         fi
3708
3709         # Make a backup of the uninstalled library when relinking
3710         if test "$mode" = relink; then
3711           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3712         fi
3713
3714         # Do each of the archive commands.
3715         if test "$module" = yes && test -n "$module_cmds" ; then
3716           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3717             eval cmds=\"$module_expsym_cmds\"
3718           else
3719             eval cmds=\"$module_cmds\"
3720           fi
3721         else
3722         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3723           eval cmds=\"$archive_expsym_cmds\"
3724         else
3725           eval cmds=\"$archive_cmds\"
3726           fi
3727         fi
3728
3729         if test "X$skipped_export" != "X:" && len=`expr "X$cmds" : ".*"` &&
3730            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3731           :
3732         else
3733           # The command line is too long to link in one step, link piecewise.
3734           $echo "creating reloadable object files..."
3735
3736           # Save the value of $output and $libobjs because we want to
3737           # use them later.  If we have whole_archive_flag_spec, we
3738           # want to use save_libobjs as it was before
3739           # whole_archive_flag_spec was expanded, because we can't
3740           # assume the linker understands whole_archive_flag_spec.
3741           # This may have to be revisited, in case too many
3742           # convenience libraries get linked in and end up exceeding
3743           # the spec.
3744           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3745             save_libobjs=$libobjs
3746           fi
3747           save_output=$output
3748
3749           # Clear the reloadable object creation command queue and
3750           # initialize k to one.
3751           test_cmds=
3752           concat_cmds=
3753           objlist=
3754           delfiles=
3755           last_robj=
3756           k=1
3757           output=$output_objdir/$save_output-${k}.$objext
3758           # Loop over the list of objects to be linked.
3759           for obj in $save_libobjs
3760           do
3761             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3762             if test "X$objlist" = X ||
3763                { len=`expr "X$test_cmds" : ".*"` &&
3764                  test "$len" -le "$max_cmd_len"; }; then
3765               objlist="$objlist $obj"
3766             else
3767               # The command $test_cmds is almost too long, add a
3768               # command to the queue.
3769               if test "$k" -eq 1 ; then
3770                 # The first file doesn't have a previous command to add.
3771                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3772               else
3773                 # All subsequent reloadable object files will link in
3774                 # the last one created.
3775                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3776               fi
3777               last_robj=$output_objdir/$save_output-${k}.$objext
3778               k=`expr $k + 1`
3779               output=$output_objdir/$save_output-${k}.$objext
3780               objlist=$obj
3781               len=1
3782             fi
3783           done
3784           # Handle the remaining objects by creating one last
3785           # reloadable object file.  All subsequent reloadable object
3786           # files will link in the last one created.
3787           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3788           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3789
3790           if ${skipped_export-false}; then
3791             $show "generating symbol list for \`$libname.la'"
3792             export_symbols="$output_objdir/$libname.exp"
3793             $run $rm $export_symbols
3794             libobjs=$output
3795             # Append the command to create the export file.
3796             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3797           fi
3798
3799           # Set up a command to remove the reloadale object files
3800           # after they are used.
3801           i=0
3802           while test "$i" -lt "$k"
3803           do
3804             i=`expr $i + 1`
3805             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3806           done
3807
3808           $echo "creating a temporary reloadable object file: $output"
3809
3810           # Loop through the commands generated above and execute them.
3811           save_ifs="$IFS"; IFS='~'
3812           for cmd in $concat_cmds; do
3813             IFS="$save_ifs"
3814             $show "$cmd"
3815             $run eval "$cmd" || exit $?
3816           done
3817           IFS="$save_ifs"
3818
3819           libobjs=$output
3820           # Restore the value of output.
3821           output=$save_output
3822
3823           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3824             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3825           fi
3826           # Expand the library linking commands again to reset the
3827           # value of $libobjs for piecewise linking.
3828
3829           # Do each of the archive commands.
3830           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3831             eval cmds=\"$archive_expsym_cmds\"
3832           else
3833             eval cmds=\"$archive_cmds\"
3834           fi
3835
3836           # Append the command to remove the reloadable object files
3837           # to the just-reset $cmds.
3838           eval cmds=\"\$cmds~$rm $delfiles\"
3839         fi
3840         save_ifs="$IFS"; IFS='~'
3841         for cmd in $cmds; do
3842           IFS="$save_ifs"
3843           $show "$cmd"
3844           $run eval "$cmd" || exit $?
3845         done
3846         IFS="$save_ifs"
3847
3848         # Restore the uninstalled library and exit
3849         if test "$mode" = relink; then
3850           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3851           exit 0
3852         fi
3853
3854         # Create links to the real library.
3855         for linkname in $linknames; do
3856           if test "$realname" != "$linkname"; then
3857             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3858             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3859           fi
3860         done
3861
3862         # If -module or -export-dynamic was specified, set the dlname.
3863         if test "$module" = yes || test "$export_dynamic" = yes; then
3864           # On all known operating systems, these are identical.
3865           dlname="$soname"
3866         fi
3867       fi
3868       ;;
3869
3870     obj)
3871       if test -n "$deplibs"; then
3872         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3873       fi
3874
3875       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3876         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3877       fi
3878
3879       if test -n "$rpath"; then
3880         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3881       fi
3882
3883       if test -n "$xrpath"; then
3884         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3885       fi
3886
3887       if test -n "$vinfo"; then
3888         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3889       fi
3890
3891       if test -n "$release"; then
3892         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3893       fi
3894
3895       case $output in
3896       *.lo)
3897         if test -n "$objs$old_deplibs"; then
3898           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3899           exit 1
3900         fi
3901         libobj="$output"
3902         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3903         ;;
3904       *)
3905         libobj=
3906         obj="$output"
3907         ;;
3908       esac
3909
3910       # Delete the old objects.
3911       $run $rm $obj $libobj
3912
3913       # Objects from convenience libraries.  This assumes
3914       # single-version convenience libraries.  Whenever we create
3915       # different ones for PIC/non-PIC, this we'll have to duplicate
3916       # the extraction.
3917       reload_conv_objs=
3918       gentop=
3919       # reload_cmds runs $LD directly, so let us get rid of
3920       # -Wl from whole_archive_flag_spec
3921       wl=
3922
3923       if test -n "$convenience"; then
3924         if test -n "$whole_archive_flag_spec"; then
3925           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3926         else
3927           gentop="$output_objdir/${obj}x"
3928           $show "${rm}r $gentop"
3929           $run ${rm}r "$gentop"
3930           $show "$mkdir $gentop"
3931           $run $mkdir "$gentop"
3932           status=$?
3933           if test "$status" -ne 0 && test ! -d "$gentop"; then
3934             exit $status
3935           fi
3936           generated="$generated $gentop"
3937
3938           for xlib in $convenience; do
3939             # Extract the objects.
3940             case $xlib in
3941             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3942             *) xabs=`pwd`"/$xlib" ;;
3943             esac
3944             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3945             xdir="$gentop/$xlib"
3946
3947             $show "${rm}r $xdir"
3948             $run ${rm}r "$xdir"
3949             $show "$mkdir $xdir"
3950             $run $mkdir "$xdir"
3951             status=$?
3952             if test "$status" -ne 0 && test ! -d "$xdir"; then
3953               exit $status
3954             fi
3955             # We will extract separately just the conflicting names and we will no
3956             # longer touch any unique names. It is faster to leave these extract
3957             # automatically by $AR in one run.
3958             $show "(cd $xdir && $AR x $xabs)"
3959             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3960             if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3961               :
3962             else
3963               $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3964               $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3965               $AR t "$xabs" | sort | uniq -cd | while read -r count name
3966               do
3967                 i=1
3968                 while test "$i" -le "$count"
3969                 do
3970                  # Put our $i before any first dot (extension)
3971                  # Never overwrite any file
3972                  name_to="$name"
3973                  while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3974                  do
3975                    name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3976                  done
3977                  $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3978                  $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3979                  i=`expr $i + 1`
3980                 done
3981               done
3982             fi
3983
3984             reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3985           done
3986         fi
3987       fi
3988
3989       # Create the old-style object.
3990       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
3991
3992       output="$obj"
3993       eval cmds=\"$reload_cmds\"
3994       save_ifs="$IFS"; IFS='~'
3995       for cmd in $cmds; do
3996         IFS="$save_ifs"
3997         $show "$cmd"
3998         $run eval "$cmd" || exit $?
3999       done
4000       IFS="$save_ifs"
4001
4002       # Exit if we aren't doing a library object file.
4003       if test -z "$libobj"; then
4004         if test -n "$gentop"; then
4005           $show "${rm}r $gentop"
4006           $run ${rm}r $gentop
4007         fi
4008
4009         exit 0
4010       fi
4011
4012       if test "$build_libtool_libs" != yes; then
4013         if test -n "$gentop"; then
4014           $show "${rm}r $gentop"
4015           $run ${rm}r $gentop
4016         fi
4017
4018         # Create an invalid libtool object if no PIC, so that we don't
4019         # accidentally link it into a program.
4020         # $show "echo timestamp > $libobj"
4021         # $run eval "echo timestamp > $libobj" || exit $?
4022         exit 0
4023       fi
4024
4025       if test -n "$pic_flag" || test "$pic_mode" != default; then
4026         # Only do commands if we really have different PIC objects.
4027         reload_objs="$libobjs $reload_conv_objs"
4028         output="$libobj"
4029         eval cmds=\"$reload_cmds\"
4030         save_ifs="$IFS"; IFS='~'
4031         for cmd in $cmds; do
4032           IFS="$save_ifs"
4033           $show "$cmd"
4034           $run eval "$cmd" || exit $?
4035         done
4036         IFS="$save_ifs"
4037       fi
4038
4039       if test -n "$gentop"; then
4040         $show "${rm}r $gentop"
4041         $run ${rm}r $gentop
4042       fi
4043
4044       exit 0
4045       ;;
4046
4047     prog)
4048       case $host in
4049         *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4050       esac
4051       if test -n "$vinfo"; then
4052         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4053       fi
4054
4055       if test -n "$release"; then
4056         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4057       fi
4058
4059       if test "$preload" = yes; then
4060         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4061            test "$dlopen_self_static" = unknown; then
4062           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4063         fi
4064       fi
4065
4066       case $host in
4067       *-*-rhapsody* | *-*-darwin1.[012])
4068         # On Rhapsody replace the C library is the System framework
4069         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4070         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4071         ;;
4072       esac
4073
4074       case $host in
4075       *darwin*)
4076         # Don't allow lazy linking, it breaks C++ global constructors
4077         if test "$tagname" = CXX ; then
4078         compile_command="$compile_command ${wl}-bind_at_load"
4079         finalize_command="$finalize_command ${wl}-bind_at_load"
4080         fi
4081         ;;
4082       esac
4083
4084       compile_command="$compile_command $compile_deplibs"
4085       finalize_command="$finalize_command $finalize_deplibs"
4086
4087       if test -n "$rpath$xrpath"; then
4088         # If the user specified any rpath flags, then add them.
4089         for libdir in $rpath $xrpath; do
4090           # This is the magic to use -rpath.
4091           case "$finalize_rpath " in
4092           *" $libdir "*) ;;
4093           *) finalize_rpath="$finalize_rpath $libdir" ;;
4094           esac
4095         done
4096       fi
4097
4098       # Now hardcode the library paths
4099       rpath=
4100       hardcode_libdirs=
4101       for libdir in $compile_rpath $finalize_rpath; do
4102         if test -n "$hardcode_libdir_flag_spec"; then
4103           if test -n "$hardcode_libdir_separator"; then
4104             if test -z "$hardcode_libdirs"; then
4105               hardcode_libdirs="$libdir"
4106             else
4107               # Just accumulate the unique libdirs.
4108               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4109               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4110                 ;;
4111               *)
4112                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4113                 ;;
4114               esac
4115             fi
4116           else
4117             eval flag=\"$hardcode_libdir_flag_spec\"
4118             rpath="$rpath $flag"
4119           fi
4120         elif test -n "$runpath_var"; then
4121           case "$perm_rpath " in
4122           *" $libdir "*) ;;
4123           *) perm_rpath="$perm_rpath $libdir" ;;
4124           esac
4125         fi
4126         case $host in
4127         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4128           case :$dllsearchpath: in
4129           *":$libdir:"*) ;;
4130           *) dllsearchpath="$dllsearchpath:$libdir";;
4131           esac
4132           ;;
4133         esac
4134       done
4135       # Substitute the hardcoded libdirs into the rpath.
4136       if test -n "$hardcode_libdir_separator" &&
4137          test -n "$hardcode_libdirs"; then
4138         libdir="$hardcode_libdirs"
4139         eval rpath=\" $hardcode_libdir_flag_spec\"
4140       fi
4141       compile_rpath="$rpath"