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