ltmain.sh

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