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