git.gag.com Git - debian/sudo/blob - ltmain.sh

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