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