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