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