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