source: mod_gnutls/config/ltmain.sh @ 8ce897a

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

Imported Upstream version 0.5.2

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