sjero.net Git - wget/blob - ltmain.sh

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