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