build-scripts/ltmain.sh

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