1 # ltmain.sh - Provide generalized library-building support services.
2 # NOTE: Changing this file will not affect anything until you rerun configure.
3 #
4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
5 # Free Software Foundation, Inc.
6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #
13 # This program is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 # General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #
22 # As a special exception to the GNU General Public License, if you
23 # distribute this file as part of a program that contains a
24 # configuration script generated by Autoconf, you may include it under
25 # the same distribution terms that you use for the rest of that program.
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
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
51 # The name of this program.
52 progname=`$echo "$0" | ${SED} 's%^.*/%%'`
53 modename="$progname"
55 # Constants.
56 PROGRAM=ltmain.sh
57 PACKAGE=libtool
58 VERSION=1.5a
59 TIMESTAMP=" (1.1240 2003/06/26 06:55:19)"
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"
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
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
96 # Make sure IFS has a sensible default
97 : ${IFS="       "}
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
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/"
117 #####################################
118 # Shell function definitions:
119 # This seems to be the best place for them
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
157 # End of Shell function definitions
158 #####################################
160 # Parse our command line options once, thoroughly.
161 while test "$#" -gt 0
162 do
163   arg="$1"
164   shift
166   case $arg in
167   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
168   *) optarg= ;;
169   esac
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"
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
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
209     prev=
210     prevopt=
211     continue
212   fi
214   # Have we seen a non-optional argument yet?
215   case $arg in
216   --help)
217     show_help=yes
218     ;;
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     ;;
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     ;;
238   --debug)
239     $echo "$progname: enabling shell trace mode"
240     set -x
241     ;;
243   --dry-run | -n)
244     run=:
245     ;;
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     ;;
262   --finish) mode="finish" ;;
264   --mode) prevopt="--mode" prev=mode ;;
265   --mode=*) mode="$optarg" ;;
267   --preserve-dup-deps) duplicate_deps="yes" ;;
269   --quiet | --silent)
270     show=:
271     ;;
273   --tag) prevopt="--tag" prev=tag ;;
274   --tag=*)
275     set tag "$optarg" ${1+"$@"}
276     shift
277     prev=tag
278     ;;
280   -dlopen)
281     prevopt="-dlopen"
282     prev=execute_dlfiles
283     ;;
285   -*)
286     $echo "$modename: unrecognized option \`$arg'" 1>&2
287     $echo "$help" 1>&2
288     exit 1
289     ;;
291   *)
292     nonopt="$arg"
293     break
294     ;;
295   esac
296 done
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
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=
309 if test -z "$show_help"; then
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
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
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
360   # Change the help message to a mode-specific one.
361   generic_help="$help"
362   help="Try \`$modename --help --mode=$mode' for more information."
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=
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         ;;
385       target )
386         libobj="$arg"
387         arg_mode=normal
388         continue
389         ;;
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           ;;
403         -static)
404           build_old_libs=yes
405           continue
406           ;;
408         -prefer-pic)
409           pic_mode=yes
410           continue
411           ;;
413         -prefer-non-pic)
414           pic_mode=no
415           continue
416           ;;
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.
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"
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/^ //"`
443           # Add the arguments to base_compile.
444           base_compile="$base_compile $lastarg"
445           continue
446           ;;
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
459       # Aesthetically quote the previous argument.
460       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
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
471       base_compile="$base_compile $lastarg"
472     done # for arg
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
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
508     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
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
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
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
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
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
581     $run $rm $removelist
582     trap "$run $rm $removelist; exit 1" 1 2 15
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
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
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`
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."
628         $run $rm $removelist
629         exit 1
630       fi
631       $echo $srcfile > "$lockfile"
632     fi
634     if test -n "$fix_srcfile_path"; then
635       eval srcfile=\"$fix_srcfile_path\"
636     fi
638     $run $rm "$libobj" "${libobj}T"
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
646 # Please DO NOT delete this file!
647 # It is necessary for linking the library.
649 # Name of the PIC object.
650 EOF
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
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
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
673       if test -z "$output_obj"; then
674         # Place PIC objects in $objdir
675         command="$command -o $lobj"
676       fi
678       $run $rm "$lobj" "$output_obj"
680       $show "$command"
681       if $run eval "$command"; then :
682       else
683         test -n "$output_obj" && $run $rm $removelist
684         exit 1
685       fi
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`
693 but it should contain:
694 $srcfile
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."
703         $run $rm $removelist
704         exit 1
705       fi
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
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'
722 EOF
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
732 EOF
733     fi
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
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
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`
763 but it should contain:
764 $srcfile
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."
773         $run $rm $removelist
774         exit 1
775       fi
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
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'
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
802 EOF
803     fi
805     $run $mv "${libobj}T" "${libobj}"
807     # Unlock the critical section if it was locked
808     if test "$need_locks" != no; then
809       $run $rm "$lockfile"
810     fi
812     exit 0
813     ;;
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
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"
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=
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
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
909     # See if our shared archives depend on static archives.
910     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
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"
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
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.
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=
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
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
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
1037                 if test "$pic_object" != none; then
1038                   # Prepend the subdirectory the object is found in.
1039                   pic_object="$xdir$pic_object"
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
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
1059                   # A PIC object.
1060                   libobjs="$libobjs $pic_object"
1061                   arg="$pic_object"
1062                 fi
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"
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.
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
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         *)
1153           eval "$prev=\"\$arg\""
1154           prev=
1155           continue
1156           ;;
1157         esac
1158       fi # test -n "$prev"
1160       prevarg="$arg"
1162       case $arg in
1163       -all-static)
1164         if test -n "$link_static_flag"; then
1165           compile_command="$compile_command $link_static_flag"
1166           finalize_command="$finalize_command $link_static_flag"
1167         fi
1168         continue
1169         ;;
1171       -allow-undefined)
1172         # FIXME: remove this flag sometime in the future.
1173         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1174         continue
1175         ;;
1177       -avoid-version)
1178         avoid_version=yes
1179         continue
1180         ;;
1182       -dlopen)
1183         prev=dlfiles
1184         continue
1185         ;;
1187       -dlpreopen)
1188         prev=dlprefiles
1189         continue
1190         ;;
1192       -export-dynamic)
1193         export_dynamic=yes
1194         continue
1195         ;;
1197       -export-symbols | -export-symbols-regex)
1198         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1199           $echo "$modename: more than one -exported-symbols argument is not allowed"
1200           exit 1
1201         fi
1202         if test "X$arg" = "X-export-symbols"; then
1203           prev=expsyms
1204         else
1205           prev=expsyms_regex
1206         fi
1207         continue
1208         ;;
1210       -inst-prefix-dir)
1211         prev=inst_prefix
1212         continue
1213         ;;
1215       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1216       # so, if we see these flags be careful not to treat them like -L
1217       -L[A-Z][A-Z]*:*)
1218         case $with_gcc/$host in
1219         no/*-*-irix* | /*-*-irix*)
1220           compile_command="$compile_command $arg"
1221           finalize_command="$finalize_command $arg"
1222           ;;
1223         esac
1224         continue
1225         ;;
1227       -L*)
1228         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1229         # We need an absolute path.
1230         case $dir in
1231         [\\/]* | [A-Za-z]:[\\/]*) ;;
1232         *)
1233           absdir=`cd "$dir" && pwd`
1234           if test -z "$absdir"; then
1235             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1236             exit 1
1237           fi
1238           dir="$absdir"
1239           ;;
1240         esac
1241         case "$deplibs " in
1242         *" -L$dir "*) ;;
1243         *)
1244           deplibs="$deplibs -L$dir"
1245           lib_search_path="$lib_search_path $dir"
1246           ;;
1247         esac
1248         case $host in
1249         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1250           case :$dllsearchpath: in
1251           *":$dir:"*) ;;
1252           *) dllsearchpath="$dllsearchpath:$dir";;
1253           esac
1254           ;;
1255         esac
1256         continue
1257         ;;
1259       -l*)
1260         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1261           case $host in
1262           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1263             # These systems don't actually have a C or math library (as such)
1264             continue
1265             ;;
1266           *-*-freebsd*-gnu*)
1267             # prevent being parsed by the freebsd regexp below
1268             ;;
1269           *-*-mingw* | *-*-os2*)
1270             # These systems don't actually have a C library (as such)
1271             test "X$arg" = "X-lc" && continue
1272             ;;
1273           *-*-openbsd* | *-*-freebsd*)
1274             # Do not include libc due to us having libc/libc_r.
1275             test "X$arg" = "X-lc" && continue
1276             ;;
1277           *-*-rhapsody* | *-*-darwin1.[012])
1278             # Rhapsody C and math libraries are in the System framework
1279             deplibs="$deplibs -framework System"
1280             continue
1281           esac
1282         elif test "X$arg" = "X-lc_r"; then
1283          case $host in
1284          *-*-freebsd*-gnu*)
1285            # prevent being parsed by the freebsd regexp below
1286            ;;
1287          *-*-openbsd*)
1288            # Do not include libc_r directly, use -pthread flag.
1289            continue
1290            ;;
1291          esac
1292         fi
1293         deplibs="$deplibs $arg"
1294         continue
1295         ;;
1297       -module)
1298         module=yes
1299         continue
1300         ;;
1302       # gcc -m* arguments should be passed to the linker via $compiler_flags
1303       # in order to pass architecture information to the linker
1304       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1305       # but this is not reliable with gcc because gcc may use -mfoo to
1306       # select a different linker, different libraries, etc, while
1307       # -Wl,-mfoo simply passes -mfoo to the linker.
1308       -m*)
1309         # Unknown arguments in both finalize_command and compile_command need
1310         # to be aesthetically quoted because they are evaled later.
1311         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1312         case $arg in
1313         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1314           arg="\"$arg\""
1315           ;;
1316         esac
1317         compile_command="$compile_command $arg"
1318         finalize_command="$finalize_command $arg"
1319         if test "$with_gcc" = "yes" ; then
1320           compiler_flags="$compiler_flags $arg"
1321         fi
1322         continue
1323         ;;
1325       -shrext)
1326         prev=shrext
1327         continue
1328         ;;
1330       -no-fast-install)
1331         fast_install=no
1332         continue
1333         ;;
1335       -no-install)
1336         case $host in
1337         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1338           # The PATH hackery in wrapper scripts is required on Windows
1339           # in order for the loader to find any dlls it needs.
1340           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1341           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1342           fast_install=no
1343           ;;
1344         *) no_install=yes ;;
1345         esac
1346         continue
1347         ;;
1349       -no-undefined)
1350         allow_undefined=no
1351         continue
1352         ;;
1354       -objectlist)
1355         prev=objectlist
1356         continue
1357         ;;
1359       -o) prev=output ;;
1361       -release)
1362         prev=release
1363         continue
1364         ;;
1366       -rpath)
1367         prev=rpath
1368         continue
1369         ;;
1371       -R)
1372         prev=xrpath
1373         continue
1374         ;;
1376       -R*)
1377         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1378         # We need an absolute path.
1379         case $dir in
1380         [\\/]* | [A-Za-z]:[\\/]*) ;;
1381         *)
1382           $echo "$modename: only absolute run-paths are allowed" 1>&2
1383           exit 1
1384           ;;
1385         esac
1386         case "$xrpath " in
1387         *" $dir "*) ;;
1388         *) xrpath="$xrpath $dir" ;;
1389         esac
1390         continue
1391         ;;
1393       -static)
1394         # The effects of -static are defined in a previous loop.
1395         # We used to do the same as -all-static on platforms that
1396         # didn't have a PIC flag, but the assumption that the effects
1397         # would be equivalent was wrong.  It would break on at least
1398         # Digital Unix and AIX.
1399         continue
1400         ;;
1402       -thread-safe)
1403         thread_safe=yes
1404         continue
1405         ;;
1407       -version-info)
1408         prev=vinfo
1409         continue
1410         ;;
1411       -version-number)
1412         prev=vinfo
1413         vinfo_number=yes
1414         continue
1415         ;;
1417       -Wc,*)
1418         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1419         arg=
1420         save_ifs="$IFS"; IFS=','
1421         for flag in $args; do
1422           IFS="$save_ifs"
1423           case $flag in
1424             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1425             flag="\"$flag\""
1426             ;;
1427           esac
1428           arg="$arg $wl$flag"
1429           compiler_flags="$compiler_flags $flag"
1430         done
1431         IFS="$save_ifs"
1432         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1433         ;;
1435       -Wl,*)
1436         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1437         arg=
1438         save_ifs="$IFS"; IFS=','
1439         for flag in $args; do
1440           IFS="$save_ifs"
1441           case $flag in
1442             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1443             flag="\"$flag\""
1444             ;;
1445           esac
1446           arg="$arg $wl$flag"
1447           compiler_flags="$compiler_flags $wl$flag"
1448           linker_flags="$linker_flags $flag"
1449         done
1450         IFS="$save_ifs"
1451         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1452         ;;
1454       -Xcompiler)
1455         prev=xcompiler
1456         continue
1457         ;;
1459       -Xlinker)
1460         prev=xlinker
1461         continue
1462         ;;
1464       -XCClinker)
1465         prev=xcclinker
1466         continue
1467         ;;
1469       # Some other compiler flag.
1470       -* | +*)
1471         # Unknown arguments in both finalize_command and compile_command need
1472         # to be aesthetically quoted because they are evaled later.
1473         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1474         case $arg in
1475         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1476           arg="\"$arg\""
1477           ;;
1478         esac
1479         add_flags="$add_flags $arg"
1480         ;;
1482       *.$objext)
1483         # A standard object.
1484         objs="$objs $arg"
1485         ;;
1487       *.lo)
1488         # A libtool-controlled object.
1490         # Check to see that this really is a libtool object.
1491         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1492           pic_object=
1493           non_pic_object=
1495           # Read the .lo file
1496           # If there is no directory component, then add one.
1497           case $arg in
1498           */* | *\\*) . $arg ;;
1499           *) . ./$arg ;;
1500           esac
1502           if test -z "$pic_object" || \
1503              test -z "$non_pic_object" ||
1504              test "$pic_object" = none && \
1505              test "$non_pic_object" = none; then
1506             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1507             exit 1
1508           fi
1510           # Extract subdirectory from the argument.
1511           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1512           if test "X$xdir" = "X$arg"; then
1513             xdir=
1514           else
1515             xdir="$xdir/"
1516           fi
1518           if test "$pic_object" != none; then
1519             # Prepend the subdirectory the object is found in.
1520             pic_object="$xdir$pic_object"
1522             if test "$prev" = dlfiles; then
1523               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1524                 dlfiles="$dlfiles $pic_object"
1525                 prev=
1526                 continue
1527               else
1528                 # If libtool objects are unsupported, then we need to preload.
1529                 prev=dlprefiles
1530               fi
1531             fi
1533             # CHECK ME:  I think I busted this.  -Ossama
1534             if test "$prev" = dlprefiles; then
1535               # Preload the old-style object.
1536               dlprefiles="$dlprefiles $pic_object"
1537               prev=
1538             fi
1540             # A PIC object.
1541             libobjs="$libobjs $pic_object"
1542             arg="$pic_object"
1543           fi
1545           # Non-PIC object.
1546           if test "$non_pic_object" != none; then
1547             # Prepend the subdirectory the object is found in.
1548             non_pic_object="$xdir$non_pic_object"
1550             # A standard non-PIC object
1551             non_pic_objects="$non_pic_objects $non_pic_object"
1552             if test -z "$pic_object" || test "$pic_object" = none ; then
1553               arg="$non_pic_object"
1554             fi
1555           fi
1556         else
1557           # Only an error if not doing a dry-run.
1558           if test -z "$run"; then
1559             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1560             exit 1
1561           else
1562             # Dry-run case.
1564             # Extract subdirectory from the argument.
1565             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1566             if test "X$xdir" = "X$arg"; then
1567               xdir=
1568             else
1569               xdir="$xdir/"
1570             fi
1572             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1573             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1574             libobjs="$libobjs $pic_object"
1575             non_pic_objects="$non_pic_objects $non_pic_object"
1576           fi
1577         fi
1578         ;;
1580       *.$libext)
1581         # An archive.
1582         deplibs="$deplibs $arg"
1583         old_deplibs="$old_deplibs $arg"
1584         continue
1585         ;;
1587       *.la)
1588         # A libtool-controlled library.
1590         if test "$prev" = dlfiles; then
1591           # This library was specified with -dlopen.
1592           dlfiles="$dlfiles $arg"
1593           prev=
1594         elif test "$prev" = dlprefiles; then
1595           # The library was specified with -dlpreopen.
1596           dlprefiles="$dlprefiles $arg"
1597           prev=
1598         else
1599           deplibs="$deplibs $arg"
1600         fi
1601         continue
1602         ;;
1604       # Some other compiler argument.
1605       *)
1606         # Unknown arguments in both finalize_command and compile_command need
1607         # to be aesthetically quoted because they are evaled later.
1608         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1609         case $arg in
1610         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1611           arg="\"$arg\""
1612           ;;
1613         esac
1614         add_flags="$add_flags $arg"
1615         ;;
1616       esac # arg
1618       # Now actually substitute the argument into the commands.
1619       if test -n "$arg"; then
1620         compile_command="$compile_command $arg"
1621         finalize_command="$finalize_command $arg"
1622       fi
1623     done # argument parsing loop
1625     if test -n "$prev"; then
1626       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1627       $echo "$help" 1>&2
1628       exit 1
1629     fi
1631     # Infer tagged configuration to use if any are available and
1632     # if one wasn't chosen via the "--tag" command line option.
1633     # Only attempt this if the compiler in the base link
1634     # command doesn't match the default compiler.
1635     if test -n "$available_tags" && test -z "$tagname"; then
1636       case $base_compile in
1637       # Blanks in the command may have been stripped by the calling shell,
1638       # but not from the CC environment variable when configure was run.
1639       "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
1640       # Blanks at the start of $base_compile will cause this to fail
1641       # if we don't check for them as well.
1642       *)
1643         for z in $available_tags; do
1644           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1645             # Evaluate the configuration.
1646             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1647             case $base_compile in
1648             "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
1649               # The compiler in $compile_command matches
1650               # the one in the tagged configuration.
1651               # Assume this is the tagged configuration we want.
1652               tagname=$z
1653               break
1654               ;;
1655             esac
1656           fi
1657         done
1658         # If $tagname still isn't set, then no tagged configuration
1659         # was found and let the user know that the "--tag" command
1660         # line option must be used.
1661         if test -z "$tagname"; then
1662           $echo "$modename: unable to infer tagged configuration"
1663           $echo "$modename: specify a tag with \`--tag'" 1>&2
1664           exit 1
1665 #       else
1666 #         $echo "$modename: using $tagname tagged configuration"
1667         fi
1668         ;;
1669       esac
1670     fi
1672     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1673       eval arg=\"$export_dynamic_flag_spec\"
1674       compile_command="$compile_command $arg"
1675       finalize_command="$finalize_command $arg"
1676     fi
1678     oldlibs=
1679     # calculate the name of the file, without its directory
1680     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1681     libobjs_save="$libobjs"
1683     if test -n "$shlibpath_var"; then
1684       # get the directories listed in $shlibpath_var
1685       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1686     else
1687       shlib_search_path=
1688     fi
1689     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1690     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1692     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1693     if test "X$output_objdir" = "X$output"; then
1694       output_objdir="$objdir"
1695     else
1696       output_objdir="$output_objdir/$objdir"
1697     fi
1698     # Create the object directory.
1699     if test ! -d "$output_objdir"; then
1700       $show "$mkdir $output_objdir"
1701       $run $mkdir $output_objdir
1702       status=$?
1703       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1704         exit $status
1705       fi
1706     fi
1708     # Determine the type of output
1709     case $output in
1710     "")
1711       $echo "$modename: you must specify an output file" 1>&2
1712       $echo "$help" 1>&2
1713       exit 1
1714       ;;
1715     *.$libext) linkmode=oldlib ;;
1716     *.lo | *.$objext) linkmode=obj ;;
1717     *.la) linkmode=lib ;;
1718     *) linkmode=prog ;; # Anything else should be a program.
1719     esac
1721     case $host in
1722     *cygwin* | *mingw* | *pw32*)
1723       # don't eliminate duplcations in $postdeps and $predeps
1724       duplicate_compiler_generated_deps=yes
1725       ;;
1726     *)
1727       duplicate_compiler_generated_deps=$duplicate_deps
1728       ;;
1729     esac
1730     specialdeplibs=
1732     libs=
1733     # Find all interdependent deplibs by searching for libraries
1734     # that are linked more than once (e.g. -la -lb -la)
1735     for deplib in $deplibs; do
1736       if test "X$duplicate_deps" = "Xyes" ; then
1737         case "$libs " in
1738         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1739         esac
1740       fi
1741       libs="$libs $deplib"
1742     done
1744     if test "$linkmode" = lib; then
1745       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1747       # Compute libraries that are listed more than once in $predeps
1748       # $postdeps and mark them as special (i.e., whose duplicates are
1749       # not to be eliminated).
1750       pre_post_deps=
1751       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1752         for pre_post_dep in $predeps $postdeps; do
1753           case "$pre_post_deps " in
1754           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1755           esac
1756           pre_post_deps="$pre_post_deps $pre_post_dep"
1757         done
1758       fi
1759       pre_post_deps=
1760     fi
1762     deplibs=
1763     newdependency_libs=
1764     newlib_search_path=
1765     need_relink=no # whether we're linking any uninstalled libtool libraries
1766     notinst_deplibs= # not-installed libtool libraries
1767     notinst_path= # paths that contain not-installed libtool libraries
1768     case $linkmode in
1769     lib)
1770         passes="conv link"
1771         for file in $dlfiles $dlprefiles; do
1772           case $file in
1773           *.la) ;;
1774           *)
1775             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1776             exit 1
1777             ;;
1778           esac
1779         done
1780         ;;
1781     prog)
1782         compile_deplibs=
1783         finalize_deplibs=
1784         alldeplibs=no
1785         newdlfiles=
1786         newdlprefiles=
1787         passes="conv scan dlopen dlpreopen link"
1788         ;;
1789     *)  passes="conv"
1790         ;;
1791     esac
1792     for pass in $passes; do
1793       if test "$linkmode,$pass" = "lib,link" ||
1794          test "$linkmode,$pass" = "prog,scan"; then
1795         libs="$deplibs"
1796         deplibs=
1797       fi
1798       if test "$linkmode" = prog; then
1799         case $pass in
1800         dlopen) libs="$dlfiles" ;;
1801         dlpreopen) libs="$dlprefiles" ;;
1802         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1803         esac
1804       fi
1805       if test "$pass" = dlopen; then
1806         # Collect dlpreopened libraries
1807         save_deplibs="$deplibs"
1808         deplibs=
1809       fi
1810       for deplib in $libs; do
1811         lib=
1812         found=no
1813         case $deplib in
1814         -l*)
1815           if test "$linkmode" != lib && test "$linkmode" != prog; then
1816             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1817             continue
1818           fi
1819           if test "$pass" = conv && test "$allow_undefined" = yes; then
1820             deplibs="$deplib $deplibs"
1821             continue
1822           fi
1823           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1824           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1825             for search_ext in .la $shrext .so .a; do
1826               # Search the libtool library
1827               lib="$searchdir/lib${name}${search_ext}"
1828               if test -f "$lib"; then
1829                 if test "$search_ext" = ".la"; then
1830                   found=yes
1831                 else
1832                   found=no
1833                 fi
1834                 break 2
1835               fi
1836             done
1837           done
1838           if test "$found" != yes; then
1839             # deplib doesn't seem to be a libtool library
1840             if test "$linkmode,$pass" = "prog,link"; then
1841               compile_deplibs="$deplib $compile_deplibs"
1842               finalize_deplibs="$deplib $finalize_deplibs"
1843             else
1844               deplibs="$deplib $deplibs"
1845               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1846             fi
1847             continue
1848           else # deplib is a libtool library
1849             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1850             # We need to do some special things here, and not later.
1851             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1852               case " $predeps $postdeps " in
1853               *" $deplib "*)
1854                 if (${SED} -e '2q' $lib |
1855                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1856                   library_names=
1857                   old_library=
1858                   case $lib in
1859                   */* | *\\*) . $lib ;;
1860                   *) . ./$lib ;;
1861                   esac
1862                   for l in $old_library $library_names; do
1863                     ll="$l"
1864                   done
1865                   if test "X$ll" = "X$old_library" ; then # only static version available
1866                     found=no
1867                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1868                     test "X$ladir" = "X$lib" && ladir="."
1869                     lib=$ladir/$old_library
1870                     if test "$linkmode,$pass" = "prog,link"; then
1871                       compile_deplibs="$deplib $compile_deplibs"
1872                       finalize_deplibs="$deplib $finalize_deplibs"
1873                     else
1874                       deplibs="$deplib $deplibs"
1875                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1876                     fi
1877                     continue
1878                   fi
1879                 fi
1880                 ;;
1881               *) ;;
1882               esac
1883             fi
1884           fi
1885           ;; # -l
1886         -L*)
1887           case $linkmode in
1888           lib)
1889             deplibs="$deplib $deplibs"
1890             test "$pass" = conv && continue
1891             newdependency_libs="$deplib $newdependency_libs"
1892             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1893             ;;
1894           prog)
1895             if test "$pass" = conv; then
1896               deplibs="$deplib $deplibs"
1897               continue
1898             fi
1899             if test "$pass" = scan; then
1900               deplibs="$deplib $deplibs"
1901               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1902             else
1903               compile_deplibs="$deplib $compile_deplibs"
1904               finalize_deplibs="$deplib $finalize_deplibs"
1905             fi
1906             ;;
1907           *)
1908             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1909             ;;
1910           esac # linkmode
1911           continue
1912           ;; # -L
1913         -R*)
1914           if test "$pass" = link; then
1915             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1916             # Make sure the xrpath contains only unique directories.
1917             case "$xrpath " in
1918             *" $dir "*) ;;
1919             *) xrpath="$xrpath $dir" ;;
1920             esac
1921           fi
1922           deplibs="$deplib $deplibs"
1923           continue
1924           ;;
1925         *.la) lib="$deplib" ;;
1926         *.$libext)
1927           if test "$pass" = conv; then
1928             deplibs="$deplib $deplibs"
1929             continue
1930           fi
1931           case $linkmode in
1932           lib)
1933             if test "$deplibs_check_method" != pass_all; then
1934               $echo
1935               $echo "*** Warning: Trying to link with static lib archive $deplib."
1936               $echo "*** I have the capability to make that library automatically link in when"
1937               $echo "*** you link to this library.  But I can only do this if you have a"
1938               $echo "*** shared version of the library, which you do not appear to have"
1939               $echo "*** because the file extensions .$libext of this argument makes me believe"
1940               $echo "*** that it is just a static archive that I should not used here."
1941             else
1942               $echo
1943               $echo "*** Warning: Linking the shared library $output against the"
1944               $echo "*** static library $deplib is not portable!"
1945               deplibs="$deplib $deplibs"
1946             fi
1947             continue
1948             ;;
1949           prog)
1950             if test "$pass" != link; then
1951               deplibs="$deplib $deplibs"
1952             else
1953               compile_deplibs="$deplib $compile_deplibs"
1954               finalize_deplibs="$deplib $finalize_deplibs"
1955             fi
1956             continue
1957             ;;
1958           esac # linkmode
1959           ;; # *.$libext
1960         *.lo | *.$objext)
1961           if test "$pass" = conv; then
1962             deplibs="$deplib $deplibs"
1963           elif test "$linkmode" = prog; then
1964             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1965               # If there is no dlopen support or we're linking statically,
1966               # we need to preload.
1967               newdlprefiles="$newdlprefiles $deplib"
1968               compile_deplibs="$deplib $compile_deplibs"
1969               finalize_deplibs="$deplib $finalize_deplibs"
1970             else
1971               newdlfiles="$newdlfiles $deplib"
1972             fi
1973           fi
1974           continue
1975           ;;
1976         %DEPLIBS%)
1977           alldeplibs=yes
1978           continue
1979           ;;
1980         esac # case $deplib
1981         if test "$found" = yes || test -f "$lib"; then :
1982         else
1983           $echo "$modename: cannot find the library \`$lib'" 1>&2
1984           exit 1
1985         fi
1987         # Check to see that this really is a libtool archive.
1988         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1989         else
1990           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1991           exit 1
1992         fi
1994         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1995         test "X$ladir" = "X$lib" && ladir="."
1997         dlname=
1998         dlopen=
1999         dlpreopen=
2000         libdir=
2001         library_names=
2002         old_library=
2003         # If the library was installed with an old release of libtool,
2004         # it will not redefine variables installed, or shouldnotlink
2005         installed=yes
2006         shouldnotlink=no
2008         # Read the .la file
2009         case $lib in
2010         */* | *\\*) . $lib ;;
2011         *) . ./$lib ;;
2012         esac
2014         if test "$linkmode,$pass" = "lib,link" ||
2015            test "$linkmode,$pass" = "prog,scan" ||
2016            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2017           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2018           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2019         fi
2021         if test "$pass" = conv; then
2022           # Only check for convenience libraries
2023           deplibs="$lib $deplibs"
2024           tmp_libs=
2025           for deplib in $dependency_libs; do
2026             #echo "Adding $deplib to \$deplibs"
2027             deplibs="$deplib $deplibs"
2028             if test "X$duplicate_deps" = "Xyes" ; then
2029               case "$tmp_libs " in
2030               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2031               esac
2032             fi
2033             tmp_libs="$tmp_libs $deplib"
2034           done
2035           if test -z "$libdir"; then
2036             if test -z "$old_library"; then
2037               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2038               exit 1
2039             fi
2040             # It is a libtool convenience library, so add in its objects.
2041             convenience="$convenience $ladir/$objdir/$old_library"
2042             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2043           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2044             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2045             exit 1
2046           fi
2047           continue
2048         fi # $pass = conv
2050     
2051         # Get the name of the library we link against.
2052         linklib=
2053         for l in $old_library $library_names; do
2054           linklib="$l"
2055         done
2056         if test -z "$linklib"; then
2057           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2058           exit 1
2059         fi
2061         # This library was specified with -dlopen.
2062         if test "$pass" = dlopen; then
2063           if test -z "$libdir"; then
2064             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2065             exit 1
2066           fi
2067           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2068             # If there is no dlname, no dlopen support or we're linking
2069             # statically, we need to preload.  We also need to preload any
2070             # dependent libraries so libltdl's deplib preloader doesn't
2071             # bomb out in the load deplibs phase.
2072             dlprefiles="$dlprefiles $lib $dependency_libs"
2073           else
2074             newdlfiles="$newdlfiles $lib"
2075           fi
2076           continue
2077         fi # $pass = dlopen
2079         # We need an absolute path.
2080         case $ladir in
2081         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2082         *)
2083           abs_ladir=`cd "$ladir" && pwd`
2084           if test -z "$abs_ladir"; then
2085             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2086             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2087             abs_ladir="$ladir"
2088           fi
2089           ;;
2090         esac
2091         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2093         # Find the relevant object directory and library name.
2094         if test "X$installed" = Xyes; then
2095           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2096             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2097             dir="$ladir"
2098             absdir="$abs_ladir"
2099             libdir="$abs_ladir"
2100           else
2101             dir="$libdir"
2102             absdir="$libdir"
2103           fi
2104         else
2105           dir="$ladir/$objdir"
2106           absdir="$abs_ladir/$objdir"
2107           # Remove this search path later
2108           notinst_path="$notinst_path $abs_ladir"
2109         fi # $installed = yes
2110         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2112         # This library was specified with -dlpreopen.
2113         if test "$pass" = dlpreopen; then
2114           if test -z "$libdir"; then
2115             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2116             exit 1
2117           fi
2118           # Prefer using a static library (so that no silly _DYNAMIC symbols
2119           # are required to link).
2120           if test -n "$old_library"; then
2121             newdlprefiles="$newdlprefiles $dir/$old_library"
2122           # Otherwise, use the dlname, so that lt_dlopen finds it.
2123           elif test -n "$dlname"; then
2124             newdlprefiles="$newdlprefiles $dir/$dlname"
2125           else
2126             newdlprefiles="$newdlprefiles $dir/$linklib"
2127           fi
2128         fi # $pass = dlpreopen
2130         if test -z "$libdir"; then
2131           # Link the convenience library
2132           if test "$linkmode" = lib; then
2133             deplibs="$dir/$old_library $deplibs"
2134           elif test "$linkmode,$pass" = "prog,link"; then
2135             compile_deplibs="$dir/$old_library $compile_deplibs"
2136             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2137           else
2138             deplibs="$lib $deplibs" # used for prog,scan pass
2139           fi
2140           continue
2141         fi
2143     
2144         if test "$linkmode" = prog && test "$pass" != link; then
2145           newlib_search_path="$newlib_search_path $ladir"
2146           deplibs="$lib $deplibs"
2148           linkalldeplibs=no
2149           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2150              test "$build_libtool_libs" = no; then
2151             linkalldeplibs=yes
2152           fi
2154           tmp_libs=
2155           for deplib in $dependency_libs; do
2156             case $deplib in
2157             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2158             esac
2159             # Need to link against all dependency_libs?
2160             if test "$linkalldeplibs" = yes; then
2161               deplibs="$deplib $deplibs"
2162             else
2163               # Need to hardcode shared library paths
2164               # or/and link against static libraries
2165               newdependency_libs="$deplib $newdependency_libs"
2166             fi
2167             if test "X$duplicate_deps" = "Xyes" ; then
2168               case "$tmp_libs " in
2169               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2170               esac
2171             fi
2172             tmp_libs="$tmp_libs $deplib"
2173           done # for deplib
2174           continue
2175         fi # $linkmode = prog...
2177         if test "$linkmode,$pass" = "prog,link"; then
2178           if test -n "$library_names" &&
2179              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2180             # We need to hardcode the library path
2181             if test -n "$shlibpath_var"; then
2182               # Make sure the rpath contains only unique directories.
2183               case "$temp_rpath " in
2184               *" $dir "*) ;;
2185               *" $absdir "*) ;;
2186               *) temp_rpath="$temp_rpath $dir" ;;
2187               esac
2188             fi
2190             # Hardcode the library path.
2191             # Skip directories that are in the system default run-time
2192             # search path.
2193             case " $sys_lib_dlsearch_path " in
2194             *" $absdir "*) ;;
2195             *)
2196               case "$compile_rpath " in
2197               *" $absdir "*) ;;
2198               *) compile_rpath="$compile_rpath $absdir"
2199               esac
2200               ;;
2201             esac
2202             case " $sys_lib_dlsearch_path " in
2203             *" $libdir "*) ;;
2204             *)
2205               case "$finalize_rpath " in
2206               *" $libdir "*) ;;
2207               *) finalize_rpath="$finalize_rpath $libdir"
2208               esac
2209               ;;
2210             esac
2211           fi # $linkmode,$pass = prog,link...
2213           if test "$alldeplibs" = yes &&
2214              { test "$deplibs_check_method" = pass_all ||
2215                { test "$build_libtool_libs" = yes &&
2216                  test -n "$library_names"; }; }; then
2217             # We only need to search for static libraries
2218             continue
2219           fi
2220         fi
2222         link_static=no # Whether the deplib will be linked statically
2223         if test -n "$library_names" &&
2224            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2225           if test "$installed" = no; then
2226             notinst_deplibs="$notinst_deplibs $lib"
2227             need_relink=yes
2228           fi
2229           # This is a shared library
2230         
2231       # Warn about portability, can't link against -module's on some systems (darwin)
2232       if test "$shouldnotlink" = yes && test "$pass" = link ; then
2233             $echo
2234             if test "$linkmode" = prog; then
2235               $echo "*** Warning: Linking the executable $output against the loadable module"
2236             else
2237               $echo "*** Warning: Linking the shared library $output against the loadable module"
2238             fi
2239             $echo "*** $linklib is not portable!"    
2240       fi          
2241           if test "$linkmode" = lib &&
2242              test "$hardcode_into_libs" = yes; then
2243             # Hardcode the library path.
2244             # Skip directories that are in the system default run-time
2245             # search path.
2246             case " $sys_lib_dlsearch_path " in
2247             *" $absdir "*) ;;
2248             *)
2249               case "$compile_rpath " in
2250               *" $absdir "*) ;;
2251               *) compile_rpath="$compile_rpath $absdir"
2252               esac
2253               ;;
2254             esac
2255             case " $sys_lib_dlsearch_path " in
2256             *" $libdir "*) ;;
2257             *)
2258               case "$finalize_rpath " in
2259               *" $libdir "*) ;;
2260               *) finalize_rpath="$finalize_rpath $libdir"
2261               esac
2262               ;;
2263             esac
2264           fi
2266           if test -n "$old_archive_from_expsyms_cmds"; then
2267             # figure out the soname
2268             set dummy $library_names
2269             realname="$2"
2270             shift; shift
2271             libname=`eval \\$echo \"$libname_spec\"`
2272             # use dlname if we got it. it's perfectly good, no?
2273             if test -n "$dlname"; then
2274               soname="$dlname"
2275             elif test -n "$soname_spec"; then
2276               # bleh windows
2277               case $host in
2278               *cygwin* | mingw*)
2279                 major=`expr $current - $age`
2280                 versuffix="-$major"
2281                 ;;
2282               esac
2283               eval soname=\"$soname_spec\"
2284             else
2285               soname="$realname"
2286             fi
2288             # Make a new name for the extract_expsyms_cmds to use
2289             soroot="$soname"
2290             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2291             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2293             # If the library has no export list, then create one now
2294             if test -f "$output_objdir/$soname-def"; then :
2295             else
2296               $show "extracting exported symbol list from \`$soname'"
2297               save_ifs="$IFS"; IFS='~'
2298               eval cmds=\"$extract_expsyms_cmds\"
2299               for cmd in $cmds; do
2300                 IFS="$save_ifs"
2301                 $show "$cmd"
2302                 $run eval "$cmd" || exit $?
2303               done
2304               IFS="$save_ifs"
2305             fi
2307             # Create $newlib
2308             if test -f "$output_objdir/$newlib"; then :; else
2309               $show "generating import library for \`$soname'"
2310               save_ifs="$IFS"; IFS='~'
2311               eval cmds=\"$old_archive_from_expsyms_cmds\"
2312               for cmd in $cmds; do
2313                 IFS="$save_ifs"
2314                 $show "$cmd"
2315                 $run eval "$cmd" || exit $?
2316               done
2317               IFS="$save_ifs"
2318             fi
2319             # make sure the library variables are pointing to the new library
2320             dir=$output_objdir
2321             linklib=$newlib
2322           fi # test -n "$old_archive_from_expsyms_cmds"
2324           if test "$linkmode" = prog || test "$mode" != relink; then
2325             add_shlibpath=
2326             add_dir=
2327             add=
2328             lib_linked=yes
2329             case $hardcode_action in
2330             immediate | unsupported)
2331               if test "$hardcode_direct" = no; then
2332                 add="$dir/$linklib"
2333                 case $host in
2334                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2335                   *-*-darwin* )
2336                     # if the lib is a module then we can not link against it, someone
2337                     # is ignoring the new warnings I added
2338                     if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
2339                       $echo "** Warning, lib $linklib is a module, not a shared library"
2340                       if test -z "$old_library" ; then
2341                         $echo
2342                         $echo "** And there doesn't seem to be a static archive available"
2343                         $echo "** The link will probably fail, sorry"
2344                       else
2345                         add="$dir/$old_library"
2346                       fi 
2347                     fi
2348                 esac
2349               elif test "$hardcode_minus_L" = no; then
2350                 case $host in
2351                 *-*-sunos*) add_shlibpath="$dir" ;;
2352                 esac
2353                 add_dir="-L$dir"
2354                 add="-l$name"
2355               elif test "$hardcode_shlibpath_var" = no; then
2356                 add_shlibpath="$dir"
2357                 add="-l$name"
2358               else
2359                 lib_linked=no
2360               fi
2361               ;;
2362             relink)
2363               if test "$hardcode_direct" = yes; then
2364                 add="$dir/$linklib"
2365               elif test "$hardcode_minus_L" = yes; then
2366                 add_dir="-L$dir"
2367                 # Try looking first in the location we're being installed to.
2368                 if test -n "$inst_prefix_dir"; then
2369                   case "$libdir" in
2370                     [\\/]*)
2371                       add_dir="-L$inst_prefix_dir$libdir $add_dir"
2372                       ;;
2373                   esac
2374                 fi
2375                 add="-l$name"
2376               elif test "$hardcode_shlibpath_var" = yes; then
2377                 add_shlibpath="$dir"
2378                 add="-l$name"
2379               else
2380                 lib_linked=no
2381               fi
2382               ;;
2383             *) lib_linked=no ;;
2384             esac
2386             if test "$lib_linked" != yes; then
2387               $echo "$modename: configuration error: unsupported hardcode properties"
2388               exit 1
2389             fi
2391             if test -n "$add_shlibpath"; then
2392               case :$compile_shlibpath: in
2393               *":$add_shlibpath:"*) ;;
2394               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2395               esac
2396             fi
2397             if test "$linkmode" = prog; then
2398               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2399               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2400             else
2401               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2402               test -n "$add" && deplibs="$add $deplibs"
2403               if test "$hardcode_direct" != yes && \
2404                  test "$hardcode_minus_L" != yes && \
2405                  test "$hardcode_shlibpath_var" = yes; then
2406                 case :$finalize_shlibpath: in
2407                 *":$libdir:"*) ;;
2408                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2409                 esac
2410               fi
2411             fi
2412           fi
2414           if test "$linkmode" = prog || test "$mode" = relink; then
2415             add_shlibpath=
2416             add_dir=
2417             add=
2418             # Finalize command for both is simple: just hardcode it.
2419             if test "$hardcode_direct" = yes; then
2420               add="$libdir/$linklib"
2421             elif test "$hardcode_minus_L" = yes; then
2422               add_dir="-L$libdir"
2423               add="-l$name"
2424             elif test "$hardcode_shlibpath_var" = yes; then
2425               case :$finalize_shlibpath: in
2426               *":$libdir:"*) ;;
2427               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2428               esac
2429               add="-l$name"
2430             elif test "$hardcode_automatic" = yes; then
2431               if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
2432                 add="$inst_prefix_dir$libdir/$linklib"
2433               else
2434                 add="$libdir/$linklib"
2435               fi
2436             else
2437               # We cannot seem to hardcode it, guess we'll fake it.
2438               add_dir="-L$libdir"
2439               # Try looking first in the location we're being installed to.
2440               if test -n "$inst_prefix_dir"; then
2441                 case "$libdir" in
2442                   [\\/]*)
2443                     add_dir="-L$inst_prefix_dir$libdir $add_dir"
2444                     ;;
2445                 esac
2446               fi
2447               add="-l$name"
2448             fi
2450             if test "$linkmode" = prog; then
2451               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2452               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2453             else
2454               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2455               test -n "$add" && deplibs="$add $deplibs"
2456             fi
2457           fi
2458         elif test "$linkmode" = prog; then
2459           # Here we assume that one of hardcode_direct or hardcode_minus_L
2460           # is not unsupported.  This is valid on all known static and
2461           # shared platforms.
2462           if test "$hardcode_direct" != unsupported; then
2463             test -n "$old_library" && linklib="$old_library"
2464             compile_deplibs="$dir/$linklib $compile_deplibs"
2465             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2466           else
2467             compile_deplibs="-l$name -L$dir $compile_deplibs"
2468             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2469           fi
2470         elif test "$build_libtool_libs" = yes; then
2471           # Not a shared library
2472           if test "$deplibs_check_method" != pass_all; then
2473             # We're trying link a shared library against a static one
2474             # but the system doesn't support it.
2476             # Just print a warning and add the library to dependency_libs so
2477             # that the program can be linked against the static library.
2478             $echo
2479             $echo "*** Warning: This system can not link to static lib archive $lib."
2480             $echo "*** I have the capability to make that library automatically link in when"
2481             $echo "*** you link to this library.  But I can only do this if you have a"
2482             $echo "*** shared version of the library, which you do not appear to have."
2483             if test "$module" = yes; then
2484               $echo "*** But as you try to build a module library, libtool will still create "
2485               $echo "*** a static module, that should work as long as the dlopening application"
2486               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2487               if test -z "$global_symbol_pipe"; then
2488                 $echo
2489                 $echo "*** However, this would only work if libtool was able to extract symbol"
2490                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2491                 $echo "*** not find such a program.  So, this module is probably useless."
2492                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2493               fi
2494               if test "$build_old_libs" = no; then
2495                 build_libtool_libs=module
2496                 build_old_libs=yes
2497               else
2498                 build_libtool_libs=no
2499               fi
2500             fi
2501           else
2502             convenience="$convenience $dir/$old_library"
2503             old_convenience="$old_convenience $dir/$old_library"
2504             deplibs="$dir/$old_library $deplibs"
2505             link_static=yes
2506           fi
2507         fi # link shared/static library?
2509         if test "$linkmode" = lib; then
2510           #if test -n "$dependency_libs" &&
2511           #   { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
2512           #     test "$link_static" = yes; }; then
2513             # Extract -R from dependency_libs
2514             temp_deplibs=
2515             for libdir in $dependency_libs; do
2516               case $libdir in
2517               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2518                    case " $xrpath " in
2519                    *" $temp_xrpath "*) ;;
2520                    *) xrpath="$xrpath $temp_xrpath";;
2521                    esac;;
2522               *) temp_deplibs="$temp_deplibs $libdir";;
2523               esac
2524             done
2525             dependency_libs="$temp_deplibs"
2526           #fi
2528           newlib_search_path="$newlib_search_path $absdir"
2529           # Link against this library
2530           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2531           # ... and its dependency_libs
2532           tmp_libs=
2533           for deplib in $dependency_libs; do
2534             newdependency_libs="$deplib $newdependency_libs"
2535             if test "X$duplicate_deps" = "Xyes" ; then
2536               case "$tmp_libs " in
2537               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2538               esac
2539             fi
2540             tmp_libs="$tmp_libs $deplib"
2541           done
2543           if test "$link_all_deplibs" != no; then
2544             # Add the search paths of all dependency libraries
2545             for deplib in $dependency_libs; do
2546               case $deplib in
2547               -L*) path="$deplib" ;;
2548               *.la)
2549                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2550                 test "X$dir" = "X$deplib" && dir="."
2551                 # We need an absolute path.
2552                 case $dir in
2553                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2554                 *)
2555                   absdir=`cd "$dir" && pwd`
2556                   if test -z "$absdir"; then
2557                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2558                     absdir="$dir"
2559                   fi
2560                   ;;
2561                 esac
2562                 if grep "^installed=no" $deplib > /dev/null; then
2563                   path="$absdir/$objdir"
2564                 else
2565                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2566                   if test -z "$libdir"; then
2567                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2568                     exit 1
2569                   fi
2570                   if test "$absdir" != "$libdir"; then
2571                     # Sure, some shells/systems don't implement the -ef.
2572                     # Those will have to live with the warning.
2573                     test "$absdir" -ef "$libdir" > /dev/null 2>&1 ||
2574                       $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2575                   fi
2576                   path="$absdir"
2577                 fi
2578                 depdepl=
2579                 case $host in
2580                 *-*-darwin*)
2581                   # we do not want to link against static libs, but need to link against shared
2582                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2583                   if test -n "$deplibrary_names" ; then
2584                     for tmp in $deplibrary_names ; do
2585                       depdepl=$tmp
2586                     done
2587                     if test -f "$path/$depdepl" ; then
2588                       depdepl="$path/$depdepl"
2589                    fi
2590                     # do not add paths which are already there
2591                     case " $newlib_search_path " in
2592                     *" $path "*) ;;
2593                     *) newlib_search_path="$newlib_search_path $path";;
2594                     esac
2595                     path=""
2596                   fi
2597                   ;;
2598                 *)
2599                 path="-L$path"
2600                 ;;
2601                 esac 
2602                 
2603                 ;;
2604                   -l*)
2605                 case $host in
2606                 *-*-darwin*)
2607                  # Again, we only want to link against shared libraries
2608                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2609                  for tmp in $newlib_search_path ; do
2610                      if test -f "$tmp/lib$tmp_libs.dylib" ; then
2611                        eval depdepl="$tmp/lib$tmp_libs.dylib"
2612                        break
2613                      fi  
2614          done
2615          path=""
2616                   ;;
2617                 *) continue ;;
2618                 esac              
2619                 ;;
2620               *) continue ;;
2621               esac
2622               case " $deplibs " in
2623               *" $depdepl "*) ;;
2624               *) deplibs="$deplibs $depdepl" ;;
2625               esac            
2626               case " $deplibs " in
2627               *" $path "*) ;;
2628               *) deplibs="$deplibs $path" ;;
2629               esac
2630             done
2631           fi # link_all_deplibs != no
2632         fi # linkmode = lib
2633       done # for deplib in $libs
2634       dependency_libs="$newdependency_libs"
2635       if test "$pass" = dlpreopen; then
2636         # Link the dlpreopened libraries before other libraries
2637         for deplib in $save_deplibs; do
2638           deplibs="$deplib $deplibs"
2639         done
2640       fi
2641       if test "$pass" != dlopen; then
2642         if test "$pass" != conv; then
2643           # Make sure lib_search_path contains only unique directories.
2644           lib_search_path=
2645           for dir in $newlib_search_path; do
2646             case "$lib_search_path " in
2647             *" $dir "*) ;;
2648             *) lib_search_path="$lib_search_path $dir" ;;
2649             esac
2650           done
2651           newlib_search_path=
2652         fi
2654         if test "$linkmode,$pass" != "prog,link"; then
2655           vars="deplibs"
2656         else
2657           vars="compile_deplibs finalize_deplibs"
2658         fi
2659         for var in $vars dependency_libs; do
2660           # Add libraries to $var in reverse order
2661           eval tmp_libs=\"\$$var\"
2662           new_libs=
2663           for deplib in $tmp_libs; do
2664             # FIXME: Pedantically, this is the right thing to do, so
2665             #        that some nasty dependency loop isn't accidentally
2666             #        broken:
2667             #new_libs="$deplib $new_libs"
2668             # Pragmatically, this seems to cause very few problems in
2669             # practice:
2670             case $deplib in
2671             -L*) new_libs="$deplib $new_libs" ;;
2672             -R*) ;;
2673             *)
2674               # And here is the reason: when a library appears more
2675               # than once as an explicit dependence of a library, or
2676               # is implicitly linked in more than once by the
2677               # compiler, it is considered special, and multiple
2678               # occurrences thereof are not removed.  Compare this
2679               # with having the same library being listed as a
2680               # dependency of multiple other libraries: in this case,
2681               # we know (pedantically, we assume) the library does not
2682               # need to be listed more than once, so we keep only the
2683               # last copy.  This is not always right, but it is rare
2684               # enough that we require users that really mean to play
2685               # such unportable linking tricks to link the library
2686               # using -Wl,-lname, so that libtool does not consider it
2687               # for duplicate removal.
2688               case " $specialdeplibs " in
2689               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2690               *)
2691                 case " $new_libs " in
2692                 *" $deplib "*) ;;
2693                 *) new_libs="$deplib $new_libs" ;;
2694                 esac
2695                 ;;
2696               esac
2697               ;;
2698             esac
2699           done
2700           tmp_libs=
2701           for deplib in $new_libs; do
2702             case $deplib in
2703             -L*)
2704               case " $tmp_libs " in
2705               *" $deplib "*) ;;
2706               *) tmp_libs="$tmp_libs $deplib" ;;
2707               esac
2708               ;;
2709             *) tmp_libs="$tmp_libs $deplib" ;;
2710             esac
2711           done
2712           eval $var=\"$tmp_libs\"
2713         done # for var
2714       fi
2715       # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
2716       tmp_libs=
2717       for i in $dependency_libs ; do
2718         case " $predeps $postdeps $compiler_lib_search_path " in
2719         *" $i "*)
2720           i=""
2721           ;;
2722         esac
2723         if test -n "$i" ; then
2724           tmp_libs="$tmp_libs $i"
2725         fi
2726       done
2727       dependency_libs=$tmp_libs
2728     done # for pass
2729     if test "$linkmode" = prog; then
2730       dlfiles="$newdlfiles"
2731       dlprefiles="$newdlprefiles"
2732     fi
2734     case $linkmode in
2735     oldlib)
2736       if test -n "$deplibs"; then
2737         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2738       fi
2740       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2741         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2742       fi
2744       if test -n "$rpath"; then
2745         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2746       fi
2748       if test -n "$xrpath"; then
2749         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2750       fi
2752       if test -n "$vinfo"; then
2753         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2754       fi
2756       if test -n "$release"; then
2757         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2758       fi
2760       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2761         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2762       fi
2764       # Now set the variables for building old libraries.
2765       build_libtool_libs=no
2766       oldlibs="$output"
2767       objs="$objs$old_deplibs"
2768       ;;
2770     lib)
2771       # Make sure we only generate libraries of the form `libNAME.la'.
2772       case $outputname in
2773       lib*)
2774         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2775         eval shared_ext=\"$shrext\"
2776         eval libname=\"$libname_spec\"
2777         ;;
2778       *)
2779         if test "$module" = no; then
2780           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2781           $echo "$help" 1>&2
2782           exit 1
2783         fi
2784         if test "$need_lib_prefix" != no; then
2785           # Add the "lib" prefix for modules if required
2786           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2787           eval shared_ext=\"$shrext\"
2788           eval libname=\"$libname_spec\"
2789         else
2790           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2791         fi
2792         ;;
2793       esac
2795       if test -n "$objs"; then
2796         if test "$deplibs_check_method" != pass_all; then
2797           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2798           exit 1
2799         else
2800           $echo
2801           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2802           $echo "*** objects $objs is not portable!"
2803           libobjs="$libobjs $objs"
2804         fi
2805       fi
2807       if test "$dlself" != no; then
2808         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2809       fi
2811       set dummy $rpath
2812       if test "$#" -gt 2; then
2813         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2814       fi
2815       install_libdir="$2"
2817       oldlibs=
2818       if test -z "$rpath"; then
2819         if test "$build_libtool_libs" = yes; then
2820           # Building a libtool convenience library.
2821           # Some compilers have problems with a `.al' extension so
2822           # convenience libraries should have the same extension an
2823           # archive normally would.
2824           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2825           build_libtool_libs=convenience
2826           build_old_libs=yes
2827         fi
2829         if test -n "$vinfo"; then
2830           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2831         fi
2833         if test -n "$release"; then
2834           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2835         fi
2836       else
2838         # Parse the version information argument.
2839         save_ifs="$IFS"; IFS=':'
2840         set dummy $vinfo 0 0 0
2841         IFS="$save_ifs"
2843         if test -n "$8"; then
2844           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2845           $echo "$help" 1>&2
2846           exit 1
2847         fi
2849         # convert absolute version numbers to libtool ages
2850         # this retains compatibility with .la files and attempts
2851         # to make the code below a bit more comprehensible
2852         
2853         case $vinfo_number in
2854         yes)
2855           number_major="$2"
2856           number_minor="$3"
2857           number_revision="$4"
2858           #
2859           # There are really only two kinds -- those that
2860           # use the current revision as the major version
2861           # and those that subtract age and use age as
2862           # a minor version.  But, then there is irix
2863           # which has an extra 1 added just for fun
2864           #
2865           case $version_type in
2866           darwin|linux|osf|windows)
2867             current=`expr $number_major + $number_minor`
2868             age="$number_minor"
2869             revision="$number_revision"
2870             ;;
2871           freebsd-aout|freebsd-elf|sunos)
2872             current="$number_major"
2873             revision="$number_minor"
2874             age="0"
2875             ;;
2876           irix|nonstopux)
2877             current=`expr $number_major + $number_minor - 1`
2878             age="$number_minor"
2879             revision="$number_minor"
2880             ;;
2881           esac
2882           ;;
2883         no)
2884           current="$2"
2885           revision="$3"
2886           age="$4"
2887           ;;
2888         esac
2890         # Check that each of the things are valid numbers.
2891         case $current in
2892         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2893         *)
2894           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2895           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2896           exit 1
2897           ;;
2898         esac
2900         case $revision in
2901         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2902         *)
2903           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2904           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2905           exit 1
2906           ;;
2907         esac
2909         case $age in
2910         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2911         *)
2912           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2913           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2914           exit 1
2915           ;;
2916         esac
2918         if test "$age" -gt "$current"; then
2919           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2920           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2921           exit 1
2922         fi
2924         # Calculate the version variables.
2925         major=
2926         versuffix=
2927         verstring=
2928         case $version_type in
2929         none) ;;
2931         darwin)
2932           # Like Linux, but with the current version available in
2933           # verstring for coding it into the library header
2934           major=.`expr $current - $age`
2935           versuffix="$major.$age.$revision"
2936           # Darwin ld doesn't like 0 for these options...
2937           minor_current=`expr $current + 1`
2938           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2939           ;;
2941         freebsd-aout)
2942           major=".$current"
2943           versuffix=".$current.$revision";
2944           ;;
2946         freebsd-elf)
2947           major=".$current"
2948           versuffix=".$current";
2949           ;;
2951         irix | nonstopux)
2952           major=`expr $current - $age + 1`
2954           case $version_type in
2955             nonstopux) verstring_prefix=nonstopux ;;
2956             *)         verstring_prefix=sgi ;;
2957           esac
2958           verstring="$verstring_prefix$major.$revision"
2960           # Add in all the interfaces that we are compatible with.
2961           loop=$revision
2962           while test "$loop" -ne 0; do
2963             iface=`expr $revision - $loop`
2964             loop=`expr $loop - 1`
2965             verstring="$verstring_prefix$major.$iface:$verstring"
2966           done
2968           # Before this point, $major must not contain `.'.
2969           major=.$major
2970           versuffix="$major.$revision"
2971           ;;
2973         linux)
2974           major=.`expr $current - $age`
2975           versuffix="$major.$age.$revision"
2976           ;;
2978         osf)
2979           major=.`expr $current - $age`
2980           versuffix=".$current.$age.$revision"
2981           verstring="$current.$age.$revision"
2983           # Add in all the interfaces that we are compatible with.
2984           loop=$age
2985           while test "$loop" -ne 0; do
2986             iface=`expr $current - $loop`
2987             loop=`expr $loop - 1`
2988             verstring="$verstring:${iface}.0"
2989           done
2991           # Make executables depend on our current version.
2992           verstring="$verstring:${current}.0"
2993           ;;
2995         sunos)
2996           major=".$current"
2997           versuffix=".$current.$revision"
2998           ;;
3000         windows)
3001           # Use '-' rather than '.', since we only want one
3002           # extension on DOS 8.3 filesystems.
3003           major=`expr $current - $age`
3004           versuffix="-$major"
3005           ;;
3007         *)
3008           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3009           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3010           exit 1
3011           ;;
3012         esac
3014         # Clear the version info if we defaulted, and they specified a release.
3015         if test -z "$vinfo" && test -n "$release"; then
3016           major=
3017           case $version_type in
3018           darwin)
3019             # we can't check for "0.0" in archive_cmds due to quoting
3020             # problems, so we reset it completely
3021             verstring=
3022             ;;
3023           *)
3024             verstring="0.0"
3025             ;;
3026           esac
3027           if test "$need_version" = no; then
3028             versuffix=
3029           else
3030             versuffix=".0.0"
3031           fi
3032         fi
3034         # Remove version info from name if versioning should be avoided
3035         if test "$avoid_version" = yes && test "$need_version" = no; then
3036           major=
3037           versuffix=
3038           verstring=""
3039         fi
3041         # Check to see if the archive will have undefined symbols.
3042         if test "$allow_undefined" = yes; then
3043           if test "$allow_undefined_flag" = unsupported; then
3044             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3045             build_libtool_libs=no
3046             build_old_libs=yes
3047           fi
3048         else
3049           # Don't allow undefined symbols.
3050           allow_undefined_flag="$no_undefined_flag"
3051         fi
3052       fi
3054       if test "$mode" != relink; then
3055         # Remove our outputs, but don't remove object files since they
3056         # may have been created when compiling PIC objects.
3057         removelist=
3058         tempremovelist=`$echo "$output_objdir/*"`
3059         for p in $tempremovelist; do
3060           case $p in
3061             *.$objext)
3062                ;;
3063             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3064                removelist="$removelist $p"
3065                ;;
3066             *) ;;
3067           esac
3068         done
3069         if test -n "$removelist"; then
3070           $show "${rm}r $removelist"
3071           $run ${rm}r $removelist
3072         fi
3073       fi
3075       # Now set the variables for building old libraries.
3076       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3077         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3079         # Transform .lo files to .o files.
3080         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3081       fi
3083       # Eliminate all temporary directories.
3084       for path in $notinst_path; do
3085         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3086         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3087         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3088       done
3090       if test -n "$xrpath"; then
3091         # If the user specified any rpath flags, then add them.
3092         temp_xrpath=
3093         for libdir in $xrpath; do
3094           temp_xrpath="$temp_xrpath -R$libdir"
3095           case "$finalize_rpath " in
3096           *" $libdir "*) ;;
3097           *) finalize_rpath="$finalize_rpath $libdir" ;;
3098           esac
3099         done
3100         if true || test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3101           dependency_libs="$temp_xrpath $dependency_libs"
3102         fi
3103       fi
3105       # Make sure dlfiles contains only unique files that won't be dlpreopened
3106       old_dlfiles="$dlfiles"
3107       dlfiles=
3108       for lib in $old_dlfiles; do
3109         case " $dlprefiles $dlfiles " in
3110         *" $lib "*) ;;
3111         *) dlfiles="$dlfiles $lib" ;;
3112         esac
3113       done
3115       # Make sure dlprefiles contains only unique files
3116       old_dlprefiles="$dlprefiles"
3117       dlprefiles=
3118       for lib in $old_dlprefiles; do
3119         case "$dlprefiles " in
3120         *" $lib "*) ;;
3121         *) dlprefiles="$dlprefiles $lib" ;;
3122         esac
3123       done
3125       if test "$build_libtool_libs" = yes; then
3126         if test -n "$rpath"; then
3127           case $host in
3128           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3129             # these systems don't actually have a c library (as such)!
3130             ;;
3131           *-*-rhapsody* | *-*-darwin1.[012])
3132             # Rhapsody C library is in the System framework
3133             deplibs="$deplibs -framework System"
3134             ;;
3135           *-*-netbsd*)
3136             # Don't link with libc until the a.out ld.so is fixed.
3137             ;;
3138           *-*-freebsd*-gnu*)
3139             # Prevent $arg from being parsed by the freebsd regexp below.
3140             if test "$build_libtool_need_lc" = "yes"; then
3141               deplibs="$deplibs -lc"
3142             fi
3143             ;;
3144           *-*-openbsd* | *-*-freebsd*)
3145             # Do not include libc due to us having libc/libc_r.
3146             test "X$arg" = "X-lc" && continue
3147             ;;
3148           *)
3149             # Add libc to deplibs on all other systems if necessary.
3150             if test "$build_libtool_need_lc" = "yes"; then
3151               deplibs="$deplibs -lc"
3152             fi
3153             ;;
3154           esac
3155         fi
3157         # Transform deplibs into only deplibs that can be linked in shared.
3158         name_save=$name
3159         libname_save=$libname
3160         release_save=$release
3161         versuffix_save=$versuffix
3162         major_save=$major
3163         # I'm not sure if I'm treating the release correctly.  I think
3164         # release should show up in the -l (ie -lgmp5) so we don't want to
3165         # add it in twice.  Is that correct?
3166         release=""
3167         versuffix=""
3168         major=""
3169         newdeplibs=
3170         droppeddeps=no
3171         case $deplibs_check_method in
3172         pass_all)
3173           # Don't check for shared/static.  Everything works.
3174           # This might be a little naive.  We might want to check
3175           # whether the library exists or not.  But this is on
3176           # osf3 & osf4 and I'm not really sure... Just
3177           # implementing what was already the behavior.
3178           newdeplibs=$deplibs
3179           ;;
3180         test_compile)
3181           # This code stresses the "libraries are programs" paradigm to its
3182           # limits. Maybe even breaks it.  We compile a program, linking it
3183           # against the deplibs as a proxy for the library.  Then we can check
3184           # whether they linked in statically or dynamically with ldd.
3185           $rm conftest.c
3186           cat > conftest.c <<EOF
3187           int main() { return 0; }
3188 EOF
3189           $rm conftest
3190           $LTCC -o conftest conftest.c $deplibs
3191           if test "$?" -eq 0 ; then
3192             ldd_output=`ldd conftest`
3193             for i in $deplibs; do
3194               name="`expr $i : '-l\(.*\)'`"
3195               # If $name is empty we are operating on a -L argument.
3196               if test "$name" != "" && test "$name" -ne "0"; then
3197                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3198                   case " $predeps $postdeps " in
3199                   *" $i "*)
3200                     newdeplibs="$newdeplibs $i"
3201                     i=""
3202                     ;;
3203                   esac
3204                 fi
3205                 if test -n "$i" ; then
3206                   libname=`eval \\$echo \"$libname_spec\"`
3207                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3208                   set dummy $deplib_matches
3209                   deplib_match=$2
3210                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3211                     newdeplibs="$newdeplibs $i"
3212                   else
3213                     droppeddeps=yes
3214                     $echo
3215                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3216                     $echo "*** I have the capability to make that library automatically link in when"
3217                     $echo "*** you link to this library.  But I can only do this if you have a"
3218                     $echo "*** shared version of the library, which I believe you do not have"
3219                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3220                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3221                   fi
3222                 fi
3223               else
3224                 newdeplibs="$newdeplibs $i"
3225               fi
3226             done
3227           else
3228             # Error occurred in the first compile.  Let's try to salvage
3229             # the situation: Compile a separate program for each library.
3230             for i in $deplibs; do
3231               name="`expr $i : '-l\(.*\)'`"
3232               # If $name is empty we are operating on a -L argument.
3233               if test "$name" != "" && test "$name" != "0"; then
3234                 $rm conftest
3235                 $LTCC -o conftest conftest.c $i
3236                 # Did it work?
3237                 if test "$?" -eq 0 ; then
3238                   ldd_output=`ldd conftest`
3239                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3240                     case " $predeps $postdeps " in
3241                     *" $i "*)
3242                       newdeplibs="$newdeplibs $i"
3243                       i=""
3244                       ;;
3245                     esac
3246                   fi
3247                   if test -n "$i" ; then
3248                     libname=`eval \\$echo \"$libname_spec\"`
3249                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3250                     set dummy $deplib_matches
3251                     deplib_match=$2
3252                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3253                       newdeplibs="$newdeplibs $i"
3254                     else
3255                       droppeddeps=yes
3256                       $echo
3257                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3258                       $echo "*** I have the capability to make that library automatically link in when"
3259                       $echo "*** you link to this library.  But I can only do this if you have a"
3260                       $echo "*** shared version of the library, which you do not appear to have"
3261                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3262                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3263                     fi
3264                   fi
3265                 else
3266                   droppeddeps=yes
3267                   $echo
3268                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3269                   $echo "***  make it link in!  You will probably need to install it or some"
3270                   $echo "*** library that it depends on before this library will be fully"
3271                   $echo "*** functional.  Installing it before continuing would be even better."
3272                 fi
3273               else
3274                 newdeplibs="$newdeplibs $i"
3275               fi
3276             done
3277           fi
3278           ;;
3279         file_magic*)
3280           set dummy $deplibs_check_method
3281           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3282           for a_deplib in $deplibs; do
3283             name="`expr $a_deplib : '-l\(.*\)'`"
3284             # If $name is empty we are operating on a -L argument.
3285             if test "$name" != "" && test  "$name" != "0"; then
3286               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3287                 case " $predeps $postdeps " in
3288                 *" $a_deplib "*)
3289                   newdeplibs="$newdeplibs $a_deplib"
3290                   a_deplib=""
3291                   ;;
3292                 esac
3293               fi
3294               if test -n "$a_deplib" ; then
3295                 libname=`eval \\$echo \"$libname_spec\"`
3296                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3297                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3298                   for potent_lib in $potential_libs; do
3299                       # Follow soft links.
3300                       if ls -lLd "$potent_lib" 2>/dev/null \
3301                          | grep " -> " >/dev/null; then
3302                         continue
3303                       fi
3304                       # The statement above tries to avoid entering an
3305                       # endless loop below, in case of cyclic links.
3306                       # We might still enter an endless loop, since a link
3307                       # loop can be closed while we follow links,
3308                       # but so what?
3309                       potlib="$potent_lib"
3310                       while test -h "$potlib" 2>/dev/null; do
3311                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3312                         case $potliblink in
3313                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3314                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3315                         esac
3316                       done
3317                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3318                          | ${SED} 10q \
3319                          | $EGREP "$file_magic_regex" > /dev/null; then
3320                         newdeplibs="$newdeplibs $a_deplib"
3321                         a_deplib=""
3322                         break 2
3323                       fi
3324                   done
3325                 done
3326               fi
3327               if test -n "$a_deplib" ; then
3328                 droppeddeps=yes
3329                 $echo
3330                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3331                 $echo "*** I have the capability to make that library automatically link in when"
3332                 $echo "*** you link to this library.  But I can only do this if you have a"
3333                 $echo "*** shared version of the library, which you do not appear to have"
3334                 $echo "*** because I did check the linker path looking for a file starting"
3335                 if test -z "$potlib" ; then
3336                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3337                 else
3338                   $echo "*** with $libname and none of the candidates passed a file format test"
3339                   $echo "*** using a file magic. Last file checked: $potlib"
3340                 fi
3341               fi
3342             else
3343               # Add a -L argument.
3344               newdeplibs="$newdeplibs $a_deplib"
3345             fi
3346           done # Gone through all deplibs.
3347           ;;
3348         match_pattern*)
3349           set dummy $deplibs_check_method
3350           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3351           for a_deplib in $deplibs; do
3352             name="`expr $a_deplib : '-l\(.*\)'`"
3353             # If $name is empty we are operating on a -L argument.
3354             if test -n "$name" && test "$name" != "0"; then
3355               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3356                 case " $predeps $postdeps " in
3357                 *" $a_deplib "*)
3358                   newdeplibs="$newdeplibs $a_deplib"
3359                   a_deplib=""
3360                   ;;
3361                 esac
3362               fi
3363               if test -n "$a_deplib" ; then
3364                 libname=`eval \\$echo \"$libname_spec\"`
3365                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3366                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3367                   for potent_lib in $potential_libs; do
3368                     potlib="$potent_lib" # see symlink-check above in file_magic test
3369                     if eval $echo \"$potent_lib\" 2>/dev/null \
3370                         | ${SED} 10q \
3371                         | $EGREP "$match_pattern_regex" > /dev/null; then
3372                       newdeplibs="$newdeplibs $a_deplib"
3373                       a_deplib=""
3374                       break 2
3375                     fi
3376                   done
3377                 done
3378               fi
3379               if test -n "$a_deplib" ; then
3380                 droppeddeps=yes
3381                 $echo
3382                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3383                 $echo "*** I have the capability to make that library automatically link in when"
3384                 $echo "*** you link to this library.  But I can only do this if you have a"
3385                 $echo "*** shared version of the library, which you do not appear to have"
3386                 $echo "*** because I did check the linker path looking for a file starting"
3387                 if test -z "$potlib" ; then
3388                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3389                 else
3390                   $echo "*** with $libname and none of the candidates passed a file format test"
3391                   $echo "*** using a regex pattern. Last file checked: $potlib"
3392                 fi
3393               fi
3394             else
3395               # Add a -L argument.
3396               newdeplibs="$newdeplibs $a_deplib"
3397             fi
3398           done # Gone through all deplibs.
3399           ;;
3400         none | unknown | *)
3401           newdeplibs=""
3402           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3403             -e 's/ -[LR][^ ]*//g'`
3404           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3405             for i in $predeps $postdeps ; do
3406               # can't use Xsed below, because $i might contain '/'
3407               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3408             done
3409           fi
3410           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3411             | grep . >/dev/null; then
3412             $echo
3413             if test "X$deplibs_check_method" = "Xnone"; then
3414               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3415             else
3416               $echo "*** Warning: inter-library dependencies are not known to be supported."
3417             fi
3418             $echo "*** All declared inter-library dependencies are being dropped."
3419             droppeddeps=yes
3420           fi
3421           ;;
3422         esac
3423         versuffix=$versuffix_save
3424         major=$major_save
3425         release=$release_save
3426         libname=$libname_save
3427         name=$name_save
3429         case $host in
3430         *-*-rhapsody* | *-*-darwin1.[012])
3431           # On Rhapsody replace the C library is the System framework
3432           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3433           ;;
3434         esac
3436         if test "$droppeddeps" = yes; then
3437           if test "$module" = yes; then
3438             $echo
3439             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3440             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3441             $echo "*** a static module, that should work as long as the dlopening"
3442             $echo "*** application is linked with the -dlopen flag."
3443             if test -z "$global_symbol_pipe"; then
3444               $echo
3445               $echo "*** However, this would only work if libtool was able to extract symbol"
3446               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3447               $echo "*** not find such a program.  So, this module is probably useless."
3448               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3449             fi
3450             if test "$build_old_libs" = no; then
3451               oldlibs="$output_objdir/$libname.$libext"
3452               build_libtool_libs=module
3453               build_old_libs=yes
3454             else
3455               build_libtool_libs=no
3456             fi
3457           else
3458             $echo "*** The inter-library dependencies that have been dropped here will be"
3459             $echo "*** automatically added whenever a program is linked with this library"
3460             $echo "*** or is declared to -dlopen it."
3462             if test "$allow_undefined" = no; then
3463               $echo
3464               $echo "*** Since this library must not contain undefined symbols,"
3465               $echo "*** because either the platform does not support them or"
3466               $echo "*** it was explicitly requested with -no-undefined,"
3467               $echo "*** libtool will only create a static version of it."
3468               if test "$build_old_libs" = no; then
3469                 oldlibs="$output_objdir/$libname.$libext"
3470                 build_libtool_libs=module
3471                 build_old_libs=yes
3472               else
3473                 build_libtool_libs=no
3474               fi
3475             fi
3476           fi
3477         fi
3478         # Done checking deplibs!
3479         deplibs=$newdeplibs
3480       fi
3482       # All the library-specific variables (install_libdir is set above).
3483       library_names=
3484       old_library=
3485       dlname=
3487       # Test again, we may have decided not to build it any more
3488       if test "$build_libtool_libs" = yes; then
3489         if test "$hardcode_into_libs" = yes; then
3490           # Hardcode the library paths
3491           hardcode_libdirs=
3492           dep_rpath=
3493           rpath="$finalize_rpath"
3494           test "$mode" != relink && test "$fast_install" = no && rpath="$compile_rpath$rpath"
3495           for libdir in $rpath; do
3496             if test -n "$hardcode_libdir_flag_spec"; then
3497               if test -n "$hardcode_libdir_separator"; then
3498                 if test -z "$hardcode_libdirs"; then
3499                   hardcode_libdirs="$libdir"
3500                 else
3501                   # Just accumulate the unique libdirs.
3502                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3503                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3504                     ;;
3505                   *)
3506                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3507                     ;;
3508                   esac
3509                 fi
3510               else
3511                 eval flag=\"$hardcode_libdir_flag_spec\"
3512                 dep_rpath="$dep_rpath $flag"
3513               fi
3514             elif test -n "$runpath_var"; then
3515               case "$perm_rpath " in
3516               *" $libdir "*) ;;
3517               *) perm_rpath="$perm_rpath $libdir" ;;
3518               esac
3519             fi
3520           done
3521           # Substitute the hardcoded libdirs into the rpath.
3522           if test -n "$hardcode_libdir_separator" &&
3523              test -n "$hardcode_libdirs"; then
3524             libdir="$hardcode_libdirs"
3525             if test -n "$hardcode_libdir_flag_spec_ld"; then
3526               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3527             else
3528               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3529             fi
3530           fi
3531           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3532             # We should set the runpath_var.
3533             rpath=
3534             for dir in $perm_rpath; do
3535               rpath="$rpath$dir:"
3536             done
3537             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3538           fi
3539           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3540         fi
3542         shlibpath="$finalize_shlibpath"
3543         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3544         if test -n "$shlibpath"; then
3545           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3546         fi
3548         # Get the real and link names of the library.
3549         eval shared_ext=\"$shrext\"
3550         eval library_names=\"$library_names_spec\"
3551         set dummy $library_names
3552         realname="$2"
3553         shift; shift
3555         if test -n "$soname_spec"; then
3556           eval soname=\"$soname_spec\"
3557         else
3558           soname="$realname"
3559         fi
3560         if test -z "$dlname"; then
3561           dlname=$soname
3562         fi
3564         lib="$output_objdir/$realname"
3565         for link
3566         do
3567           linknames="$linknames $link"
3568         done
3570         # Use standard objects if they are pic
3571         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3573         # Prepare the list of exported symbols
3574         if test -z "$export_symbols"; then
3575           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3576             $show "generating symbol list for \`$libname.la'"
3577             export_symbols="$output_objdir/$libname.exp"
3578             $run $rm $export_symbols
3579             eval cmds=\"$export_symbols_cmds\"
3580             save_ifs="$IFS"; IFS='~'
3581             for cmd in $cmds; do
3582               IFS="$save_ifs"
3583               if len=`expr "X$cmd" : ".*"` &&
3584                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3585                 $show "$cmd"
3586                 $run eval "$cmd" || exit $?
3587                 skipped_export=false
3588               else
3589                 # The command line is too long to execute in one step.
3590                 $show "using reloadable object file for export list..."
3591                 skipped_export=:
3592               fi
3593             done
3594             IFS="$save_ifs"
3595             if test -n "$export_symbols_regex"; then
3596               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3597               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3598               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3599               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3600             fi
3601           fi
3602         fi
3604         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3605           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3606         fi
3608         tmp_deplibs=
3609         for test_deplib in $deplibs; do
3610                 case " $convenience " in
3611                 *" $test_deplib "*) ;;
3612                 *) 
3613                         tmp_deplibs="$tmp_deplibs $test_deplib"
3614                         ;;
3615                 esac
3616         done
3617         deplibs="$tmp_deplibs" 
3619         if test -n "$convenience"; then
3620           if test -n "$whole_archive_flag_spec"; then
3621             save_libobjs=$libobjs
3622             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3623           else
3624             gentop="$output_objdir/${outputname}x"
3625             $show "${rm}r $gentop"
3626             $run ${rm}r "$gentop"
3627             $show "$mkdir $gentop"
3628             $run $mkdir "$gentop"
3629             status=$?
3630             if test "$status" -ne 0 && test ! -d "$gentop"; then
3631               exit $status
3632             fi
3633             generated="$generated $gentop"
3635             for xlib in $convenience; do
3636               # Extract the objects.
3637               case $xlib in
3638               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3639               *) xabs=`pwd`"/$xlib" ;;
3640               esac
3641               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3642               xdir="$gentop/$xlib"
3644               $show "${rm}r $xdir"
3645               $run ${rm}r "$xdir"
3646               $show "$mkdir $xdir"
3647               $run $mkdir "$xdir"
3648               status=$?
3649               if test "$status" -ne 0 && test ! -d "$xdir"; then
3650                 exit $status
3651               fi
3652               # We will extract separately just the conflicting names and we will no
3653               # longer touch any unique names. It is faster to leave these extract
3654               # automatically by $AR in one run.
3655               $show "(cd $xdir && $AR x $xabs)"
3656               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3657               if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3658                 :
3659               else
3660                 $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3661                 $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3662                 $AR t "$xabs" | sort | uniq -cd | while read -r count name
3663                 do
3664                   i=1
3665                   while test "$i" -le "$count"
3666                   do
3667                    # Put our $i before any first dot (extension)
3668                    # Never overwrite any file
3669                    name_to="$name"
3670                    while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3671                    do
3672                      name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3673                    done
3674                    $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3675                    $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3676                    i=`expr $i + 1`
3677                   done
3678                 done
3679               fi
3681               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3682             done
3683           fi
3684         fi
3686         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3687           eval flag=\"$thread_safe_flag_spec\"
3688           linker_flags="$linker_flags $flag"
3689         fi
3691         # Make a backup of the uninstalled library when relinking
3692         if test "$mode" = relink; then
3693           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3694         fi
3696         # Add all flags from the command line.  We here create a library,
3697         # but those flags were only added to compile_command and
3698         # finalize_command, which are only used when creating executables.
3699         # So do it by hand here.
3700         compiler_flags="$compiler_flags $add_flags"
3701         # Only add it to commands which use CC, instead of LD, i.e.
3702         # only to $compiler_flags
3703         #linker_flags="$linker_flags $add_flags"
3705         # Do each of the archive commands.
3706         if test "$module" = yes && test -n "$module_cmds" ; then
3707           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3708             eval cmds=\"$module_expsym_cmds\"
3709           else
3710             eval cmds=\"$module_cmds\"
3711           fi
3712         else
3713         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3714           eval cmds=\"$archive_expsym_cmds\"
3715         else
3716           eval cmds=\"$archive_cmds\"
3717           fi
3718         fi
3720         if test "X$skipped_export" != "X:" && len=`expr "X$cmds" : ".*"` &&
3721            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3722           :
3723         else
3724           # The command line is too long to link in one step, link piecewise.
3725           $echo "creating reloadable object files..."
3727           # Save the value of $output and $libobjs because we want to
3728           # use them later.  If we have whole_archive_flag_spec, we
3729           # want to use save_libobjs as it was before
3730           # whole_archive_flag_spec was expanded, because we can't
3731           # assume the linker understands whole_archive_flag_spec.
3732           # This may have to be revisited, in case too many
3733           # convenience libraries get linked in and end up exceeding
3734           # the spec.
3735           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3736             save_libobjs=$libobjs
3737           fi
3738           save_output=$output
3740           # Clear the reloadable object creation command queue and
3741           # initialize k to one.
3742           test_cmds=
3743           concat_cmds=
3744           objlist=
3745           delfiles=
3746           last_robj=
3747           k=1
3748           output=$output_objdir/$save_output-${k}.$objext
3749           # Loop over the list of objects to be linked.
3750           for obj in $save_libobjs
3751           do
3752             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3753             if test "X$objlist" = X ||
3754                { len=`expr "X$test_cmds" : ".*"` &&
3755                  test "$len" -le "$max_cmd_len"; }; then
3756               objlist="$objlist $obj"
3757             else
3758               # The command $test_cmds is almost too long, add a
3759               # command to the queue.
3760               if test "$k" -eq 1 ; then
3761                 # The first file doesn't have a previous command to add.
3762                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3763               else
3764                 # All subsequent reloadable object files will link in
3765                 # the last one created.
3766                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3767               fi
3768               last_robj=$output_objdir/$save_output-${k}.$objext
3769               k=`expr $k + 1`
3770               output=$output_objdir/$save_output-${k}.$objext
3771               objlist=$obj
3772               len=1
3773             fi
3774           done
3775           # Handle the remaining objects by creating one last
3776           # reloadable object file.  All subsequent reloadable object
3777           # files will link in the last one created.
3778           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3779           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3781           if ${skipped_export-false}; then
3782             $show "generating symbol list for \`$libname.la'"
3783             export_symbols="$output_objdir/$libname.exp"
3784             $run $rm $export_symbols
3785             libobjs=$output
3786             # Append the command to create the export file.
3787             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3788           fi
3790           # Set up a command to remove the reloadale object files
3791           # after they are used.
3792           i=0
3793           while test "$i" -lt "$k"
3794           do
3795             i=`expr $i + 1`
3796             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3797           done
3799           $echo "creating a temporary reloadable object file: $output"
3801           # Loop through the commands generated above and execute them.
3802           save_ifs="$IFS"; IFS='~'
3803           for cmd in $concat_cmds; do
3804             IFS="$save_ifs"
3805             $show "$cmd"
3806             $run eval "$cmd" || exit $?
3807           done
3808           IFS="$save_ifs"
3810           libobjs=$output
3811           # Restore the value of output.
3812           output=$save_output
3814           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3815             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3816           fi
3817           # Expand the library linking commands again to reset the
3818           # value of $libobjs for piecewise linking.
3820           # Do each of the archive commands.
3821           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3822             eval cmds=\"$archive_expsym_cmds\"
3823           else
3824             eval cmds=\"$archive_cmds\"
3825           fi
3827           # Append the command to remove the reloadable object files
3828           # to the just-reset $cmds.
3829           eval cmds=\"\$cmds~$rm $delfiles\"
3830         fi
3831         save_ifs="$IFS"; IFS='~'
3832         for cmd in $cmds; do
3833           IFS="$save_ifs"
3834           $show "$cmd"