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         if [ $PORTOBJFORMAT = elf ]; then
 974         versuffix="$current";
 975         else
 976         versuffix="$current.$revision";
 977         fi
 978         ;;
 979
 980       *)
 981         $echo "$modename: unknown library version type \`$version_type'" 1>&2
 982         echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 983         exit 1
 984         ;;
 985       esac
 986
 987       # Create the output directory, or remove our outputs if we need to.
 988       if test -d $objdir; then
 989         $show "$rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*"
 990         $run $rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*
 991       else
 992         $show "$mkdir $objdir"
 993         $run $mkdir $objdir
 994         status=$?
 995         if test $status -eq 0 || test -d $objdir; then :
 996         else
 997           exit $status
 998         fi
 999       fi
1000
1001       # Check to see if the archive will have undefined symbols.
1002       if test "$allow_undefined" = yes; then
1003         if test "$allow_undefined_flag" = unsupported; then
1004           $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
1005           build_libtool_libs=no
1006           build_old_libs=yes
1007         fi
1008       else
1009         # Don't allow undefined symbols.
1010         allow_undefined_flag="$no_undefined_flag"
1011       fi
1012
1013       # Add libc to deplibs on all systems.
1014       dependency_libs="$deplibs"
1015       deplibs="$deplibs -lc"
1016
1017       if test "$build_libtool_libs" = yes; then
1018         # Get the real and link names of the library.
1019         eval library_names=\"$library_names_spec\"
1020         set dummy $library_names
1021         realname="$2"
1022         shift; shift
1023
1024         if test -n "$soname_spec"; then
1025           eval soname=\"$soname_spec\"
1026         else
1027           soname="$realname"
1028         fi
1029
1030         lib="$objdir/$realname"
1031         for link
1032         do
1033           linknames="$linknames $link"
1034         done
1035
1036         # Use standard objects if they are PIC.
1037         test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//g'`
1038
1039         # Do each of the archive commands.
1040         eval cmds=\"$archive_cmds\"
1041         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1042         for cmd in $cmds; do
1043           IFS="$save_ifs"
1044           $show "$cmd"
1045           $run eval "$cmd" || exit $?
1046         done
1047         IFS="$save_ifs"
1048
1049         # Create links to the real library.
1050         for linkname in $linknames; do
1051           $show "(cd $objdir && $LN_S $realname $linkname)"
1052           $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $?
1053         done
1054
1055         # If -export-dynamic was specified, set the dlname.
1056         if test "$export_dynamic" = yes; then
1057           # On all known operating systems, these are identical.
1058           dlname="$soname"
1059         fi
1060       fi
1061
1062       # Now set the variables for building old libraries.
1063       oldlib="$objdir/$libname.a"
1064       ;;
1065
1066     *.lo | *.o)
1067       if test -n "$link_against_libtool_libs"; then
1068         $echo "$modename: error: cannot link libtool libraries into reloadable objects" 1>&2
1069         exit 1
1070       fi
1071
1072       if test -n "$deplibs"; then
1073         $echo "$modename: warning: \`-l' and \`-L' are ignored while creating objects" 1>&2
1074       fi
1075
1076       if test -n "$dlfiles$dlprefiles"; then
1077         $echo "$modename: warning: \`-dlopen' is ignored while creating objects" 1>&2
1078         # Nullify the symbol file.
1079         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1080         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1081       fi
1082
1083       if test -n "$rpath"; then
1084         $echo "$modename: warning: \`-rpath' is ignored while creating objects" 1>&2
1085       fi
1086
1087       if test -n "$vinfo"; then
1088         $echo "$modename: warning: \`-version-info' is ignored while creating objects" 1>&2
1089       fi
1090
1091       if test -n "$release"; then
1092         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
1093       fi
1094
1095       case "$output" in
1096       *.lo)
1097         if test -n "$objs"; then
1098           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
1099           exit 1
1100         fi
1101         libobj="$output"
1102         obj=`$echo "X$output" | $Xsed -e 's/\.lo$/.o/'`
1103         ;;
1104       *)
1105         libobj=
1106         obj="$output"
1107         ;;
1108       esac
1109
1110       # Delete the old objects.
1111       $run $rm $obj $libobj
1112
1113       # Create the old-style object.
1114       reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^       ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
1115
1116       output="$obj"
1117       eval cmds=\"$reload_cmds\"
1118       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1119       for cmd in $cmds; do
1120         IFS="$save_ifs"
1121         $show "$cmd"
1122         $run eval "$cmd" || exit $?
1123       done
1124       IFS="$save_ifs"
1125
1126       # Exit if we aren't doing a library object file.
1127       test -z "$libobj" && exit 0
1128
1129       if test "$build_libtool_libs" != yes; then
1130         # Create an invalid libtool object if no PIC, so that we don't
1131         # accidentally link it into a program.
1132         $show "echo timestamp > $libobj"
1133         $run eval "echo timestamp > $libobj" || exit $?
1134         exit 0
1135       fi
1136
1137       if test -n "$pic_flag"; then
1138         # Only do commands if we really have different PIC objects.
1139         reload_objs="$libobjs"
1140         output="$libobj"
1141         eval cmds=\"$reload_cmds\"
1142         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1143         for cmd in $cmds; do
1144           IFS="$save_ifs"
1145           $show "$cmd"
1146           $run eval "$cmd" || exit $?
1147         done
1148         IFS="$save_ifs"
1149       else
1150         # Just create a symlink.
1151         $show "$LN_S $obj $libobj"
1152         $run $LN_S $obj $libobj || exit 1
1153       fi
1154
1155       exit 0
1156       ;;
1157
1158     *)
1159       if test -n "$vinfo"; then
1160         $echo "$modename: warning: \`-version-info' is ignored while linking programs" 1>&2
1161       fi
1162
1163       if test -n "$release"; then
1164         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
1165       fi
1166
1167       if test -n "$rpath"; then
1168         # If the user specified any rpath flags, then add them.
1169         for libdir in $rpath; do
1170           if test -n "$hardcode_libdir_flag_spec"; then
1171             if test -n "$hardcode_libdir_separator"; then
1172               if test -z "$hardcode_libdirs"; then
1173                 # Put the magic libdir with the hardcode flag.
1174                 hardcode_libdirs="$libdir"
1175                 libdir="@HARDCODE_LIBDIRS@"
1176               else
1177                 # Just accumulate the unique libdirs.
1178                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
1179                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
1180                   ;;
1181                 *)
1182                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
1183                   ;;
1184                 esac
1185                 libdir=
1186               fi
1187             fi
1188
1189             if test -n "$libdir"; then
1190               eval flag=\"$hardcode_libdir_flag_spec\"
1191
1192               compile_command="$compile_command $flag"
1193               finalize_command="$finalize_command $flag"
1194             fi
1195           elif test -n "$runpath_var"; then
1196             case "$perm_rpath " in
1197             *" $libdir "*) ;;
1198             *) perm_rpath="$perm_rpath $libdir" ;;
1199             esac
1200           fi
1201         done
1202       fi
1203
1204       # Substitute the hardcoded libdirs into the compile commands.
1205       if test -n "$hardcode_libdir_separator"; then
1206         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1207         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1208       fi
1209
1210       if test -n "$libobjs" && test "$build_old_libs" = yes; then
1211         # Transform all the library objects into standard objects.
1212         compile_command=`$echo "X$compile_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1213         finalize_command=`$echo "X$finalize_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1214       fi
1215
1216       if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then
1217         dlsyms="${output}S.c"
1218       else
1219         dlsyms=
1220       fi
1221
1222       if test -n "$dlsyms"; then
1223         # Add our own program objects to the preloaded list.
1224         dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
1225
1226         # Discover the nlist of each of the dlfiles.
1227         nlist="$objdir/${output}.nm"
1228
1229         if test -d $objdir; then
1230           $show "$rm $nlist ${nlist}T"
1231           $run $rm "$nlist" "${nlist}T"
1232         else
1233           $show "$mkdir $objdir"
1234           $run $mkdir $objdir
1235           status=$?
1236           if test $status -eq 0 || test -d $objdir; then :
1237           else
1238             exit $status
1239           fi
1240         fi
1241
1242         for arg in $dlprefiles; do
1243           $show "extracting global C symbols from \`$arg'"
1244           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
1245         done
1246
1247         # Parse the name list into a source file.
1248         $show "creating $objdir/$dlsyms"
1249         if test -z "$run"; then
1250           # Make sure we at least have an empty file.
1251           test -f "$nlist" || : > "$nlist"
1252
1253           # Try sorting and uniquifying the output.
1254           if sort "$nlist" | uniq > "$nlist"T; then
1255             mv -f "$nlist"T "$nlist"
1256             wcout=`wc "$nlist" 2>/dev/null`
1257             count=`echo "X$wcout" | $Xsed -e 's/^[      ]*\([0-9][0-9]*\).*$/\1/'`
1258             (test "$count" -ge 0) 2>/dev/null || count=-1
1259           else
1260             $rm "$nlist"T
1261             count=-1
1262           fi
1263
1264           case "$dlsyms" in
1265           "") ;;
1266           *.c)
1267             $echo > "$objdir/$dlsyms" "\
1268 /* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */
1269 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */
1270
1271 #ifdef __cplusplus
1272 extern \"C\" {
1273 #endif
1274
1275 /* Prevent the only kind of declaration conflicts we can make. */
1276 #define dld_preloaded_symbol_count some_other_symbol
1277 #define dld_preloaded_symbols some_other_symbol
1278
1279 /* External symbol declarations for the compiler. */\
1280 "
1281
1282             if test -f "$nlist"; then
1283               sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms"
1284             else
1285               echo '/* NONE */' >> "$objdir/$dlsyms"
1286             fi
1287
1288             $echo >> "$objdir/$dlsyms" "\
1289
1290 #undef dld_preloaded_symbol_count
1291 #undef dld_preloaded_symbols
1292
1293 #if defined (__STDC__) && __STDC__
1294 # define __ptr_t void *
1295 #else
1296 # define __ptr_t char *
1297 #endif
1298
1299 /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */
1300 int dld_preloaded_symbol_count = $count;
1301
1302 /* The mapping between symbol names and symbols. */
1303 struct {
1304   char *name;
1305   __ptr_t address;
1306 }
1307 dld_preloaded_symbols[] =
1308 {\
1309 "
1310
1311             if test -f "$nlist"; then
1312               sed 's/^\(.*\) \(.*\)$/  {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms"
1313             fi
1314
1315             $echo >> "$objdir/$dlsyms" "\
1316   {0, (__ptr_t) 0}
1317 };
1318
1319 #ifdef __cplusplus
1320 }
1321 #endif\
1322 "
1323             ;;
1324
1325           *)
1326             $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
1327             exit 1
1328             ;;
1329           esac
1330         fi
1331
1332         # Now compile the dynamic symbol file.
1333         $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")"
1334         $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $?
1335
1336         # Transform the symbol file into the correct name.
1337         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
1338         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
1339       elif test "$export_dynamic" != yes; then
1340         test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2
1341       else
1342         # We keep going just in case the user didn't refer to
1343         # dld_preloaded_symbols.  The linker will fail if global_symbol_pipe
1344         # really was required.
1345         $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
1346
1347         # Nullify the symbol file.
1348         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1349         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1350       fi
1351
1352       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
1353         # Replace the output file specification.
1354         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1355         finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1356
1357         # We have no uninstalled library dependencies, so finalize right now.
1358         $show "$compile_command"
1359         $run eval "$compile_command"
1360         exit $?
1361       fi
1362
1363       # Replace the output file specification.
1364       compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'`
1365       finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'`
1366
1367       # Create the binary in the object directory, then wrap it.
1368       if test -d $objdir; then :
1369       else
1370         $show "$mkdir $objdir"
1371         $run $mkdir $objdir
1372         status=$?
1373         if test $status -eq 0 || test -d $objdir; then :
1374         else
1375           exit $status
1376         fi
1377       fi
1378
1379       if test -n "$shlibpath_var"; then
1380         # We should set the shlibpath_var
1381         rpath=
1382         for dir in $temp_rpath; do
1383           case "$dir" in
1384           /* | [A-Za-z]:\\*)
1385             # Absolute path.
1386             rpath="$rpath$dir:"
1387             ;;
1388           *)
1389             # Relative path: add a thisdir entry.
1390             rpath="$rpath\$thisdir/$dir:"
1391             ;;
1392           esac
1393         done
1394         temp_rpath="$rpath"
1395       fi
1396
1397       # Delete the old output file.
1398       $run $rm $output
1399
1400       if test -n "$compile_shlibpath"; then
1401         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
1402       fi
1403       if test -n "$finalize_shlibpath"; then
1404         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
1405       fi
1406
1407       if test -n "$runpath_var" && test -n "$perm_rpath"; then
1408         # We should set the runpath_var.
1409         rpath=
1410         for dir in $perm_rpath; do
1411           rpath="$rpath$dir:"
1412         done
1413         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
1414         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
1415       fi
1416
1417       case "$hardcode_action" in
1418       relink)
1419         # AGH! Flame the AIX and HP-UX people for me, will ya?
1420         $echo "$modename: warning: using a buggy system linker" 1>&2
1421         $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2
1422         ;;
1423       esac
1424
1425       $show "$compile_command"
1426       $run eval "$compile_command" || exit $?
1427
1428       # Now create the wrapper script.
1429       $show "creating $output"
1430
1431       # Quote the finalize command for shipping.
1432       finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"`
1433
1434       # Quote $echo for shipping.
1435       qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
1436
1437       # Only actually do things if our run command is non-null.
1438       if test -z "$run"; then
1439         $rm $output
1440         trap "$rm $output; exit 1" 1 2 15
1441
1442         $echo > $output "\
1443 #! /bin/sh
1444
1445 # $output - temporary wrapper script for $objdir/$output
1446 # Generated by ltmain.sh - GNU $PACKAGE $VERSION
1447 #
1448 # The $output program cannot be directly executed until all the libtool
1449 # libraries that it depends on are installed.
1450 #
1451 # This wrapper script should never be moved out of \``pwd`'.
1452 # If it is, it will not operate correctly.
1453
1454 # Sed substitution that helps us do robust quoting.  It backslashifies
1455 # metacharacters that are still active within double-quoted strings.
1456 Xsed='sed -e s/^X//'
1457 sed_quote_subst='$sed_quote_subst'
1458
1459 # The HP-UX ksh and POSIX shell print the target directory to stdout
1460 # if CDPATH is set.
1461 if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi
1462
1463 # This environment variable determines our operation mode.
1464 if test \"\$libtool_install_magic\" = \"$magic\"; then
1465   # install mode needs the following variables:
1466   link_against_libtool_libs='$link_against_libtool_libs'
1467   finalize_command=\"$finalize_command\"
1468 else
1469   # When we are sourced in execute mode, \$file and \$echo are already set.
1470   if test \"\$libtool_execute_magic\" = \"$magic\"; then :
1471   else
1472     echo=\"$qecho\"
1473     file=\"\$0\"
1474   fi\
1475 "
1476         $echo >> $output "\
1477
1478   # Find the directory that this script lives in.
1479   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
1480   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
1481
1482   # Follow symbolic links until we get to the real thisdir.
1483   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
1484   while test -n \"\$file\"; do
1485     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
1486
1487     # If there was a directory component, then change thisdir.
1488     if test \"x\$destdir\" != \"x\$file\"; then
1489       case \"\$destdir\" in
1490       /* | [A-Za-z]:\\*) thisdir=\"\$destdir\" ;;
1491       *) thisdir=\"\$thisdir/\$destdir\" ;;
1492       esac
1493     fi
1494
1495     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
1496     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
1497   done
1498
1499   # Try to get the absolute directory name.
1500   absdir=\`cd \"\$thisdir\" && pwd\`
1501   test -n \"\$absdir\" && thisdir=\"\$absdir\"
1502
1503   progdir=\"\$thisdir/$objdir\"
1504   program='$output'
1505
1506   if test -f \"\$progdir/\$program\"; then"
1507
1508         # Export our shlibpath_var if we have one.
1509         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
1510           $echo >> $output "\
1511     # Add our own library path to $shlibpath_var
1512     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
1513
1514     # Some systems cannot cope with colon-terminated $shlibpath_var
1515     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\`
1516
1517     export $shlibpath_var
1518 "
1519         fi
1520
1521         $echo >> $output "\
1522     if test \"\$libtool_execute_magic\" != \"$magic\"; then
1523       # Run the actual program with our arguments.
1524
1525       # Export the path to the program.
1526       PATH=\"\$progdir:\$PATH\"
1527       export PATH
1528
1529       exec \$program \${1+\"\$@\"}
1530
1531       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
1532       exit 1
1533     fi
1534   else
1535     # The program doesn't exist.
1536     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
1537     \$echo \"This script is just a wrapper for \$program.\" 1>&2
1538     echo \"See the $PACKAGE documentation for more information.\" 1>&2
1539     exit 1
1540   fi
1541 fi\
1542 "
1543         chmod +x $output
1544       fi
1545       exit 0
1546       ;;
1547     esac
1548
1549     # See if we need to build an old-fashioned archive.
1550     if test "$build_old_libs" = "yes"; then
1551       # Transform .lo files to .o files.
1552       oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^   ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
1553
1554       # Do each command in the archive commands.
1555       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
1556         eval cmds=\"$old_archive_from_new_cmds\"
1557       else
1558         eval cmds=\"$old_archive_cmds\"
1559       fi
1560       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1561       for cmd in $cmds; do
1562         IFS="$save_ifs"
1563         $show "$cmd"
1564         $run eval "$cmd" || exit $?
1565       done
1566       IFS="$save_ifs"
1567     fi
1568
1569     # Now create the libtool archive.
1570     case "$output" in
1571     *.la)
1572       old_library=
1573       test "$build_old_libs" = yes && old_library="$libname.a"
1574
1575       $show "creating $output"
1576
1577       # Only create the output if not a dry run.
1578       if test -z "$run"; then
1579         $echo > $output "\
1580 # $output - a libtool library file
1581 # Generated by ltmain.sh - GNU $PACKAGE $VERSION
1582
1583 # The name that we can dlopen(3).
1584 dlname='$dlname'
1585
1586 # Names of this library.
1587 library_names='$library_names'
1588
1589 # The name of the static archive.
1590 old_library='$old_library'
1591
1592 # Libraries that this one depends upon.
1593 dependency_libs='$dependency_libs'
1594
1595 # Version information for $libname.
1596 current=$current
1597 age=$age
1598 revision=$revision
1599
1600 # Directory that this library needs to be installed in:
1601 libdir='$install_libdir'\
1602 "
1603       fi
1604
1605       # Do a symbolic link so that the libtool archive can be found in
1606       # LD_LIBRARY_PATH before the program is installed.
1607       $show "(cd $objdir && $LN_S ../$output $output)"
1608       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit 1
1609       ;;
1610     esac
1611     exit 0
1612     ;;
1613
1614   # libtool install mode
1615   install)
1616     modename="$modename: install"
1617
1618     # There may be an optional /bin/sh argument at the beginning of
1619     # install_prog (especially on Windows NT).
1620     if test "$nonopt" = "$SHELL"; then
1621       # Aesthetically quote it.
1622       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
1623       case "$arg" in
1624       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1625         arg="\"$arg\""
1626         ;;
1627       esac
1628       install_prog="$arg "
1629       arg="$1"
1630       shift
1631     else
1632       install_prog=
1633       arg="$nonopt"
1634     fi
1635
1636     # The real first argument should be the name of the installation program.
1637     # Aesthetically quote it.
1638     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1639     case "$arg" in
1640     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
1641       arg="\"$arg\""
1642       ;;
1643     esac
1644     install_prog="$install_prog$arg"
1645
1646     # We need to accept at least all the BSD install flags.
1647     dest=
1648     files=
1649     opts=
1650     prev=
1651     install_type=
1652     isdir=
1653     stripme=
1654     for arg
1655     do
1656       if test -n "$dest"; then
1657         files="$files $dest"
1658         dest="$arg"
1659         continue
1660       fi
1661
1662       case "$arg" in
1663       -d) isdir=yes ;;
1664       -f) prev="-f" ;;
1665       -g) prev="-g" ;;
1666       -m) prev="-m" ;;
1667       -o) prev="-o" ;;
1668       -s)
1669         stripme=" -s"
1670         continue
1671         ;;
1672       -*) ;;
1673
1674       *)
1675         # If the previous option needed an argument, then skip it.
1676         if test -n "$prev"; then
1677           prev=
1678         else
1679           dest="$arg"
1680           continue
1681         fi
1682         ;;
1683       esac
1684
1685       # Aesthetically quote the argument.
1686       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1687       case "$arg" in
1688       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1689         arg="\"$arg\""
1690         ;;
1691       esac
1692       install_prog="$install_prog $arg"
1693     done
1694
1695     if test -z "$install_prog"; then
1696       $echo "$modename: you must specify an install program" 1>&2
1697       $echo "$help" 1>&2
1698       exit 1
1699     fi
1700
1701     if test -n "$prev"; then
1702       $echo "$modename: the \`$prev' option requires an argument" 1>&2
1703       $echo "$help" 1>&2
1704       exit 1
1705     fi
1706
1707     if test -z "$files"; then
1708       if test -z "$dest"; then
1709         $echo "$modename: no file or destination specified" 1>&2
1710       else
1711         $echo "$modename: you must specify a destination" 1>&2
1712       fi
1713       $echo "$help" 1>&2
1714       exit 1
1715     fi
1716
1717     # Strip any trailing slash from the destination.
1718     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
1719
1720     # Check to see that the destination is a directory.
1721     test -d "$dest" && isdir=yes
1722     if test -n "$isdir"; then
1723       destdir="$dest"
1724       destname=
1725     else
1726       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
1727       test "X$destdir" = "X$dest" && destdir=.
1728       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
1729
1730       # Not a directory, so check to see that there is only one file specified.
1731       set dummy $files
1732       if test $# -gt 2; then
1733         $echo "$modename: \`$dest' is not a directory" 1>&2
1734         $echo "$help" 1>&2
1735         exit 1
1736       fi
1737     fi
1738     case "$destdir" in
1739     /* | [A-Za-z]:\\*) ;;
1740     *)
1741       for file in $files; do
1742         case "$file" in
1743         *.lo) ;;
1744         *)
1745           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
1746           $echo "$help" 1>&2
1747           exit 1
1748           ;;
1749         esac
1750       done
1751       ;;
1752     esac
1753
1754     # This variable tells wrapper scripts just to set variables rather
1755     # than running their programs.
1756     libtool_install_magic="$magic"
1757
1758     staticlibs=
1759     future_libdirs=
1760     current_libdirs=
1761     for file in $files; do
1762
1763       # Do each installation.
1764       case "$file" in
1765       *.a)
1766         # Do the static libraries later.
1767         staticlibs="$staticlibs $file"
1768         ;;
1769
1770       *.la)
1771         # Check to see that this really is a libtool archive.
1772         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
1773         else
1774           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
1775           $echo "$help" 1>&2
1776           exit 1
1777         fi
1778
1779         library_names=
1780         old_library=
1781         # If there is no directory component, then add one.
1782         case "$file" in
1783         */* | *\\*) . $file ;;
1784         *) . ./$file ;;
1785         esac
1786
1787         # Add the libdir to current_libdirs if it is the destination.
1788         if test "X$destdir" = "X$libdir"; then
1789           case "$current_libdirs " in
1790           *" $libdir "*) ;;
1791           *) current_libdirs="$current_libdirs $libdir" ;;
1792           esac
1793         else
1794           # Note the libdir as a future libdir.
1795           case "$future_libdirs " in
1796           *" $libdir "*) ;;
1797           *) future_libdirs="$future_libdirs $libdir" ;;
1798           esac
1799         fi
1800
1801         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
1802         test "X$dir" = "X$file/" && dir=
1803         dir="$dir$objdir"
1804
1805         # See the names of the shared library.
1806         set dummy $library_names
1807         if test -n "$2"; then
1808           realname="$2"
1809           shift
1810           shift
1811
1812           # Install the shared library and build the symlinks.
1813           $show "$install_prog $dir/$realname $destdir/$realname"
1814           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
1815           test "X$dlname" = "X$realname" && dlname=
1816
1817           if test $# -gt 0; then
1818             # Delete the old symlinks.
1819             rmcmd="$rm"
1820             for linkname
1821             do
1822               rmcmd="$rmcmd $destdir/$linkname"
1823             done
1824             $show "$rmcmd"
1825             $run $rmcmd
1826
1827             # ... and create new ones.
1828             for linkname
1829             do
1830               test "X$dlname" = "X$linkname" && dlname=
1831               $show "(cd $destdir && $LN_S $realname $linkname)"
1832               $run eval "(cd $destdir && $LN_S $realname $linkname)"
1833             done
1834           fi
1835
1836           if test -n "$dlname"; then
1837             # Install the dynamically-loadable library.
1838             $show "$install_prog $dir/$dlname $destdir/$dlname"
1839             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1840           fi
1841
1842           # Do each command in the postinstall commands.
1843           lib="$destdir/$realname"
1844           eval cmds=\"$postinstall_cmds\"
1845           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1846           for cmd in $cmds; do
1847             IFS="$save_ifs"
1848             $show "$cmd"
1849             $run eval "$cmd" || exit $?
1850           done
1851           IFS="$save_ifs"
1852         fi
1853
1854         # Install the pseudo-library for information purposes.
1855         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1856         $show "$install_prog $file $destdir/$name"
1857         $run eval "$install_prog $file $destdir/$name" || exit $?
1858
1859         # Maybe install the static library, too.
1860         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
1861         ;;
1862
1863       *.lo)
1864         # Install (i.e. copy) a libtool object.
1865
1866         # Figure out destination file name, if it wasn't already specified.
1867         if test -n "$destname"; then
1868           destfile="$destdir/$destname"
1869         else
1870           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1871           destfile="$destdir/$destfile"
1872         fi
1873
1874         # Deduce the name of the destination old-style object file.
1875         case "$destfile" in
1876         *.lo)
1877           staticdest=`$echo "X$destfile" | $Xsed -e 's/\.lo$/\.o/'`
1878           ;;
1879         *.o)
1880           staticdest="$destfile"
1881           destfile=
1882           ;;
1883         *)
1884           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
1885           $echo "$help" 1>&2
1886           exit 1
1887           ;;
1888         esac
1889
1890         # Install the libtool object if requested.
1891         if test -n "$destfile"; then
1892           $show "$install_prog $file $destfile"
1893           $run eval "$install_prog $file $destfile" || exit $?
1894         fi
1895
1896         # Install the old object if enabled.
1897         if test "$build_old_libs" = yes; then
1898           # Deduce the name of the old-style object file.
1899           staticobj=`$echo "X$file" | $Xsed -e 's/\.lo$/\.o/'`
1900
1901           $show "$install_prog $staticobj $staticdest"
1902           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
1903         fi
1904         exit 0
1905         ;;
1906
1907       *)
1908         # Do a test to see if this is really a libtool program.
1909         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
1910           link_against_libtool_libs=
1911           finalize_command=
1912
1913           # If there is no directory component, then add one.
1914           case "$file" in
1915           */* | *\\*) . $file ;;
1916           *) . ./$file ;;
1917           esac
1918
1919           # Check the variables that should have been set.
1920           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
1921             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
1922             exit 1
1923           fi
1924
1925           finalize=yes
1926           for lib in $link_against_libtool_libs; do
1927             # Check to see that each library is installed.
1928             libdir=
1929             if test -f "$lib"; then
1930               # If there is no directory component, then add one.
1931               case "$lib" in
1932               */* | *\\*) . $lib ;;
1933               *) . ./$lib ;;
1934               esac
1935             fi
1936             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
1937             if test -z "$libdir"; then
1938               $echo "$modename: warning: \`$lib' contains no -rpath information" 1>&2
1939             elif test -f "$libfile"; then :
1940             else
1941               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
1942               finalize=no
1943             fi
1944           done
1945
1946           if test "$hardcode_action" = relink; then
1947             if test "$finalize" = yes; then
1948               $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
1949               $show "$finalize_command"
1950               if $run eval "$finalize_command"; then :
1951               else
1952                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
1953                 continue
1954               fi
1955               file="$objdir/$file"T
1956             else
1957               $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
1958             fi
1959           else
1960             # Install the binary that we compiled earlier.
1961             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
1962           fi
1963         fi
1964
1965         $show "$install_prog$stripme $file $dest"
1966         $run eval "$install_prog\$stripme \$file \$dest" || exit $?
1967         ;;
1968       esac
1969     done
1970
1971     for file in $staticlibs; do
1972       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1973
1974       # Set up the ranlib parameters.
1975       oldlib="$destdir/$name"
1976
1977       $show "$install_prog $file $oldlib"
1978       $run eval "$install_prog \$file \$oldlib" || exit $?
1979
1980       # Do each command in the postinstall commands.
1981       eval cmds=\"$old_postinstall_cmds\"
1982       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1983       for cmd in $cmds; do
1984         IFS="$save_ifs"
1985         $show "$cmd"
1986         $run eval "$cmd" || exit $?
1987       done
1988       IFS="$save_ifs"
1989     done
1990
1991     if test -n "$future_libdirs"; then
1992       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
1993     fi
1994
1995     if test -n "$current_libdirs"; then
1996       # Maybe just do a dry run.
1997       test -n "$run" && current_libdirs=" -n$current_libdirs"
1998       exec $SHELL $0 --finish$current_libdirs
1999       exit 1
2000     fi
2001
2002     exit 0
2003     ;;
2004
2005   # libtool finish mode
2006   finish)
2007     modename="$modename: finish"
2008     libdirs="$nonopt"
2009
2010     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2011       for dir
2012       do
2013         libdirs="$libdirs $dir"
2014       done
2015
2016       for libdir in $libdirs; do
2017         if test -n "$finish_cmds"; then
2018           # Do each command in the finish commands.
2019           eval cmds=\"$finish_cmds\"
2020           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
2021           for cmd in $cmds; do
2022             IFS="$save_ifs"
2023             $show "$cmd"
2024             $run eval "$cmd"
2025           done
2026           IFS="$save_ifs"
2027         fi
2028         if test -n "$finish_eval"; then
2029           # Do the single finish_eval.
2030           eval cmds=\"$finish_eval\"
2031           $run eval "$cmds"
2032         fi
2033       done
2034     fi
2035
2036     echo "------------------------------------------------------------------------------"
2037     echo "Libraries have been installed in:"
2038     for libdir in $libdirs; do
2039       echo "   $libdir"
2040     done
2041     echo
2042     echo "To link against installed libraries in a given directory, LIBDIR,"
2043     echo "you must use the \`-LLIBDIR' flag during linking."
2044     echo
2045     echo " You will also need to do one of the following:"
2046     if test -n "$shlibpath_var"; then
2047       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2048       echo "     during execution"
2049     fi
2050     if test -n "$runpath_var"; then
2051       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2052       echo "     during linking"
2053     fi
2054     if test -n "$hardcode_libdir_flag_spec"; then
2055       libdir=LIBDIR
2056       eval flag=\"$hardcode_libdir_flag_spec\"
2057
2058       echo "   - use the \`$flag' linker flag"
2059     fi
2060     if test -f /etc/ld.so.conf; then
2061       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2062     fi
2063     echo
2064     echo "See any operating system documentation about shared libraries for"
2065     echo "more information, such as the ld(1) and ld.so(8) manual pages."
2066     echo "------------------------------------------------------------------------------"
2067     exit 0
2068     ;;
2069
2070   # libtool execute mode
2071   execute)
2072     modename="$modename: execute"
2073
2074     # The first argument is the command name.
2075     cmd="$nonopt"
2076     if test -z "$cmd"; then
2077       $echo "$modename: you must specify a COMMAND" 1>&2
2078       $echo "$help"
2079       exit 1
2080     fi
2081
2082     # Handle -dlopen flags immediately.
2083     for file in $execute_dlfiles; do
2084       if test -f "$file"; then :
2085       else
2086         $echo "$modename: \`$file' is not a file" 1>&2
2087         $echo "$help" 1>&2
2088         exit 1
2089       fi
2090
2091       dir=
2092       case "$file" in
2093       *.la)
2094         # Check to see that this really is a libtool archive.
2095         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
2096         else
2097           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2098           $echo "$help" 1>&2
2099           exit 1
2100         fi
2101
2102         # Read the libtool library.
2103         dlname=
2104         library_names=
2105
2106         # If there is no directory component, then add one.
2107         case "$file" in
2108         */* | *\\*) . $file ;;
2109         *) . ./$file ;;
2110         esac
2111
2112         # Skip this library if it cannot be dlopened.
2113         if test -z "$dlname"; then
2114           # Warn if it was a shared library.
2115           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
2116           continue
2117         fi
2118
2119         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2120         test "X$dir" = "X$file" && dir=.
2121
2122         if test -f "$dir/$objdir/$dlname"; then
2123           dir="$dir/$objdir"
2124         else
2125           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
2126           exit 1
2127         fi
2128         ;;
2129
2130       *.lo)
2131         # Just add the directory containing the .lo file.
2132         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2133         test "X$dir" = "X$file" && dir=.
2134         ;;
2135
2136       *)
2137         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
2138         continue
2139         ;;
2140       esac
2141
2142       # Get the absolute pathname.
2143       absdir=`cd "$dir" && pwd`
2144       test -n "$absdir" && dir="$absdir"
2145
2146       # Now add the directory to shlibpath_var.
2147       if eval "test -z \"\$$shlibpath_var\""; then
2148         eval "$shlibpath_var=\"\$dir\""
2149       else
2150         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2151       fi
2152     done
2153
2154     # This variable tells wrapper scripts just to set shlibpath_var
2155     # rather than running their programs.
2156     libtool_execute_magic="$magic"
2157
2158     # Check if any of the arguments is a wrapper script.
2159     args=
2160     for file
2161     do
2162       case "$file" in
2163       -*) ;;
2164       *)
2165         # Do a test to see if this is really a libtool program.
2166         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
2167           # If there is no directory component, then add one.
2168           case "$file" in
2169           */* | *\\*) . $file ;;
2170           *) . ./$file ;;
2171           esac
2172
2173           # Transform arg to wrapped name.
2174           file="$progdir/$program"
2175         fi
2176         ;;
2177       esac
2178       # Quote arguments (to preserve shell metacharacters).
2179       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
2180       args="$args \"$file\""
2181     done
2182
2183     if test -z "$run"; then
2184       # Export the shlibpath_var.
2185       eval "export $shlibpath_var"
2186
2187       # Now actually exec the command.
2188       eval "exec \$cmd$args"
2189
2190       $echo "$modename: cannot exec \$cmd$args"
2191       exit 1
2192     else
2193       # Display what would be done.
2194       eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
2195       $echo "export $shlibpath_var"
2196       $echo "$cmd$args"
2197       exit 0
2198     fi
2199     ;;
2200
2201   # libtool uninstall mode
2202   uninstall)
2203     modename="$modename: uninstall"
2204     rm="$nonopt"
2205     files=
2206
2207     for arg
2208     do
2209       case "$arg" in
2210       -*) rm="$rm $arg" ;;
2211       *) files="$files $arg" ;;
2212       esac
2213     done
2214
2215     if test -z "$rm"; then
2216       $echo "$modename: you must specify an RM program" 1>&2
2217       $echo "$help" 1>&2
2218       exit 1
2219     fi
2220
2221     for file in $files; do
2222       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2223       test "X$dir" = "X$file" && dir=.
2224       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2225
2226       rmfiles="$file"
2227
2228       case "$name" in
2229       *.la)
2230         # Possibly a libtool archive, so verify it.
2231         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
2232           . $dir/$name
2233
2234           # Delete the libtool libraries and symlinks.
2235           for n in $library_names; do
2236             rmfiles="$rmfiles $dir/$n"
2237             test "X$n" = "X$dlname" && dlname=
2238           done
2239           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
2240           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
2241
2242           $show "$rm $rmfiles"
2243           $run $rm $rmfiles
2244
2245           if test -n "$library_names"; then
2246             # Do each command in the postuninstall commands.
2247             eval cmds=\"$postuninstall_cmds\"
2248             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2249             for cmd in $cmds; do
2250               IFS="$save_ifs"
2251               $show "$cmd"
2252               $run eval "$cmd"
2253             done
2254             IFS="$save_ifs"
2255           fi
2256
2257           if test -n "$old_library"; then
2258             # Do each command in the old_postuninstall commands.
2259             eval cmds=\"$old_postuninstall_cmds\"
2260             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2261             for cmd in $cmds; do
2262               IFS="$save_ifs"
2263               $show "$cmd"
2264               $run eval "$cmd"
2265             done
2266             IFS="$save_ifs"
2267           fi
2268
2269           # FIXME: should reinstall the best remaining shared library.
2270         fi
2271         ;;
2272
2273       *.lo)
2274         if test "$build_old_libs" = yes; then
2275           oldobj=`$echo "X$name" | $Xsed -e 's/\.lo$/\.o/'`
2276           rmfiles="$rmfiles $dir/$oldobj"
2277         fi
2278         $show "$rm $rmfiles"
2279         $run $rm $rmfiles
2280         ;;
2281
2282       *)
2283         $show "$rm $rmfiles"
2284         $run $rm $rmfiles
2285         ;;
2286       esac
2287     done
2288     exit 0
2289     ;;
2290
2291   "")
2292     $echo "$modename: you must specify a MODE" 1>&2
2293     $echo "$generic_help" 1>&2
2294     exit 1
2295     ;;
2296   esac
2297
2298   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2299   $echo "$generic_help" 1>&2
2300   exit 1
2301 fi # test -z "$show_help"
2302
2303 # We need to display help for each of the modes.
2304 case "$mode" in
2305 "") $echo \
2306 "Usage: $modename [OPTION]... [MODE-ARG]...
2307
2308 Provide generalized library-building support services.
2309
2310 -n, --dry-run         display commands without modifying any files
2311     --features        display configuration information and exit
2312     --finish          same as \`--mode=finish'
2313     --help            display this help message and exit
2314     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
2315     --quiet           same as \`--silent'
2316     --silent          don't print informational messages
2317     --version         print version information
2318
2319 MODE must be one of the following:
2320
2321       compile         compile a source file into a libtool object
2322       execute         automatically set library path, then run a program
2323       finish          complete the installation of libtool libraries
2324       install         install libraries or executables
2325       link            create a library or an executable
2326       uninstall       remove libraries from an installed directory
2327
2328 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
2329 a more detailed description of MODE."
2330   exit 0
2331   ;;
2332
2333 compile)
2334   $echo \
2335 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2336
2337 Compile a source file into a libtool library object.
2338
2339 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2340 from the given SOURCEFILE.
2341
2342 The output file name is determined by removing the directory component from
2343 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2344 library object suffix, \`.lo'."
2345   ;;
2346
2347 execute)
2348   $echo \
2349 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
2350
2351 Automatically set library path, then run a program.
2352
2353 This mode accepts the following additional options:
2354
2355   -dlopen FILE      add the directory containing FILE to the library path
2356
2357 This mode sets the library path environment variable according to \`-dlopen'
2358 flags.
2359
2360 If any of the ARGS are libtool executable wrappers, then they are translated
2361 into their corresponding uninstalled binary, and any of their required library
2362 directories are added to the library path.
2363
2364 Then, COMMAND is executed, with ARGS as arguments."
2365   ;;
2366
2367 finish)
2368   $echo \
2369 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
2370
2371 Complete the installation of libtool libraries.
2372
2373 Each LIBDIR is a directory that contains libtool libraries.
2374
2375 The commands that this mode executes may require superuser privileges.  Use
2376 the \`--dry-run' option if you just want to see what would be executed."
2377   ;;
2378
2379 install)
2380   $echo \
2381 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
2382
2383 Install executables or libraries.
2384
2385 INSTALL-COMMAND is the installation command.  The first component should be
2386 either the \`install' or \`cp' program.
2387
2388 The rest of the components are interpreted as arguments to that command (only
2389 BSD-compatible install options are recognized)."
2390   ;;
2391
2392 link)
2393   $echo \
2394 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
2395
2396 Link object files or libraries together to form another library, or to
2397 create an executable program.
2398
2399 LINK-COMMAND is a command using the C compiler that you would use to create
2400 a program from several object files.
2401
2402 The following components of LINK-COMMAND are treated specially:
2403
2404   -all-static       do not do any dynamic linking at all
2405   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2406   -dlpreopen FILE   link in FILE and add its symbols to dld_preloaded_symbols
2407   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2408   -LLIBDIR          search LIBDIR for required installed libraries
2409   -lNAME            OUTPUT-FILE requires the installed library libNAME
2410   -no-undefined     declare that a library does not refer to external symbols
2411   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2412   -release RELEASE  specify package release information
2413   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2414   -static           do not do any dynamic linking of libtool libraries
2415   -version-info CURRENT[:REVISION[:AGE]]
2416                     specify library version info [each variable defaults to 0]
2417
2418 All other options (arguments beginning with \`-') are ignored.
2419
2420 Every other argument is treated as a filename.  Files ending in \`.la' are
2421 treated as uninstalled libtool libraries, other files are standard or library
2422 object files.
2423
2424 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
2425 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
2426
2427 If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar'
2428 and \`ranlib'.
2429
2430 If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is
2431 created, otherwise an executable program is created."
2432   ;;
2433
2434 uninstall)
2435   $echo
2436 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2437
2438 Remove libraries from an installation directory.
2439
2440 RM is the name of the program to use to delete files associated with each FILE
2441 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2442 to RM.
2443
2444 If FILE is a libtool library, all the files associated with it are deleted.
2445 Otherwise, only FILE itself is deleted using RM."
2446   ;;
2447
2448 *)
2449   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2450   $echo "$help" 1>&2
2451   exit 1
2452   ;;
2453 esac
2454
2455 echo
2456 $echo "Try \`$modename --help' for more information about other modes."
2457
2458 exit 0
2459
2460 # Local Variables:
2461 # mode:shell-script
2462 # sh-indentation:2
2463 # End: