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