ltmain.sh

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