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