git.maemo.org Git - guivpn/blob - trunk/vpngui/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.20
  47 TIMESTAMP=" (1.1220.2.287 2005/08/31 18:54:15)"
  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 X|tr X '\101'` in
  92  A) # ASCII based system
  93     # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
  94   SP2NL='tr \040 \012'
  95   NL2SP='tr \015\012 \040\040'
  96   ;;
  97  *) # EBCDIC based system
  98   SP2NL='tr \100 \n'
  99   NL2SP='tr \r\n \100\100'
 100   ;;
 101 esac
 102
 103 # NLS nuisances.
 104 # Only set LANG and LC_ALL to C if already set.
 105 # These must not be set unconditionally because not all systems understand
 106 # e.g. LANG=C (notably SCO).
 107 # We save the old values to restore during execute mode.
 108 if test "${LC_ALL+set}" = set; then
 109   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
 110 fi
 111 if test "${LANG+set}" = set; then
 112   save_LANG="$LANG"; LANG=C; export LANG
 113 fi
 114
 115 # Make sure IFS has a sensible default
 116 lt_nl='
 117 '
 118 IFS="   $lt_nl"
 119
 120 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 121   $echo "$modename: not configured to build any kind of library" 1>&2
 122   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 123   exit $EXIT_FAILURE
 124 fi
 125
 126 # Global variables.
 127 mode=$default_mode
 128 nonopt=
 129 prev=
 130 prevopt=
 131 run=
 132 show="$echo"
 133 show_help=
 134 execute_dlfiles=
 135 lo2o="s/\\.lo\$/.${objext}/"
 136 o2lo="s/\\.${objext}\$/.lo/"
 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           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
 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               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 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               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 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       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 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       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 741         qlibobj="\"$qlibobj\"" ;;
 742     esac
 743     test "X$libobj" != "X$qlibobj" \
 744         && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
 745         && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
 746     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 747     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 748     if test "X$xdir" = "X$obj"; then
 749       xdir=
 750     else
 751       xdir=$xdir/
 752     fi
 753     lobj=${xdir}$objdir/$objname
 754
 755     if test -z "$base_compile"; then
 756       $echo "$modename: you must specify a compilation command" 1>&2
 757       $echo "$help" 1>&2
 758       exit $EXIT_FAILURE
 759     fi
 760
 761     # Delete any leftover library objects.
 762     if test "$build_old_libs" = yes; then
 763       removelist="$obj $lobj $libobj ${libobj}T"
 764     else
 765       removelist="$lobj $libobj ${libobj}T"
 766     fi
 767
 768     $run $rm $removelist
 769     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 770
 771     # On Cygwin there's no "real" PIC flag so we must build both object types
 772     case $host_os in
 773     cygwin* | mingw* | pw32* | os2*)
 774       pic_mode=default
 775       ;;
 776     esac
 777     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
 778       # non-PIC code in shared libraries is not supported
 779       pic_mode=default
 780     fi
 781
 782     # Calculate the filename of the output object if compiler does
 783     # not support -o with -c
 784     if test "$compiler_c_o" = no; then
 785       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 786       lockfile="$output_obj.lock"
 787       removelist="$removelist $output_obj $lockfile"
 788       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 789     else
 790       output_obj=
 791       need_locks=no
 792       lockfile=
 793     fi
 794
 795     # Lock this critical section if it is needed
 796     # We use this script file to make the link, it avoids creating a new file
 797     if test "$need_locks" = yes; then
 798       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
 799         $show "Waiting for $lockfile to be removed"
 800         sleep 2
 801       done
 802     elif test "$need_locks" = warn; then
 803       if test -f "$lockfile"; then
 804         $echo "\
 805 *** ERROR, $lockfile exists and contains:
 806 `cat $lockfile 2>/dev/null`
 807
 808 This indicates that another process is trying to use the same
 809 temporary object file, and libtool could not work around it because
 810 your compiler does not support \`-c' and \`-o' together.  If you
 811 repeat this compilation, it may succeed, by chance, but you had better
 812 avoid parallel builds (make -j) in this platform, or get a better
 813 compiler."
 814
 815         $run $rm $removelist
 816         exit $EXIT_FAILURE
 817       fi
 818       $echo "$srcfile" > "$lockfile"
 819     fi
 820
 821     if test -n "$fix_srcfile_path"; then
 822       eval srcfile=\"$fix_srcfile_path\"
 823     fi
 824     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
 825     case $qsrcfile in
 826       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 827       qsrcfile="\"$qsrcfile\"" ;;
 828     esac
 829
 830     $run $rm "$libobj" "${libobj}T"
 831
 832     # Create a libtool object file (analogous to a ".la" file),
 833     # but don't create it if we're doing a dry run.
 834     test -z "$run" && cat > ${libobj}T <<EOF
 835 # $libobj - a libtool object file
 836 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 837 #
 838 # Please DO NOT delete this file!
 839 # It is necessary for linking the library.
 840
 841 # Name of the PIC object.
 842 EOF
 843
 844     # Only build a PIC object if we are building libtool libraries.
 845     if test "$build_libtool_libs" = yes; then
 846       # Without this assignment, base_compile gets emptied.
 847       fbsd_hideous_sh_bug=$base_compile
 848
 849       if test "$pic_mode" != no; then
 850         command="$base_compile $qsrcfile $pic_flag"
 851       else
 852         # Don't build PIC code
 853         command="$base_compile $qsrcfile"
 854       fi
 855
 856       if test ! -d "${xdir}$objdir"; then
 857         $show "$mkdir ${xdir}$objdir"
 858         $run $mkdir ${xdir}$objdir
 859         status=$?
 860         if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
 861           exit $status
 862         fi
 863       fi
 864
 865       if test -z "$output_obj"; then
 866         # Place PIC objects in $objdir
 867         command="$command -o $lobj"
 868       fi
 869
 870       $run $rm "$lobj" "$output_obj"
 871
 872       $show "$command"
 873       if $run eval "$command"; then :
 874       else
 875         test -n "$output_obj" && $run $rm $removelist
 876         exit $EXIT_FAILURE
 877       fi
 878
 879       if test "$need_locks" = warn &&
 880          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 881         $echo "\
 882 *** ERROR, $lockfile contains:
 883 `cat $lockfile 2>/dev/null`
 884
 885 but it should contain:
 886 $srcfile
 887
 888 This indicates that another process is trying to use the same
 889 temporary object file, and libtool could not work around it because
 890 your compiler does not support \`-c' and \`-o' together.  If you
 891 repeat this compilation, it may succeed, by chance, but you had better
 892 avoid parallel builds (make -j) in this platform, or get a better
 893 compiler."
 894
 895         $run $rm $removelist
 896         exit $EXIT_FAILURE
 897       fi
 898
 899       # Just move the object if needed, then go on to compile the next one
 900       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
 901         $show "$mv $output_obj $lobj"
 902         if $run $mv $output_obj $lobj; then :
 903         else
 904           error=$?
 905           $run $rm $removelist
 906           exit $error
 907         fi
 908       fi
 909
 910       # Append the name of the PIC object to the libtool object file.
 911       test -z "$run" && cat >> ${libobj}T <<EOF
 912 pic_object='$objdir/$objname'
 913
 914 EOF
 915
 916       # Allow error messages only from the first compilation.
 917       if test "$suppress_opt" = yes; then
 918         suppress_output=' >/dev/null 2>&1'
 919       fi
 920     else
 921       # No PIC object so indicate it doesn't exist in the libtool
 922       # object file.
 923       test -z "$run" && cat >> ${libobj}T <<EOF
 924 pic_object=none
 925
 926 EOF
 927     fi
 928
 929     # Only build a position-dependent object if we build old libraries.
 930     if test "$build_old_libs" = yes; then
 931       if test "$pic_mode" != yes; then
 932         # Don't build PIC code
 933         command="$base_compile $qsrcfile"
 934       else
 935         command="$base_compile $qsrcfile $pic_flag"
 936       fi
 937       if test "$compiler_c_o" = yes; then
 938         command="$command -o $obj"
 939       fi
 940
 941       # Suppress compiler output if we already did a PIC compilation.
 942       command="$command$suppress_output"
 943       $run $rm "$obj" "$output_obj"
 944       $show "$command"
 945       if $run eval "$command"; then :
 946       else
 947         $run $rm $removelist
 948         exit $EXIT_FAILURE
 949       fi
 950
 951       if test "$need_locks" = warn &&
 952          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 953         $echo "\
 954 *** ERROR, $lockfile contains:
 955 `cat $lockfile 2>/dev/null`
 956
 957 but it should contain:
 958 $srcfile
 959
 960 This indicates that another process is trying to use the same
 961 temporary object file, and libtool could not work around it because
 962 your compiler does not support \`-c' and \`-o' together.  If you
 963 repeat this compilation, it may succeed, by chance, but you had better
 964 avoid parallel builds (make -j) in this platform, or get a better
 965 compiler."
 966
 967         $run $rm $removelist
 968         exit $EXIT_FAILURE
 969       fi
 970
 971       # Just move the object if needed
 972       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 973         $show "$mv $output_obj $obj"
 974         if $run $mv $output_obj $obj; then :
 975         else
 976           error=$?
 977           $run $rm $removelist
 978           exit $error
 979         fi
 980       fi
 981
 982       # Append the name of the non-PIC object the libtool object file.
 983       # Only append if the libtool object file exists.
 984       test -z "$run" && cat >> ${libobj}T <<EOF
 985 # Name of the non-PIC object.
 986 non_pic_object='$objname'
 987
 988 EOF
 989     else
 990       # Append the name of the non-PIC object the libtool object file.
 991       # Only append if the libtool object file exists.
 992       test -z "$run" && cat >> ${libobj}T <<EOF
 993 # Name of the non-PIC object.
 994 non_pic_object=none
 995
 996 EOF
 997     fi
 998
 999     $run $mv "${libobj}T" "${libobj}"
1000
1001     # Unlock the critical section if it was locked
1002     if test "$need_locks" != no; then
1003       $run $rm "$lockfile"
1004     fi
1005
1006     exit $EXIT_SUCCESS
1007     ;;
1008
1009   # libtool link mode
1010   link | relink)
1011     modename="$modename: link"
1012     case $host in
1013     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1014       # It is impossible to link a dll without this setting, and
1015       # we shouldn't force the makefile maintainer to figure out
1016       # which system we are compiling for in order to pass an extra
1017       # flag for every libtool invocation.
1018       # allow_undefined=no
1019
1020       # FIXME: Unfortunately, there are problems with the above when trying
1021       # to make a dll which has undefined symbols, in which case not
1022       # even a static library is built.  For now, we need to specify
1023       # -no-undefined on the libtool link line when we can be certain
1024       # that all symbols are satisfied, otherwise we get a static library.
1025       allow_undefined=yes
1026       ;;
1027     *)
1028       allow_undefined=yes
1029       ;;
1030     esac
1031     libtool_args="$nonopt"
1032     base_compile="$nonopt $@"
1033     compile_command="$nonopt"
1034     finalize_command="$nonopt"
1035
1036     compile_rpath=
1037     finalize_rpath=
1038     compile_shlibpath=
1039     finalize_shlibpath=
1040     convenience=
1041     old_convenience=
1042     deplibs=
1043     old_deplibs=
1044     compiler_flags=
1045     linker_flags=
1046     dllsearchpath=
1047     lib_search_path=`pwd`
1048     inst_prefix_dir=
1049
1050     avoid_version=no
1051     dlfiles=
1052     dlprefiles=
1053     dlself=no
1054     export_dynamic=no
1055     export_symbols=
1056     export_symbols_regex=
1057     generated=
1058     libobjs=
1059     ltlibs=
1060     module=no
1061     no_install=no
1062     objs=
1063     non_pic_objects=
1064     precious_files_regex=
1065     prefer_static_libs=no
1066     preload=no
1067     prev=
1068     prevarg=
1069     release=
1070     rpath=
1071     xrpath=
1072     perm_rpath=
1073     temp_rpath=
1074     thread_safe=no
1075     vinfo=
1076     vinfo_number=no
1077
1078     func_infer_tag $base_compile
1079
1080     # We need to know -static, to get the right output filenames.
1081     for arg
1082     do
1083       case $arg in
1084       -all-static | -static)
1085         if test "X$arg" = "X-all-static"; then
1086           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1087             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1088           fi
1089           if test -n "$link_static_flag"; then
1090             dlopen_self=$dlopen_self_static
1091           fi
1092         else
1093           if test -z "$pic_flag" && test -n "$link_static_flag"; then
1094             dlopen_self=$dlopen_self_static
1095           fi
1096         fi
1097         build_libtool_libs=no
1098         build_old_libs=yes
1099         prefer_static_libs=yes
1100         break
1101         ;;
1102       esac
1103     done
1104
1105     # See if our shared archives depend on static archives.
1106     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1107
1108     # Go through the arguments, transforming them on the way.
1109     while test "$#" -gt 0; do
1110       arg="$1"
1111       shift
1112       case $arg in
1113       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1114         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1115         ;;
1116       *) qarg=$arg ;;
1117       esac
1118       libtool_args="$libtool_args $qarg"
1119
1120       # If the previous option needs an argument, assign it.
1121       if test -n "$prev"; then
1122         case $prev in
1123         output)
1124           compile_command="$compile_command @OUTPUT@"
1125           finalize_command="$finalize_command @OUTPUT@"
1126           ;;
1127         esac
1128
1129         case $prev in
1130         dlfiles|dlprefiles)
1131           if test "$preload" = no; then
1132             # Add the symbol object into the linking commands.
1133             compile_command="$compile_command @SYMFILE@"
1134             finalize_command="$finalize_command @SYMFILE@"
1135             preload=yes
1136           fi
1137           case $arg in
1138           *.la | *.lo) ;;  # We handle these cases below.
1139           force)
1140             if test "$dlself" = no; then
1141               dlself=needless
1142               export_dynamic=yes
1143             fi
1144             prev=
1145             continue
1146             ;;
1147           self)
1148             if test "$prev" = dlprefiles; then
1149               dlself=yes
1150             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1151               dlself=yes
1152             else
1153               dlself=needless
1154               export_dynamic=yes
1155             fi
1156             prev=
1157             continue
1158             ;;
1159           *)
1160             if test "$prev" = dlfiles; then
1161               dlfiles="$dlfiles $arg"
1162             else
1163               dlprefiles="$dlprefiles $arg"
1164             fi
1165             prev=
1166             continue
1167             ;;
1168           esac
1169           ;;
1170         expsyms)
1171           export_symbols="$arg"
1172           if test ! -f "$arg"; then
1173             $echo "$modename: symbol file \`$arg' does not exist"
1174             exit $EXIT_FAILURE
1175           fi
1176           prev=
1177           continue
1178           ;;
1179         expsyms_regex)
1180           export_symbols_regex="$arg"
1181           prev=
1182           continue
1183           ;;
1184         inst_prefix)
1185           inst_prefix_dir="$arg"
1186           prev=
1187           continue
1188           ;;
1189         precious_regex)
1190           precious_files_regex="$arg"
1191           prev=
1192           continue
1193           ;;
1194         release)
1195           release="-$arg"
1196           prev=
1197           continue
1198           ;;
1199         objectlist)
1200           if test -f "$arg"; then
1201             save_arg=$arg
1202             moreargs=
1203             for fil in `cat $save_arg`
1204             do
1205 #             moreargs="$moreargs $fil"
1206               arg=$fil
1207               # A libtool-controlled object.
1208
1209               # Check to see that this really is a libtool object.
1210               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1211                 pic_object=
1212                 non_pic_object=
1213
1214                 # Read the .lo file
1215                 # If there is no directory component, then add one.
1216                 case $arg in
1217                 */* | *\\*) . $arg ;;
1218                 *) . ./$arg ;;
1219                 esac
1220
1221                 if test -z "$pic_object" || \
1222                    test -z "$non_pic_object" ||
1223                    test "$pic_object" = none && \
1224                    test "$non_pic_object" = none; then
1225                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1226                   exit $EXIT_FAILURE
1227                 fi
1228
1229                 # Extract subdirectory from the argument.
1230                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1231                 if test "X$xdir" = "X$arg"; then
1232                   xdir=
1233                 else
1234                   xdir="$xdir/"
1235                 fi
1236
1237                 if test "$pic_object" != none; then
1238                   # Prepend the subdirectory the object is found in.
1239                   pic_object="$xdir$pic_object"
1240
1241                   if test "$prev" = dlfiles; then
1242                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1243                       dlfiles="$dlfiles $pic_object"
1244                       prev=
1245                       continue
1246                     else
1247                       # If libtool objects are unsupported, then we need to preload.
1248                       prev=dlprefiles
1249                     fi
1250                   fi
1251
1252                   # CHECK ME:  I think I busted this.  -Ossama
1253                   if test "$prev" = dlprefiles; then
1254                     # Preload the old-style object.
1255                     dlprefiles="$dlprefiles $pic_object"
1256                     prev=
1257                   fi
1258
1259                   # A PIC object.
1260                   libobjs="$libobjs $pic_object"
1261                   arg="$pic_object"
1262                 fi
1263
1264                 # Non-PIC object.
1265                 if test "$non_pic_object" != none; then
1266                   # Prepend the subdirectory the object is found in.
1267                   non_pic_object="$xdir$non_pic_object"
1268
1269                   # A standard non-PIC object
1270                   non_pic_objects="$non_pic_objects $non_pic_object"
1271                   if test -z "$pic_object" || test "$pic_object" = none ; then
1272                     arg="$non_pic_object"
1273                   fi
1274                 fi
1275               else
1276                 # Only an error if not doing a dry-run.
1277                 if test -z "$run"; then
1278                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1279                   exit $EXIT_FAILURE
1280                 else
1281                   # Dry-run case.
1282
1283                   # Extract subdirectory from the argument.
1284                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1285                   if test "X$xdir" = "X$arg"; then
1286                     xdir=
1287                   else
1288                     xdir="$xdir/"
1289                   fi
1290
1291                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1292                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1293                   libobjs="$libobjs $pic_object"
1294                   non_pic_objects="$non_pic_objects $non_pic_object"
1295                 fi
1296               fi
1297             done
1298           else
1299             $echo "$modename: link input file \`$save_arg' does not exist"
1300             exit $EXIT_FAILURE
1301           fi
1302           arg=$save_arg
1303           prev=
1304           continue
1305           ;;
1306         rpath | xrpath)
1307           # We need an absolute path.
1308           case $arg in
1309           [\\/]* | [A-Za-z]:[\\/]*) ;;
1310           *)
1311             $echo "$modename: only absolute run-paths are allowed" 1>&2
1312             exit $EXIT_FAILURE
1313             ;;
1314           esac
1315           if test "$prev" = rpath; then
1316             case "$rpath " in
1317             *" $arg "*) ;;
1318             *) rpath="$rpath $arg" ;;
1319             esac
1320           else
1321             case "$xrpath " in
1322             *" $arg "*) ;;
1323             *) xrpath="$xrpath $arg" ;;
1324             esac
1325           fi
1326           prev=
1327           continue
1328           ;;
1329         xcompiler)
1330           compiler_flags="$compiler_flags $qarg"
1331           prev=
1332           compile_command="$compile_command $qarg"
1333           finalize_command="$finalize_command $qarg"
1334           continue
1335           ;;
1336         xlinker)
1337           linker_flags="$linker_flags $qarg"
1338           compiler_flags="$compiler_flags $wl$qarg"
1339           prev=
1340           compile_command="$compile_command $wl$qarg"
1341           finalize_command="$finalize_command $wl$qarg"
1342           continue
1343           ;;
1344         xcclinker)
1345           linker_flags="$linker_flags $qarg"
1346           compiler_flags="$compiler_flags $qarg"
1347           prev=
1348           compile_command="$compile_command $qarg"
1349           finalize_command="$finalize_command $qarg"
1350           continue
1351           ;;
1352         shrext)
1353           shrext_cmds="$arg"
1354           prev=
1355           continue
1356           ;;
1357         darwin_framework)
1358           compiler_flags="$compiler_flags $arg"
1359           compile_command="$compile_command $arg"
1360           finalize_command="$finalize_command $arg"
1361           prev=
1362           continue
1363           ;;
1364         *)
1365           eval "$prev=\"\$arg\""
1366           prev=
1367           continue
1368           ;;
1369         esac
1370       fi # test -n "$prev"
1371
1372       prevarg="$arg"
1373
1374       case $arg in
1375       -all-static)
1376         if test -n "$link_static_flag"; then
1377           compile_command="$compile_command $link_static_flag"
1378           finalize_command="$finalize_command $link_static_flag"
1379         fi
1380         continue
1381         ;;
1382
1383       -allow-undefined)
1384         # FIXME: remove this flag sometime in the future.
1385         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1386         continue
1387         ;;
1388
1389       -avoid-version)
1390         avoid_version=yes
1391         continue
1392         ;;
1393
1394       -dlopen)
1395         prev=dlfiles
1396         continue
1397         ;;
1398
1399       -dlpreopen)
1400         prev=dlprefiles
1401         continue
1402         ;;
1403
1404       -export-dynamic)
1405         export_dynamic=yes
1406         continue
1407         ;;
1408
1409       -export-symbols | -export-symbols-regex)
1410         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1411           $echo "$modename: more than one -exported-symbols argument is not allowed"
1412           exit $EXIT_FAILURE
1413         fi
1414         if test "X$arg" = "X-export-symbols"; then
1415           prev=expsyms
1416         else
1417           prev=expsyms_regex
1418         fi
1419         continue
1420         ;;
1421
1422       -framework|-arch)
1423         prev=darwin_framework
1424         compiler_flags="$compiler_flags $arg"
1425         compile_command="$compile_command $arg"
1426         finalize_command="$finalize_command $arg"
1427         continue
1428         ;;
1429
1430       -inst-prefix-dir)
1431         prev=inst_prefix
1432         continue
1433         ;;
1434
1435       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1436       # so, if we see these flags be careful not to treat them like -L
1437       -L[A-Z][A-Z]*:*)
1438         case $with_gcc/$host in
1439         no/*-*-irix* | /*-*-irix*)
1440           compile_command="$compile_command $arg"
1441           finalize_command="$finalize_command $arg"
1442           ;;
1443         esac
1444         continue
1445         ;;
1446
1447       -L*)
1448         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1449         # We need an absolute path.
1450         case $dir in
1451         [\\/]* | [A-Za-z]:[\\/]*) ;;
1452         *)
1453           absdir=`cd "$dir" && pwd`
1454           if test -z "$absdir"; then
1455             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1456             exit $EXIT_FAILURE
1457           fi
1458           dir="$absdir"
1459           ;;
1460         esac
1461         case "$deplibs " in
1462         *" -L$dir "*) ;;
1463         *)
1464           deplibs="$deplibs -L$dir"
1465           lib_search_path="$lib_search_path $dir"
1466           ;;
1467         esac
1468         case $host in
1469         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1470           case :$dllsearchpath: in
1471           *":$dir:"*) ;;
1472           *) dllsearchpath="$dllsearchpath:$dir";;
1473           esac
1474           ;;
1475         esac
1476         continue
1477         ;;
1478
1479       -l*)
1480         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1481           case $host in
1482           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1483             # These systems don't actually have a C or math library (as such)
1484             continue
1485             ;;
1486           *-*-mingw* | *-*-os2*)
1487             # These systems don't actually have a C library (as such)
1488             test "X$arg" = "X-lc" && continue
1489             ;;
1490           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1491             # Do not include libc due to us having libc/libc_r.
1492             test "X$arg" = "X-lc" && continue
1493             ;;
1494           *-*-rhapsody* | *-*-darwin1.[012])
1495             # Rhapsody C and math libraries are in the System framework
1496             deplibs="$deplibs -framework System"
1497             continue
1498           esac
1499         elif test "X$arg" = "X-lc_r"; then
1500          case $host in
1501          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1502            # Do not include libc_r directly, use -pthread flag.
1503            continue
1504            ;;
1505          esac
1506         fi
1507         deplibs="$deplibs $arg"
1508         continue
1509         ;;
1510
1511       # Tru64 UNIX uses -model [arg] to determine the layout of C++
1512       # classes, name mangling, and exception handling.
1513       -model)
1514         compile_command="$compile_command $arg"
1515         compiler_flags="$compiler_flags $arg"
1516         finalize_command="$finalize_command $arg"
1517         prev=xcompiler
1518         continue
1519         ;;
1520
1521      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1522         compiler_flags="$compiler_flags $arg"
1523         compile_command="$compile_command $arg"
1524         finalize_command="$finalize_command $arg"
1525         continue
1526         ;;
1527
1528       -module)
1529         module=yes
1530         continue
1531         ;;
1532
1533       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1534       # -r[0-9][0-9]* specifies the processor on the SGI compiler
1535       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1536       # +DA*, +DD* enable 64-bit mode on the HP compiler
1537       # -q* pass through compiler args for the IBM compiler
1538       # -m* pass through architecture-specific compiler args for GCC
1539       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*)
1540
1541         # Unknown arguments in both finalize_command and compile_command need
1542         # to be aesthetically quoted because they are evaled later.
1543         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1544         case $arg in
1545         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1546           arg="\"$arg\""
1547           ;;
1548         esac
1549         compile_command="$compile_command $arg"
1550         finalize_command="$finalize_command $arg"
1551         if test "$with_gcc" = "yes" ; then
1552           compiler_flags="$compiler_flags $arg"
1553         fi
1554         continue
1555         ;;
1556
1557       -shrext)
1558         prev=shrext
1559         continue
1560         ;;
1561
1562       -no-fast-install)
1563         fast_install=no
1564         continue
1565         ;;
1566
1567       -no-install)
1568         case $host in
1569         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1570           # The PATH hackery in wrapper scripts is required on Windows
1571           # in order for the loader to find any dlls it needs.
1572           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1573           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1574           fast_install=no
1575           ;;
1576         *) no_install=yes ;;
1577         esac
1578         continue
1579         ;;
1580
1581       -no-undefined)
1582         allow_undefined=no
1583         continue
1584         ;;
1585
1586       -objectlist)
1587         prev=objectlist
1588         continue
1589         ;;
1590
1591       -o) prev=output ;;
1592
1593       -precious-files-regex)
1594         prev=precious_regex
1595         continue
1596         ;;
1597
1598       -release)
1599         prev=release
1600         continue
1601         ;;
1602
1603       -rpath)
1604         prev=rpath
1605         continue
1606         ;;
1607
1608       -R)
1609         prev=xrpath
1610         continue
1611         ;;
1612
1613       -R*)
1614         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1615         # We need an absolute path.
1616         case $dir in
1617         [\\/]* | [A-Za-z]:[\\/]*) ;;
1618         *)
1619           $echo "$modename: only absolute run-paths are allowed" 1>&2
1620           exit $EXIT_FAILURE
1621           ;;
1622         esac
1623         case "$xrpath " in
1624         *" $dir "*) ;;
1625         *) xrpath="$xrpath $dir" ;;
1626         esac
1627         continue
1628         ;;
1629
1630       -static)
1631         # The effects of -static are defined in a previous loop.
1632         # We used to do the same as -all-static on platforms that
1633         # didn't have a PIC flag, but the assumption that the effects
1634         # would be equivalent was wrong.  It would break on at least
1635         # Digital Unix and AIX.
1636         continue
1637         ;;
1638
1639       -thread-safe)
1640         thread_safe=yes
1641         continue
1642         ;;
1643
1644       -version-info)
1645         prev=vinfo
1646         continue
1647         ;;
1648       -version-number)
1649         prev=vinfo
1650         vinfo_number=yes
1651         continue
1652         ;;
1653
1654       -Wc,*)
1655         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1656         arg=
1657         save_ifs="$IFS"; IFS=','
1658         for flag in $args; do
1659           IFS="$save_ifs"
1660           case $flag in
1661             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1662             flag="\"$flag\""
1663             ;;
1664           esac
1665           arg="$arg $wl$flag"
1666           compiler_flags="$compiler_flags $flag"
1667         done
1668         IFS="$save_ifs"
1669         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1670         ;;
1671
1672       -Wl,*)
1673         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1674         arg=
1675         save_ifs="$IFS"; IFS=','
1676         for flag in $args; do
1677           IFS="$save_ifs"
1678           case $flag in
1679             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1680             flag="\"$flag\""
1681             ;;
1682           esac
1683           arg="$arg $wl$flag"
1684           compiler_flags="$compiler_flags $wl$flag"
1685           linker_flags="$linker_flags $flag"
1686         done
1687         IFS="$save_ifs"
1688         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1689         ;;
1690
1691       -Xcompiler)
1692         prev=xcompiler
1693         continue
1694         ;;
1695
1696       -Xlinker)
1697         prev=xlinker
1698         continue
1699         ;;
1700
1701       -XCClinker)
1702         prev=xcclinker
1703         continue
1704         ;;
1705
1706       # Some other compiler flag.
1707       -* | +*)
1708         # Unknown arguments in both finalize_command and compile_command need
1709         # to be aesthetically quoted because they are evaled later.
1710         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1711         case $arg in
1712         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1713           arg="\"$arg\""
1714           ;;
1715         esac
1716         ;;
1717
1718       *.$objext)
1719         # A standard object.
1720         objs="$objs $arg"
1721         ;;
1722
1723       *.lo)
1724         # A libtool-controlled object.
1725
1726         # Check to see that this really is a libtool object.
1727         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1728           pic_object=
1729           non_pic_object=
1730
1731           # Read the .lo file
1732           # If there is no directory component, then add one.
1733           case $arg in
1734           */* | *\\*) . $arg ;;
1735           *) . ./$arg ;;
1736           esac
1737
1738           if test -z "$pic_object" || \
1739              test -z "$non_pic_object" ||
1740              test "$pic_object" = none && \
1741              test "$non_pic_object" = none; then
1742             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1743             exit $EXIT_FAILURE
1744           fi
1745
1746           # Extract subdirectory from the argument.
1747           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1748           if test "X$xdir" = "X$arg"; then
1749             xdir=
1750           else
1751             xdir="$xdir/"
1752           fi
1753
1754           if test "$pic_object" != none; then
1755             # Prepend the subdirectory the object is found in.
1756             pic_object="$xdir$pic_object"
1757
1758             if test "$prev" = dlfiles; then
1759               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1760                 dlfiles="$dlfiles $pic_object"
1761                 prev=
1762                 continue
1763               else
1764                 # If libtool objects are unsupported, then we need to preload.
1765                 prev=dlprefiles
1766               fi
1767             fi
1768
1769             # CHECK ME:  I think I busted this.  -Ossama
1770             if test "$prev" = dlprefiles; then
1771               # Preload the old-style object.
1772               dlprefiles="$dlprefiles $pic_object"
1773               prev=
1774             fi
1775
1776             # A PIC object.
1777             libobjs="$libobjs $pic_object"
1778             arg="$pic_object"
1779           fi
1780
1781           # Non-PIC object.
1782           if test "$non_pic_object" != none; then
1783             # Prepend the subdirectory the object is found in.
1784             non_pic_object="$xdir$non_pic_object"
1785
1786             # A standard non-PIC object
1787             non_pic_objects="$non_pic_objects $non_pic_object"
1788             if test -z "$pic_object" || test "$pic_object" = none ; then
1789               arg="$non_pic_object"
1790             fi
1791           fi
1792         else
1793           # Only an error if not doing a dry-run.
1794           if test -z "$run"; then
1795             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1796             exit $EXIT_FAILURE
1797           else
1798             # Dry-run case.
1799
1800             # Extract subdirectory from the argument.
1801             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1802             if test "X$xdir" = "X$arg"; then
1803               xdir=
1804             else
1805               xdir="$xdir/"
1806             fi
1807
1808             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1809             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1810             libobjs="$libobjs $pic_object"
1811             non_pic_objects="$non_pic_objects $non_pic_object"
1812           fi
1813         fi
1814         ;;
1815
1816       *.$libext)
1817         # An archive.
1818         deplibs="$deplibs $arg"
1819         old_deplibs="$old_deplibs $arg"
1820         continue
1821         ;;
1822
1823       *.la)
1824         # A libtool-controlled library.
1825
1826         if test "$prev" = dlfiles; then
1827           # This library was specified with -dlopen.
1828           dlfiles="$dlfiles $arg"
1829           prev=
1830         elif test "$prev" = dlprefiles; then
1831           # The library was specified with -dlpreopen.
1832           dlprefiles="$dlprefiles $arg"
1833           prev=
1834         else
1835           deplibs="$deplibs $arg"
1836         fi
1837         continue
1838         ;;
1839
1840       # Some other compiler argument.
1841       *)
1842         # Unknown arguments in both finalize_command and compile_command need
1843         # to be aesthetically quoted because they are evaled later.
1844         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1845         case $arg in
1846         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1847           arg="\"$arg\""
1848           ;;
1849         esac
1850         ;;
1851       esac # arg
1852
1853       # Now actually substitute the argument into the commands.
1854       if test -n "$arg"; then
1855         compile_command="$compile_command $arg"
1856         finalize_command="$finalize_command $arg"
1857       fi
1858     done # argument parsing loop
1859
1860     if test -n "$prev"; then
1861       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1862       $echo "$help" 1>&2
1863       exit $EXIT_FAILURE
1864     fi
1865
1866     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1867       eval arg=\"$export_dynamic_flag_spec\"
1868       compile_command="$compile_command $arg"
1869       finalize_command="$finalize_command $arg"
1870     fi
1871
1872     oldlibs=
1873     # calculate the name of the file, without its directory
1874     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1875     libobjs_save="$libobjs"
1876
1877     if test -n "$shlibpath_var"; then
1878       # get the directories listed in $shlibpath_var
1879       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1880     else
1881       shlib_search_path=
1882     fi
1883     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1884     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1885
1886     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1887     if test "X$output_objdir" = "X$output"; then
1888       output_objdir="$objdir"
1889     else
1890       output_objdir="$output_objdir/$objdir"
1891     fi
1892     # Create the object directory.
1893     if test ! -d "$output_objdir"; then
1894       $show "$mkdir $output_objdir"
1895       $run $mkdir $output_objdir
1896       status=$?
1897       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1898         exit $status
1899       fi
1900     fi
1901
1902     # Determine the type of output
1903     case $output in
1904     "")
1905       $echo "$modename: you must specify an output file" 1>&2
1906       $echo "$help" 1>&2
1907       exit $EXIT_FAILURE
1908       ;;
1909     *.$libext) linkmode=oldlib ;;
1910     *.lo | *.$objext) linkmode=obj ;;
1911     *.la) linkmode=lib ;;
1912     *) linkmode=prog ;; # Anything else should be a program.
1913     esac
1914
1915     case $host in
1916     *cygwin* | *mingw* | *pw32*)
1917       # don't eliminate duplications in $postdeps and $predeps
1918       duplicate_compiler_generated_deps=yes
1919       ;;
1920     *)
1921       duplicate_compiler_generated_deps=$duplicate_deps
1922       ;;
1923     esac
1924     specialdeplibs=
1925
1926     libs=
1927     # Find all interdependent deplibs by searching for libraries
1928     # that are linked more than once (e.g. -la -lb -la)
1929     for deplib in $deplibs; do
1930       if test "X$duplicate_deps" = "Xyes" ; then
1931         case "$libs " in
1932         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1933         esac
1934       fi
1935       libs="$libs $deplib"
1936     done
1937
1938     if test "$linkmode" = lib; then
1939       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1940
1941       # Compute libraries that are listed more than once in $predeps
1942       # $postdeps and mark them as special (i.e., whose duplicates are
1943       # not to be eliminated).
1944       pre_post_deps=
1945       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1946         for pre_post_dep in $predeps $postdeps; do
1947           case "$pre_post_deps " in
1948           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1949           esac
1950           pre_post_deps="$pre_post_deps $pre_post_dep"
1951         done
1952       fi
1953       pre_post_deps=
1954     fi
1955
1956     deplibs=
1957     newdependency_libs=
1958     newlib_search_path=
1959     need_relink=no # whether we're linking any uninstalled libtool libraries
1960     notinst_deplibs= # not-installed libtool libraries
1961     notinst_path= # paths that contain not-installed libtool libraries
1962     case $linkmode in
1963     lib)
1964         passes="conv link"
1965         for file in $dlfiles $dlprefiles; do
1966           case $file in
1967           *.la) ;;
1968           *)
1969             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1970             exit $EXIT_FAILURE
1971             ;;
1972           esac
1973         done
1974         ;;
1975     prog)
1976         compile_deplibs=
1977         finalize_deplibs=
1978         alldeplibs=no
1979         newdlfiles=
1980         newdlprefiles=
1981         passes="conv scan dlopen dlpreopen link"
1982         ;;
1983     *)  passes="conv"
1984         ;;
1985     esac
1986     for pass in $passes; do
1987       if test "$linkmode,$pass" = "lib,link" ||
1988          test "$linkmode,$pass" = "prog,scan"; then
1989         libs="$deplibs"
1990         deplibs=
1991       fi
1992       if test "$linkmode" = prog; then
1993         case $pass in
1994         dlopen) libs="$dlfiles" ;;
1995         dlpreopen) libs="$dlprefiles" ;;
1996         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1997         esac
1998       fi
1999       if test "$pass" = dlopen; then
2000         # Collect dlpreopened libraries
2001         save_deplibs="$deplibs"
2002         deplibs=
2003       fi
2004       for deplib in $libs; do
2005         lib=
2006         found=no
2007         case $deplib in
2008         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
2009           if test "$linkmode,$pass" = "prog,link"; then
2010             compile_deplibs="$deplib $compile_deplibs"
2011             finalize_deplibs="$deplib $finalize_deplibs"
2012           else
2013             compiler_flags="$compiler_flags $deplib"
2014           fi
2015           continue
2016           ;;
2017         -l*)
2018           if test "$linkmode" != lib && test "$linkmode" != prog; then
2019             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2020             continue
2021           fi
2022           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2023           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
2024             for search_ext in .la $std_shrext .so .a; do
2025               # Search the libtool library
2026               lib="$searchdir/lib${name}${search_ext}"
2027               if test -f "$lib"; then
2028                 if test "$search_ext" = ".la"; then
2029                   found=yes
2030                 else
2031                   found=no
2032                 fi
2033                 break 2
2034               fi
2035             done
2036           done
2037           if test "$found" != yes; then
2038             # deplib doesn't seem to be a libtool library
2039             if test "$linkmode,$pass" = "prog,link"; then
2040               compile_deplibs="$deplib $compile_deplibs"
2041               finalize_deplibs="$deplib $finalize_deplibs"
2042             else
2043               deplibs="$deplib $deplibs"
2044               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2045             fi
2046             continue
2047           else # deplib is a libtool library
2048             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2049             # We need to do some special things here, and not later.
2050             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2051               case " $predeps $postdeps " in
2052               *" $deplib "*)
2053                 if (${SED} -e '2q' $lib |
2054                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2055                   library_names=
2056                   old_library=
2057                   case $lib in
2058                   */* | *\\*) . $lib ;;
2059                   *) . ./$lib ;;
2060                   esac
2061                   for l in $old_library $library_names; do
2062                     ll="$l"
2063                   done
2064                   if test "X$ll" = "X$old_library" ; then # only static version available
2065                     found=no
2066                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2067                     test "X$ladir" = "X$lib" && ladir="."
2068                     lib=$ladir/$old_library
2069                     if test "$linkmode,$pass" = "prog,link"; then
2070                       compile_deplibs="$deplib $compile_deplibs"
2071                       finalize_deplibs="$deplib $finalize_deplibs"
2072                     else
2073                       deplibs="$deplib $deplibs"
2074                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2075                     fi
2076                     continue
2077                   fi
2078                 fi
2079                 ;;
2080               *) ;;
2081               esac
2082             fi
2083           fi
2084           ;; # -l
2085         -L*)
2086           case $linkmode in
2087           lib)
2088             deplibs="$deplib $deplibs"
2089             test "$pass" = conv && continue
2090             newdependency_libs="$deplib $newdependency_libs"
2091             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2092             ;;
2093           prog)
2094             if test "$pass" = conv; then
2095               deplibs="$deplib $deplibs"
2096               continue
2097             fi
2098             if test "$pass" = scan; then
2099               deplibs="$deplib $deplibs"
2100             else
2101               compile_deplibs="$deplib $compile_deplibs"
2102               finalize_deplibs="$deplib $finalize_deplibs"
2103             fi
2104             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2105             ;;
2106           *)
2107             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2108             ;;
2109           esac # linkmode
2110           continue
2111           ;; # -L
2112         -R*)
2113           if test "$pass" = link; then
2114             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2115             # Make sure the xrpath contains only unique directories.
2116             case "$xrpath " in
2117             *" $dir "*) ;;
2118             *) xrpath="$xrpath $dir" ;;
2119             esac
2120           fi
2121           deplibs="$deplib $deplibs"
2122           continue
2123           ;;
2124         *.la) lib="$deplib" ;;
2125         *.$libext)
2126           if test "$pass" = conv; then
2127             deplibs="$deplib $deplibs"
2128             continue
2129           fi
2130           case $linkmode in
2131           lib)
2132             valid_a_lib=no
2133             case $deplibs_check_method in
2134               match_pattern*)
2135                 set dummy $deplibs_check_method
2136                 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2137                 if eval $echo \"$deplib\" 2>/dev/null \
2138                     | $SED 10q \
2139                     | $EGREP "$match_pattern_regex" > /dev/null; then
2140                   valid_a_lib=yes
2141                 fi
2142                 ;;
2143               pass_all)
2144                 valid_a_lib=yes
2145                 ;;
2146             esac
2147             if test "$valid_a_lib" != yes; then
2148               $echo
2149               $echo "*** Warning: Trying to link with static lib archive $deplib."
2150               $echo "*** I have the capability to make that library automatically link in when"
2151               $echo "*** you link to this library.  But I can only do this if you have a"
2152               $echo "*** shared version of the library, which you do not appear to have"
2153               $echo "*** because the file extensions .$libext of this argument makes me believe"
2154               $echo "*** that it is just a static archive that I should not used here."
2155             else
2156               $echo
2157               $echo "*** Warning: Linking the shared library $output against the"
2158               $echo "*** static library $deplib is not portable!"
2159               deplibs="$deplib $deplibs"
2160             fi
2161             continue
2162             ;;
2163           prog)
2164             if test "$pass" != link; then
2165               deplibs="$deplib $deplibs"
2166             else
2167               compile_deplibs="$deplib $compile_deplibs"
2168               finalize_deplibs="$deplib $finalize_deplibs"
2169             fi
2170             continue
2171             ;;
2172           esac # linkmode
2173           ;; # *.$libext
2174         *.lo | *.$objext)
2175           if test "$pass" = conv; then
2176             deplibs="$deplib $deplibs"
2177           elif test "$linkmode" = prog; then
2178             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2179               # If there is no dlopen support or we're linking statically,
2180               # we need to preload.
2181               newdlprefiles="$newdlprefiles $deplib"
2182               compile_deplibs="$deplib $compile_deplibs"
2183               finalize_deplibs="$deplib $finalize_deplibs"
2184             else
2185               newdlfiles="$newdlfiles $deplib"
2186             fi
2187           fi
2188           continue
2189           ;;
2190         %DEPLIBS%)
2191           alldeplibs=yes
2192           continue
2193           ;;
2194         esac # case $deplib
2195         if test "$found" = yes || test -f "$lib"; then :
2196         else
2197           $echo "$modename: cannot find the library \`$lib'" 1>&2
2198           exit $EXIT_FAILURE
2199         fi
2200
2201         # Check to see that this really is a libtool archive.
2202         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2203         else
2204           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2205           exit $EXIT_FAILURE
2206         fi
2207
2208         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2209         test "X$ladir" = "X$lib" && ladir="."
2210
2211         dlname=
2212         dlopen=
2213         dlpreopen=
2214         libdir=
2215         library_names=
2216         old_library=
2217         # If the library was installed with an old release of libtool,
2218         # it will not redefine variables installed, or shouldnotlink
2219         installed=yes
2220         shouldnotlink=no
2221         avoidtemprpath=
2222
2223
2224         # Read the .la file
2225         case $lib in
2226         */* | *\\*) . $lib ;;
2227         *) . ./$lib ;;
2228         esac
2229
2230         if test "$linkmode,$pass" = "lib,link" ||
2231            test "$linkmode,$pass" = "prog,scan" ||
2232            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2233           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2234           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2235         fi
2236
2237         if test "$pass" = conv; then
2238           # Only check for convenience libraries
2239           deplibs="$lib $deplibs"
2240           if test -z "$libdir"; then
2241             if test -z "$old_library"; then
2242               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2243               exit $EXIT_FAILURE
2244             fi
2245             # It is a libtool convenience library, so add in its objects.
2246             convenience="$convenience $ladir/$objdir/$old_library"
2247             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2248             tmp_libs=
2249             for deplib in $dependency_libs; do
2250               deplibs="$deplib $deplibs"
2251               if test "X$duplicate_deps" = "Xyes" ; then
2252                 case "$tmp_libs " in
2253                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2254                 esac
2255               fi
2256               tmp_libs="$tmp_libs $deplib"
2257             done
2258           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2259             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2260             exit $EXIT_FAILURE
2261           fi
2262           continue
2263         fi # $pass = conv
2264
2265
2266         # Get the name of the library we link against.
2267         linklib=
2268         for l in $old_library $library_names; do
2269           linklib="$l"
2270         done
2271         if test -z "$linklib"; then
2272           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2273           exit $EXIT_FAILURE
2274         fi
2275
2276         # This library was specified with -dlopen.
2277         if test "$pass" = dlopen; then
2278           if test -z "$libdir"; then
2279             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2280             exit $EXIT_FAILURE
2281           fi
2282           if test -z "$dlname" ||
2283              test "$dlopen_support" != yes ||
2284              test "$build_libtool_libs" = no; then
2285             # If there is no dlname, no dlopen support or we're linking
2286             # statically, we need to preload.  We also need to preload any
2287             # dependent libraries so libltdl's deplib preloader doesn't
2288             # bomb out in the load deplibs phase.
2289             dlprefiles="$dlprefiles $lib $dependency_libs"
2290           else
2291             newdlfiles="$newdlfiles $lib"
2292           fi
2293           continue
2294         fi # $pass = dlopen
2295
2296         # We need an absolute path.
2297         case $ladir in
2298         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2299         *)
2300           abs_ladir=`cd "$ladir" && pwd`
2301           if test -z "$abs_ladir"; then
2302             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2303             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2304             abs_ladir="$ladir"
2305           fi
2306           ;;
2307         esac
2308         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2309
2310         # Find the relevant object directory and library name.
2311         if test "X$installed" = Xyes; then
2312           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2313             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2314             dir="$ladir"
2315             absdir="$abs_ladir"
2316             libdir="$abs_ladir"
2317           else
2318             dir="$libdir"
2319             absdir="$libdir"
2320           fi
2321           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2322         else
2323           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2324             dir="$ladir"
2325             absdir="$abs_ladir"
2326             # Remove this search path later
2327             notinst_path="$notinst_path $abs_ladir"
2328           else
2329             dir="$ladir/$objdir"
2330             absdir="$abs_ladir/$objdir"
2331             # Remove this search path later
2332             notinst_path="$notinst_path $abs_ladir"
2333           fi
2334         fi # $installed = yes
2335         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2336
2337         # This library was specified with -dlpreopen.
2338         if test "$pass" = dlpreopen; then
2339           if test -z "$libdir"; then
2340             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2341             exit $EXIT_FAILURE
2342           fi
2343           # Prefer using a static library (so that no silly _DYNAMIC symbols
2344           # are required to link).
2345           if test -n "$old_library"; then
2346             newdlprefiles="$newdlprefiles $dir/$old_library"
2347           # Otherwise, use the dlname, so that lt_dlopen finds it.
2348           elif test -n "$dlname"; then
2349             newdlprefiles="$newdlprefiles $dir/$dlname"
2350           else
2351             newdlprefiles="$newdlprefiles $dir/$linklib"
2352           fi
2353         fi # $pass = dlpreopen
2354
2355         if test -z "$libdir"; then
2356           # Link the convenience library
2357           if test "$linkmode" = lib; then
2358             deplibs="$dir/$old_library $deplibs"
2359           elif test "$linkmode,$pass" = "prog,link"; then
2360             compile_deplibs="$dir/$old_library $compile_deplibs"
2361             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2362           else
2363             deplibs="$lib $deplibs" # used for prog,scan pass
2364           fi
2365           continue
2366         fi
2367
2368
2369         if test "$linkmode" = prog && test "$pass" != link; then
2370           newlib_search_path="$newlib_search_path $ladir"
2371           deplibs="$lib $deplibs"
2372
2373           linkalldeplibs=no
2374           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2375              test "$build_libtool_libs" = no; then
2376             linkalldeplibs=yes
2377           fi
2378
2379           tmp_libs=
2380           for deplib in $dependency_libs; do
2381             case $deplib in
2382             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2383             esac
2384             # Need to link against all dependency_libs?
2385             if test "$linkalldeplibs" = yes; then
2386               deplibs="$deplib $deplibs"
2387             else
2388               # Need to hardcode shared library paths
2389               # or/and link against static libraries
2390               newdependency_libs="$deplib $newdependency_libs"
2391             fi
2392             if test "X$duplicate_deps" = "Xyes" ; then
2393               case "$tmp_libs " in
2394               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2395               esac
2396             fi
2397             tmp_libs="$tmp_libs $deplib"
2398           done # for deplib
2399           continue
2400         fi # $linkmode = prog...
2401
2402         if test "$linkmode,$pass" = "prog,link"; then
2403           if test -n "$library_names" &&
2404              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2405             # We need to hardcode the library path
2406             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2407               # Make sure the rpath contains only unique directories.
2408               case "$temp_rpath " in
2409               *" $dir "*) ;;
2410               *" $absdir "*) ;;
2411               *) temp_rpath="$temp_rpath $absdir" ;;
2412               esac
2413             fi
2414
2415             # Hardcode the library path.
2416             # Skip directories that are in the system default run-time
2417             # search path.
2418             case " $sys_lib_dlsearch_path " in
2419             *" $absdir "*) ;;
2420             *)
2421               case "$compile_rpath " in
2422               *" $absdir "*) ;;
2423               *) compile_rpath="$compile_rpath $absdir"
2424               esac
2425               ;;
2426             esac
2427             case " $sys_lib_dlsearch_path " in
2428             *" $libdir "*) ;;
2429             *)
2430               case "$finalize_rpath " in
2431               *" $libdir "*) ;;
2432               *) finalize_rpath="$finalize_rpath $libdir"
2433               esac
2434               ;;
2435             esac
2436           fi # $linkmode,$pass = prog,link...
2437
2438           if test "$alldeplibs" = yes &&
2439              { test "$deplibs_check_method" = pass_all ||
2440                { test "$build_libtool_libs" = yes &&
2441                  test -n "$library_names"; }; }; then
2442             # We only need to search for static libraries
2443             continue
2444           fi
2445         fi
2446
2447         link_static=no # Whether the deplib will be linked statically
2448         if test -n "$library_names" &&
2449            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2450           if test "$installed" = no; then
2451             notinst_deplibs="$notinst_deplibs $lib"
2452             need_relink=yes
2453           fi
2454           # This is a shared library
2455
2456           # Warn about portability, can't link against -module's on
2457           # some systems (darwin)
2458           if test "$shouldnotlink" = yes && test "$pass" = link ; then
2459             $echo
2460             if test "$linkmode" = prog; then
2461               $echo "*** Warning: Linking the executable $output against the loadable module"
2462             else
2463               $echo "*** Warning: Linking the shared library $output against the loadable module"
2464             fi
2465             $echo "*** $linklib is not portable!"
2466           fi
2467           if test "$linkmode" = lib &&
2468              test "$hardcode_into_libs" = yes; then
2469             # Hardcode the library path.
2470             # Skip directories that are in the system default run-time
2471             # search path.
2472             case " $sys_lib_dlsearch_path " in
2473             *" $absdir "*) ;;
2474             *)
2475               case "$compile_rpath " in
2476               *" $absdir "*) ;;
2477               *) compile_rpath="$compile_rpath $absdir"
2478               esac
2479               ;;
2480             esac
2481             case " $sys_lib_dlsearch_path " in
2482             *" $libdir "*) ;;
2483             *)
2484               case "$finalize_rpath " in
2485               *" $libdir "*) ;;
2486               *) finalize_rpath="$finalize_rpath $libdir"
2487               esac
2488               ;;
2489             esac
2490           fi
2491
2492           if test -n "$old_archive_from_expsyms_cmds"; then
2493             # figure out the soname
2494             set dummy $library_names
2495             realname="$2"
2496             shift; shift
2497             libname=`eval \\$echo \"$libname_spec\"`
2498             # use dlname if we got it. it's perfectly good, no?
2499             if test -n "$dlname"; then
2500               soname="$dlname"
2501             elif test -n "$soname_spec"; then
2502               # bleh windows
2503               case $host in
2504               *cygwin* | mingw*)
2505                 major=`expr $current - $age`
2506                 versuffix="-$major"
2507                 ;;
2508               esac
2509               eval soname=\"$soname_spec\"
2510             else
2511               soname="$realname"
2512             fi
2513
2514             # Make a new name for the extract_expsyms_cmds to use
2515             soroot="$soname"
2516             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2517             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2518
2519             # If the library has no export list, then create one now
2520             if test -f "$output_objdir/$soname-def"; then :
2521             else
2522               $show "extracting exported symbol list from \`$soname'"
2523               save_ifs="$IFS"; IFS='~'
2524               cmds=$extract_expsyms_cmds
2525               for cmd in $cmds; do
2526                 IFS="$save_ifs"
2527                 eval cmd=\"$cmd\"
2528                 $show "$cmd"
2529                 $run eval "$cmd" || exit $?
2530               done
2531               IFS="$save_ifs"
2532             fi
2533
2534             # Create $newlib
2535             if test -f "$output_objdir/$newlib"; then :; else
2536               $show "generating import library for \`$soname'"
2537               save_ifs="$IFS"; IFS='~'
2538               cmds=$old_archive_from_expsyms_cmds
2539               for cmd in $cmds; do
2540                 IFS="$save_ifs"
2541                 eval cmd=\"$cmd\"
2542                 $show "$cmd"
2543                 $run eval "$cmd" || exit $?
2544               done
2545               IFS="$save_ifs"
2546             fi
2547             # make sure the library variables are pointing to the new library
2548             dir=$output_objdir
2549             linklib=$newlib
2550           fi # test -n "$old_archive_from_expsyms_cmds"
2551
2552           if test "$linkmode" = prog || test "$mode" != relink; then
2553             add_shlibpath=
2554             add_dir=
2555             add=
2556             lib_linked=yes
2557             case $hardcode_action in
2558             immediate | unsupported)
2559               if test "$hardcode_direct" = no; then
2560                 add="$dir/$linklib"
2561                 case $host in
2562                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2563                   *-*-darwin* )
2564                     # if the lib is a module then we can not link against
2565                     # it, someone is ignoring the new warnings I added
2566                     if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2567                       $echo "** Warning, lib $linklib is a module, not a shared library"
2568                       if test -z "$old_library" ; then
2569                         $echo
2570                         $echo "** And there doesn't seem to be a static archive available"
2571                         $echo "** The link will probably fail, sorry"
2572                       else
2573                         add="$dir/$old_library"
2574                       fi
2575                     fi
2576                 esac
2577               elif test "$hardcode_minus_L" = no; then
2578                 case $host in
2579                 *-*-sunos*) add_shlibpath="$dir" ;;
2580                 esac
2581                 add_dir="-L$dir"
2582                 add="-l$name"
2583               elif test "$hardcode_shlibpath_var" = no; then
2584                 add_shlibpath="$dir"
2585                 add="-l$name"
2586               else
2587                 lib_linked=no
2588               fi
2589               ;;
2590             relink)
2591               if test "$hardcode_direct" = yes; then
2592                 add="$dir/$linklib"
2593               elif test "$hardcode_minus_L" = yes; then
2594                 add_dir="-L$dir"
2595                 # Try looking first in the location we're being installed to.
2596                 if test -n "$inst_prefix_dir"; then
2597                   case $libdir in
2598                     [\\/]*)
2599                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2600                       ;;
2601                   esac
2602                 fi
2603                 add="-l$name"
2604               elif test "$hardcode_shlibpath_var" = yes; then
2605                 add_shlibpath="$dir"
2606                 add="-l$name"
2607               else
2608                 lib_linked=no
2609               fi
2610               ;;
2611             *) lib_linked=no ;;
2612             esac
2613
2614             if test "$lib_linked" != yes; then
2615               $echo "$modename: configuration error: unsupported hardcode properties"
2616               exit $EXIT_FAILURE
2617             fi
2618
2619             if test -n "$add_shlibpath"; then
2620               case :$compile_shlibpath: in
2621               *":$add_shlibpath:"*) ;;
2622               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2623               esac
2624             fi
2625             if test "$linkmode" = prog; then
2626               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2627               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2628             else
2629               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2630               test -n "$add" && deplibs="$add $deplibs"
2631               if test "$hardcode_direct" != yes && \
2632                  test "$hardcode_minus_L" != yes && \
2633                  test "$hardcode_shlibpath_var" = yes; then
2634                 case :$finalize_shlibpath: in
2635                 *":$libdir:"*) ;;
2636                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2637                 esac
2638               fi
2639             fi
2640           fi
2641
2642           if test "$linkmode" = prog || test "$mode" = relink; then
2643             add_shlibpath=
2644             add_dir=
2645             add=
2646             # Finalize command for both is simple: just hardcode it.
2647             if test "$hardcode_direct" = yes; then
2648               add="$libdir/$linklib"
2649             elif test "$hardcode_minus_L" = yes; then
2650               add_dir="-L$libdir"
2651               add="-l$name"
2652             elif test "$hardcode_shlibpath_var" = yes; then
2653               case :$finalize_shlibpath: in
2654               *":$libdir:"*) ;;
2655               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2656               esac
2657               add="-l$name"
2658             elif test "$hardcode_automatic" = yes; then
2659               if test -n "$inst_prefix_dir" &&
2660                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
2661                 add="$inst_prefix_dir$libdir/$linklib"
2662               else
2663                 add="$libdir/$linklib"
2664               fi
2665             else
2666               # We cannot seem to hardcode it, guess we'll fake it.
2667               add_dir="-L$libdir"
2668               # Try looking first in the location we're being installed to.
2669               if test -n "$inst_prefix_dir"; then
2670                 case $libdir in
2671                   [\\/]*)
2672                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2673                     ;;
2674                 esac
2675               fi
2676               add="-l$name"
2677             fi
2678
2679             if test "$linkmode" = prog; then
2680               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2681               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2682             else
2683               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2684               test -n "$add" && deplibs="$add $deplibs"
2685             fi
2686           fi
2687         elif test "$linkmode" = prog; then
2688           # Here we assume that one of hardcode_direct or hardcode_minus_L
2689           # is not unsupported.  This is valid on all known static and
2690           # shared platforms.
2691           if test "$hardcode_direct" != unsupported; then
2692             test -n "$old_library" && linklib="$old_library"
2693             compile_deplibs="$dir/$linklib $compile_deplibs"
2694             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2695           else
2696             compile_deplibs="-l$name -L$dir $compile_deplibs"
2697             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2698           fi
2699         elif test "$build_libtool_libs" = yes; then
2700           # Not a shared library
2701           if test "$deplibs_check_method" != pass_all; then
2702             # We're trying link a shared library against a static one
2703             # but the system doesn't support it.
2704
2705             # Just print a warning and add the library to dependency_libs so
2706             # that the program can be linked against the static library.
2707             $echo
2708             $echo "*** Warning: This system can not link to static lib archive $lib."
2709             $echo "*** I have the capability to make that library automatically link in when"
2710             $echo "*** you link to this library.  But I can only do this if you have a"
2711             $echo "*** shared version of the library, which you do not appear to have."
2712             if test "$module" = yes; then
2713               $echo "*** But as you try to build a module library, libtool will still create "
2714               $echo "*** a static module, that should work as long as the dlopening application"
2715               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2716               if test -z "$global_symbol_pipe"; then
2717                 $echo
2718                 $echo "*** However, this would only work if libtool was able to extract symbol"
2719                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2720                 $echo "*** not find such a program.  So, this module is probably useless."
2721                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2722               fi
2723               if test "$build_old_libs" = no; then
2724                 build_libtool_libs=module
2725                 build_old_libs=yes
2726               else
2727                 build_libtool_libs=no
2728               fi
2729             fi
2730           else
2731             deplibs="$dir/$old_library $deplibs"
2732             link_static=yes
2733           fi
2734         fi # link shared/static library?
2735
2736         if test "$linkmode" = lib; then
2737           if test -n "$dependency_libs" &&
2738              { test "$hardcode_into_libs" != yes ||
2739                test "$build_old_libs" = yes ||
2740                test "$link_static" = yes; }; then
2741             # Extract -R from dependency_libs
2742             temp_deplibs=
2743             for libdir in $dependency_libs; do
2744               case $libdir in
2745               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2746                    case " $xrpath " in
2747                    *" $temp_xrpath "*) ;;
2748                    *) xrpath="$xrpath $temp_xrpath";;
2749                    esac;;
2750               *) temp_deplibs="$temp_deplibs $libdir";;
2751               esac
2752             done
2753             dependency_libs="$temp_deplibs"
2754           fi
2755
2756           newlib_search_path="$newlib_search_path $absdir"
2757           # Link against this library
2758           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2759           # ... and its dependency_libs
2760           tmp_libs=
2761           for deplib in $dependency_libs; do
2762             newdependency_libs="$deplib $newdependency_libs"
2763             if test "X$duplicate_deps" = "Xyes" ; then
2764               case "$tmp_libs " in
2765               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2766               esac
2767             fi
2768             tmp_libs="$tmp_libs $deplib"
2769           done
2770
2771           if test "$link_all_deplibs" != no; then
2772             # Add the search paths of all dependency libraries
2773             for deplib in $dependency_libs; do
2774               case $deplib in
2775               -L*) path="$deplib" ;;
2776               *.la)
2777                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2778                 test "X$dir" = "X$deplib" && dir="."
2779                 # We need an absolute path.
2780                 case $dir in
2781                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2782                 *)
2783                   absdir=`cd "$dir" && pwd`
2784                   if test -z "$absdir"; then
2785                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2786                     absdir="$dir"
2787                   fi
2788                   ;;
2789                 esac
2790                 if grep "^installed=no" $deplib > /dev/null; then
2791                   path="$absdir/$objdir"
2792                 else
2793                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2794                   if test -z "$libdir"; then
2795                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2796                     exit $EXIT_FAILURE
2797                   fi
2798                   if test "$absdir" != "$libdir"; then
2799                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2800                   fi
2801                   path="$absdir"
2802                 fi
2803                 depdepl=
2804                 case $host in
2805                 *-*-darwin*)
2806                   # we do not want to link against static libs,
2807                   # but need to link against shared
2808                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2809                   if test -n "$deplibrary_names" ; then
2810                     for tmp in $deplibrary_names ; do
2811                       depdepl=$tmp
2812                     done
2813                     if test -f "$path/$depdepl" ; then
2814                       depdepl="$path/$depdepl"
2815                     fi
2816                     # do not add paths which are already there
2817                     case " $newlib_search_path " in
2818                     *" $path "*) ;;
2819                     *) newlib_search_path="$newlib_search_path $path";;
2820                     esac
2821                   fi
2822                   path=""
2823                   ;;
2824                 *)
2825                   path="-L$path"
2826                   ;;
2827                 esac
2828                 ;;
2829               -l*)
2830                 case $host in
2831                 *-*-darwin*)
2832                   # Again, we only want to link against shared libraries
2833                   eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2834                   for tmp in $newlib_search_path ; do
2835                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2836                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2837                       break
2838                     fi
2839                   done
2840                   path=""
2841                   ;;
2842                 *) continue ;;
2843                 esac
2844                 ;;
2845               *) continue ;;
2846               esac
2847               case " $deplibs " in
2848               *" $path "*) ;;
2849               *) deplibs="$path $deplibs" ;;
2850               esac
2851               case " $deplibs " in
2852               *" $depdepl "*) ;;
2853               *) deplibs="$depdepl $deplibs" ;;
2854               esac
2855             done
2856           fi # link_all_deplibs != no
2857         fi # linkmode = lib
2858       done # for deplib in $libs
2859       dependency_libs="$newdependency_libs"
2860       if test "$pass" = dlpreopen; then
2861         # Link the dlpreopened libraries before other libraries
2862         for deplib in $save_deplibs; do
2863           deplibs="$deplib $deplibs"
2864         done
2865       fi
2866       if test "$pass" != dlopen; then
2867         if test "$pass" != conv; then
2868           # Make sure lib_search_path contains only unique directories.
2869           lib_search_path=
2870           for dir in $newlib_search_path; do
2871             case "$lib_search_path " in
2872             *" $dir "*) ;;
2873             *) lib_search_path="$lib_search_path $dir" ;;
2874             esac
2875           done
2876           newlib_search_path=
2877         fi
2878
2879         if test "$linkmode,$pass" != "prog,link"; then
2880           vars="deplibs"
2881         else
2882           vars="compile_deplibs finalize_deplibs"
2883         fi
2884         for var in $vars dependency_libs; do
2885           # Add libraries to $var in reverse order
2886           eval tmp_libs=\"\$$var\"
2887           new_libs=
2888           for deplib in $tmp_libs; do
2889             # FIXME: Pedantically, this is the right thing to do, so
2890             #        that some nasty dependency loop isn't accidentally
2891             #        broken:
2892             #new_libs="$deplib $new_libs"
2893             # Pragmatically, this seems to cause very few problems in
2894             # practice:
2895             case $deplib in
2896             -L*) new_libs="$deplib $new_libs" ;;
2897             -R*) ;;
2898             *)
2899               # And here is the reason: when a library appears more
2900               # than once as an explicit dependence of a library, or
2901               # is implicitly linked in more than once by the
2902               # compiler, it is considered special, and multiple
2903               # occurrences thereof are not removed.  Compare this
2904               # with having the same library being listed as a
2905               # dependency of multiple other libraries: in this case,
2906               # we know (pedantically, we assume) the library does not
2907               # need to be listed more than once, so we keep only the
2908               # last copy.  This is not always right, but it is rare
2909               # enough that we require users that really mean to play
2910               # such unportable linking tricks to link the library
2911               # using -Wl,-lname, so that libtool does not consider it
2912               # for duplicate removal.
2913               case " $specialdeplibs " in
2914               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2915               *)
2916                 case " $new_libs " in
2917                 *" $deplib "*) ;;
2918                 *) new_libs="$deplib $new_libs" ;;
2919                 esac
2920                 ;;
2921               esac
2922               ;;
2923             esac
2924           done
2925           tmp_libs=
2926           for deplib in $new_libs; do
2927             case $deplib in
2928             -L*)
2929               case " $tmp_libs " in
2930               *" $deplib "*) ;;
2931               *) tmp_libs="$tmp_libs $deplib" ;;
2932               esac
2933               ;;
2934             *) tmp_libs="$tmp_libs $deplib" ;;
2935             esac
2936           done
2937           eval $var=\"$tmp_libs\"
2938         done # for var
2939       fi
2940       # Last step: remove runtime libs from dependency_libs
2941       # (they stay in deplibs)
2942       tmp_libs=
2943       for i in $dependency_libs ; do
2944         case " $predeps $postdeps $compiler_lib_search_path " in
2945         *" $i "*)
2946           i=""
2947           ;;
2948         esac
2949         if test -n "$i" ; then
2950           tmp_libs="$tmp_libs $i"
2951         fi
2952       done
2953       dependency_libs=$tmp_libs
2954     done # for pass
2955     if test "$linkmode" = prog; then
2956       dlfiles="$newdlfiles"
2957       dlprefiles="$newdlprefiles"
2958     fi
2959
2960     case $linkmode in
2961     oldlib)
2962       if test -n "$deplibs"; then
2963         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2964       fi
2965
2966       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2967         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2968       fi
2969
2970       if test -n "$rpath"; then
2971         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2972       fi
2973
2974       if test -n "$xrpath"; then
2975         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2976       fi
2977
2978       if test -n "$vinfo"; then
2979         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2980       fi
2981
2982       if test -n "$release"; then
2983         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2984       fi
2985
2986       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2987         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2988       fi
2989
2990       # Now set the variables for building old libraries.
2991       build_libtool_libs=no
2992       oldlibs="$output"
2993       objs="$objs$old_deplibs"
2994       ;;
2995
2996     lib)
2997       # Make sure we only generate libraries of the form `libNAME.la'.
2998       case $outputname in
2999       lib*)
3000         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3001         eval shared_ext=\"$shrext_cmds\"
3002         eval libname=\"$libname_spec\"
3003         ;;
3004       *)
3005         if test "$module" = no; then
3006           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3007           $echo "$help" 1>&2
3008           exit $EXIT_FAILURE
3009         fi
3010         if test "$need_lib_prefix" != no; then
3011           # Add the "lib" prefix for modules if required
3012           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3013           eval shared_ext=\"$shrext_cmds\"
3014           eval libname=\"$libname_spec\"
3015         else
3016           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3017         fi
3018         ;;
3019       esac
3020
3021       if test -n "$objs"; then
3022         if test "$deplibs_check_method" != pass_all; then
3023           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3024           exit $EXIT_FAILURE
3025         else
3026           $echo
3027           $echo "*** Warning: Linking the shared library $output against the non-libtool"
3028           $echo "*** objects $objs is not portable!"
3029           libobjs="$libobjs $objs"
3030         fi
3031       fi
3032
3033       if test "$dlself" != no; then
3034         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3035       fi
3036
3037       set dummy $rpath
3038       if test "$#" -gt 2; then
3039         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3040       fi
3041       install_libdir="$2"
3042
3043       oldlibs=
3044       if test -z "$rpath"; then
3045         if test "$build_libtool_libs" = yes; then
3046           # Building a libtool convenience library.
3047           # Some compilers have problems with a `.al' extension so
3048           # convenience libraries should have the same extension an
3049           # archive normally would.
3050           oldlibs="$output_objdir/$libname.$libext $oldlibs"
3051           build_libtool_libs=convenience
3052           build_old_libs=yes
3053         fi
3054
3055         if test -n "$vinfo"; then
3056           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3057         fi
3058
3059         if test -n "$release"; then
3060           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3061         fi
3062       else
3063
3064         # Parse the version information argument.
3065         save_ifs="$IFS"; IFS=':'
3066         set dummy $vinfo 0 0 0
3067         IFS="$save_ifs"
3068
3069         if test -n "$8"; then
3070           $echo "$modename: too many parameters to \`-version-info'" 1>&2
3071           $echo "$help" 1>&2
3072           exit $EXIT_FAILURE
3073         fi
3074
3075         # convert absolute version numbers to libtool ages
3076         # this retains compatibility with .la files and attempts
3077         # to make the code below a bit more comprehensible
3078
3079         case $vinfo_number in
3080         yes)
3081           number_major="$2"
3082           number_minor="$3"
3083           number_revision="$4"
3084           #
3085           # There are really only two kinds -- those that
3086           # use the current revision as the major version
3087           # and those that subtract age and use age as
3088           # a minor version.  But, then there is irix
3089           # which has an extra 1 added just for fun
3090           #
3091           case $version_type in
3092           darwin|linux|osf|windows)
3093             current=`expr $number_major + $number_minor`
3094             age="$number_minor"
3095             revision="$number_revision"
3096             ;;
3097           freebsd-aout|freebsd-elf|sunos)
3098             current="$number_major"
3099             revision="$number_minor"
3100             age="0"
3101             ;;
3102           irix|nonstopux)
3103             current=`expr $number_major + $number_minor - 1`
3104             age="$number_minor"
3105             revision="$number_minor"
3106             ;;
3107           esac
3108           ;;
3109         no)
3110           current="$2"
3111           revision="$3"
3112           age="$4"
3113           ;;
3114         esac
3115
3116         # Check that each of the things are valid numbers.
3117         case $current in
3118         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]) ;;
3119         *)
3120           $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3121           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3122           exit $EXIT_FAILURE
3123           ;;
3124         esac
3125
3126         case $revision in
3127         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]) ;;
3128         *)
3129           $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3130           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3131           exit $EXIT_FAILURE
3132           ;;
3133         esac
3134
3135         case $age in
3136         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]) ;;
3137         *)
3138           $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3139           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3140           exit $EXIT_FAILURE
3141           ;;
3142         esac
3143
3144         if test "$age" -gt "$current"; then
3145           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3146           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3147           exit $EXIT_FAILURE
3148         fi
3149
3150         # Calculate the version variables.
3151         major=
3152         versuffix=
3153         verstring=
3154         case $version_type in
3155         none) ;;
3156
3157         darwin)
3158           # Like Linux, but with the current version available in
3159           # verstring for coding it into the library header
3160           major=.`expr $current - $age`
3161           versuffix="$major.$age.$revision"
3162           # Darwin ld doesn't like 0 for these options...
3163           minor_current=`expr $current + 1`
3164           verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3165           ;;
3166
3167         freebsd-aout)
3168           major=".$current"
3169           versuffix=".$current.$revision";
3170           ;;
3171
3172         freebsd-elf)
3173           major=".$current"
3174           versuffix=".$current";
3175           ;;
3176
3177         irix | nonstopux)
3178           major=`expr $current - $age + 1`
3179
3180           case $version_type in
3181             nonstopux) verstring_prefix=nonstopux ;;
3182             *)         verstring_prefix=sgi ;;
3183           esac
3184           verstring="$verstring_prefix$major.$revision"
3185
3186           # Add in all the interfaces that we are compatible with.
3187           loop=$revision
3188           while test "$loop" -ne 0; do
3189             iface=`expr $revision - $loop`
3190             loop=`expr $loop - 1`
3191             verstring="$verstring_prefix$major.$iface:$verstring"
3192           done
3193
3194           # Before this point, $major must not contain `.'.
3195           major=.$major
3196           versuffix="$major.$revision"
3197           ;;
3198
3199         linux)
3200           major=.`expr $current - $age`
3201           versuffix="$major.$age.$revision"
3202           ;;
3203
3204         osf)
3205           major=.`expr $current - $age`
3206           versuffix=".$current.$age.$revision"
3207           verstring="$current.$age.$revision"
3208
3209           # Add in all the interfaces that we are compatible with.
3210           loop=$age
3211           while test "$loop" -ne 0; do
3212             iface=`expr $current - $loop`
3213             loop=`expr $loop - 1`
3214             verstring="$verstring:${iface}.0"
3215           done
3216
3217           # Make executables depend on our current version.
3218           verstring="$verstring:${current}.0"
3219           ;;
3220
3221         sunos)
3222           major=".$current"
3223           versuffix=".$current.$revision"
3224           ;;
3225
3226         windows)
3227           # Use '-' rather than '.', since we only want one
3228           # extension on DOS 8.3 filesystems.
3229           major=`expr $current - $age`
3230           versuffix="-$major"
3231           ;;
3232
3233         *)
3234           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3235           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3236           exit $EXIT_FAILURE
3237           ;;
3238         esac
3239
3240         # Clear the version info if we defaulted, and they specified a release.
3241         if test -z "$vinfo" && test -n "$release"; then
3242           major=
3243           case $version_type in
3244           darwin)
3245             # we can't check for "0.0" in archive_cmds due to quoting
3246             # problems, so we reset it completely
3247             verstring=
3248             ;;
3249           *)
3250             verstring="0.0"
3251             ;;
3252           esac
3253           if test "$need_version" = no; then
3254             versuffix=
3255           else
3256             versuffix=".0.0"
3257           fi
3258         fi
3259
3260         # Remove version info from name if versioning should be avoided
3261         if test "$avoid_version" = yes && test "$need_version" = no; then
3262           major=
3263           versuffix=
3264           verstring=""
3265         fi
3266
3267         # Check to see if the archive will have undefined symbols.
3268         if test "$allow_undefined" = yes; then
3269           if test "$allow_undefined_flag" = unsupported; then
3270             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3271             build_libtool_libs=no
3272             build_old_libs=yes
3273           fi
3274         else
3275           # Don't allow undefined symbols.
3276           allow_undefined_flag="$no_undefined_flag"
3277         fi
3278       fi
3279
3280       if test "$mode" != relink; then
3281         # Remove our outputs, but don't remove object files since they
3282         # may have been created when compiling PIC objects.
3283         removelist=
3284         tempremovelist=`$echo "$output_objdir/*"`
3285         for p in $tempremovelist; do
3286           case $p in
3287             *.$objext)
3288                ;;
3289             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3290                if test "X$precious_files_regex" != "X"; then
3291                  if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3292                  then
3293                    continue
3294                  fi
3295                fi
3296                removelist="$removelist $p"
3297                ;;
3298             *) ;;
3299           esac
3300         done
3301         if test -n "$removelist"; then
3302           $show "${rm}r $removelist"
3303           $run ${rm}r $removelist
3304         fi
3305       fi
3306
3307       # Now set the variables for building old libraries.
3308       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3309         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3310
3311         # Transform .lo files to .o files.
3312         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3313       fi
3314
3315       # Eliminate all temporary directories.
3316       for path in $notinst_path; do
3317         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3318         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3319         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3320       done
3321
3322       if test -n "$xrpath"; then
3323         # If the user specified any rpath flags, then add them.
3324         temp_xrpath=
3325         for libdir in $xrpath; do
3326           temp_xrpath="$temp_xrpath -R$libdir"
3327           case "$finalize_rpath " in
3328           *" $libdir "*) ;;
3329           *) finalize_rpath="$finalize_rpath $libdir" ;;
3330           esac
3331         done
3332         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3333           dependency_libs="$temp_xrpath $dependency_libs"
3334         fi
3335       fi
3336
3337       # Make sure dlfiles contains only unique files that won't be dlpreopened
3338       old_dlfiles="$dlfiles"
3339       dlfiles=
3340       for lib in $old_dlfiles; do
3341         case " $dlprefiles $dlfiles " in
3342         *" $lib "*) ;;
3343         *) dlfiles="$dlfiles $lib" ;;
3344         esac
3345       done
3346
3347       # Make sure dlprefiles contains only unique files
3348       old_dlprefiles="$dlprefiles"
3349       dlprefiles=
3350       for lib in $old_dlprefiles; do
3351         case "$dlprefiles " in
3352         *" $lib "*) ;;
3353         *) dlprefiles="$dlprefiles $lib" ;;
3354         esac
3355       done
3356
3357       if test "$build_libtool_libs" = yes; then
3358         if test -n "$rpath"; then
3359           case $host in
3360           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3361             # these systems don't actually have a c library (as such)!
3362             ;;
3363           *-*-rhapsody* | *-*-darwin1.[012])
3364             # Rhapsody C library is in the System framework
3365             deplibs="$deplibs -framework System"
3366             ;;
3367           *-*-netbsd*)
3368             # Don't link with libc until the a.out ld.so is fixed.
3369             ;;
3370           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3371             # Do not include libc due to us having libc/libc_r.
3372             test "X$arg" = "X-lc" && continue
3373             ;;
3374           *)
3375             # Add libc to deplibs on all other systems if necessary.
3376             if test "$build_libtool_need_lc" = "yes"; then
3377               deplibs="$deplibs -lc"
3378             fi
3379             ;;
3380           esac
3381         fi
3382
3383         # Transform deplibs into only deplibs that can be linked in shared.
3384         name_save=$name
3385         libname_save=$libname
3386         release_save=$release
3387         versuffix_save=$versuffix
3388         major_save=$major
3389         # I'm not sure if I'm treating the release correctly.  I think
3390         # release should show up in the -l (ie -lgmp5) so we don't want to
3391         # add it in twice.  Is that correct?
3392         release=""
3393         versuffix=""
3394         major=""
3395         newdeplibs=
3396         droppeddeps=no
3397         case $deplibs_check_method in
3398         pass_all)
3399           # Don't check for shared/static.  Everything works.
3400           # This might be a little naive.  We might want to check
3401           # whether the library exists or not.  But this is on
3402           # osf3 & osf4 and I'm not really sure... Just
3403           # implementing what was already the behavior.
3404           newdeplibs=$deplibs
3405           ;;
3406         test_compile)
3407           # This code stresses the "libraries are programs" paradigm to its
3408           # limits. Maybe even breaks it.  We compile a program, linking it
3409           # against the deplibs as a proxy for the library.  Then we can check
3410           # whether they linked in statically or dynamically with ldd.
3411           $rm conftest.c
3412           cat > conftest.c <<EOF
3413           int main() { return 0; }
3414 EOF
3415           $rm conftest
3416           $LTCC -o conftest conftest.c $deplibs
3417           if test "$?" -eq 0 ; then
3418             ldd_output=`ldd conftest`
3419             for i in $deplibs; do
3420               name=`expr $i : '-l\(.*\)'`
3421               # If $name is empty we are operating on a -L argument.
3422               if test "$name" != "" && test "$name" -ne "0"; then
3423                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3424                   case " $predeps $postdeps " in
3425                   *" $i "*)
3426                     newdeplibs="$newdeplibs $i"
3427                     i=""
3428                     ;;
3429                   esac
3430                 fi
3431                 if test -n "$i" ; then
3432                   libname=`eval \\$echo \"$libname_spec\"`
3433                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3434                   set dummy $deplib_matches
3435                   deplib_match=$2
3436                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3437                     newdeplibs="$newdeplibs $i"
3438                   else
3439                     droppeddeps=yes
3440                     $echo
3441                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3442                     $echo "*** I have the capability to make that library automatically link in when"
3443                     $echo "*** you link to this library.  But I can only do this if you have a"
3444                     $echo "*** shared version of the library, which I believe you do not have"
3445                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3446                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3447                   fi
3448                 fi
3449               else
3450                 newdeplibs="$newdeplibs $i"
3451               fi
3452             done
3453           else
3454             # Error occurred in the first compile.  Let's try to salvage
3455             # the situation: Compile a separate program for each library.
3456             for i in $deplibs; do
3457               name=`expr $i : '-l\(.*\)'`
3458               # If $name is empty we are operating on a -L argument.
3459               if test "$name" != "" && test "$name" != "0"; then
3460                 $rm conftest
3461                 $LTCC -o conftest conftest.c $i
3462                 # Did it work?
3463                 if test "$?" -eq 0 ; then
3464                   ldd_output=`ldd conftest`
3465                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3466                     case " $predeps $postdeps " in
3467                     *" $i "*)
3468                       newdeplibs="$newdeplibs $i"
3469                       i=""
3470                       ;;
3471                     esac
3472                   fi
3473                   if test -n "$i" ; then
3474                     libname=`eval \\$echo \"$libname_spec\"`
3475                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3476                     set dummy $deplib_matches
3477                     deplib_match=$2
3478                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3479                       newdeplibs="$newdeplibs $i"
3480                     else
3481                       droppeddeps=yes
3482                       $echo
3483                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3484                       $echo "*** I have the capability to make that library automatically link in when"
3485                       $echo "*** you link to this library.  But I can only do this if you have a"
3486                       $echo "*** shared version of the library, which you do not appear to have"
3487                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3488                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3489                     fi
3490                   fi
3491                 else
3492                   droppeddeps=yes
3493                   $echo
3494                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3495                   $echo "***  make it link in!  You will probably need to install it or some"
3496                   $echo "*** library that it depends on before this library will be fully"
3497                   $echo "*** functional.  Installing it before continuing would be even better."
3498                 fi
3499               else
3500                 newdeplibs="$newdeplibs $i"
3501               fi
3502             done
3503           fi
3504           ;;
3505         file_magic*)
3506           set dummy $deplibs_check_method
3507           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3508           for a_deplib in $deplibs; do
3509             name=`expr $a_deplib : '-l\(.*\)'`
3510             # If $name is empty we are operating on a -L argument.
3511             if test "$name" != "" && test  "$name" != "0"; then
3512               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3513                 case " $predeps $postdeps " in
3514                 *" $a_deplib "*)
3515                   newdeplibs="$newdeplibs $a_deplib"
3516                   a_deplib=""
3517                   ;;
3518                 esac
3519               fi
3520               if test -n "$a_deplib" ; then
3521                 libname=`eval \\$echo \"$libname_spec\"`
3522                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3523                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3524                   for potent_lib in $potential_libs; do
3525                       # Follow soft links.
3526                       if ls -lLd "$potent_lib" 2>/dev/null \
3527                          | grep " -> " >/dev/null; then
3528                         continue
3529                       fi
3530                       # The statement above tries to avoid entering an
3531                       # endless loop below, in case of cyclic links.
3532                       # We might still enter an endless loop, since a link
3533                       # loop can be closed while we follow links,
3534                       # but so what?
3535                       potlib="$potent_lib"
3536                       while test -h "$potlib" 2>/dev/null; do
3537                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3538                         case $potliblink in
3539                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3540                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3541                         esac
3542                       done
3543                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3544                          | ${SED} 10q \
3545                          | $EGREP "$file_magic_regex" > /dev/null; then
3546                         newdeplibs="$newdeplibs $a_deplib"
3547                         a_deplib=""
3548                         break 2
3549                       fi
3550                   done
3551                 done
3552               fi
3553               if test -n "$a_deplib" ; then
3554                 droppeddeps=yes
3555                 $echo
3556                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3557                 $echo "*** I have the capability to make that library automatically link in when"
3558                 $echo "*** you link to this library.  But I can only do this if you have a"
3559                 $echo "*** shared version of the library, which you do not appear to have"
3560                 $echo "*** because I did check the linker path looking for a file starting"
3561                 if test -z "$potlib" ; then
3562                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3563                 else
3564                   $echo "*** with $libname and none of the candidates passed a file format test"
3565                   $echo "*** using a file magic. Last file checked: $potlib"
3566                 fi
3567               fi
3568             else
3569               # Add a -L argument.
3570               newdeplibs="$newdeplibs $a_deplib"
3571             fi
3572           done # Gone through all deplibs.
3573           ;;
3574         match_pattern*)
3575           set dummy $deplibs_check_method
3576           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3577           for a_deplib in $deplibs; do
3578             name=`expr $a_deplib : '-l\(.*\)'`
3579             # If $name is empty we are operating on a -L argument.
3580             if test -n "$name" && test "$name" != "0"; then
3581               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3582                 case " $predeps $postdeps " in
3583                 *" $a_deplib "*)
3584                   newdeplibs="$newdeplibs $a_deplib"
3585                   a_deplib=""
3586                   ;;
3587                 esac
3588               fi
3589               if test -n "$a_deplib" ; then
3590                 libname=`eval \\$echo \"$libname_spec\"`
3591                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3592                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3593                   for potent_lib in $potential_libs; do
3594                     potlib="$potent_lib" # see symlink-check above in file_magic test
3595                     if eval $echo \"$potent_lib\" 2>/dev/null \
3596                         | ${SED} 10q \
3597                         | $EGREP "$match_pattern_regex" > /dev/null; then
3598                       newdeplibs="$newdeplibs $a_deplib"
3599                       a_deplib=""
3600                       break 2
3601                     fi
3602                   done
3603                 done
3604               fi
3605               if test -n "$a_deplib" ; then
3606                 droppeddeps=yes
3607                 $echo
3608                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3609                 $echo "*** I have the capability to make that library automatically link in when"
3610                 $echo "*** you link to this library.  But I can only do this if you have a"
3611                 $echo "*** shared version of the library, which you do not appear to have"
3612                 $echo "*** because I did check the linker path looking for a file starting"
3613                 if test -z "$potlib" ; then
3614                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3615                 else
3616                   $echo "*** with $libname and none of the candidates passed a file format test"
3617                   $echo "*** using a regex pattern. Last file checked: $potlib"
3618                 fi
3619               fi
3620             else
3621               # Add a -L argument.
3622               newdeplibs="$newdeplibs $a_deplib"
3623             fi
3624           done # Gone through all deplibs.
3625           ;;
3626         none | unknown | *)
3627           newdeplibs=""
3628           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3629             -e 's/ -[LR][^ ]*//g'`
3630           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3631             for i in $predeps $postdeps ; do
3632               # can't use Xsed below, because $i might contain '/'
3633               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3634             done
3635           fi
3636           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3637             | grep . >/dev/null; then
3638             $echo
3639             if test "X$deplibs_check_method" = "Xnone"; then
3640               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3641             else
3642               $echo "*** Warning: inter-library dependencies are not known to be supported."
3643             fi
3644             $echo "*** All declared inter-library dependencies are being dropped."
3645             droppeddeps=yes
3646           fi
3647           ;;
3648         esac
3649         versuffix=$versuffix_save
3650         major=$major_save
3651         release=$release_save
3652         libname=$libname_save
3653         name=$name_save
3654
3655         case $host in
3656         *-*-rhapsody* | *-*-darwin1.[012])
3657           # On Rhapsody replace the C library is the System framework
3658           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3659           ;;
3660         esac
3661
3662         if test "$droppeddeps" = yes; then
3663           if test "$module" = yes; then
3664             $echo
3665             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3666             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3667             $echo "*** a static module, that should work as long as the dlopening"
3668             $echo "*** application is linked with the -dlopen flag."
3669             if test -z "$global_symbol_pipe"; then
3670               $echo
3671               $echo "*** However, this would only work if libtool was able to extract symbol"
3672               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3673               $echo "*** not find such a program.  So, this module is probably useless."
3674               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3675             fi
3676             if test "$build_old_libs" = no; then
3677               oldlibs="$output_objdir/$libname.$libext"
3678               build_libtool_libs=module
3679               build_old_libs=yes
3680             else
3681               build_libtool_libs=no
3682             fi
3683           else
3684             $echo "*** The inter-library dependencies that have been dropped here will be"
3685             $echo "*** automatically added whenever a program is linked with this library"
3686             $echo "*** or is declared to -dlopen it."
3687
3688             if test "$allow_undefined" = no; then
3689               $echo
3690               $echo "*** Since this library must not contain undefined symbols,"
3691               $echo "*** because either the platform does not support them or"
3692               $echo "*** it was explicitly requested with -no-undefined,"
3693               $echo "*** libtool will only create a static version of it."
3694               if test "$build_old_libs" = no; then
3695                 oldlibs="$output_objdir/$libname.$libext"
3696                 build_libtool_libs=module
3697                 build_old_libs=yes
3698               else
3699                 build_libtool_libs=no
3700               fi
3701             fi
3702           fi
3703         fi
3704         # Done checking deplibs!
3705         deplibs=$newdeplibs
3706       fi
3707
3708       # All the library-specific variables (install_libdir is set above).
3709       library_names=
3710       old_library=
3711       dlname=
3712
3713       # Test again, we may have decided not to build it any more
3714       if test "$build_libtool_libs" = yes; then
3715         if test "$hardcode_into_libs" = yes; then
3716           # Hardcode the library paths
3717           hardcode_libdirs=
3718           dep_rpath=
3719           rpath="$finalize_rpath"
3720           test "$mode" != relink && rpath="$compile_rpath$rpath"
3721           for libdir in $rpath; do
3722             if test -n "$hardcode_libdir_flag_spec"; then
3723               if test -n "$hardcode_libdir_separator"; then
3724                 if test -z "$hardcode_libdirs"; then
3725                   hardcode_libdirs="$libdir"
3726                 else
3727                   # Just accumulate the unique libdirs.
3728                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3729                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3730                     ;;
3731                   *)
3732                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3733                     ;;
3734                   esac
3735                 fi
3736               else
3737                 eval flag=\"$hardcode_libdir_flag_spec\"
3738                 dep_rpath="$dep_rpath $flag"
3739               fi
3740             elif test -n "$runpath_var"; then
3741               case "$perm_rpath " in
3742               *" $libdir "*) ;;
3743               *) perm_rpath="$perm_rpath $libdir" ;;
3744               esac
3745             fi
3746           done
3747           # Substitute the hardcoded libdirs into the rpath.
3748           if test -n "$hardcode_libdir_separator" &&
3749              test -n "$hardcode_libdirs"; then
3750             libdir="$hardcode_libdirs"
3751             if test -n "$hardcode_libdir_flag_spec_ld"; then
3752               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3753             else
3754               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3755             fi
3756           fi
3757           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3758             # We should set the runpath_var.
3759             rpath=
3760             for dir in $perm_rpath; do
3761               rpath="$rpath$dir:"
3762             done
3763             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3764           fi
3765           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3766         fi
3767
3768         shlibpath="$finalize_shlibpath"
3769         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3770         if test -n "$shlibpath"; then
3771           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3772         fi
3773
3774         # Get the real and link names of the library.
3775         eval shared_ext=\"$shrext_cmds\"
3776         eval library_names=\"$library_names_spec\"
3777         set dummy $library_names
3778         realname="$2"
3779         shift; shift
3780
3781         if test -n "$soname_spec"; then
3782           eval soname=\"$soname_spec\"
3783         else
3784           soname="$realname"
3785         fi
3786         if test -z "$dlname"; then
3787           dlname=$soname
3788         fi
3789
3790         lib="$output_objdir/$realname"
3791         for link
3792         do
3793           linknames="$linknames $link"
3794         done
3795
3796         # Use standard objects if they are pic
3797         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3798
3799         # Prepare the list of exported symbols
3800         if test -z "$export_symbols"; then
3801           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3802             $show "generating symbol list for \`$libname.la'"
3803             export_symbols="$output_objdir/$libname.exp"
3804             $run $rm $export_symbols
3805             cmds=$export_symbols_cmds
3806             save_ifs="$IFS"; IFS='~'
3807             for cmd in $cmds; do
3808               IFS="$save_ifs"
3809               eval cmd=\"$cmd\"
3810               if len=`expr "X$cmd" : ".*"` &&
3811                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3812                 $show "$cmd"
3813                 $run eval "$cmd" || exit $?
3814                 skipped_export=false
3815               else
3816                 # The command line is too long to execute in one step.
3817                 $show "using reloadable object file for export list..."
3818                 skipped_export=:
3819                 # Break out early, otherwise skipped_export may be
3820                 # set to false by a later but shorter cmd.
3821                 break
3822               fi
3823             done
3824             IFS="$save_ifs"
3825             if test -n "$export_symbols_regex"; then
3826               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3827               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3828               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3829               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3830             fi
3831           fi
3832         fi
3833
3834         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3835           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3836         fi
3837
3838         tmp_deplibs=
3839         for test_deplib in $deplibs; do
3840                 case " $convenience " in
3841                 *" $test_deplib "*) ;;
3842                 *)
3843                         tmp_deplibs="$tmp_deplibs $test_deplib"
3844                         ;;
3845                 esac
3846         done
3847         deplibs="$tmp_deplibs"
3848
3849         if test -n "$convenience"; then
3850           if test -n "$whole_archive_flag_spec"; then
3851             save_libobjs=$libobjs
3852             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3853           else
3854             gentop="$output_objdir/${outputname}x"
3855             generated="$generated $gentop"
3856
3857             func_extract_archives $gentop $convenience
3858             libobjs="$libobjs $func_extract_archives_result"
3859           fi
3860         fi
3861
3862         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3863           eval flag=\"$thread_safe_flag_spec\"
3864           linker_flags="$linker_flags $flag"
3865         fi
3866
3867         # Make a backup of the uninstalled library when relinking
3868         if test "$mode" = relink; then
3869           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3870         fi
3871
3872         # Do each of the archive commands.
3873         if test "$module" = yes && test -n "$module_cmds" ; then
3874           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3875             eval test_cmds=\"$module_expsym_cmds\"
3876             cmds=$module_expsym_cmds
3877           else
3878             eval test_cmds=\"$module_cmds\"
3879             cmds=$module_cmds
3880           fi
3881         else
3882         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3883           eval test_cmds=\"$archive_expsym_cmds\"
3884           cmds=$archive_expsym_cmds
3885         else
3886           eval test_cmds=\"$archive_cmds\"
3887           cmds=$archive_cmds
3888           fi
3889         fi
3890
3891         if test "X$skipped_export" != "X:" &&
3892            len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
3893            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3894           :
3895         else
3896           # The command line is too long to link in one step, link piecewise.
3897           $echo "creating reloadable object files..."
3898
3899           # Save the value of $output and $libobjs because we want to
3900           # use them later.  If we have whole_archive_flag_spec, we
3901           # want to use save_libobjs as it was before
3902           # whole_archive_flag_spec was expanded, because we can't
3903           # assume the linker understands whole_archive_flag_spec.
3904           # This may have to be revisited, in case too many
3905           # convenience libraries get linked in and end up exceeding
3906           # the spec.
3907           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3908             save_libobjs=$libobjs
3909           fi
3910           save_output=$output
3911           output_la=`$echo "X$output" | $Xsed -e "$basename"`
3912
3913           # Clear the reloadable object creation command queue and
3914           # initialize k to one.
3915           test_cmds=
3916           concat_cmds=
3917           objlist=
3918           delfiles=
3919           last_robj=
3920           k=1
3921           output=$output_objdir/$output_la-${k}.$objext
3922           # Loop over the list of objects to be linked.
3923           for obj in $save_libobjs
3924           do
3925