ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # Generated automatically from ltmain.sh.in by configure.
   3 # Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   4 # Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19 #
  20 # As a special exception to the GNU General Public License, if you
  21 # distribute this file as part of a program that contains a
  22 # configuration script generated by Autoconf, you may include it under
  23 # the same distribution terms that you use for the rest of that program.
  24
  25 # The name of this program.
  26 progname=`echo "$0" | sed 's%^.*/%%'`
  27
  28 # Constants.
  29 PROGRAM=ltmain.sh
  30 PACKAGE=libtool
  31 VERSION=1.0
  32
  33 default_mode=
  34 help="Try \`$progname --help' for more information."
  35 magic="%%%MAGIC variable%%%"
  36 mkdir="mkdir"
  37 mv="mv -f"
  38 objdir=.libs
  39 rm="rm -f"
  40
  41 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  42   echo "$progname: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  43   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  44   exit 1
  45 fi
  46
  47 #
  48 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  49   echo "$progname: not configured to build any kind of library" 1>&2
  50   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  51   exit 1
  52 fi
  53
  54 # Global variables.
  55 mode=$default_mode
  56 nonopt=
  57 prev=
  58 prevopt=
  59 run=
  60 show=echo
  61 show_help=
  62
  63 # Parse our command line options once, thoroughly.
  64 while test $# -gt 0
  65 do
  66   arg="$1"
  67   shift
  68
  69   case "$arg" in
  70   -*=*) optarg=`echo "$arg" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  71   *) optarg= ;;
  72   esac
  73
  74   # If the previous option needs an argument, assign it.
  75   if test -n "$prev"; then
  76     eval "$prev=\$arg"
  77     prev=
  78     prevopt=
  79     continue
  80   fi
  81
  82   # Have we seen a non-optional argument yet?
  83   case "$arg" in
  84   --help)
  85     show_help=yes
  86     ;;
  87
  88   --version)
  89     echo "$PROGRAM (GNU $PACKAGE) $VERSION"
  90     exit 0
  91     ;;
  92
  93   --dry-run | -n)
  94     run=:
  95     ;;
  96
  97   --features)
  98     echo "host: $host"
  99     if test "$build_libtool_libs" = yes; then
 100       echo "enable shared libraries"
 101     else
 102       echo "disable shared libraries"
 103     fi
 104     if test "$build_old_libs" = yes; then
 105       echo "enable static libraries"
 106     else
 107       echo "disable static libraries"
 108     fi
 109     exit 0
 110     ;;
 111
 112   --finish) mode="finish" ;;
 113
 114   --mode) prevopt="--mode" prev=mode ;;
 115   --mode=*) mode="$optarg" ;;
 116
 117   -*)
 118     echo "$progname: unrecognized option \`$arg'" 1>&2
 119     echo "$help" 1>&2
 120     exit 1
 121     ;;
 122
 123   *)
 124     nonopt="$arg"
 125     break
 126     ;;
 127   esac
 128 done
 129
 130
 131 if test -n "$prevopt"; then
 132   echo "$progname: option \`$prevopt' requires an argument" 1>&2
 133   echo "$help" 1>&2
 134   exit 1
 135 fi
 136
 137
 138 if test -z "$show_help"; then
 139
 140   # Infer the operation mode.
 141   if test -z "$mode"; then
 142     case "$nonopt" in
 143     *cc)
 144       mode=link
 145       for arg
 146       do
 147         case "$arg" in
 148         -c)
 149            mode=compile
 150            break
 151            ;;
 152         esac
 153       done
 154       ;;
 155     *install*|cp)
 156       mode=install
 157       ;;
 158     *rm)
 159       mode=uninstall
 160       ;;
 161     *.la)
 162       mode=dlname
 163       ;;
 164     *)
 165       # Just use the default operation mode.
 166       if test -z "$mode"; then
 167         if test -n "$nonopt"; then
 168           echo "$progname: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 169         else
 170           echo "$progname: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 171         fi
 172       fi
 173       ;;
 174     esac
 175   fi
 176
 177   # Change the help message to a mode-specific one.
 178   generic_help="$help"
 179   help="Try \`$progname --help --mode=$mode' for more information."
 180
 181   # These modes are in order of execution frequency so that they run quickly.
 182   case "$mode" in
 183   # libtool compile mode
 184   compile)
 185     progname="$progname: compile"
 186     # Get the compilation command and the source file.
 187     base_compile="$nonopt"
 188     lastarg=
 189     srcfile=
 190
 191     for arg
 192     do
 193       # Quote any args containing shell metacharacters.
 194       case "$arg" in
 195       *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*|*\"*)
 196          quote_arg="'$arg'" ;;
 197       *) quote_arg="$arg" ;;
 198       esac
 199
 200       base_compile="$base_compile$lastarg"
 201       srcfile="$quote_arg"
 202       lastarg=" $srcfile"
 203     done
 204
 205     # Get the name of the library object.
 206     libobj=`echo "$srcfile" | sed -e 's%^.*/%%'`
 207
 208     # Recognize several different file suffixes.
 209     xform='[cCFSf]'
 210     case "$libobj" in
 211     *.c++) xform='c++' ;;
 212     *.cc) xform=cc ;;
 213     *.cpp) xform=cpp ;;
 214     *.cxx) xform=cxx ;;
 215     *.f90) xform=f90 ;;
 216     *.for) xform='for' ;;
 217     esac
 218
 219     libobj=`echo "$libobj" | sed -e "s/\.$xform$/.lo/"`
 220
 221     case "$libobj" in
 222     *.lo) obj=`echo "$libobj" | sed -e 's/\.lo$/.o/'` ;;
 223     *)
 224       echo "$progname: cannot determine name of library object from \`$srcfile'" 1>&2
 225       exit 1
 226       ;;
 227     esac
 228
 229     if test -z "$base_compile"; then
 230       echo "$progname: you must specify a compilation command" 1>&2
 231       echo "$help" 1>&2
 232       exit 1
 233     fi
 234
 235     # Delete any leftover library objects.
 236     if test "$build_old_libs" = yes; then
 237       $run $rm $obj $libobj
 238       trap "$run $rm $obj $libobj; exit 1" 1 2 15
 239     else
 240       $run $rm $libobj
 241       trap "$run $rm $libobj; exit 1" 1 2 15
 242     fi
 243
 244     # Only build a PIC object if we are building libtool libraries.
 245     if test "$build_libtool_libs" = yes; then
 246       # All platforms use -DPIC, to notify preprocessed assembler code.
 247       $show "$base_compile$pic_flag -DPIC $srcfile"
 248       if $run eval "$base_compile$pic_flag -DPIC $srcfile"; then :
 249       else
 250         test -n "$obj" && $run $rm $obj
 251         exit 1
 252       fi
 253
 254       # If we have no pic_flag, then copy the object into place and finish.
 255       if test -z "$pic_flag"; then
 256         $show "$LN_S $obj $libobj"
 257         $run $LN_S $obj $libobj
 258         exit $?
 259       fi
 260
 261       # Just move the object, then go on to compile the next one
 262       $show "$mv $obj $libobj"
 263       $run $mv $obj $libobj || exit 1
 264     fi
 265
 266     # Only build a position-dependent object if we build old libraries.
 267     if test "$build_old_libs" = yes; then
 268       $show "$base_compile $srcfile"
 269       if $run eval "$base_compile $srcfile"; then :
 270       else
 271         $run $rm $obj $libobj
 272         exit 1
 273       fi
 274     fi
 275
 276     # Create an invalid libtool object if no PIC, so that we don't accidentally
 277     # link it into a program.
 278     if test "$build_libtool_libs" != yes; then
 279       $show "echo timestamp > $libobj"
 280       $run eval "echo timestamp > $libobj" || exit $?
 281     fi
 282
 283     exit 0
 284     ;;
 285
 286   # libtool link mode
 287   link)
 288     progname="$progname: link"
 289     # Go through the arguments, transforming them on the way.
 290     cc="$nonopt"
 291     args="$cc"
 292     allow_undefined=no
 293     compile_command="$cc"
 294     finalize_command="$cc"
 295     compile_shlibpath=
 296     finalize_shlibpath=
 297     deplibs=
 298     export_dynamic=no
 299     hardcode_libdirs=
 300     install_libdir=
 301     libobjs=
 302     link_against_libtool_libs=
 303     link_static=
 304     ltlibs=
 305     objs=
 306     prev=
 307     prevarg=
 308     perm_rpath=
 309     temp_rpath=
 310     vinfo=
 311
 312     # We need to know -static, to get the right output filenames.
 313     for arg
 314     do
 315       case "$arg" in
 316       -static)
 317         build_libtool_libs=no
 318         build_old_libs=yes
 319         break
 320         ;;
 321       esac
 322     done
 323
 324     for arg
 325     do
 326       # If the previous option needs an argument, assign it.
 327       if test -n "$prev"; then
 328         case "$prev" in
 329         output)
 330           compile_command="$compile_command @OUTPUT@"
 331           finalize_command="$finalize_command @OUTPUT@"
 332           args="$args $arg"
 333           ;;
 334         esac
 335
 336         eval "$prev=\$arg"
 337         prev=
 338
 339         continue
 340       fi
 341
 342       args="$args $arg"
 343       prevarg="$arg"
 344
 345       case "$arg" in
 346       -allow-undefined) allow_undefined=yes ;;
 347
 348       -export-dynamic)
 349         export_dynamic=yes
 350         compile_command="$compile_command $export_dynamic_flag"
 351         finalize_command="$finalize_command $export_dynamic_flag"
 352         continue
 353         ;;
 354
 355       -L*)
 356         dir=`echo "$arg" | sed 's%^-L\(.*\)$%\1%'`
 357         case "$dir" in
 358         /*)
 359           ;;
 360         *)
 361           echo "$progname: \`-L$dir' cannot specify a relative directory" 1>&2
 362           exit 1
 363           ;;
 364         esac
 365         deplibs="$deplibs $arg"
 366         ;;
 367
 368       -l*) deplibs="$deplibs $arg" ;;
 369
 370       -o) prev=output ;;
 371
 372       -rpath)
 373         prev=install_libdir
 374         continue
 375         ;;
 376
 377       -static)
 378         link_static="`eval echo \"$link_static_flag\"`"
 379         compile_command="$compile_command $link_static"
 380         continue
 381         ;;
 382
 383       -version-file)
 384         echo "$progname: \`-version-file' has been replaced by \`-version-info'" 1>&2
 385         echo "$help" 1>&2
 386         exit 1
 387         ;;
 388
 389       -version-info)
 390         prev=vinfo
 391         continue
 392         ;;
 393
 394       -*) cc="$cc $arg" ;; # Some other compiler flag.
 395
 396       *.o)
 397         # A standard object.
 398         objs="$objs $arg"
 399         ;;
 400
 401       *.a)
 402         # Find the relevant object directory and library name.
 403         file=`echo "$arg" | sed 's%^.*/%%'`
 404         dir=`echo "$arg" | sed 's%/[^/]*$%/%'`
 405         test "$dir" = "$arg" && dir=
 406
 407         # Standard archive.
 408         objs="$objs $arg"
 409         ;;
 410
 411       *.lo)
 412         # A library object.
 413         libobjs="$libobjs $arg"
 414         ;;
 415
 416       *.la)
 417         # A libtool-controlled library.
 418
 419         libdir=
 420         library_names=
 421         old_library=
 422
 423         # Check to see that this really is a libtool archive.
 424         if egrep "^# Generated by $PROGRAM" $arg >/dev/null 2>&1; then :
 425         else
 426           echo "$progname: \`$arg' is not a valid libtool archive" 1>&2
 427           exit 1
 428         fi
 429
 430         # If there is no directory component, then add one.
 431         case "$arg" in
 432         */*) . $arg ;;
 433         *) . ./$arg ;;
 434         esac
 435
 436         if test -z "$libdir"; then
 437           echo "$progname: \`$arg' contains no -rpath information" 1>&2
 438           exit 1
 439         fi
 440
 441         # Get the name of the library we link against.
 442         linklib=
 443         for l in $old_library $library_names; do
 444           linklib="$l"
 445         done
 446
 447         if test -z "$linklib"; then
 448           echo "$progname: cannot find name of link library for \`$arg'" 1>&2
 449           exit 1
 450         fi
 451
 452         # Find the relevant object directory and library name.
 453         name=`echo "$arg" | sed 's%^.*/%%; s/\.la$//; s/^lib//'`
 454         dir=`echo "$arg" | sed 's%/[^/]*$%%'`
 455         if test "$dir" = "$arg"; then
 456           dir="$objdir"
 457         else
 458           dir="$dir/$objdir"
 459         fi
 460
 461         if test "$build_libtool_libs" = yes && test -n "$library_names"; then
 462           link_against_libtool_libs="$link_against_libtool_libs $arg"
 463           if test -n "$shlibpath_var"; then
 464             # Make sure the rpath contains only unique directories.
 465             case "$temp_rpath " in
 466             "* $dir *") ;;
 467             *) temp_rpath="$temp_rpath $dir" ;;
 468             esac
 469           fi
 470
 471           if test -n "$hardcode_libdir_flag_spec"; then
 472             if test -n "$hardcode_libdir_separator"; then
 473               if test -z "$hardcode_libdirs"; then
 474                 # Put the magic libdir with the hardcode flag.
 475                 hardcode_libdirs="$libdir"
 476                 libdir="@HARDCODE_LIBDIRS@"
 477               else
 478                 # Just accumulate the libdirs.
 479                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 480                 libdir=
 481               fi
 482             fi
 483
 484             if test -n "$libdir"; then
 485               hardcode_libdir_flag=`eval echo \"$hardcode_libdir_flag_spec\"`
 486               compile_command="$compile_command $hardcode_libdir_flag"
 487               finalize_command="$finalize_command $hardcode_libdir_flag"
 488             fi
 489           elif test "$hardcode_runpath_var" = yes; then
 490             # Do the same for the permanent run path.
 491             case "$perm_rpath " in
 492             "* $libdir *") ;;
 493             *) perm_rpath="$perm_rpath $libdir" ;;
 494             esac
 495           fi
 496
 497
 498           case "$hardcode_action" in
 499           immediate)
 500             if test "$hardcode_direct" = no; then
 501               compile_command="$compile_command $dir/$linklib"
 502             elif test "$hardcode_minus_L" = no; then
 503               compile_command="$compile_command -L$dir -l$name"
 504             elif test "$hardcode_shlibpath_var" = no; then
 505               compile_shlibpath="$compile_shlibpath$dir:"
 506               compile_command="$compile_command -l$name"
 507             fi
 508             ;;
 509
 510           relink)
 511             # We need an absolute path.
 512             case "$dir" in
 513             /*) ;;
 514             *)
 515               absdir=`cd "$dir" && pwd`
 516               if test -z "$absdir"; then
 517                 echo "$progname: cannot determine absolute directory name of \`$dir'" 1>&2
 518                 exit 1
 519               fi
 520               dir="$absdir"
 521               ;;
 522             esac
 523
 524             if test "$hardcode_direct" = yes; then
 525               compile_command="$compile_command $dir/$linklib"
 526             elif test "$hardcode_minus_L" = yes; then
 527               compile_command="$compile_command -L$dir -l$name"
 528             elif test "$hardcode_shlibpath_var" = yes; then
 529               compile_shlibpath="$compile_shlibpath$dir:"
 530               compile_command="$compile_command -l$name"
 531             fi
 532             ;;
 533
 534           *)
 535             echo "$progname: \`$hardcode_action' is an unknown hardcode action" 1>&2
 536             exit 1
 537             ;;
 538           esac
 539
 540           # Finalize command for both is simple: just hardcode it.
 541           if test "$hardcode_direct" = yes; then
 542             finalize_command="$finalize_command $libdir/$linklib"
 543           elif test "$hardcode_minus_L" = yes; then
 544             finalize_command="$finalize_command -L$libdir -l$name"
 545           elif test "$hardcode_shlibpath_var" = yes; then
 546             finalize_shlibpath="$finalize_shlibpath$libdir:"
 547             finalize_command="$finalize_command -l$name"
 548           else
 549             # We can't seem to hardcode it, guess we'll fake it.
 550             finalize_command="$finalize_command -L$libdir -l$name"
 551           fi
 552         else
 553           # Transform directly to old archives if we don't build new libraries.
 554           if test -n "$pic_flag" && test -z "$old_library"; then
 555             echo "$progname: cannot find static library for \`$arg'" 1>&2
 556             exit 1
 557           fi
 558           test -n "$old_library" && linklib="$old_library"
 559           compile_command="$compile_command $dir/$linklib"
 560           finalize_command="$finalize_command $dir/$linklib"
 561         fi
 562         continue
 563         ;;
 564
 565       *)
 566         echo "$progname: unknown file suffix for \`$arg'" 1>&2
 567         echo "$help" 1>&2
 568         exit 1
 569         ;;
 570       esac
 571
 572       compile_command="$compile_command $arg"
 573       finalize_command="$finalize_command $arg"
 574     done
 575
 576     if test -n "$prev"; then
 577       echo "$progname: the \`$prevarg' option requires an argument" 1>&2
 578       echo "$help" 1>&2
 579       exit 1
 580     fi
 581
 582     # Substitute the hardcoded libdirs into the compile commands.
 583     if test "$hardcode_libdir_colon_separated" = yes; then
 584       compile_command=`echo "$compile_command" | sed "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
 585       finalize_command=`echo "$finalize_command" | sed "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
 586     fi
 587
 588     oldlib=
 589     oldobjs=
 590     case "$output" in
 591     "")
 592       echo "$progname: you must specify an output file" 1>&2
 593       echo "$help" 1>&2
 594       exit 1
 595       ;;
 596
 597     */*)
 598       echo "$progname: output file \`$output' must have no directory components" 1>&2
 599       exit 1
 600       ;;
 601
 602     *.la)
 603       libname=`echo "$output" | sed 's/\.la$//'`
 604
 605       # All the library-specific variables (install_libdir is set above).
 606       library_names=
 607       old_library=
 608       dlname=
 609       current=0
 610       revision=0
 611       age=0
 612
 613       if test -n "$objs"; then
 614         echo "$progname: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
 615         exit 1
 616       fi
 617
 618       # How the heck are we supposed to write a wrapper for a shared library?
 619       if test -n "$link_against_libtool_libs"; then
 620         echo "$progname: libtool library \`$output' may not depend on uninstalled libraries:$link_against_libtool_libs" 1>&2
 621         exit 1
 622       fi
 623
 624       if test -z "$install_libdir"; then
 625         echo "$progname: you must specify an installation directory with \`-rpath'" 1>&2
 626         exit 1
 627       fi
 628
 629       # Parse the version information argument.
 630       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=':'
 631       set dummy $vinfo
 632       IFS="$save_ifs"
 633
 634       if test -n "$5"; then
 635         echo "$progname: too many parameters to \`-version-info'" 1>&2
 636         echo "$help" 1>&2
 637         exit 1
 638       fi
 639
 640       test -n "$2" && current="$2"
 641       test -n "$3" && revision="$3"
 642       test -n "$4" && age="$4"
 643
 644       # Check that each of the things are valid numbers.
 645       case "$current" in
 646       0 | [1-9] | [1-9][0-9]*) ;;
 647       *)
 648         echo "$progname: CURRENT \`$current' is not a nonnegative integer" 1>&2
 649         echo "$progname: \`$vinfo' is not valid version information" 1>&2
 650         exit 1
 651         ;;
 652       esac
 653
 654       case "$revision" in
 655       0 | [1-9] | [1-9][0-9]*) ;;
 656       *)
 657         echo "$progname: REVISION \`$revision' is not a nonnegative integer" 1>&2
 658         echo "$progname: \`$vinfo' is not valid version information" 1>&2
 659         exit 1
 660         ;;
 661       esac
 662
 663       case "$age" in
 664       0 | [1-9] | [1-9][0-9]*) ;;
 665       *)
 666         echo "$progname: AGE \`$age' is not a nonnegative integer" 1>&2
 667         echo "$progname: \`$vinfo' is not valid version information" 1>&2
 668         exit 1
 669         ;;
 670       esac
 671
 672       if test $age -gt $current; then
 673         echo "$progname: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
 674         echo "$progname: \`$vinfo' is not valid version information" 1>&2
 675         exit 1
 676       fi
 677
 678       # Calculate the version variables.
 679       version_vars="version_type current age revision"
 680       case "$version_type" in
 681       none) ;;
 682
 683       linux)
 684         version_vars="$version_vars major versuffix"
 685         major=`expr $current - $age`
 686         versuffix="$major.$age.$revision"
 687         ;;
 688
 689       osf)
 690         version_vars="$version_vars versuffix verstring"
 691         major=`expr $current - $age`
 692         versuffix="$current.$age.$revision"
 693         verstring="$versuffix"
 694
 695         # Add in all the interfaces that we are compatible with.
 696         loop=$age
 697         while test $loop != 0; do
 698           iface=`expr $current - $loop`
 699           loop=`expr $loop - 1`
 700           verstring="$verstring:${iface}.0"
 701         done
 702
 703         # Make executables depend on our current version.
 704         verstring="$verstring:${current}.0"
 705         ;;
 706
 707       sunos)
 708         version_vars="$version_vars major versuffix"
 709         major="$current"
 710         versuffix="$current.$revision"
 711         ;;
 712
 713       *)
 714         echo "$progname: unknown library version type \`$version_type'" 1>&2
 715         echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 716         exit 1
 717         ;;
 718       esac
 719
 720       # Create the output directory, or remove our outputs if we need to.
 721       if test -d $objdir; then
 722         $show "$rm $objdir/$libname.*"
 723         $run $rm $objdir/$libname.*
 724       else
 725         $show "$mkdir $objdir"
 726         $run $mkdir $objdir || exit $?
 727       fi
 728
 729       # Check to see if the archive will have undefined symbols.
 730       if test "$allow_undefined" = yes; then
 731         if test "$allow_undefined_flag" = unsupported; then
 732           echo "$progname: warning: undefined symbols not allowed in $host shared libraries" 1>&2
 733           build_libtool_libs=no
 734         fi
 735       else
 736         # Clear the flag.
 737         allow_undefined_flag=
 738       fi
 739
 740       if test "$build_libtool_libs" = yes; then
 741         # Get the real and link names of the library.
 742         library_names=`eval echo \"$library_names_spec\"`
 743         set dummy $library_names
 744         realname="$2"
 745         shift; shift
 746
 747         if test -n "$soname_spec"; then
 748           soname=`eval echo \"$soname_spec\"`
 749         else
 750           soname="$realname"
 751         fi
 752
 753         lib="$objdir/$realname"
 754         linknames=
 755         for link
 756         do
 757           linknames="$linknames $link"
 758         done
 759
 760         # Use standard objects if they are PIC.
 761         test -z "$pic_flag" && libobjs=`echo "$libobjs " | sed 's/\.lo /.o /g; s/ $//g'`
 762
 763         # Do each of the archive commands.
 764         cmds=`eval echo \"$archive_cmds\"`
 765         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
 766         for cmd in $cmds; do
 767           IFS="$save_ifs"
 768           $show "$cmd"
 769           $run eval "$cmd" || exit $?
 770         done
 771         IFS="$save_ifs"
 772
 773         # Create links to the real library.
 774         for link in $linknames; do
 775           $show "(cd $objdir && $LN_S $realname $link)"
 776           $run eval "(cd $objdir && $LN_S $realname $link)" || exit $?
 777         done
 778
 779         # If -export-dynamic was specified, set the dlname.
 780         if test "$export_dynamic" = yes; then
 781           # On all known operating systems, these are identical.
 782           dlname="$soname"
 783         fi
 784       fi
 785       ;;
 786
 787     *.lo | *.o)
 788       if test -n "$link_against_libtool_libs"; then
 789         echo "$progname: error: cannot link libtool libraries into reloadable objects" 1>&2
 790         exit 1
 791       fi
 792
 793       if test -n "$deplibs"; then
 794         echo "$progname: warning: \`-l' and \`-L' are ignored while creating objects" 1>&2
 795       fi
 796
 797       if test -n "$install_libdir"; then
 798         echo "$progname: warning: \`-rpath' is ignored while creating objects" 1>&2
 799       fi
 800
 801       if test -n "$vinfo"; then
 802         echo "$progname: warning: \`-version-info' is ignored while creating objects" 1>&2
 803       fi
 804
 805       case "$output" in
 806       *.lo)
 807         if test -n "$objs"; then
 808           echo "$progname: cannot build library object \`$output' from non-libtool objects" 1>&2
 809           exit 1
 810         fi
 811         libobj="$output"
 812         obj=`echo "$output" | sed 's/\.lo$/.o/'`
 813         ;;
 814       *)
 815         libobj=
 816         obj="$output"
 817         ;;
 818       esac
 819
 820       # Delete the old objects.
 821       $run $rm $obj $libobj
 822
 823       # Create the old-style object.
 824       reload_objs="$objs"`echo "$libobjs " | sed 's/[^  ]*\.a //g; s/\.lo /.o /g; s/ $//g'`
 825
 826       output="$obj"
 827       cmds=`eval echo \"$reload_cmds\"`
 828       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
 829       for cmd in $cmds; do
 830         IFS="$save_ifs"
 831         $show "$cmd"
 832         $run eval "$cmd" || exit $?
 833       done
 834       IFS="$save_ifs"
 835
 836       # Exit if we aren't doing a library object file.
 837       test -z "$libobj" && exit 0
 838
 839       if test "$build_libtool_libs" != yes; then
 840         # Create an invalid libtool object if no PIC, so that we don't
 841         # accidentally link it into a program.
 842         $show "echo timestamp > $libobj"
 843         $run eval "echo timestamp > $libobj" || exit $?
 844         exit 0
 845       fi
 846
 847       if test -n "$pic_flag"; then
 848         # Only do commands if we really have different PIC objects.
 849         reload_objs="$libobjs"
 850         output="$libobj"
 851         cmds=`eval echo \"$reload_cmds\"`
 852         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
 853         for cmd in $cmds; do
 854           IFS="$save_ifs"
 855           $show "$cmd"
 856           $run eval "$cmd" || exit $?
 857         done
 858         IFS="$save_ifs"
 859       else
 860         # Just create a symlink.
 861         $show "$LN_S $obj $libobj"
 862         $run $LN_S $obj $libobj || exit 1
 863       fi
 864
 865       exit 0
 866       ;;
 867
 868     *)
 869       if test -n "$install_libdir"; then
 870         echo "$progname: warning: \`-rpath' is ignored while linking programs" 1>&2
 871       fi
 872
 873       if test -n "$vinfo"; then
 874         echo "$progname: warning: \`-version-info' is ignored while linking programs" 1>&2
 875       fi
 876
 877       if test -n "$libobjs"; then
 878         # Transform all the library objects into standard objects.
 879         compile_command=`echo "$compile_command " | sed 's/\.lo /.o /g; s/ $//'`
 880         finalize_command=`echo "$finalize_command " | sed 's/\.lo /.o /g; s/ $//'`
 881       fi
 882
 883       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
 884         # Replace the output file specification.
 885         compile_command=`echo "$compile_command" | sed 's%@OUTPUT@%'"$output"'%g'`
 886         finalize_command=`echo "$finalize_command" | sed 's%@OUTPUT@%'"$output"'%g'`
 887
 888         # We have no uninstalled library dependencies, so finalize right now.
 889         $show "$compile_command"
 890         $run $compile_command
 891         status=$?
 892
 893         # If we failed to link statically, then try again.
 894         if test $status -ne 0 && test -n "$link_static"; then
 895           echo "$progname: cannot link \`$output' statically; retrying semi-dynamically" 1>&2
 896           compile_command=`echo "$compile_command " | sed "s% $link_static % %;s/ $//"`
 897           $show "$finalize_command"
 898           $run $finalize_command
 899           status=$?
 900         fi
 901         exit $status
 902       fi
 903
 904       # Replace the output file specification.
 905       compile_command=`echo "$compile_command" | sed 's%@OUTPUT@%'"$objdir/$output"'%g'`
 906       finalize_command=`echo "$finalize_command" | sed 's%@OUTPUT@%'"$objdir/$output"'T%g'`
 907
 908       # Create the binary in the object directory, then wrap it.
 909       if test -d $objdir; then :
 910       else
 911         $show "$mkdir $objdir"
 912         $run $mkdir $objdir || exit $?
 913       fi
 914
 915       if test -n "$shlibpath_var"; then
 916         # We should set the shlibpath_var
 917         rpath=
 918         for dir in $temp_rpath; do
 919           case "$dir" in
 920           /*)
 921             # Absolute path.
 922             rpath="$rpath$dir:"
 923             ;;
 924           *)
 925             # Relative path: add a thisdir entry.
 926             rpath="$rpath\$thisdir/$dir:"
 927             ;;
 928           esac
 929         done
 930         temp_rpath="$rpath"
 931       fi
 932
 933       # Delete the old output file.
 934       $run $rm $output
 935
 936       if test -n "$compile_shlibpath"; then
 937         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
 938       fi
 939       if test -n "$finalize_shlibpath"; then
 940         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 941       fi
 942
 943       if test -n "$perm_rpath"; then
 944         # We should set the runpath_var.
 945         rpath=
 946         for dir in $perm_rpath; do
 947           rpath="$rpath$dir:"
 948         done
 949         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
 950         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
 951       fi
 952
 953       case "$hardcode_action" in
 954       relink)
 955         # AGH! Flame the AIX and HP-UX people for me, will ya?
 956         echo "$progname: warning: using a buggy system linker" 1>&2
 957         echo "$progname: relinking will be required before \`$output' can be installed" 1>&2
 958         ;;
 959       esac
 960
 961       $show "$compile_command"
 962       $run eval "$compile_command" || exit $?
 963
 964       # Now create the wrapper script.
 965       echo "creating $output"
 966
 967       # Only actually do things if our run command is non-null.
 968       if test -z "$run"; then
 969         $rm $output
 970         trap "$rm $output; exit 1" 1 2 15
 971
 972         cat > $output <<EOF
 973 #! /bin/sh
 974
 975 # $output - temporary wrapper script for $objdir/$output
 976 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
 977 #
 978 # The $output program cannot be directly executed until all the libtool
 979 # libraries that it depends on are installed.
 980 #
 981 # This wrapper script should never be moved out of \``pwd`'.
 982 # If it is, it will not operate correctly.
 983
 984 # This environment variable determines our operation mode.
 985 if test "\$libtool_install_magic" = "$magic"; then
 986   # install mode needs the following variables:
 987   link_against_libtool_libs='$link_against_libtool_libs'
 988   finalize_command='$finalize_command'
 989 else
 990   # Find the directory that this script lives in.
 991   thisdir=\`echo \$0 | sed 's%/[^/]*$%%'\`
 992   test "x\$thisdir" = "x\$0" && thisdir=.
 993
 994   # Try to get the absolute directory name.
 995   absdir=\`cd "\$thisdir" && pwd\`
 996   test -n "\$absdir" && thisdir="\$absdir"
 997
 998   progdir="\$thisdir/$objdir"
 999   program="$output"
1000
1001   if test -f "\$progdir/\$program"; then
1002     # Run the actual program with our arguments.
1003     args=
1004     for arg
1005     do
1006       # Quote arguments (to preserve shell metacharacters).
1007       args="\$args '\$arg'"
1008     done
1009
1010     # Export the path to the program.
1011     PATH="\$progdir:\$PATH"
1012     export PATH
1013 EOF
1014
1015         # Export our shlibpath_var if we have one.
1016         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
1017           cat >> $output <<EOF
1018
1019     # Add our own library path to $shlibpath_var
1020     $shlibpath_var="$temp_rpath\$$shlibpath_var"
1021
1022     # Some systems cannot cope with colon-terminated $shlibpath_var
1023     $shlibpath_var=\`echo \$$shlibpath_var | sed -e 's/:*\$//'\`
1024
1025     export $shlibpath_var
1026 EOF
1027         fi
1028
1029         cat >> $output <<EOF
1030
1031     eval "exec \$program \$args"
1032
1033     echo "\$0: cannot exec \$program \$args"
1034     exit 1
1035   else
1036     # The program doesn't exist.
1037     echo "\$0: error: \$progdir/\$program does not exist" 1>&2
1038     echo "This script is just a wrapper for \$program." 1>&2
1039     echo "See the $PACKAGE documentation for more information." 1>&2
1040     exit 1
1041   fi
1042 fi
1043 EOF
1044         chmod +x $output
1045       fi
1046       exit 0
1047       ;;
1048     esac
1049
1050
1051     # See if we need to build an old-fashioned archive.
1052     if test "$build_old_libs" = "yes"; then
1053       # Now set the variables for building old libraries.
1054       oldlib="$objdir/$libname.a"
1055
1056       # Transform .lo files to .o files.
1057       oldobjs="$objs"`echo "$libobjs " | sed 's/[^      ]*\.a //g; s/\.lo /.o /g; s/ $//g'`
1058
1059       if test -d "$objdir"; then
1060         $show "$rm $oldlib"
1061         $run $rm $oldlib
1062       else
1063         $show "$mkdir $objdir"
1064         $run $mkdir $objdir
1065       fi
1066
1067       # Do each command in the archive commands.
1068       cmds=`eval echo \"$old_archive_cmds\"`
1069       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1070       for cmd in $cmds; do
1071         IFS="$save_ifs"
1072         $show "$cmd"
1073         $run eval "$cmd" || exit $?
1074       done
1075       IFS="$save_ifs"
1076     fi
1077
1078     # Now create the libtool archive.
1079     case "$output" in
1080     *.la)
1081       old_library=
1082       test "$build_old_libs" = yes && old_library="$libname.a"
1083
1084       echo "creating $output"
1085
1086       # Only create the output if not a dry run.
1087       if test -z "$run"; then
1088         cat > $output <<EOF
1089 # $output - a libtool library file
1090 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
1091
1092 # The name that we can dlopen(3).
1093 dlname='$dlname'
1094
1095 # Names of this library.
1096 library_names='$library_names'
1097
1098 # The name of the static archive.
1099 old_library='$old_library'
1100
1101 # Version information for $libname.
1102 current=$current
1103 age=$age
1104 revision=$revision
1105
1106 # Directory that this library needs to be installed in:
1107 libdir='$install_libdir'
1108 EOF
1109       fi
1110
1111       # Do a symbolic link so that the libtool archive can be found in
1112       # LD_LIBRARY_PATH before the program is installed.
1113       $show "(cd $objdir && $LN_S ../$output $output)"
1114       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit 1
1115       ;;
1116     esac
1117     exit 0
1118     ;;
1119
1120   # libtool install mode
1121   install)
1122     progname="$progname: install"
1123
1124     # The first argument is the name of the installation program.
1125     install_prog="$nonopt"
1126
1127     # CYGNUS LOCAL: Handle /bin/sh at the start.
1128     if test "$install_prog" = "/bin/sh"; then
1129       install_prog=$1
1130       shift
1131     fi
1132
1133     # We need to accept at least all the BSD install flags.
1134     dest=
1135     files=
1136     opts=
1137     prev=
1138     install_type=
1139     isdir=
1140     stripme=
1141     for arg
1142     do
1143       if test -n "$dest"; then
1144         files="$files $dest"
1145         dest="$arg"
1146         continue
1147       fi
1148
1149       case "$arg" in
1150       -d) isdir=yes ;;
1151       -f) prev="-f" ;;
1152       -g) prev="-g" ;;
1153       -m) prev="-m" ;;
1154       -o) prev="-o" ;;
1155       -s)
1156         stripme=" -s"
1157         continue
1158         ;;
1159       -*) ;;
1160
1161       *)
1162         # If the previous option needed an argument, then skip it.
1163         if test -n "$prev"; then
1164           prev=
1165         else
1166           dest="$arg"
1167           continue
1168         fi
1169         ;;
1170       esac
1171       install_prog="$install_prog $arg"
1172     done
1173
1174     if test -z "$install_prog"; then
1175       echo "$progname: you must specify an install program" 1>&2
1176       echo "$help" 1>&2
1177       exit 1
1178     fi
1179
1180     if test -n "$prev"; then
1181       echo "$progname: the \`$prev' option requires an argument" 1>&2
1182       echo "$help" 1>&2
1183       exit 1
1184     fi
1185
1186     if test -z "$files"; then
1187       if test -z "$dest"; then
1188         echo "$progname: no file or destination specified" 1>&2
1189       else
1190         echo "$progname: you must specify a destination" 1>&2
1191       fi
1192       echo "$help" 1>&2
1193       exit 1
1194     fi
1195
1196     # Strip any trailing slash from the destination.
1197     dest=`echo "$dest" | sed 's%/$%%'`
1198
1199     # Check to see that the destination is a directory.
1200     test -d "$dest" && isdir=yes
1201     if test -n "$isdir"; then
1202       destdir="$dest"
1203       destname=
1204     else
1205       destdir=`echo "$dest" | sed 's%/[^/]*$%%'`
1206       test "$destdir" = "$dest" && destdir=.
1207       destname=`echo "$dest" | sed 's%^.*/%%'`
1208
1209       # Not a directory, so check to see that there is only one file specified.
1210       set dummy $files
1211       if test $# -gt 2; then
1212         echo "$progname: \`$dest' is not a directory" 1>&2
1213         echo "$help" 1>&2
1214         exit 1
1215       fi
1216     fi
1217     case "$destdir" in
1218     /*) ;;
1219     *)
1220       for file in $files; do
1221         case "$file" in
1222         *.lo) ;;
1223         *)
1224           echo "$progname: \`$destdir' must be an absolute directory name" 1>&2
1225           echo "$help" 1>&2
1226           exit 1
1227           ;;
1228         esac
1229       done
1230       ;;
1231     esac
1232
1233     staticlibs=
1234     future_libdirs=
1235     current_libdirs=
1236     for file in $files; do
1237
1238       # Do each installation.
1239       case "$file" in
1240       *.a)
1241         # Do the static libraries later.
1242         staticlibs="$staticlibs $file"
1243         ;;
1244
1245       *.la)
1246         # Check to see that this really is a libtool archive.
1247         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then :
1248         else
1249           echo "$progname: \`$file' is not a valid libtool archive" 1>&2
1250           echo "$help" 1>&2
1251           exit 1
1252         fi
1253
1254         library_names=
1255         old_library=
1256         # If there is no directory component, then add one.
1257         case "$file" in
1258         */*) . $file ;;
1259         *) . ./$file ;;
1260         esac
1261
1262         # Add the libdir to current_libdirs if it is the destination.
1263         if test "$destdir" = "$libdir"; then
1264           case "$current_libdirs " in
1265           "* $libdir *") ;;
1266           *) current_libdirs="$current_libdirs $libdir" ;;
1267           esac
1268         else
1269           # Note the libdir as a future libdir.
1270           case "$future_libdirs " in
1271           "* $libdir *") ;;
1272           *) future_libdirs="$future_libdirs $libdir" ;;
1273           esac
1274         fi
1275
1276         dir="`echo "$file" | sed 's%/[^/]*$%%'`/"
1277         test "$dir" = "$file/" && dir=
1278         dir="$dir$objdir"
1279
1280         # See the names of the shared library.
1281         set dummy $library_names
1282         if test -n "$2"; then
1283           realname="$2"
1284           shift
1285           shift
1286
1287           # Install the shared library and build the symlinks.
1288           $show "$install_prog $dir/$realname $destdir/$realname"
1289           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
1290           test "X$dlname" = "X$realname" && dlname=
1291
1292           # Support stripping libraries.
1293           if test -n "$stripme"; then
1294             if test -n "$striplib"; then
1295               $show "$striplib $destdir/$realname"
1296               $run $striplib $destdir/$realname || exit $?
1297             else
1298               echo "$progname: warning: no library stripping program" 1>&2
1299             fi
1300           fi
1301
1302           if test $# -gt 0; then
1303             # Delete the old symlinks.
1304             rmcmd="$rm"
1305             for linkname
1306             do
1307               rmcmd="$rmcmd $destdir/$linkname"
1308             done
1309             $show "$rmcmd"
1310             $run $rmcmd
1311
1312             # ... and create new ones.
1313             for linkname
1314             do
1315               test "X$dlname" = "X$linkname" && dlname=
1316               $show "(cd $destdir && $LN_S $realname $linkname)"
1317               $run eval "(cd $destdir && $LN_S $realname $linkname)"
1318             done
1319           fi
1320
1321           if test -n "$dlname"; then
1322             # Install the dynamically-loadable library.
1323             $show "$install_prog $dir/$dlname $destdir/$dlname"
1324             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1325           fi
1326
1327           # Do each command in the postinstall commands.
1328           lib="$destdir/$realname"
1329           cmds=`eval echo \"$postinstall_cmds\"`
1330           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1331           for cmd in $cmds; do
1332             IFS="$save_ifs"
1333             $show "$cmd"
1334             $run eval "$cmd" || exit $?
1335           done
1336           IFS="$save_ifs"
1337         fi
1338
1339         # Install the pseudo-library for information purposes.
1340         name=`echo "$file" | sed 's%^.*/%%'`
1341         $show "$install_prog $file $destdir/$name"
1342         $run $install_prog $file $destdir/$name || exit $?
1343
1344         # Maybe install the static library, too.
1345         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
1346         ;;
1347
1348       *.lo)
1349         # Install (i.e. copy) a libtool object.
1350
1351         # Figure out destination file name, if it wasn't already specified.
1352         if test -n "$destname"; then
1353           destfile="$destdir/$destname"
1354         else
1355           destfile=`echo "$file" | sed 's%^.*/%%;'`
1356           destfile="$destdir/$destfile"
1357         fi
1358
1359         # Deduce the name of the destination old-style object file.
1360         case "$destfile" in
1361         *.lo)
1362           staticdest=`echo "$destfile" | sed 's/\.lo$/\.o/;'`
1363           ;;
1364         *.o)
1365           staticdest="$destfile"
1366           destfile=
1367           ;;
1368         *)
1369           echo "$progname: cannot copy a libtool object to \`$destfile'" 1>&2
1370           echo "$help" 1>&2
1371           exit 1
1372           ;;
1373         esac
1374
1375         # Install the libtool object if requested.
1376         if test -n "$destfile"; then
1377           $show "$install_prog $file $destfile"
1378           $run $install_prog $file $destfile || exit $?
1379         fi
1380
1381         # Install the old object if enabled.
1382         if test "$build_old_libs" = yes; then
1383           # Deduce the name of the old-style object file.
1384           staticobj=`echo "$file" | sed 's/\.lo$/\.o/;'`
1385
1386           $show "$install_prog $staticobj $staticdest"
1387           $run $install_prog $staticobj $staticdest || exit $?
1388         fi
1389         exit 0
1390         ;;
1391
1392       *)
1393         # Do a test to see if this is really a libtool program.
1394         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then
1395           # This variable tells wrapper scripts just to set variables rather
1396           # than running their programs.
1397           libtool_install_magic="$magic"
1398           link_against_libtool_libs=
1399           finalize_command=
1400
1401           # If there is no directory component, then add one.
1402           case "$file" in
1403           */*) . $file ;;
1404           *) . ./$file ;;
1405           esac
1406
1407           # Check the variables that should have been set.
1408           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
1409             echo "$progname: invalid libtool wrapper script \`$file'" 1>&2
1410             exit 1
1411           fi
1412
1413           finalize=yes
1414           for lib in $link_against_libtool_libs; do
1415             # Check to see that each library is installed.
1416             libdir=
1417             if test -f "$lib"; then
1418               # If there is no directory component, then add one.
1419               case "$lib" in
1420               */*) . $lib ;;
1421               *) . ./$lib ;;
1422               esac
1423             fi
1424             libfile="$libdir/`echo "$lib" | sed 's%^.*/%%g'`"
1425             if test -z "$libdir"; then
1426               echo "$progname: warning: \`$lib' contains no -rpath information" 1>&2
1427             elif test -f "$libfile"; then :
1428             else
1429               echo "$progname: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
1430               finalize=no
1431             fi
1432           done
1433
1434           if test "$hardcode_action" = relink; then
1435             if test "$finalize" = yes; then
1436               echo "$progname: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
1437               $show "$finalize_command"
1438               if $run $finalize_command; then :
1439               else
1440                 echo "$progname: error: relink \`$file' with the above command before installing it" 1>&2
1441                 continue
1442               fi
1443               file="$objdir/$file"T
1444             else
1445               echo "$progname: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
1446             fi
1447           else
1448             # Install the binary that we compiled earlier.
1449             dir=`echo "$file" | sed 's%/[^/]*$%%'`
1450             if test "$file" = "$dir"; then
1451               file="$objdir/$file"
1452             else
1453               file="$dir/$objdir/`echo "$file" | sed 's%^.*/%%'`"
1454             fi
1455           fi
1456         fi
1457
1458         $show "$install_prog$stripme $file $dest"
1459         $run $install_prog$stripme $file $dest || exit $?
1460         ;;
1461       esac
1462     done
1463
1464     for file in $staticlibs; do
1465       name=`echo "$file" | sed 's%^.*/%%'`
1466
1467       # Set up the ranlib parameters.
1468       oldlib="$destdir/$name"
1469
1470       $show "$install_prog $file $oldlib"
1471       $run $install_prog $file $oldlib || exit $?
1472
1473       # Support stripping libraries.
1474       if test -n "$stripme"; then
1475         if test -n "$old_striplib"; then
1476           $show "$old_striplib $oldlib"
1477           $run $old_striplib $oldlib || exit $?
1478         else
1479           echo "$progname: warning: no static library stripping program" 1>&2
1480         fi
1481       fi
1482
1483       # Do each command in the postinstall commands.
1484       cmds=`eval echo \"$old_postinstall_cmds\"`
1485       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1486       for cmd in $cmds; do
1487         IFS="$save_ifs"
1488         $show "$cmd"
1489         $run eval "$cmd" || exit $?
1490       done
1491       IFS="$save_ifs"
1492     done
1493
1494     if test -n "$future_libdirs"; then
1495       echo "$progname: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
1496     fi
1497
1498     if test -n "$current_libdirs"; then
1499       # Maybe just do a dry run.
1500       test -n "$run" && current_libdirs=" -n$current_libdirs"
1501       exec $0 --finish$current_libdirs
1502       exit 1
1503     fi
1504
1505     exit 0
1506     ;;
1507
1508   # libtool dlname mode
1509   dlname)
1510     progname="$progname: dlname"
1511     ltlibs="$nonopt"
1512     for lib
1513     do
1514       ltlibs="$ltlibs $lib"
1515     done
1516
1517     if test -z "$ltlibs"; then
1518       echo "$progname: you must specify at least one LTLIBRARY" 1>&2
1519       echo "$help" 1>&2
1520       exit 1
1521     fi
1522
1523     # Now check to make sure each one is a valid libtool library.
1524     status=0
1525     for lib in $ltlibs; do
1526       dlname=
1527       libdir=
1528       library_names=
1529
1530       # Check to see that this really is a libtool archive.
1531       if egrep "^# Generated by $PROGRAM" $arg >/dev/null 2>&1; then :
1532       else
1533         echo "$progname: \`$arg' is not a valid libtool archive" 1>&2
1534         status=1
1535         continue
1536       fi
1537
1538       # If there is no directory component, then add one.
1539       case "$arg" in
1540       */*) . $arg ;;
1541       *) . ./$arg ;;
1542       esac
1543
1544       if test -z "$libdir"; then
1545         echo "$progname: \`$arg' contains no -rpath information" 1>&2
1546         status=1
1547       elif test -n "$dlname"; then
1548         echo "$libdir/$dlname"
1549       elif test -z "$library_names"; then
1550         echo "$progname: \`$arg' is not a shared library" 1>&2
1551         status=1
1552       else
1553         echo "$progname: \`$arg' was not linked with \`-export-dynamic'" 1>&2
1554         status=1
1555       fi
1556     done
1557     exit $status
1558     ;;
1559
1560   # libtool finish mode
1561   finish)
1562     progname="$progname: finish"
1563     libdirs="$nonopt"
1564
1565     if test -n "$finish_cmds" && test -n "$libdirs"; then
1566       for dir
1567       do
1568         libdirs="$libdirs $dir"
1569       done
1570
1571       for libdir in $libdirs; do
1572         # Do each command in the postinstall commands.
1573         cmds=`eval echo \"$finish_cmds\"`
1574         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1575         for cmd in $cmds; do
1576           IFS="$save_ifs"
1577           $show "$cmd"
1578           $run eval "$cmd"
1579         done
1580         IFS="$save_ifs"
1581       done
1582     fi
1583
1584     echo "To link against installed libraries in LIBDIR, users may have to:"
1585     if test -n "$shlibpath_var"; then
1586       echo "   - add LIBDIR to their \`$shlibpath_var' environment variable"
1587     fi
1588     echo "   - use the \`-LLIBDIR' linker flag"
1589     exit 0
1590     ;;
1591
1592   # libtool uninstall mode
1593   uninstall)
1594     progname="$progname: uninstall"
1595     rm="$nonopt"
1596     files=
1597
1598     for arg
1599     do
1600       case "$arg" in
1601       -*) rm="$rm $arg" ;;
1602       *) files="$files $arg" ;;
1603       esac
1604     done
1605
1606     if test -z "$rm"; then
1607       echo "$progname: you must specify an RM program" 1>&2
1608       echo "$help" 1>&2
1609       exit 1
1610     fi
1611
1612     for file in $files; do
1613       dir=`echo "$file" | sed -e 's%/[^/]*$%%'`
1614       test "$dir" = "$file" && dir=.
1615       name=`echo "$file" | sed -e 's%^.*/%%'`
1616
1617       rmfiles="$file"
1618
1619       case "$name" in
1620       *.la)
1621         # Possibly a libtool archive, so verify it.
1622         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then
1623           . $dir/$name
1624
1625           # Delete the libtool libraries and symlinks.
1626           for n in $library_names; do
1627             rmfiles="$rmfiles $dir/$n"
1628             test "X$n" = "X$dlname" && dlname=
1629           done
1630           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
1631           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
1632
1633           # FIXME: should reinstall the best remaining shared library.
1634         fi
1635         ;;
1636
1637       *.lo)
1638         if test "$build_old_libs" = yes; then
1639           oldobj=`echo "$name" | sed 's/\.lo$/\.o/'`
1640           rmfiles="$rmfiles $dir/$oldobj"
1641         fi
1642         ;;
1643       esac
1644
1645       $show "$rm $rmfiles"
1646       $run $rm $rmfiles
1647     done
1648     exit 0
1649     ;;
1650
1651   NONE)
1652     echo "$progname: you must specify a MODE" 1>&2
1653     echo "$generic_help" 1>&2
1654     exit 1
1655     ;;
1656   esac
1657
1658   echo "$progname: invalid operation mode \`$mode'" 1>&2
1659   echo "$generic_help" 1>&2
1660   exit 1
1661 fi # test -z "$show_help"
1662
1663 # We need to display help for each of the modes.
1664 case "$mode" in
1665 NONE) cat <<EOF
1666 Usage: $progname [OPTION]... [MODE-ARG]...
1667
1668 Provide generalized library-building support services.
1669
1670 -n, --dry-run         display commands without modifying any files
1671     --features        display configuration information and exit
1672     --finish          same as \`--mode=finish'
1673     --help            display this help message and exit
1674     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
1675     --version         print version information
1676
1677 MODE must be one of the following:
1678
1679       compile         compile a source file into a libtool object
1680       dlname          print filenames to use to \`dlopen' libtool libraries
1681       finish          complete the installation of libtool libraries
1682       install         install libraries or executables
1683       link            create a library or an executable
1684       uninstall       remove libraries from an installed directory
1685
1686 MODE-ARGS vary depending on the MODE.  Try \`$progname --help --mode=MODE' for
1687 a more detailed description of MODE.
1688 EOF
1689   ;;
1690
1691 compile)
1692   cat <<EOF
1693 Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1694
1695 Compile a source file into a libtool library object.
1696
1697 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1698 from the given SOURCEFILE.
1699
1700 The output file name is determined by removing the directory component from
1701 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1702 library object suffix, \`.lo'.
1703 EOF
1704   ;;
1705
1706 dlname)
1707   cat <<EOF
1708 Usage: $progname [OPTION]... --mode=dlname LTLIBRARY...
1709
1710 Print filenames to use to \`dlopen' libtool libraries.
1711
1712 Each LTLIBRARY is the name of a dynamically loadable libtool library (one that
1713 was linked using the \`-export-dynamic' option).
1714
1715 The names to use are printed to standard output, one per line.
1716 EOF
1717   ;;
1718
1719 finish)
1720   cat <<EOF
1721 Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1722
1723 Complete the installation of libtool libraries.
1724
1725 Each LIBDIR is a directory that contains libtool libraries.
1726
1727 The commands that this mode executes may require superuser privileges.  Use
1728 the \`--dry-run' option if you just want to see what would be executed.
1729 EOF
1730   ;;
1731
1732 install)
1733   cat <<EOF
1734 Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1735
1736 Install executables or libraries.
1737
1738 INSTALL-COMMAND is the installation command.  The first component should be
1739 either the \`install' or \`cp' program.
1740
1741 The rest of the components are interpreted as arguments to that command (only
1742 BSD-compatible install options are recognized).
1743 EOF
1744   ;;
1745
1746 link)
1747   cat <<EOF
1748 Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1749
1750 Link object files or libraries together to form another library, or to
1751 create an executable program.
1752
1753 LINK-COMMAND is a command using the C compiler that you would use to create
1754 a program from several object files.
1755
1756 The following components of LINK-COMMAND are treated specially:
1757
1758   -allow-undefined  allow a libtool library to reference undefined symbols
1759   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1760   -LLIBDIR          search LIBDIR for required installed libraries
1761   -lNAME            OUTPUT-FILE requires the installed library libNAME
1762   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1763   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1764   -static           do not do any dynamic linking or shared library creation
1765   -version-info CURRENT[:REVISION[:AGE]]
1766                     specify library version info [each variable defaults to 0]
1767
1768 All other options (arguments beginning with \`-') are ignored.
1769
1770 Every other argument is treated as a filename.  Files ending in \`.la' are
1771 treated as uninstalled libtool libraries, other files are standard or library
1772 object files.
1773
1774 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
1775 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
1776
1777 If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar'
1778 and \`ranlib'.
1779
1780 If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is
1781 created, otherwise an executable program is created.
1782 EOF
1783   ;;
1784
1785 uninstall)
1786   cat <<EOF
1787 Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1788
1789 Remove libraries from an installation directory.
1790
1791 RM is the name of the program to use to delete files associated with each FILE
1792 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1793 to RM.
1794
1795 If FILE is a libtool library, all the files associated with it are deleted.
1796 Otherwise, only FILE itself is deleted using RM.
1797 EOF
1798   ;;
1799
1800 *)
1801   echo "$progname: invalid operation mode \`$mode'" 1>&2
1802   echo "$help" 1>&2
1803   exit 1
1804   ;;
1805 esac
1806
1807 case "$mode" in
1808 archive|compile)
1809   echo
1810   echo "Try \`$progname --help' for more information about other modes."
1811   ;;
1812 esac
1813
1814 exit 0
1815
1816 # Local Variables:
1817 # mode:shell-script
1818 # sh-indentation:2
1819 # End: