autoconf/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
  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) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
2086         esac
2087       fi
2088       if test "$pass" = dlopen; then
2089         # Collect dlpreopened libraries
2090         save_deplibs="$deplibs"
2091         deplibs=
2092       fi
2093       for deplib in $libs; do
2094         lib=
2095         found=no
2096         case $deplib in
2097         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
2098           if test "$linkmode,$pass" = "prog,link"; then
2099             compile_deplibs="$deplib $compile_deplibs"
2100             finalize_deplibs="$deplib $finalize_deplibs"
2101           else
2102             compiler_flags="$compiler_flags $deplib"
2103           fi
2104           continue
2105           ;;
2106         -l*)
2107           if test "$linkmode" != lib && test "$linkmode" != prog; then
2108             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2109             continue
2110           fi
2111           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2112           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
2113             for search_ext in .la $std_shrext .so .a; do
2114               # Search the libtool library
2115               lib="$searchdir/lib${name}${search_ext}"
2116               if test -f "$lib"; then
2117                 if test "$search_ext" = ".la"; then
2118                   found=yes
2119                 else
2120                   found=no
2121                 fi
2122                 break 2
2123               fi
2124             done
2125           done
2126           if test "$found" != yes; then
2127             # deplib doesn't seem to be a libtool library
2128             if test "$linkmode,$pass" = "prog,link"; then
2129               compile_deplibs="$deplib $compile_deplibs"
2130               finalize_deplibs="$deplib $finalize_deplibs"
2131             else
2132               deplibs="$deplib $deplibs"
2133               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2134             fi
2135             continue
2136           else # deplib is a libtool library
2137             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2138             # We need to do some special things here, and not later.
2139             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2140               case " $predeps $postdeps " in
2141               *" $deplib "*)
2142                 if (${SED} -e '2q' $lib |
2143                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2144                   library_names=
2145                   old_library=
2146                   case $lib in
2147                   */* | *\\*) . $lib ;;
2148                   *) . ./$lib ;;
2149                   esac
2150                   for l in $old_library $library_names; do
2151                     ll="$l"
2152                   done
2153                   if test "X$ll" = "X$old_library" ; then # only static version available
2154                     found=no
2155                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2156                     test "X$ladir" = "X$lib" && ladir="."
2157                     lib=$ladir/$old_library
2158                     if test "$linkmode,$pass" = "prog,link"; then
2159                       compile_deplibs="$deplib $compile_deplibs"
2160                       finalize_deplibs="$deplib $finalize_deplibs"
2161                     else
2162                       deplibs="$deplib $deplibs"
2163                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2164                     fi
2165                     continue
2166                   fi
2167                 fi
2168                 ;;
2169               *) ;;
2170               esac
2171             fi
2172           fi
2173           ;; # -l
2174         -L*)
2175           case $linkmode in
2176           lib)
2177             deplibs="$deplib $deplibs"
2178             test "$pass" = conv && continue
2179             newdependency_libs="$deplib $newdependency_libs"
2180             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2181             ;;
2182           prog)
2183             if test "$pass" = conv; then
2184               deplibs="$deplib $deplibs"
2185               continue
2186             fi
2187             if test "$pass" = scan; then
2188               deplibs="$deplib $deplibs"
2189             else
2190               compile_deplibs="$deplib $compile_deplibs"
2191               finalize_deplibs="$deplib $finalize_deplibs"
2192             fi
2193             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2194             ;;
2195           *)
2196             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2197             ;;
2198           esac # linkmode
2199           continue
2200           ;; # -L
2201         -R*)
2202           if test "$pass" = link; then
2203             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2204             # Make sure the xrpath contains only unique directories.
2205             case "$xrpath " in
2206             *" $dir "*) ;;
2207             *) xrpath="$xrpath $dir" ;;
2208             esac
2209           fi
2210           deplibs="$deplib $deplibs"
2211           continue
2212           ;;
2213         *.la) lib="$deplib" ;;
2214         *.$libext)
2215           if test "$pass" = conv; then
2216             deplibs="$deplib $deplibs"
2217             continue
2218           fi
2219           case $linkmode in
2220           lib)
2221             valid_a_lib=no
2222             case $deplibs_check_method in
2223               match_pattern*)
2224                 set dummy $deplibs_check_method
2225                 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2226                 if eval $echo \"$deplib\" 2>/dev/null \
2227                     | $SED 10q \
2228                     | $EGREP "$match_pattern_regex" > /dev/null; then
2229                   valid_a_lib=yes
2230                 fi
2231                 ;;
2232               pass_all)
2233                 valid_a_lib=yes
2234                 ;;
2235             esac
2236             if test "$valid_a_lib" != yes; then
2237               $echo
2238               $echo "*** Warning: Trying to link with static lib archive $deplib."
2239               $echo "*** I have the capability to make that library automatically link in when"
2240               $echo "*** you link to this library.  But I can only do this if you have a"
2241               $echo "*** shared version of the library, which you do not appear to have"
2242               $echo "*** because the file extensions .$libext of this argument makes me believe"
2243               $echo "*** that it is just a static archive that I should not used here."
2244             else
2245               $echo
2246               $echo "*** Warning: Linking the shared library $output against the"
2247               $echo "*** static library $deplib is not portable!"
2248               deplibs="$deplib $deplibs"
2249             fi
2250             continue
2251             ;;
2252           prog)
2253             if test "$pass" != link; then
2254               deplibs="$deplib $deplibs"
2255             else
2256               compile_deplibs="$deplib $compile_deplibs"
2257               finalize_deplibs="$deplib $finalize_deplibs"
2258             fi
2259             continue
2260             ;;
2261           esac # linkmode
2262           ;; # *.$libext
2263         *.lo | *.$objext)
2264           if test "$pass" = conv; then
2265             deplibs="$deplib $deplibs"
2266           elif test "$linkmode" = prog; then
2267             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2268               # If there is no dlopen support or we're linking statically,
2269               # we need to preload.
2270               newdlprefiles="$newdlprefiles $deplib"
2271               compile_deplibs="$deplib $compile_deplibs"
2272               finalize_deplibs="$deplib $finalize_deplibs"
2273             else
2274               newdlfiles="$newdlfiles $deplib"
2275             fi
2276           fi
2277           continue
2278           ;;
2279         %DEPLIBS%)
2280           alldeplibs=yes
2281           continue
2282           ;;
2283         esac # case $deplib
2284         if test "$found" = yes || test -f "$lib"; then :
2285         else
2286           $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2287           exit $EXIT_FAILURE
2288         fi
2289
2290         # Check to see that this really is a libtool archive.
2291         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2292         else
2293           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2294           exit $EXIT_FAILURE
2295         fi
2296
2297         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2298         test "X$ladir" = "X$lib" && ladir="."
2299
2300         dlname=
2301         dlopen=
2302         dlpreopen=
2303         libdir=
2304         library_names=
2305         old_library=
2306         # If the library was installed with an old release of libtool,
2307         # it will not redefine variables installed, or shouldnotlink
2308         installed=yes
2309         shouldnotlink=no
2310         avoidtemprpath=
2311
2312
2313         # Read the .la file
2314         case $lib in
2315         */* | *\\*) . $lib ;;
2316         *) . ./$lib ;;
2317         esac
2318
2319         if test "$linkmode,$pass" = "lib,link" ||
2320            test "$linkmode,$pass" = "prog,scan" ||
2321            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2322           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2323           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2324         fi
2325
2326         if test "$pass" = conv; then
2327           # Only check for convenience libraries
2328           deplibs="$lib $deplibs"
2329           if test -z "$libdir"; then
2330             if test -z "$old_library"; then
2331               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2332               exit $EXIT_FAILURE
2333             fi
2334             # It is a libtool convenience library, so add in its objects.
2335             convenience="$convenience $ladir/$objdir/$old_library"
2336             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2337             tmp_libs=
2338             for deplib in $dependency_libs; do
2339               deplibs="$deplib $deplibs"
2340               if test "X$duplicate_deps" = "Xyes" ; then
2341                 case "$tmp_libs " in
2342                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2343                 esac
2344               fi
2345               tmp_libs="$tmp_libs $deplib"
2346             done
2347           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2348             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2349             exit $EXIT_FAILURE
2350           fi
2351           continue
2352         fi # $pass = conv
2353
2354
2355         # Get the name of the library we link against.
2356         linklib=
2357         for l in $old_library $library_names; do
2358           linklib="$l"
2359         done
2360         if test -z "$linklib"; then
2361           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2362           exit $EXIT_FAILURE
2363         fi
2364
2365         # This library was specified with -dlopen.
2366         if test "$pass" = dlopen; then
2367           if test -z "$libdir"; then
2368             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2369             exit $EXIT_FAILURE
2370           fi
2371           if test -z "$dlname" ||
2372              test "$dlopen_support" != yes ||
2373              test "$build_libtool_libs" = no; then
2374             # If there is no dlname, no dlopen support or we're linking
2375             # statically, we need to preload.  We also need to preload any
2376             # dependent libraries so libltdl's deplib preloader doesn't
2377             # bomb out in the load deplibs phase.
2378             dlprefiles="$dlprefiles $lib $dependency_libs"
2379           else
2380             newdlfiles="$newdlfiles $lib"
2381           fi
2382           continue
2383         fi # $pass = dlopen
2384
2385         # We need an absolute path.
2386         case $ladir in
2387         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2388         *)
2389           abs_ladir=`cd "$ladir" && pwd`
2390           if test -z "$abs_ladir"; then
2391             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2392             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2393             abs_ladir="$ladir"
2394           fi
2395           ;;
2396         esac
2397         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2398
2399         # Find the relevant object directory and library name.
2400         if test "X$installed" = Xyes; then
2401           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2402             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2403             dir="$ladir"
2404             absdir="$abs_ladir"
2405             libdir="$abs_ladir"
2406           else
2407             dir="$libdir"
2408             absdir="$libdir"
2409           fi
2410           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2411         else
2412           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2413             dir="$ladir"
2414             absdir="$abs_ladir"
2415             # Remove this search path later
2416             notinst_path="$notinst_path $abs_ladir"
2417           else
2418             dir="$ladir/$objdir"
2419             absdir="$abs_ladir/$objdir"
2420             # Remove this search path later
2421             notinst_path="$notinst_path $abs_ladir"
2422           fi
2423         fi # $installed = yes
2424         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2425
2426         # This library was specified with -dlpreopen.
2427         if test "$pass" = dlpreopen; then
2428           if test -z "$libdir"; then
2429             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2430             exit $EXIT_FAILURE
2431           fi
2432           # Prefer using a static library (so that no silly _DYNAMIC symbols
2433           # are required to link).
2434           if test -n "$old_library"; then
2435             newdlprefiles="$newdlprefiles $dir/$old_library"
2436           # Otherwise, use the dlname, so that lt_dlopen finds it.
2437           elif test -n "$dlname"; then
2438             newdlprefiles="$newdlprefiles $dir/$dlname"
2439           else
2440             newdlprefiles="$newdlprefiles $dir/$linklib"
2441           fi
2442         fi # $pass = dlpreopen
2443
2444         if test -z "$libdir"; then
2445           # Link the convenience library
2446           if test "$linkmode" = lib; then
2447             deplibs="$dir/$old_library $deplibs"
2448           elif test "$linkmode,$pass" = "prog,link"; then
2449             compile_deplibs="$dir/$old_library $compile_deplibs"
2450             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2451           else
2452             deplibs="$lib $deplibs" # used for prog,scan pass
2453           fi
2454           continue
2455         fi
2456
2457
2458         if test "$linkmode" = prog && test "$pass" != link; then
2459           newlib_search_path="$newlib_search_path $ladir"
2460           deplibs="$lib $deplibs"
2461
2462           linkalldeplibs=no
2463           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2464              test "$build_libtool_libs" = no; then
2465             linkalldeplibs=yes
2466           fi
2467
2468           tmp_libs=
2469           for deplib in $dependency_libs; do
2470             case $deplib in
2471             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2472             esac
2473             # Need to link against all dependency_libs?
2474             if test "$linkalldeplibs" = yes; then
2475               deplibs="$deplib $deplibs"
2476             else
2477               # Need to hardcode shared library paths
2478               # or/and link against static libraries
2479               newdependency_libs="$deplib $newdependency_libs"
2480             fi
2481             if test "X$duplicate_deps" = "Xyes" ; then
2482               case "$tmp_libs " in
2483               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2484               esac
2485             fi
2486             tmp_libs="$tmp_libs $deplib"
2487           done # for deplib
2488           continue
2489         fi # $linkmode = prog...
2490
2491         if test "$linkmode,$pass" = "prog,link"; then
2492           if test -n "$library_names" &&
2493              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2494             # We need to hardcode the library path
2495             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2496               # Make sure the rpath contains only unique directories.
2497               case "$temp_rpath " in
2498               *" $dir "*) ;;
2499               *" $absdir "*) ;;
2500               *) temp_rpath="$temp_rpath $absdir" ;;
2501               esac
2502             fi
2503
2504             # Hardcode the library path.
2505             # Skip directories that are in the system default run-time
2506             # search path.
2507             case " $sys_lib_dlsearch_path " in
2508             *" $absdir "*) ;;
2509             *)
2510               case "$compile_rpath " in
2511               *" $absdir "*) ;;
2512               *) compile_rpath="$compile_rpath $absdir"
2513               esac
2514               ;;
2515             esac
2516             case " $sys_lib_dlsearch_path " in
2517             *" $libdir "*) ;;
2518             *)
2519               case "$finalize_rpath " in
2520               *" $libdir "*) ;;
2521               *) finalize_rpath="$finalize_rpath $libdir"
2522               esac
2523               ;;
2524             esac
2525           fi # $linkmode,$pass = prog,link...
2526
2527           if test "$alldeplibs" = yes &&
2528              { test "$deplibs_check_method" = pass_all ||
2529                { test "$build_libtool_libs" = yes &&
2530                  test -n "$library_names"; }; }; then
2531             # We only need to search for static libraries
2532             continue
2533           fi
2534         fi
2535
2536         link_static=no # Whether the deplib will be linked statically
2537         use_static_libs=$prefer_static_libs
2538         if test "$use_static_libs" = built && test "$installed" = yes ; then
2539           use_static_libs=no
2540         fi
2541         if test -n "$library_names" &&
2542            { test "$use_static_libs" = no || test -z "$old_library"; }; then
2543           if test "$installed" = no; then
2544             notinst_deplibs="$notinst_deplibs $lib"
2545             need_relink=yes
2546           fi
2547           # This is a shared library
2548
2549           # Warn about portability, can't link against -module's on
2550           # some systems (darwin)
2551           if test "$shouldnotlink" = yes && test "$pass" = link ; then
2552             $echo
2553             if test "$linkmode" = prog; then
2554               $echo "*** Warning: Linking the executable $output against the loadable module"
2555             else
2556               $echo "*** Warning: Linking the shared library $output against the loadable module"
2557             fi
2558             $echo "*** $linklib is not portable!"
2559           fi
2560           if test "$linkmode" = lib &&
2561              test "$hardcode_into_libs" = yes; then
2562             # Hardcode the library path.
2563             # Skip directories that are in the system default run-time
2564             # search path.
2565             case " $sys_lib_dlsearch_path " in
2566             *" $absdir "*) ;;
2567             *)
2568               case "$compile_rpath " in
2569               *" $absdir "*) ;;
2570               *) compile_rpath="$compile_rpath $absdir"
2571               esac
2572               ;;
2573             esac
2574             case " $sys_lib_dlsearch_path " in
2575             *" $libdir "*) ;;
2576             *)
2577               case "$finalize_rpath " in
2578               *" $libdir "*) ;;
2579               *) finalize_rpath="$finalize_rpath $libdir"
2580               esac
2581               ;;
2582             esac
2583           fi
2584
2585           if test -n "$old_archive_from_expsyms_cmds"; then
2586             # figure out the soname
2587             set dummy $library_names
2588             realname="$2"
2589             shift; shift
2590             libname=`eval \\$echo \"$libname_spec\"`
2591             # use dlname if we got it. it's perfectly good, no?
2592             if test -n "$dlname"; then
2593               soname="$dlname"
2594             elif test -n "$soname_spec"; then
2595               # bleh windows
2596               case $host in
2597               *cygwin* | mingw*)
2598                 major=`expr $current - $age`
2599                 versuffix="-$major"
2600                 ;;
2601               esac
2602               eval soname=\"$soname_spec\"
2603             else
2604               soname="$realname"
2605             fi
2606
2607             # Make a new name for the extract_expsyms_cmds to use
2608             soroot="$soname"
2609             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2610             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2611
2612             # If the library has no export list, then create one now
2613             if test -f "$output_objdir/$soname-def"; then :
2614             else
2615               $show "extracting exported symbol list from \`$soname'"
2616               save_ifs="$IFS"; IFS='~'
2617               cmds=$extract_expsyms_cmds
2618               for cmd in $cmds; do
2619                 IFS="$save_ifs"
2620                 eval cmd=\"$cmd\"
2621                 $show "$cmd"
2622                 $run eval "$cmd" || exit $?
2623               done
2624               IFS="$save_ifs"
2625             fi
2626
2627             # Create $newlib
2628             if test -f "$output_objdir/$newlib"; then :; else
2629               $show "generating import library for \`$soname'"
2630               save_ifs="$IFS"; IFS='~'
2631               cmds=$old_archive_from_expsyms_cmds
2632               for cmd in $cmds; do
2633                 IFS="$save_ifs"
2634                 eval cmd=\"$cmd\"
2635                 $show "$cmd"
2636                 $run eval "$cmd" || exit $?
2637               done
2638               IFS="$save_ifs"
2639             fi
2640             # make sure the library variables are pointing to the new library
2641             dir=$output_objdir
2642             linklib=$newlib
2643           fi # test -n "$old_archive_from_expsyms_cmds"
2644
2645           if test "$linkmode" = prog || test "$mode" != relink; then
2646             add_shlibpath=
2647             add_dir=
2648             add=
2649             lib_linked=yes
2650             case $hardcode_action in
2651             immediate | unsupported)
2652               if test "$hardcode_direct" = no; then
2653                 add="$dir/$linklib"
2654                 case $host in
2655                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
2656                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
2657                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2658                     *-*-unixware7*) add_dir="-L$dir" ;;
2659                   *-*-darwin* )
2660                     # if the lib is a module then we can not link against
2661                     # it, someone is ignoring the new warnings I added
2662                     if /usr/bin/file -L $add 2> /dev/null |
2663                       $EGREP ": [^:]* bundle" >/dev/null ; then
2664                       $echo "** Warning, lib $linklib is a module, not a shared library"
2665                       if test -z "$old_library" ; then
2666                         $echo
2667                         $echo "** And there doesn't seem to be a static archive available"
2668                         $echo "** The link will probably fail, sorry"
2669                       else
2670                         add="$dir/$old_library"
2671                       fi
2672                     fi
2673                 esac
2674               elif test "$hardcode_minus_L" = no; then
2675                 case $host in
2676                 *-*-sunos*) add_shlibpath="$dir" ;;
2677                 esac
2678                 add_dir="-L$dir"
2679                 add="-l$name"
2680               elif test "$hardcode_shlibpath_var" = no; then
2681                 add_shlibpath="$dir"
2682                 add="-l$name"
2683               else
2684                 lib_linked=no
2685               fi
2686               ;;
2687             relink)
2688               if test "$hardcode_direct" = yes; then
2689                 add="$dir/$linklib"
2690               elif test "$hardcode_minus_L" = yes; then
2691                 add_dir="-L$dir"
2692                 # Try looking first in the location we're being installed to.
2693                 if test -n "$inst_prefix_dir"; then
2694                   case $libdir in
2695                     [\\/]*)
2696                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2697                       ;;
2698                   esac
2699                 fi
2700                 add="-l$name"
2701               elif test "$hardcode_shlibpath_var" = yes; then
2702                 add_shlibpath="$dir"
2703                 add="-l$name"
2704               else
2705                 lib_linked=no
2706               fi
2707               ;;
2708             *) lib_linked=no ;;
2709             esac
2710
2711             if test "$lib_linked" != yes; then
2712               $echo "$modename: configuration error: unsupported hardcode properties"
2713               exit $EXIT_FAILURE
2714             fi
2715
2716             if test -n "$add_shlibpath"; then
2717               case :$compile_shlibpath: in
2718               *":$add_shlibpath:"*) ;;
2719               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2720               esac
2721             fi
2722             if test "$linkmode" = prog; then
2723               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2724               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2725             else
2726               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2727               test -n "$add" && deplibs="$add $deplibs"
2728               if test "$hardcode_direct" != yes && \
2729                  test "$hardcode_minus_L" != yes && \
2730                  test "$hardcode_shlibpath_var" = yes; then
2731                 case :$finalize_shlibpath: in
2732                 *":$libdir:"*) ;;
2733                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2734                 esac
2735               fi
2736             fi
2737           fi
2738
2739           if test "$linkmode" = prog || test "$mode" = relink; then
2740             add_shlibpath=
2741             add_dir=
2742             add=
2743             # Finalize command for both is simple: just hardcode it.
2744             if test "$hardcode_direct" = yes; then
2745               add="$libdir/$linklib"
2746             elif test "$hardcode_minus_L" = yes; then
2747               add_dir="-L$libdir"
2748               add="-l$name"
2749             elif test "$hardcode_shlibpath_var" = yes; then
2750               case :$finalize_shlibpath: in
2751               *":$libdir:"*) ;;
2752               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2753               esac
2754               add="-l$name"
2755             elif test "$hardcode_automatic" = yes; then
2756               if test -n "$inst_prefix_dir" &&
2757                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
2758                 add="$inst_prefix_dir$libdir/$linklib"
2759               else
2760                 add="$libdir/$linklib"
2761               fi
2762             else
2763               # We cannot seem to hardcode it, guess we'll fake it.
2764               add_dir="-L$libdir"
2765               # Try looking first in the location we're being installed to.
2766               if test -n "$inst_prefix_dir"; then
2767                 case $libdir in
2768                   [\\/]*)
2769                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2770                     ;;
2771                 esac
2772               fi
2773               add="-l$name"
2774             fi
2775
2776             if test "$linkmode" = prog; then
2777               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2778               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2779             else
2780               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2781               test -n "$add" && deplibs="$add $deplibs"
2782             fi
2783           fi
2784         elif test "$linkmode" = prog; then
2785           # Here we assume that one of hardcode_direct or hardcode_minus_L
2786           # is not unsupported.  This is valid on all known static and
2787           # shared platforms.
2788           if test "$hardcode_direct" != unsupported; then
2789             test -n "$old_library" && linklib="$old_library"
2790             compile_deplibs="$dir/$linklib $compile_deplibs"
2791             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2792           else
2793             compile_deplibs="-l$name -L$dir $compile_deplibs"
2794             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2795           fi
2796         elif test "$build_libtool_libs" = yes; then
2797           # Not a shared library
2798           if test "$deplibs_check_method" != pass_all; then
2799             # We're trying link a shared library against a static one
2800             # but the system doesn't support it.
2801
2802             # Just print a warning and add the library to dependency_libs so
2803             # that the program can be linked against the static library.
2804             $echo
2805             $echo "*** Warning: This system can not link to static lib archive $lib."
2806             $echo "*** I have the capability to make that library automatically link in when"
2807             $echo "*** you link to this library.  But I can only do this if you have a"
2808             $echo "*** shared version of the library, which you do not appear to have."
2809             if test "$module" = yes; then
2810               $echo "*** But as you try to build a module library, libtool will still create "
2811               $echo "*** a static module, that should work as long as the dlopening application"
2812               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2813               if test -z "$global_symbol_pipe"; then
2814                 $echo
2815                 $echo "*** However, this would only work if libtool was able to extract symbol"
2816                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2817                 $echo "*** not find such a program.  So, this module is probably useless."
2818                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2819               fi
2820               if test "$build_old_libs" = no; then
2821                 build_libtool_libs=module
2822                 build_old_libs=yes
2823               else
2824                 build_libtool_libs=no
2825               fi
2826             fi
2827           else
2828             deplibs="$dir/$old_library $deplibs"
2829             link_static=yes
2830           fi
2831         fi # link shared/static library?
2832
2833         if test "$linkmode" = lib; then
2834           if test -n "$dependency_libs" &&
2835              { test "$hardcode_into_libs" != yes ||
2836                test "$build_old_libs" = yes ||
2837                test "$link_static" = yes; }; then
2838             # Extract -R from dependency_libs
2839             temp_deplibs=
2840             for libdir in $dependency_libs; do
2841               case $libdir in
2842               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2843                    case " $xrpath " in
2844                    *" $temp_xrpath "*) ;;
2845                    *) xrpath="$xrpath $temp_xrpath";;
2846                    esac;;
2847               *) temp_deplibs="$temp_deplibs $libdir";;
2848               esac
2849             done
2850             dependency_libs="$temp_deplibs"
2851           fi
2852
2853           newlib_search_path="$newlib_search_path $absdir"
2854           # Link against this library
2855           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2856           # ... and its dependency_libs
2857           tmp_libs=
2858           for deplib in $dependency_libs; do
2859             newdependency_libs="$deplib $newdependency_libs"
2860             if test "X$duplicate_deps" = "Xyes" ; then
2861               case "$tmp_libs " in
2862               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2863               esac
2864             fi
2865             tmp_libs="$tmp_libs $deplib"
2866           done
2867
2868           if test "$link_all_deplibs" != no; then
2869             # Add the search paths of all dependency libraries
2870             for deplib in $dependency_libs; do
2871               case $deplib in
2872               -L*) path="$deplib" ;;
2873               *.la)
2874                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2875                 test "X$dir" = "X$deplib" && dir="."
2876                 # We need an absolute path.
2877                 case $dir in
2878                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2879                 *)
2880                   absdir=`cd "$dir" && pwd`
2881                   if test -z "$absdir"; then
2882                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2883                     absdir="$dir"
2884                   fi
2885                   ;;
2886                 esac
2887                 if grep "^installed=no" $deplib > /dev/null; then
2888                   path="$absdir/$objdir"
2889                 else
2890                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2891                   if test -z "$libdir"; then
2892                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2893                     exit $EXIT_FAILURE
2894                   fi
2895                   if test "$absdir" != "$libdir"; then
2896                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2897                   fi
2898                   path="$absdir"
2899                 fi
2900                 depdepl=
2901                 case $host in
2902                 *-*-darwin*)
2903                   # we do not want to link against static libs,
2904                   # but need to link against shared
2905                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2906                   if test -n "$deplibrary_names" ; then
2907                     for tmp in $deplibrary_names ; do
2908                       depdepl=$tmp
2909                     done
2910                     if test -f "$path/$depdepl" ; then
2911                       depdepl="$path/$depdepl"
2912                     fi
2913                     # do not add paths which are already there
2914                     case " $newlib_search_path " in
2915                     *" $path "*) ;;
2916                     *) newlib_search_path="$newlib_search_path $path";;
2917                     esac
2918                   fi
2919                   path=""
2920                   ;;
2921                 *)
2922                   path="-L$path"
2923                   ;;
2924                 esac
2925                 ;;
2926               -l*)
2927                 case $host in
2928                 *-*-darwin*)
2929                   # Again, we only want to link against shared libraries
2930                   eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2931                   for tmp in $newlib_search_path ; do
2932                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2933                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2934                       break
2935                     fi
2936                   done
2937                   path=""
2938                   ;;
2939                 *) continue ;;
2940                 esac
2941                 ;;
2942               *) continue ;;
2943               esac
2944               case " $deplibs " in
2945               *" $path "*) ;;
2946               *) deplibs="$path $deplibs" ;;
2947               esac
2948               case " $deplibs " in
2949               *" $depdepl "*) ;;
2950               *) deplibs="$depdepl $deplibs" ;;
2951               esac
2952             done
2953           fi # link_all_deplibs != no
2954         fi # linkmode = lib
2955       done # for deplib in $libs
2956       dependency_libs="$newdependency_libs"
2957       if test "$pass" = dlpreopen; then
2958         # Link the dlpreopened libraries before other libraries
2959         for deplib in $save_deplibs; do
2960           deplibs="$deplib $deplibs"
2961         done
2962       fi
2963       if test "$pass" != dlopen; then
2964         if test "$pass" != conv; then
2965           # Make sure lib_search_path contains only unique directories.
2966           lib_search_path=
2967           for dir in $newlib_search_path; do
2968             case "$lib_search_path " in
2969             *" $dir "*) ;;
2970             *) lib_search_path="$lib_search_path $dir" ;;
2971             esac
2972           done
2973           newlib_search_path=
2974         fi
2975
2976         if test "$linkmode,$pass" != "prog,link"; then
2977           vars="deplibs"
2978         else
2979           vars="compile_deplibs finalize_deplibs"
2980         fi
2981         for var in $vars dependency_libs; do
2982           # Add libraries to $var in reverse order
2983           eval tmp_libs=\"\$$var\"
2984           new_libs=
2985           for deplib in $tmp_libs; do
2986             # FIXME: Pedantically, this is the right thing to do, so
2987             #        that some nasty dependency loop isn't accidentally
2988             #        broken:
2989             #new_libs="$deplib $new_libs"
2990             # Pragmatically, this seems to cause very few problems in
2991             # practice:
2992             case $deplib in
2993             -L*) new_libs="$deplib $new_libs" ;;
2994             -R*) ;;
2995             *)
2996               # And here is the reason: when a library appears more
2997               # than once as an explicit dependence of a library, or
2998               # is implicitly linked in more than once by the
2999               # compiler, it is considered special, and multiple
3000               # occurrences thereof are not removed.  Compare this
3001               # with having the same library being listed as a
3002               # dependency of multiple other libraries: in this case,
3003               # we know (pedantically, we assume) the library does not
3004               # need to be listed more than once, so we keep only the
3005               # last copy.  This is not always right, but it is rare
3006               # enough that we require users that really mean to play
3007               # such unportable linking tricks to link the library
3008               # using -Wl,-lname, so that libtool does not consider it
3009               # for duplicate removal.
3010               case " $specialdeplibs " in
3011               *" $deplib "*) new_libs="$deplib $new_libs" ;;
3012               *)
3013                 case " $new_libs " in
3014                 *" $deplib "*) ;;
3015                 *) new_libs="$deplib $new_libs" ;;
3016                 esac
3017                 ;;
3018               esac
3019               ;;
3020             esac
3021           done
3022           tmp_libs=
3023           for deplib in $new_libs; do
3024             case $deplib in
3025             -L*)
3026               case " $tmp_libs " in
3027               *" $deplib "*) ;;
3028               *) tmp_libs="$tmp_libs $deplib" ;;
3029               esac
3030               ;;
3031             *) tmp_libs="$tmp_libs $deplib" ;;
3032             esac
3033           done
3034           eval $var=\"$tmp_libs\"
3035         done # for var
3036       fi
3037       # Last step: remove runtime libs from dependency_libs
3038       # (they stay in deplibs)
3039       tmp_libs=
3040       for i in $dependency_libs ; do
3041         case " $predeps $postdeps $compiler_lib_search_path " in
3042         *" $i "*)
3043           i=""
3044           ;;
3045         esac
3046         if test -n "$i" ; then
3047           tmp_libs="$tmp_libs $i"
3048         fi
3049       done
3050       dependency_libs=$tmp_libs
3051     done # for pass
3052     if test "$linkmode" = prog; then
3053       dlfiles="$newdlfiles"
3054       dlprefiles="$newdlprefiles"
3055     fi
3056
3057     case $linkmode in
3058     oldlib)
3059       if test -n "$deplibs"; then
3060         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
3061       fi
3062
3063       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3064         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3065       fi
3066
3067       if test -n "$rpath"; then
3068         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3069       fi
3070
3071       if test -n "$xrpath"; then
3072         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3073       fi
3074
3075       if test -n "$vinfo"; then
3076         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3077       fi
3078
3079       if test -n "$release"; then
3080         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3081       fi
3082
3083       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3084         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3085       fi
3086
3087       # Now set the variables for building old libraries.
3088       build_libtool_libs=no
3089       oldlibs="$output"
3090       objs="$objs$old_deplibs"
3091       ;;
3092
3093     lib)
3094       # Make sure we only generate libraries of the form `libNAME.la'.
3095       case $outputname in
3096       lib*)
3097         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3098         eval shared_ext=\"$shrext_cmds\"
3099         eval libname=\"$libname_spec\"
3100         ;;
3101       *)
3102         if test "$module" = no; then
3103           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3104           $echo "$help" 1>&2
3105           exit $EXIT_FAILURE
3106         fi
3107         if test "$need_lib_prefix" != no; then
3108           # Add the "lib" prefix for modules if required
3109           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3110           eval shared_ext=\"$shrext_cmds\"
3111           eval libname=\"$libname_spec\"
3112         else
3113           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3114         fi
3115         ;;
3116       esac
3117
3118       if test -n "$objs"; then
3119         if test "$deplibs_check_method" != pass_all; then
3120           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3121           exit $EXIT_FAILURE
3122         else
3123           $echo
3124           $echo "*** Warning: Linking the shared library $output against the non-libtool"
3125           $echo "*** objects $objs is not portable!"
3126           libobjs="$libobjs $objs"
3127         fi
3128       fi
3129
3130       if test "$dlself" != no; then
3131         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3132       fi
3133
3134       set dummy $rpath
3135       if test "$#" -gt 2; then
3136         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3137       fi
3138       install_libdir="$2"
3139
3140       oldlibs=
3141       if test -z "$rpath"; then
3142         if test "$build_libtool_libs" = yes; then
3143           # Building a libtool convenience library.
3144           # Some compilers have problems with a `.al' extension so
3145           # convenience libraries should have the same extension an
3146           # archive normally would.
3147           oldlibs="$output_objdir/$libname.$libext $oldlibs"
3148           build_libtool_libs=convenience
3149           build_old_libs=yes
3150         fi
3151
3152         if test -n "$vinfo"; then
3153           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3154         fi
3155
3156         if test -n "$release"; then
3157           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3158         fi
3159       else
3160
3161         # Parse the version information argument.
3162         save_ifs="$IFS"; IFS=':'
3163         set dummy $vinfo 0 0 0
3164         IFS="$save_ifs"
3165
3166         if test -n "$8"; then
3167           $echo "$modename: too many parameters to \`-version-info'" 1>&2
3168           $echo "$help" 1>&2
3169           exit $EXIT_FAILURE
3170         fi
3171
3172         # convert absolute version numbers to libtool ages
3173         # this retains compatibility with .la files and attempts
3174         # to make the code below a bit more comprehensible
3175
3176         case $vinfo_number in
3177         yes)
3178           number_major="$2"
3179           number_minor="$3"
3180           number_revision="$4"
3181           #
3182           # There are really only two kinds -- those that
3183           # use the current revision as the major version
3184           # and those that subtract age and use age as
3185           # a minor version.  But, then there is irix
3186           # which has an extra 1 added just for fun
3187           #
3188           case $version_type in
3189           darwin|linux|osf|windows)
3190             current=`expr $number_major + $number_minor`
3191             age="$number_minor"
3192             revision="$number_revision"
3193             ;;
3194           freebsd-aout|freebsd-elf|sunos)
3195             current="$number_major"
3196             revision="$number_minor"
3197             age="0"
3198             ;;
3199           irix|nonstopux)
3200             current=`expr $number_major + $number_minor - 1`
3201             age="$number_minor"
3202             revision="$number_minor"
3203             ;;
3204           esac
3205           ;;
3206         no)
3207           current="$2"
3208           revision="$3"
3209           age="$4"
3210           ;;
3211         esac
3212
3213         # Check that each of the things are valid numbers.
3214         case $current in
3215         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]) ;;
3216         *)
3217           $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3218           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3219           exit $EXIT_FAILURE
3220           ;;
3221         esac
3222
3223         case $revision in
3224         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]) ;;
3225         *)
3226           $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3227           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3228           exit $EXIT_FAILURE
3229           ;;
3230         esac
3231
3232         case $age in
3233         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]) ;;
3234         *)
3235           $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3236           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3237           exit $EXIT_FAILURE
3238           ;;
3239         esac
3240
3241         if test "$age" -gt "$current"; then
3242           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3243           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3244           exit $EXIT_FAILURE
3245         fi
3246
3247         # Calculate the version variables.
3248         major=
3249         versuffix=
3250         verstring=
3251         case $version_type in
3252         none) ;;
3253
3254         darwin)
3255           # Like Linux, but with the current version available in
3256           # verstring for coding it into the library header
3257           major=.`expr $current - $age`
3258           versuffix="$major.$age.$revision"
3259           # Darwin ld doesn't like 0 for these options...
3260           minor_current=`expr $current + 1`
3261           verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3262           ;;
3263
3264         freebsd-aout)
3265           major=".$current"
3266           versuffix=".$current.$revision";
3267           ;;
3268
3269         freebsd-elf)
3270           major=".$current"
3271           versuffix=".$current";
3272           ;;
3273
3274         irix | nonstopux)
3275           major=`expr $current - $age + 1`
3276
3277           case $version_type in
3278             nonstopux) verstring_prefix=nonstopux ;;
3279             *)         verstring_prefix=sgi ;;
3280           esac
3281           verstring="$verstring_prefix$major.$revision"
3282
3283           # Add in all the interfaces that we are compatible with.
3284           loop=$revision
3285           while test "$loop" -ne 0; do
3286             iface=`expr $revision - $loop`
3287             loop=`expr $loop - 1`
3288             verstring="$verstring_prefix$major.$iface:$verstring"
3289           done
3290
3291           # Before this point, $major must not contain `.'.
3292           major=.$major
3293           versuffix="$major.$revision"
3294           ;;
3295
3296         linux)
3297           major=.`expr $current - $age`
3298           versuffix="$major.$age.$revision"
3299           ;;
3300
3301         osf)
3302           major=.`expr $current - $age`
3303           versuffix=".$current.$age.$revision"
3304           verstring="$current.$age.$revision"
3305
3306           # Add in all the interfaces that we are compatible with.
3307           loop=$age
3308           while test "$loop" -ne 0; do
3309             iface=`expr $current - $loop`
3310             loop=`expr $loop - 1`
3311             verstring="$verstring:${iface}.0"
3312           done
3313
3314           # Make executables depend on our current version.
3315           verstring="$verstring:${current}.0"
3316           ;;
3317
3318         sunos)
3319           major=".$current"
3320           versuffix=".$current.$revision"
3321           ;;
3322
3323         windows)
3324           # Use '-' rather than '.', since we only want one
3325           # extension on DOS 8.3 filesystems.
3326           major=`expr $current - $age`
3327           versuffix="-$major"
3328           ;;
3329
3330         *)
3331           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3332           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3333           exit $EXIT_FAILURE
3334           ;;
3335         esac
3336
3337         # Clear the version info if we defaulted, and they specified a release.
3338         if test -z "$vinfo" && test -n "$release"; then
3339           major=
3340           case $version_type in
3341           darwin)
3342             # we can't check for "0.0" in archive_cmds due to quoting
3343             # problems, so we reset it completely
3344             verstring=
3345             ;;
3346           *)
3347             verstring="0.0"
3348             ;;
3349           esac
3350           if test "$need_version" = no; then
3351             versuffix=
3352           else
3353             versuffix=".0.0"
3354           fi
3355         fi
3356
3357         # Remove version info from name if versioning should be avoided
3358         if test "$avoid_version" = yes && test "$need_version" = no; then
3359           major=
3360           versuffix=
3361           verstring=""
3362         fi
3363
3364         # Check to see if the archive will have undefined symbols.
3365         if test "$allow_undefined" = yes; then
3366           if test "$allow_undefined_flag" = unsupported; then
3367             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3368             build_libtool_libs=no
3369             build_old_libs=yes
3370           fi
3371         else
3372           # Don't allow undefined symbols.
3373           allow_undefined_flag="$no_undefined_flag"
3374         fi
3375       fi
3376
3377       if test "$mode" != relink; then
3378         # Remove our outputs, but don't remove object files since they
3379         # may have been created when compiling PIC objects.
3380         removelist=
3381         tempremovelist=`$echo "$output_objdir/*"`
3382         for p in $tempremovelist; do
3383           case $p in
3384             *.$objext)
3385                ;;
3386             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3387                if test "X$precious_files_regex" != "X"; then
3388                  if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3389                  then
3390                    continue
3391                  fi
3392                fi
3393                removelist="$removelist $p"
3394                ;;
3395             *) ;;
3396           esac
3397         done
3398         if test -n "$removelist"; then
3399           $show "${rm}r $removelist"
3400           $run ${rm}r $removelist
3401         fi
3402       fi
3403
3404       # Now set the variables for building old libraries.
3405       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3406         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3407
3408         # Transform .lo files to .o files.
3409         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3410       fi
3411
3412       # Eliminate all temporary directories.
3413       for path in $notinst_path; do
3414         lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3415         deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3416         dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
3417       done
3418
3419       if test -n "$xrpath"; then
3420         # If the user specified any rpath flags, then add them.
3421         temp_xrpath=
3422         for libdir in $xrpath; do
3423           temp_xrpath="$temp_xrpath -R$libdir"
3424           case "$finalize_rpath " in
3425           *" $libdir "*) ;;
3426           *) finalize_rpath="$finalize_rpath $libdir" ;;
3427           esac
3428         done
3429         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3430           dependency_libs="$temp_xrpath $dependency_libs"
3431         fi
3432       fi
3433
3434       # Make sure dlfiles contains only unique files that won't be dlpreopened
3435       old_dlfiles="$dlfiles"
3436       dlfiles=
3437       for lib in $old_dlfiles; do
3438         case " $dlprefiles $dlfiles " in
3439         *" $lib "*) ;;
3440         *) dlfiles="$dlfiles $lib" ;;
3441         esac
3442       done
3443
3444       # Make sure dlprefiles contains only unique files
3445       old_dlprefiles="$dlprefiles"
3446       dlprefiles=
3447       for lib in $old_dlprefiles; do
3448         case "$dlprefiles " in
3449         *" $lib "*) ;;
3450         *) dlprefiles="$dlprefiles $lib" ;;
3451         esac
3452       done
3453
3454       if test "$build_libtool_libs" = yes; then
3455         if test -n "$rpath"; then
3456           case $host in
3457           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3458             # these systems don't actually have a c library (as such)!
3459             ;;
3460           *-*-rhapsody* | *-*-darwin1.[012])
3461             # Rhapsody C library is in the System framework
3462             deplibs="$deplibs -framework System"
3463             ;;
3464           *-*-netbsd*)
3465             # Don't link with libc until the a.out ld.so is fixed.
3466             ;;
3467           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3468             # Do not include libc due to us having libc/libc_r.
3469             ;;
3470           *-*-sco3.2v5* | *-*-sco5v6*)
3471             # Causes problems with __ctype
3472             ;;
3473           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3474             # Compiler inserts libc in the correct place for threads to work
3475             ;;
3476           *)
3477             # Add libc to deplibs on all other systems if necessary.
3478             if test "$build_libtool_need_lc" = "yes"; then
3479               deplibs="$deplibs -lc"
3480             fi
3481             ;;
3482           esac
3483         fi
3484
3485         # Transform deplibs into only deplibs that can be linked in shared.
3486         name_save=$name
3487         libname_save=$libname
3488         release_save=$release
3489         versuffix_save=$versuffix
3490         major_save=$major
3491         # I'm not sure if I'm treating the release correctly.  I think
3492         # release should show up in the -l (ie -lgmp5) so we don't want to
3493         # add it in twice.  Is that correct?
3494         release=""
3495         versuffix=""
3496         major=""
3497         newdeplibs=
3498         droppeddeps=no
3499         case $deplibs_check_method in
3500         pass_all)
3501           # Don't check for shared/static.  Everything works.
3502           # This might be a little naive.  We might want to check
3503           # whether the library exists or not.  But this is on
3504           # osf3 & osf4 and I'm not really sure... Just
3505           # implementing what was already the behavior.
3506           newdeplibs=$deplibs
3507           ;;
3508         test_compile)
3509           # This code stresses the "libraries are programs" paradigm to its
3510           # limits. Maybe even breaks it.  We compile a program, linking it
3511           # against the deplibs as a proxy for the library.  Then we can check
3512           # whether they linked in statically or dynamically with ldd.
3513           $rm conftest.c
3514           cat > conftest.c <<EOF
3515           int main() { return 0; }
3516 EOF
3517           $rm conftest
3518           $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
3519           if test "$?" -eq 0 ; then
3520             ldd_output=`ldd conftest`
3521             for i in $deplibs; do
3522               name=`expr $i : '-l\(.*\)'`
3523               # If $name is empty we are operating on a -L argument.
3524               if test "$name" != "" && test "$name" -ne "0"; then
3525                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3526                   case " $predeps $postdeps " in
3527                   *" $i "*)
3528                     newdeplibs="$newdeplibs $i"
3529                     i=""
3530                     ;;
3531                   esac
3532                 fi
3533                 if test -n "$i" ; then
3534                   libname=`eval \\$echo \"$libname_spec\"`
3535                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3536                   set dummy $deplib_matches
3537                   deplib_match=$2
3538                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3539                     newdeplibs="$newdeplibs $i"
3540                   else
3541                     droppeddeps=yes
3542                     $echo
3543                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3544                     $echo "*** I have the capability to make that library automatically link in when"
3545                     $echo "*** you link to this library.  But I can only do this if you have a"
3546                     $echo "*** shared version of the library, which I believe you do not have"
3547                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3548                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3549                   fi
3550                 fi
3551               else
3552                 newdeplibs="$newdeplibs $i"
3553               fi
3554             done
3555           else
3556             # Error occurred in the first compile.  Let's try to salvage
3557             # the situation: Compile a separate program for each library.
3558             for i in $deplibs; do
3559               name=`expr $i : '-l\(.*\)'`
3560               # If $name is empty we are operating on a -L argument.
3561               if test "$name" != "" && test "$name" != "0"; then
3562                 $rm conftest
3563                 $LTCC $LTCFLAGS -o conftest conftest.c $i
3564                 # Did it work?
3565                 if test "$?" -eq 0 ; then
3566                   ldd_output=`ldd conftest`
3567                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3568                     case " $predeps $postdeps " in
3569                     *" $i "*)
3570                       newdeplibs="$newdeplibs $i"
3571                       i=""
3572                       ;;
3573                     esac
3574                   fi
3575                   if test -n "$i" ; then
3576                     libname=`eval \\$echo \"$libname_spec\"`
3577                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3578                     set dummy $deplib_matches
3579                     deplib_match=$2
3580                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3581                       newdeplibs="$newdeplibs $i"
3582                     else
3583                       droppeddeps=yes
3584                       $echo
3585                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3586                       $echo "*** I have the capability to make that library automatically link in when"
3587                       $echo "*** you link to this library.  But I can only do this if you have a"
3588                       $echo "*** shared version of the library, which you do not appear to have"
3589                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3590                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3591                     fi
3592                   fi
3593                 else
3594                   droppeddeps=yes
3595                   $echo
3596                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3597                   $echo "***  make it link in!  You will probably need to install it or some"
3598                   $echo "*** library that it depends on before this library will be fully"
3599                   $echo "*** functional.  Installing it before continuing would be even better."
3600                 fi
3601               else
3602                 newdeplibs="$newdeplibs $i"
3603               fi
3604             done
3605           fi
3606           ;;
3607         file_magic*)
3608           set dummy $deplibs_check_method
3609           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3610           for a_deplib in $deplibs; do
3611             name=`expr $a_deplib : '-l\(.*\)'`
3612             # If $name is empty we are operating on a -L argument.
3613             if test "$name" != "" && test  "$name" != "0"; then
3614               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3615                 case " $predeps $postdeps " in
3616                 *" $a_deplib "*)
3617                   newdeplibs="$newdeplibs $a_deplib"
3618                   a_deplib=""
3619                   ;;
3620                 esac
3621               fi
3622               if test -n "$a_deplib" ; then
3623                 libname=`eval \\$echo \"$libname_spec\"`
3624                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3625                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3626                   for potent_lib in $potential_libs; do
3627                       # Follow soft links.
3628                       if ls -lLd "$potent_lib" 2>/dev/null \
3629                          | grep " -> " >/dev/null; then
3630                         continue
3631                       fi
3632                       # The statement above tries to avoid entering an
3633                       # endless loop below, in case of cyclic links.
3634                       # We might still enter an endless loop, since a link
3635                       # loop can be closed while we follow links,
3636                       # but so what?
3637                       potlib="$potent_lib"
3638                       while test -h "$potlib" 2>/dev/null; do
3639                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3640                         case $potliblink in
3641                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3642                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3643                         esac
3644                       done
3645                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3646                          | ${SED} 10q \
3647                          | $EGREP "$file_magic_regex" > /dev/null; then
3648                         newdeplibs="$newdeplibs $a_deplib"
3649                         a_deplib=""
3650                         break 2
3651                       fi
3652                   done
3653                 done
3654               fi
3655               if test -n "$a_deplib" ; then
3656                 droppeddeps=yes
3657                 $echo
3658                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3659                 $echo "*** I have the capability to make that library automatically link in when"
3660                 $echo "*** you link to this library.  But I can only do this if you have a"
3661                 $echo "*** shared version of the library, which you do not appear to have"
3662                 $echo "*** because I did check the linker path looking for a file starting"
3663                 if test -z "$potlib" ; then
3664                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3665                 else
3666                   $echo "*** with $libname and none of the candidates passed a file format test"
3667                   $echo "*** using a file magic. Last file checked: $potlib"
3668                 fi
3669               fi
3670             else
3671               # Add a -L argument.
3672               newdeplibs="$newdeplibs $a_deplib"
3673             fi
3674           done # Gone through all deplibs.
3675           ;;
3676         match_pattern*)
3677           set dummy $deplibs_check_method
3678           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3679           for a_deplib in $deplibs; do
3680             name=`expr $a_deplib : '-l\(.*\)'`
3681             # If $name is empty we are operating on a -L argument.
3682             if test -n "$name" && test "$name" != "0"; then
3683               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3684                 case " $predeps $postdeps " in
3685                 *" $a_deplib "*)
3686                   newdeplibs="$newdeplibs $a_deplib"
3687                   a_deplib=""
3688                   ;;
3689                 esac
3690               fi
3691               if test -n "$a_deplib" ; then
3692                 libname=`eval \\$echo \"$libname_spec\"`
3693                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3694                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3695                   for potent_lib in $potential_libs; do
3696                     potlib="$potent_lib" # see symlink-check above in file_magic test
3697                     if eval $echo \"$potent_lib\" 2>/dev/null \
3698                         | ${SED} 10q \
3699                         | $EGREP "$match_pattern_regex" > /dev/null; then
3700                       newdeplibs="$newdeplibs $a_deplib"
3701                       a_deplib=""
3702                       break 2
3703                     fi
3704                   done
3705                 done
3706               fi
3707               if test -n "$a_deplib" ; then
3708                 droppeddeps=yes
3709                 $echo
3710                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3711                 $echo "*** I have the capability to make that library automatically link in when"
3712                 $echo "*** you link to this library.  But I can only do this if you have a"
3713                 $echo "*** shared version of the library, which you do not appear to have"
3714                 $echo "*** because I did check the linker path looking for a file starting"
3715                 if test -z "$potlib" ; then
3716                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3717                 else
3718                   $echo "*** with $libname and none of the candidates passed a file format test"
3719                   $echo "*** using a regex pattern. Last file checked: $potlib"
3720                 fi
3721               fi
3722             else
3723               # Add a -L argument.
3724               newdeplibs="$newdeplibs $a_deplib"
3725             fi
3726           done # Gone through all deplibs.
3727           ;;
3728         none | unknown | *)
3729           newdeplibs=""
3730           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3731             -e 's/ -[LR][^ ]*//g'`
3732           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3733             for i in $predeps $postdeps ; do
3734               # can't use Xsed below, because $i might contain '/'
3735               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3736             done
3737           fi
3738           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3739             | grep . >/dev/null; then
3740             $echo
3741             if test "X$deplibs_check_method" = "Xnone"; then
3742               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3743             else
3744               $echo "*** Warning: inter-library dependencies are not known to be supported."
3745             fi
3746             $echo "*** All declared inter-library dependencies are being dropped."
3747             droppeddeps=yes
3748           fi
3749           ;;
3750         esac
3751         versuffix=$versuffix_save
3752         major=$major_save
3753         release=$release_save
3754         libname=$libname_save
3755         name=$name_save
3756
3757         case $host in
3758         *-*-rhapsody* | *-*-darwin1.[012])
3759           # On Rhapsody replace the C library is the System framework
3760           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3761           ;;
3762         esac
3763
3764         if test "$droppeddeps" = yes; then
3765           if test "$module" = yes; then
3766             $echo
3767             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3768             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3769             $echo "*** a static module, that should work as long as the dlopening"
3770             $echo "*** application is linked with the -dlopen flag."
3771             if test -z "$global_symbol_pipe"; then
3772               $echo
3773               $echo "*** However, this would only work if libtool was able to extract symbol"
3774               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3775               $echo "*** not find such a program.  So, this module is probably useless."
3776               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3777             fi
3778             if test "$build_old_libs" = no; then
3779               oldlibs="$output_objdir/$libname.$libext"
3780               build_libtool_libs=module
3781               build_old_libs=yes
3782             else
3783               build_libtool_libs=no
3784             fi
3785           else
3786             $echo "*** The inter-library dependencies that have been dropped here will be"
3787             $echo "*** automatically added whenever a program is linked with this library"
3788             $echo "*** or is declared to -dlopen it."
3789
3790             if test "$allow_undefined" = no; then
3791               $echo
3792               $echo "*** Since this library must not contain undefined symbols,"
3793               $echo "*** because either the platform does not support them or"
3794               $echo "*** it was explicitly requested with -no-undefined,"
3795               $echo "*** libtool will only create a static version of it."
3796               if test "$build_old_libs" = no; then
3797                 oldlibs="$output_objdir/$libname.$libext"
3798                 build_libtool_libs=module
3799                 build_old_libs=yes
3800               else
3801                 build_libtool_libs=no
3802               fi
3803             fi
3804           fi
3805         fi
3806         # Done checking deplibs!
3807         deplibs=$newdeplibs
3808       fi
3809
3810
3811       # move library search paths that coincide with paths to not yet
3812       # installed libraries to the beginning of the library search list
3813       new_libs=
3814       for path in $notinst_path; do
3815         case " $new_libs " in
3816         *" -L$path/$objdir "*) ;;
3817         *)
3818           case " $deplibs " in
3819           *" -L$path/$objdir "*)
3820             new_libs="$new_libs -L$path/$objdir" ;;
3821           esac
3822           ;;
3823         esac
3824       done
3825       for deplib in $deplibs; do
3826         case $deplib in
3827         -L*)
3828           case " $new_libs " in
3829           *" $deplib "*) ;;
3830           *) new_libs="$new_libs $deplib" ;;
3831           esac
3832           ;;
3833         *) new_libs="$new_libs $deplib" ;;
3834         esac
3835       done
3836       deplibs="$new_libs"
3837
3838
3839       # All the library-specific variables (install_libdir is set above).
3840       library_names=
3841       old_library=
3842       dlname=
3843
3844       # Test again, we may have decided not to build it any more
3845       if test "$build_libtool_libs" = yes; then
3846         if test "$hardcode_into_libs" = yes; then
3847           # Hardcode the library paths
3848           hardcode_libdirs=
3849           dep_rpath=
3850           rpath="$finalize_rpath"
3851           test "$mode" != relink && rpath="$compile_rpath$rpath"
3852           for libdir in $rpath; do
3853             if test -n "$hardcode_libdir_flag_spec"; then
3854               if test -n "$hardcode_libdir_separator"; then
3855                 if test -z "$hardcode_libdirs"; then
3856                   hardcode_libdirs="$libdir"
3857                 else
3858                   # Just accumulate the unique libdirs.
3859                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3860                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3861                     ;;
3862                   *)
3863                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3864                     ;;
3865                   esac
3866                 fi
3867               else
3868                 eval flag=\"$hardcode_libdir_flag_spec\"
3869                 dep_rpath="$dep_rpath $flag"
3870               fi
3871             elif test -n "$runpath_var"; then
3872               case "$perm_rpath " in
3873               *" $libdir "*) ;;
3874               *) perm_rpath="$perm_rpath $libdir" ;;
3875               esac
3876             fi
3877           done
3878           # Substitute the hardcoded libdirs into the rpath.
3879           if test -n "$hardcode_libdir_separator" &&
3880              test -n "$hardcode_libdirs"; then
3881             libdir="$hardcode_libdirs"
3882             if test -n "$hardcode_libdir_flag_spec_ld"; then
3883               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3884             else
3885               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3886             fi
3887           fi
3888           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3889             # We should set the runpath_var.
3890             rpath=
3891             for dir in $perm_rpath; do
3892               rpath="$rpath$dir:"
3893             done
3894             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3895           fi
3896           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3897         fi
3898
3899         shlibpath="$finalize_shlibpath"
3900         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3901         if test -n "$shlibpath"; then
3902           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3903         fi
3904
3905         # Get the real and link names of the library.
3906         eval shared_ext=\"$shrext_cmds\"
3907         eval library_names=\"$library_names_spec\"
3908         set dummy $library_names
3909         realname="$2"
3910         shift; shift
3911
3912         if test -n "$soname_spec"; then
3913           eval soname=\"$soname_spec\"
3914         else
3915           soname="$realname"
3916         fi
3917         if test -z "$dlname"; then
3918           dlname=$soname
3919         fi
3920
3921         lib="$output_objdir/$realname"
3922         linknames=
3923         for link
3924         do
3925           linknames="$linknames $link"
3926         done
3927
3928         # Use standard objects if they are pic
3929         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3930
3931         # Prepare the list of exported symbols
3932         if test -z "$export_symbols"; then
3933           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3934             $show "generating symbol list for \`$libname.la'"
3935             export_symbols="$output_objdir/$libname.exp"
3936             $run $rm $export_symbols
3937             cmds=$export_symbols_cmds
3938             save_ifs="$IFS"; IFS='~'
3939             for cmd in $cmds; do
3940               IFS="$save_ifs"
3941               eval cmd=\"$cmd\"
3942               if len=`expr "X$cmd" : ".*"` &&
3943                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3944                 $show "$cmd"
3945                 $run eval "$cmd" || exit $?
3946                 skipped_export=false
3947               else
3948                 # The command line is too long to execute in one step.
3949                 $show "using reloadable object file for export list..."
3950                 skipped_export=:
3951                 # Break out early, otherwise skipped_export may be
3952                 # set to false by a later but shorter cmd.
3953                 break
3954               fi
3955             done
3956             IFS="$save_ifs"
3957             if test -n "$export_symbols_regex"; then
3958               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3959               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3960               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3961               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3962             fi
3963           fi
3964         fi
3965
3966         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3967           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3968         fi
3969
3970         tmp_deplibs=
3971         for test_deplib in $deplibs; do
3972                 case " $convenience " in
3973                 *" $test_deplib "*) ;;
3974                 *)
3975                         tmp_deplibs="$tmp_deplibs $test_deplib"
3976                         ;;
3977                 esac
3978         done
3979         deplibs="$tmp_deplibs"
3980
3981         if test -n "$convenience"; then
3982           if test -n "$whole_archive_flag_spec"; then
3983             save_libobjs=$libobjs
3984             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3985           else
3986             gentop="$output_objdir/${outputname}x"
3987             generated="$generated $gentop"
3988
3989             func_extract_archives $gentop $convenience
3990             libobjs="$libobjs $func_extract_archives_result"
3991           fi
3992         fi
3993
3994         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3995           eval flag=\"$thread_safe_flag_spec\"
3996           linker_flags="$linker_flags $flag"
3997         fi
3998
3999         # Make a backup of the uninstalled library when relinking
4000         if test "$mode" = relink; then
4001           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
4002         fi
4003
4004         # Do each of the archive commands.
4005         if test "$module" = yes && test -n "$module_cmds" ; then
4006           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4007             eval test_cmds=\"$module_expsym_cmds\"
4008             cmds=$module_expsym_cmds
4009           else
4010             eval test_cmds=\"$module_cmds\"
4011             cmds=$module_cmds
4012           fi
4013         else
4014         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4015           eval test_cmds=\"$archive_expsym_cmds\"
4016           cmds=$archive_expsym_cmds
4017         else
4018           eval test_cmds=\"$archive_cmds\"
4019           cmds=$archive_cmds
4020           fi
4021         fi
4022
4023         if test "X$skipped_export" != "X:" &&
4024            len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4025            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4026           :
4027         else
4028           # The command line is too long to link in one step, link piecewise.
4029           $echo "creating reloadable object files..."
4030
4031           # Save the value of $output and $libobjs because we want to
4032           # use them later.  If we have whole_archive_flag_spec, we
4033           # want to use save_libobjs as it was before
4034           # whole_archive_flag_spec was expanded, because we can't
4035           # assume the linker understands whole_archive_flag_spec.
4036           # This may have to be revisited, in case too many
4037           # convenience libraries get linked in and end up exceeding
4038           # the spec.
4039           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
4040             save_libobjs=$libobjs
4041           fi
4042           save_output=$output
4043           output_la=`$echo "X$output" | $Xsed -e "$basename"`
4044
4045           # Clear the reloadable object creation command queue and
4046           # initialize k to one.
4047           test_cmds=
4048           concat_cmds=
4049           objlist=
4050           delfiles=
4051           last_robj=
4052           k=1
4053           output=$output_objdir/$output_la-${k}.$objext
4054           # Loop over the list of objects to be linked.
4055           for obj in $save_libobjs
4056           do
4057             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4058             if test "X$objlist" = X ||
4059                { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4060                  test "$len" -le "$max_cmd_len"; }; then
4061               objlist="$objlist $obj"
4062             else
4063               # The command $test_cmds is almost too long, add a
4064               # command to the queue.
4065               if test "$k" -eq 1 ; then
4066                 # The first file doesn't have a previous command to add.
4067                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4068               else
4069                 # All subsequent reloadable object files will link in
4070                 # the last one created.
4071                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4072               fi
4073               last_robj=$output_objdir/$output_la-${k}.$objext
4074               k=`expr $k + 1`
4075               output=$output_objdir/$output_la-${k}.$objext
4076               objlist=$obj
4077               len=1
4078             fi
4079           done
4080           # Handle the remaining objects by creating one last
4081           # reloadable object file.  All subsequent reloadable object
4082           # files will link in the last one created.
4083           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4084           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4085
4086           if ${skipped_export-false}; then
4087             $show "generating symbol list for \`$libname.la'"
4088             export_symbols="$output_objdir/$libname.exp"
4089             $run $rm $export_symbols
4090             libobjs=$output
4091             # Append the command to create the export file.
4092             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4093           fi
4094
4095           # Set up a command to remove the reloadable object files
4096           # after they are used.
4097           i=0
4098           while test "$i" -lt "$k"
4099           do
4100             i=`expr $i + 1`
4101             delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4102           done
4103
4104           $echo "creating a temporary reloadable object file: $output"
4105
4106           # Loop through the commands generated above and execute them.
4107           save_ifs="$IFS"; IFS='~'
4108           for cmd in $concat_cmds; do
4109             IFS="$save_ifs"
4110             $show "$cmd"
4111             $run eval "$cmd" || exit $?
4112           done
4113           IFS="$save_ifs"
4114
4115           libobjs=$output
4116           # Restore the value of output.
4117           output=$save_output
4118
4119           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4120             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4121           fi
4122           # Expand the library linking commands again to reset the
4123           # value of $libobjs for piecewise linking.
4124
4125           # Do each of the archive commands.
4126           if test "$module" = yes && test -n "$module_cmds" ; then
4127             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4128               cmds=$module_expsym_cmds
4129             else
4130               cmds=$module_cmds
4131             fi
4132           else
4133           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4134             cmds=$archive_expsym_cmds
4135           else
4136             cmds=$archive_cmds
4137             fi
4138           fi
4139
4140           # Append the command to remove the reloadable object files
4141           # to the just-reset $cmds.
4142           eval cmds=\"\$cmds~\$rm $delfiles\"
4143         fi
4144         save_ifs="$IFS"; IFS='~'
4145         for cmd in $cmds; do
4146           IFS="$save_ifs"
4147           eval cmd=\"$cmd\"
4148           $show "$cmd"
4149           $run eval "$cmd" || {
4150             lt_exit=$?
4151
4152             # Restore the uninstalled library and exit
4153             if test "$mode" = relink; then
4154               $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
4155             fi
4156
4157             exit $lt_exit
4158           }
4159         done
4160         IFS="$save_ifs"
4161
4162         # Restore the uninstalled library and exit
4163         if test "$mode" = relink; then
4164           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
4165
4166           if test -n "$convenience"; then
4167             if test -z "$whole_archive_flag_spec"; then
4168               $show "${rm}r $gentop"
4169               $run ${rm}r "$gentop"
4170             fi
4171           fi
4172
4173           exit $EXIT_SUCCESS
4174         fi
4175
4176         # Create links to the real library.
4177         for linkname in $linknames; do
4178           if test "$realname" != "$linkname"; then
4179             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4180             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
4181           fi
4182         done
4183
4184         # If -module or -export-dynamic was specified, set the dlname.
4185         if test "$module" = yes || test "$export_dynamic" = yes; then
4186           # On all known operating systems, these are identical.
4187           dlname="$soname"
4188         fi
4189       fi
4190       ;;
4191
4192     obj)
4193       if test -n "$deplibs"; then
4194         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4195       fi
4196
4197       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4198         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4199       fi
4200
4201       if test -n "$rpath"; then
4202         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4203       fi
4204
4205       if test -n "$xrpath"; then
4206         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4207       fi
4208
4209       if test -n "$vinfo"; then
4210         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4211       fi
4212
4213       if test -n "$release"; then
4214         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4215       fi
4216
4217       case $output in
4218       *.lo)
4219         if test -n "$objs$old_deplibs"; then
4220           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4221           exit $EXIT_FAILURE
4222         fi
4223         libobj="$output"
4224         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4225         ;;
4226       *)
4227         libobj=
4228         obj="$output"
4229         ;;
4230       esac
4231
4232       # Delete the old objects.
4233       $run $rm $obj $libobj
4234
4235       # Objects from convenience libraries.  This assumes
4236       # single-version convenience libraries.  Whenever we create
4237       # different ones for PIC/non-PIC, this we'll have to duplicate
4238       # the extraction.
4239       reload_conv_objs=
4240       gentop=
4241       # reload_cmds runs $LD directly, so let us get rid of
4242       # -Wl from whole_archive_flag_spec
4243       wl=
4244
4245       if test -n "$convenience"; then
4246         if test -n "$whole_archive_flag_spec"; then
4247           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
4248         else
4249           gentop="$output_objdir/${obj}x"
4250           generated="$generated $gentop"
4251
4252           func_extract_archives $gentop $convenience
4253           reload_conv_objs="$reload_objs $func_extract_archives_result"
4254         fi
4255       fi
4256
4257       # Create the old-style object.
4258       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
4259
4260       output="$obj"
4261       cmds=$reload_cmds
4262       save_ifs="$IFS"; IFS='~'
4263       for cmd in $cmds; do
4264         IFS="$save_ifs"
4265         eval cmd=\"$cmd\"
4266         $show "$cmd"
4267         $run eval "$cmd" || exit $?
4268       done
4269       IFS="$save_ifs"
4270
4271       # Exit if we aren't doing a library object file.
4272       if test -z "$libobj"; then
4273         if test -n "$gentop"; then
4274           $show "${rm}r $gentop"
4275           $run ${rm}r $gentop
4276         fi
4277
4278         exit $EXIT_SUCCESS
4279       fi
4280
4281       if test "$build_libtool_libs" != yes; then
4282         if test -n "$gentop"; then
4283           $show "${rm}r $gentop"
4284           $run ${rm}r $gentop
4285         fi
4286
4287         # Create an invalid libtool object if no PIC, so that we don't
4288         # accidentally link it into a program.
4289         # $show "echo timestamp > $libobj"
4290         # $run eval "echo timestamp > $libobj" || exit $?
4291         exit $EXIT_SUCCESS
4292       fi
4293
4294       if test -n "$pic_flag" || test "$pic_mode" != default; then
4295         # Only do commands if we really have different PIC objects.
4296         reload_objs="$libobjs $reload_conv_objs"
4297         output="$libobj"
4298         cmds=$reload_cmds
4299         save_ifs="$IFS"; IFS='~'
4300         for cmd in $cmds; do
4301           IFS="$save_ifs"
4302           eval cmd=\"$cmd\"
4303           $show "$cmd"
4304           $run eval "$cmd" || exit $?
4305         done
4306         IFS="$save_ifs"
4307       fi
4308
4309       if test -n "$gentop"; then
4310         $show "${rm}r $gentop"
4311         $run ${rm}r $gentop
4312       fi
4313
4314       exit $EXIT_SUCCESS
4315       ;;
4316
4317     prog)
4318       case $host in
4319         *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4320       esac
4321       if test -n "$vinfo"; then
4322         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4323       fi
4324
4325       if test -n "$release"; then
4326         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4327       fi
4328
4329       if test "$preload" = yes; then
4330         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4331            test "$dlopen_self_static" = unknown; then
4332           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4333         fi
4334       fi
4335
4336       case $host in
4337       *-*-rhapsody* | *-*-darwin1.[012])
4338         # On Rhapsody replace the C library is the System framework
4339         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4340         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4341         ;;
4342       esac
4343
4344       case $host in
4345       *darwin*)
4346         # Don't allow lazy linking, it breaks C++ global constructors
4347         if test "$tagname" = CXX ; then
4348         compile_command="$compile_command ${wl}-bind_at_load"
4349         finalize_command="$finalize_command ${wl}-bind_at_load"
4350         fi
4351         ;;
4352       esac
4353
4354
4355       # move library search paths that coincide with paths to not yet
4356       # installed libraries to the beginning of the library search list
4357       new_libs=
4358       for path in $notinst_path; do
4359         case " $new_libs " in
4360         *" -L$path/$objdir "*) ;;
4361         *)
4362           case " $compile_deplibs " in
4363           *" -L$path/$objdir "*)
4364             new_libs="$new_libs -L$path/$objdir" ;;
4365           esac
4366           ;;
4367         esac
4368       done
4369       for deplib in $compile_deplibs; do
4370         case $deplib in
4371         -L*)
4372           case " $new_libs " in
4373           *" $deplib "*) ;;
4374           *) new_libs="$new_libs $deplib" ;;
4375           esac
4376           ;;
4377         *) new_libs="$new_libs $deplib" ;;
4378         esac
4379       done
4380       compile_deplibs="$new_libs"
4381
4382
4383       compile_command="$compile_command $compile_deplibs"
4384       finalize_command="$finalize_command $finalize_deplibs"
4385
4386       if test -n "$rpath$xrpath"; then
4387         # If the user specified any rpath flags, then add them.
4388         for libdir in $rpath $xrpath; do
4389           # This is the magic to use -rpath.
4390           case "$finalize_rpath " in
4391           *" $libdir "*) ;;
4392           *) finalize_rpath="$finalize_rpath $libdir" ;;
4393           esac
4394         done
4395       fi
4396
4397       # Now hardcode the library paths
4398       rpath=
4399       hardcode_libdirs=
4400       for libdir in $compile_rpath $finalize_rpath; do
4401         if test -n "$hardcode_libdir_flag_spec"; then
4402           if test -n "$hardcode_libdir_separator"; then
4403             if test -z "$hardcode_libdirs"; then
4404               hardcode_libdirs="$libdir"
4405             else
4406               # Just accumulate the unique libdirs.
4407               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4408               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4409                 ;;
4410               *)
4411                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4412                 ;;
4413               esac
4414             fi
4415           else
4416             eval flag=\"$hardcode_libdir_flag_spec\"
4417             rpath="$rpath $flag"
4418           fi
4419         elif test -n "$runpath_var"; then
4420           case "$perm_rpath " in
4421           *" $libdir "*) ;;
4422           *) perm_rpath="$perm_rpath $libdir" ;;
4423           esac
4424         fi
4425         case $host in
4426         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4427           testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
4428           case :$dllsearchpath: in
4429           *":$libdir:"*) ;;
4430           *) dllsearchpath="$dllsearchpath:$libdir";;
4431           esac
4432           case :$dllsearchpath: in
4433           *":$testbindir:"*) ;;
4434           *) dllsearchpath="$dllsearchpath:$testbindir";;
4435           esac
4436           ;;
4437         esac
4438       done
4439       # Substitute the hardcoded libdirs into the rpath.
4440       if test -n "$hardcode_libdir_separator" &&
4441          test -n "$hardcode_libdirs"; then
4442         libdir="$hardcode_libdirs"
4443         eval rpath=\" $hardcode_libdir_flag_spec\"
4444       fi
4445       compile_rpath="$rpath"
4446
4447       rpath=
4448       hardcode_libdirs=
4449       for libdir in $finalize_rpath; do
4450         if test -n "$hardcode_libdir_flag_spec"; then
4451           if test -n "$hardcode_libdir_separator"; then
4452             if test -z "$hardcode_libdirs"; then
4453               hardcode_libdirs="$libdir"
4454             else
4455               # Just accumulate the unique libdirs.
4456               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4457               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4458                 ;;
4459               *)
4460                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4461                 ;;
4462               esac
4463             fi
4464           else
4465             eval flag=\"$hardcode_libdir_flag_spec\"
4466             rpath="$rpath $flag"
4467           fi
4468         elif test -n "$runpath_var"; then
4469           case "$finalize_perm_rpath " in
4470           *" $libdir "*) ;;
4471           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4472           esac
4473         fi
4474       done
4475       # Substitute the hardcoded libdirs into the rpath.
4476       if test -n "$hardcode_libdir_separator" &&
4477          test -n "$hardcode_libdirs"; then
4478         libdir="$hardcode_libdirs"
4479         eval rpath=\" $hardcode_libdir_flag_spec\"
4480       fi
4481       finalize_rpath="$rpath"
4482
4483       if test -n "$libobjs" && test "$build_old_libs" = yes; then
4484         # Transform all the library objects into standard objects.
4485         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4486         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4487       fi
4488
4489       dlsyms=
4490       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4491         if test -n "$NM" && test -n "$global_symbol_pipe"; then
4492           dlsyms="${outputname}S.c"
4493         else
4494           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4495         fi
4496       fi
4497
4498       if test -n "$dlsyms"; then
4499         case $dlsyms in
4500         "") ;;
4501         *.c)
4502           # Discover the nlist of each of the dlfiles.
4503           nlist="$output_objdir/${outputname}.nm"
4504
4505           $show "$rm $nlist ${nlist}S ${nlist}T"
4506           $run $rm "$nlist" "${nlist}S" "${nlist}T"
4507
4508           # Parse the name list into a source file.
4509           $show "creating $output_objdir/$dlsyms"
4510
4511           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4512 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4513 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4514
4515 #ifdef __cplusplus
4516 extern \"C\" {
4517 #endif
4518
4519 /* Prevent the only kind of declaration conflicts we can make. */
4520 #define lt_preloaded_symbols some_other_symbol
4521
4522 /* External symbol declarations for the compiler. */\
4523 "
4524
4525           if test "$dlself" = yes; then
4526             $show "generating symbol list for \`$output'"
4527
4528             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4529
4530             # Add our own program objects to the symbol list.
4531             progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4532             for arg in $progfiles; do
4533               $show "extracting global C symbols from \`$arg'"
4534               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4535             done
4536
4537             if test -n "$exclude_expsyms"; then
4538               $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4539               $run eval '$mv "$nlist"T "$nlist"'
4540             fi
4541
4542             if test -n "$export_symbols_regex"; then
4543               $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4544               $run eval '$mv "$nlist"T "$nlist"'
4545             fi
4546
4547             # Prepare the list of exported symbols
4548             if test -z "$export_symbols"; then
4549               export_symbols="$output_objdir/$outputname.exp"
4550               $run $rm $export_symbols
4551               $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4552               case $host in
4553               *cygwin* | *mingw* )
4554                 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4555                 $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4556                 ;;
4557               esac
4558             else
4559               $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4560               $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4561               $run eval 'mv "$nlist"T "$nlist"'
4562               case $host in
4563               *cygwin* | *mingw* )
4564                 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4565                 $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4566                 ;;
4567               esac
4568             fi
4569           fi
4570
4571           for arg in $dlprefiles; do
4572             $show "extracting global C symbols from \`$arg'"
4573             name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4574             $run eval '$echo ": $name " >> "$nlist"'
4575             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4576           done
4577
4578           if test -z "$run"; then
4579             # Make sure we have at least an empty file.
4580             test -f "$nlist" || : > "$nlist"
4581
4582             if test -n "$exclude_expsyms"; then
4583               $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4584               $mv "$nlist"T "$nlist"
4585             fi
4586
4587             # Try sorting and uniquifying the output.
4588             if grep -v "^: " < "$nlist" |
4589                 if sort -k 3 </dev/null >/dev/null 2>&1; then
4590                   sort -k 3
4591                 else
4592                   sort +2
4593                 fi |
4594                 uniq > "$nlist"S; then
4595               :
4596             else
4597               grep -v "^: " < "$nlist" > "$nlist"S
4598             fi
4599
4600             if test -f "$nlist"S; then
4601               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4602             else
4603               $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4604             fi
4605
4606             $echo >> "$output_objdir/$dlsyms" "\
4607
4608 #undef lt_preloaded_symbols
4609
4610 #if defined (__STDC__) && __STDC__
4611 # define lt_ptr void *
4612 #else
4613 # define lt_ptr char *
4614 # define const
4615 #endif
4616
4617 /* The mapping between symbol names and symbols. */
4618 "
4619
4620             case $host in
4621             *cygwin* | *mingw* )
4622           $echo >> "$output_objdir/$dlsyms" "\
4623 /* DATA imports from DLLs on WIN32 can't be const, because
4624    runtime relocations are performed -- see ld's documentation
4625    on pseudo-relocs */
4626 struct {
4627 "
4628               ;;
4629             * )
4630           $echo >> "$output_objdir/$dlsyms" "\
4631 const struct {
4632 "
4633               ;;
4634             esac
4635
4636
4637           $echo >> "$output_objdir/$dlsyms" "\
4638   const char *name;
4639   lt_ptr address;
4640 }
4641 lt_preloaded_symbols[] =
4642 {\
4643 "
4644
4645             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4646
4647             $echo >> "$output_objdir/$dlsyms" "\
4648   {0, (lt_ptr) 0}
4649 };
4650
4651 /* This works around a problem in FreeBSD linker */
4652 #ifdef FREEBSD_WORKAROUND
4653 static const void *lt_preloaded_setup() {
4654   return lt_preloaded_symbols;
4655 }
4656 #endif
4657
4658 #ifdef __cplusplus
4659 }
4660 #endif\
4661 "
4662           fi
4663
4664           pic_flag_for_symtable=
4665           case $host in
4666           # compiling the symbol table file with pic_flag works around
4667           # a FreeBSD bug that causes programs to crash when -lm is
4668           # linked before any other PIC object.  But we must not use
4669           # pic_flag when linking with -static.  The problem exists in
4670           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4671           *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4672             case "$compile_command " in
4673             *" -static "*) ;;
4674             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4675             esac;;
4676           *-*-hpux*)
4677             case "$compile_command " in
4678             *" -static "*) ;;
4679             *) pic_flag_for_symtable=" $pic_flag";;
4680             esac
4681           esac
4682
4683           # Now compile the dynamic symbol file.
4684           $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4685           $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4686
4687           # Clean up the generated files.
4688           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4689           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4690
4691           # Transform the symbol file into the correct name.
4692           case $host in
4693           *cygwin* | *mingw* )
4694             if test -f "$output_objdir/${outputname}.def" ; then
4695               compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4696               finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4697             else
4698               compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4699               finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4700              fi
4701             ;;
4702           * )
4703             compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4704             finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4705             ;;
4706           esac
4707           ;;
4708         *)
4709           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4710           exit $EXIT_FAILURE
4711           ;;
4712         esac
4713       else
4714         # We keep going just in case the user didn't refer to
4715         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4716         # really was required.
4717
4718         # Nullify the symbol file.
4719         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4720         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4721       fi
4722
4723       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4724         # Replace the output file specification.
4725         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4726         link_command="$compile_command$compile_rpath"
4727
4728         # We have no uninstalled library dependencies, so finalize right now.
4729         $show "$link_command"
4730         $run eval "$link_command"
4731         exit_status=$?
4732
4733         # Delete the generated files.
4734         if test -n "$dlsyms"; then
4735           $show "$rm $output_objdir/${outputname}S.${objext}"
4736           $run $rm "$output_objdir/${outputname}S.${objext}"
4737         fi
4738
4739         exit $exit_status
4740       fi
4741
4742       if test -n "$shlibpath_var"; then
4743         # We should set the shlibpath_var
4744         rpath=
4745         for dir in $temp_rpath; do
4746           case $dir in
4747           [\\/]* | [A-Za-z]:[\\/]*)
4748             # Absolute path.
4749             rpath="$rpath$dir:"
4750             ;;
4751           *)
4752             # Relative path: add a thisdir entry.
4753             rpath="$rpath\$thisdir/$dir:"
4754             ;;
4755           esac
4756         done
4757         temp_rpath="$rpath"
4758       fi
4759
4760       if test -n "$compile_shlibpath$finalize_shlibpath"; then
4761         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4762       fi
4763       if test -n "$finalize_shlibpath"; then
4764         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4765       fi
4766
4767       compile_var=
4768       finalize_var=
4769       if test -n "$runpath_var"; then
4770         if test -n "$perm_rpath"; then
4771           # We should set the runpath_var.
4772           rpath=
4773           for dir in $perm_rpath; do
4774             rpath="$rpath$dir:"
4775           done
4776           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4777         fi
4778         if test -n "$finalize_perm_rpath"; then
4779           # We should set the runpath_var.
4780           rpath=
4781           for dir in $finalize_perm_rpath; do
4782             rpath="$rpath$dir:"
4783           done
4784           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4785         fi
4786       fi
4787
4788       if test "$no_install" = yes; then
4789         # We don't need to create a wrapper script.
4790         link_command="$compile_var$compile_command$compile_rpath"
4791         # Replace the output file specification.
4792         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4793         # Delete the old output file.
4794         $run $rm $output
4795         # Link the executable and exit
4796         $show "$link_command"
4797         $run eval "$link_command" || exit $?
4798         exit $EXIT_SUCCESS
4799       fi
4800
4801       if test "$hardcode_action" = relink; then
4802         # Fast installation is not supported
4803         link_command="$compile_var$compile_command$compile_rpath"
4804         relink_command="$finalize_var$finalize_command$finalize_rpath"
4805
4806         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4807         $echo "$modename: \`$output' will be relinked during installation" 1>&2
4808       else
4809         if test "$fast_install" != no; then
4810           link_command="$finalize_var$compile_command$finalize_rpath"
4811           if test "$fast_install" = yes; then
4812             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4813           else
4814             # fast_install is set to needless
4815             relink_command=
4816           fi
4817         else
4818           link_command="$compile_var$compile_command$compile_rpath"
4819           relink_command="$finalize_var$finalize_command$finalize_rpath"
4820         fi
4821       fi
4822
4823       # Replace the output file specification.
4824       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4825
4826       # Delete the old output files.
4827       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4828
4829       $show "$link_command"
4830       $run eval "$link_command" || exit $?
4831
4832       # Now create the wrapper script.
4833       $show "creating $output"
4834
4835       # Quote the relink command for shipping.
4836       if test -n "$relink_command"; then
4837         # Preserve any variables that may affect compiler behavior
4838         for var in $variables_saved_for_relink; do
4839           if eval test -z \"\${$var+set}\"; then
4840             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4841           elif eval var_value=\$$var; test -z "$var_value"; then
4842             relink_command="$var=; export $var; $relink_command"
4843           else
4844             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4845             relink_command="$var=\"$var_value\"; export $var; $relink_command"
4846           fi
4847         done
4848         relink_command="(cd `pwd`; $relink_command)"
4849         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4850       fi
4851
4852       # Quote $echo for shipping.
4853       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4854         case $progpath in
4855         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4856         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4857         esac
4858         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4859       else
4860         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4861       fi
4862
4863       # Only actually do things if our run command is non-null.
4864       if test -z "$run"; then
4865         # win32 will think the script is a binary if it has
4866         # a .exe suffix, so we strip it off here.
4867         case $output in
4868           *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4869         esac
4870         # test for cygwin because mv fails w/o .exe extensions
4871         case $host in
4872           *cygwin*)
4873             exeext=.exe
4874             outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4875           *) exeext= ;;
4876         esac
4877         case $host in
4878           *cygwin* | *mingw* )
4879             output_name=`basename $output`
4880             output_path=`dirname $output`
4881             cwrappersource="$output_path/$objdir/lt-$output_name.c"
4882             cwrapper="$output_path/$output_name.exe"
4883             $rm $cwrappersource $cwrapper
4884             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4885
4886             cat > $cwrappersource <<EOF
4887
4888 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4889    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4890
4891    The $output program cannot be directly executed until all the libtool
4892    libraries that it depends on are installed.
4893
4894    This wrapper executable should never be moved out of the build directory.
4895    If it is, it will not operate correctly.
4896
4897    Currently, it simply execs the wrapper *script* "/bin/sh $output",
4898    but could eventually absorb all of the scripts functionality and
4899    exec $objdir/$outputname directly.
4900 */
4901 EOF
4902             cat >> $cwrappersource<<"EOF"
4903 #include <stdio.h>
4904 #include <stdlib.h>
4905 #include <unistd.h>
4906 #include <malloc.h>
4907 #include <stdarg.h>
4908 #include <assert.h>
4909 #include <string.h>
4910 #include <ctype.h>
4911 #include <sys/stat.h>
4912
4913 #if defined(PATH_MAX)
4914 # define LT_PATHMAX PATH_MAX
4915 #elif defined(MAXPATHLEN)
4916 # define LT_PATHMAX MAXPATHLEN
4917 #else
4918 # define LT_PATHMAX 1024
4919 #endif
4920
4921 #ifndef DIR_SEPARATOR
4922 # define DIR_SEPARATOR '/'
4923 # define PATH_SEPARATOR ':'
4924 #endif
4925
4926 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4927   defined (__OS2__)
4928 # define HAVE_DOS_BASED_FILE_SYSTEM
4929 # ifndef DIR_SEPARATOR_2
4930 #  define DIR_SEPARATOR_2 '\\'
4931 # endif
4932 # ifndef PATH_SEPARATOR_2
4933 #  define PATH_SEPARATOR_2 ';'
4934 # endif
4935 #endif
4936
4937 #ifndef DIR_SEPARATOR_2
4938 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4939 #else /* DIR_SEPARATOR_2 */
4940 # define IS_DIR_SEPARATOR(ch) \
4941         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4942 #endif /* DIR_SEPARATOR_2 */
4943
4944 #ifndef PATH_SEPARATOR_2
4945 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4946 #else /* PATH_SEPARATOR_2 */
4947 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4948 #endif /* PATH_SEPARATOR_2 */
4949
4950 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4951 #define XFREE(stale) do { \
4952   if (stale) { free ((void *) stale); stale = 0; } \
4953 } while (0)
4954
4955 /* -DDEBUG is fairly common in CFLAGS.  */
4956 #undef DEBUG
4957 #if defined DEBUGWRAPPER
4958 # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
4959 #else
4960 # define DEBUG(format, ...)
4961 #endif
4962
4963 const char *program_name = NULL;
4964
4965 void * xmalloc (size_t num);
4966 char * xstrdup (const char *string);
4967 const char * base_name (const char *name);
4968 char * find_executable(const char *wrapper);
4969 int    check_executable(const char *path);
4970 char * strendzap(char *str, const char *pat);
4971 void lt_fatal (const char *message, ...);
4972
4973 int
4974 main (int argc, char *argv[])
4975 {
4976   char **newargz;
4977   int i;
4978
4979   program_name = (char *) xstrdup (base_name (argv[0]));
4980   DEBUG("(main) argv[0]      : %s\n",argv[0]);
4981   DEBUG("(main) program_name : %s\n",program_name);
4982   newargz = XMALLOC(char *, argc+2);
4983 EOF
4984
4985             cat >> $cwrappersource <<EOF
4986   newargz[0] = (char *) xstrdup("$SHELL");
4987 EOF
4988
4989             cat >> $cwrappersource <<"EOF"
4990   newargz[1] = find_executable(argv[0]);
4991   if (newargz[1] == NULL)
4992     lt_fatal("Couldn't find %s", argv[0]);
4993   DEBUG("(main) found exe at : %s\n",newargz[1]);
4994   /* we know the script has the same name, without the .exe */
4995   /* so make sure newargz[1] doesn't end in .exe */
4996   strendzap(newargz[1],".exe");
4997   for (i = 1; i < argc; i++)
4998     newargz[i+1] = xstrdup(argv[i]);
4999   newargz[argc+1] = NULL;
5000
5001   for (i=0; i<argc+1; i++)
5002   {
5003     DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
5004     ;
5005   }
5006
5007 EOF
5008
5009             case $host_os in
5010               mingw*)
5011                 cat >> $cwrappersource <<EOF
5012   execv("$SHELL",(char const **)newargz);
5013 EOF
5014               ;;
5015               *)
5016                 cat >> $cwrappersource <<EOF
5017   execv("$SHELL",newargz);
5018 EOF
5019               ;;
5020             esac
5021
5022             cat >> $cwrappersource <<"EOF"
5023   return 127;
5024 }
5025
5026 void *
5027 xmalloc (size_t num)
5028 {
5029   void * p = (void *) malloc (num);
5030   if (!p)
5031     lt_fatal ("Memory exhausted");
5032
5033   return p;
5034 }
5035
5036 char *
5037 xstrdup (const char *string)
5038 {
5039   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5040 ;
5041 }
5042
5043 const char *
5044 base_name (const char *name)
5045 {
5046   const char *base;
5047
5048 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5049   /* Skip over the disk name in MSDOS pathnames. */
5050   if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5051     name += 2;
5052 #endif
5053
5054   for (base = name; *name; name++)
5055     if (IS_DIR_SEPARATOR (*name))
5056       base = name + 1;
5057   return base;
5058 }
5059
5060 int
5061 check_executable(const char * path)
5062 {
5063   struct stat st;
5064
5065   DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5066   if ((!path) || (!*path))
5067     return 0;
5068
5069   if ((stat (path, &st) >= 0) &&
5070       (
5071         /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5072 #if defined (S_IXOTH)
5073        ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5074 #endif
5075 #if defined (S_IXGRP)
5076        ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5077 #endif
5078        ((st.st_mode & S_IXUSR) == S_IXUSR))
5079       )
5080     return 1;
5081   else
5082     return 0;
5083 }
5084
5085 /* Searches for the full path of the wrapper.  Returns
5086    newly allocated full path name if found, NULL otherwise */
5087 char *
5088 find_executable (const char* wrapper)
5089 {
5090   int has_slash = 0;
5091   const char* p;
5092   const char* p_next;
5093   /* static buffer for getcwd */
5094   char tmp[LT_PATHMAX + 1];
5095   int tmp_len;
5096   char* concat_name;
5097
5098   DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5099
5100   if ((wrapper == NULL) || (*wrapper == '\0'))
5101     return NULL;
5102
5103   /* Absolute path? */
5104 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5105   if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5106   {
5107     concat_name = xstrdup (wrapper);
5108     if (check_executable(concat_name))
5109       return concat_name;
5110     XFREE(concat_name);
5111   }
5112   else
5113   {
5114 #endif
5115     if (IS_DIR_SEPARATOR (wrapper[0]))
5116     {
5117       concat_name = xstrdup (wrapper);
5118       if (check_executable(concat_name))
5119         return concat_name;
5120       XFREE(concat_name);
5121     }
5122 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5123   }
5124 #endif
5125
5126   for (p = wrapper; *p; p++)
5127     if (*p == '/')
5128     {
5129       has_slash = 1;
5130       break;
5131     }
5132   if (!has_slash)
5133   {
5134     /* no slashes; search PATH */
5135     const char* path = getenv ("PATH");
5136     if (path != NULL)
5137     {
5138       for (p = path; *p; p = p_next)
5139       {
5140         const char* q;
5141         size_t p_len;
5142         for (q = p; *q; q++)
5143           if (IS_PATH_SEPARATOR(*q))
5144             break;
5145         p_len = q - p;
5146         p_next = (*q == '\0' ? q : q + 1);
5147         if (p_len == 0)
5148         {
5149           /* empty path: current directory */
5150           if (getcwd (tmp, LT_PATHMAX) == NULL)
5151             lt_fatal ("getcwd failed");
5152           tmp_len = strlen(tmp);
5153           concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5154           memcpy (concat_name, tmp, tmp_len);
5155           concat_name[tmp_len] = '/';
5156           strcpy (concat_name + tmp_len + 1, wrapper);
5157         }
5158         else
5159         {
5160           concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5161           memcpy (concat_name, p, p_len);
5162           concat_name[p_len] = '/';
5163           strcpy (concat_name + p_len + 1, wrapper);
5164         }
5165         if (check_executable(concat_name))
5166           return concat_name;
5167         XFREE(concat_name);
5168       }
5169     }
5170     /* not found in PATH; assume curdir */
5171   }
5172   /* Relative path | not found in path: prepend cwd */
5173   if (getcwd (tmp, LT_PATHMAX) == NULL)
5174     lt_fatal ("getcwd failed");
5175   tmp_len = strlen(tmp);
5176   concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5177   memcpy (concat_name, tmp, tmp_len);
5178   concat_name[tmp_len] = '/';
5179   strcpy (concat_name + tmp_len + 1, wrapper);
5180
5181   if (check_executable(concat_name))
5182     return concat_name;
5183   XFREE(concat_name);
5184   return NULL;
5185 }
5186
5187 char *
5188 strendzap(char *str, const char *pat)
5189 {
5190   size_t len, patlen;
5191
5192   assert(str != NULL);
5193   assert(pat != NULL);
5194
5195   len = strlen(str);
5196   patlen = strlen(pat);
5197
5198   if (patlen <= len)
5199   {
5200     str += len - patlen;
5201     if (strcmp(str, pat) == 0)
5202       *str = '\0';
5203   }
5204   return str;
5205 }
5206
5207 static void
5208 lt_error_core (int exit_status, const char * mode,
5209           const char * message, va_list ap)
5210 {
5211   fprintf (stderr, "%s: %s: ", program_name, mode);
5212   vfprintf (stderr, message, ap);
5213   fprintf (stderr, ".\n");
5214
5215   if (exit_status >= 0)
5216     exit (exit_status);
5217 }
5218
5219 void
5220 lt_fatal (const char *message, ...)
5221 {
5222   va_list ap;
5223   va_start (ap, message);
5224   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5225   va_end (ap);
5226 }
5227 EOF
5228           # we should really use a build-platform specific compiler
5229           # here, but OTOH, the wrappers (shell script and this C one)
5230           # are only useful if you want to execute the "real" binary.
5231           # Since the "real" binary is built for $host, then this
5232           # wrapper might as well be built for $host, too.
5233           $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5234           ;;
5235         esac
5236         $rm $output
5237         trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5238
5239         $echo > $output "\
5240 #! $SHELL
5241
5242 # $output - temporary wrapper script for $objdir/$outputname
5243 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5244 #
5245 # The $output program cannot be directly executed until all the libtool
5246 # libraries that it depends on are installed.
5247 #
5248 # This wrapper script should never be moved out of the build directory.
5249 # If it is, it will not operate correctly.
5250
5251 # Sed substitution that helps us do robust quoting.  It backslashifies
5252 # metacharacters that are still active within double-quoted strings.
5253 Xsed='${SED} -e 1s/^X//'
5254 sed_quote_subst='$sed_quote_subst'
5255
5256 # The HP-UX ksh and POSIX shell print the target directory to stdout
5257 # if CDPATH is set.
5258 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5259
5260 relink_command=\"$relink_command\"
5261
5262 # This environment variable determines our operation mode.
5263 if test \"\$libtool_install_magic\" = \"$magic\"; then
5264   # install mode needs the following variable:
5265   notinst_deplibs='$notinst_deplibs'
5266 else
5267   # When we are sourced in execute mode, \$file and \$echo are already set.
5268   if test \"\$libtool_execute_magic\" != \"$magic\"; then
5269     echo=\"$qecho\"
5270     file=\"\$0\"
5271     # Make sure echo works.
5272     if test \"X\$1\" = X--no-reexec; then
5273       # Discard the --no-reexec flag, and continue.
5274       shift
5275     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5276       # Yippee, \$echo works!
5277       :
5278     else
5279       # Restart under the correct shell, and then maybe \$echo will work.
5280       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5281     fi
5282   fi\
5283 "
5284         $echo >> $output "\
5285
5286   # Find the directory that this script lives in.
5287   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5288   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5289
5290   # Follow symbolic links until we get to the real thisdir.
5291   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5292   while test -n \"\$file\"; do
5293     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5294
5295     # If there was a directory component, then change thisdir.
5296     if test \"x\$destdir\" != \"x\$file\"; then
5297       case \"\$destdir\" in
5298       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5299       *) thisdir=\"\$thisdir/\$destdir\" ;;
5300       esac
5301     fi
5302
5303     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5304     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5305   done
5306
5307   # Try to get the absolute directory name.
5308   absdir=\`cd \"\$thisdir\" && pwd\`
5309   test -n \"\$absdir\" && thisdir=\"\$absdir\"
5310 "
5311
5312         if test "$fast_install" = yes; then
5313           $echo >> $output "\
5314   program=lt-'$outputname'$exeext
5315   progdir=\"\$thisdir/$objdir\"
5316
5317   if test ! -f \"\$progdir/\$program\" || \\
5318      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5319        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5320
5321     file=\"\$\$-\$program\"
5322
5323     if test ! -d \"\$progdir\"; then
5324       $mkdir \"\$progdir\"
5325     else
5326       $rm \"\$progdir/\$file\"
5327     fi"
5328
5329           $echo >> $output "\
5330
5331     # relink executable if necessary
5332     if test -n \"\$relink_command\"; then
5333       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5334       else
5335         $echo \"\$relink_command_output\" >&2
5336         $rm \"\$progdir/\$file\"
5337         exit $EXIT_FAILURE
5338       fi
5339     fi
5340
5341     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5342     { $rm \"\$progdir/\$program\";
5343       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5344     $rm \"\$progdir/\$file\"
5345   fi"
5346         else
5347           $echo >> $output "\
5348   program='$outputname'
5349   progdir=\"\$thisdir/$objdir\"
5350 "
5351         fi
5352
5353         $echo >> $output "\
5354
5355   if test -f \"\$progdir/\$program\"; then"
5356
5357         # Export our shlibpath_var if we have one.
5358         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5359           $echo >> $output "\
5360     # Add our own library path to $shlibpath_var
5361     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5362
5363     # Some systems cannot cope with colon-terminated $shlibpath_var
5364     # The second colon is a workaround for a bug in BeOS R4 sed
5365     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5366
5367     export $shlibpath_var
5368 "
5369         fi
5370
5371         # fixup the dll searchpath if we need to.
5372         if test -n "$dllsearchpath"; then
5373           $echo >> $output "\
5374     # Add the dll search path components to the executable PATH
5375     PATH=$dllsearchpath:\$PATH
5376 "
5377         fi
5378
5379         $echo >> $output "\
5380     if test \"\$libtool_execute_magic\" != \"$magic\"; then
5381       # Run the actual program with our arguments.
5382 "
5383         case $host in
5384         # Backslashes separate directories on plain windows
5385         *-*-mingw | *-*-os2*)
5386           $echo >> $output "\
5387       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5388 "
5389           ;;
5390
5391         *)
5392           $echo >> $output "\
5393       exec \"\$progdir/\$program\" \${1+\"\$@\"}
5394 "
5395           ;;
5396         esac
5397         $echo >> $output "\
5398       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
5399       exit $EXIT_FAILURE
5400     fi
5401   else
5402     # The program doesn't exist.
5403     \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5404     \$echo \"This script is just a wrapper for \$program.\" 1>&2
5405     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5406     exit $EXIT_FAILURE
5407   fi
5408 fi\
5409 "
5410         chmod +x $output
5411       fi
5412       exit $EXIT_SUCCESS
5413       ;;
5414     esac
5415
5416     # See if we need to build an old-fashioned archive.
5417     for oldlib in $oldlibs; do
5418
5419       if test "$build_libtool_libs" = convenience; then
5420         oldobjs="$libobjs_save"
5421         addlibs="$convenience"
5422         build_libtool_libs=no
5423       else
5424         if test "$build_libtool_libs" = module; then
5425           oldobjs="$libobjs_save"
5426           build_libtool_libs=no
5427         else
5428           oldobjs="$old_deplibs $non_pic_objects"
5429         fi
5430         addlibs="$old_convenience"
5431       fi
5432
5433       if test -n "$addlibs"; then
5434         gentop="$output_objdir/${outputname}x"
5435         generated="$generated $gentop"
5436
5437         func_extract_archives $gentop $addlibs
5438         oldobjs="$oldobjs $func_extract_archives_result"
5439       fi
5440
5441       # Do each command in the archive commands.
5442       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5443        cmds=$old_archive_from_new_cmds
5444       else
5445         # POSIX demands no paths to be encoded in archives.  We have
5446         # to avoid creating archives with duplicate basenames if we
5447         # might have to extract them afterwards, e.g., when creating a
5448         # static archive out of a convenience library, or when linking
5449         # the entirety of a libtool archive into another (currently
5450         # not supported by libtool).
5451         if (for obj in $oldobjs
5452             do
5453               $echo "X$obj" | $Xsed -e 's%^.*/%%'
5454             done | sort | sort -uc >/dev/null 2>&1); then
5455           :
5456         else
5457           $echo "copying selected object files to avoid basename conflicts..."
5458
5459           if test -z "$gentop"; then
5460             gentop="$output_objdir/${outputname}x"
5461             generated="$generated $gentop"
5462
5463             $show "${rm}r $gentop"
5464             $run ${rm}r "$gentop"
5465             $show "$mkdir $gentop"
5466             $run $mkdir "$gentop"
5467             exit_status=$?
5468             if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5469               exit $exit_status
5470             fi
5471           fi
5472
5473           save_oldobjs=$oldobjs
5474           oldobjs=
5475           counter=1
5476           for obj in $save_oldobjs
5477           do
5478             objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
5479             case " $oldobjs " in
5480             " ") oldobjs=$obj ;;
5481             *[\ /]"$objbase "*)
5482               while :; do
5483                 # Make sure we don't pick an alternate name that also
5484                 # overlaps.
5485                 newobj=lt$counter-$objbase
5486                 counter=`expr $counter + 1`
5487                 case " $oldobjs " in
5488                 *[\ /]"$newobj "*) ;;
5489                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5490                 esac
5491               done
5492               $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5493               $run ln "$obj" "$gentop/$newobj" ||
5494               $run cp "$obj" "$gentop/$newobj"
5495               oldobjs="$oldobjs $gentop/$newobj"
5496               ;;
5497             *) oldobjs="$oldobjs $obj" ;;
5498             esac
5499           done
5500         fi
5501
5502         eval cmds=\"$old_archive_cmds\"
5503
5504         if len=`expr "X$cmds" : ".*"` &&
5505              test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5506           cmds=$old_archive_cmds
5507         else
5508           # the command line is too long to link in one step, link in parts
5509           $echo "using piecewise archive linking..."
5510           save_RANLIB=$RANLIB
5511           RANLIB=:
5512           objlist=
5513           concat_cmds=
5514           save_oldobjs=$oldobjs
5515
5516           # Is there a better way of finding the last object in the list?
5517           for obj in $save_oldobjs
5518           do
5519             last_oldobj=$obj
5520           done
5521           for obj in $save_oldobjs
5522           do
5523             oldobjs="$objlist $obj"
5524             objlist="$objlist $obj"
5525             eval test_cmds=\"$old_archive_cmds\"
5526             if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5527                test "$len" -le "$max_cmd_len"; then
5528               :
5529             else
5530               # the above command should be used before it gets too long
5531               oldobjs=$objlist
5532               if test "$obj" = "$last_oldobj" ; then
5533                 RANLIB=$save_RANLIB
5534               fi
5535               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5536               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5537               objlist=
5538             fi
5539           done
5540           RANLIB=$save_RANLIB
5541           oldobjs=$objlist
5542           if test "X$oldobjs" = "X" ; then
5543             eval cmds=\"\$concat_cmds\"
5544           else
5545             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5546           fi
5547         fi
5548       fi
5549       save_ifs="$IFS"; IFS='~'
5550       for cmd in $cmds; do
5551         eval cmd=\"$cmd\"
5552         IFS="$save_ifs"
5553         $show "$cmd"
5554         $run eval "$cmd" || exit $?
5555       done
5556       IFS="$save_ifs"
5557     done
5558
5559     if test -n "$generated"; then
5560       $show "${rm}r$generated"
5561       $run ${rm}r$generated
5562     fi
5563
5564     # Now create the libtool archive.
5565     case $output in
5566     *.la)
5567       old_library=
5568       test "$build_old_libs" = yes && old_library="$libname.$libext"
5569       $show "creating $output"
5570
5571       # Preserve any variables that may affect compiler behavior
5572       for var in $variables_saved_for_relink; do
5573         if eval test -z \"\${$var+set}\"; then
5574           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5575         elif eval var_value=\$$var; test -z "$var_value"; then
5576           relink_command="$var=; export $var; $relink_command"
5577         else
5578           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5579           relink_command="$var=\"$var_value\"; export $var; $relink_command"
5580         fi
5581       done
5582       # Quote the link command for shipping.
5583       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5584       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5585       if test "$hardcode_automatic" = yes ; then
5586         relink_command=
5587       fi
5588
5589
5590       # Only create the output if not a dry run.
5591       if test -z "$run"; then
5592         for installed in no yes; do
5593           if test "$installed" = yes; then
5594             if test -z "$install_libdir"; then
5595               break
5596             fi
5597             output="$output_objdir/$outputname"i
5598             # Replace all uninstalled libtool libraries with the installed ones
5599             newdependency_libs=
5600             for deplib in $dependency_libs; do
5601               case $deplib in
5602               *.la)
5603                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5604                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5605                 if test -z "$libdir"; then
5606                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5607                   exit $EXIT_FAILURE
5608                 fi
5609                 newdependency_libs="$newdependency_libs $libdir/$name"
5610                 ;;
5611               *) newdependency_libs="$newdependency_libs $deplib" ;;
5612               esac
5613             done
5614             dependency_libs="$newdependency_libs"
5615             newdlfiles=
5616             for lib in $dlfiles; do
5617               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5618               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5619               if test -z "$libdir"; then
5620                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5621                 exit $EXIT_FAILURE
5622               fi
5623               newdlfiles="$newdlfiles $libdir/$name"
5624             done
5625             dlfiles="$newdlfiles"
5626             newdlprefiles=
5627             for lib in $dlprefiles; do
5628               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5629               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5630               if test -z "$libdir"; then
5631                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5632                 exit $EXIT_FAILURE
5633               fi
5634               newdlprefiles="$newdlprefiles $libdir/$name"
5635             done
5636             dlprefiles="$newdlprefiles"
5637           else
5638             newdlfiles=
5639             for lib in $dlfiles; do
5640               case $lib in
5641                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5642                 *) abs=`pwd`"/$lib" ;;
5643               esac
5644               newdlfiles="$newdlfiles $abs"
5645             done
5646             dlfiles="$newdlfiles"
5647             newdlprefiles=
5648             for lib in $dlprefiles; do
5649               case $lib in
5650                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5651                 *) abs=`pwd`"/$lib" ;;
5652               esac
5653               newdlprefiles="$newdlprefiles $abs"
5654             done
5655             dlprefiles="$newdlprefiles"
5656           fi
5657           $rm $output
5658           # place dlname in correct position for cygwin
5659           tdlname=$dlname
5660           case $host,$output,$installed,$module,$dlname in
5661             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5662           esac
5663           $echo > $output "\
5664 # $outputname - a libtool library file
5665 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5666 #
5667 # Please DO NOT delete this file!
5668 # It is necessary for linking the library.
5669
5670 # The name that we can dlopen(3).
5671 dlname='$tdlname'
5672
5673 # Names of this library.
5674 library_names='$library_names'
5675
5676 # The name of the static archive.
5677 old_library='$old_library'
5678
5679 # Libraries that this one depends upon.
5680 dependency_libs='$dependency_libs'
5681
5682 # Version information for $libname.
5683 current=$current
5684 age=$age
5685 revision=$revision
5686
5687 # Is this an already installed library?
5688 installed=$installed
5689
5690 # Should we warn about portability when linking against -modules?
5691 shouldnotlink=$module
5692
5693 # Files to dlopen/dlpreopen
5694 dlopen='$dlfiles'
5695 dlpreopen='$dlprefiles'
5696
5697 # Directory that this library needs to be installed in:
5698 libdir='$install_libdir'"
5699           if test "$installed" = no && test "$need_relink" = yes; then
5700             $echo >> $output "\
5701 relink_command=\"$relink_command\""
5702           fi
5703         done
5704       fi
5705
5706       # Do a symbolic link so that the libtool archive can be found in
5707       # LD_LIBRARY_PATH before the program is installed.
5708       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5709       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5710       ;;
5711     esac
5712     exit $EXIT_SUCCESS
5713     ;;
5714
5715   # libtool install mode
5716   install)
5717     modename="$modename: install"
5718
5719     # There may be an optional sh(1) argument at the beginning of
5720     # install_prog (especially on Windows NT).
5721     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5722        # Allow the use of GNU shtool's install command.
5723        $echo "X$nonopt" | grep shtool > /dev/null; then
5724       # Aesthetically quote it.
5725       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5726       case $arg in
5727       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5728         arg="\"$arg\""
5729         ;;
5730       esac
5731       install_prog="$arg "
5732       arg="$1"
5733       shift
5734     else
5735       install_prog=
5736       arg=$nonopt
5737     fi
5738
5739     # The real first argument should be the name of the installation program.
5740     # Aesthetically quote it.
5741     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5742     case $arg in
5743     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5744       arg="\"$arg\""
5745       ;;
5746     esac
5747     install_prog="$install_prog$arg"
5748
5749     # We need to accept at least all the BSD install flags.
5750     dest=
5751     files=
5752     opts=
5753     prev=
5754     install_type=
5755     isdir=no
5756     stripme=
5757     for arg
5758     do
5759       if test -n "$dest"; then
5760         files="$files $dest"
5761         dest=$arg
5762         continue
5763       fi
5764
5765       case $arg in
5766       -d) isdir=yes ;;
5767       -f)
5768         case " $install_prog " in
5769         *[\\\ /]cp\ *) ;;
5770         *) prev=$arg ;;
5771         esac
5772         ;;
5773       -g | -m | -o) prev=$arg ;;
5774       -s)
5775         stripme=" -s"
5776         continue
5777         ;;
5778       -*)
5779         ;;
5780       *)
5781         # If the previous option needed an argument, then skip it.
5782         if test -n "$prev"; then
5783           prev=
5784         else
5785           dest=$arg
5786           continue
5787         fi
5788         ;;
5789       esac
5790
5791       # Aesthetically quote the argument.
5792       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5793       case $arg in
5794       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5795         arg="\"$arg\""
5796         ;;
5797       esac
5798       install_prog="$install_prog $arg"
5799     done
5800
5801     if test -z "$install_prog"; then
5802       $echo "$modename: you must specify an install program" 1>&2
5803       $echo "$help" 1>&2
5804       exit $EXIT_FAILURE
5805     fi
5806
5807     if test -n "$prev"; then
5808       $echo "$modename: the \`$prev' option requires an argument" 1>&2
5809       $echo "$help" 1>&2
5810       exit $EXIT_FAILURE
5811     fi
5812
5813     if test -z "$files"; then
5814       if test -z "$dest"; then
5815         $echo "$modename: no file or destination specified" 1>&2
5816       else
5817         $echo "$modename: you must specify a destination" 1>&2
5818       fi
5819       $echo "$help" 1>&2
5820       exit $EXIT_FAILURE
5821     fi
5822
5823     # Strip any trailing slash from the destination.
5824     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5825
5826     # Check to see that the destination is a directory.
5827     test -d "$dest" && isdir=yes
5828     if test "$isdir" = yes; then
5829       destdir="$dest"
5830       destname=
5831     else
5832       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5833       test "X$destdir" = "X$dest" && destdir=.
5834       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5835
5836       # Not a directory, so check to see that there is only one file specified.
5837       set dummy $files
5838       if test "$#" -gt 2; then
5839         $echo "$modename: \`$dest' is not a directory" 1>&2
5840         $echo "$help" 1>&2
5841         exit $EXIT_FAILURE
5842       fi
5843     fi
5844     case $destdir in
5845     [\\/]* | [A-Za-z]:[\\/]*) ;;
5846     *)
5847       for file in $files; do
5848         case $file in
5849         *.lo) ;;
5850         *)
5851           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5852           $echo "$help" 1>&2
5853           exit $EXIT_FAILURE
5854           ;;
5855         esac
5856       done
5857       ;;
5858     esac
5859
5860     # This variable tells wrapper scripts just to set variables rather
5861     # than running their programs.
5862     libtool_install_magic="$magic"
5863
5864     staticlibs=
5865     future_libdirs=
5866     current_libdirs=
5867     for file in $files; do
5868
5869       # Do each installation.
5870       case $file in
5871       *.$libext)
5872         # Do the static libraries later.
5873         staticlibs="$staticlibs $file"
5874         ;;
5875
5876       *.la)
5877         # Check to see that this really is a libtool archive.
5878         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5879         else
5880           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5881           $echo "$help" 1>&2
5882           exit $EXIT_FAILURE
5883         fi
5884
5885         library_names=
5886         old_library=
5887         relink_command=
5888         # If there is no directory component, then add one.
5889         case $file in
5890         */* | *\\*) . $file ;;
5891         *) . ./$file ;;
5892         esac
5893
5894         # Add the libdir to current_libdirs if it is the destination.
5895         if test "X$destdir" = "X$libdir"; then
5896           case "$current_libdirs " in
5897           *" $libdir "*) ;;
5898           *) current_libdirs="$current_libdirs $libdir" ;;
5899           esac
5900         else
5901           # Note the libdir as a future libdir.
5902           case "$future_libdirs " in
5903           *" $libdir "*) ;;
5904           *) future_libdirs="$future_libdirs $libdir" ;;
5905           esac
5906         fi
5907
5908         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5909         test "X$dir" = "X$file/" && dir=
5910         dir="$dir$objdir"
5911
5912         if test -n "$relink_command"; then
5913           # Determine the prefix the user has applied to our future dir.
5914           inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5915
5916           # Don't allow the user to place us outside of our expected
5917           # location b/c this prevents finding dependent libraries that
5918           # are installed to the same prefix.
5919           # At present, this check doesn't affect windows .dll's that
5920           # are installed into $libdir/../bin (currently, that works fine)
5921           # but it's something to keep an eye on.
5922           if test "$inst_prefix_dir" = "$destdir"; then
5923             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5924             exit $EXIT_FAILURE
5925           fi
5926
5927           if test -n "$inst_prefix_dir"; then
5928             # Stick the inst_prefix_dir data into the link command.
5929             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5930           else
5931             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5932           fi
5933
5934           $echo "$modename: warning: relinking \`$file'" 1>&2
5935           $show "$relink_command"
5936           if $run eval "$relink_command"; then :
5937           else
5938             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5939             exit $EXIT_FAILURE
5940           fi
5941         fi
5942
5943         # See the names of the shared library.
5944         set dummy $library_names
5945         if test -n "$2"; then
5946           realname="$2"
5947           shift
5948           shift
5949
5950           srcname="$realname"
5951           test -n "$relink_command" && srcname="$realname"T
5952
5953           # Install the shared library and build the symlinks.
5954           $show "$install_prog $dir/$srcname $destdir/$realname"
5955           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5956           if test -n "$stripme" && test -n "$striplib"; then
5957             $show "$striplib $destdir/$realname"
5958             $run eval "$striplib $destdir/$realname" || exit $?
5959           fi
5960
5961           if test "$#" -gt 0; then
5962             # Delete the old symlinks, and create new ones.
5963             # Try `ln -sf' first, because the `ln' binary might depend on
5964             # the symlink we replace!  Solaris /bin/ln does not understand -f,
5965             # so we also need to try rm && ln -s.
5966             for linkname
5967             do
5968               if test "$linkname" != "$realname"; then
5969                 $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5970                 $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5971               fi
5972             done
5973           fi
5974
5975           # Do each command in the postinstall commands.
5976           lib="$destdir/$realname"
5977           cmds=$postinstall_cmds
5978           save_ifs="$IFS"; IFS='~'
5979           for cmd in $cmds; do
5980             IFS="$save_ifs"
5981             eval cmd=\"$cmd\"
5982             $show "$cmd"
5983             $run eval "$cmd" || {
5984               lt_exit=$?
5985
5986               # Restore the uninstalled library and exit
5987               if test "$mode" = relink; then
5988                 $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
5989               fi
5990
5991               exit $lt_exit
5992             }
5993           done
5994           IFS="$save_ifs"
5995         fi
5996
5997         # Install the pseudo-library for information purposes.
5998         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5999         instname="$dir/$name"i
6000         $show "$install_prog $instname $destdir/$name"
6001         $run eval "$install_prog $instname $destdir/$name" || exit $?
6002
6003         # Maybe install the static library, too.
6004         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6005         ;;
6006
6007       *.lo)
6008         # Install (i.e. copy) a libtool object.
6009
6010         # Figure out destination file name, if it wasn't already specified.
6011         if test -n "$destname"; then
6012           destfile="$destdir/$destname"
6013         else
6014           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6015           destfile="$destdir/$destfile"
6016         fi
6017
6018         # Deduce the name of the destination old-style object file.
6019         case $destfile in
6020         *.lo)
6021           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6022           ;;
6023         *.$objext)
6024           staticdest="$destfile"
6025           destfile=
6026           ;;
6027         *)
6028           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6029           $echo "$help" 1>&2
6030           exit $EXIT_FAILURE
6031           ;;
6032         esac
6033
6034         # Install the libtool object if requested.
6035         if test -n "$destfile"; then
6036           $show "$install_prog $file $destfile"
6037           $run eval "$install_prog $file $destfile" || exit $?
6038         fi
6039
6040         # Install the old object if enabled.
6041         if test "$build_old_libs" = yes; then
6042           # Deduce the name of the old-style object file.
6043           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6044
6045           $show "$install_prog $staticobj $staticdest"
6046           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
6047         fi
6048         exit $EXIT_SUCCESS
6049         ;;
6050
6051       *)
6052         # Figure out destination file name, if it wasn't already specified.
6053         if test -n "$destname"; then
6054           destfile="$destdir/$destname"
6055         else
6056           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6057           destfile="$destdir/$destfile"
6058         fi
6059
6060         # If the file is missing, and there is a .exe on the end, strip it
6061         # because it is most likely a libtool script we actually want to
6062         # install
6063         stripped_ext=""
6064         case $file in
6065           *.exe)
6066             if test ! -f "$file"; then
6067               file=`$echo $file|${SED} 's,.exe$,,'`
6068               stripped_ext=".exe"
6069             fi
6070             ;;
6071         esac
6072
6073         # Do a test to see if this is really a libtool program.
6074         case $host in
6075         *cygwin*|*mingw*)
6076             wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6077             ;;
6078         *)
6079             wrapper=$file
6080             ;;
6081         esac
6082         if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6083           notinst_deplibs=
6084           relink_command=
6085
6086           # Note that it is not necessary on cygwin/mingw to append a dot to
6087           # foo even if both foo and FILE.exe exist: automatic-append-.exe
6088           # behavior happens only for exec(3), not for open(2)!  Also, sourcing
6089           # `FILE.' does not work on cygwin managed mounts.
6090           #
6091           # If there is no directory component, then add one.
6092           case $wrapper in
6093           */* | *\\*) . ${wrapper} ;;
6094           *) . ./${wrapper} ;;
6095           esac
6096
6097           # Check the variables that should have been set.
6098           if test -z "$notinst_deplibs"; then
6099             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6100             exit $EXIT_FAILURE
6101           fi
6102
6103           finalize=yes
6104           for lib in $notinst_deplibs; do
6105             # Check to see that each library is installed.
6106             libdir=
6107             if test -f "$lib"; then
6108               # If there is no directory component, then add one.
6109               case $lib in
6110               */* | *\\*) . $lib ;;
6111               *) . ./$lib ;;
6112               esac
6113             fi
6114             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6115             if test -n "$libdir" && test ! -f "$libfile"; then
6116               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6117               finalize=no
6118             fi
6119           done
6120
6121           relink_command=
6122           # Note that it is not necessary on cygwin/mingw to append a dot to
6123           # foo even if both foo and FILE.exe exist: automatic-append-.exe
6124           # behavior happens only for exec(3), not for open(2)!  Also, sourcing
6125           # `FILE.' does not work on cygwin managed mounts.
6126           #
6127           # If there is no directory component, then add one.
6128           case $wrapper in
6129           */* | *\\*) . ${wrapper} ;;
6130           *) . ./${wrapper} ;;
6131           esac
6132
6133           outputname=
6134           if test "$fast_install" = no && test -n "$relink_command"; then
6135             if test "$finalize" = yes && test -z "$run"; then
6136               tmpdir=`func_mktempdir`
6137               file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6138               outputname="$tmpdir/$file"
6139               # Replace the output file specification.
6140               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
6141
6142               $show "$relink_command"
6143               if $run eval "$relink_command"; then :
6144               else
6145                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6146                 ${rm}r "$tmpdir"
6147                 continue
6148               fi
6149               file="$outputname"
6150             else
6151               $echo "$modename: warning: cannot relink \`$file'" 1>&2
6152             fi
6153           else
6154             # Install the binary that we compiled earlier.
6155             file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6156           fi
6157         fi
6158
6159         # remove .exe since cygwin /usr/bin/install will append another
6160         # one anyway
6161         case $install_prog,$host in
6162         */usr/bin/install*,*cygwin*)
6163           case $file:$destfile in
6164           *.exe:*.exe)
6165             # this is ok
6166             ;;
6167           *.exe:*)
6168             destfile=$destfile.exe
6169             ;;
6170           *:*.exe)
6171             destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6172             ;;
6173           esac
6174           ;;
6175         esac
6176         $show "$install_prog$stripme $file $destfile"
6177         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6178         test -n "$outputname" && ${rm}r "$tmpdir"
6179         ;;
6180       esac
6181     done
6182
6183     for file in $staticlibs; do
6184       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6185
6186       # Set up the ranlib parameters.
6187       oldlib="$destdir/$name"
6188
6189       $show "$install_prog $file $oldlib"
6190       $run eval "$install_prog \$file \$oldlib" || exit $?
6191
6192       if test -n "$stripme" && test -n "$old_striplib"; then
6193         $show "$old_striplib $oldlib"
6194         $run eval "$old_striplib $oldlib" || exit $?
6195       fi
6196
6197       # Do each command in the postinstall commands.
6198       cmds=$old_postinstall_cmds
6199       save_ifs="$IFS"; IFS='~'
6200       for cmd in $cmds; do
6201         IFS="$save_ifs"
6202         eval cmd=\"$cmd\"
6203         $show "$cmd"
6204         $run eval "$cmd" || exit $?
6205       done
6206       IFS="$save_ifs"
6207     done
6208
6209     if test -n "$future_libdirs"; then
6210       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6211     fi
6212
6213     if test -n "$current_libdirs"; then
6214       # Maybe just do a dry run.
6215       test -n "$run" && current_libdirs=" -n$current_libdirs"
6216       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6217     else
6218       exit $EXIT_SUCCESS
6219     fi
6220     ;;
6221
6222   # libtool finish mode
6223   finish)
6224     modename="$modename: finish"
6225     libdirs="$nonopt"
6226     admincmds=
6227
6228     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6229       for dir
6230       do
6231         libdirs="$libdirs $dir"
6232       done
6233
6234       for libdir in $libdirs; do
6235         if test -n "$finish_cmds"; then
6236           # Do each command in the finish commands.
6237           cmds=$finish_cmds
6238           save_ifs="$IFS"; IFS='~'
6239           for cmd in $cmds; do
6240             IFS="$save_ifs"
6241             eval cmd=\"$cmd\"
6242             $show "$cmd"
6243             $run eval "$cmd" || admincmds="$admincmds
6244        $cmd"
6245           done
6246           IFS="$save_ifs"
6247         fi
6248         if test -n "$finish_eval"; then
6249           # Do the single finish_eval.
6250           eval cmds=\"$finish_eval\"
6251           $run eval "$cmds" || admincmds="$admincmds
6252        $cmds"
6253         fi
6254       done
6255     fi
6256
6257     # Exit here if they wanted silent mode.
6258     test "$show" = : && exit $EXIT_SUCCESS
6259
6260     $echo "X----------------------------------------------------------------------" | $Xsed
6261     $echo "Libraries have been installed in:"
6262     for libdir in $libdirs; do
6263       $echo "   $libdir"
6264     done
6265     $echo
6266     $echo "If you ever happen to want to link against installed libraries"
6267     $echo "in a given directory, LIBDIR, you must either use libtool, and"
6268     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6269     $echo "flag during linking and do at least one of the following:"
6270     if test -n "$shlibpath_var"; then
6271       $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
6272       $echo "     during execution"
6273     fi
6274     if test -n "$runpath_var"; then
6275       $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
6276       $echo "     during linking"
6277     fi
6278     if test -n "$hardcode_libdir_flag_spec"; then
6279       libdir=LIBDIR
6280       eval flag=\"$hardcode_libdir_flag_spec\"
6281
6282       $echo "   - use the \`$flag' linker flag"
6283     fi
6284     if test -n "$admincmds"; then
6285       $echo "   - have your system administrator run these commands:$admincmds"
6286     fi
6287     if test -f /etc/ld.so.conf; then
6288       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6289     fi
6290     $echo
6291     $echo "See any operating system documentation about shared libraries for"
6292     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
6293     $echo "X----------------------------------------------------------------------" | $Xsed
6294     exit $EXIT_SUCCESS
6295     ;;
6296
6297   # libtool execute mode
6298   execute)
6299     modename="$modename: execute"
6300
6301     # The first argument is the command name.
6302     cmd="$nonopt"
6303     if test -z "$cmd"; then
6304       $echo "$modename: you must specify a COMMAND" 1>&2
6305       $echo "$help"
6306       exit $EXIT_FAILURE
6307     fi
6308
6309     # Handle -dlopen flags immediately.
6310     for file in $execute_dlfiles; do
6311       if test ! -f "$file"; then
6312         $echo "$modename: \`$file' is not a file" 1>&2
6313         $echo "$help" 1>&2
6314         exit $EXIT_FAILURE
6315       fi
6316
6317       dir=
6318       case $file in
6319       *.la)
6320         # Check to see that this really is a libtool archive.
6321         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6322         else
6323           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6324           $echo "$help" 1>&2
6325           exit $EXIT_FAILURE
6326         fi
6327
6328         # Read the libtool library.
6329         dlname=
6330         library_names=
6331
6332         # If there is no directory component, then add one.
6333         case $file in
6334         */* | *\\*) . $file ;;
6335         *) . ./$file ;;
6336         esac
6337
6338         # Skip this library if it cannot be dlopened.
6339         if test -z "$dlname"; then
6340           # Warn if it was a shared library.
6341           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6342           continue
6343         fi
6344
6345         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6346         test "X$dir" = "X$file" && dir=.
6347
6348         if test -f "$dir/$objdir/$dlname"; then
6349           dir="$dir/$objdir"
6350         else
6351           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6352           exit $EXIT_FAILURE
6353         fi
6354         ;;
6355
6356       *.lo)
6357         # Just add the directory containing the .lo file.
6358         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6359         test "X$dir" = "X$file" && dir=.
6360         ;;
6361
6362       *)
6363         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6364         continue
6365         ;;
6366       esac
6367
6368       # Get the absolute pathname.
6369       absdir=`cd "$dir" && pwd`
6370       test -n "$absdir" && dir="$absdir"
6371
6372       # Now add the directory to shlibpath_var.
6373       if eval "test -z \"\$$shlibpath_var\""; then
6374         eval "$shlibpath_var=\"\$dir\""
6375       else
6376         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6377       fi
6378     done
6379
6380     # This variable tells wrapper scripts just to set shlibpath_var
6381     # rather than running their programs.
6382     libtool_execute_magic="$magic"
6383
6384     # Check if any of the arguments is a wrapper script.
6385     args=
6386     for file
6387     do
6388       case $file in
6389       -*) ;;
6390       *)
6391         # Do a test to see if this is really a libtool program.
6392         if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6393           # If there is no directory component, then add one.
6394           case $file in
6395           */* | *\\*) . $file ;;
6396           *) . ./$file ;;
6397           esac
6398
6399           # Transform arg to wrapped name.
6400           file="$progdir/$program"
6401         fi
6402         ;;
6403       esac
6404       # Quote arguments (to preserve shell metacharacters).
6405       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6406       args="$args \"$file\""
6407     done
6408
6409     if test -z "$run"; then
6410       if test -n "$shlibpath_var"; then
6411         # Export the shlibpath_var.
6412         eval "export $shlibpath_var"
6413       fi
6414
6415       # Restore saved environment variables
6416       if test "${save_LC_ALL+set}" = set; then
6417         LC_ALL="$save_LC_ALL"; export LC_ALL
6418       fi
6419       if test "${save_LANG+set}" = set; then
6420         LANG="$save_LANG"; export LANG
6421       fi
6422
6423       # Now prepare to actually exec the command.
6424       exec_cmd="\$cmd$args"
6425     else
6426       # Display what would be done.
6427       if test -n "$shlibpath_var"; then
6428         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6429         $echo "export $shlibpath_var"
6430       fi
6431       $echo "$cmd$args"
6432       exit $EXIT_SUCCESS
6433     fi
6434     ;;
6435
6436   # libtool clean and uninstall mode
6437   clean | uninstall)
6438     modename="$modename: $mode"
6439     rm="$nonopt"
6440     files=
6441     rmforce=
6442     exit_status=0
6443
6444     # This variable tells wrapper scripts just to set variables rather
6445     # than running their programs.
6446     libtool_install_magic="$magic"
6447
6448     for arg
6449     do
6450       case $arg in
6451       -f) rm="$rm $arg"; rmforce=yes ;;
6452       -*) rm="$rm $arg" ;;
6453       *) files="$files $arg" ;;
6454       esac
6455     done
6456
6457     if test -z "$rm"; then
6458       $echo "$modename: you must specify an RM program" 1>&2
6459       $echo "$help" 1>&2
6460       exit $EXIT_FAILURE
6461     fi
6462
6463     rmdirs=
6464
6465     origobjdir="$objdir"
6466     for file in $files; do
6467       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6468       if test "X$dir" = "X$file"; then
6469         dir=.
6470         objdir="$origobjdir"
6471       else
6472         objdir="$dir/$origobjdir"
6473       fi
6474       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6475       test "$mode" = uninstall && objdir="$dir"
6476
6477       # Remember objdir for removal later, being careful to avoid duplicates
6478       if test "$mode" = clean; then
6479         case " $rmdirs " in
6480           *" $objdir "*) ;;
6481           *) rmdirs="$rmdirs $objdir" ;;
6482         esac
6483       fi
6484
6485       # Don't error if the file doesn't exist and rm -f was used.
6486       if (test -L "$file") >/dev/null 2>&1 \
6487         || (test -h "$file") >/dev/null 2>&1 \
6488         || test -f "$file"; then
6489         :
6490       elif test -d "$file"; then
6491         exit_status=1
6492         continue
6493       elif test "$rmforce" = yes; then
6494         continue
6495       fi
6496
6497       rmfiles="$file"
6498
6499       case $name in
6500       *.la)
6501         # Possibly a libtool archive, so verify it.
6502         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6503           . $dir/$name
6504
6505           # Delete the libtool libraries and symlinks.
6506           for n in $library_names; do
6507             rmfiles="$rmfiles $objdir/$n"
6508           done
6509           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6510
6511           case "$mode" in
6512           clean)
6513             case "  $library_names " in
6514             # "  " in the beginning catches empty $dlname
6515             *" $dlname "*) ;;
6516             *) rmfiles="$rmfiles $objdir/$dlname" ;;
6517             esac
6518              test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
6519             ;;
6520           uninstall)
6521             if test -n "$library_names"; then
6522               # Do each command in the postuninstall commands.
6523               cmds=$postuninstall_cmds
6524               save_ifs="$IFS"; IFS='~'
6525               for cmd in $cmds; do
6526                 IFS="$save_ifs"
6527                 eval cmd=\"$cmd\"
6528                 $show "$cmd"
6529                 $run eval "$cmd"
6530                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6531                   exit_status=1
6532                 fi
6533               done
6534               IFS="$save_ifs"
6535             fi
6536
6537             if test -n "$old_library"; then
6538               # Do each command in the old_postuninstall commands.
6539               cmds=$old_postuninstall_cmds
6540               save_ifs="$IFS"; IFS='~'
6541               for cmd in $cmds; do
6542                 IFS="$save_ifs"
6543                 eval cmd=\"$cmd\"
6544                 $show "$cmd"
6545                 $run eval "$cmd"
6546                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6547                   exit_status=1
6548                 fi
6549               done
6550               IFS="$save_ifs"
6551             fi
6552             # FIXME: should reinstall the best remaining shared library.
6553             ;;
6554           esac
6555         fi
6556         ;;
6557
6558       *.lo)
6559         # Possibly a libtool object, so verify it.
6560         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6561
6562           # Read the .lo file
6563           . $dir/$name
6564
6565           # Add PIC object to the list of files to remove.
6566           if test -n "$pic_object" \
6567              && test "$pic_object" != none; then
6568             rmfiles="$rmfiles $dir/$pic_object"
6569           fi
6570
6571           # Add non-PIC object to the list of files to remove.
6572           if test -n "$non_pic_object" \
6573              && test "$non_pic_object" != none; then
6574             rmfiles="$rmfiles $dir/$non_pic_object"
6575           fi
6576         fi
6577         ;;
6578
6579       *)
6580         if test "$mode" = clean ; then
6581           noexename=$name
6582           case $file in
6583           *.exe)
6584             file=`$echo $file|${SED} 's,.exe$,,'`
6585             noexename=`$echo $name|${SED} 's,.exe$,,'`
6586             # $file with .exe has already been added to rmfiles,
6587             # add $file without .exe
6588             rmfiles="$rmfiles $file"
6589             ;;
6590           esac
6591           # Do a test to see if this is a libtool program.
6592           if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6593             relink_command=
6594             . $dir/$noexename
6595
6596             # note $name still contains .exe if it was in $file originally
6597             # as does the version of $file that was added into $rmfiles
6598             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
6599             if test "$fast_install" = yes && test -n "$relink_command"; then
6600               rmfiles="$rmfiles $objdir/lt-$name"
6601             fi
6602             if test "X$noexename" != "X$name" ; then
6603               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
6604             fi
6605           fi
6606         fi
6607         ;;
6608       esac
6609       $show "$rm $rmfiles"
6610       $run $rm $rmfiles || exit_status=1
6611     done
6612     objdir="$origobjdir"
6613
6614     # Try to remove the ${objdir}s in the directories where we deleted files
6615     for dir in $rmdirs; do
6616       if test -d "$dir"; then
6617         $show "rmdir $dir"
6618         $run rmdir $dir >/dev/null 2>&1
6619       fi
6620     done
6621
6622     exit $exit_status
6623     ;;
6624
6625   "")
6626     $echo "$modename: you must specify a MODE" 1>&2
6627     $echo "$generic_help" 1>&2
6628     exit $EXIT_FAILURE
6629     ;;
6630   esac
6631
6632   if test -z "$exec_cmd"; then
6633     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6634     $echo "$generic_help" 1>&2
6635     exit $EXIT_FAILURE
6636   fi
6637 fi # test -z "$show_help"
6638
6639 if test -n "$exec_cmd"; then
6640   eval exec $exec_cmd
6641   exit $EXIT_FAILURE
6642 fi
6643
6644 # We need to display help for each of the modes.
6645 case $mode in
6646 "") $echo \
6647 "Usage: $modename [OPTION]... [MODE-ARG]...
6648
6649 Provide generalized library-building support services.
6650
6651     --config          show all configuration variables
6652     --debug           enable verbose shell tracing
6653 -n, --dry-run         display commands without modifying any files
6654     --features        display basic configuration information and exit
6655     --finish          same as \`--mode=finish'
6656     --help            display this help message and exit
6657     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6658     --quiet           same as \`--silent'
6659     --silent          don't print informational messages
6660     --tag=TAG         use configuration variables from tag TAG
6661     --version         print version information
6662
6663 MODE must be one of the following:
6664
6665       clean           remove files from the build directory
6666       compile         compile a source file into a libtool object
6667       execute         automatically set library path, then run a program
6668       finish          complete the installation of libtool libraries
6669       install         install libraries or executables
6670       link            create a library or an executable
6671       uninstall       remove libraries from an installed directory
6672
6673 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6674 a more detailed description of MODE.
6675
6676 Report bugs to <bug-libtool@gnu.org>."
6677   exit $EXIT_SUCCESS
6678   ;;
6679
6680 clean)
6681   $echo \
6682 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6683
6684 Remove files from the build directory.
6685
6686 RM is the name of the program to use to delete files associated with each FILE
6687 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6688 to RM.
6689
6690 If FILE is a libtool library, object or program, all the files associated
6691 with it are deleted. Otherwise, only FILE itself is deleted using RM."
6692   ;;
6693
6694 compile)
6695   $echo \
6696 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6697
6698 Compile a source file into a libtool library object.
6699
6700 This mode accepts the following additional options:
6701
6702   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6703   -prefer-pic       try to building PIC objects only
6704   -prefer-non-pic   try to building non-PIC objects only
6705   -static           always build a \`.o' file suitable for static linking
6706
6707 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6708 from the given SOURCEFILE.
6709
6710 The output file name is determined by removing the directory component from
6711 SOURCEFILE, then substituting the C source code suffix \`.c' with the
6712 library object suffix, \`.lo'."
6713   ;;
6714
6715 execute)
6716   $echo \
6717 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6718
6719 Automatically set library path, then run a program.
6720
6721 This mode accepts the following additional options:
6722
6723   -dlopen FILE      add the directory containing FILE to the library path
6724
6725 This mode sets the library path environment variable according to \`-dlopen'
6726 flags.
6727
6728 If any of the ARGS are libtool executable wrappers, then they are translated
6729 into their corresponding uninstalled binary, and any of their required library
6730 directories are added to the library path.
6731
6732 Then, COMMAND is executed, with ARGS as arguments."
6733   ;;
6734
6735 finish)
6736   $echo \
6737 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6738
6739 Complete the installation of libtool libraries.
6740
6741 Each LIBDIR is a directory that contains libtool libraries.
6742
6743 The commands that this mode executes may require superuser privileges.  Use
6744 the \`--dry-run' option if you just want to see what would be executed."
6745   ;;
6746
6747 install)
6748   $echo \
6749 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6750
6751 Install executables or libraries.
6752
6753 INSTALL-COMMAND is the installation command.  The first component should be
6754 either the \`install' or \`cp' program.
6755
6756 The rest of the components are interpreted as arguments to that command (only
6757 BSD-compatible install options are recognized)."
6758   ;;
6759
6760 link)
6761   $echo \
6762 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6763
6764 Link object files or libraries together to form another library, or to
6765 create an executable program.
6766
6767 LINK-COMMAND is a command using the C compiler that you would use to create
6768 a program from several object files.
6769
6770 The following components of LINK-COMMAND are treated specially:
6771
6772   -all-static       do not do any dynamic linking at all
6773   -avoid-version    do not add a version suffix if possible
6774   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6775   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6776   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6777   -export-symbols SYMFILE
6778                     try to export only the symbols listed in SYMFILE
6779   -export-symbols-regex REGEX
6780                     try to export only the symbols matching REGEX
6781   -LLIBDIR          search LIBDIR for required installed libraries
6782   -lNAME            OUTPUT-FILE requires the installed library libNAME
6783   -module           build a library that can dlopened
6784   -no-fast-install  disable the fast-install mode
6785   -no-install       link a not-installable executable
6786   -no-undefined     declare that a library does not refer to external symbols
6787   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6788   -objectlist FILE  Use a list of object files found in FILE to specify objects
6789   -precious-files-regex REGEX
6790                     don't remove output files matching REGEX
6791   -release RELEASE  specify package release information
6792   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6793   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6794   -static           do not do any dynamic linking of libtool libraries
6795   -version-info CURRENT[:REVISION[:AGE]]
6796                     specify library version info [each variable defaults to 0]
6797
6798 All other options (arguments beginning with \`-') are ignored.
6799
6800 Every other argument is treated as a filename.  Files ending in \`.la' are
6801 treated as uninstalled libtool libraries, other files are standard or library
6802 object files.
6803
6804 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6805 only library objects (\`.lo' files) may be specified, and \`-rpath' is
6806 required, except when creating a convenience library.
6807
6808 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6809 using \`ar' and \`ranlib', or on Windows using \`lib'.
6810
6811 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6812 is created, otherwise an executable program is created."
6813   ;;
6814
6815 uninstall)
6816   $echo \
6817 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6818
6819 Remove libraries from an installation directory.
6820
6821 RM is the name of the program to use to delete files associated with each FILE
6822 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6823 to RM.
6824
6825 If FILE is a libtool library, all the files associated with it are deleted.
6826 Otherwise, only FILE itself is deleted using RM."
6827   ;;
6828
6829 *)
6830   $echo "$modename: invalid operation mode \`$mode'" 1>&2
6831   $echo "$help" 1>&2
6832   exit $EXIT_FAILURE
6833   ;;
6834 esac
6835
6836 $echo
6837 $echo "Try \`$modename --help' for more information about other modes."
6838
6839 exit $?
6840
6841 # The TAGs below are defined such that we never get into a situation
6842 # in which we disable both kinds of libraries.  Given conflicting
6843 # choices, we go for a static library, that is the most portable,
6844 # since we can't tell whether shared libraries were disabled because
6845 # the user asked for that or because the platform doesn't support
6846 # them.  This is particularly important on AIX, because we don't
6847 # support having both static and shared libraries enabled at the same
6848 # time on that platform, so we default to a shared-only configuration.
6849 # If a disable-shared tag is given, we'll fallback to a static-only
6850 # configuration.  But we'll never go from static-only to shared-only.
6851
6852 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6853 disable_libs=shared
6854 # ### END LIBTOOL TAG CONFIG: disable-shared
6855
6856 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
6857 disable_libs=static
6858 # ### END LIBTOOL TAG CONFIG: disable-static
6859
6860 # Local Variables:
6861 # mode:shell-script
6862 # sh-indentation:2
6863 # End: