source: mod_gnutls/config/ltmain.sh @ 70c2d86

debian/masterdebian/stretch-backportsjessie-backportsupstream upstream/0.3.4
Last change on this file since 70c2d86 was 70c2d86, checked in by Daniel Kahn Gillmor <dkg@…>, 8 years ago

Imported Upstream version 0.3.4

  • Property mode set to 100644
File size: 194.6 KB
Line 
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, 2006,
5# 2007  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
27basename="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.
34progpath="$0"
35
36# The name of this program:
37progname=`echo "$progpath" | $SED $basename`
38modename="$progname"
39
40# Global variables:
41EXIT_SUCCESS=0
42EXIT_FAILURE=1
43
44PROGRAM=ltmain.sh
45PACKAGE=libtool
46VERSION="1.5.24 Debian 1.5.24-1ubuntu1"
47TIMESTAMP=" (1.1220.2.456 2007/06/24 02:25:32)"
48
49# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
50if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
51  emulate sh
52  NULLCMD=:
53  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
54  # is contrary to our usage.  Disable this feature.
55  alias -g '${1+"$@"}'='"$@"'
56  setopt NO_GLOB_SUBST
57else
58  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
59fi
60BIN_SH=xpg4; export BIN_SH # for Tru64
61DUALCASE=1; export DUALCASE # for MKS sh
62
63# Check that we have a working $echo.
64if test "X$1" = X--no-reexec; then
65  # Discard the --no-reexec flag, and continue.
66  shift
67elif test "X$1" = X--fallback-echo; then
68  # Avoid inline document here, it may be left over
69  :
70elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
71  # Yippee, $echo works!
72  :
73else
74  # Restart under the correct shell, and then maybe $echo will work.
75  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
76fi
77
78if test "X$1" = X--fallback-echo; then
79  # used as fallback echo
80  shift
81  cat <<EOF
82$*
83EOF
84  exit $EXIT_SUCCESS
85fi
86
87default_mode=
88help="Try \`$progname --help' for more information."
89magic="%%%MAGIC variable%%%"
90mkdir="mkdir"
91mv="mv -f"
92rm="rm -f"
93
94# Sed substitution that helps us do robust quoting.  It backslashifies
95# metacharacters that are still active within double-quoted strings.
96Xsed="${SED}"' -e 1s/^X//'
97sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
98# test EBCDIC or ASCII
99case `echo X|tr X '\101'` in
100 A) # ASCII based system
101    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
102  SP2NL='tr \040 \012'
103  NL2SP='tr \015\012 \040\040'
104  ;;
105 *) # EBCDIC based system
106  SP2NL='tr \100 \n'
107  NL2SP='tr \r\n \100\100'
108  ;;
109esac
110
111# NLS nuisances.
112# Only set LANG and LC_ALL to C if already set.
113# These must not be set unconditionally because not all systems understand
114# e.g. LANG=C (notably SCO).
115# We save the old values to restore during execute mode.
116for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
117do
118  eval "if test \"\${$lt_var+set}\" = set; then
119          save_$lt_var=\$$lt_var
120          $lt_var=C
121          export $lt_var
122        fi"
123done
124
125# Make sure IFS has a sensible default
126lt_nl='
127'
128IFS="   $lt_nl"
129
130if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
131  $echo "$modename: not configured to build any kind of library" 1>&2
132  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
133  exit $EXIT_FAILURE
134fi
135
136# Global variables.
137mode=$default_mode
138nonopt=
139prev=
140prevopt=
141run=
142show="$echo"
143show_help=
144execute_dlfiles=
145duplicate_deps=no
146preserve_args=
147lo2o="s/\\.lo\$/.${objext}/"
148o2lo="s/\\.${objext}\$/.lo/"
149extracted_archives=
150extracted_serial=0
151
152#####################################
153# Shell function definitions:
154# This seems to be the best place for them
155
156# func_mktempdir [string]
157# Make a temporary directory that won't clash with other running
158# libtool processes, and avoids race conditions if possible.  If
159# given, STRING is the basename for that directory.
160func_mktempdir ()
161{
162    my_template="${TMPDIR-/tmp}/${1-$progname}"
163
164    if test "$run" = ":"; then
165      # Return a directory name, but don't create it in dry-run mode
166      my_tmpdir="${my_template}-$$"
167    else
168
169      # If mktemp works, use that first and foremost
170      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
171
172      if test ! -d "$my_tmpdir"; then
173        # Failing that, at least try and use $RANDOM to avoid a race
174        my_tmpdir="${my_template}-${RANDOM-0}$$"
175
176        save_mktempdir_umask=`umask`
177        umask 0077
178        $mkdir "$my_tmpdir"
179        umask $save_mktempdir_umask
180      fi
181
182      # If we're not in dry-run mode, bomb out on failure
183      test -d "$my_tmpdir" || {
184        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
185        exit $EXIT_FAILURE
186      }
187    fi
188
189    $echo "X$my_tmpdir" | $Xsed
190}
191
192
193# func_win32_libid arg
194# return the library type of file 'arg'
195#
196# Need a lot of goo to handle *both* DLLs and import libs
197# Has to be a shell function in order to 'eat' the argument
198# that is supplied when $file_magic_command is called.
199func_win32_libid ()
200{
201  win32_libid_type="unknown"
202  win32_fileres=`file -L $1 2>/dev/null`
203  case $win32_fileres in
204  *ar\ archive\ import\ library*) # definitely import
205    win32_libid_type="x86 archive import"
206    ;;
207  *ar\ archive*) # could be an import, or static
208    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
209      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
210      win32_nmres=`eval $NM -f posix -A $1 | \
211        $SED -n -e '1,100{
212                / I /{
213                        s,.*,import,
214                        p
215                        q
216                        }
217                }'`
218      case $win32_nmres in
219      import*)  win32_libid_type="x86 archive import";;
220      *)        win32_libid_type="x86 archive static";;
221      esac
222    fi
223    ;;
224  *DLL*)
225    win32_libid_type="x86 DLL"
226    ;;
227  *executable*) # but shell scripts are "executable" too...
228    case $win32_fileres in
229    *MS\ Windows\ PE\ Intel*)
230      win32_libid_type="x86 DLL"
231      ;;
232    esac
233    ;;
234  esac
235  $echo $win32_libid_type
236}
237
238
239# func_infer_tag arg
240# Infer tagged configuration to use if any are available and
241# if one wasn't chosen via the "--tag" command line option.
242# Only attempt this if the compiler in the base compile
243# command doesn't match the default compiler.
244# arg is usually of the form 'gcc ...'
245func_infer_tag ()
246{
247    if test -n "$available_tags" && test -z "$tagname"; then
248      CC_quoted=
249      for arg in $CC; do
250        case $arg in
251          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
252          arg="\"$arg\""
253          ;;
254        esac
255        CC_quoted="$CC_quoted $arg"
256      done
257      case $@ in
258      # Blanks in the command may have been stripped by the calling shell,
259      # but not from the CC environment variable when configure was run.
260      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
261      # Blanks at the start of $base_compile will cause this to fail
262      # if we don't check for them as well.
263      *)
264        for z in $available_tags; do
265          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
266            # Evaluate the configuration.
267            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
268            CC_quoted=
269            for arg in $CC; do
270            # Double-quote args containing other shell metacharacters.
271            case $arg in
272              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
273              arg="\"$arg\""
274              ;;
275            esac
276            CC_quoted="$CC_quoted $arg"
277          done
278            case "$@ " in
279              " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
280              # The compiler in the base compile command matches
281              # the one in the tagged configuration.
282              # Assume this is the tagged configuration we want.
283              tagname=$z
284              break
285              ;;
286            esac
287          fi
288        done
289        # If $tagname still isn't set, then no tagged configuration
290        # was found and let the user know that the "--tag" command
291        # line option must be used.
292        if test -z "$tagname"; then
293          $echo "$modename: unable to infer tagged configuration"
294          $echo "$modename: specify a tag with \`--tag'" 1>&2
295          exit $EXIT_FAILURE
296#        else
297#          $echo "$modename: using $tagname tagged configuration"
298        fi
299        ;;
300      esac
301    fi
302}
303
304
305# func_extract_an_archive dir oldlib
306func_extract_an_archive ()
307{
308    f_ex_an_ar_dir="$1"; shift
309    f_ex_an_ar_oldlib="$1"
310
311    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
312    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
313    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
314     :
315    else
316      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
317      exit $EXIT_FAILURE
318    fi
319}
320
321# func_extract_archives gentop oldlib ...
322func_extract_archives ()
323{
324    my_gentop="$1"; shift
325    my_oldlibs=${1+"$@"}
326    my_oldobjs=""
327    my_xlib=""
328    my_xabs=""
329    my_xdir=""
330    my_status=""
331
332    $show "${rm}r $my_gentop"
333    $run ${rm}r "$my_gentop"
334    $show "$mkdir $my_gentop"
335    $run $mkdir "$my_gentop"
336    my_status=$?
337    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
338      exit $my_status
339    fi
340
341    for my_xlib in $my_oldlibs; do
342      # Extract the objects.
343      case $my_xlib in
344        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
345        *) my_xabs=`pwd`"/$my_xlib" ;;
346      esac
347      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
348      my_xlib_u=$my_xlib
349      while :; do
350        case " $extracted_archives " in
351        *" $my_xlib_u "*)
352          extracted_serial=`expr $extracted_serial + 1`
353          my_xlib_u=lt$extracted_serial-$my_xlib ;;
354        *) break ;;
355        esac
356      done
357      extracted_archives="$extracted_archives $my_xlib_u"
358      my_xdir="$my_gentop/$my_xlib_u"
359
360      $show "${rm}r $my_xdir"
361      $run ${rm}r "$my_xdir"
362      $show "$mkdir $my_xdir"
363      $run $mkdir "$my_xdir"
364      exit_status=$?
365      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
366        exit $exit_status
367      fi
368      case $host in
369      *-darwin*)
370        $show "Extracting $my_xabs"
371        # Do not bother doing anything if just a dry run
372        if test -z "$run"; then
373          darwin_orig_dir=`pwd`
374          cd $my_xdir || exit $?
375          darwin_archive=$my_xabs
376          darwin_curdir=`pwd`
377          darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
378          darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
379          if test -n "$darwin_arches"; then 
380            darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
381            darwin_arch=
382            $show "$darwin_base_archive has multiple architectures $darwin_arches"
383            for darwin_arch in  $darwin_arches ; do
384              mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
385              lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
386              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
387              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
388              cd "$darwin_curdir"
389              $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
390            done # $darwin_arches
391      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
392            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
393            darwin_file=
394            darwin_files=
395            for darwin_file in $darwin_filelist; do
396              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
397              lipo -create -output "$darwin_file" $darwin_files
398            done # $darwin_filelist
399            ${rm}r unfat-$$
400            cd "$darwin_orig_dir"
401          else
402            cd "$darwin_orig_dir"
403            func_extract_an_archive "$my_xdir" "$my_xabs"
404          fi # $darwin_arches
405        fi # $run
406        ;;
407      *)
408        func_extract_an_archive "$my_xdir" "$my_xabs"
409        ;;
410      esac
411      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
412    done
413    func_extract_archives_result="$my_oldobjs"
414}
415# End of Shell function definitions
416#####################################
417
418# Darwin sucks
419eval std_shrext=\"$shrext_cmds\"
420
421disable_libs=no
422
423# Parse our command line options once, thoroughly.
424while test "$#" -gt 0
425do
426  arg="$1"
427  shift
428
429  case $arg in
430  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
431  *) optarg= ;;
432  esac
433
434  # If the previous option needs an argument, assign it.
435  if test -n "$prev"; then
436    case $prev in
437    execute_dlfiles)
438      execute_dlfiles="$execute_dlfiles $arg"
439      ;;
440    tag)
441      tagname="$arg"
442      preserve_args="${preserve_args}=$arg"
443
444      # Check whether tagname contains only valid characters
445      case $tagname in
446      *[!-_A-Za-z0-9,/]*)
447        $echo "$progname: invalid tag name: $tagname" 1>&2
448        exit $EXIT_FAILURE
449        ;;
450      esac
451
452      case $tagname in
453      CC)
454        # Don't test for the "default" C tag, as we know, it's there, but
455        # not specially marked.
456        ;;
457      *)
458        if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
459          taglist="$taglist $tagname"
460          # Evaluate the configuration.
461          eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
462        else
463          $echo "$progname: ignoring unknown tag $tagname" 1>&2
464        fi
465        ;;
466      esac
467      ;;
468    *)
469      eval "$prev=\$arg"
470      ;;
471    esac
472
473    prev=
474    prevopt=
475    continue
476  fi
477
478  # Have we seen a non-optional argument yet?
479  case $arg in
480  --help)
481    show_help=yes
482    ;;
483
484  --version)
485    echo "\
486$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
487
488Copyright (C) 2007  Free Software Foundation, Inc.
489This is free software; see the source for copying conditions.  There is NO
490warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
491    exit $?
492    ;;
493
494  --config)
495    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
496    # Now print the configurations for the tags.
497    for tagname in $taglist; do
498      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
499    done
500    exit $?
501    ;;
502
503  --debug)
504    $echo "$progname: enabling shell trace mode"
505    set -x
506    preserve_args="$preserve_args $arg"
507    ;;
508
509  --dry-run | -n)
510    run=:
511    ;;
512
513  --features)
514    $echo "host: $host"
515    if test "$build_libtool_libs" = yes; then
516      $echo "enable shared libraries"
517    else
518      $echo "disable shared libraries"
519    fi
520    if test "$build_old_libs" = yes; then
521      $echo "enable static libraries"
522    else
523      $echo "disable static libraries"
524    fi
525    exit $?
526    ;;
527
528  --finish) mode="finish" ;;
529
530  --mode) prevopt="--mode" prev=mode ;;
531  --mode=*) mode="$optarg" ;;
532
533  --preserve-dup-deps) duplicate_deps="yes" ;;
534
535  --quiet | --silent)
536    show=:
537    preserve_args="$preserve_args $arg"
538    ;;
539
540  --tag)
541    prevopt="--tag"
542    prev=tag
543    preserve_args="$preserve_args --tag"
544    ;;
545  --tag=*)
546    set tag "$optarg" ${1+"$@"}
547    shift
548    prev=tag
549    preserve_args="$preserve_args --tag"
550    ;;
551
552  -dlopen)
553    prevopt="-dlopen"
554    prev=execute_dlfiles
555    ;;
556
557  -*)
558    $echo "$modename: unrecognized option \`$arg'" 1>&2
559    $echo "$help" 1>&2
560    exit $EXIT_FAILURE
561    ;;
562
563  *)
564    nonopt="$arg"
565    break
566    ;;
567  esac
568done
569
570if test -n "$prevopt"; then
571  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
572  $echo "$help" 1>&2
573  exit $EXIT_FAILURE
574fi
575
576case $disable_libs in
577no) 
578  ;;
579shared)
580  build_libtool_libs=no
581  build_old_libs=yes
582  ;;
583static)
584  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
585  ;;
586esac
587
588# If this variable is set in any of the actions, the command in it
589# will be execed at the end.  This prevents here-documents from being
590# left over by shells.
591exec_cmd=
592
593if test -z "$show_help"; then
594
595  # Infer the operation mode.
596  if test -z "$mode"; then
597    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
598    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
599    case $nonopt in
600    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
601      mode=link
602      for arg
603      do
604        case $arg in
605        -c)
606           mode=compile
607           break
608           ;;
609        esac
610      done
611      ;;
612    *db | *dbx | *strace | *truss)
613      mode=execute
614      ;;
615    *install*|cp|mv)
616      mode=install
617      ;;
618    *rm)
619      mode=uninstall
620      ;;
621    *)
622      # If we have no mode, but dlfiles were specified, then do execute mode.
623      test -n "$execute_dlfiles" && mode=execute
624
625      # Just use the default operation mode.
626      if test -z "$mode"; then
627        if test -n "$nonopt"; then
628          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
629        else
630          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
631        fi
632      fi
633      ;;
634    esac
635  fi
636
637  # Only execute mode is allowed to have -dlopen flags.
638  if test -n "$execute_dlfiles" && test "$mode" != execute; then
639    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
640    $echo "$help" 1>&2
641    exit $EXIT_FAILURE
642  fi
643
644  # Change the help message to a mode-specific one.
645  generic_help="$help"
646  help="Try \`$modename --help --mode=$mode' for more information."
647
648  # These modes are in order of execution frequency so that they run quickly.
649  case $mode in
650  # libtool compile mode
651  compile)
652    modename="$modename: compile"
653    # Get the compilation command and the source file.
654    base_compile=
655    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
656    suppress_opt=yes
657    suppress_output=
658    arg_mode=normal
659    libobj=
660    later=
661
662    for arg
663    do
664      case $arg_mode in
665      arg  )
666        # do not "continue".  Instead, add this to base_compile
667        lastarg="$arg"
668        arg_mode=normal
669        ;;
670
671      target )
672        libobj="$arg"
673        arg_mode=normal
674        continue
675        ;;
676
677      normal )
678        # Accept any command-line options.
679        case $arg in
680        -o)
681          if test -n "$libobj" ; then
682            $echo "$modename: you cannot specify \`-o' more than once" 1>&2
683            exit $EXIT_FAILURE
684          fi
685          arg_mode=target
686          continue
687          ;;
688
689        -static | -prefer-pic | -prefer-non-pic)
690          later="$later $arg"
691          continue
692          ;;
693
694        -no-suppress)
695          suppress_opt=no
696          continue
697          ;;
698
699        -Xcompiler)
700          arg_mode=arg  #  the next one goes into the "base_compile" arg list
701          continue      #  The current "srcfile" will either be retained or
702          ;;            #  replaced later.  I would guess that would be a bug.
703
704        -Wc,*)
705          args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
706          lastarg=
707          save_ifs="$IFS"; IFS=','
708          for arg in $args; do
709            IFS="$save_ifs"
710
711            # Double-quote args containing other shell metacharacters.
712            # Many Bourne shells cannot handle close brackets correctly
713            # in scan sets, so we specify it separately.
714            case $arg in
715              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
716              arg="\"$arg\""
717              ;;
718            esac
719            lastarg="$lastarg $arg"
720          done
721          IFS="$save_ifs"
722          lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
723
724          # Add the arguments to base_compile.
725          base_compile="$base_compile $lastarg"
726          continue
727          ;;
728
729        * )
730          # Accept the current argument as the source file.
731          # The previous "srcfile" becomes the current argument.
732          #
733          lastarg="$srcfile"
734          srcfile="$arg"
735          ;;
736        esac  #  case $arg
737        ;;
738      esac    #  case $arg_mode
739
740      # Aesthetically quote the previous argument.
741      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
742
743      case $lastarg in
744      # Double-quote args containing other shell metacharacters.
745      # Many Bourne shells cannot handle close brackets correctly
746      # in scan sets, and some SunOS ksh mistreat backslash-escaping
747      # in scan sets (worked around with variable expansion),
748      # and furthermore cannot handle '|' '&' '(' ')' in scan sets
749      # at all, so we specify them separately.
750      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
751        lastarg="\"$lastarg\""
752        ;;
753      esac
754
755      base_compile="$base_compile $lastarg"
756    done # for arg
757
758    case $arg_mode in
759    arg)
760      $echo "$modename: you must specify an argument for -Xcompile"
761      exit $EXIT_FAILURE
762      ;;
763    target)
764      $echo "$modename: you must specify a target with \`-o'" 1>&2
765      exit $EXIT_FAILURE
766      ;;
767    *)
768      # Get the name of the library object.
769      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
770      ;;
771    esac
772
773    # Recognize several different file suffixes.
774    # If the user specifies -o file.o, it is replaced with file.lo
775    xform='[cCFSifmso]'
776    case $libobj in
777    *.ada) xform=ada ;;
778    *.adb) xform=adb ;;
779    *.ads) xform=ads ;;
780    *.asm) xform=asm ;;
781    *.c++) xform=c++ ;;
782    *.cc) xform=cc ;;
783    *.ii) xform=ii ;;
784    *.class) xform=class ;;
785    *.cpp) xform=cpp ;;
786    *.cxx) xform=cxx ;;
787    *.[fF][09]?) xform=[fF][09]. ;;
788    *.for) xform=for ;;
789    *.java) xform=java ;;
790    *.obj) xform=obj ;;
791    esac
792
793    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
794
795    case $libobj in
796    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
797    *)
798      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
799      exit $EXIT_FAILURE
800      ;;
801    esac
802
803    func_infer_tag $base_compile
804
805    for arg in $later; do
806      case $arg in
807      -static)
808        build_old_libs=yes
809        continue
810        ;;
811
812      -prefer-pic)
813        pic_mode=yes
814        continue
815        ;;
816
817      -prefer-non-pic)
818        pic_mode=no
819        continue
820        ;;
821      esac
822    done
823
824    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
825    case $qlibobj in
826      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
827        qlibobj="\"$qlibobj\"" ;;
828    esac
829    test "X$libobj" != "X$qlibobj" \
830        && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
831        && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
832    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
833    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
834    if test "X$xdir" = "X$obj"; then
835      xdir=
836    else
837      xdir=$xdir/
838    fi
839    lobj=${xdir}$objdir/$objname
840
841    if test -z "$base_compile"; then
842      $echo "$modename: you must specify a compilation command" 1>&2
843      $echo "$help" 1>&2
844      exit $EXIT_FAILURE
845    fi
846
847    # Delete any leftover library objects.
848    if test "$build_old_libs" = yes; then
849      removelist="$obj $lobj $libobj ${libobj}T"
850    else
851      removelist="$lobj $libobj ${libobj}T"
852    fi
853
854    $run $rm $removelist
855    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
856
857    # On Cygwin there's no "real" PIC flag so we must build both object types
858    case $host_os in
859    cygwin* | mingw* | pw32* | os2*)
860      pic_mode=default
861      ;;
862    esac
863    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
864      # non-PIC code in shared libraries is not supported
865      pic_mode=default
866    fi
867
868    # Calculate the filename of the output object if compiler does
869    # not support -o with -c
870    if test "$compiler_c_o" = no; then
871      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
872      lockfile="$output_obj.lock"
873      removelist="$removelist $output_obj $lockfile"
874      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
875    else
876      output_obj=
877      need_locks=no
878      lockfile=
879    fi
880
881    # Lock this critical section if it is needed
882    # We use this script file to make the link, it avoids creating a new file
883    if test "$need_locks" = yes; then
884      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
885        $show "Waiting for $lockfile to be removed"
886        sleep 2
887      done
888    elif test "$need_locks" = warn; then
889      if test -f "$lockfile"; then
890        $echo "\
891*** ERROR, $lockfile exists and contains:
892`cat $lockfile 2>/dev/null`
893
894This indicates that another process is trying to use the same
895temporary object file, and libtool could not work around it because
896your compiler does not support \`-c' and \`-o' together.  If you
897repeat this compilation, it may succeed, by chance, but you had better
898avoid parallel builds (make -j) in this platform, or get a better
899compiler."
900
901        $run $rm $removelist
902        exit $EXIT_FAILURE
903      fi
904      $echo "$srcfile" > "$lockfile"
905    fi
906
907    if test -n "$fix_srcfile_path"; then
908      eval srcfile=\"$fix_srcfile_path\"
909    fi
910    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
911    case $qsrcfile in
912      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
913      qsrcfile="\"$qsrcfile\"" ;;
914    esac
915
916    $run $rm "$libobj" "${libobj}T"
917
918    # Create a libtool object file (analogous to a ".la" file),
919    # but don't create it if we're doing a dry run.
920    test -z "$run" && cat > ${libobj}T <<EOF
921# $libobj - a libtool object file
922# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
923#
924# Please DO NOT delete this file!
925# It is necessary for linking the library.
926
927# Name of the PIC object.
928EOF
929
930    # Only build a PIC object if we are building libtool libraries.
931    if test "$build_libtool_libs" = yes; then
932      # Without this assignment, base_compile gets emptied.
933      fbsd_hideous_sh_bug=$base_compile
934
935      if test "$pic_mode" != no; then
936        command="$base_compile $qsrcfile $pic_flag"
937      else
938        # Don't build PIC code
939        command="$base_compile $qsrcfile"
940      fi
941
942      if test ! -d "${xdir}$objdir"; then
943        $show "$mkdir ${xdir}$objdir"
944        $run $mkdir ${xdir}$objdir
945        exit_status=$?
946        if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
947          exit $exit_status
948        fi
949      fi
950
951      if test -z "$output_obj"; then
952        # Place PIC objects in $objdir
953        command="$command -o $lobj"
954      fi
955
956      $run $rm "$lobj" "$output_obj"
957
958      $show "$command"
959      if $run eval "$command"; then :
960      else
961        test -n "$output_obj" && $run $rm $removelist
962        exit $EXIT_FAILURE
963      fi
964
965      if test "$need_locks" = warn &&
966         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
967        $echo "\
968*** ERROR, $lockfile contains:
969`cat $lockfile 2>/dev/null`
970
971but it should contain:
972$srcfile
973
974This indicates that another process is trying to use the same
975temporary object file, and libtool could not work around it because
976your compiler does not support \`-c' and \`-o' together.  If you
977repeat this compilation, it may succeed, by chance, but you had better
978avoid parallel builds (make -j) in this platform, or get a better
979compiler."
980
981        $run $rm $removelist
982        exit $EXIT_FAILURE
983      fi
984
985      # Just move the object if needed, then go on to compile the next one
986      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
987        $show "$mv $output_obj $lobj"
988        if $run $mv $output_obj $lobj; then :
989        else
990          error=$?
991          $run $rm $removelist
992          exit $error
993        fi
994      fi
995
996      # Append the name of the PIC object to the libtool object file.
997      test -z "$run" && cat >> ${libobj}T <<EOF
998pic_object='$objdir/$objname'
999
1000EOF
1001
1002      # Allow error messages only from the first compilation.
1003      if test "$suppress_opt" = yes; then
1004        suppress_output=' >/dev/null 2>&1'
1005      fi
1006    else
1007      # No PIC object so indicate it doesn't exist in the libtool
1008      # object file.
1009      test -z "$run" && cat >> ${libobj}T <<EOF
1010pic_object=none
1011
1012EOF
1013    fi
1014
1015    # Only build a position-dependent object if we build old libraries.
1016    if test "$build_old_libs" = yes; then
1017      if test "$pic_mode" != yes; then
1018        # Don't build PIC code
1019        command="$base_compile $qsrcfile"
1020      else
1021        command="$base_compile $qsrcfile $pic_flag"
1022      fi
1023      if test "$compiler_c_o" = yes; then
1024        command="$command -o $obj"
1025      fi
1026
1027      # Suppress compiler output if we already did a PIC compilation.
1028      command="$command$suppress_output"
1029      $run $rm "$obj" "$output_obj"
1030      $show "$command"
1031      if $run eval "$command"; then :
1032      else
1033        $run $rm $removelist
1034        exit $EXIT_FAILURE
1035      fi
1036
1037      if test "$need_locks" = warn &&
1038         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1039        $echo "\
1040*** ERROR, $lockfile contains:
1041`cat $lockfile 2>/dev/null`
1042
1043but it should contain:
1044$srcfile
1045
1046This indicates that another process is trying to use the same
1047temporary object file, and libtool could not work around it because
1048your compiler does not support \`-c' and \`-o' together.  If you
1049repeat this compilation, it may succeed, by chance, but you had better
1050avoid parallel builds (make -j) in this platform, or get a better
1051compiler."
1052
1053        $run $rm $removelist
1054        exit $EXIT_FAILURE
1055      fi
1056
1057      # Just move the object if needed
1058      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1059        $show "$mv $output_obj $obj"
1060        if $run $mv $output_obj $obj; then :
1061        else
1062          error=$?
1063          $run $rm $removelist
1064          exit $error
1065        fi
1066      fi
1067
1068      # Append the name of the non-PIC object the libtool object file.
1069      # Only append if the libtool object file exists.
1070      test -z "$run" && cat >> ${libobj}T <<EOF
1071# Name of the non-PIC object.
1072non_pic_object='$objname'
1073
1074EOF
1075    else
1076      # Append the name of the non-PIC object the libtool object file.
1077      # Only append if the libtool object file exists.
1078      test -z "$run" && cat >> ${libobj}T <<EOF
1079# Name of the non-PIC object.
1080non_pic_object=none
1081
1082EOF
1083    fi
1084
1085    $run $mv "${libobj}T" "${libobj}"
1086
1087    # Unlock the critical section if it was locked
1088    if test "$need_locks" != no; then
1089      $run $rm "$lockfile"
1090    fi
1091
1092    exit $EXIT_SUCCESS
1093    ;;
1094
1095  # libtool link mode
1096  link | relink)
1097    modename="$modename: link"
1098    case $host in
1099    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1100      # It is impossible to link a dll without this setting, and
1101      # we shouldn't force the makefile maintainer to figure out
1102      # which system we are compiling for in order to pass an extra
1103      # flag for every libtool invocation.
1104      # allow_undefined=no
1105
1106      # FIXME: Unfortunately, there are problems with the above when trying
1107      # to make a dll which has undefined symbols, in which case not
1108      # even a static library is built.  For now, we need to specify
1109      # -no-undefined on the libtool link line when we can be certain
1110      # that all symbols are satisfied, otherwise we get a static library.
1111      allow_undefined=yes
1112      ;;
1113    *)
1114      allow_undefined=yes
1115      ;;
1116    esac
1117    libtool_args="$nonopt"
1118    base_compile="$nonopt $@"
1119    compile_command="$nonopt"
1120    finalize_command="$nonopt"
1121
1122    compile_rpath=
1123    finalize_rpath=
1124    compile_shlibpath=
1125    finalize_shlibpath=
1126    convenience=
1127    old_convenience=
1128    deplibs=
1129    old_deplibs=
1130    compiler_flags=
1131    linker_flags=
1132    dllsearchpath=
1133    lib_search_path=`pwd`
1134    inst_prefix_dir=
1135
1136    avoid_version=no
1137    dlfiles=
1138    dlprefiles=
1139    dlself=no
1140    export_dynamic=no
1141    export_symbols=
1142    export_symbols_regex=
1143    generated=
1144    libobjs=
1145    ltlibs=
1146    module=no
1147    no_install=no
1148    objs=
1149    non_pic_objects=
1150    notinst_path= # paths that contain not-installed libtool libraries
1151    precious_files_regex=
1152    prefer_static_libs=no
1153    preload=no
1154    prev=
1155    prevarg=
1156    release=
1157    rpath=
1158    xrpath=
1159    perm_rpath=
1160    temp_rpath=
1161    thread_safe=no
1162    vinfo=
1163    vinfo_number=no
1164
1165    func_infer_tag $base_compile
1166
1167    # We need to know -static, to get the right output filenames.
1168    for arg
1169    do
1170      case $arg in
1171      -all-static | -static | -static-libtool-libs)
1172        case $arg in
1173        -all-static)
1174          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1175            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1176          fi
1177          if test -n "$link_static_flag"; then
1178            dlopen_self=$dlopen_self_static
1179          fi
1180          prefer_static_libs=yes
1181          ;;
1182        -static)
1183          if test -z "$pic_flag" && test -n "$link_static_flag"; then
1184            dlopen_self=$dlopen_self_static
1185          fi
1186          prefer_static_libs=built
1187          ;;
1188        -static-libtool-libs)
1189          if test -z "$pic_flag" && test -n "$link_static_flag"; then
1190            dlopen_self=$dlopen_self_static
1191          fi
1192          prefer_static_libs=yes
1193          ;;
1194        esac
1195        build_libtool_libs=no
1196        build_old_libs=yes
1197        break
1198        ;;
1199      esac
1200    done
1201
1202    # See if our shared archives depend on static archives.
1203    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1204
1205    # Go through the arguments, transforming them on the way.
1206    while test "$#" -gt 0; do
1207      arg="$1"
1208      shift
1209      case $arg in
1210      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1211        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1212        ;;
1213      *) qarg=$arg ;;
1214      esac
1215      libtool_args="$libtool_args $qarg"
1216
1217      # If the previous option needs an argument, assign it.
1218      if test -n "$prev"; then
1219        case $prev in
1220        output)
1221          compile_command="$compile_command @OUTPUT@"
1222          finalize_command="$finalize_command @OUTPUT@"
1223          ;;
1224        esac
1225
1226        case $prev in
1227        dlfiles|dlprefiles)
1228          if test "$preload" = no; then
1229            # Add the symbol object into the linking commands.
1230            compile_command="$compile_command @SYMFILE@"
1231            finalize_command="$finalize_command @SYMFILE@"
1232            preload=yes
1233          fi
1234          case $arg in
1235          *.la | *.lo) ;;  # We handle these cases below.
1236          force)
1237            if test "$dlself" = no; then
1238              dlself=needless
1239              export_dynamic=yes
1240            fi
1241            prev=
1242            continue
1243            ;;
1244          self)
1245            if test "$prev" = dlprefiles; then
1246              dlself=yes
1247            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1248              dlself=yes
1249            else
1250              dlself=needless
1251              export_dynamic=yes
1252            fi
1253            prev=
1254            continue
1255            ;;
1256          *)
1257            if test "$prev" = dlfiles; then
1258              dlfiles="$dlfiles $arg"
1259            else
1260              dlprefiles="$dlprefiles $arg"
1261            fi
1262            prev=
1263            continue
1264            ;;
1265          esac
1266          ;;
1267        expsyms)
1268          export_symbols="$arg"
1269          if test ! -f "$arg"; then
1270            $echo "$modename: symbol file \`$arg' does not exist"
1271            exit $EXIT_FAILURE
1272          fi
1273          prev=
1274          continue
1275          ;;
1276        expsyms_regex)
1277          export_symbols_regex="$arg"
1278          prev=
1279          continue
1280          ;;
1281        inst_prefix)
1282          inst_prefix_dir="$arg"
1283          prev=
1284          continue
1285          ;;
1286        precious_regex)
1287          precious_files_regex="$arg"
1288          prev=
1289          continue
1290          ;;
1291        release)
1292          release="-$arg"
1293          prev=
1294          continue
1295          ;;
1296        objectlist)
1297          if test -f "$arg"; then
1298            save_arg=$arg
1299            moreargs=
1300            for fil in `cat $save_arg`
1301            do
1302#             moreargs="$moreargs $fil"
1303              arg=$fil
1304              # A libtool-controlled object.
1305
1306              # Check to see that this really is a libtool object.
1307              if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1308                pic_object=
1309                non_pic_object=
1310
1311                # Read the .lo file
1312                # If there is no directory component, then add one.
1313                case $arg in
1314                */* | *\\*) . $arg ;;
1315                *) . ./$arg ;;
1316                esac
1317
1318                if test -z "$pic_object" || \
1319                   test -z "$non_pic_object" ||
1320                   test "$pic_object" = none && \
1321                   test "$non_pic_object" = none; then
1322                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1323                  exit $EXIT_FAILURE
1324                fi
1325
1326                # Extract subdirectory from the argument.
1327                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1328                if test "X$xdir" = "X$arg"; then
1329                  xdir=
1330                else
1331                  xdir="$xdir/"
1332                fi
1333
1334                if test "$pic_object" != none; then
1335                  # Prepend the subdirectory the object is found in.
1336                  pic_object="$xdir$pic_object"
1337
1338                  if test "$prev" = dlfiles; then
1339                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1340                      dlfiles="$dlfiles $pic_object"
1341                      prev=
1342                      continue
1343                    else
1344                      # If libtool objects are unsupported, then we need to preload.
1345                      prev=dlprefiles
1346                    fi
1347                  fi
1348
1349                  # CHECK ME:  I think I busted this.  -Ossama
1350                  if test "$prev" = dlprefiles; then
1351                    # Preload the old-style object.
1352                    dlprefiles="$dlprefiles $pic_object"
1353                    prev=
1354                  fi
1355
1356                  # A PIC object.
1357                  libobjs="$libobjs $pic_object"
1358                  arg="$pic_object"
1359                fi
1360
1361                # Non-PIC object.
1362                if test "$non_pic_object" != none; then
1363                  # Prepend the subdirectory the object is found in.
1364                  non_pic_object="$xdir$non_pic_object"
1365
1366                  # A standard non-PIC object
1367                  non_pic_objects="$non_pic_objects $non_pic_object"
1368                  if test -z "$pic_object" || test "$pic_object" = none ; then
1369                    arg="$non_pic_object"
1370                  fi
1371                else
1372                  # If the PIC object exists, use it instead.
1373                  # $xdir was prepended to $pic_object above.
1374                  non_pic_object="$pic_object"
1375                  non_pic_objects="$non_pic_objects $non_pic_object"
1376                fi
1377              else
1378                # Only an error if not doing a dry-run.
1379                if test -z "$run"; then
1380                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1381                  exit $EXIT_FAILURE
1382                else
1383                  # Dry-run case.
1384
1385                  # Extract subdirectory from the argument.
1386                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1387                  if test "X$xdir" = "X$arg"; then
1388                    xdir=
1389                  else
1390                    xdir="$xdir/"
1391                  fi
1392
1393                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1394                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1395                  libobjs="$libobjs $pic_object"
1396                  non_pic_objects="$non_pic_objects $non_pic_object"
1397                fi
1398              fi
1399            done
1400          else
1401            $echo "$modename: link input file \`$save_arg' does not exist"
1402            exit $EXIT_FAILURE
1403          fi
1404          arg=$save_arg
1405          prev=
1406          continue
1407          ;;
1408        rpath | xrpath)
1409          # We need an absolute path.
1410          case $arg in
1411          [\\/]* | [A-Za-z]:[\\/]*) ;;
1412          *)
1413            $echo "$modename: only absolute run-paths are allowed" 1>&2
1414            exit $EXIT_FAILURE
1415            ;;
1416          esac
1417          if test "$prev" = rpath; then
1418            case "$rpath " in
1419            *" $arg "*) ;;
1420            *) rpath="$rpath $arg" ;;
1421            esac
1422          else
1423            case "$xrpath " in
1424            *" $arg "*) ;;
1425            *) xrpath="$xrpath $arg" ;;
1426            esac
1427          fi
1428          prev=
1429          continue
1430          ;;
1431        xcompiler)
1432          compiler_flags="$compiler_flags $qarg"
1433          prev=
1434          compile_command="$compile_command $qarg"
1435          finalize_command="$finalize_command $qarg"
1436          continue
1437          ;;
1438        xlinker)
1439          linker_flags="$linker_flags $qarg"
1440          compiler_flags="$compiler_flags $wl$qarg"
1441          prev=
1442          compile_command="$compile_command $wl$qarg"
1443          finalize_command="$finalize_command $wl$qarg"
1444          continue
1445          ;;
1446        xcclinker)
1447          linker_flags="$linker_flags $qarg"
1448          compiler_flags="$compiler_flags $qarg"
1449          prev=
1450          compile_command="$compile_command $qarg"
1451          finalize_command="$finalize_command $qarg"
1452          continue
1453          ;;
1454        shrext)
1455          shrext_cmds="$arg"
1456          prev=
1457          continue
1458          ;;
1459        darwin_framework|darwin_framework_skip)
1460          test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
1461          compile_command="$compile_command $arg"
1462          finalize_command="$finalize_command $arg"
1463          prev=
1464          continue
1465          ;;
1466        *)
1467          eval "$prev=\"\$arg\""
1468          prev=
1469          continue
1470          ;;
1471        esac
1472      fi # test -n "$prev"
1473
1474      prevarg="$arg"
1475
1476      case $arg in
1477      -all-static)
1478        if test -n "$link_static_flag"; then
1479          compile_command="$compile_command $link_static_flag"
1480          finalize_command="$finalize_command $link_static_flag"
1481        fi
1482        continue
1483        ;;
1484
1485      -allow-undefined)
1486        # FIXME: remove this flag sometime in the future.
1487        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1488        continue
1489        ;;
1490
1491      -avoid-version)
1492        avoid_version=yes
1493        continue
1494        ;;
1495
1496      -dlopen)
1497        prev=dlfiles
1498        continue
1499        ;;
1500
1501      -dlpreopen)
1502        prev=dlprefiles
1503        continue
1504        ;;
1505
1506      -export-dynamic)
1507        export_dynamic=yes
1508        continue
1509        ;;
1510
1511      -export-symbols | -export-symbols-regex)
1512        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1513          $echo "$modename: more than one -exported-symbols argument is not allowed"
1514          exit $EXIT_FAILURE
1515        fi
1516        if test "X$arg" = "X-export-symbols"; then
1517          prev=expsyms
1518        else
1519          prev=expsyms_regex
1520        fi
1521        continue
1522        ;;
1523
1524      -framework|-arch|-isysroot)
1525        case " $CC " in
1526          *" ${arg} ${1} "* | *" ${arg} ${1} "*) 
1527                prev=darwin_framework_skip ;;
1528          *) compiler_flags="$compiler_flags $arg"
1529             prev=darwin_framework ;;
1530        esac
1531        compile_command="$compile_command $arg"
1532        finalize_command="$finalize_command $arg"
1533        continue
1534        ;;
1535
1536      -inst-prefix-dir)
1537        prev=inst_prefix
1538        continue
1539        ;;
1540
1541      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1542      # so, if we see these flags be careful not to treat them like -L
1543      -L[A-Z][A-Z]*:*)
1544        case $with_gcc/$host in
1545        no/*-*-irix* | /*-*-irix*)
1546          compile_command="$compile_command $arg"
1547          finalize_command="$finalize_command $arg"
1548          ;;
1549        esac
1550        continue
1551        ;;
1552
1553      -L*)
1554        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1555        # We need an absolute path.
1556        case $dir in
1557        [\\/]* | [A-Za-z]:[\\/]*) ;;
1558        *)
1559          absdir=`cd "$dir" && pwd`
1560          if test -z "$absdir"; then
1561            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1562            absdir="$dir"
1563            notinst_path="$notinst_path $dir"
1564          fi
1565          dir="$absdir"
1566          ;;
1567        esac
1568        case "$deplibs " in
1569        *" -L$dir "*) ;;
1570        *)
1571          deplibs="$deplibs -L$dir"
1572          lib_search_path="$lib_search_path $dir"
1573          ;;
1574        esac
1575        case $host in
1576        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1577          testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
1578          case :$dllsearchpath: in
1579          *":$dir:"*) ;;
1580          *) dllsearchpath="$dllsearchpath:$dir";;
1581          esac
1582          case :$dllsearchpath: in
1583          *":$testbindir:"*) ;;
1584          *) dllsearchpath="$dllsearchpath:$testbindir";;
1585          esac
1586          ;;
1587        esac
1588        continue
1589        ;;
1590
1591      -l*)
1592        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1593          case $host in
1594          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
1595            # These systems don't actually have a C or math library (as such)
1596            continue
1597            ;;
1598          *-*-os2*)
1599            # These systems don't actually have a C library (as such)
1600            test "X$arg" = "X-lc" && continue
1601            ;;
1602          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1603            # Do not include libc due to us having libc/libc_r.
1604            test "X$arg" = "X-lc" && continue
1605            ;;
1606          *-*-rhapsody* | *-*-darwin1.[012])
1607            # Rhapsody C and math libraries are in the System framework
1608            deplibs="$deplibs -framework System"
1609            continue
1610            ;;
1611          *-*-sco3.2v5* | *-*-sco5v6*)
1612            # Causes problems with __ctype
1613            test "X$arg" = "X-lc" && continue
1614            ;;
1615          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
1616            # Compiler inserts libc in the correct place for threads to work
1617            test "X$arg" = "X-lc" && continue
1618            ;;
1619          esac
1620        elif test "X$arg" = "X-lc_r"; then
1621         case $host in
1622         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1623           # Do not include libc_r directly, use -pthread flag.
1624           continue
1625           ;;
1626         esac
1627        fi
1628        deplibs="$deplibs $arg"
1629        continue
1630        ;;
1631
1632      # Tru64 UNIX uses -model [arg] to determine the layout of C++
1633      # classes, name mangling, and exception handling.
1634      -model)
1635        compile_command="$compile_command $arg"
1636        compiler_flags="$compiler_flags $arg"
1637        finalize_command="$finalize_command $arg"
1638        prev=xcompiler
1639        continue
1640        ;;
1641
1642     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
1643        compiler_flags="$compiler_flags $arg"
1644        compile_command="$compile_command $arg"
1645        finalize_command="$finalize_command $arg"
1646        continue
1647        ;;
1648
1649      -module)
1650        module=yes
1651        continue
1652        ;;
1653
1654      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1655      # -r[0-9][0-9]* specifies the processor on the SGI compiler
1656      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1657      # +DA*, +DD* enable 64-bit mode on the HP compiler
1658      # -q* pass through compiler args for the IBM compiler
1659      # -m* pass through architecture-specific compiler args for GCC
1660      # -m*, -t[45]*, -txscale* pass through architecture-specific
1661      # compiler args for GCC
1662      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
1663      # -F/path gives path to uninstalled frameworks, gcc on darwin
1664      # @file GCC response files
1665      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
1666      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
1667
1668        # Unknown arguments in both finalize_command and compile_command need
1669        # to be aesthetically quoted because they are evaled later.
1670        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1671        case $arg in
1672        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1673          arg="\"$arg\""
1674          ;;
1675        esac
1676        compile_command="$compile_command $arg"
1677        finalize_command="$finalize_command $arg"
1678        compiler_flags="$compiler_flags $arg"
1679        continue
1680        ;;
1681
1682      -shrext)
1683        prev=shrext
1684        continue
1685        ;;
1686
1687      -no-fast-install)
1688        fast_install=no
1689        continue
1690        ;;
1691
1692      -no-install)
1693        case $host in
1694        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
1695          # The PATH hackery in wrapper scripts is required on Windows
1696          # and Darwin in order for the loader to find any dlls it needs.
1697          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1698          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1699          fast_install=no
1700          ;;
1701        *) no_install=yes ;;
1702        esac
1703        continue
1704        ;;
1705
1706      -no-undefined)
1707        allow_undefined=no
1708        continue
1709        ;;
1710
1711      -objectlist)
1712        prev=objectlist
1713        continue
1714        ;;
1715
1716      -o) prev=output ;;
1717
1718      -precious-files-regex)
1719        prev=precious_regex
1720        continue
1721        ;;
1722
1723      -release)
1724        prev=release
1725        continue
1726        ;;
1727
1728      -rpath)
1729        prev=rpath
1730        continue
1731        ;;
1732
1733      -R)
1734        prev=xrpath
1735        continue
1736        ;;
1737
1738      -R*)
1739        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1740        # We need an absolute path.
1741        case $dir in
1742        [\\/]* | [A-Za-z]:[\\/]*) ;;
1743        *)
1744          $echo "$modename: only absolute run-paths are allowed" 1>&2
1745          exit $EXIT_FAILURE
1746          ;;
1747        esac
1748        case "$xrpath " in
1749        *" $dir "*) ;;
1750        *) xrpath="$xrpath $dir" ;;
1751        esac
1752        continue
1753        ;;
1754
1755      -static | -static-libtool-libs)
1756        # The effects of -static are defined in a previous loop.
1757        # We used to do the same as -all-static on platforms that
1758        # didn't have a PIC flag, but the assumption that the effects
1759        # would be equivalent was wrong.  It would break on at least
1760        # Digital Unix and AIX.
1761        continue
1762        ;;
1763
1764      -thread-safe)
1765        thread_safe=yes
1766        continue
1767        ;;
1768
1769      -version-info)
1770        prev=vinfo
1771        continue
1772        ;;
1773      -version-number)
1774        prev=vinfo
1775        vinfo_number=yes
1776        continue
1777        ;;
1778
1779      -Wc,*)
1780        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1781        arg=
1782        save_ifs="$IFS"; IFS=','
1783        for flag in $args; do
1784          IFS="$save_ifs"
1785          case $flag in
1786            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1787            flag="\"$flag\""
1788            ;;
1789          esac
1790          arg="$arg $wl$flag"
1791          compiler_flags="$compiler_flags $flag"
1792        done
1793        IFS="$save_ifs"
1794        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1795        ;;
1796
1797      -Wl,*)
1798        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1799        arg=
1800        save_ifs="$IFS"; IFS=','
1801        for flag in $args; do
1802          IFS="$save_ifs"
1803          case $flag in
1804            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1805            flag="\"$flag\""
1806            ;;
1807          esac
1808          arg="$arg $wl$flag"
1809          compiler_flags="$compiler_flags $wl$flag"
1810          linker_flags="$linker_flags $flag"
1811        done
1812        IFS="$save_ifs"
1813        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1814        ;;
1815
1816      -Xcompiler)
1817        prev=xcompiler
1818        continue
1819        ;;
1820
1821      -Xlinker)
1822        prev=xlinker
1823        continue
1824        ;;
1825
1826      -XCClinker)
1827        prev=xcclinker
1828        continue
1829        ;;
1830
1831      # Some other compiler flag.
1832      -* | +*)
1833        # Unknown arguments in both finalize_command and compile_command need
1834        # to be aesthetically quoted because they are evaled later.
1835        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1836        case $arg in
1837        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1838          arg="\"$arg\""
1839          ;;
1840        esac
1841        ;;
1842
1843      *.$objext)
1844        # A standard object.
1845        objs="$objs $arg"
1846        ;;
1847
1848      *.lo)
1849        # A libtool-controlled object.
1850
1851        # Check to see that this really is a libtool object.
1852        if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1853          pic_object=
1854          non_pic_object=
1855
1856          # Read the .lo file
1857          # If there is no directory component, then add one.
1858          case $arg in
1859          */* | *\\*) . $arg ;;
1860          *) . ./$arg ;;
1861          esac
1862
1863          if test -z "$pic_object" || \
1864             test -z "$non_pic_object" ||
1865             test "$pic_object" = none && \
1866             test "$non_pic_object" = none; then
1867            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1868            exit $EXIT_FAILURE
1869          fi
1870
1871          # Extract subdirectory from the argument.
1872          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1873          if test "X$xdir" = "X$arg"; then
1874            xdir=
1875          else
1876            xdir="$xdir/"
1877          fi
1878
1879          if test "$pic_object" != none; then
1880            # Prepend the subdirectory the object is found in.
1881            pic_object="$xdir$pic_object"
1882
1883            if test "$prev" = dlfiles; then
1884              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1885                dlfiles="$dlfiles $pic_object"
1886                prev=
1887                continue
1888              else
1889                # If libtool objects are unsupported, then we need to preload.
1890                prev=dlprefiles
1891              fi
1892            fi
1893
1894            # CHECK ME:  I think I busted this.  -Ossama
1895            if test "$prev" = dlprefiles; then
1896              # Preload the old-style object.
1897              dlprefiles="$dlprefiles $pic_object"
1898              prev=
1899            fi
1900
1901            # A PIC object.
1902            libobjs="$libobjs $pic_object"
1903            arg="$pic_object"
1904          fi
1905
1906          # Non-PIC object.
1907          if test "$non_pic_object" != none; then
1908            # Prepend the subdirectory the object is found in.
1909            non_pic_object="$xdir$non_pic_object"
1910
1911            # A standard non-PIC object
1912            non_pic_objects="$non_pic_objects $non_pic_object"
1913            if test -z "$pic_object" || test "$pic_object" = none ; then
1914              arg="$non_pic_object"
1915            fi
1916          else
1917            # If the PIC object exists, use it instead.
1918            # $xdir was prepended to $pic_object above.
1919            non_pic_object="$pic_object"
1920            non_pic_objects="$non_pic_objects $non_pic_object"
1921          fi
1922        else
1923          # Only an error if not doing a dry-run.
1924          if test -z "$run"; then
1925            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1926            exit $EXIT_FAILURE
1927          else
1928            # Dry-run case.
1929
1930            # Extract subdirectory from the argument.
1931            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1932            if test "X$xdir" = "X$arg"; then
1933              xdir=
1934            else
1935              xdir="$xdir/"
1936            fi
1937
1938            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1939            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1940            libobjs="$libobjs $pic_object"
1941            non_pic_objects="$non_pic_objects $non_pic_object"
1942          fi
1943        fi
1944        ;;
1945
1946      *.$libext)
1947        # An archive.
1948        deplibs="$deplibs $arg"
1949        old_deplibs="$old_deplibs $arg"
1950        continue
1951        ;;
1952
1953      *.la)
1954        # A libtool-controlled library.
1955
1956        if test "$prev" = dlfiles; then
1957          # This library was specified with -dlopen.
1958          dlfiles="$dlfiles $arg"
1959          prev=
1960        elif test "$prev" = dlprefiles; then
1961          # The library was specified with -dlpreopen.
1962          dlprefiles="$dlprefiles $arg"
1963          prev=
1964        else
1965          deplibs="$deplibs $arg"
1966        fi
1967        continue
1968        ;;
1969
1970      # Some other compiler argument.
1971      *)
1972        # Unknown arguments in both finalize_command and compile_command need
1973        # to be aesthetically quoted because they are evaled later.
1974        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1975        case $arg in
1976        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1977          arg="\"$arg\""
1978          ;;
1979        esac
1980        ;;
1981      esac # arg
1982
1983      # Now actually substitute the argument into the commands.
1984      if test -n "$arg"; then
1985        compile_command="$compile_command $arg"
1986        finalize_command="$finalize_command $arg"
1987      fi
1988    done # argument parsing loop
1989
1990    if test -n "$prev"; then
1991      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1992      $echo "$help" 1>&2
1993      exit $EXIT_FAILURE
1994    fi
1995
1996    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1997      eval arg=\"$export_dynamic_flag_spec\"
1998      compile_command="$compile_command $arg"
1999      finalize_command="$finalize_command $arg"
2000    fi
2001
2002    oldlibs=
2003    # calculate the name of the file, without its directory
2004    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
2005    libobjs_save="$libobjs"
2006
2007    if test -n "$shlibpath_var"; then
2008      # get the directories listed in $shlibpath_var
2009      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
2010    else
2011      shlib_search_path=
2012    fi
2013    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
2014    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
2015
2016    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
2017    if test "X$output_objdir" = "X$output"; then
2018      output_objdir="$objdir"
2019    else
2020      output_objdir="$output_objdir/$objdir"
2021    fi
2022    # Create the object directory.
2023    if test ! -d "$output_objdir"; then
2024      $show "$mkdir $output_objdir"
2025      $run $mkdir $output_objdir
2026      exit_status=$?
2027      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
2028        exit $exit_status
2029      fi
2030    fi
2031
2032    # Determine the type of output
2033    case $output in
2034    "")
2035      $echo "$modename: you must specify an output file" 1>&2
2036      $echo "$help" 1>&2
2037      exit $EXIT_FAILURE
2038      ;;
2039    *.$libext) linkmode=oldlib ;;
2040    *.lo | *.$objext) linkmode=obj ;;
2041    *.la) linkmode=lib ;;
2042    *) linkmode=prog ;; # Anything else should be a program.
2043    esac
2044
2045    case $host in
2046    *cygwin* | *mingw* | *pw32*)
2047      # don't eliminate duplications in $postdeps and $predeps
2048      duplicate_compiler_generated_deps=yes
2049      ;;
2050    *)
2051      duplicate_compiler_generated_deps=$duplicate_deps
2052      ;;
2053    esac
2054    specialdeplibs=
2055
2056    libs=
2057    # Find all interdependent deplibs by searching for libraries
2058    # that are linked more than once (e.g. -la -lb -la)
2059    for deplib in $deplibs; do
2060      if test "X$duplicate_deps" = "Xyes" ; then
2061        case "$libs " in
2062        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2063        esac
2064      fi
2065      libs="$libs $deplib"
2066    done
2067
2068    if test "$linkmode" = lib; then
2069      libs="$predeps $libs $compiler_lib_search_path $postdeps"
2070
2071      # Compute libraries that are listed more than once in $predeps
2072      # $postdeps and mark them as special (i.e., whose duplicates are
2073      # not to be eliminated).
2074      pre_post_deps=
2075      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
2076        for pre_post_dep in $predeps $postdeps; do
2077          case "$pre_post_deps " in
2078          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
2079          esac
2080          pre_post_deps="$pre_post_deps $pre_post_dep"
2081        done
2082      fi
2083      pre_post_deps=
2084    fi
2085
2086    deplibs=
2087    newdependency_libs=
2088    newlib_search_path=
2089    need_relink=no # whether we're linking any uninstalled libtool libraries
2090    notinst_deplibs= # not-installed libtool libraries
2091    case $linkmode in
2092    lib)
2093        passes="conv link"
2094        for file in $dlfiles $dlprefiles; do
2095          case $file in
2096          *.la) ;;
2097          *)
2098            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2099            exit $EXIT_FAILURE
2100            ;;
2101          esac
2102        done
2103        ;;
2104    prog)
2105        compile_deplibs=
2106        finalize_deplibs=
2107        alldeplibs=no
2108        newdlfiles=
2109        newdlprefiles=
2110        passes="conv scan dlopen dlpreopen link"
2111        ;;
2112    *)  passes="conv"
2113        ;;
2114    esac
2115    for pass in $passes; do
2116      if test "$linkmode,$pass" = "lib,link" ||
2117         test "$linkmode,$pass" = "prog,scan"; then
2118        libs="$deplibs"
2119        deplibs=
2120      fi
2121      if test "$linkmode" = prog; then
2122        case $pass in
2123        dlopen) libs="$dlfiles" ;;
2124        dlpreopen) libs="$dlprefiles" ;;
2125        link)
2126          libs="$deplibs %DEPLIBS%"
2127          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
2128          ;;
2129        esac
2130      fi
2131      if test "$pass" = dlopen; then
2132        # Collect dlpreopened libraries
2133        save_deplibs="$deplibs"
2134        deplibs=
2135      fi
2136      for deplib in $libs; do
2137        lib=
2138        found=no
2139        case $deplib in
2140        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
2141          if test "$linkmode,$pass" = "prog,link"; then
2142            compile_deplibs="$deplib $compile_deplibs"
2143            finalize_deplibs="$deplib $finalize_deplibs"
2144          else
2145            compiler_flags="$compiler_flags $deplib"
2146          fi
2147          continue
2148          ;;
2149        -l*)
2150          if test "$linkmode" != lib && test "$linkmode" != prog; then
2151            $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2152            continue
2153          fi
2154          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2155          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
2156            for search_ext in .la $std_shrext .so .a; do
2157              # Search the libtool library
2158              lib="$searchdir/lib${name}${search_ext}"
2159              if test -f "$lib"; then
2160                if test "$search_ext" = ".la"; then
2161                  found=yes
2162                else
2163                  found=no
2164                fi
2165                break 2
2166              fi
2167            done
2168          done
2169          if test "$found" != yes; then
2170            # deplib doesn't seem to be a libtool library
2171            if test "$linkmode,$pass" = "prog,link"; then
2172              compile_deplibs="$deplib $compile_deplibs"
2173              finalize_deplibs="$deplib $finalize_deplibs"
2174            else
2175              deplibs="$deplib $deplibs"
2176              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2177            fi
2178            continue
2179          else # deplib is a libtool library
2180            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2181            # We need to do some special things here, and not later.
2182            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2183              case " $predeps $postdeps " in
2184              *" $deplib "*)
2185                if (${SED} -e '2q' $lib |
2186                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2187                  library_names=
2188                  old_library=
2189                  case $lib in
2190                  */* | *\\*) . $lib ;;
2191                  *) . ./$lib ;;
2192                  esac
2193                  for l in $old_library $library_names; do
2194                    ll="$l"
2195                  done
2196                  if test "X$ll" = "X$old_library" ; then # only static version available
2197                    found=no
2198                    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2199                    test "X$ladir" = "X$lib" && ladir="."
2200                    lib=$ladir/$old_library
2201                    if test "$linkmode,$pass" = "prog,link"; then
2202                      compile_deplibs="$deplib $compile_deplibs"
2203                      finalize_deplibs="$deplib $finalize_deplibs"
2204                    else
2205                      deplibs="$deplib $deplibs"
2206                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2207                    fi
2208                    continue
2209                  fi
2210                fi
2211                ;;
2212              *) ;;
2213              esac
2214            fi
2215          fi
2216          ;; # -l
2217        -L*)
2218          case $linkmode in
2219          lib)
2220            deplibs="$deplib $deplibs"
2221            test "$pass" = conv && continue
2222            newdependency_libs="$deplib $newdependency_libs"
2223            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2224            ;;
2225          prog)
2226            if test "$pass" = conv; then
2227              deplibs="$deplib $deplibs"
2228              continue
2229            fi
2230            if test "$pass" = scan; then
2231              deplibs="$deplib $deplibs"
2232            else
2233              compile_deplibs="$deplib $compile_deplibs"
2234              finalize_deplibs="$deplib $finalize_deplibs"
2235            fi
2236            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2237            ;;
2238          *)
2239            $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2240            ;;
2241          esac # linkmode
2242          continue
2243          ;; # -L
2244        -R*)
2245          if test "$pass" = link; then
2246            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2247            # Make sure the xrpath contains only unique directories.
2248            case "$xrpath " in
2249            *" $dir "*) ;;
2250            *) xrpath="$xrpath $dir" ;;
2251            esac
2252          fi
2253          deplibs="$deplib $deplibs"
2254          continue
2255          ;;
2256        *.la) lib="$deplib" ;;
2257        *.$libext)
2258          if test "$pass" = conv; then
2259            deplibs="$deplib $deplibs"
2260            continue
2261          fi
2262          case $linkmode in
2263          lib)
2264            valid_a_lib=no
2265            case $deplibs_check_method in
2266              match_pattern*)
2267                set dummy $deplibs_check_method
2268                match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2269                if eval $echo \"$deplib\" 2>/dev/null \
2270                    | $SED 10q \
2271                    | $EGREP "$match_pattern_regex" > /dev/null; then
2272                  valid_a_lib=yes
2273                fi
2274                ;;
2275              pass_all)
2276                valid_a_lib=yes
2277                ;;
2278            esac
2279            if test "$valid_a_lib" != yes; then
2280              $echo
2281              $echo "*** Warning: Trying to link with static lib archive $deplib."
2282              $echo "*** I have the capability to make that library automatically link in when"
2283              $echo "*** you link to this library.  But I can only do this if you have a"
2284              $echo "*** shared version of the library, which you do not appear to have"
2285              $echo "*** because the file extensions .$libext of this argument makes me believe"
2286              $echo "*** that it is just a static archive that I should not used here."
2287            else
2288              $echo
2289              $echo "*** Warning: Linking the shared library $output against the"
2290              $echo "*** static library $deplib is not portable!"
2291              deplibs="$deplib $deplibs"
2292            fi
2293            continue
2294            ;;
2295          prog)
2296            if test "$pass" != link; then
2297              deplibs="$deplib $deplibs"
2298            else
2299              compile_deplibs="$deplib $compile_deplibs"
2300              finalize_deplibs="$deplib $finalize_deplibs"
2301            fi
2302            continue
2303            ;;
2304          esac # linkmode
2305          ;; # *.$libext
2306        *.lo | *.$objext)
2307          if test "$pass" = conv; then
2308            deplibs="$deplib $deplibs"
2309          elif test "$linkmode" = prog; then
2310            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2311              # If there is no dlopen support or we're linking statically,
2312              # we need to preload.
2313              newdlprefiles="$newdlprefiles $deplib"
2314              compile_deplibs="$deplib $compile_deplibs"
2315              finalize_deplibs="$deplib $finalize_deplibs"
2316            else
2317              newdlfiles="$newdlfiles $deplib"
2318            fi
2319          fi
2320          continue
2321          ;;
2322        %DEPLIBS%)
2323          alldeplibs=yes
2324          continue
2325          ;;
2326        esac # case $deplib
2327        if test "$found" = yes || test -f "$lib"; then :
2328        else
2329          $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2330          exit $EXIT_FAILURE
2331        fi
2332
2333        # Check to see that this really is a libtool archive.
2334        if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2335        else
2336          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2337          exit $EXIT_FAILURE
2338        fi
2339
2340        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2341        test "X$ladir" = "X$lib" && ladir="."
2342
2343        dlname=
2344        dlopen=
2345        dlpreopen=
2346        libdir=
2347        library_names=
2348        old_library=
2349        # If the library was installed with an old release of libtool,
2350        # it will not redefine variables installed, or shouldnotlink
2351        installed=yes
2352        shouldnotlink=no
2353        avoidtemprpath=
2354
2355
2356        # Read the .la file
2357        case $lib in
2358        */* | *\\*) . $lib ;;
2359        *) . ./$lib ;;
2360        esac
2361
2362        if test "$linkmode,$pass" = "lib,link" ||
2363           test "$linkmode,$pass" = "prog,scan" ||
2364           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2365          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2366          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2367        fi
2368
2369        if test "$pass" = conv; then
2370          # Only check for convenience libraries
2371          deplibs="$lib $deplibs"
2372          if test -z "$libdir"; then
2373            if test -z "$old_library"; then
2374              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2375              exit $EXIT_FAILURE
2376            fi
2377            # It is a libtool convenience library, so add in its objects.
2378            convenience="$convenience $ladir/$objdir/$old_library"
2379            old_convenience="$old_convenience $ladir/$objdir/$old_library"
2380            tmp_libs=
2381            for deplib in $dependency_libs; do
2382              deplibs="$deplib $deplibs"
2383              if test "X$duplicate_deps" = "Xyes" ; then
2384                case "$tmp_libs " in
2385                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2386                esac
2387              fi
2388              tmp_libs="$tmp_libs $deplib"
2389            done
2390          elif test "$linkmode" != prog && test "$linkmode" != lib; then
2391            $echo "$modename: \`$lib' is not a convenience library" 1>&2
2392            exit $EXIT_FAILURE
2393          fi
2394          continue
2395        fi # $pass = conv
2396
2397
2398        # Get the name of the library we link against.
2399        linklib=
2400        for l in $old_library $library_names; do
2401          linklib="$l"
2402        done
2403        if test -z "$linklib"; then
2404          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2405          exit $EXIT_FAILURE
2406        fi
2407
2408        # This library was specified with -dlopen.
2409        if test "$pass" = dlopen; then
2410          if test -z "$libdir"; then
2411            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2412            exit $EXIT_FAILURE
2413          fi
2414          if test -z "$dlname" ||
2415             test "$dlopen_support" != yes ||
2416             test "$build_libtool_libs" = no; then
2417            # If there is no dlname, no dlopen support or we're linking
2418            # statically, we need to preload.  We also need to preload any
2419            # dependent libraries so libltdl's deplib preloader doesn't
2420            # bomb out in the load deplibs phase.
2421            dlprefiles="$dlprefiles $lib $dependency_libs"
2422          else
2423            newdlfiles="$newdlfiles $lib"
2424          fi
2425          continue
2426        fi # $pass = dlopen
2427
2428        # We need an absolute path.
2429        case $ladir in
2430        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2431        *)
2432          abs_ladir=`cd "$ladir" && pwd`
2433          if test -z "$abs_ladir"; then
2434            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2435            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2436            abs_ladir="$ladir"
2437          fi
2438          ;;
2439        esac
2440        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2441
2442        # Find the relevant object directory and library name.
2443        if test "X$installed" = Xyes; then
2444          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2445            $echo "$modename: warning: library \`$lib' was moved." 1>&2
2446            dir="$ladir"
2447            absdir="$abs_ladir"
2448            libdir="$abs_ladir"
2449          else
2450            dir="$libdir"
2451            absdir="$libdir"
2452          fi
2453          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2454        else
2455          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2456            dir="$ladir"
2457            absdir="$abs_ladir"
2458            # Remove this search path later
2459            notinst_path="$notinst_path $abs_ladir"
2460          else
2461            dir="$ladir/$objdir"
2462            absdir="$abs_ladir/$objdir"
2463            # Remove this search path later
2464            notinst_path="$notinst_path $abs_ladir"
2465          fi
2466        fi # $installed = yes
2467        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2468
2469        # This library was specified with -dlpreopen.
2470        if test "$pass" = dlpreopen; then
2471          if test -z "$libdir"; then
2472            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2473            exit $EXIT_FAILURE
2474          fi
2475          # Prefer using a static library (so that no silly _DYNAMIC symbols
2476          # are required to link).
2477          if test -n "$old_library"; then
2478            newdlprefiles="$newdlprefiles $dir/$old_library"
2479          # Otherwise, use the dlname, so that lt_dlopen finds it.
2480          elif test -n "$dlname"; then
2481            newdlprefiles="$newdlprefiles $dir/$dlname"
2482          else
2483            newdlprefiles="$newdlprefiles $dir/$linklib"
2484          fi
2485        fi # $pass = dlpreopen
2486
2487        if test -z "$libdir"; then
2488          # Link the convenience library
2489          if test "$linkmode" = lib; then
2490            deplibs="$dir/$old_library $deplibs"
2491          elif test "$linkmode,$pass" = "prog,link"; then
2492            compile_deplibs="$dir/$old_library $compile_deplibs"
2493            finalize_deplibs="$dir/$old_library $finalize_deplibs"
2494          else
2495            deplibs="$lib $deplibs" # used for prog,scan pass
2496          fi
2497          continue
2498        fi
2499
2500
2501        if test "$linkmode" = prog && test "$pass" != link; then
2502          newlib_search_path="$newlib_search_path $ladir"
2503          deplibs="$lib $deplibs"
2504
2505          linkalldeplibs=no
2506          if test "$link_all_deplibs" != no || test -z "$library_names" ||
2507             test "$build_libtool_libs" = no; then
2508            linkalldeplibs=yes
2509          fi
2510
2511          tmp_libs=
2512          for deplib in $dependency_libs; do
2513            case $deplib in
2514            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2515            esac
2516            # Need to link against all dependency_libs?
2517            if test "$linkalldeplibs" = yes; then
2518              deplibs="$deplib $deplibs"
2519            else
2520              # Need to hardcode shared library paths
2521              # or/and link against static libraries
2522              newdependency_libs="$deplib $newdependency_libs"
2523            fi
2524            if test "X$duplicate_deps" = "Xyes" ; then
2525              case "$tmp_libs " in
2526              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2527              esac
2528            fi
2529            tmp_libs="$tmp_libs $deplib"
2530          done # for deplib
2531          continue
2532        fi # $linkmode = prog...
2533
2534        if test "$linkmode,$pass" = "prog,link"; then
2535          if test -n "$library_names" &&
2536             { { test "$prefer_static_libs" = no ||
2537                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
2538               test -z "$old_library"; }; then
2539            # We need to hardcode the library path
2540            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2541              # Make sure the rpath contains only unique directories.
2542              case "$temp_rpath " in
2543              *" $dir "*) ;;
2544              *" $absdir "*) ;;
2545              *) temp_rpath="$temp_rpath $absdir" ;;
2546              esac
2547            fi
2548
2549            # Hardcode the library path.
2550            # Skip directories that are in the system default run-time
2551            # search path.
2552            case " $sys_lib_dlsearch_path " in
2553            *" $absdir "*) ;;
2554            *)
2555              case "$compile_rpath " in
2556              *" $absdir "*) ;;
2557              *) compile_rpath="$compile_rpath $absdir"
2558              esac
2559              ;;
2560            esac
2561            case " $sys_lib_dlsearch_path " in
2562            *" $libdir "*) ;;
2563            *)
2564              case "$finalize_rpath " in
2565              *" $libdir "*) ;;
2566              *) finalize_rpath="$finalize_rpath $libdir"
2567              esac
2568              ;;
2569            esac
2570          fi # $linkmode,$pass = prog,link...
2571
2572          if test "$alldeplibs" = yes &&
2573             { test "$deplibs_check_method" = pass_all ||
2574               { test "$build_libtool_libs" = yes &&
2575                 test -n "$library_names"; }; }; then
2576            # We only need to search for static libraries
2577            continue
2578          fi
2579        fi
2580
2581        link_static=no # Whether the deplib will be linked statically
2582        use_static_libs=$prefer_static_libs
2583        if test "$use_static_libs" = built && test "$installed" = yes ; then
2584          use_static_libs=no
2585        fi
2586        if test -n "$library_names" &&
2587           { test "$use_static_libs" = no || test -z "$old_library"; }; then
2588          if test "$installed" = no; then
2589            notinst_deplibs="$notinst_deplibs $lib"
2590            need_relink=yes
2591          fi
2592          # This is a shared library
2593
2594          # Warn about portability, can't link against -module's on
2595          # some systems (darwin)
2596          if test "$shouldnotlink" = yes && test "$pass" = link ; then
2597            $echo
2598            if test "$linkmode" = prog; then
2599              $echo "*** Warning: Linking the executable $output against the loadable module"
2600            else
2601              $echo "*** Warning: Linking the shared library $output against the loadable module"
2602            fi
2603            $echo "*** $linklib is not portable!"
2604          fi
2605          if test "$linkmode" = lib &&
2606             test "$hardcode_into_libs" = yes; then
2607            # Hardcode the library path.
2608            # Skip directories that are in the system default run-time
2609            # search path.
2610            case " $sys_lib_dlsearch_path " in
2611            *" $absdir "*) ;;
2612            *)
2613              case "$compile_rpath " in
2614              *" $absdir "*) ;;
2615              *) compile_rpath="$compile_rpath $absdir"
2616              esac
2617              ;;
2618            esac
2619            case " $sys_lib_dlsearch_path " in
2620            *" $libdir "*) ;;
2621            *)
2622              case "$finalize_rpath " in
2623              *" $libdir "*) ;;
2624              *) finalize_rpath="$finalize_rpath $libdir"
2625              esac
2626              ;;
2627            esac
2628          fi
2629
2630          if test -n "$old_archive_from_expsyms_cmds"; then
2631            # figure out the soname
2632            set dummy $library_names
2633            realname="$2"
2634            shift; shift
2635            libname=`eval \\$echo \"$libname_spec\"`
2636            # use dlname if we got it. it's perfectly good, no?
2637            if test -n "$dlname"; then
2638              soname="$dlname"
2639            elif test -n "$soname_spec"; then
2640              # bleh windows
2641              case $host in
2642              *cygwin* | mingw*)
2643                major=`expr $current - $age`
2644                versuffix="-$major"
2645                ;;
2646              esac
2647              eval soname=\"$soname_spec\"
2648            else
2649              soname="$realname"
2650            fi
2651
2652            # Make a new name for the extract_expsyms_cmds to use
2653            soroot="$soname"
2654            soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2655            newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2656
2657            # If the library has no export list, then create one now
2658            if test -f "$output_objdir/$soname-def"; then :
2659            else
2660              $show "extracting exported symbol list from \`$soname'"
2661              save_ifs="$IFS"; IFS='~'
2662              cmds=$extract_expsyms_cmds
2663              for cmd in $cmds; do
2664                IFS="$save_ifs"
2665                eval cmd=\"$cmd\"
2666                $show "$cmd"
2667                $run eval "$cmd" || exit $?
2668              done
2669              IFS="$save_ifs"
2670            fi
2671
2672            # Create $newlib
2673            if test -f "$output_objdir/$newlib"; then :; else
2674              $show "generating import library for \`$soname'"
2675              save_ifs="$IFS"; IFS='~'
2676              cmds=$old_archive_from_expsyms_cmds
2677              for cmd in $cmds; do
2678                IFS="$save_ifs"
2679                eval cmd=\"$cmd\"
2680                $show "$cmd"
2681                $run eval "$cmd" || exit $?
2682              done
2683              IFS="$save_ifs"
2684            fi
2685            # make sure the library variables are pointing to the new library
2686            dir=$output_objdir
2687            linklib=$newlib
2688          fi # test -n "$old_archive_from_expsyms_cmds"
2689
2690          if test "$linkmode" = prog || test "$mode" != relink; then
2691            add_shlibpath=
2692            add_dir=
2693            add=
2694            lib_linked=yes
2695            case $hardcode_action in
2696            immediate | unsupported)
2697              if test "$hardcode_direct" = no; then
2698                add="$dir/$linklib"
2699                case $host in
2700                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
2701                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
2702                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2703                    *-*-unixware7*) add_dir="-L$dir" ;;
2704                  *-*-darwin* )
2705                    # if the lib is a module then we can not link against
2706                    # it, someone is ignoring the new warnings I added
2707                    if /usr/bin/file -L $add 2> /dev/null |
2708                      $EGREP ": [^:]* bundle" >/dev/null ; then
2709                      $echo "** Warning, lib $linklib is a module, not a shared library"
2710                      if test -z "$old_library" ; then
2711                        $echo
2712                        $echo "** And there doesn't seem to be a static archive available"
2713                        $echo "** The link will probably fail, sorry"
2714                      else
2715                        add="$dir/$old_library"
2716                      fi
2717                    fi
2718                esac
2719              elif test "$hardcode_minus_L" = no; then
2720                case $host in
2721                *-*-sunos*) add_shlibpath="$dir" ;;
2722                esac
2723                add_dir="-L$dir"
2724                add="-l$name"
2725              elif test "$hardcode_shlibpath_var" = no; then
2726                add_shlibpath="$dir"
2727                add="-l$name"
2728              else
2729                lib_linked=no
2730              fi
2731              ;;
2732            relink)
2733              if test "$hardcode_direct" = yes; then
2734                add="$dir/$linklib"
2735              elif test "$hardcode_minus_L" = yes; then
2736                add_dir="-L$dir"
2737                # Try looking first in the location we're being installed to.
2738                if test -n "$inst_prefix_dir"; then
2739                  case $libdir in
2740                    [\\/]*)
2741                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
2742                      ;;
2743                  esac
2744                fi
2745                add="-l$name"
2746              elif test "$hardcode_shlibpath_var" = yes; then
2747                add_shlibpath="$dir"
2748                add="-l$name"
2749              else
2750                lib_linked=no
2751              fi
2752              ;;
2753            *) lib_linked=no ;;
2754            esac
2755
2756            if test "$lib_linked" != yes; then
2757              $echo "$modename: configuration error: unsupported hardcode properties"
2758              exit $EXIT_FAILURE
2759            fi
2760
2761            if test -n "$add_shlibpath"; then
2762              case :$compile_shlibpath: in
2763              *":$add_shlibpath:"*) ;;
2764              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2765              esac
2766            fi
2767            if test "$linkmode" = prog; then
2768              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2769              test -n "$add" && compile_deplibs="$add $compile_deplibs"
2770            else
2771              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2772              test -n "$add" && deplibs="$add $deplibs"
2773              if test "$hardcode_direct" != yes && \
2774                 test "$hardcode_minus_L" != yes && \
2775                 test "$hardcode_shlibpath_var" = yes; then
2776                case :$finalize_shlibpath: in
2777                *":$libdir:"*) ;;
2778                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2779                esac
2780              fi
2781            fi
2782          fi
2783
2784          if test "$linkmode" = prog || test "$mode" = relink; then
2785            add_shlibpath=
2786            add_dir=
2787            add=
2788            # Finalize command for both is simple: just hardcode it.
2789            if test "$hardcode_direct" = yes; then
2790              add="$libdir/$linklib"
2791            elif test "$hardcode_minus_L" = yes; then
2792              add_dir="-L$libdir"
2793              add="-l$name"
2794            elif test "$hardcode_shlibpath_var" = yes; then
2795              case :$finalize_shlibpath: in
2796              *":$libdir:"*) ;;
2797              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2798              esac
2799              add="-l$name"
2800            elif test "$hardcode_automatic" = yes; then
2801              if test -n "$inst_prefix_dir" &&
2802                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2803                add="$inst_prefix_dir$libdir/$linklib"
2804              else
2805                add="$libdir/$linklib"
2806              fi
2807            else
2808              # We cannot seem to hardcode it, guess we'll fake it.
2809              add_dir="-L$libdir"
2810              # Try looking first in the location we're being installed to.
2811              if test -n "$inst_prefix_dir"; then
2812                case $libdir in
2813                  [\\/]*)
2814                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
2815                    ;;
2816                esac
2817              fi
2818              add="-l$name"
2819            fi
2820
2821            if test "$linkmode" = prog; then
2822              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2823              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2824            else
2825              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2826              test -n "$add" && deplibs="$add $deplibs"
2827            fi
2828          fi
2829        elif test "$linkmode" = prog; then
2830          # Here we assume that one of hardcode_direct or hardcode_minus_L
2831          # is not unsupported.  This is valid on all known static and
2832          # shared platforms.
2833          if test "$hardcode_direct" != unsupported; then
2834            test -n "$old_library" && linklib="$old_library"
2835            compile_deplibs="$dir/$linklib $compile_deplibs"
2836            finalize_deplibs="$dir/$linklib $finalize_deplibs"
2837          else
2838            compile_deplibs="-l$name -L$dir $compile_deplibs"
2839            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2840          fi
2841        elif test "$build_libtool_libs" = yes; then
2842          # Not a shared library
2843          if test "$deplibs_check_method" != pass_all; then
2844            # We're trying link a shared library against a static one
2845            # but the system doesn't support it.
2846
2847            # Just print a warning and add the library to dependency_libs so
2848            # that the program can be linked against the static library.
2849            $echo
2850            $echo "*** Warning: This system can not link to static lib archive $lib."
2851            $echo "*** I have the capability to make that library automatically link in when"
2852            $echo "*** you link to this library.  But I can only do this if you have a"
2853            $echo "*** shared version of the library, which you do not appear to have."
2854            if test "$module" = yes; then
2855              $echo "*** But as you try to build a module library, libtool will still create "
2856              $echo "*** a static module, that should work as long as the dlopening application"
2857              $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2858              if test -z "$global_symbol_pipe"; then
2859                $echo
2860                $echo "*** However, this would only work if libtool was able to extract symbol"
2861                $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2862                $echo "*** not find such a program.  So, this module is probably useless."
2863                $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2864              fi
2865              if test "$build_old_libs" = no; then
2866                build_libtool_libs=module
2867                build_old_libs=yes
2868              else
2869                build_libtool_libs=no
2870              fi
2871            fi
2872          else
2873            deplibs="$dir/$old_library $deplibs"
2874            link_static=yes
2875          fi
2876        fi # link shared/static library?
2877
2878        if test "$linkmode" = lib; then
2879          if test -n "$dependency_libs" &&
2880             { test "$hardcode_into_libs" != yes ||
2881               test "$build_old_libs" = yes ||
2882               test "$link_static" = yes; }; then
2883            # Extract -R from dependency_libs
2884            temp_deplibs=
2885            for libdir in $dependency_libs; do
2886              case $libdir in
2887              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2888                   case " $xrpath " in
2889                   *" $temp_xrpath "*) ;;
2890                   *) xrpath="$xrpath $temp_xrpath";;
2891                   esac;;
2892              *) temp_deplibs="$temp_deplibs $libdir";;
2893              esac
2894            done
2895            dependency_libs="$temp_deplibs"
2896          fi
2897
2898          newlib_search_path="$newlib_search_path $absdir"
2899          # Link against this library
2900          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2901          # ... and its dependency_libs
2902          tmp_libs=
2903          for deplib in $dependency_libs; do
2904            newdependency_libs="$deplib $newdependency_libs"
2905            if test "X$duplicate_deps" = "Xyes" ; then
2906              case "$tmp_libs " in
2907              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2908              esac
2909            fi
2910            tmp_libs="$tmp_libs $deplib"
2911          done
2912
2913          if test "$link_all_deplibs" != no; then
2914            # Add the search paths of all dependency libraries
2915            for deplib in $dependency_libs; do
2916              case $deplib in
2917              -L*) path="$deplib" ;;
2918              *.la)
2919                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2920                test "X$dir" = "X$deplib" && dir="."
2921                # We need an absolute path.
2922                case $dir in
2923                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2924                *)
2925                  absdir=`cd "$dir" && pwd`
2926                  if test -z "$absdir"; then
2927                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2928                    absdir="$dir"
2929                  fi
2930                  ;;
2931                esac
2932                if grep "^installed=no" $deplib > /dev/null; then
2933                  path="$absdir/$objdir"
2934                else
2935                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2936                  if test -z "$libdir"; then
2937                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2938                    exit $EXIT_FAILURE
2939                  fi
2940                  if test "$absdir" != "$libdir"; then
2941                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2942                  fi
2943                  path="$absdir"
2944                fi
2945                depdepl=
2946                case $host in
2947                *-*-darwin*)
2948                  # we do not want to link against static libs,
2949                  # but need to link against shared
2950                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2951                  if test -n "$deplibrary_names" ; then
2952                    for tmp in $deplibrary_names ; do
2953                      depdepl=$tmp
2954                    done
2955                    if test -f "$path/$depdepl" ; then
2956                      depdepl="$path/$depdepl"
2957                    fi
2958                    # do not add paths which are already there
2959                    case " $newlib_search_path " in
2960                    *" $path "*) ;;
2961                    *) newlib_search_path="$newlib_search_path $path";;
2962                    esac
2963                  fi
2964                  path=""
2965                  ;;
2966                *)
2967                  path="-L$path"
2968                  ;;
2969                esac
2970                ;;
2971              -l*)
2972                case $host in
2973                *-*-darwin*)
2974                  # Again, we only want to link against shared libraries
2975                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2976                  for tmp in $newlib_search_path ; do
2977                    if test -f "$tmp/lib$tmp_libs.dylib" ; then
2978                      eval depdepl="$tmp/lib$tmp_libs.dylib"
2979                      break
2980                    fi
2981                  done
2982                  path=""
2983                  ;;
2984                *) continue ;;
2985                esac
2986                ;;
2987              *) continue ;;
2988              esac
2989              case " $deplibs " in
2990              *" $path "*) ;;
2991              *) deplibs="$path $deplibs" ;;
2992              esac
2993              case " $deplibs " in
2994              *" $depdepl "*) ;;
2995              *) deplibs="$depdepl $deplibs" ;;
2996              esac
2997            done
2998          fi # link_all_deplibs != no
2999        fi # linkmode = lib
3000      done # for deplib in $libs
3001      dependency_libs="$newdependency_libs"
3002      if test "$pass" = dlpreopen; then
3003        # Link the dlpreopened libraries before other libraries
3004        for deplib in $save_deplibs; do
3005          deplibs="$deplib $deplibs"
3006        done
3007      fi
3008      if test "$pass" != dlopen; then
3009        if test "$pass" != conv; then
3010          # Make sure lib_search_path contains only unique directories.
3011          lib_search_path=
3012          for dir in $newlib_search_path; do
3013            case "$lib_search_path " in
3014            *" $dir "*) ;;
3015            *) lib_search_path="$lib_search_path $dir" ;;
3016            esac
3017          done
3018          newlib_search_path=
3019        fi
3020
3021        if test "$linkmode,$pass" != "prog,link"; then
3022          vars="deplibs"
3023        else
3024          vars="compile_deplibs finalize_deplibs"
3025        fi
3026        for var in $vars dependency_libs; do
3027          # Add libraries to $var in reverse order
3028          eval tmp_libs=\"\$$var\"
3029          new_libs=
3030          for deplib in $tmp_libs; do
3031            # FIXME: Pedantically, this is the right thing to do, so
3032            #        that some nasty dependency loop isn't accidentally
3033            #        broken:
3034            #new_libs="$deplib $new_libs"
3035            # Pragmatically, this seems to cause very few problems in
3036            # practice:
3037            case $deplib in
3038            -L*) new_libs="$deplib $new_libs" ;;
3039            -R*) ;;
3040            *)
3041              # And here is the reason: when a library appears more
3042              # than once as an explicit dependence of a library, or
3043              # is implicitly linked in more than once by the
3044              # compiler, it is considered special, and multiple
3045              # occurrences thereof are not removed.  Compare this
3046              # with having the same library being listed as a
3047              # dependency of multiple other libraries: in this case,
3048              # we know (pedantically, we assume) the library does not
3049              # need to be listed more than once, so we keep only the
3050              # last copy.  This is not always right, but it is rare
3051              # enough that we require users that really mean to play
3052              # such unportable linking tricks to link the library
3053              # using -Wl,-lname, so that libtool does not consider it
3054              # for duplicate removal.
3055              case " $specialdeplibs " in
3056              *" $deplib "*) new_libs="$deplib $new_libs" ;;
3057              *)
3058                case " $new_libs " in
3059                *" $deplib "*) ;;
3060                *) new_libs="$deplib $new_libs" ;;
3061                esac
3062                ;;
3063              esac
3064              ;;
3065            esac
3066          done
3067          tmp_libs=
3068          for deplib in $new_libs; do
3069            case $deplib in
3070            -L*)
3071              case " $tmp_libs " in
3072              *" $deplib "*) ;;
3073              *) tmp_libs="$tmp_libs $deplib" ;;
3074              esac
3075              ;;
3076            *) tmp_libs="$tmp_libs $deplib" ;;
3077            esac
3078          done
3079          eval $var=\"$tmp_libs\"
3080        done # for var
3081      fi
3082      # Last step: remove runtime libs from dependency_libs
3083      # (they stay in deplibs)
3084      tmp_libs=
3085      for i in $dependency_libs ; do
3086        case " $predeps $postdeps $compiler_lib_search_path " in
3087        *" $i "*)
3088          i=""
3089          ;;
3090        esac
3091        if test -n "$i" ; then
3092          tmp_libs="$tmp_libs $i"
3093        fi
3094      done
3095      dependency_libs=$tmp_libs
3096    done # for pass
3097    if test "$linkmode" = prog; then
3098      dlfiles="$newdlfiles"
3099      dlprefiles="$newdlprefiles"
3100    fi
3101
3102    case $linkmode in
3103    oldlib)
3104      if test -n "$deplibs"; then
3105        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
3106      fi
3107
3108      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3109        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3110      fi
3111
3112      if test -n "$rpath"; then
3113        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3114      fi
3115
3116      if test -n "$xrpath"; then
3117        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3118      fi
3119
3120      if test -n "$vinfo"; then
3121        $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3122      fi
3123
3124      if test -n "$release"; then
3125        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3126      fi
3127
3128      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3129        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3130      fi
3131
3132      # Now set the variables for building old libraries.
3133      build_libtool_libs=no
3134      oldlibs="$output"
3135      objs="$objs$old_deplibs"
3136      ;;
3137
3138    lib)
3139      # Make sure we only generate libraries of the form `libNAME.la'.
3140      case $outputname in
3141      lib*)
3142        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3143        eval shared_ext=\"$shrext_cmds\"
3144        eval libname=\"$libname_spec\"
3145        ;;
3146      *)
3147        if test "$module" = no; then
3148          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3149          $echo "$help" 1>&2
3150          exit $EXIT_FAILURE
3151        fi
3152        if test "$need_lib_prefix" != no; then
3153          # Add the "lib" prefix for modules if required
3154          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3155          eval shared_ext=\"$shrext_cmds\"
3156          eval libname=\"$libname_spec\"
3157        else
3158          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3159        fi
3160        ;;
3161      esac
3162
3163      if test -n "$objs"; then
3164        if test "$deplibs_check_method" != pass_all; then
3165          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3166          exit $EXIT_FAILURE
3167        else
3168          $echo
3169          $echo "*** Warning: Linking the shared library $output against the non-libtool"
3170          $echo "*** objects $objs is not portable!"
3171          libobjs="$libobjs $objs"
3172        fi
3173      fi
3174
3175      if test "$dlself" != no; then
3176        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3177      fi
3178
3179      set dummy $rpath
3180      if test "$#" -gt 2; then
3181        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3182      fi
3183      install_libdir="$2"
3184
3185      oldlibs=
3186      if test -z "$rpath"; then
3187        if test "$build_libtool_libs" = yes; then
3188          # Building a libtool convenience library.
3189          # Some compilers have problems with a `.al' extension so
3190          # convenience libraries should have the same extension an
3191          # archive normally would.
3192          oldlibs="$output_objdir/$libname.$libext $oldlibs"
3193          build_libtool_libs=convenience
3194          build_old_libs=yes
3195        fi
3196
3197        if test -n "$vinfo"; then
3198          $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3199        fi
3200
3201        if test -n "$release"; then
3202          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3203        fi
3204      else
3205
3206        # Parse the version information argument.
3207        save_ifs="$IFS"; IFS=':'
3208        set dummy $vinfo 0 0 0
3209        IFS="$save_ifs"
3210
3211        if test -n "$8"; then
3212          $echo "$modename: too many parameters to \`-version-info'" 1>&2
3213          $echo "$help" 1>&2
3214          exit $EXIT_FAILURE
3215        fi
3216
3217        # convert absolute version numbers to libtool ages
3218        # this retains compatibility with .la files and attempts
3219        # to make the code below a bit more comprehensible
3220
3221        case $vinfo_number in
3222        yes)
3223          number_major="$2"
3224          number_minor="$3"
3225          number_revision="$4"
3226          #
3227          # There are really only two kinds -- those that
3228          # use the current revision as the major version
3229          # and those that subtract age and use age as
3230          # a minor version.  But, then there is irix
3231          # which has an extra 1 added just for fun
3232          #
3233          case $version_type in
3234          darwin|linux|osf|windows|none)
3235            current=`expr $number_major + $number_minor`
3236            age="$number_minor"
3237            revision="$number_revision"
3238            ;;
3239          freebsd-aout|freebsd-elf|sunos)
3240            current="$number_major"
3241            revision="$number_minor"
3242            age="0"
3243            ;;
3244          irix|nonstopux)
3245            current=`expr $number_major + $number_minor`
3246            age="$number_minor"
3247            revision="$number_minor"
3248            lt_irix_increment=no
3249            ;;
3250          *)
3251            $echo "$modename: unknown library version type \`$version_type'" 1>&2
3252            $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3253            exit $EXIT_FAILURE
3254            ;;
3255          esac
3256          ;;
3257        no)
3258          current="$2"
3259          revision="$3"
3260          age="$4"
3261          ;;
3262        esac
3263
3264        # Check that each of the things are valid numbers.
3265        case $current in
3266        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]) ;;
3267        *)
3268          $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3269          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3270          exit $EXIT_FAILURE
3271          ;;
3272        esac
3273
3274        case $revision in
3275        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]) ;;
3276        *)
3277          $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3278          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3279          exit $EXIT_FAILURE
3280          ;;
3281        esac
3282
3283        case $age in
3284        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]) ;;
3285        *)
3286          $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3287          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3288          exit $EXIT_FAILURE
3289          ;;
3290        esac
3291
3292        if test "$age" -gt "$current"; then
3293          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3294          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3295          exit $EXIT_FAILURE
3296        fi
3297
3298        # Calculate the version variables.
3299        major=
3300        versuffix=
3301        verstring=
3302        case $version_type in
3303        none) ;;
3304
3305        darwin)
3306          # Like Linux, but with the current version available in
3307          # verstring for coding it into the library header
3308          major=.`expr $current - $age`
3309          versuffix="$major.$age.$revision"
3310          # Darwin ld doesn't like 0 for these options...
3311          minor_current=`expr $current + 1`
3312          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3313          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
3314          ;;
3315
3316        freebsd-aout)
3317          major=".$current"
3318          versuffix=".$current.$revision";
3319          ;;
3320
3321        freebsd-elf)
3322          major=".$current"
3323          versuffix=".$current";
3324          ;;
3325
3326        irix | nonstopux)
3327          if test "X$lt_irix_increment" = "Xno"; then
3328            major=`expr $current - $age`
3329          else
3330            major=`expr $current - $age + 1`
3331          fi
3332          case $version_type in
3333            nonstopux) verstring_prefix=nonstopux ;;
3334            *)         verstring_prefix=sgi ;;
3335          esac
3336          verstring="$verstring_prefix$major.$revision"
3337
3338          # Add in all the interfaces that we are compatible with.
3339          loop=$revision
3340          while test "$loop" -ne 0; do
3341            iface=`expr $revision - $loop`
3342            loop=`expr $loop - 1`
3343            verstring="$verstring_prefix$major.$iface:$verstring"
3344          done
3345
3346          # Before this point, $major must not contain `.'.
3347          major=.$major
3348          versuffix="$major.$revision"
3349          ;;
3350
3351        linux)
3352          major=.`expr $current - $age`
3353          versuffix="$major.$age.$revision"
3354          ;;
3355
3356        osf)
3357          major=.`expr $current - $age`
3358          versuffix=".$current.$age.$revision"
3359          verstring="$current.$age.$revision"
3360
3361          # Add in all the interfaces that we are compatible with.
3362          loop=$age
3363          while test "$loop" -ne 0; do
3364            iface=`expr $current - $loop`
3365            loop=`expr $loop - 1`
3366            verstring="$verstring:${iface}.0"
3367          done
3368
3369          # Make executables depend on our current version.
3370          verstring="$verstring:${current}.0"
3371          ;;
3372
3373        sunos)
3374          major=".$current"
3375          versuffix=".$current.$revision"
3376          ;;
3377
3378        windows)
3379          # Use '-' rather than '.', since we only want one
3380          # extension on DOS 8.3 filesystems.
3381          major=`expr $current - $age`
3382          versuffix="-$major"
3383          ;;
3384
3385        *)
3386          $echo "$modename: unknown library version type \`$version_type'" 1>&2
3387          $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3388          exit $EXIT_FAILURE
3389          ;;
3390        esac
3391
3392        # Clear the version info if we defaulted, and they specified a release.
3393        if test -z "$vinfo" && test -n "$release"; then
3394          major=
3395          case $version_type in
3396          darwin)
3397            # we can't check for "0.0" in archive_cmds due to quoting
3398            # problems, so we reset it completely
3399            verstring=
3400            ;;
3401          *)
3402            verstring="0.0"
3403            ;;
3404          esac
3405          if test "$need_version" = no; then
3406            versuffix=
3407          else
3408            versuffix=".0.0"
3409          fi
3410        fi
3411
3412        # Remove version info from name if versioning should be avoided
3413        if test "$avoid_version" = yes && test "$need_version" = no; then
3414          major=
3415          versuffix=
3416          verstring=""
3417        fi
3418
3419        # Check to see if the archive will have undefined symbols.
3420        if test "$allow_undefined" = yes; then
3421          if test "$allow_undefined_flag" = unsupported; then
3422            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3423            build_libtool_libs=no
3424            build_old_libs=yes
3425          fi
3426        else
3427          # Don't allow undefined symbols.
3428          allow_undefined_flag="$no_undefined_flag"
3429        fi
3430      fi
3431
3432      if test "$mode" != relink; then
3433        # Remove our outputs, but don't remove object files since they
3434        # may have been created when compiling PIC objects.
3435        removelist=
3436        tempremovelist=`$echo "$output_objdir/*"`
3437        for p in $tempremovelist; do
3438          case $p in
3439            *.$objext)
3440               ;;
3441            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3442               if test "X$precious_files_regex" != "X"; then
3443                 if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3444                 then
3445                   continue
3446                 fi
3447               fi
3448               removelist="$removelist $p"
3449               ;;
3450            *) ;;
3451          esac
3452        done
3453        if test -n "$removelist"; then
3454          $show "${rm}r $removelist"
3455          $run ${rm}r $removelist
3456        fi
3457      fi
3458
3459      # Now set the variables for building old libraries.
3460      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3461        oldlibs="$oldlibs $output_objdir/$libname.$libext"
3462
3463        # Transform .lo files to .o files.
3464        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3465      fi
3466
3467      # Eliminate all temporary directories.
3468      #for path in $notinst_path; do
3469      # lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3470      # deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3471      # dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
3472      #done
3473
3474      if test -n "$xrpath"; then
3475        # If the user specified any rpath flags, then add them.
3476        temp_xrpath=
3477        for libdir in $xrpath; do
3478          temp_xrpath="$temp_xrpath -R$libdir"
3479          case "$finalize_rpath " in
3480          *" $libdir "*) ;;
3481          *) finalize_rpath="$finalize_rpath $libdir" ;;
3482          esac
3483        done
3484        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3485          dependency_libs="$temp_xrpath $dependency_libs"
3486        fi
3487      fi
3488
3489      # Make sure dlfiles contains only unique files that won't be dlpreopened
3490      old_dlfiles="$dlfiles"
3491      dlfiles=
3492      for lib in $old_dlfiles; do
3493        case " $dlprefiles $dlfiles " in
3494        *" $lib "*) ;;
3495        *) dlfiles="$dlfiles $lib" ;;
3496        esac
3497      done
3498
3499      # Make sure dlprefiles contains only unique files
3500      old_dlprefiles="$dlprefiles"
3501      dlprefiles=
3502      for lib in $old_dlprefiles; do
3503        case "$dlprefiles " in
3504        *" $lib "*) ;;
3505        *) dlprefiles="$dlprefiles $lib" ;;
3506        esac
3507      done
3508
3509      if test "$build_libtool_libs" = yes; then
3510        if test -n "$rpath"; then
3511          case $host in
3512          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3513            # these systems don't actually have a c library (as such)!
3514            ;;
3515          *-*-rhapsody* | *-*-darwin1.[012])
3516            # Rhapsody C library is in the System framework
3517            deplibs="$deplibs -framework System"
3518            ;;
3519          *-*-netbsd*)
3520            # Don't link with libc until the a.out ld.so is fixed.
3521            ;;
3522          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3523            # Do not include libc due to us having libc/libc_r.
3524            ;;
3525          *-*-sco3.2v5* | *-*-sco5v6*)
3526            # Causes problems with __ctype
3527            ;;
3528          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3529            # Compiler inserts libc in the correct place for threads to work
3530            ;;
3531          *)
3532            # Add libc to deplibs on all other systems if necessary.
3533            if test "$build_libtool_need_lc" = "yes"; then
3534              deplibs="$deplibs -lc"
3535            fi
3536            ;;
3537          esac
3538        fi
3539
3540        # Transform deplibs into only deplibs that can be linked in shared.
3541        name_save=$name
3542        libname_save=$libname
3543        release_save=$release
3544        versuffix_save=$versuffix
3545        major_save=$major
3546        # I'm not sure if I'm treating the release correctly.  I think
3547        # release should show up in the -l (ie -lgmp5) so we don't want to
3548        # add it in twice.  Is that correct?
3549        release=""
3550        versuffix=""
3551        major=""
3552        newdeplibs=
3553        droppeddeps=no
3554        case $deplibs_check_method in
3555        pass_all)
3556          # Don't check for shared/static.  Everything works.
3557          # This might be a little naive.  We might want to check
3558          # whether the library exists or not.  But this is on
3559          # osf3 & osf4 and I'm not really sure... Just
3560          # implementing what was already the behavior.
3561          newdeplibs=$deplibs
3562          ;;
3563        test_compile)
3564          # This code stresses the "libraries are programs" paradigm to its
3565          # limits. Maybe even breaks it.  We compile a program, linking it
3566          # against the deplibs as a proxy for the library.  Then we can check
3567          # whether they linked in statically or dynamically with ldd.
3568          $rm conftest.c
3569          cat > conftest.c <<EOF
3570          int main() { return 0; }
3571EOF
3572          $rm conftest
3573          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
3574            ldd_output=`ldd conftest`
3575            for i in $deplibs; do
3576              name=`expr $i : '-l\(.*\)'`
3577              # If $name is empty we are operating on a -L argument.
3578              if test "$name" != "" && test "$name" != "0"; then
3579                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3580                  case " $predeps $postdeps " in
3581                  *" $i "*)
3582                    newdeplibs="$newdeplibs $i"
3583                    i=""
3584                    ;;
3585                  esac
3586                fi
3587                if test -n "$i" ; then
3588                  libname=`eval \\$echo \"$libname_spec\"`
3589                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
3590                  set dummy $deplib_matches
3591                  deplib_match=$2
3592                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3593                    newdeplibs="$newdeplibs $i"
3594                  else
3595                    droppeddeps=yes
3596                    $echo
3597                    $echo "*** Warning: dynamic linker does not accept needed library $i."
3598                    $echo "*** I have the capability to make that library automatically link in when"
3599                    $echo "*** you link to this library.  But I can only do this if you have a"
3600                    $echo "*** shared version of the library, which I believe you do not have"
3601                    $echo "*** because a test_compile did reveal that the linker did not use it for"
3602                    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3603                  fi
3604                fi
3605              else
3606                newdeplibs="$newdeplibs $i"
3607              fi
3608            done
3609          else
3610            # Error occurred in the first compile.  Let's try to salvage
3611            # the situation: Compile a separate program for each library.
3612            for i in $deplibs; do
3613              name=`expr $i : '-l\(.*\)'`
3614              # If $name is empty we are operating on a -L argument.
3615              if test "$name" != "" && test "$name" != "0"; then
3616                $rm conftest
3617                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
3618                  ldd_output=`ldd conftest`
3619                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3620                    case " $predeps $postdeps " in
3621                    *" $i "*)
3622                      newdeplibs="$newdeplibs $i"
3623                      i=""
3624                      ;;
3625                    esac
3626                  fi
3627                  if test -n "$i" ; then
3628                    libname=`eval \\$echo \"$libname_spec\"`
3629                    deplib_matches=`eval \\$echo \"$library_names_spec\"`
3630                    set dummy $deplib_matches
3631                    deplib_match=$2
3632                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3633                      newdeplibs="$newdeplibs $i"
3634                    else
3635                      droppeddeps=yes
3636                      $echo
3637                      $echo "*** Warning: dynamic linker does not accept needed library $i."
3638                      $echo "*** I have the capability to make that library automatically link in when"
3639                      $echo "*** you link to this library.  But I can only do this if you have a"
3640                      $echo "*** shared version of the library, which you do not appear to have"
3641                      $echo "*** because a test_compile did reveal that the linker did not use this one"
3642                      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3643                    fi
3644                  fi
3645                else
3646                  droppeddeps=yes
3647                  $echo
3648                  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3649                  $echo "*** make it link in!  You will probably need to install it or some"
3650                  $echo "*** library that it depends on before this library will be fully"
3651                  $echo "*** functional.  Installing it before continuing would be even better."
3652                fi
3653              else
3654                newdeplibs="$newdeplibs $i"
3655              fi
3656            done
3657          fi
3658          ;;
3659        file_magic*)
3660          set dummy $deplibs_check_method
3661          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3662          for a_deplib in $deplibs; do
3663            name=`expr $a_deplib : '-l\(.*\)'`
3664            # If $name is empty we are operating on a -L argument.
3665            if test "$name" != "" && test  "$name" != "0"; then
3666              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3667                case " $predeps $postdeps " in
3668                *" $a_deplib "*)
3669                  newdeplibs="$newdeplibs $a_deplib"
3670                  a_deplib=""
3671                  ;;
3672                esac
3673              fi
3674              if test -n "$a_deplib" ; then
3675                libname=`eval \\$echo \"$libname_spec\"`
3676                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3677                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3678                  for potent_lib in $potential_libs; do
3679                      # Follow soft links.
3680                      if ls -lLd "$potent_lib" 2>/dev/null \
3681                         | grep " -> " >/dev/null; then
3682                        continue
3683                      fi
3684                      # The statement above tries to avoid entering an
3685                      # endless loop below, in case of cyclic links.
3686                      # We might still enter an endless loop, since a link
3687                      # loop can be closed while we follow links,
3688                      # but so what?
3689                      potlib="$potent_lib"
3690                      while test -h "$potlib" 2>/dev/null; do
3691                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3692                        case $potliblink in
3693                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3694                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3695                        esac
3696                      done
3697                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3698                         | ${SED} 10q \
3699                         | $EGREP "$file_magic_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 file magic test)"
3717                else
3718                  $echo "*** with $libname and none of the candidates passed a file format test"
3719                  $echo "*** using a file magic. 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        match_pattern*)
3729          set dummy $deplibs_check_method
3730          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3731          for a_deplib in $deplibs; do
3732            name=`expr $a_deplib : '-l\(.*\)'`
3733            # If $name is empty we are operating on a -L argument.
3734            if test -n "$name" && test "$name" != "0"; then
3735              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3736                case " $predeps $postdeps " in
3737                *" $a_deplib "*)
3738                  newdeplibs="$newdeplibs $a_deplib"
3739                  a_deplib=""
3740                  ;;
3741                esac
3742              fi
3743              if test -n "$a_deplib" ; then
3744                libname=`eval \\$echo \"$libname_spec\"`
3745                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3746                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3747                  for potent_lib in $potential_libs; do
3748                    potlib="$potent_lib" # see symlink-check above in file_magic test
3749                    if eval $echo \"$potent_lib\" 2>/dev/null \
3750                        | ${SED} 10q \
3751                        | $EGREP "$match_pattern_regex" > /dev/null; then
3752                      newdeplibs="$newdeplibs $a_deplib"
3753                      a_deplib=""
3754                      break 2
3755                    fi
3756                  done
3757                done
3758              fi
3759              if test -n "$a_deplib" ; then
3760                droppeddeps=yes
3761                $echo
3762                $echo "*** Warning: linker path does not have real file for library $a_deplib."
3763                $echo "*** I have the capability to make that library automatically link in when"
3764                $echo "*** you link to this library.  But I can only do this if you have a"
3765                $echo "*** shared version of the library, which you do not appear to have"
3766                $echo "*** because I did check the linker path looking for a file starting"
3767                if test -z "$potlib" ; then
3768                  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3769                else
3770                  $echo "*** with $libname and none of the candidates passed a file format test"
3771                  $echo "*** using a regex pattern. Last file checked: $potlib"
3772                fi
3773              fi
3774            else
3775              # Add a -L argument.
3776              newdeplibs="$newdeplibs $a_deplib"
3777            fi
3778          done # Gone through all deplibs.
3779          ;;
3780        none | unknown | *)
3781          newdeplibs=""
3782          tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3783            -e 's/ -[LR][^ ]*//g'`
3784          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3785            for i in $predeps $postdeps ; do
3786              # can't use Xsed below, because $i might contain '/'
3787              tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3788            done
3789          fi
3790          if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3791            | grep . >/dev/null; then
3792            $echo
3793            if test "X$deplibs_check_method" = "Xnone"; then
3794              $echo "*** Warning: inter-library dependencies are not supported in this platform."
3795            else
3796              $echo "*** Warning: inter-library dependencies are not known to be supported."
3797            fi
3798            $echo "*** All declared inter-library dependencies are being dropped."
3799            droppeddeps=yes
3800          fi
3801          ;;
3802        esac
3803        versuffix=$versuffix_save
3804        major=$major_save
3805        release=$release_save
3806        libname=$libname_save
3807        name=$name_save
3808
3809        case $host in
3810        *-*-rhapsody* | *-*-darwin1.[012])
3811          # On Rhapsody replace the C library is the System framework
3812          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3813          ;;
3814        esac
3815
3816        if test "$droppeddeps" = yes; then
3817          if test "$module" = yes; then
3818            $echo
3819            $echo "*** Warning: libtool could not satisfy all declared inter-library"
3820            $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3821            $echo "*** a static module, that should work as long as the dlopening"
3822            $echo "*** application is linked with the -dlopen flag."
3823            if test -z "$global_symbol_pipe"; then
3824              $echo
3825              $echo "*** However, this would only work if libtool was able to extract symbol"
3826              $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3827              $echo "*** not find such a program.  So, this module is probably useless."
3828              $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3829            fi
3830            if test "$build_old_libs" = no; then
3831              oldlibs="$output_objdir/$libname.$libext"
3832              build_libtool_libs=module
3833              build_old_libs=yes
3834            else
3835              build_libtool_libs=no
3836            fi
3837          else
3838            $echo "*** The inter-library dependencies that have been dropped here will be"
3839            $echo "*** automatically added whenever a program is linked with this library"
3840            $echo "*** or is declared to -dlopen it."
3841
3842            if test "$allow_undefined" = no; then
3843              $echo
3844              $echo "*** Since this library must not contain undefined symbols,"
3845              $echo "*** because either the platform does not support them or"
3846              $echo "*** it was explicitly requested with -no-undefined,"
3847              $echo "*** libtool will only create a static version of it."
3848              if test "$build_old_libs" = no; then
3849                oldlibs="$output_objdir/$libname.$libext"
3850                build_libtool_libs=module
3851                build_old_libs=yes
3852              else
3853                build_libtool_libs=no
3854              fi
3855            fi
3856          fi
3857        fi
3858        # Done checking deplibs!
3859        deplibs=$newdeplibs
3860      fi
3861
3862
3863      # move library search paths that coincide with paths to not yet
3864      # installed libraries to the beginning of the library search list
3865      new_libs=
3866      for path in $notinst_path; do
3867        case " $new_libs " in
3868        *" -L$path/$objdir "*) ;;
3869        *)
3870          case " $deplibs " in
3871          *" -L$path/$objdir "*)
3872            new_libs="$new_libs -L$path/$objdir" ;;
3873          esac
3874          ;;
3875        esac
3876      done
3877      for deplib in $deplibs; do
3878        case $deplib in
3879        -L*)
3880          case " $new_libs " in
3881          *" $deplib "*) ;;
3882          *) new_libs="$new_libs $deplib" ;;
3883          esac
3884          ;;
3885        *) new_libs="$new_libs $deplib" ;;
3886        esac
3887      done
3888      deplibs="$new_libs"
3889
3890
3891      # All the library-specific variables (install_libdir is set above).
3892      library_names=
3893      old_library=
3894      dlname=
3895
3896      # Test again, we may have decided not to build it any more
3897      if test "$build_libtool_libs" = yes; then
3898        if test "$hardcode_into_libs" = yes; then
3899          # Hardcode the library paths
3900          hardcode_libdirs=
3901          dep_rpath=
3902          rpath="$finalize_rpath"
3903          test "$mode" != relink && rpath="$compile_rpath$rpath"
3904          for libdir in $rpath; do
3905            if test -n "$hardcode_libdir_flag_spec"; then
3906              if test -n "$hardcode_libdir_separator"; then
3907                if test -z "$hardcode_libdirs"; then
3908                  hardcode_libdirs="$libdir"
3909                else
3910                  # Just accumulate the unique libdirs.
3911                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3912                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3913                    ;;
3914                  *)
3915                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3916                    ;;
3917                  esac
3918                fi
3919              else
3920                eval flag=\"$hardcode_libdir_flag_spec\"
3921                dep_rpath="$dep_rpath $flag"
3922              fi
3923            elif test -n "$runpath_var"; then
3924              case "$perm_rpath " in
3925              *" $libdir "*) ;;
3926              *) perm_rpath="$perm_rpath $libdir" ;;
3927              esac
3928            fi
3929          done
3930          # Substitute the hardcoded libdirs into the rpath.
3931          if test -n "$hardcode_libdir_separator" &&
3932             test -n "$hardcode_libdirs"; then
3933            libdir="$hardcode_libdirs"
3934            if test -n "$hardcode_libdir_flag_spec_ld"; then
3935              case $archive_cmds in
3936              *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
3937              *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
3938              esac
3939            else
3940              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3941            fi
3942          fi
3943          if test -n "$runpath_var" && test -n "$perm_rpath"; then
3944            # We should set the runpath_var.
3945            rpath=
3946            for dir in $perm_rpath; do
3947              rpath="$rpath$dir:"
3948            done
3949            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3950          fi
3951          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3952        fi
3953
3954        shlibpath="$finalize_shlibpath"
3955        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3956        if test -n "$shlibpath"; then
3957          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3958        fi
3959
3960        # Get the real and link names of the library.
3961        eval shared_ext=\"$shrext_cmds\"
3962        eval library_names=\"$library_names_spec\"
3963        set dummy $library_names
3964        realname="$2"
3965        shift; shift
3966
3967        if test -n "$soname_spec"; then
3968          eval soname=\"$soname_spec\"
3969        else
3970          soname="$realname"
3971        fi
3972        if test -z "$dlname"; then
3973          dlname=$soname
3974        fi
3975
3976        lib="$output_objdir/$realname"
3977        linknames=
3978        for link
3979        do
3980          linknames="$linknames $link"
3981        done
3982
3983        # Use standard objects if they are pic
3984        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3985
3986        # Prepare the list of exported symbols
3987        if test -z "$export_symbols"; then
3988          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3989            $show "generating symbol list for \`$libname.la'"
3990            export_symbols="$output_objdir/$libname.exp"
3991            $run $rm $export_symbols
3992            cmds=$export_symbols_cmds
3993            save_ifs="$IFS"; IFS='~'
3994            for cmd in $cmds; do
3995              IFS="$save_ifs"
3996              eval cmd=\"$cmd\"
3997              if len=`expr "X$cmd" : ".*"` &&
3998               test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3999                $show "$cmd"
4000                $run eval "$cmd" || exit $?
4001                skipped_export=false
4002              else
4003                # The command line is too long to execute in one step.
4004                $show "using reloadable object file for export list..."
4005                skipped_export=:
4006                # Break out early, otherwise skipped_export may be
4007                # set to false by a later but shorter cmd.
4008                break
4009              fi
4010            done
4011            IFS="$save_ifs"
4012            if test -n "$export_symbols_regex"; then
4013              $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
4014              $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
4015              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
4016              $run eval '$mv "${export_symbols}T" "$export_symbols"'
4017            fi
4018          fi
4019        fi
4020
4021        if test -n "$export_symbols" && test -n "$include_expsyms"; then
4022          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
4023        fi
4024
4025        tmp_deplibs=
4026        for test_deplib in $deplibs; do
4027                case " $convenience " in
4028                *" $test_deplib "*) ;;
4029                *)
4030                        tmp_deplibs="$tmp_deplibs $test_deplib"
4031                        ;;
4032                esac
4033        done
4034        deplibs="$tmp_deplibs"
4035
4036        if test -n "$convenience"; then
4037          if test -n "$whole_archive_flag_spec"; then
4038            save_libobjs=$libobjs
4039            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4040          else
4041            gentop="$output_objdir/${outputname}x"
4042            generated="$generated $gentop"
4043
4044            func_extract_archives $gentop $convenience
4045            libobjs="$libobjs $func_extract_archives_result"
4046          fi
4047        fi
4048       
4049        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
4050          eval flag=\"$thread_safe_flag_spec\"
4051          linker_flags="$linker_flags $flag"
4052        fi
4053
4054        # Make a backup of the uninstalled library when relinking
4055        if test "$mode" = relink; then
4056          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
4057        fi
4058
4059        # Do each of the archive commands.
4060        if test "$module" = yes && test -n "$module_cmds" ; then
4061          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4062            eval test_cmds=\"$module_expsym_cmds\"
4063            cmds=$module_expsym_cmds
4064          else
4065            eval test_cmds=\"$module_cmds\"
4066            cmds=$module_cmds
4067          fi
4068        else
4069        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4070          eval test_cmds=\"$archive_expsym_cmds\"
4071          cmds=$archive_expsym_cmds
4072        else
4073          eval test_cmds=\"$archive_cmds\"
4074          cmds=$archive_cmds
4075          fi
4076        fi
4077
4078        if test "X$skipped_export" != "X:" &&
4079           len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4080           test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4081          :
4082        else
4083          # The command line is too long to link in one step, link piecewise.
4084          $echo "creating reloadable object files..."
4085
4086          # Save the value of $output and $libobjs because we want to
4087          # use them later.  If we have whole_archive_flag_spec, we
4088          # want to use save_libobjs as it was before
4089          # whole_archive_flag_spec was expanded, because we can't
4090          # assume the linker understands whole_archive_flag_spec.
4091          # This may have to be revisited, in case too many
4092          # convenience libraries get linked in and end up exceeding
4093          # the spec.
4094          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
4095            save_libobjs=$libobjs
4096          fi
4097          save_output=$output
4098          output_la=`$echo "X$output" | $Xsed -e "$basename"`
4099
4100          # Clear the reloadable object creation command queue and
4101          # initialize k to one.
4102          test_cmds=
4103          concat_cmds=
4104          objlist=
4105          delfiles=
4106          last_robj=
4107          k=1
4108          output=$output_objdir/$output_la-${k}.$objext
4109          # Loop over the list of objects to be linked.
4110          for obj in $save_libobjs
4111          do
4112            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4113            if test "X$objlist" = X ||
4114               { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4115                 test "$len" -le "$max_cmd_len"; }; then
4116              objlist="$objlist $obj"
4117            else
4118              # The command $test_cmds is almost too long, add a
4119              # command to the queue.
4120              if test "$k" -eq 1 ; then
4121                # The first file doesn't have a previous command to add.
4122                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4123              else
4124                # All subsequent reloadable object files will link in
4125                # the last one created.
4126                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4127              fi
4128              last_robj=$output_objdir/$output_la-${k}.$objext
4129              k=`expr $k + 1`
4130              output=$output_objdir/$output_la-${k}.$objext
4131              objlist=$obj
4132              len=1
4133            fi
4134          done
4135          # Handle the remaining objects by creating one last
4136          # reloadable object file.  All subsequent reloadable object
4137          # files will link in the last one created.
4138          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4139          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4140
4141          if ${skipped_export-false}; then
4142            $show "generating symbol list for \`$libname.la'"
4143            export_symbols="$output_objdir/$libname.exp"
4144            $run $rm $export_symbols
4145            libobjs=$output
4146            # Append the command to create the export file.
4147            eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4148          fi
4149
4150          # Set up a command to remove the reloadable object files
4151          # after they are used.
4152          i=0
4153          while test "$i" -lt "$k"
4154          do
4155            i=`expr $i + 1`
4156            delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4157          done
4158
4159          $echo "creating a temporary reloadable object file: $output"
4160
4161          # Loop through the commands generated above and execute them.
4162          save_ifs="$IFS"; IFS='~'
4163          for cmd in $concat_cmds; do
4164            IFS="$save_ifs"
4165            $show "$cmd"
4166            $run eval "$cmd" || exit $?
4167          done
4168          IFS="$save_ifs"
4169
4170          libobjs=$output
4171          # Restore the value of output.
4172          output=$save_output
4173
4174          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4175            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4176          fi
4177          # Expand the library linking commands again to reset the
4178          # value of $libobjs for piecewise linking.
4179
4180          # Do each of the archive commands.
4181          if test "$module" = yes && test -n "$module_cmds" ; then
4182            if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4183              cmds=$module_expsym_cmds
4184            else
4185              cmds=$module_cmds
4186            fi
4187          else
4188          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4189            cmds=$archive_expsym_cmds
4190          else
4191            cmds=$archive_cmds
4192            fi
4193          fi
4194
4195          # Append the command to remove the reloadable object files
4196          # to the just-reset $cmds.
4197          eval cmds=\"\$cmds~\$rm $delfiles\"
4198        fi
4199        save_ifs="$IFS"; IFS='~'
4200        for cmd in $cmds; do
4201          IFS="$save_ifs"
4202          eval cmd=\"$cmd\"
4203          $show "$cmd"
4204          $run eval "$cmd" || {
4205            lt_exit=$?
4206
4207            # Restore the uninstalled library and exit
4208            if test "$mode" = relink; then
4209              $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
4210            fi
4211
4212            exit $lt_exit
4213          }
4214        done
4215        IFS="$save_ifs"
4216
4217        # Restore the uninstalled library and exit
4218        if test "$mode" = relink; then
4219          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
4220
4221          if test -n "$convenience"; then
4222            if test -z "$whole_archive_flag_spec"; then
4223              $show "${rm}r $gentop"
4224              $run ${rm}r "$gentop"
4225            fi
4226          fi
4227
4228          exit $EXIT_SUCCESS
4229        fi
4230
4231        # Create links to the real library.
4232        for linkname in $linknames; do
4233          if test "$realname" != "$linkname"; then
4234            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4235            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
4236          fi
4237        done
4238
4239        # If -module or -export-dynamic was specified, set the dlname.
4240        if test "$module" = yes || test "$export_dynamic" = yes; then
4241          # On all known operating systems, these are identical.
4242          dlname="$soname"
4243        fi
4244      fi
4245      ;;
4246
4247    obj)
4248      if test -n "$deplibs"; then
4249        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4250      fi
4251
4252      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4253        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4254      fi
4255
4256      if test -n "$rpath"; then
4257        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4258      fi
4259
4260      if test -n "$xrpath"; then
4261        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4262      fi
4263
4264      if test -n "$vinfo"; then
4265        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4266      fi
4267
4268      if test -n "$release"; then
4269        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4270      fi
4271
4272      case $output in
4273      *.lo)
4274        if test -n "$objs$old_deplibs"; then
4275          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4276          exit $EXIT_FAILURE
4277        fi
4278        libobj="$output"
4279        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4280        ;;
4281      *)
4282        libobj=
4283        obj="$output"
4284        ;;
4285      esac
4286
4287      # Delete the old objects.
4288      $run $rm $obj $libobj
4289
4290      # Objects from convenience libraries.  This assumes
4291      # single-version convenience libraries.  Whenever we create
4292      # different ones for PIC/non-PIC, this we'll have to duplicate
4293      # the extraction.
4294      reload_conv_objs=
4295      gentop=
4296      # reload_cmds runs $LD directly, so let us get rid of
4297      # -Wl from whole_archive_flag_spec and hope we can get by with
4298      # turning comma into space..
4299      wl=
4300
4301      if test -n "$convenience"; then
4302        if test -n "$whole_archive_flag_spec"; then
4303          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
4304          reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
4305        else
4306          gentop="$output_objdir/${obj}x"
4307          generated="$generated $gentop"
4308
4309          func_extract_archives $gentop $convenience
4310          reload_conv_objs="$reload_objs $func_extract_archives_result"
4311        fi
4312      fi
4313
4314      # Create the old-style object.
4315      reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4316
4317      output="$obj"
4318      cmds=$reload_cmds
4319      save_ifs="$IFS"; IFS='~'
4320      for cmd in $cmds; do
4321        IFS="$save_ifs"
4322        eval cmd=\"$cmd\"
4323        $show "$cmd"
4324        $run eval "$cmd" || exit $?
4325      done
4326      IFS="$save_ifs"
4327
4328      # Exit if we aren't doing a library object file.
4329      if test -z "$libobj"; then
4330        if test -n "$gentop"; then
4331          $show "${rm}r $gentop"
4332          $run ${rm}r $gentop
4333        fi
4334
4335        exit $EXIT_SUCCESS
4336      fi
4337
4338      if test "$build_libtool_libs" != yes; then
4339        if test -n "$gentop"; then
4340          $show "${rm}r $gentop"
4341          $run ${rm}r $gentop
4342        fi
4343
4344        # Create an invalid libtool object if no PIC, so that we don't
4345        # accidentally link it into a program.
4346        # $show "echo timestamp > $libobj"
4347        # $run eval "echo timestamp > $libobj" || exit $?
4348        exit $EXIT_SUCCESS
4349      fi
4350
4351      if test -n "$pic_flag" || test "$pic_mode" != default; then
4352        # Only do commands if we really have different PIC objects.
4353        reload_objs="$libobjs $reload_conv_objs"
4354        output="$libobj"
4355        cmds=$reload_cmds
4356        save_ifs="$IFS"; IFS='~'
4357        for cmd in $cmds; do
4358          IFS="$save_ifs"
4359          eval cmd=\"$cmd\"
4360          $show "$cmd"
4361          $run eval "$cmd" || exit $?
4362        done
4363        IFS="$save_ifs"
4364      fi
4365
4366      if test -n "$gentop"; then
4367        $show "${rm}r $gentop"
4368        $run ${rm}r $gentop
4369      fi
4370
4371      exit $EXIT_SUCCESS
4372      ;;
4373
4374    prog)
4375      case $host in
4376        *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4377      esac
4378      if test -n "$vinfo"; then
4379        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4380      fi
4381
4382      if test -n "$release"; then
4383        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4384      fi
4385
4386      if test "$preload" = yes; then
4387        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4388           test "$dlopen_self_static" = unknown; then
4389          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4390        fi
4391      fi
4392
4393      case $host in
4394      *-*-rhapsody* | *-*-darwin1.[012])
4395        # On Rhapsody replace the C library is the System framework
4396        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4397        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4398        ;;
4399      esac
4400
4401      case $host in
4402      *darwin*)
4403        # Don't allow lazy linking, it breaks C++ global constructors
4404        if test "$tagname" = CXX ; then
4405        compile_command="$compile_command ${wl}-bind_at_load"
4406        finalize_command="$finalize_command ${wl}-bind_at_load"
4407        fi
4408        ;;
4409      esac
4410
4411
4412      # move library search paths that coincide with paths to not yet
4413      # installed libraries to the beginning of the library search list
4414      new_libs=
4415      for path in $notinst_path; do
4416        case " $new_libs " in
4417        *" -L$path/$objdir "*) ;;
4418        *)
4419          case " $compile_deplibs " in
4420          *" -L$path/$objdir "*)
4421            new_libs="$new_libs -L$path/$objdir" ;;
4422          esac
4423          ;;
4424        esac
4425      done
4426      for deplib in $compile_deplibs; do
4427        case $deplib in
4428        -L*)
4429          case " $new_libs " in
4430          *" $deplib "*) ;;
4431          *) new_libs="$new_libs $deplib" ;;
4432          esac
4433          ;;
4434        *) new_libs="$new_libs $deplib" ;;
4435        esac
4436      done
4437      compile_deplibs="$new_libs"
4438
4439
4440      compile_command="$compile_command $compile_deplibs"
4441      finalize_command="$finalize_command $finalize_deplibs"
4442
4443      if test -n "$rpath$xrpath"; then
4444        # If the user specified any rpath flags, then add them.
4445        for libdir in $rpath $xrpath; do
4446          # This is the magic to use -rpath.
4447          case "$finalize_rpath " in
4448          *" $libdir "*) ;;
4449          *) finalize_rpath="$finalize_rpath $libdir" ;;
4450          esac
4451        done
4452      fi
4453
4454      # Now hardcode the library paths
4455      rpath=
4456      hardcode_libdirs=
4457      for libdir in $compile_rpath $finalize_rpath; do
4458        if test -n "$hardcode_libdir_flag_spec"; then
4459          if test -n "$hardcode_libdir_separator"; then
4460            if test -z "$hardcode_libdirs"; then
4461              hardcode_libdirs="$libdir"
4462            else
4463              # Just accumulate the unique libdirs.
4464              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4465              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4466                ;;
4467              *)
4468                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4469                ;;
4470              esac
4471            fi
4472          else
4473            eval flag=\"$hardcode_libdir_flag_spec\"
4474            rpath="$rpath $flag"
4475          fi
4476        elif test -n "$runpath_var"; then
4477          case "$perm_rpath " in
4478          *" $libdir "*) ;;
4479          *) perm_rpath="$perm_rpath $libdir" ;;
4480          esac
4481        fi
4482        case $host in
4483        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4484          testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
4485          case :$dllsearchpath: in
4486          *":$libdir:"*) ;;
4487          *) dllsearchpath="$dllsearchpath:$libdir";;
4488          esac
4489          case :$dllsearchpath: in
4490          *":$testbindir:"*) ;;
4491          *) dllsearchpath="$dllsearchpath:$testbindir";;
4492          esac
4493          ;;
4494        esac
4495      done
4496      # Substitute the hardcoded libdirs into the rpath.
4497      if test -n "$hardcode_libdir_separator" &&
4498         test -n "$hardcode_libdirs"; then
4499        libdir="$hardcode_libdirs"
4500        eval rpath=\" $hardcode_libdir_flag_spec\"
4501      fi
4502      compile_rpath="$rpath"
4503
4504      rpath=
4505      hardcode_libdirs=
4506      for libdir in $finalize_rpath; do
4507        if test -n "$hardcode_libdir_flag_spec"; then
4508          if test -n "$hardcode_libdir_separator"; then
4509            if test -z "$hardcode_libdirs"; then
4510              hardcode_libdirs="$libdir"
4511            else
4512              # Just accumulate the unique libdirs.
4513              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4514              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4515                ;;
4516              *)
4517                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4518                ;;
4519              esac
4520            fi
4521          else
4522            eval flag=\"$hardcode_libdir_flag_spec\"
4523            rpath="$rpath $flag"
4524          fi
4525        elif test -n "$runpath_var"; then
4526          case "$finalize_perm_rpath " in
4527          *" $libdir "*) ;;
4528          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4529          esac
4530        fi
4531      done
4532      # Substitute the hardcoded libdirs into the rpath.
4533      if test -n "$hardcode_libdir_separator" &&
4534         test -n "$hardcode_libdirs"; then
4535        libdir="$hardcode_libdirs"
4536        eval rpath=\" $hardcode_libdir_flag_spec\"
4537      fi
4538      finalize_rpath="$rpath"
4539
4540      if test -n "$libobjs" && test "$build_old_libs" = yes; then
4541        # Transform all the library objects into standard objects.
4542        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4543        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4544      fi
4545
4546      dlsyms=
4547      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4548        if test -n "$NM" && test -n "$global_symbol_pipe"; then
4549          dlsyms="${outputname}S.c"
4550        else
4551          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4552        fi
4553      fi
4554
4555      if test -n "$dlsyms"; then
4556        case $dlsyms in
4557        "") ;;
4558        *.c)
4559          # Discover the nlist of each of the dlfiles.
4560          nlist="$output_objdir/${outputname}.nm"
4561
4562          $show "$rm $nlist ${nlist}S ${nlist}T"
4563          $run $rm "$nlist" "${nlist}S" "${nlist}T"
4564
4565          # Parse the name list into a source file.
4566          $show "creating $output_objdir/$dlsyms"
4567
4568          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4569/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4570/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4571
4572#ifdef __cplusplus
4573extern \"C\" {
4574#endif
4575
4576/* Prevent the only kind of declaration conflicts we can make. */
4577#define lt_preloaded_symbols some_other_symbol
4578
4579/* External symbol declarations for the compiler. */\
4580"
4581
4582          if test "$dlself" = yes; then
4583            $show "generating symbol list for \`$output'"
4584
4585            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4586
4587            # Add our own program objects to the symbol list.
4588            progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4589            for arg in $progfiles; do
4590              $show "extracting global C symbols from \`$arg'"
4591              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4592            done
4593
4594            if test -n "$exclude_expsyms"; then
4595              $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4596              $run eval '$mv "$nlist"T "$nlist"'
4597            fi
4598
4599            if test -n "$export_symbols_regex"; then
4600              $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4601              $run eval '$mv "$nlist"T "$nlist"'
4602            fi
4603
4604            # Prepare the list of exported symbols
4605            if test -z "$export_symbols"; then
4606              export_symbols="$output_objdir/$outputname.exp"
4607              $run $rm $export_symbols
4608              $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4609              case $host in
4610              *cygwin* | *mingw* )
4611                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4612                $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4613                ;;
4614              esac
4615            else
4616              $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4617              $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4618              $run eval 'mv "$nlist"T "$nlist"'
4619              case $host in
4620              *cygwin* | *mingw* )
4621                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4622                $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4623                ;;
4624              esac
4625            fi
4626          fi
4627
4628          for arg in $dlprefiles; do
4629            $show "extracting global C symbols from \`$arg'"
4630            name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4631            $run eval '$echo ": $name " >> "$nlist"'
4632            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4633          done
4634
4635          if test -z "$run"; then
4636            # Make sure we have at least an empty file.
4637            test -f "$nlist" || : > "$nlist"
4638
4639            if test -n "$exclude_expsyms"; then
4640              $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4641              $mv "$nlist"T "$nlist"
4642            fi
4643
4644            # Try sorting and uniquifying the output.
4645            if grep -v "^: " < "$nlist" |
4646                if sort -k 3 </dev/null >/dev/null 2>&1; then
4647                  sort -k 3
4648                else
4649                  sort +2
4650                fi |
4651                uniq > "$nlist"S; then
4652              :
4653            else
4654              grep -v "^: " < "$nlist" > "$nlist"S
4655            fi
4656
4657            if test -f "$nlist"S; then
4658              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4659            else
4660              $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4661            fi
4662
4663            $echo >> "$output_objdir/$dlsyms" "\
4664
4665#undef lt_preloaded_symbols
4666
4667#if defined (__STDC__) && __STDC__
4668# define lt_ptr void *
4669#else
4670# define lt_ptr char *
4671# define const
4672#endif
4673
4674/* The mapping between symbol names and symbols. */
4675"
4676
4677            case $host in
4678            *cygwin* | *mingw* )
4679          $echo >> "$output_objdir/$dlsyms" "\
4680/* DATA imports from DLLs on WIN32 can't be const, because
4681   runtime relocations are performed -- see ld's documentation
4682   on pseudo-relocs */
4683struct {
4684"
4685              ;;
4686            * )
4687          $echo >> "$output_objdir/$dlsyms" "\
4688const struct {
4689"
4690              ;;
4691            esac
4692
4693
4694          $echo >> "$output_objdir/$dlsyms" "\
4695  const char *name;
4696  lt_ptr address;
4697}
4698lt_preloaded_symbols[] =
4699{\
4700"
4701
4702            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4703
4704            $echo >> "$output_objdir/$dlsyms" "\
4705  {0, (lt_ptr) 0}
4706};
4707
4708/* This works around a problem in FreeBSD linker */
4709#ifdef FREEBSD_WORKAROUND
4710static const void *lt_preloaded_setup() {
4711  return lt_preloaded_symbols;
4712}
4713#endif
4714
4715#ifdef __cplusplus
4716}
4717#endif\
4718"
4719          fi
4720
4721          pic_flag_for_symtable=
4722          case $host in
4723          # compiling the symbol table file with pic_flag works around
4724          # a FreeBSD bug that causes programs to crash when -lm is
4725          # linked before any other PIC object.  But we must not use
4726          # pic_flag when linking with -static.  The problem exists in
4727          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4728          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4729            case "$compile_command " in
4730            *" -static "*) ;;
4731            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4732            esac;;
4733          *-*-hpux*)
4734            case "$compile_command " in
4735            *" -static "*) ;;
4736            *) pic_flag_for_symtable=" $pic_flag";;
4737            esac
4738          esac
4739
4740          # Now compile the dynamic symbol file.
4741          $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4742          $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4743
4744          # Clean up the generated files.
4745          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4746          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4747
4748          # Transform the symbol file into the correct name.
4749          case $host in
4750          *cygwin* | *mingw* )
4751            if test -f "$output_objdir/${outputname}.def" ; then
4752              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4753              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4754            else
4755              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4756              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4757             fi
4758            ;;
4759          * )
4760            compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4761            finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4762            ;;
4763          esac
4764          ;;
4765        *)
4766          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4767          exit $EXIT_FAILURE
4768          ;;
4769        esac
4770      else
4771        # We keep going just in case the user didn't refer to
4772        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4773        # really was required.
4774
4775        # Nullify the symbol file.
4776        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4777        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4778      fi
4779
4780      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4781        # Replace the output file specification.
4782        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
4783        link_command="$compile_command$compile_rpath"
4784
4785        # We have no uninstalled library dependencies, so finalize right now.
4786        $show "$link_command"
4787        $run eval "$link_command"
4788        exit_status=$?
4789
4790        # Delete the generated files.
4791        if test -n "$dlsyms"; then
4792          $show "$rm $output_objdir/${outputname}S.${objext}"
4793          $run $rm "$output_objdir/${outputname}S.${objext}"
4794        fi
4795
4796        exit $exit_status
4797      fi
4798
4799      if test -n "$shlibpath_var"; then
4800        # We should set the shlibpath_var
4801        rpath=
4802        for dir in $temp_rpath; do
4803          case $dir in
4804          [\\/]* | [A-Za-z]:[\\/]*)
4805            # Absolute path.
4806            rpath="$rpath$dir:"
4807            ;;
4808          *)
4809            # Relative path: add a thisdir entry.
4810            rpath="$rpath\$thisdir/$dir:"
4811            ;;
4812          esac
4813        done
4814        temp_rpath="$rpath"
4815      fi
4816
4817      if test -n "$compile_shlibpath$finalize_shlibpath"; then
4818        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4819      fi
4820      if test -n "$finalize_shlibpath"; then
4821        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4822      fi
4823
4824      compile_var=
4825      finalize_var=
4826      if test -n "$runpath_var"; then
4827        if test -n "$perm_rpath"; then
4828          # We should set the runpath_var.
4829          rpath=
4830          for dir in $perm_rpath; do
4831            rpath="$rpath$dir:"
4832          done
4833          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4834        fi
4835        if test -n "$finalize_perm_rpath"; then
4836          # We should set the runpath_var.
4837          rpath=
4838          for dir in $finalize_perm_rpath; do
4839            rpath="$rpath$dir:"
4840          done
4841          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4842        fi
4843      fi
4844
4845      if test "$no_install" = yes; then
4846        # We don't need to create a wrapper script.
4847        link_command="$compile_var$compile_command$compile_rpath"
4848        # Replace the output file specification.
4849        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4850        # Delete the old output file.
4851        $run $rm $output
4852        # Link the executable and exit
4853        $show "$link_command"
4854        $run eval "$link_command" || exit $?
4855        exit $EXIT_SUCCESS
4856      fi
4857
4858      if test "$hardcode_action" = relink; then
4859        # Fast installation is not supported
4860        link_command="$compile_var$compile_command$compile_rpath"
4861        relink_command="$finalize_var$finalize_command$finalize_rpath"
4862
4863        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4864        $echo "$modename: \`$output' will be relinked during installation" 1>&2
4865      else
4866        if test "$fast_install" != no; then
4867          link_command="$finalize_var$compile_command$finalize_rpath"
4868          if test "$fast_install" = yes; then
4869            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
4870          else
4871            # fast_install is set to needless
4872            relink_command=
4873          fi
4874        else
4875          link_command="$compile_var$compile_command$compile_rpath"
4876          relink_command="$finalize_var$finalize_command$finalize_rpath"
4877        fi
4878      fi
4879
4880      # Replace the output file specification.
4881      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4882
4883      # Delete the old output files.
4884      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4885
4886      $show "$link_command"
4887      $run eval "$link_command" || exit $?
4888
4889      # Now create the wrapper script.
4890      $show "creating $output"
4891
4892      # Quote the relink command for shipping.
4893      if test -n "$relink_command"; then
4894        # Preserve any variables that may affect compiler behavior
4895        for var in $variables_saved_for_relink; do
4896          if eval test -z \"\${$var+set}\"; then
4897            relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4898          elif eval var_value=\$$var; test -z "$var_value"; then
4899            relink_command="$var=; export $var; $relink_command"
4900          else
4901            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4902            relink_command="$var=\"$var_value\"; export $var; $relink_command"
4903          fi
4904        done
4905        relink_command="(cd `pwd`; $relink_command)"
4906        relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
4907      fi
4908
4909      # Quote $echo for shipping.
4910      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4911        case $progpath in
4912        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4913        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4914        esac
4915        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4916      else
4917        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4918      fi
4919
4920      # Only actually do things if our run command is non-null.
4921      if test -z "$run"; then
4922        # win32 will think the script is a binary if it has
4923        # a .exe suffix, so we strip it off here.
4924        case $output in
4925          *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4926        esac
4927        # test for cygwin because mv fails w/o .exe extensions
4928        case $host in
4929          *cygwin*)
4930            exeext=.exe
4931            outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4932          *) exeext= ;;
4933        esac
4934        case $host in
4935          *cygwin* | *mingw* )
4936            output_name=`basename $output`
4937            output_path=`dirname $output`
4938            cwrappersource="$output_path/$objdir/lt-$output_name.c"
4939            cwrapper="$output_path/$output_name.exe"
4940            $rm $cwrappersource $cwrapper
4941            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4942
4943            cat > $cwrappersource <<EOF
4944
4945/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4946   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4947
4948   The $output program cannot be directly executed until all the libtool
4949   libraries that it depends on are installed.
4950
4951   This wrapper executable should never be moved out of the build directory.
4952   If it is, it will not operate correctly.
4953
4954   Currently, it simply execs the wrapper *script* "/bin/sh $output",
4955   but could eventually absorb all of the scripts functionality and
4956   exec $objdir/$outputname directly.
4957*/
4958EOF
4959            cat >> $cwrappersource<<"EOF"
4960#include <stdio.h>
4961#include <stdlib.h>
4962#include <unistd.h>
4963#include <malloc.h>
4964#include <stdarg.h>
4965#include <assert.h>
4966#include <string.h>
4967#include <ctype.h>
4968#include <sys/stat.h>
4969
4970#if defined(PATH_MAX)
4971# define LT_PATHMAX PATH_MAX
4972#elif defined(MAXPATHLEN)
4973# define LT_PATHMAX MAXPATHLEN
4974#else
4975# define LT_PATHMAX 1024
4976#endif
4977
4978#ifndef DIR_SEPARATOR
4979# define DIR_SEPARATOR '/'
4980# define PATH_SEPARATOR ':'
4981#endif
4982
4983#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4984  defined (__OS2__)
4985# define HAVE_DOS_BASED_FILE_SYSTEM
4986# ifndef DIR_SEPARATOR_2
4987#  define DIR_SEPARATOR_2 '\\'
4988# endif
4989# ifndef PATH_SEPARATOR_2
4990#  define PATH_SEPARATOR_2 ';'
4991# endif
4992#endif
4993
4994#ifndef DIR_SEPARATOR_2
4995# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4996#else /* DIR_SEPARATOR_2 */
4997# define IS_DIR_SEPARATOR(ch) \
4998        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4999#endif /* DIR_SEPARATOR_2 */
5000
5001#ifndef PATH_SEPARATOR_2
5002# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5003#else /* PATH_SEPARATOR_2 */
5004# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5005#endif /* PATH_SEPARATOR_2 */
5006
5007#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
5008#define XFREE(stale) do { \
5009  if (stale) { free ((void *) stale); stale = 0; } \
5010} while (0)
5011
5012/* -DDEBUG is fairly common in CFLAGS.  */
5013#undef DEBUG
5014#if defined DEBUGWRAPPER
5015# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5016#else
5017# define DEBUG(format, ...)
5018#endif
5019
5020const char *program_name = NULL;
5021
5022void * xmalloc (size_t num);
5023char * xstrdup (const char *string);
5024const char * base_name (const char *name);
5025char * find_executable(const char *wrapper);
5026int    check_executable(const char *path);
5027char * strendzap(char *str, const char *pat);
5028void lt_fatal (const char *message, ...);
5029
5030int
5031main (int argc, char *argv[])
5032{
5033  char **newargz;
5034  int i;
5035
5036  program_name = (char *) xstrdup (base_name (argv[0]));
5037  DEBUG("(main) argv[0]      : %s\n",argv[0]);
5038  DEBUG("(main) program_name : %s\n",program_name);
5039  newargz = XMALLOC(char *, argc+2);
5040EOF
5041
5042            cat >> $cwrappersource <<EOF
5043  newargz[0] = (char *) xstrdup("$SHELL");
5044EOF
5045
5046            cat >> $cwrappersource <<"EOF"
5047  newargz[1] = find_executable(argv[0]);
5048  if (newargz[1] == NULL)
5049    lt_fatal("Couldn't find %s", argv[0]);
5050  DEBUG("(main) found exe at : %s\n",newargz[1]);
5051  /* we know the script has the same name, without the .exe */
5052  /* so make sure newargz[1] doesn't end in .exe */
5053  strendzap(newargz[1],".exe");
5054  for (i = 1; i < argc; i++)
5055    newargz[i+1] = xstrdup(argv[i]);
5056  newargz[argc+1] = NULL;
5057
5058  for (i=0; i<argc+1; i++)
5059  {
5060    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
5061    ;
5062  }
5063
5064EOF
5065
5066            case $host_os in
5067              mingw*)
5068                cat >> $cwrappersource <<EOF
5069  execv("$SHELL",(char const **)newargz);
5070EOF
5071              ;;
5072              *)
5073                cat >> $cwrappersource <<EOF
5074  execv("$SHELL",newargz);
5075EOF
5076              ;;
5077            esac
5078
5079            cat >> $cwrappersource <<"EOF"
5080  return 127;
5081}
5082
5083void *
5084xmalloc (size_t num)
5085{
5086  void * p = (void *) malloc (num);
5087  if (!p)
5088    lt_fatal ("Memory exhausted");
5089
5090  return p;
5091}
5092
5093char *
5094xstrdup (const char *string)
5095{
5096  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5097;
5098}
5099
5100const char *
5101base_name (const char *name)
5102{
5103  const char *base;
5104
5105#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5106  /* Skip over the disk name in MSDOS pathnames. */
5107  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5108    name += 2;
5109#endif
5110
5111  for (base = name; *name; name++)
5112    if (IS_DIR_SEPARATOR (*name))
5113      base = name + 1;
5114  return base;
5115}
5116
5117int
5118check_executable(const char * path)
5119{
5120  struct stat st;
5121
5122  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5123  if ((!path) || (!*path))
5124    return 0;
5125
5126  if ((stat (path, &st) >= 0) &&
5127      (
5128        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5129#if defined (S_IXOTH)
5130       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5131#endif
5132#if defined (S_IXGRP)
5133       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5134#endif
5135       ((st.st_mode & S_IXUSR) == S_IXUSR))
5136      )
5137    return 1;
5138  else
5139    return 0;
5140}
5141
5142/* Searches for the full path of the wrapper.  Returns
5143   newly allocated full path name if found, NULL otherwise */
5144char *
5145find_executable (const char* wrapper)
5146{
5147  int has_slash = 0;
5148  const char* p;
5149  const char* p_next;
5150  /* static buffer for getcwd */
5151  char tmp[LT_PATHMAX + 1];
5152  int tmp_len;
5153  char* concat_name;
5154
5155  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5156
5157  if ((wrapper == NULL) || (*wrapper == '\0'))
5158    return NULL;
5159
5160  /* Absolute path? */
5161#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5162  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5163  {
5164    concat_name = xstrdup (wrapper);
5165    if (check_executable(concat_name))
5166      return concat_name;
5167    XFREE(concat_name);
5168  }
5169  else
5170  {
5171#endif
5172    if (IS_DIR_SEPARATOR (wrapper[0]))
5173    {
5174      concat_name = xstrdup (wrapper);
5175      if (check_executable(concat_name))
5176        return concat_name;
5177      XFREE(concat_name);
5178    }
5179#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5180  }
5181#endif
5182
5183  for (p = wrapper; *p; p++)
5184    if (*p == '/')
5185    {
5186      has_slash = 1;
5187      break;
5188    }
5189  if (!has_slash)
5190  {
5191    /* no slashes; search PATH */
5192    const char* path = getenv ("PATH");
5193    if (path != NULL)
5194    {
5195      for (p = path; *p; p = p_next)
5196      {
5197        const char* q;
5198        size_t p_len;
5199        for (q = p; *q; q++)
5200          if (IS_PATH_SEPARATOR(*q))
5201            break;
5202        p_len = q - p;
5203        p_next = (*q == '\0' ? q : q + 1);
5204        if (p_len == 0)
5205        {
5206          /* empty path: current directory */
5207          if (getcwd (tmp, LT_PATHMAX) == NULL)
5208            lt_fatal ("getcwd failed");
5209          tmp_len = strlen(tmp);
5210          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5211          memcpy (concat_name, tmp, tmp_len);
5212          concat_name[tmp_len] = '/';
5213          strcpy (concat_name + tmp_len + 1, wrapper);
5214        }
5215        else
5216        {
5217          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5218          memcpy (concat_name, p, p_len);
5219          concat_name[p_len] = '/';
5220          strcpy (concat_name + p_len + 1, wrapper);
5221        }
5222        if (check_executable(concat_name))
5223          return concat_name;
5224        XFREE(concat_name);
5225      }
5226    }
5227    /* not found in PATH; assume curdir */
5228  }
5229  /* Relative path | not found in path: prepend cwd */
5230  if (getcwd (tmp, LT_PATHMAX) == NULL)
5231    lt_fatal ("getcwd failed");
5232  tmp_len = strlen(tmp);
5233  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5234  memcpy (concat_name, tmp, tmp_len);
5235  concat_name[tmp_len] = '/';
5236  strcpy (concat_name + tmp_len + 1, wrapper);
5237
5238  if (check_executable(concat_name))
5239    return concat_name;
5240  XFREE(concat_name);
5241  return NULL;
5242}
5243
5244char *
5245strendzap(char *str, const char *pat)
5246{
5247  size_t len, patlen;
5248
5249  assert(str != NULL);
5250  assert(pat != NULL);
5251
5252  len = strlen(str);
5253  patlen = strlen(pat);
5254
5255  if (patlen <= len)
5256  {
5257    str += len - patlen;
5258    if (strcmp(str, pat) == 0)
5259      *str = '\0';
5260  }
5261  return str;
5262}
5263
5264static void
5265lt_error_core (int exit_status, const char * mode,
5266          const char * message, va_list ap)
5267{
5268  fprintf (stderr, "%s: %s: ", program_name, mode);
5269  vfprintf (stderr, message, ap);
5270  fprintf (stderr, ".\n");
5271
5272  if (exit_status >= 0)
5273    exit (exit_status);
5274}
5275
5276void
5277lt_fatal (const char *message, ...)
5278{
5279  va_list ap;
5280  va_start (ap, message);
5281  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5282  va_end (ap);
5283}
5284EOF
5285          # we should really use a build-platform specific compiler
5286          # here, but OTOH, the wrappers (shell script and this C one)
5287          # are only useful if you want to execute the "real" binary.
5288          # Since the "real" binary is built for $host, then this
5289          # wrapper might as well be built for $host, too.
5290          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5291          ;;
5292        esac
5293        $rm $output
5294        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5295
5296        $echo > $output "\
5297#! $SHELL
5298
5299# $output - temporary wrapper script for $objdir/$outputname
5300# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5301#
5302# The $output program cannot be directly executed until all the libtool
5303# libraries that it depends on are installed.
5304#
5305# This wrapper script should never be moved out of the build directory.
5306# If it is, it will not operate correctly.
5307
5308# Sed substitution that helps us do robust quoting.  It backslashifies
5309# metacharacters that are still active within double-quoted strings.
5310Xsed='${SED} -e 1s/^X//'
5311sed_quote_subst='$sed_quote_subst'
5312
5313# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5314if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5315  emulate sh
5316  NULLCMD=:
5317  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5318  # is contrary to our usage.  Disable this feature.
5319  alias -g '\${1+\"\$@\"}'='\"\$@\"'
5320  setopt NO_GLOB_SUBST
5321else
5322  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5323fi
5324BIN_SH=xpg4; export BIN_SH # for Tru64
5325DUALCASE=1; export DUALCASE # for MKS sh
5326
5327# The HP-UX ksh and POSIX shell print the target directory to stdout
5328# if CDPATH is set.
5329(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5330
5331relink_command=\"$relink_command\"
5332
5333# This environment variable determines our operation mode.
5334if test \"\$libtool_install_magic\" = \"$magic\"; then
5335  # install mode needs the following variable:
5336  notinst_deplibs='$notinst_deplibs'
5337else
5338  # When we are sourced in execute mode, \$file and \$echo are already set.
5339  if test \"\$libtool_execute_magic\" != \"$magic\"; then
5340    echo=\"$qecho\"
5341    file=\"\$0\"
5342    # Make sure echo works.
5343    if test \"X\$1\" = X--no-reexec; then
5344      # Discard the --no-reexec flag, and continue.
5345      shift
5346    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5347      # Yippee, \$echo works!
5348      :
5349    else
5350      # Restart under the correct shell, and then maybe \$echo will work.
5351      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5352    fi
5353  fi\
5354"
5355        $echo >> $output "\
5356
5357  # Find the directory that this script lives in.
5358  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5359  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5360
5361  # Follow symbolic links until we get to the real thisdir.
5362  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5363  while test -n \"\$file\"; do
5364    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5365
5366    # If there was a directory component, then change thisdir.
5367    if test \"x\$destdir\" != \"x\$file\"; then
5368      case \"\$destdir\" in
5369      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5370      *) thisdir=\"\$thisdir/\$destdir\" ;;
5371      esac
5372    fi
5373
5374    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5375    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5376  done
5377
5378  # Try to get the absolute directory name.
5379  absdir=\`cd \"\$thisdir\" && pwd\`
5380  test -n \"\$absdir\" && thisdir=\"\$absdir\"
5381"
5382
5383        if test "$fast_install" = yes; then
5384          $echo >> $output "\
5385  program=lt-'$outputname'$exeext
5386  progdir=\"\$thisdir/$objdir\"
5387
5388  if test ! -f \"\$progdir/\$program\" || \\
5389     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5390       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5391
5392    file=\"\$\$-\$program\"
5393
5394    if test ! -d \"\$progdir\"; then
5395      $mkdir \"\$progdir\"
5396    else
5397      $rm \"\$progdir/\$file\"
5398    fi"
5399
5400          $echo >> $output "\
5401
5402    # relink executable if necessary
5403    if test -n \"\$relink_command\"; then
5404      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5405      else
5406        $echo \"\$relink_command_output\" >&2
5407        $rm \"\$progdir/\$file\"
5408        exit $EXIT_FAILURE
5409      fi
5410    fi
5411
5412    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5413    { $rm \"\$progdir/\$program\";
5414      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5415    $rm \"\$progdir/\$file\"
5416  fi"
5417        else
5418          $echo >> $output "\
5419  program='$outputname'
5420  progdir=\"\$thisdir/$objdir\"
5421"
5422        fi
5423
5424        $echo >> $output "\
5425
5426  if test -f \"\$progdir/\$program\"; then"
5427
5428        # Export our shlibpath_var if we have one.
5429        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5430          $echo >> $output "\
5431    # Add our own library path to $shlibpath_var
5432    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5433
5434    # Some systems cannot cope with colon-terminated $shlibpath_var
5435    # The second colon is a workaround for a bug in BeOS R4 sed
5436    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5437
5438    export $shlibpath_var
5439"
5440        fi
5441
5442        # fixup the dll searchpath if we need to.
5443        if test -n "$dllsearchpath"; then
5444          $echo >> $output "\
5445    # Add the dll search path components to the executable PATH
5446    PATH=$dllsearchpath:\$PATH
5447"
5448        fi
5449
5450        $echo >> $output "\
5451    if test \"\$libtool_execute_magic\" != \"$magic\"; then
5452      # Run the actual program with our arguments.
5453"
5454        case $host in
5455        # Backslashes separate directories on plain windows
5456        *-*-mingw | *-*-os2*)
5457          $echo >> $output "\
5458      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5459"
5460          ;;
5461
5462        *)
5463          $echo >> $output "\
5464      exec \"\$progdir/\$program\" \${1+\"\$@\"}
5465"
5466          ;;
5467        esac
5468        $echo >> $output "\
5469      \$echo \"\$0: cannot exec \$program \$*\"
5470      exit $EXIT_FAILURE
5471    fi
5472  else
5473    # The program doesn't exist.
5474    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5475    \$echo \"This script is just a wrapper for \$program.\" 1>&2
5476    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5477    exit $EXIT_FAILURE
5478  fi
5479fi\
5480"
5481        chmod +x $output
5482      fi
5483      exit $EXIT_SUCCESS
5484      ;;
5485    esac
5486
5487    # See if we need to build an old-fashioned archive.
5488    for oldlib in $oldlibs; do
5489
5490      if test "$build_libtool_libs" = convenience; then
5491        oldobjs="$libobjs_save"
5492        addlibs="$convenience"
5493        build_libtool_libs=no
5494      else
5495        if test "$build_libtool_libs" = module; then
5496          oldobjs="$libobjs_save"
5497          build_libtool_libs=no
5498        else
5499          oldobjs="$old_deplibs $non_pic_objects"
5500        fi
5501        addlibs="$old_convenience"
5502      fi
5503
5504      if test -n "$addlibs"; then
5505        gentop="$output_objdir/${outputname}x"
5506        generated="$generated $gentop"
5507
5508        func_extract_archives $gentop $addlibs
5509        oldobjs="$oldobjs $func_extract_archives_result"
5510      fi
5511
5512      # Do each command in the archive commands.
5513      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5514       cmds=$old_archive_from_new_cmds
5515      else
5516        # POSIX demands no paths to be encoded in archives.  We have
5517        # to avoid creating archives with duplicate basenames if we
5518        # might have to extract them afterwards, e.g., when creating a
5519        # static archive out of a convenience library, or when linking
5520        # the entirety of a libtool archive into another (currently
5521        # not supported by libtool).
5522        if (for obj in $oldobjs
5523            do
5524              $echo "X$obj" | $Xsed -e 's%^.*/%%'
5525            done | sort | sort -uc >/dev/null 2>&1); then
5526          :
5527        else
5528          $echo "copying selected object files to avoid basename conflicts..."
5529
5530          if test -z "$gentop"; then
5531            gentop="$output_objdir/${outputname}x"
5532            generated="$generated $gentop"
5533
5534            $show "${rm}r $gentop"
5535            $run ${rm}r "$gentop"
5536            $show "$mkdir $gentop"
5537            $run $mkdir "$gentop"
5538            exit_status=$?
5539            if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5540              exit $exit_status
5541            fi
5542          fi
5543
5544          save_oldobjs=$oldobjs
5545          oldobjs=
5546          counter=1
5547          for obj in $save_oldobjs
5548          do
5549            objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
5550            case " $oldobjs " in
5551            " ") oldobjs=$obj ;;
5552            *[\ /]"$objbase "*)
5553              while :; do
5554                # Make sure we don't pick an alternate name that also
5555                # overlaps.
5556                newobj=lt$counter-$objbase
5557                counter=`expr $counter + 1`
5558                case " $oldobjs " in
5559                *[\ /]"$newobj "*) ;;
5560                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5561                esac
5562              done
5563              $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5564              $run ln "$obj" "$gentop/$newobj" ||
5565              $run cp "$obj" "$gentop/$newobj"
5566              oldobjs="$oldobjs $gentop/$newobj"
5567              ;;
5568            *) oldobjs="$oldobjs $obj" ;;
5569            esac
5570          done
5571        fi
5572
5573        eval cmds=\"$old_archive_cmds\"
5574
5575        if len=`expr "X$cmds" : ".*"` &&
5576             test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5577          cmds=$old_archive_cmds
5578        else
5579          # the command line is too long to link in one step, link in parts
5580          $echo "using piecewise archive linking..."
5581          save_RANLIB=$RANLIB
5582          RANLIB=:
5583          objlist=
5584          concat_cmds=
5585          save_oldobjs=$oldobjs
5586
5587          # Is there a better way of finding the last object in the list?
5588          for obj in $save_oldobjs
5589          do
5590            last_oldobj=$obj
5591          done
5592          for obj in $save_oldobjs
5593          do
5594            oldobjs="$objlist $obj"
5595            objlist="$objlist $obj"
5596            eval test_cmds=\"$old_archive_cmds\"
5597            if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5598               test "$len" -le "$max_cmd_len"; then
5599              :
5600            else
5601              # the above command should be used before it gets too long
5602              oldobjs=$objlist
5603              if test "$obj" = "$last_oldobj" ; then
5604                RANLIB=$save_RANLIB
5605              fi
5606              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5607              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5608              objlist=
5609            fi
5610          done
5611          RANLIB=$save_RANLIB
5612          oldobjs=$objlist
5613          if test "X$oldobjs" = "X" ; then
5614            eval cmds=\"\$concat_cmds\"
5615          else
5616            eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5617          fi
5618        fi
5619      fi
5620      save_ifs="$IFS"; IFS='~'
5621      for cmd in $cmds; do
5622        eval cmd=\"$cmd\"
5623        IFS="$save_ifs"
5624        $show "$cmd"
5625        $run eval "$cmd" || exit $?
5626      done
5627      IFS="$save_ifs"
5628    done
5629
5630    if test -n "$generated"; then
5631      $show "${rm}r$generated"
5632      $run ${rm}r$generated
5633    fi
5634
5635    # Now create the libtool archive.
5636    case $output in
5637    *.la)
5638      old_library=
5639      test "$build_old_libs" = yes && old_library="$libname.$libext"
5640      $show "creating $output"
5641
5642      # Preserve any variables that may affect compiler behavior
5643      for var in $variables_saved_for_relink; do
5644        if eval test -z \"\${$var+set}\"; then
5645          relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5646        elif eval var_value=\$$var; test -z "$var_value"; then
5647          relink_command="$var=; export $var; $relink_command"
5648        else
5649          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5650          relink_command="$var=\"$var_value\"; export $var; $relink_command"
5651        fi
5652      done
5653      # Quote the link command for shipping.
5654      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5655      relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
5656      if test "$hardcode_automatic" = yes ; then
5657        relink_command=
5658      fi
5659
5660
5661      # Only create the output if not a dry run.
5662      if test -z "$run"; then
5663        for installed in no yes; do
5664          if test "$installed" = yes; then
5665            if test -z "$install_libdir"; then
5666              break
5667            fi
5668            output="$output_objdir/$outputname"i
5669            # Replace all uninstalled libtool libraries with the installed ones
5670            newdependency_libs=
5671            for deplib in $dependency_libs; do
5672              case $deplib in
5673              *.la)
5674                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5675                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5676                if test -z "$libdir"; then
5677                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5678                  exit $EXIT_FAILURE
5679                fi
5680                newdependency_libs="$newdependency_libs $libdir/$name"
5681                ;;
5682              *) newdependency_libs="$newdependency_libs $deplib" ;;
5683              esac
5684            done
5685            dependency_libs="$newdependency_libs"
5686            newdlfiles=
5687            for lib in $dlfiles; do
5688              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5689              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5690              if test -z "$libdir"; then
5691                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5692                exit $EXIT_FAILURE
5693              fi
5694              newdlfiles="$newdlfiles $libdir/$name"
5695            done
5696            dlfiles="$newdlfiles"
5697            newdlprefiles=
5698            for lib in $dlprefiles; do
5699              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5700              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5701              if test -z "$libdir"; then
5702                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5703                exit $EXIT_FAILURE
5704              fi
5705              newdlprefiles="$newdlprefiles $libdir/$name"
5706            done
5707            dlprefiles="$newdlprefiles"
5708          else
5709            newdlfiles=
5710            for lib in $dlfiles; do
5711              case $lib in
5712                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5713                *) abs=`pwd`"/$lib" ;;
5714              esac
5715              newdlfiles="$newdlfiles $abs"
5716            done
5717            dlfiles="$newdlfiles"
5718            newdlprefiles=
5719            for lib in $dlprefiles; do
5720              case $lib in
5721                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5722                *) abs=`pwd`"/$lib" ;;
5723              esac
5724              newdlprefiles="$newdlprefiles $abs"
5725            done
5726            dlprefiles="