source: trunk/packages/libyaml/config/ltmain.sh @ 1275

Last change on this file since 1275 was 898, checked in by hartmans, 16 years ago

Add pyyaml and libyaml packages
backported from lenny.
There is discussion about how these should go in the repository; these are added in this form
in order to make forward progress.

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