source: mod_gnutls/config/ltmain.sh @ de80d66

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

Imported Upstream version 0.1.0

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