ltmain.sh

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