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