git.sur5r.net Git - openldap/blob - build/ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun ltconfig.
   3 #
   4 # Copyright (C) 1996-1998 Free Software Foundation, Inc.
   5 # Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20 #
  21 # As a special exception to the GNU General Public License, if you
  22 # distribute this file as part of a program that contains a
  23 # configuration script generated by Autoconf, you may include it under
  24 # the same distribution terms that you use for the rest of that program.
  25
  26 # The name of this program.
  27 progname=`$echo "$0" | sed 's%^.*/%%'`
  28 modename="$progname"
  29
  30 # Constants.
  31 PROGRAM=ltmain.sh
  32 PACKAGE=libtool
  33 VERSION=1.2
  34
  35 default_mode=
  36 help="Try \`$progname --help' for more information."
  37 magic="%%%MAGIC variable%%%"
  38 mkdir="mkdir"
  39 mv="mv -f"
  40 rm="rm -f"
  41
  42 # Sed substitution that helps us do robust quoting.  It backslashifies
  43 # metacharacters that are still active within double-quoted strings.
  44 Xsed='sed -e s/^X//'
  45 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  46
  47 # NLS nuisances.
  48 # Only set LANG and LC_ALL to C if already set.
  49 # These must not be set unconditionally because not all systems understand
  50 # e.g. LANG=C (notably SCO).
  51 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
  52 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
  53
  54 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  55   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  56   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  57   exit 1
  58 fi
  59
  60 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  61   echo "$modename: not configured to build any kind of library" 1>&2
  62   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  63   exit 1
  64 fi
  65
  66 # Global variables.
  67 mode=$default_mode
  68 nonopt=
  69 prev=
  70 prevopt=
  71 run=
  72 show="$echo"
  73 show_help=
  74 execute_dlfiles=
  75
  76 # Parse our command line options once, thoroughly.
  77 while test $# -gt 0
  78 do
  79   arg="$1"
  80   shift
  81
  82   case "$arg" in
  83   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  84   *) optarg= ;;
  85   esac
  86
  87   # If the previous option needs an argument, assign it.
  88   if test -n "$prev"; then
  89     case "$prev" in
  90     execute_dlfiles)
  91       eval "$prev=\"\$$prev \$arg\""
  92       ;;
  93     *)
  94       eval "$prev=\$arg"
  95       ;;
  96     esac
  97
  98     prev=
  99     prevopt=
 100     continue
 101   fi
 102
 103   # Have we seen a non-optional argument yet?
 104   case "$arg" in
 105   --help)
 106     show_help=yes
 107     ;;
 108
 109   --version)
 110     echo "$PROGRAM (GNU $PACKAGE) $VERSION"
 111     exit 0
 112     ;;
 113
 114   --dry-run | -n)
 115     run=:
 116     ;;
 117
 118   --features)
 119     echo "host: $host"
 120     if test "$build_libtool_libs" = yes; then
 121       echo "enable shared libraries"
 122     else
 123       echo "disable shared libraries"
 124     fi
 125     if test "$build_old_libs" = yes; then
 126       echo "enable static libraries"
 127     else
 128       echo "disable static libraries"
 129     fi
 130     exit 0
 131     ;;
 132
 133   --finish) mode="finish" ;;
 134
 135   --mode) prevopt="--mode" prev=mode ;;
 136   --mode=*) mode="$optarg" ;;
 137
 138   --quiet | --silent)
 139     show=:
 140     ;;
 141
 142   -dlopen)
 143     prevopt="-dlopen"
 144     prev=execute_dlfiles
 145     ;;
 146
 147   -*)
 148     $echo "$modename: unrecognized option \`$arg'" 1>&2
 149     $echo "$help" 1>&2
 150     exit 1
 151     ;;
 152
 153   *)
 154     nonopt="$arg"
 155     break
 156     ;;
 157   esac
 158 done
 159
 160 if test -n "$prevopt"; then
 161   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 162   $echo "$help" 1>&2
 163   exit 1
 164 fi
 165
 166 if test -z "$show_help"; then
 167
 168   # Infer the operation mode.
 169   if test -z "$mode"; then
 170     case "$nonopt" in
 171     *cc | *++ | gcc* | *-gcc*)
 172       mode=link
 173       for arg
 174       do
 175         case "$arg" in
 176         -c)
 177            mode=compile
 178            break
 179            ;;
 180         esac
 181       done
 182       ;;
 183     *db | *dbx)
 184       mode=execute
 185       ;;
 186     *install*|cp|mv)
 187       mode=install
 188       ;;
 189     *rm)
 190       mode=uninstall
 191       ;;
 192     *)
 193       # If we have no mode, but dlfiles were specified, then do execute mode.
 194       test -n "$execute_dlfiles" && mode=execute
 195
 196       # Just use the default operation mode.
 197       if test -z "$mode"; then
 198         if test -n "$nonopt"; then
 199           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 200         else
 201           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 202         fi
 203       fi
 204       ;;
 205     esac
 206   fi
 207
 208   # Only execute mode is allowed to have -dlopen flags.
 209   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 210     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 211     $echo "$help" 1>&2
 212     exit 1
 213   fi
 214
 215   # Change the help message to a mode-specific one.
 216   generic_help="$help"
 217   help="Try \`$modename --help --mode=$mode' for more information."
 218
 219   # These modes are in order of execution frequency so that they run quickly.
 220   case "$mode" in
 221   # libtool compile mode
 222   compile)
 223     modename="$modename: compile"
 224     # Get the compilation command and the source file.
 225     base_compile=
 226     lastarg=
 227     srcfile="$nonopt"
 228     suppress_output=
 229
 230     for arg
 231     do
 232       # Accept any command-line options.
 233       case "$arg" in
 234       -o)
 235         $echo "$modename: you cannot specify the output filename with \`-o'" 1>&2
 236         $echo "$help" 1>&2
 237         exit 1
 238         ;;
 239
 240       -static)
 241         build_libtool_libs=no
 242         build_old_libs=yes
 243         continue
 244         ;;
 245       esac
 246
 247       # Accept the current argument as the source file.
 248       lastarg="$srcfile"
 249       srcfile="$arg"
 250
 251       # Aesthetically quote the previous argument.
 252
 253       # Backslashify any backslashes, double quotes, and dollar signs.
 254       # These are the only characters that are still specially
 255       # interpreted inside of double-quoted scrings.
 256       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 257
 258       # Double-quote args containing other shell metacharacters.
 259       # Many Bourne shells cannot handle close brackets correctly in scan
 260       # sets, so we specify it separately.
 261       case "$lastarg" in
 262       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
 263         lastarg="\"$lastarg\""
 264         ;;
 265       esac
 266
 267       # Add the previous argument to base_compile.
 268       if test -z "$base_compile"; then
 269         base_compile="$lastarg"
 270       else
 271         base_compile="$base_compile $lastarg"
 272       fi
 273     done
 274
 275     # Get the name of the library object.
 276     libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 277
 278     # Recognize several different file suffixes.
 279     xform='[cCFSfms]'
 280     case "$libobj" in
 281     *.ada) xform=ada ;;
 282     *.adb) xform=adb ;;
 283     *.ads) xform=ads ;;
 284     *.asm) xform=asm ;;
 285     *.c++) xform=c++ ;;
 286     *.cc) xform=cc ;;
 287     *.cpp) xform=cpp ;;
 288     *.cxx) xform=cxx ;;
 289     *.f90) xform=f90 ;;
 290     *.for) xform=for ;;
 291     esac
 292
 293     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 294
 295     case "$libobj" in
 296     *.lo) obj=`$echo "X$libobj" | $Xsed -e 's/\.lo$/.o/'` ;;
 297     *)
 298       $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2
 299       exit 1
 300       ;;
 301     esac
 302
 303     if test -z "$base_compile"; then
 304       $echo "$modename: you must specify a compilation command" 1>&2
 305       $echo "$help" 1>&2
 306       exit 1
 307     fi
 308
 309     # Delete any leftover library objects.
 310     if test "$build_old_libs" = yes; then
 311       $run $rm $obj $libobj
 312       trap "$run $rm $obj $libobj; exit 1" 1 2 15
 313     else
 314       $run $rm $libobj
 315       trap "$run $rm $libobj; exit 1" 1 2 15
 316     fi
 317
 318     # Only build a PIC object if we are building libtool libraries.
 319     if test "$build_libtool_libs" = yes; then
 320       # Without this assignment, base_compile gets emptied.
 321       fbsd_hideous_sh_bug=$base_compile
 322
 323       # All platforms use -DPIC, to notify preprocessed assembler code.
 324       $show "$base_compile$pic_flag -DPIC $srcfile"
 325       if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then :
 326       else
 327         test -n "$obj" && $run $rm $obj
 328         exit 1
 329       fi
 330
 331       # If we have no pic_flag, then copy the object into place and finish.
 332       if test -z "$pic_flag"; then
 333         $show "$LN_S $obj $libobj"
 334         $run $LN_S $obj $libobj
 335         exit $?
 336       fi
 337
 338       # Just move the object, then go on to compile the next one
 339       $show "$mv $obj $libobj"
 340       $run $mv $obj $libobj || exit 1
 341
 342       # Allow error messages only from the first compilation.
 343       suppress_output=' >/dev/null 2>&1'
 344     fi
 345
 346     # Only build a position-dependent object if we build old libraries.
 347     if test "$build_old_libs" = yes; then
 348       # Suppress compiler output if we already did a PIC compilation.
 349       $show "$base_compile $srcfile$suppress_output"
 350       if $run eval "$base_compile \$srcfile$suppress_output"; then :
 351       else
 352         $run $rm $obj $libobj
 353         exit 1
 354       fi
 355     fi
 356
 357     # Create an invalid libtool object if no PIC, so that we do not
 358     # accidentally link it into a program.
 359     if test "$build_libtool_libs" != yes; then
 360       $show "echo timestamp > $libobj"
 361       $run eval "echo timestamp > \$libobj" || exit $?
 362     fi
 363
 364     exit 0
 365     ;;
 366
 367   # libtool link mode
 368   link)
 369     modename="$modename: link"
 370     CC="$nonopt"
 371     allow_undefined=yes
 372     compile_command="$CC"
 373     finalize_command="$CC"
 374
 375     compile_shlibpath=
 376     finalize_shlibpath=
 377     deplibs=
 378     dlfiles=
 379     dlprefiles=
 380     export_dynamic=no
 381     hardcode_libdirs=
 382     libobjs=
 383     link_against_libtool_libs=
 384     ltlibs=
 385     objs=
 386     prev=
 387     prevarg=
 388     release=
 389     rpath=
 390     perm_rpath=
 391     temp_rpath=
 392     vinfo=
 393
 394     # We need to know -static, to get the right output filenames.
 395     for arg
 396     do
 397       case "$arg" in
 398       -all-static | -static)
 399         if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 400             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 401         fi
 402         build_libtool_libs=no
 403         build_old_libs=yes
 404         break
 405         ;;
 406       esac
 407     done
 408
 409     # See if our shared archives depend on static archives.
 410     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 411
 412     # Go through the arguments, transforming them on the way.
 413     for arg
 414     do
 415       # If the previous option needs an argument, assign it.
 416       if test -n "$prev"; then
 417         case "$prev" in
 418         output)
 419           compile_command="$compile_command @OUTPUT@"
 420           finalize_command="$finalize_command @OUTPUT@"
 421           ;;
 422         esac
 423
 424         case "$prev" in
 425         dlfiles|dlprefiles)
 426           case "$arg" in
 427           *.la | *.lo) ;;  # We handle these cases below.
 428           *)
 429             dlprefiles="$dlprefiles $arg"
 430             test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
 431             prev=
 432             ;;
 433           esac
 434           ;;
 435         release)
 436           release="-$arg"
 437           prev=
 438           continue
 439           ;;
 440         rpath)
 441           rpath="$rpath $arg"
 442           prev=
 443           continue
 444           ;;
 445         *)
 446           eval "$prev=\"\$arg\""
 447           prev=
 448           continue
 449           ;;
 450         esac
 451       fi
 452
 453       prevarg="$arg"
 454
 455       case "$arg" in
 456       -all-static)
 457         if test -n "$link_static_flag"; then
 458           compile_command="$compile_command $link_static_flag"
 459           finalize_command="$finalize_command $link_static_flag"
 460         fi
 461         continue
 462         ;;
 463
 464       -allow-undefined)
 465         # FIXME: remove this flag sometime in the future.
 466         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
 467         continue
 468         ;;
 469
 470       -dlopen)
 471         prev=dlfiles
 472         continue
 473         ;;
 474
 475       -dlpreopen)
 476         prev=dlprefiles
 477         continue
 478         ;;
 479
 480       -export-dynamic)
 481         if test "$export_dynamic" != yes; then
 482           export_dynamic=yes
 483           if test -n "$export_dynamic_flag_spec"; then
 484             eval arg=\"$export_dynamic_flag_spec\"
 485           else
 486             arg=
 487           fi
 488
 489           # Add the symbol object into the linking commands.
 490           compile_command="$compile_command @SYMFILE@"
 491           finalize_command="$finalize_command @SYMFILE@"
 492         fi
 493         ;;
 494
 495       -L*)
 496         dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
 497         case "$dir" in
 498         /* | [A-Za-z]:\\*)
 499           # Add the corresponding hardcode_libdir_flag, if it is not identical.
 500           ;;
 501         *)
 502           $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
 503           exit 1
 504           ;;
 505         esac
 506         deplibs="$deplibs $arg"
 507         ;;
 508
 509       -l*) deplibs="$deplibs $arg" ;;
 510
 511       -no-undefined)
 512         allow_undefined=no
 513         continue
 514         ;;
 515
 516       -o) prev=output ;;
 517
 518       -release)
 519         prev=release
 520         continue
 521         ;;
 522
 523       -rpath)
 524         prev=rpath
 525         continue
 526         ;;
 527
 528       -static)
 529         # If we have no pic_flag, then this is the same as -all-static.
 530         if test -z "$pic_flag" && test -n "$link_static_flag"; then
 531           compile_command="$compile_command $link_static_flag"
 532           finalize_command="$finalize_command $link_static_flag"
 533         fi
 534         continue
 535         ;;
 536
 537       -version-info)
 538         prev=vinfo
 539         continue
 540         ;;
 541
 542       # Some other compiler flag.
 543       -* | +*)
 544         # Unknown arguments in both finalize_command and compile_command need
 545         # to be aesthetically quoted because they are evaled later.
 546         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 547         case "$arg" in
 548         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
 549           arg="\"$arg\""
 550           ;;
 551         esac
 552         ;;
 553
 554       *.o | *.a)
 555         # A standard object.
 556         objs="$objs $arg"
 557         ;;
 558
 559       *.lo)
 560         # A library object.
 561         if test "$prev" = dlfiles; then
 562           dlfiles="$dlfiles $arg"
 563           if test "$build_libtool_libs" = yes; then
 564             prev=
 565             continue
 566           else
 567             # If libtool objects are unsupported, then we need to preload.
 568             prev=dlprefiles
 569           fi
 570         fi
 571
 572         if test "$prev" = dlprefiles; then
 573           # Preload the old-style object.
 574           dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e 's/\.lo$/\.o/'`
 575           prev=
 576         fi
 577         libobjs="$libobjs $arg"
 578         ;;
 579
 580       *.la)
 581         # A libtool-controlled library.
 582
 583         dlname=
 584         libdir=
 585         library_names=
 586         old_library=
 587
 588         # Check to see that this really is a libtool archive.
 589         if (sed -e '2q' $arg | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
 590         else
 591           $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
 592           exit 1
 593         fi
 594
 595         # If there is no directory component, then add one.
 596         case "$arg" in
 597         */* | *\\*) . $arg ;;
 598         *) . ./$arg ;;
 599         esac
 600
 601         if test -z "$libdir"; then
 602           $echo "$modename: \`$arg' contains no -rpath information" 1>&2
 603           exit 1
 604         fi
 605
 606         # Get the name of the library we link against.
 607         linklib=
 608         for l in $old_library $library_names; do
 609           linklib="$l"
 610         done
 611
 612         if test -z "$linklib"; then
 613           $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
 614           exit 1
 615         fi
 616
 617         # Find the relevant object directory and library name.
 618         name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
 619         dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 620         if test "X$dir" = "X$arg"; then
 621           dir="$objdir"
 622         else
 623           dir="$dir/$objdir"
 624         fi
 625
 626         # This library was specified with -dlopen.
 627         if test "$prev" = dlfiles; then
 628           dlfiles="$dlfiles $arg"
 629           if test -z "$dlname"; then
 630             # If there is no dlname, we need to preload.
 631             prev=dlprefiles
 632           else
 633             # We should not create a dependency on this library, but we
 634             # may need any libraries it requires.
 635             compile_command="$compile_command$dependency_libs"
 636             finalize_command="$finalize_command$dependency_libs"
 637             prev=
 638             continue
 639           fi
 640         fi
 641
 642         # The library was specified with -dlpreopen.
 643         if test "$prev" = dlprefiles; then
 644           # Prefer using a static library (so that no silly _DYNAMIC symbols
 645           # are required to link).
 646           if test -n "$old_library"; then
 647             dlprefiles="$dlprefiles $dir/$old_library"
 648           else
 649             dlprefiles="$dlprefiles $dir/$linklib"
 650           fi
 651           prev=
 652         fi
 653
 654         if test "$build_libtool_libs" = yes && test -n "$library_names"; then
 655           link_against_libtool_libs="$link_against_libtool_libs $arg"
 656           if test -n "$shlibpath_var"; then
 657             # Make sure the rpath contains only unique directories.
 658             case "$temp_rpath " in
 659             *" $dir "*) ;;
 660             *) temp_rpath="$temp_rpath $dir" ;;
 661             esac
 662           fi
 663
 664           # This is the magic to use -rpath.
 665           if test -n "$hardcode_libdir_flag_spec"; then
 666             if test -n "$hardcode_libdir_separator"; then
 667               if test -z "$hardcode_libdirs"; then
 668                 # Put the magic libdir with the hardcode flag.
 669                 hardcode_libdirs="$libdir"
 670                 libdir="@HARDCODE_LIBDIRS@"
 671               else
 672                 # Just accumulate the unique libdirs.
 673                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
 674                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 675                   ;;
 676                 *)
 677                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 678                   ;;
 679                 esac
 680                 libdir=
 681               fi
 682             fi
 683
 684             if test -n "$libdir"; then
 685               eval flag=\"$hardcode_libdir_flag_spec\"
 686
 687               compile_command="$compile_command $flag"
 688               finalize_command="$finalize_command $flag"
 689             fi
 690           elif test -n "$runpath_var"; then
 691             # Do the same for the permanent run path.
 692             case "$perm_rpath " in
 693             *" $libdir "*) ;;
 694             *) perm_rpath="$perm_rpath $libdir" ;;
 695             esac
 696           fi
 697
 698
 699           case "$hardcode_action" in
 700           immediate)
 701             if test "$hardcode_direct" = no; then
 702               compile_command="$compile_command $dir/$linklib"
 703             elif test "$hardcode_minus_L" = no; then
 704               compile_command="$compile_command -L$dir -l$name"
 705             elif test "$hardcode_shlibpath_var" = no; then
 706               compile_shlibpath="$compile_shlibpath$dir:"
 707               compile_command="$compile_command -l$name"
 708             fi
 709             ;;
 710
 711           relink)
 712             # We need an absolute path.
 713             case "$dir" in
 714             /* | [A-Za-z]:\\*) ;;
 715             *)
 716               absdir=`cd "$dir" && pwd`
 717               if test -z "$absdir"; then
 718                 $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
 719                 exit 1
 720               fi
 721               dir="$absdir"
 722               ;;
 723             esac
 724
 725             if test "$hardcode_direct" = yes; then
 726               compile_command="$compile_command $dir/$linklib"
 727             elif test "$hardcode_minus_L" = yes; then
 728               compile_command="$compile_command -L$dir -l$name"
 729             elif test "$hardcode_shlibpath_var" = yes; then
 730               compile_shlibpath="$compile_shlibpath$dir:"
 731               compile_command="$compile_command -l$name"
 732             fi
 733             ;;
 734
 735           *)
 736             $echo "$modename: \`$hardcode_action' is an unknown hardcode action" 1>&2
 737             exit 1
 738             ;;
 739           esac
 740
 741           # Finalize command for both is simple: just hardcode it.
 742           if test "$hardcode_direct" = yes; then
 743             finalize_command="$finalize_command $libdir/$linklib"
 744           elif test "$hardcode_minus_L" = yes; then
 745             finalize_command="$finalize_command -L$libdir -l$name"
 746           elif test "$hardcode_shlibpath_var" = yes; then
 747             finalize_shlibpath="$finalize_shlibpath$libdir:"
 748             finalize_command="$finalize_command -l$name"
 749           else
 750             # We cannot seem to hardcode it, guess we'll fake it.
 751             finalize_command="$finalize_command -L$libdir -l$name"
 752           fi
 753         else
 754           # Transform directly to old archives if we don't build new libraries.
 755           if test -n "$pic_flag" && test -z "$old_library"; then
 756             $echo "$modename: cannot find static library for \`$arg'" 1>&2
 757             exit 1
 758           fi
 759
 760           # Here we assume that one of hardcode_direct or hardcode_minus_L
 761           # is not unsupported.  This is valid on all known static and
 762           # shared platforms.
 763           if test "$hardcode_direct" != unsupported; then
 764             test -n "$old_library" && linklib="$old_library"
 765             compile_command="$compile_command $dir/$linklib"
 766             finalize_command="$finalize_command $dir/$linklib"
 767           else
 768             compile_command="$compile_command -L$dir -l$name"
 769             finalize_command="$finalize_command -L$dir -l$name"
 770           fi
 771         fi
 772
 773         # Add in any libraries that this one depends upon.
 774         compile_command="$compile_command$dependency_libs"
 775         finalize_command="$finalize_command$dependency_libs"
 776         continue
 777         ;;
 778
 779       # Some other compiler argument.
 780       *)
 781         # Unknown arguments in both finalize_command and compile_command need
 782         # to be aesthetically quoted because they are evaled later.
 783         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 784         case "$arg" in
 785         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
 786           arg="\"$arg\""
 787           ;;
 788         esac
 789         ;;
 790       esac
 791
 792       # Now actually substitute the argument into the commands.
 793       if test -n "$arg"; then
 794         compile_command="$compile_command $arg"
 795         finalize_command="$finalize_command $arg"
 796       fi
 797     done
 798
 799     if test -n "$prev"; then
 800       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
 801       $echo "$help" 1>&2
 802       exit 1
 803     fi
 804
 805     if test -n "$vinfo" && test -n "$release"; then
 806       $echo "$modename: you cannot specify both \`-version-info' and \`-release'" 1>&2
 807       $echo "$help" 1>&2
 808       exit 1
 809     fi
 810
 811     oldlib=
 812     oldobjs=
 813     case "$output" in
 814     "")
 815       $echo "$modename: you must specify an output file" 1>&2
 816       $echo "$help" 1>&2
 817       exit 1
 818       ;;
 819
 820     */* | *\\*)
 821       $echo "$modename: output file \`$output' must have no directory components" 1>&2
 822       exit 1
 823       ;;
 824
 825     *.a)
 826       # Now set the variables for building old libraries.
 827       build_libtool_libs=no
 828       build_old_libs=yes
 829       oldlib="$output"
 830       $show "$rm $oldlib"
 831       $run $rm $oldlib
 832       ;;
 833
 834     *.la)
 835       # Make sure we only generate libraries of the form `libNAME.la'.
 836       case "$output" in
 837       lib*) ;;
 838       *)
 839         $echo "$modename: libtool library \`$arg' must begin with \`lib'" 1>&2
 840         $echo "$help" 1>&2
 841         exit 1
 842         ;;
 843       esac
 844
 845       name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 846       eval libname=\"$libname_spec\"
 847
 848       # All the library-specific variables (install_libdir is set above).
 849       library_names=
 850       old_library=
 851       dlname=
 852       current=0
 853       revision=0
 854       age=0
 855
 856       if test -n "$objs"; then
 857         $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
 858         exit 1
 859       fi
 860
 861       # How the heck are we supposed to write a wrapper for a shared library?
 862       if test -n "$link_against_libtool_libs"; then
 863         $echo "$modename: libtool library \`$output' may not depend on uninstalled libraries:$link_against_libtool_libs" 1>&2
 864         exit 1
 865       fi
 866
 867       if test -n "$dlfiles$dlprefiles"; then
 868         $echo "$modename: warning: \`-dlopen' is ignored while creating libtool libraries" 1>&2
 869         # Nullify the symbol file.
 870         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
 871         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
 872       fi
 873
 874       if test -z "$rpath"; then
 875         $echo "$modename: you must specify an installation directory with \`-rpath'" 1>&2
 876         $echo "$help" 1>&2
 877         exit 1
 878       fi
 879
 880       set dummy $rpath
 881       if test $# -gt 2; then
 882         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
 883       fi
 884       install_libdir="$2"
 885
 886       # Parse the version information argument.
 887       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=':'
 888       set dummy $vinfo
 889       IFS="$save_ifs"
 890
 891       if test -n "$5"; then
 892         $echo "$modename: too many parameters to \`-version-info'" 1>&2
 893         $echo "$help" 1>&2
 894         exit 1
 895       fi
 896
 897       test -n "$2" && current="$2"
 898       test -n "$3" && revision="$3"
 899       test -n "$4" && age="$4"
 900
 901       # Check that each of the things are valid numbers.
 902       case "$current" in
 903       0 | [1-9] | [1-9][0-9]*) ;;
 904       *)
 905         $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
 906         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 907         exit 1
 908         ;;
 909       esac
 910
 911       case "$revision" in
 912       0 | [1-9] | [1-9][0-9]*) ;;
 913       *)
 914         $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
 915         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 916         exit 1
 917         ;;
 918       esac
 919
 920       case "$age" in
 921       0 | [1-9] | [1-9][0-9]*) ;;
 922       *)
 923         $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
 924         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 925         exit 1
 926         ;;
 927       esac
 928
 929       if test $age -gt $current; then
 930         $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
 931         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 932         exit 1
 933       fi
 934
 935       # Calculate the version variables.
 936       version_vars="version_type current age revision"
 937       case "$version_type" in
 938       none) ;;
 939
 940       linux)
 941         version_vars="$version_vars major versuffix"
 942         major=`expr $current - $age`
 943         versuffix="$major.$age.$revision"
 944         ;;
 945
 946       osf)
 947         version_vars="$version_vars versuffix verstring"
 948         major=`expr $current - $age`
 949         versuffix="$current.$age.$revision"
 950         verstring="$versuffix"
 951
 952         # Add in all the interfaces that we are compatible with.
 953         loop=$age
 954         while test $loop != 0; do
 955           iface=`expr $current - $loop`
 956           loop=`expr $loop - 1`
 957           verstring="$verstring:${iface}.0"
 958         done
 959
 960         # Make executables depend on our current version.
 961         verstring="$verstring:${current}.0"
 962         ;;
 963
 964       sunos)
 965         version_vars="$version_vars major versuffix"
 966         major="$current"
 967         versuffix="$current.$revision"
 968         ;;
 969
 970       freebsd)
 971         version_vars="$version_vars major versuffix"
 972         major="$current"
 973
 974         if [ X"$OBJFORMAT" = X ]; then
 975                 if [ -x /usr/bin/objformat ]; then
 976                         OBJECTFORMAT=`objformat`
 977                 fi
 978         fi
 979
 980         if [ "$OBJFORMAT" = elf ]; then
 981                 versuffix="$current";
 982         else
 983                 versuffix="$current.$revision";
 984         fi
 985         ;;
 986
 987       *)
 988         $echo "$modename: unknown library version type \`$version_type'" 1>&2
 989         echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 990         exit 1
 991         ;;
 992       esac
 993
 994       # Create the output directory, or remove our outputs if we need to.
 995       if test -d $objdir; then
 996         $show "$rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*"
 997         $run $rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*
 998       else
 999         $show "$mkdir $objdir"
1000         $run $mkdir $objdir
1001         status=$?
1002         if test $status -eq 0 || test -d $objdir; then :
1003         else
1004           exit $status
1005         fi
1006       fi
1007
1008       # Check to see if the archive will have undefined symbols.
1009       if test "$allow_undefined" = yes; then
1010         if test "$allow_undefined_flag" = unsupported; then
1011           $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
1012           build_libtool_libs=no
1013           build_old_libs=yes
1014         fi
1015       else
1016         # Don't allow undefined symbols.
1017         allow_undefined_flag="$no_undefined_flag"
1018       fi
1019
1020       # Add libc to deplibs on all systems.
1021       dependency_libs="$deplibs"
1022       deplibs="$deplibs -lc"
1023
1024       if test "$build_libtool_libs" = yes; then
1025         # Get the real and link names of the library.
1026         eval library_names=\"$library_names_spec\"
1027         set dummy $library_names
1028         realname="$2"
1029         shift; shift
1030
1031         if test -n "$soname_spec"; then
1032           eval soname=\"$soname_spec\"
1033         else
1034           soname="$realname"
1035         fi
1036
1037         lib="$objdir/$realname"
1038         for link
1039         do
1040           linknames="$linknames $link"
1041         done
1042
1043         # Use standard objects if they are PIC.
1044         test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//g'`
1045
1046         # Do each of the archive commands.
1047         eval cmds=\"$archive_cmds\"
1048         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1049         for cmd in $cmds; do
1050           IFS="$save_ifs"
1051           $show "$cmd"
1052           $run eval "$cmd" || exit $?
1053         done
1054         IFS="$save_ifs"
1055
1056         # Create links to the real library.
1057         for linkname in $linknames; do
1058           $show "(cd $objdir && $LN_S $realname $linkname)"
1059           $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $?
1060         done
1061
1062         # If -export-dynamic was specified, set the dlname.
1063         if test "$export_dynamic" = yes; then
1064           # On all known operating systems, these are identical.
1065           dlname="$soname"
1066         fi
1067       fi
1068
1069       # Now set the variables for building old libraries.
1070       oldlib="$objdir/$libname.a"
1071       ;;
1072
1073     *.lo | *.o)
1074       if test -n "$link_against_libtool_libs"; then
1075         $echo "$modename: error: cannot link libtool libraries into reloadable objects" 1>&2
1076         exit 1
1077       fi
1078
1079       if test -n "$deplibs"; then
1080         $echo "$modename: warning: \`-l' and \`-L' are ignored while creating objects" 1>&2
1081       fi
1082
1083       if test -n "$dlfiles$dlprefiles"; then
1084         $echo "$modename: warning: \`-dlopen' is ignored while creating objects" 1>&2
1085         # Nullify the symbol file.
1086         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1087         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1088       fi
1089
1090       if test -n "$rpath"; then
1091         $echo "$modename: warning: \`-rpath' is ignored while creating objects" 1>&2
1092       fi
1093
1094       if test -n "$vinfo"; then
1095         $echo "$modename: warning: \`-version-info' is ignored while creating objects" 1>&2
1096       fi
1097
1098       if test -n "$release"; then
1099         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
1100       fi
1101
1102       case "$output" in
1103       *.lo)
1104         if test -n "$objs"; then
1105           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
1106           exit 1
1107         fi
1108         libobj="$output"
1109         obj=`$echo "X$output" | $Xsed -e 's/\.lo$/.o/'`
1110         ;;
1111       *)
1112         libobj=
1113         obj="$output"
1114         ;;
1115       esac
1116
1117       # Delete the old objects.
1118       $run $rm $obj $libobj
1119
1120       # Create the old-style object.
1121       reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^       ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
1122
1123       output="$obj"
1124       eval cmds=\"$reload_cmds\"
1125       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1126       for cmd in $cmds; do
1127         IFS="$save_ifs"
1128         $show "$cmd"
1129         $run eval "$cmd" || exit $?
1130       done
1131       IFS="$save_ifs"
1132
1133       # Exit if we aren't doing a library object file.
1134       test -z "$libobj" && exit 0
1135
1136       if test "$build_libtool_libs" != yes; then
1137         # Create an invalid libtool object if no PIC, so that we don't
1138         # accidentally link it into a program.
1139         $show "echo timestamp > $libobj"
1140         $run eval "echo timestamp > $libobj" || exit $?
1141         exit 0
1142       fi
1143
1144       if test -n "$pic_flag"; then
1145         # Only do commands if we really have different PIC objects.
1146         reload_objs="$libobjs"
1147         output="$libobj"
1148         eval cmds=\"$reload_cmds\"
1149         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1150         for cmd in $cmds; do
1151           IFS="$save_ifs"
1152           $show "$cmd"
1153           $run eval "$cmd" || exit $?
1154         done
1155         IFS="$save_ifs"
1156       else
1157         # Just create a symlink.
1158         $show "$LN_S $obj $libobj"
1159         $run $LN_S $obj $libobj || exit 1
1160       fi
1161
1162       exit 0
1163       ;;
1164
1165     *)
1166       if test -n "$vinfo"; then
1167         $echo "$modename: warning: \`-version-info' is ignored while linking programs" 1>&2
1168       fi
1169
1170       if test -n "$release"; then
1171         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
1172       fi
1173
1174       if test -n "$rpath"; then
1175         # If the user specified any rpath flags, then add them.
1176         for libdir in $rpath; do
1177           if test -n "$hardcode_libdir_flag_spec"; then
1178             if test -n "$hardcode_libdir_separator"; then
1179               if test -z "$hardcode_libdirs"; then
1180                 # Put the magic libdir with the hardcode flag.
1181                 hardcode_libdirs="$libdir"
1182                 libdir="@HARDCODE_LIBDIRS@"
1183               else
1184                 # Just accumulate the unique libdirs.
1185                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
1186                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
1187                   ;;
1188                 *)
1189                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
1190                   ;;
1191                 esac
1192                 libdir=
1193               fi
1194             fi
1195
1196             if test -n "$libdir"; then
1197               eval flag=\"$hardcode_libdir_flag_spec\"
1198
1199               compile_command="$compile_command $flag"
1200               finalize_command="$finalize_command $flag"
1201             fi
1202           elif test -n "$runpath_var"; then
1203             case "$perm_rpath " in
1204             *" $libdir "*) ;;
1205             *) perm_rpath="$perm_rpath $libdir" ;;
1206             esac
1207           fi
1208         done
1209       fi
1210
1211       # Substitute the hardcoded libdirs into the compile commands.
1212       if test -n "$hardcode_libdir_separator"; then
1213         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1214         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1215       fi
1216
1217       if test -n "$libobjs" && test "$build_old_libs" = yes; then
1218         # Transform all the library objects into standard objects.
1219         compile_command=`$echo "X$compile_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1220         finalize_command=`$echo "X$finalize_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1221       fi
1222
1223       if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then
1224         dlsyms="${output}S.c"
1225       else
1226         dlsyms=
1227       fi
1228
1229       if test -n "$dlsyms"; then
1230         # Add our own program objects to the preloaded list.
1231         dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1232
1233         # Discover the nlist of each of the dlfiles.
1234         nlist="$objdir/${output}.nm"
1235
1236         if test -d $objdir; then
1237           $show "$rm $nlist ${nlist}T"
1238           $run $rm "$nlist" "${nlist}T"
1239         else
1240           $show "$mkdir $objdir"
1241           $run $mkdir $objdir
1242           status=$?
1243           if test $status -eq 0 || test -d $objdir; then :
1244           else
1245             exit $status
1246           fi
1247         fi
1248
1249         for arg in $dlprefiles; do
1250           $show "extracting global C symbols from \`$arg'"
1251           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
1252         done
1253
1254         # Parse the name list into a source file.
1255         $show "creating $objdir/$dlsyms"
1256         if test -z "$run"; then
1257           # Make sure we at least have an empty file.
1258           test -f "$nlist" || : > "$nlist"
1259
1260           # Try sorting and uniquifying the output.
1261           if sort "$nlist" | uniq > "$nlist"T; then
1262             mv -f "$nlist"T "$nlist"
1263             wcout=`wc "$nlist" 2>/dev/null`
1264             count=`echo "X$wcout" | $Xsed -e 's/^[      ]*\([0-9][0-9]*\).*$/\1/'`
1265             (test "$count" -ge 0) 2>/dev/null || count=-1
1266           else
1267             $rm "$nlist"T
1268             count=-1
1269           fi
1270
1271           case "$dlsyms" in
1272           "") ;;
1273           *.c)
1274             $echo > "$objdir/$dlsyms" "\
1275 /* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */
1276 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */
1277
1278 #ifdef __cplusplus
1279 extern \"C\" {
1280 #endif
1281
1282 /* Prevent the only kind of declaration conflicts we can make. */
1283 #define dld_preloaded_symbol_count some_other_symbol
1284 #define dld_preloaded_symbols some_other_symbol
1285
1286 /* External symbol declarations for the compiler. */\
1287 "
1288
1289             if test -f "$nlist"; then
1290               sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms"
1291             else
1292               echo '/* NONE */' >> "$objdir/$dlsyms"
1293             fi
1294
1295             $echo >> "$objdir/$dlsyms" "\
1296
1297 #undef dld_preloaded_symbol_count
1298 #undef dld_preloaded_symbols
1299
1300 #if defined (__STDC__) && __STDC__
1301 # define __ptr_t void *
1302 #else
1303 # define __ptr_t char *
1304 #endif
1305
1306 /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */
1307 int dld_preloaded_symbol_count = $count;
1308
1309 /* The mapping between symbol names and symbols. */
1310 struct {
1311   char *name;
1312   __ptr_t address;
1313 }
1314 dld_preloaded_symbols[] =
1315 {\
1316 "
1317
1318             if test -f "$nlist"; then
1319               sed 's/^\(.*\) \(.*\)$/  {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms"
1320             fi
1321
1322             $echo >> "$objdir/$dlsyms" "\
1323   {0, (__ptr_t) 0}
1324 };
1325
1326 #ifdef __cplusplus
1327 }
1328 #endif\
1329 "
1330             ;;
1331
1332           *)
1333             $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
1334             exit 1
1335             ;;
1336           esac
1337         fi
1338
1339         # Now compile the dynamic symbol file.
1340         $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")"
1341         $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $?
1342
1343         # Transform the symbol file into the correct name.
1344         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
1345         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
1346       elif test "$export_dynamic" != yes; then
1347         test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2
1348       else
1349         # We keep going just in case the user didn't refer to
1350         # dld_preloaded_symbols.  The linker will fail if global_symbol_pipe
1351         # really was required.
1352         $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
1353
1354         # Nullify the symbol file.
1355         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1356         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1357       fi
1358
1359       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
1360         # Replace the output file specification.
1361         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1362         finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1363
1364         # We have no uninstalled library dependencies, so finalize right now.
1365         $show "$compile_command"
1366         $run eval "$compile_command"
1367         exit $?
1368       fi
1369
1370       # Replace the output file specification.
1371       compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'`
1372       finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'`
1373
1374       # Create the binary in the object directory, then wrap it.
1375       if test -d $objdir; then :
1376       else
1377         $show "$mkdir $objdir"
1378         $run $mkdir $objdir
1379         status=$?
1380         if test $status -eq 0 || test -d $objdir; then :
1381         else
1382           exit $status
1383         fi
1384       fi
1385
1386       if test -n "$shlibpath_var"; then
1387         # We should set the shlibpath_var
1388         rpath=
1389         for dir in $temp_rpath; do
1390           case "$dir" in
1391           /* | [A-Za-z]:\\*)
1392             # Absolute path.
1393             rpath="$rpath$dir:"
1394             ;;
1395           *)
1396             # Relative path: add a thisdir entry.
1397             rpath="$rpath\$thisdir/$dir:"
1398             ;;
1399           esac
1400         done
1401         temp_rpath="$rpath"
1402       fi
1403
1404       # Delete the old output file.
1405       $run $rm $output
1406
1407       if test -n "$compile_shlibpath"; then
1408         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
1409       fi
1410       if test -n "$finalize_shlibpath"; then
1411         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
1412       fi
1413
1414       if test -n "$runpath_var" && test -n "$perm_rpath"; then
1415         # We should set the runpath_var.
1416         rpath=
1417         for dir in $perm_rpath; do
1418           rpath="$rpath$dir:"
1419         done
1420         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
1421         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
1422       fi
1423
1424       case "$hardcode_action" in
1425       relink)
1426         # AGH! Flame the AIX and HP-UX people for me, will ya?
1427         $echo "$modename: warning: using a buggy system linker" 1>&2
1428         $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2
1429         ;;
1430       esac
1431
1432       $show "$compile_command"
1433       $run eval "$compile_command" || exit $?
1434
1435       # Now create the wrapper script.
1436       $show "creating $output"
1437
1438       # Quote the finalize command for shipping.
1439       finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"`
1440
1441       # Quote $echo for shipping.
1442       qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
1443
1444       # Only actually do things if our run command is non-null.
1445       if test -z "$run"; then
1446         $rm $output
1447         trap "$rm $output; exit 1" 1 2 15
1448
1449         $echo > $output "\
1450 #! /bin/sh
1451
1452 # $output - temporary wrapper script for $objdir/$output
1453 # Generated by ltmain.sh - GNU $PACKAGE $VERSION
1454 #
1455 # The $output program cannot be directly executed until all the libtool
1456 # libraries that it depends on are installed.
1457 #
1458 # This wrapper script should never be moved out of \``pwd`'.
1459 # If it is, it will not operate correctly.
1460
1461 # Sed substitution that helps us do robust quoting.  It backslashifies
1462 # metacharacters that are still active within double-quoted strings.
1463 Xsed='sed -e s/^X//'
1464 sed_quote_subst='$sed_quote_subst'
1465
1466 # The HP-UX ksh and POSIX shell print the target directory to stdout
1467 # if CDPATH is set.
1468 if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi
1469
1470 # This environment variable determines our operation mode.
1471 if test \"\$libtool_install_magic\" = \"$magic\"; then
1472   # install mode needs the following variables:
1473   link_against_libtool_libs='$link_against_libtool_libs'
1474   finalize_command=\"$finalize_command\"
1475 else
1476   # When we are sourced in execute mode, \$file and \$echo are already set.
1477   if test \"\$libtool_execute_magic\" = \"$magic\"; then :
1478   else
1479     echo=\"$qecho\"
1480     file=\"\$0\"
1481   fi\
1482 "
1483         $echo >> $output "\
1484
1485   # Find the directory that this script lives in.
1486   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
1487   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
1488
1489   # Follow symbolic links until we get to the real thisdir.
1490   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
1491   while test -n \"\$file\"; do
1492     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
1493
1494     # If there was a directory component, then change thisdir.
1495     if test \"x\$destdir\" != \"x\$file\"; then
1496       case \"\$destdir\" in
1497       /* | [A-Za-z]:\\*) thisdir=\"\$destdir\" ;;
1498       *) thisdir=\"\$thisdir/\$destdir\" ;;
1499       esac
1500     fi
1501
1502     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
1503     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
1504   done
1505
1506   # Try to get the absolute directory name.
1507   absdir=\`cd \"\$thisdir\" && pwd\`
1508   test -n \"\$absdir\" && thisdir=\"\$absdir\"
1509
1510   progdir=\"\$thisdir/$objdir\"
1511   program='$output'
1512
1513   if test -f \"\$progdir/\$program\"; then"
1514
1515         # Export our shlibpath_var if we have one.
1516         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
1517           $echo >> $output "\
1518     # Add our own library path to $shlibpath_var
1519     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
1520
1521     # Some systems cannot cope with colon-terminated $shlibpath_var
1522     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\`
1523
1524     export $shlibpath_var
1525 "
1526         fi
1527
1528         $echo >> $output "\
1529     if test \"\$libtool_execute_magic\" != \"$magic\"; then
1530       # Run the actual program with our arguments.
1531
1532       # Export the path to the program.
1533       PATH=\"\$progdir:\$PATH\"
1534       export PATH
1535
1536       exec \$program \${1+\"\$@\"}
1537
1538       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
1539       exit 1
1540     fi
1541   else
1542     # The program doesn't exist.
1543     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
1544     \$echo \"This script is just a wrapper for \$program.\" 1>&2
1545     echo \"See the $PACKAGE documentation for more information.\" 1>&2
1546     exit 1
1547   fi
1548 fi\
1549 "
1550         chmod +x $output
1551       fi
1552       exit 0
1553       ;;
1554     esac
1555
1556     # See if we need to build an old-fashioned archive.
1557     if test "$build_old_libs" = "yes"; then
1558       # Transform .lo files to .o files.
1559       oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^   ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
1560
1561       # Do each command in the archive commands.
1562       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
1563         eval cmds=\"$old_archive_from_new_cmds\"
1564       else
1565         eval cmds=\"$old_archive_cmds\"
1566       fi
1567       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1568       for cmd in $cmds; do
1569         IFS="$save_ifs"
1570         $show "$cmd"
1571         $run eval "$cmd" || exit $?
1572       done
1573       IFS="$save_ifs"
1574     fi
1575
1576     # Now create the libtool archive.
1577     case "$output" in
1578     *.la)
1579       old_library=
1580       test "$build_old_libs" = yes && old_library="$libname.a"
1581
1582       $show "creating $output"
1583
1584       # Only create the output if not a dry run.
1585       if test -z "$run"; then
1586         $echo > $output "\
1587 # $output - a libtool library file
1588 # Generated by ltmain.sh - GNU $PACKAGE $VERSION
1589
1590 # The name that we can dlopen(3).
1591 dlname='$dlname'
1592
1593 # Names of this library.
1594 library_names='$library_names'
1595
1596 # The name of the static archive.
1597 old_library='$old_library'
1598
1599 # Libraries that this one depends upon.
1600 dependency_libs='$dependency_libs'
1601
1602 # Version information for $libname.
1603 current=$current
1604 age=$age
1605 revision=$revision
1606
1607 # Directory that this library needs to be installed in:
1608 libdir='$install_libdir'\
1609 "
1610       fi
1611
1612       # Do a symbolic link so that the libtool archive can be found in
1613       # LD_LIBRARY_PATH before the program is installed.
1614       $show "(cd $objdir && $LN_S ../$output $output)"
1615       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit 1
1616       ;;
1617     esac
1618     exit 0
1619     ;;
1620
1621   # libtool install mode
1622   install)
1623     modename="$modename: install"
1624
1625     # There may be an optional /bin/sh argument at the beginning of
1626     # install_prog (especially on Windows NT).
1627     if test "$nonopt" = "$SHELL"; then
1628       # Aesthetically quote it.
1629       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
1630       case "$arg" in
1631       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1632         arg="\"$arg\""
1633         ;;
1634       esac
1635       install_prog="$arg "
1636       arg="$1"
1637       shift
1638     else
1639       install_prog=
1640       arg="$nonopt"
1641     fi
1642
1643     # The real first argument should be the name of the installation program.
1644     # Aesthetically quote it.
1645     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1646     case "$arg" in
1647     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
1648       arg="\"$arg\""
1649       ;;
1650     esac
1651     install_prog="$install_prog$arg"
1652
1653     # We need to accept at least all the BSD install flags.
1654     dest=
1655     files=
1656     opts=
1657     prev=
1658     install_type=
1659     isdir=
1660     stripme=
1661     for arg
1662     do
1663       if test -n "$dest"; then
1664         files="$files $dest"
1665         dest="$arg"
1666         continue
1667       fi
1668
1669       case "$arg" in
1670       -d) isdir=yes ;;
1671       -f) prev="-f" ;;
1672       -g) prev="-g" ;;
1673       -m) prev="-m" ;;
1674       -o) prev="-o" ;;
1675       -s)
1676         stripme=" -s"
1677         continue
1678         ;;
1679       -*) ;;
1680
1681       *)
1682         # If the previous option needed an argument, then skip it.
1683         if test -n "$prev"; then
1684           prev=
1685         else
1686           dest="$arg"
1687           continue
1688         fi
1689         ;;
1690       esac
1691
1692       # Aesthetically quote the argument.
1693       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1694       case "$arg" in
1695       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1696         arg="\"$arg\""
1697         ;;
1698       esac
1699       install_prog="$install_prog $arg"
1700     done
1701
1702     if test -z "$install_prog"; then
1703       $echo "$modename: you must specify an install program" 1>&2
1704       $echo "$help" 1>&2
1705       exit 1
1706     fi
1707
1708     if test -n "$prev"; then
1709       $echo "$modename: the \`$prev' option requires an argument" 1>&2
1710       $echo "$help" 1>&2
1711       exit 1
1712     fi
1713
1714     if test -z "$files"; then
1715       if test -z "$dest"; then
1716         $echo "$modename: no file or destination specified" 1>&2
1717       else
1718         $echo "$modename: you must specify a destination" 1>&2
1719       fi
1720       $echo "$help" 1>&2
1721       exit 1
1722     fi
1723
1724     # Strip any trailing slash from the destination.
1725     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
1726
1727     # Check to see that the destination is a directory.
1728     test -d "$dest" && isdir=yes
1729     if test -n "$isdir"; then
1730       destdir="$dest"
1731       destname=
1732     else
1733       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
1734       test "X$destdir" = "X$dest" && destdir=.
1735       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
1736
1737       # Not a directory, so check to see that there is only one file specified.
1738       set dummy $files
1739       if test $# -gt 2; then
1740         $echo "$modename: \`$dest' is not a directory" 1>&2
1741         $echo "$help" 1>&2
1742         exit 1
1743       fi
1744     fi
1745     case "$destdir" in
1746     /* | [A-Za-z]:\\*) ;;
1747     *)
1748       for file in $files; do
1749         case "$file" in
1750         *.lo) ;;
1751         *)
1752           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
1753           $echo "$help" 1>&2
1754           exit 1
1755           ;;
1756         esac
1757       done
1758       ;;
1759     esac
1760
1761     # This variable tells wrapper scripts just to set variables rather
1762     # than running their programs.
1763     libtool_install_magic="$magic"
1764
1765     staticlibs=
1766     future_libdirs=
1767     current_libdirs=
1768     for file in $files; do
1769
1770       # Do each installation.
1771       case "$file" in
1772       *.a)
1773         # Do the static libraries later.
1774         staticlibs="$staticlibs $file"
1775         ;;
1776
1777       *.la)
1778         # Check to see that this really is a libtool archive.
1779         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
1780         else
1781           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
1782           $echo "$help" 1>&2
1783           exit 1
1784         fi
1785
1786         library_names=
1787         old_library=
1788         # If there is no directory component, then add one.
1789         case "$file" in
1790         */* | *\\*) . $file ;;
1791         *) . ./$file ;;
1792         esac
1793
1794         # Add the libdir to current_libdirs if it is the destination.
1795         if test "X$destdir" = "X$libdir"; then
1796           case "$current_libdirs " in
1797           *" $libdir "*) ;;
1798           *) current_libdirs="$current_libdirs $libdir" ;;
1799           esac
1800         else
1801           # Note the libdir as a future libdir.
1802           case "$future_libdirs " in
1803           *" $libdir "*) ;;
1804           *) future_libdirs="$future_libdirs $libdir" ;;
1805           esac
1806         fi
1807
1808         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
1809         test "X$dir" = "X$file/" && dir=
1810         dir="$dir$objdir"
1811
1812         # See the names of the shared library.
1813         set dummy $library_names
1814         if test -n "$2"; then
1815           realname="$2"
1816           shift
1817           shift
1818
1819           # Install the shared library and build the symlinks.
1820           $show "$install_prog $dir/$realname $destdir/$realname"
1821           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
1822           test "X$dlname" = "X$realname" && dlname=
1823
1824           if test $# -gt 0; then
1825             # Delete the old symlinks.
1826             rmcmd="$rm"
1827             for linkname
1828             do
1829               rmcmd="$rmcmd $destdir/$linkname"
1830             done
1831             $show "$rmcmd"
1832             $run $rmcmd
1833
1834             # ... and create new ones.
1835             for linkname
1836             do
1837               test "X$dlname" = "X$linkname" && dlname=
1838               $show "(cd $destdir && $LN_S $realname $linkname)"
1839               $run eval "(cd $destdir && $LN_S $realname $linkname)"
1840             done
1841           fi
1842
1843           if test -n "$dlname"; then
1844             # Install the dynamically-loadable library.
1845             $show "$install_prog $dir/$dlname $destdir/$dlname"
1846             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1847           fi
1848
1849           # Do each command in the postinstall commands.
1850           lib="$destdir/$realname"
1851           eval cmds=\"$postinstall_cmds\"
1852           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1853           for cmd in $cmds; do
1854             IFS="$save_ifs"
1855             $show "$cmd"
1856             $run eval "$cmd" || exit $?
1857           done
1858           IFS="$save_ifs"
1859         fi
1860
1861         # Install the pseudo-library for information purposes.
1862         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1863         $show "$install_prog $file $destdir/$name"
1864         $run eval "$install_prog $file $destdir/$name" || exit $?
1865
1866         # Maybe install the static library, too.
1867         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
1868         ;;
1869
1870       *.lo)
1871         # Install (i.e. copy) a libtool object.
1872
1873         # Figure out destination file name, if it wasn't already specified.
1874         if test -n "$destname"; then
1875           destfile="$destdir/$destname"
1876         else
1877           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1878           destfile="$destdir/$destfile"
1879         fi
1880
1881         # Deduce the name of the destination old-style object file.
1882         case "$destfile" in
1883         *.lo)
1884           staticdest=`$echo "X$destfile" | $Xsed -e 's/\.lo$/\.o/'`
1885           ;;
1886         *.o)
1887           staticdest="$destfile"
1888           destfile=
1889           ;;
1890         *)
1891           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
1892           $echo "$help" 1>&2
1893           exit 1
1894           ;;
1895         esac
1896
1897         # Install the libtool object if requested.
1898         if test -n "$destfile"; then
1899           $show "$install_prog $file $destfile"
1900           $run eval "$install_prog $file $destfile" || exit $?
1901         fi
1902
1903         # Install the old object if enabled.
1904         if test "$build_old_libs" = yes; then
1905           # Deduce the name of the old-style object file.
1906           staticobj=`$echo "X$file" | $Xsed -e 's/\.lo$/\.o/'`
1907
1908           $show "$install_prog $staticobj $staticdest"
1909           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
1910         fi
1911         exit 0
1912         ;;
1913
1914       *)
1915         # Do a test to see if this is really a libtool program.
1916         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
1917           link_against_libtool_libs=
1918           finalize_command=
1919
1920           # If there is no directory component, then add one.
1921           case "$file" in
1922           */* | *\\*) . $file ;;
1923           *) . ./$file ;;
1924           esac
1925
1926           # Check the variables that should have been set.
1927           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
1928             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
1929             exit 1
1930           fi
1931
1932           finalize=yes
1933           for lib in $link_against_libtool_libs; do
1934             # Check to see that each library is installed.
1935             libdir=
1936             if test -f "$lib"; then
1937               # If there is no directory component, then add one.
1938               case "$lib" in
1939               */* | *\\*) . $lib ;;
1940               *) . ./$lib ;;
1941               esac
1942             fi
1943             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
1944             if test -z "$libdir"; then
1945               $echo "$modename: warning: \`$lib' contains no -rpath information" 1>&2
1946             elif test -f "$libfile"; then :
1947             else
1948               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
1949               finalize=no
1950             fi
1951           done
1952
1953           if test "$hardcode_action" = relink; then
1954             if test "$finalize" = yes; then
1955               $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
1956               $show "$finalize_command"
1957               if $run eval "$finalize_command"; then :
1958               else
1959                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
1960                 continue
1961               fi
1962               file="$objdir/$file"T
1963             else
1964               $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
1965             fi
1966           else
1967             # Install the binary that we compiled earlier.
1968             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
1969           fi
1970         fi
1971
1972         $show "$install_prog$stripme $file $dest"
1973         $run eval "$install_prog\$stripme \$file \$dest" || exit $?
1974         ;;
1975       esac
1976     done
1977
1978     for file in $staticlibs; do
1979       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1980
1981       # Set up the ranlib parameters.
1982       oldlib="$destdir/$name"
1983
1984       $show "$install_prog $file $oldlib"
1985       $run eval "$install_prog \$file \$oldlib" || exit $?
1986
1987       # Do each command in the postinstall commands.
1988       eval cmds=\"$old_postinstall_cmds\"
1989       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1990       for cmd in $cmds; do
1991         IFS="$save_ifs"
1992         $show "$cmd"
1993         $run eval "$cmd" || exit $?
1994       done
1995       IFS="$save_ifs"
1996     done
1997
1998     if test -n "$future_libdirs"; then
1999       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
2000     fi
2001
2002     if test -n "$current_libdirs"; then
2003       # Maybe just do a dry run.
2004       test -n "$run" && current_libdirs=" -n$current_libdirs"
2005       exec $SHELL $0 --finish$current_libdirs
2006       exit 1
2007     fi
2008
2009     exit 0
2010     ;;
2011
2012   # libtool finish mode
2013   finish)
2014     modename="$modename: finish"
2015     libdirs="$nonopt"
2016
2017     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2018       for dir
2019       do
2020         libdirs="$libdirs $dir"
2021       done
2022
2023       for libdir in $libdirs; do
2024         if test -n "$finish_cmds"; then
2025           # Do each command in the finish commands.
2026           eval cmds=\"$finish_cmds\"
2027           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
2028           for cmd in $cmds; do
2029             IFS="$save_ifs"
2030             $show "$cmd"
2031             $run eval "$cmd"
2032           done
2033           IFS="$save_ifs"
2034         fi
2035         if test -n "$finish_eval"; then
2036           # Do the single finish_eval.
2037           eval cmds=\"$finish_eval\"
2038           $run eval "$cmds"
2039         fi
2040       done
2041     fi
2042
2043     echo "------------------------------------------------------------------------------"
2044     echo "Libraries have been installed in:"
2045     for libdir in $libdirs; do
2046       echo "   $libdir"
2047     done
2048     echo
2049     echo "To link against installed libraries in a given directory, LIBDIR,"
2050     echo "you must use the \`-LLIBDIR' flag during linking."
2051     echo
2052     echo " You will also need to do one of the following:"
2053     if test -n "$shlibpath_var"; then
2054       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2055       echo "     during execution"
2056     fi
2057     if test -n "$runpath_var"; then
2058       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2059       echo "     during linking"
2060     fi
2061     if test -n "$hardcode_libdir_flag_spec"; then
2062       libdir=LIBDIR
2063       eval flag=\"$hardcode_libdir_flag_spec\"
2064
2065       echo "   - use the \`$flag' linker flag"
2066     fi
2067     if test -f /etc/ld.so.conf; then
2068       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2069     fi
2070     echo
2071     echo "See any operating system documentation about shared libraries for"
2072     echo "more information, such as the ld(1) and ld.so(8) manual pages."
2073     echo "------------------------------------------------------------------------------"
2074     exit 0
2075     ;;
2076
2077   # libtool execute mode
2078   execute)
2079     modename="$modename: execute"
2080
2081     # The first argument is the command name.
2082     cmd="$nonopt"
2083     if test -z "$cmd"; then
2084       $echo "$modename: you must specify a COMMAND" 1>&2
2085       $echo "$help"
2086       exit 1
2087     fi
2088
2089     # Handle -dlopen flags immediately.
2090     for file in $execute_dlfiles; do
2091       if test -f "$file"; then :
2092       else
2093         $echo "$modename: \`$file' is not a file" 1>&2
2094         $echo "$help" 1>&2
2095         exit 1
2096       fi
2097
2098       dir=
2099       case "$file" in
2100       *.la)
2101         # Check to see that this really is a libtool archive.
2102         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
2103         else
2104           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2105           $echo "$help" 1>&2
2106           exit 1
2107         fi
2108
2109         # Read the libtool library.
2110         dlname=
2111         library_names=
2112
2113         # If there is no directory component, then add one.
2114         case "$file" in
2115         */* | *\\*) . $file ;;
2116         *) . ./$file ;;
2117         esac
2118
2119         # Skip this library if it cannot be dlopened.
2120         if test -z "$dlname"; then
2121           # Warn if it was a shared library.
2122           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
2123           continue
2124         fi
2125
2126         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2127         test "X$dir" = "X$file" && dir=.
2128
2129         if test -f "$dir/$objdir/$dlname"; then
2130           dir="$dir/$objdir"
2131         else
2132           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
2133           exit 1
2134         fi
2135         ;;
2136
2137       *.lo)
2138         # Just add the directory containing the .lo file.
2139         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2140         test "X$dir" = "X$file" && dir=.
2141         ;;
2142
2143       *)
2144         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
2145         continue
2146         ;;
2147       esac
2148
2149       # Get the absolute pathname.
2150       absdir=`cd "$dir" && pwd`
2151       test -n "$absdir" && dir="$absdir"
2152
2153       # Now add the directory to shlibpath_var.
2154       if eval "test -z \"\$$shlibpath_var\""; then
2155         eval "$shlibpath_var=\"\$dir\""
2156       else
2157         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2158       fi
2159     done
2160
2161     # This variable tells wrapper scripts just to set shlibpath_var
2162     # rather than running their programs.
2163     libtool_execute_magic="$magic"
2164
2165     # Check if any of the arguments is a wrapper script.
2166     args=
2167     for file
2168     do
2169       case "$file" in
2170       -*) ;;
2171       *)
2172         # Do a test to see if this is really a libtool program.
2173         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
2174           # If there is no directory component, then add one.
2175           case "$file" in
2176           */* | *\\*) . $file ;;
2177           *) . ./$file ;;
2178           esac
2179
2180           # Transform arg to wrapped name.
2181           file="$progdir/$program"
2182         fi
2183         ;;
2184       esac
2185       # Quote arguments (to preserve shell metacharacters).
2186       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
2187       args="$args \"$file\""
2188     done
2189
2190     if test -z "$run"; then
2191       # Export the shlibpath_var.
2192       eval "export $shlibpath_var"
2193
2194       # Now actually exec the command.
2195       eval "exec \$cmd$args"
2196
2197       $echo "$modename: cannot exec \$cmd$args"
2198       exit 1
2199     else
2200       # Display what would be done.
2201       eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
2202       $echo "export $shlibpath_var"
2203       $echo "$cmd$args"
2204       exit 0
2205     fi
2206     ;;
2207
2208   # libtool uninstall mode
2209   uninstall)
2210     modename="$modename: uninstall"
2211     rm="$nonopt"
2212     files=
2213
2214     for arg
2215     do
2216       case "$arg" in
2217       -*) rm="$rm $arg" ;;
2218       *) files="$files $arg" ;;
2219       esac
2220     done
2221
2222     if test -z "$rm"; then
2223       $echo "$modename: you must specify an RM program" 1>&2
2224       $echo "$help" 1>&2
2225       exit 1
2226     fi
2227
2228     for file in $files; do
2229       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2230       test "X$dir" = "X$file" && dir=.
2231       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2232
2233       rmfiles="$file"
2234
2235       case "$name" in
2236       *.la)
2237         # Possibly a libtool archive, so verify it.
2238         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
2239           . $dir/$name
2240
2241           # Delete the libtool libraries and symlinks.
2242           for n in $library_names; do
2243             rmfiles="$rmfiles $dir/$n"
2244             test "X$n" = "X$dlname" && dlname=
2245           done
2246           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
2247           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
2248
2249           $show "$rm $rmfiles"
2250           $run $rm $rmfiles
2251
2252           if test -n "$library_names"; then
2253             # Do each command in the postuninstall commands.
2254             eval cmds=\"$postuninstall_cmds\"
2255             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2256             for cmd in $cmds; do
2257               IFS="$save_ifs"
2258               $show "$cmd"
2259               $run eval "$cmd"
2260             done
2261             IFS="$save_ifs"
2262           fi
2263
2264           if test -n "$old_library"; then
2265             # Do each command in the old_postuninstall commands.
2266             eval cmds=\"$old_postuninstall_cmds\"
2267             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2268             for cmd in $cmds; do
2269               IFS="$save_ifs"
2270               $show "$cmd"
2271               $run eval "$cmd"
2272             done
2273             IFS="$save_ifs"
2274           fi
2275
2276           # FIXME: should reinstall the best remaining shared library.
2277         fi
2278         ;;
2279
2280       *.lo)
2281         if test "$build_old_libs" = yes; then
2282           oldobj=`$echo "X$name" | $Xsed -e 's/\.lo$/\.o/'`
2283           rmfiles="$rmfiles $dir/$oldobj"
2284         fi
2285         $show "$rm $rmfiles"
2286         $run $rm $rmfiles
2287         ;;
2288
2289       *)
2290         $show "$rm $rmfiles"
2291         $run $rm $rmfiles
2292         ;;
2293       esac
2294     done
2295     exit 0
2296     ;;
2297
2298   "")
2299     $echo "$modename: you must specify a MODE" 1>&2
2300     $echo "$generic_help" 1>&2
2301     exit 1
2302     ;;
2303   esac
2304
2305   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2306   $echo "$generic_help" 1>&2
2307   exit 1
2308 fi # test -z "$show_help"
2309
2310 # We need to display help for each of the modes.
2311 case "$mode" in
2312 "") $echo \
2313 "Usage: $modename [OPTION]... [MODE-ARG]...
2314
2315 Provide generalized library-building support services.
2316
2317 -n, --dry-run         display commands without modifying any files
2318     --features        display configuration information and exit
2319     --finish          same as \`--mode=finish'
2320     --help            display this help message and exit
2321     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
2322     --quiet           same as \`--silent'
2323     --silent          don't print informational messages
2324     --version         print version information
2325
2326 MODE must be one of the following:
2327
2328       compile         compile a source file into a libtool object
2329       execute         automatically set library path, then run a program
2330       finish          complete the installation of libtool libraries
2331       install         install libraries or executables
2332       link            create a library or an executable
2333       uninstall       remove libraries from an installed directory
2334
2335 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
2336 a more detailed description of MODE."
2337   exit 0
2338   ;;
2339
2340 compile)
2341   $echo \
2342 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2343
2344 Compile a source file into a libtool library object.
2345
2346 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2347 from the given SOURCEFILE.
2348
2349 The output file name is determined by removing the directory component from
2350 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2351 library object suffix, \`.lo'."
2352   ;;
2353
2354 execute)
2355   $echo \
2356 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
2357
2358 Automatically set library path, then run a program.
2359
2360 This mode accepts the following additional options:
2361
2362   -dlopen FILE      add the directory containing FILE to the library path
2363
2364 This mode sets the library path environment variable according to \`-dlopen'
2365 flags.
2366
2367 If any of the ARGS are libtool executable wrappers, then they are translated
2368 into their corresponding uninstalled binary, and any of their required library
2369 directories are added to the library path.
2370
2371 Then, COMMAND is executed, with ARGS as arguments."
2372   ;;
2373
2374 finish)
2375   $echo \
2376 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
2377
2378 Complete the installation of libtool libraries.
2379
2380 Each LIBDIR is a directory that contains libtool libraries.
2381
2382 The commands that this mode executes may require superuser privileges.  Use
2383 the \`--dry-run' option if you just want to see what would be executed."
2384   ;;
2385
2386 install)
2387   $echo \
2388 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
2389
2390 Install executables or libraries.
2391
2392 INSTALL-COMMAND is the installation command.  The first component should be
2393 either the \`install' or \`cp' program.
2394
2395 The rest of the components are interpreted as arguments to that command (only
2396 BSD-compatible install options are recognized)."
2397   ;;
2398
2399 link)
2400   $echo \
2401 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
2402
2403 Link object files or libraries together to form another library, or to
2404 create an executable program.
2405
2406 LINK-COMMAND is a command using the C compiler that you would use to create
2407 a program from several object files.
2408
2409 The following components of LINK-COMMAND are treated specially:
2410
2411   -all-static       do not do any dynamic linking at all
2412   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2413   -dlpreopen FILE   link in FILE and add its symbols to dld_preloaded_symbols
2414   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2415   -LLIBDIR          search LIBDIR for required installed libraries
2416   -lNAME            OUTPUT-FILE requires the installed library libNAME
2417   -no-undefined     declare that a library does not refer to external symbols
2418   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2419   -release RELEASE  specify package release information
2420   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2421   -static           do not do any dynamic linking of libtool libraries
2422   -version-info CURRENT[:REVISION[:AGE]]
2423                     specify library version info [each variable defaults to 0]
2424
2425 All other options (arguments beginning with \`-') are ignored.
2426
2427 Every other argument is treated as a filename.  Files ending in \`.la' are
2428 treated as uninstalled libtool libraries, other files are standard or library
2429 object files.
2430
2431 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
2432 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
2433
2434 If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar'
2435 and \`ranlib'.
2436
2437 If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is
2438 created, otherwise an executable program is created."
2439   ;;
2440
2441 uninstall)
2442   $echo
2443 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2444
2445 Remove libraries from an installation directory.
2446
2447 RM is the name of the program to use to delete files associated with each FILE
2448 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2449 to RM.
2450
2451 If FILE is a libtool library, all the files associated with it are deleted.
2452 Otherwise, only FILE itself is deleted using RM."
2453   ;;
2454
2455 *)
2456   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2457   $echo "$help" 1>&2
2458   exit 1
2459   ;;
2460 esac
2461
2462 echo
2463 $echo "Try \`$modename --help' for more information about other modes."
2464
2465 exit 0
2466
2467 # Local Variables:
2468 # mode:shell-script
2469 # sh-indentation:2
2470 # End: