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