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     install_prog_shell=""
1127
1128     # CYGNUS LOCAL: Handle /bin/sh at the start.
1129     if test "$install_prog" = "${CONFIG_SHELL}"; then
1130       install_prog_shell="$install_prog "
1131       install_prog="$1"
1132       shift
1133     fi
1134
1135     # We need to accept at least all the BSD install flags.
1136     dest=
1137     files=
1138     opts=
1139     prev=
1140     install_type=
1141     isdir=
1142     stripme=
1143     for arg
1144     do
1145       if test -n "$dest"; then
1146         files="$files $dest"
1147         dest="$arg"
1148         continue
1149       fi
1150
1151       case "$arg" in
1152       -d) isdir=yes ;;
1153       -f) prev="-f" ;;
1154       -g) prev="-g" ;;
1155       -m) prev="-m" ;;
1156       -o) prev="-o" ;;
1157       -s)
1158         stripme=" -s"
1159         continue
1160         ;;
1161       -*) ;;
1162
1163       *)
1164         # If the previous option needed an argument, then skip it.
1165         if test -n "$prev"; then
1166           prev=
1167         else
1168           dest="$arg"
1169           continue
1170         fi
1171         ;;
1172       esac
1173       install_prog="$install_prog $arg"
1174     done
1175
1176     if test -z "$install_prog"; then
1177       echo "$progname: you must specify an install program" 1>&2
1178       echo "$help" 1>&2
1179       exit 1
1180     fi
1181
1182     if test -n "$prev"; then
1183       echo "$progname: the \`$prev' option requires an argument" 1>&2
1184       echo "$help" 1>&2
1185       exit 1
1186     fi
1187
1188     if test -z "$files"; then
1189       if test -z "$dest"; then
1190         echo "$progname: no file or destination specified" 1>&2
1191       else
1192         echo "$progname: you must specify a destination" 1>&2
1193       fi
1194       echo "$help" 1>&2
1195       exit 1
1196     fi
1197
1198     # Strip any trailing slash from the destination.
1199     dest=`echo "$dest" | sed 's%/$%%'`
1200
1201     # Check to see that the destination is a directory.
1202     test -d "$dest" && isdir=yes
1203     if test -n "$isdir"; then
1204       destdir="$dest"
1205       destname=
1206     else
1207       destdir=`echo "$dest" | sed 's%/[^/]*$%%'`
1208       test "$destdir" = "$dest" && destdir=.
1209       destname=`echo "$dest" | sed 's%^.*/%%'`
1210
1211       # Not a directory, so check to see that there is only one file specified.
1212       set dummy $files
1213       if test $# -gt 2; then
1214         echo "$progname: \`$dest' is not a directory" 1>&2
1215         echo "$help" 1>&2
1216         exit 1
1217       fi
1218     fi
1219     case "$destdir" in
1220     /*) ;;
1221     *)
1222       for file in $files; do
1223         case "$file" in
1224         *.lo) ;;
1225         *)
1226           echo "$progname: \`$destdir' must be an absolute directory name" 1>&2
1227           echo "$help" 1>&2
1228           exit 1
1229           ;;
1230         esac
1231       done
1232       ;;
1233     esac
1234
1235     staticlibs=
1236     future_libdirs=
1237     current_libdirs=
1238     for file in $files; do
1239
1240       # Do each installation.
1241       case "$file" in
1242       *.a)
1243         # Do the static libraries later.
1244         staticlibs="$staticlibs $file"
1245         ;;
1246
1247       *.la)
1248         # Check to see that this really is a libtool archive.
1249         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then :
1250         else
1251           echo "$progname: \`$file' is not a valid libtool archive" 1>&2
1252           echo "$help" 1>&2
1253           exit 1
1254         fi
1255
1256         library_names=
1257         old_library=
1258         # If there is no directory component, then add one.
1259         case "$file" in
1260         */*) . $file ;;
1261         *) . ./$file ;;
1262         esac
1263
1264         # Add the libdir to current_libdirs if it is the destination.
1265         if test "$destdir" = "$libdir"; then
1266           case "$current_libdirs " in
1267           "* $libdir *") ;;
1268           *) current_libdirs="$current_libdirs $libdir" ;;
1269           esac
1270         else
1271           # Note the libdir as a future libdir.
1272           case "$future_libdirs " in
1273           "* $libdir *") ;;
1274           *) future_libdirs="$future_libdirs $libdir" ;;
1275           esac
1276         fi
1277
1278         dir="`echo "$file" | sed 's%/[^/]*$%%'`/"
1279         test "$dir" = "$file/" && dir=
1280         dir="$dir$objdir"
1281
1282         # See the names of the shared library.
1283         set dummy $library_names
1284         if test -n "$2"; then
1285           realname="$2"
1286           shift
1287           shift
1288
1289           # Install the shared library and build the symlinks.
1290           $show "$install_prog_shell$install_prog $dir/$realname $destdir/$realname"
1291           $run eval "$install_prog_shell$install_prog $dir/$realname $destdir/$realname" || exit $?
1292           test "X$dlname" = "X$realname" && dlname=
1293
1294           # Support stripping libraries.
1295           if test -n "$stripme"; then
1296             if test -n "$striplib"; then
1297               $show "$striplib $destdir/$realname"
1298               $run $striplib $destdir/$realname || exit $?
1299             else
1300               echo "$progname: warning: no library stripping program" 1>&2
1301             fi
1302           fi
1303
1304           if test $# -gt 0; then
1305             # Delete the old symlinks.
1306             rmcmd="$rm"
1307             for linkname
1308             do
1309               rmcmd="$rmcmd $destdir/$linkname"
1310             done
1311             $show "$rmcmd"
1312             $run $rmcmd
1313
1314             # ... and create new ones.
1315             for linkname
1316             do
1317               test "X$dlname" = "X$linkname" && dlname=
1318               $show "(cd $destdir && $LN_S $realname $linkname)"
1319               $run eval "(cd $destdir && $LN_S $realname $linkname)"
1320             done
1321           fi
1322
1323           if test -n "$dlname"; then
1324             # Install the dynamically-loadable library.
1325             $show "$install_prog_shell$install_prog $dir/$dlname $destdir/$dlname"
1326             $run eval "$install_prog_shell$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1327           fi
1328
1329           # Do each command in the postinstall commands.
1330           lib="$destdir/$realname"
1331           cmds=`eval echo \"$postinstall_cmds\"`
1332           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1333           for cmd in $cmds; do
1334             IFS="$save_ifs"
1335             $show "$cmd"
1336             $run eval "$cmd" || exit $?
1337           done
1338           IFS="$save_ifs"
1339         fi
1340
1341         # Install the pseudo-library for information purposes.
1342         name=`echo "$file" | sed 's%^.*/%%'`
1343         $show "$install_prog_shell$install_prog $file $destdir/$name"
1344         $run $install_prog_shell$install_prog $file $destdir/$name || exit $?
1345
1346         # Maybe install the static library, too.
1347         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
1348         ;;
1349
1350       *.lo)
1351         # Install (i.e. copy) a libtool object.
1352
1353         # Figure out destination file name, if it wasn't already specified.
1354         if test -n "$destname"; then
1355           destfile="$destdir/$destname"
1356         else
1357           destfile=`echo "$file" | sed 's%^.*/%%;'`
1358           destfile="$destdir/$destfile"
1359         fi
1360
1361         # Deduce the name of the destination old-style object file.
1362         case "$destfile" in
1363         *.lo)
1364           staticdest=`echo "$destfile" | sed 's/\.lo$/\.o/;'`
1365           ;;
1366         *.o)
1367           staticdest="$destfile"
1368           destfile=
1369           ;;
1370         *)
1371           echo "$progname: cannot copy a libtool object to \`$destfile'" 1>&2
1372           echo "$help" 1>&2
1373           exit 1
1374           ;;
1375         esac
1376
1377         # Install the libtool object if requested.
1378         if test -n "$destfile"; then
1379           $show "$install_prog_shell$install_prog $file $destfile"
1380           $run $install_prog_shell$install_prog $file $destfile || exit $?
1381         fi
1382
1383         # Install the old object if enabled.
1384         if test "$build_old_libs" = yes; then
1385           # Deduce the name of the old-style object file.
1386           staticobj=`echo "$file" | sed 's/\.lo$/\.o/;'`
1387
1388           $show "$install_prog_shell$install_prog $staticobj $staticdest"
1389           $run $install_prog_shell$install_prog $staticobj $staticdest || exit $?
1390         fi
1391         exit 0
1392         ;;
1393
1394       *)
1395         # Do a test to see if this is really a libtool program.
1396         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then
1397           # This variable tells wrapper scripts just to set variables rather
1398           # than running their programs.
1399           libtool_install_magic="$magic"
1400           link_against_libtool_libs=
1401           finalize_command=
1402
1403           # If there is no directory component, then add one.
1404           case "$file" in
1405           */*) . $file ;;
1406           *) . ./$file ;;
1407           esac
1408
1409           # Check the variables that should have been set.
1410           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
1411             echo "$progname: invalid libtool wrapper script \`$file'" 1>&2
1412             exit 1
1413           fi
1414
1415           finalize=yes
1416           for lib in $link_against_libtool_libs; do
1417             # Check to see that each library is installed.
1418             libdir=
1419             if test -f "$lib"; then
1420               # If there is no directory component, then add one.
1421               case "$lib" in
1422               */*) . $lib ;;
1423               *) . ./$lib ;;
1424               esac
1425             fi
1426             libfile="$libdir/`echo "$lib" | sed 's%^.*/%%g'`"
1427             if test -z "$libdir"; then
1428               echo "$progname: warning: \`$lib' contains no -rpath information" 1>&2
1429             elif test -f "$libfile"; then :
1430             else
1431               echo "$progname: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
1432               finalize=no
1433             fi
1434           done
1435
1436           if test "$hardcode_action" = relink; then
1437             if test "$finalize" = yes; then
1438               echo "$progname: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
1439               $show "$finalize_command"
1440               if $run $finalize_command; then :
1441               else
1442                 echo "$progname: error: relink \`$file' with the above command before installing it" 1>&2
1443                 continue
1444               fi
1445               file="$objdir/$file"T
1446             else
1447               echo "$progname: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
1448             fi
1449           else
1450             # Install the binary that we compiled earlier.
1451             dir=`echo "$file" | sed 's%/[^/]*$%%'`
1452             if test "$file" = "$dir"; then
1453               file="$objdir/$file"
1454             else
1455               file="$dir/$objdir/`echo "$file" | sed 's%^.*/%%'`"
1456             fi
1457           fi
1458         fi
1459
1460         $show "$install_prog_shell$install_prog$stripme $file $dest"
1461         $run $install_prog_shell$install_prog$stripme $file $dest || exit $?
1462         ;;
1463       esac
1464     done
1465
1466     for file in $staticlibs; do
1467       name=`echo "$file" | sed 's%^.*/%%'`
1468
1469       # Set up the ranlib parameters.
1470       oldlib="$destdir/$name"
1471
1472       $show "$install_prog_shell$install_prog $file $oldlib"
1473       $run $install_prog_shell$install_prog $file $oldlib || exit $?
1474
1475       # Support stripping libraries.
1476       if test -n "$stripme"; then
1477         if test -n "$old_striplib"; then
1478           $show "$old_striplib $oldlib"
1479           $run $old_striplib $oldlib || exit $?
1480         else
1481           echo "$progname: warning: no static library stripping program" 1>&2
1482         fi
1483       fi
1484
1485       # Do each command in the postinstall commands.
1486       cmds=`eval echo \"$old_postinstall_cmds\"`
1487       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1488       for cmd in $cmds; do
1489         IFS="$save_ifs"
1490         $show "$cmd"
1491         $run eval "$cmd" || exit $?
1492       done
1493       IFS="$save_ifs"
1494     done
1495
1496     if test -n "$future_libdirs"; then
1497       echo "$progname: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
1498     fi
1499
1500     if test -n "$current_libdirs"; then
1501       # Maybe just do a dry run.
1502       test -n "$run" && current_libdirs=" -n$current_libdirs"
1503       ${CONFIG_SHELL} $0 --finish$current_libdirs
1504       exit $?
1505     fi
1506
1507     exit 0
1508     ;;
1509
1510   # libtool dlname mode
1511   dlname)
1512     progname="$progname: dlname"
1513     ltlibs="$nonopt"
1514     for lib
1515     do
1516       ltlibs="$ltlibs $lib"
1517     done
1518
1519     if test -z "$ltlibs"; then
1520       echo "$progname: you must specify at least one LTLIBRARY" 1>&2
1521       echo "$help" 1>&2
1522       exit 1
1523     fi
1524
1525     # Now check to make sure each one is a valid libtool library.
1526     status=0
1527     for lib in $ltlibs; do
1528       dlname=
1529       libdir=
1530       library_names=
1531
1532       # Check to see that this really is a libtool archive.
1533       if egrep "^# Generated by $PROGRAM" $arg >/dev/null 2>&1; then :
1534       else
1535         echo "$progname: \`$arg' is not a valid libtool archive" 1>&2
1536         status=1
1537         continue
1538       fi
1539
1540       # If there is no directory component, then add one.
1541       case "$arg" in
1542       */*) . $arg ;;
1543       *) . ./$arg ;;
1544       esac
1545
1546       if test -z "$libdir"; then
1547         echo "$progname: \`$arg' contains no -rpath information" 1>&2
1548         status=1
1549       elif test -n "$dlname"; then
1550         echo "$libdir/$dlname"
1551       elif test -z "$library_names"; then
1552         echo "$progname: \`$arg' is not a shared library" 1>&2
1553         status=1
1554       else
1555         echo "$progname: \`$arg' was not linked with \`-export-dynamic'" 1>&2
1556         status=1
1557       fi
1558     done
1559     exit $status
1560     ;;
1561
1562   # libtool finish mode
1563   finish)
1564     progname="$progname: finish"
1565     libdirs="$nonopt"
1566
1567     if test -n "$finish_cmds" && test -n "$libdirs"; then
1568       for dir
1569       do
1570         libdirs="$libdirs $dir"
1571       done
1572
1573       for libdir in $libdirs; do
1574         # Do each command in the postinstall commands.
1575         cmds=`eval echo \"$finish_cmds\"`
1576         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1577         for cmd in $cmds; do
1578           IFS="$save_ifs"
1579           $show "$cmd"
1580           $run eval "$cmd"
1581         done
1582         IFS="$save_ifs"
1583       done
1584     fi
1585
1586     echo "To link against installed libraries in LIBDIR, users may have to:"
1587     if test -n "$shlibpath_var"; then
1588       echo "   - add LIBDIR to their \`$shlibpath_var' environment variable"
1589     fi
1590     echo "   - use the \`-LLIBDIR' linker flag"
1591     exit 0
1592     ;;
1593
1594   # libtool uninstall mode
1595   uninstall)
1596     progname="$progname: uninstall"
1597     rm="$nonopt"
1598     files=
1599
1600     for arg
1601     do
1602       case "$arg" in
1603       -*) rm="$rm $arg" ;;
1604       *) files="$files $arg" ;;
1605       esac
1606     done
1607
1608     if test -z "$rm"; then
1609       echo "$progname: you must specify an RM program" 1>&2
1610       echo "$help" 1>&2
1611       exit 1
1612     fi
1613
1614     for file in $files; do
1615       dir=`echo "$file" | sed -e 's%/[^/]*$%%'`
1616       test "$dir" = "$file" && dir=.
1617       name=`echo "$file" | sed -e 's%^.*/%%'`
1618
1619       rmfiles="$file"
1620
1621       case "$name" in
1622       *.la)
1623         # Possibly a libtool archive, so verify it.
1624         if egrep "^# Generated by $PROGRAM" $file >/dev/null 2>&1; then
1625           . $dir/$name
1626
1627           # Delete the libtool libraries and symlinks.
1628           for n in $library_names; do
1629             rmfiles="$rmfiles $dir/$n"
1630             test "X$n" = "X$dlname" && dlname=
1631           done
1632           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
1633           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
1634
1635           # FIXME: should reinstall the best remaining shared library.
1636         fi
1637         ;;
1638
1639       *.lo)
1640         if test "$build_old_libs" = yes; then
1641           oldobj=`echo "$name" | sed 's/\.lo$/\.o/'`
1642           rmfiles="$rmfiles $dir/$oldobj"
1643         fi
1644         ;;
1645       esac
1646
1647       $show "$rm $rmfiles"
1648       $run $rm $rmfiles
1649     done
1650     exit 0
1651     ;;
1652
1653   NONE)
1654     echo "$progname: you must specify a MODE" 1>&2
1655     echo "$generic_help" 1>&2
1656     exit 1
1657     ;;
1658   esac
1659
1660   echo "$progname: invalid operation mode \`$mode'" 1>&2
1661   echo "$generic_help" 1>&2
1662   exit 1
1663 fi # test -z "$show_help"
1664
1665 # We need to display help for each of the modes.
1666 case "$mode" in
1667 NONE) cat <<EOF
1668 Usage: $progname [OPTION]... [MODE-ARG]...
1669
1670 Provide generalized library-building support services.
1671
1672 -n, --dry-run         display commands without modifying any files
1673     --features        display configuration information and exit
1674     --finish          same as \`--mode=finish'
1675     --help            display this help message and exit
1676     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
1677     --version         print version information
1678
1679 MODE must be one of the following:
1680
1681       compile         compile a source file into a libtool object
1682       dlname          print filenames to use to \`dlopen' libtool libraries
1683       finish          complete the installation of libtool libraries
1684       install         install libraries or executables
1685       link            create a library or an executable
1686       uninstall       remove libraries from an installed directory
1687
1688 MODE-ARGS vary depending on the MODE.  Try \`$progname --help --mode=MODE' for
1689 a more detailed description of MODE.
1690 EOF
1691   ;;
1692
1693 compile)
1694   cat <<EOF
1695 Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1696
1697 Compile a source file into a libtool library object.
1698
1699 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1700 from the given SOURCEFILE.
1701
1702 The output file name is determined by removing the directory component from
1703 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1704 library object suffix, \`.lo'.
1705 EOF
1706   ;;
1707
1708 dlname)
1709   cat <<EOF
1710 Usage: $progname [OPTION]... --mode=dlname LTLIBRARY...
1711
1712 Print filenames to use to \`dlopen' libtool libraries.
1713
1714 Each LTLIBRARY is the name of a dynamically loadable libtool library (one that
1715 was linked using the \`-export-dynamic' option).
1716
1717 The names to use are printed to standard output, one per line.
1718 EOF
1719   ;;
1720
1721 finish)
1722   cat <<EOF
1723 Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1724
1725 Complete the installation of libtool libraries.
1726
1727 Each LIBDIR is a directory that contains libtool libraries.
1728
1729 The commands that this mode executes may require superuser privileges.  Use
1730 the \`--dry-run' option if you just want to see what would be executed.
1731 EOF
1732   ;;
1733
1734 install)
1735   cat <<EOF
1736 Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1737
1738 Install executables or libraries.
1739
1740 INSTALL-COMMAND is the installation command.  The first component should be
1741 either the \`install' or \`cp' program.
1742
1743 The rest of the components are interpreted as arguments to that command (only
1744 BSD-compatible install options are recognized).
1745 EOF
1746   ;;
1747
1748 link)
1749   cat <<EOF
1750 Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1751
1752 Link object files or libraries together to form another library, or to
1753 create an executable program.
1754
1755 LINK-COMMAND is a command using the C compiler that you would use to create
1756 a program from several object files.
1757
1758 The following components of LINK-COMMAND are treated specially:
1759
1760   -allow-undefined  allow a libtool library to reference undefined symbols
1761   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1762   -LLIBDIR          search LIBDIR for required installed libraries
1763   -lNAME            OUTPUT-FILE requires the installed library libNAME
1764   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1765   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1766   -static           do not do any dynamic linking or shared library creation
1767   -version-info CURRENT[:REVISION[:AGE]]
1768                     specify library version info [each variable defaults to 0]
1769
1770 All other options (arguments beginning with \`-') are ignored.
1771
1772 Every other argument is treated as a filename.  Files ending in \`.la' are
1773 treated as uninstalled libtool libraries, other files are standard or library
1774 object files.
1775
1776 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
1777 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
1778
1779 If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar'
1780 and \`ranlib'.
1781
1782 If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is
1783 created, otherwise an executable program is created.
1784 EOF
1785   ;;
1786
1787 uninstall)
1788   cat <<EOF
1789 Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1790
1791 Remove libraries from an installation directory.
1792
1793 RM is the name of the program to use to delete files associated with each FILE
1794 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1795 to RM.
1796
1797 If FILE is a libtool library, all the files associated with it are deleted.
1798 Otherwise, only FILE itself is deleted using RM.
1799 EOF
1800   ;;
1801
1802 *)
1803   echo "$progname: invalid operation mode \`$mode'" 1>&2
1804   echo "$help" 1>&2
1805   exit 1
1806   ;;
1807 esac
1808
1809 case "$mode" in
1810 archive|compile)
1811   echo
1812   echo "Try \`$progname --help' for more information about other modes."
1813   ;;
1814 esac
1815
1816 exit 0
1817
1818 # Local Variables:
1819 # mode:shell-script
1820 # sh-indentation:2
1821 # End: