home *** CD-ROM | disk | FTP | other *** search
/ ftp.sunet.sepub/pictures / 2014.11.ftp.sunet.se-pictures.tar / ftp.sunet.se / pub / pictures / ACiD-artpacks / programs / unix / editors / gimp-plugins-unstable-0_99_23_tar.gz / gimp-plugins-unstable-0_99_23_tar / gimp-plugins-unstable-0.99.23 / ltmain.sh < prev    next >
Text File  |  1998-03-19  |  71KB  |  2,458 lines
  1. # ltmain.sh - Provide generalized library-building support services.
  2. # NOTE: Changing this file will not affect anything until you rerun ltconfig.
  3. #
  4. # Copyright (C) 1996-1998 Free Software Foundation, Inc.
  5. # Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
  6. #
  7. # This program is free software; you can redistribute it and/or modify
  8. # it under the terms of the GNU General Public License as published by
  9. # the Free Software Foundation; either version 2 of the License, or
  10. # (at your option) any later version.
  11. #
  12. # This program is distributed in the hope that it will be useful, but
  13. # WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. # General Public License for more details.
  16. #
  17. # You should have received a copy of the GNU General Public License
  18. # along with this program; if not, write to the Free Software
  19. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20. #
  21. # As a special exception to the GNU General Public License, if you
  22. # distribute this file as part of a program that contains a
  23. # configuration script generated by Autoconf, you may include it under
  24. # the same distribution terms that you use for the rest of that program.
  25.  
  26. # The name of this program.
  27. progname=`$echo "$0" | sed 's%^.*/%%'`
  28. modename="$progname"
  29.  
  30. # Constants.
  31. PROGRAM=ltmain.sh
  32. PACKAGE=libtool
  33. VERSION=1.1
  34.  
  35. default_mode=
  36. help="Try \`$progname --help' for more information."
  37. magic="%%%MAGIC variable%%%"
  38. mkdir="mkdir"
  39. mv="mv -f"
  40. rm="rm -f"
  41.  
  42. # Sed substitution that helps us do robust quoting.  It backslashifies
  43. # metacharacters that are still active within double-quoted strings.
  44. Xsed='sed -e s/^X//'
  45. sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  46.  
  47. # NLS nuisances.
  48. # Only set LANG and LC_ALL to C if already set.
  49. # These must not be set unconditionally because not all systems understand
  50. # e.g. LANG=C (notably SCO).
  51. if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
  52. if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
  53.  
  54. if test "$LTCONFIG_VERSION" != "$VERSION"; then
  55.   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  56.   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  57.   exit 1
  58. fi
  59.  
  60. if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  61.   echo "$modename: not configured to build any kind of library" 1>&2
  62.   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  63.   exit 1
  64. fi
  65.  
  66. # Global variables.
  67. mode=$default_mode
  68. nonopt=
  69. prev=
  70. prevopt=
  71. run=
  72. show="$echo"
  73. show_help=
  74. execute_dlfiles=
  75.  
  76. # Parse our command line options once, thoroughly.
  77. while test $# -gt 0
  78. do
  79.   arg="$1"
  80.   shift
  81.  
  82.   case "$arg" in
  83.   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  84.   *) optarg= ;;
  85.   esac
  86.  
  87.   # If the previous option needs an argument, assign it.
  88.   if test -n "$prev"; then
  89.     case "$prev" in
  90.     execute_dlfiles)
  91.       eval "$prev=\"\$$prev \$arg\""
  92.       ;;
  93.     *)
  94.       eval "$prev=\$arg"
  95.       ;;
  96.     esac
  97.  
  98.     prev=
  99.     prevopt=
  100.     continue
  101.   fi
  102.  
  103.   # Have we seen a non-optional argument yet?
  104.   case "$arg" in
  105.   --help)
  106.     show_help=yes
  107.     ;;
  108.  
  109.   --version)
  110.     echo "$PROGRAM (GNU $PACKAGE) $VERSION"
  111.     exit 0
  112.     ;;
  113.  
  114.   --dry-run | -n)
  115.     run=:
  116.     ;;
  117.  
  118.   --features)
  119.     echo "host: $host"
  120.     if test "$build_libtool_libs" = yes; then
  121.       echo "enable shared libraries"
  122.     else
  123.       echo "disable shared libraries"
  124.     fi
  125.     if test "$build_old_libs" = yes; then
  126.       echo "enable static libraries"
  127.     else
  128.       echo "disable static libraries"
  129.     fi
  130.     exit 0
  131.     ;;
  132.  
  133.   --finish) mode="finish" ;;
  134.  
  135.   --mode) prevopt="--mode" prev=mode ;;
  136.   --mode=*) mode="$optarg" ;;
  137.  
  138.   --quiet | --silent)
  139.     show=:
  140.     ;;
  141.  
  142.   -dlopen)
  143.     prevopt="-dlopen"
  144.     prev=execute_dlfiles
  145.     ;;
  146.  
  147.   -*)
  148.     $echo "$modename: unrecognized option \`$arg'" 1>&2
  149.     $echo "$help" 1>&2
  150.     exit 1
  151.     ;;
  152.  
  153.   *)
  154.     nonopt="$arg"
  155.     break
  156.     ;;
  157.   esac
  158. done
  159.  
  160. if test -n "$prevopt"; then
  161.   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
  162.   $echo "$help" 1>&2
  163.   exit 1
  164. fi
  165.  
  166. if test -z "$show_help"; then
  167.  
  168.   # Infer the operation mode.
  169.   if test -z "$mode"; then
  170.     case "$nonopt" in
  171.     *cc | *++ | gcc* | *-gcc*)
  172.       mode=link
  173.       for arg
  174.       do
  175.         case "$arg" in
  176.         -c)
  177.            mode=compile
  178.            break
  179.            ;;
  180.         esac
  181.       done
  182.       ;;
  183.     *db | *dbx)
  184.       mode=execute
  185.       ;;
  186.     *install*|cp|mv)
  187.       mode=install
  188.       ;;
  189.     *rm)
  190.       mode=uninstall
  191.       ;;
  192.     *)
  193.       # If we have no mode, but dlfiles were specified, then do execute mode.
  194.       test -n "$execute_dlfiles" && mode=execute
  195.  
  196.       # Just use the default operation mode.
  197.       if test -z "$mode"; then
  198.         if test -n "$nonopt"; then
  199.           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
  200.         else
  201.           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
  202.         fi
  203.       fi
  204.       ;;
  205.     esac
  206.   fi
  207.  
  208.   # Only execute mode is allowed to have -dlopen flags.
  209.   if test -n "$execute_dlfiles" && test "$mode" != execute; then
  210.     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
  211.     $echo "$help" 1>&2
  212.     exit 1
  213.   fi
  214.  
  215.   # Change the help message to a mode-specific one.
  216.   generic_help="$help"
  217.   help="Try \`$modename --help --mode=$mode' for more information."
  218.  
  219.   # These modes are in order of execution frequency so that they run quickly.
  220.   case "$mode" in
  221.   # libtool compile mode
  222.   compile)
  223.     modename="$modename: compile"
  224.     # Get the compilation command and the source file.
  225.     base_compile=
  226.     lastarg=
  227.     srcfile="$nonopt"
  228.     suppress_output=
  229.  
  230.     for arg
  231.     do
  232.       # Accept any command-line options.
  233.       case "$arg" in
  234.       -o)
  235.     $echo "$modename: you cannot specify the output filename with \`-o'" 1>&2
  236.     $echo "$help" 1>&2
  237.     exit 1
  238.     ;;
  239.  
  240.       -static)
  241.     build_libtool_libs=no
  242.     build_old_libs=yes
  243.     continue
  244.     ;;
  245.       esac
  246.  
  247.       # Accept the current argument as the source file.
  248.       lastarg="$srcfile"
  249.       srcfile="$arg"
  250.  
  251.       # Aesthetically quote the previous argument.
  252.  
  253.       # Backslashify any backslashes, double quotes, and dollar signs.
  254.       # These are the only characters that are still specially
  255.       # interpreted inside of double-quoted scrings.
  256.       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
  257.  
  258.       # Double-quote args containing other shell metacharacters.
  259.       # Many Bourne shells cannot handle close brackets correctly in scan
  260.       # sets, so we specify it separately.
  261.       case "$lastarg" in
  262.       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  263.     lastarg="\"$lastarg\""
  264.     ;;
  265.       esac
  266.  
  267.       # Add the previous argument to base_compile.
  268.       if test -z "$base_compile"; then
  269.     base_compile="$lastarg"
  270.       else
  271.     base_compile="$base_compile $lastarg"
  272.       fi
  273.     done
  274.  
  275.     # Get the name of the library object.
  276.     libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
  277.  
  278.     # Recognize several different file suffixes.
  279.     xform='[cCFSfms]'
  280.     case "$libobj" in
  281.     *.ada) xform=ada ;;
  282.     *.adb) xform=adb ;;
  283.     *.ads) xform=ads ;;
  284.     *.asm) xform=asm ;;
  285.     *.c++) xform=c++ ;;
  286.     *.cc) xform=cc ;;
  287.     *.cpp) xform=cpp ;;
  288.     *.cxx) xform=cxx ;;
  289.     *.f90) xform=f90 ;;
  290.     *.for) xform=for ;;
  291.     esac
  292.  
  293.     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
  294.  
  295.     case "$libobj" in
  296.     *.lo) obj=`$echo "X$libobj" | $Xsed -e 's/\.lo$/.o/'` ;;
  297.     *)
  298.       $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2
  299.       exit 1
  300.       ;;
  301.     esac
  302.  
  303.     if test -z "$base_compile"; then
  304.       $echo "$modename: you must specify a compilation command" 1>&2
  305.       $echo "$help" 1>&2
  306.       exit 1
  307.     fi
  308.  
  309.     # Delete any leftover library objects.
  310.     if test "$build_old_libs" = yes; then
  311.       $run $rm $obj $libobj
  312.       trap "$run $rm $obj $libobj; exit 1" 1 2 15
  313.     else
  314.       $run $rm $libobj
  315.       trap "$run $rm $libobj; exit 1" 1 2 15
  316.     fi
  317.  
  318.     # Only build a PIC object if we are building libtool libraries.
  319.     if test "$build_libtool_libs" = yes; then
  320.       # Without this assignment, base_compile gets emptied.
  321.       fbsd_hideous_sh_bug=$base_compile
  322.  
  323.       # All platforms use -DPIC, to notify preprocessed assembler code.
  324.       $show "$base_compile$pic_flag -DPIC $srcfile"
  325.       if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then :
  326.       else
  327.         test -n "$obj" && $run $rm $obj
  328.         exit 1
  329.       fi
  330.  
  331.       # If we have no pic_flag, then copy the object into place and finish.
  332.       if test -z "$pic_flag"; then
  333.         $show "$LN_S $obj $libobj"
  334.         $run $LN_S $obj $libobj
  335.         exit $?
  336.       fi
  337.  
  338.       # Just move the object, then go on to compile the next one
  339.       $show "$mv $obj $libobj"
  340.       $run $mv $obj $libobj || exit 1
  341.  
  342.       # Allow error messages only from the first compilation.
  343.       suppress_output=' >/dev/null 2>&1'
  344.     fi
  345.  
  346.     # Only build a position-dependent object if we build old libraries.
  347.     if test "$build_old_libs" = yes; then
  348.       # Suppress compiler output if we already did a PIC compilation.
  349.       $show "$base_compile $srcfile$suppress_output"
  350.       if $run eval "$base_compile \$srcfile$suppress_output"; then :
  351.       else
  352.         $run $rm $obj $libobj
  353.         exit 1
  354.       fi
  355.     fi
  356.  
  357.     # Create an invalid libtool object if no PIC, so that we do not
  358.     # accidentally link it into a program.
  359.     if test "$build_libtool_libs" != yes; then
  360.       $show "echo timestamp > $libobj"
  361.       $run eval "echo timestamp > \$libobj" || exit $?
  362.     fi
  363.  
  364.     exit 0
  365.     ;;
  366.  
  367.   # libtool link mode
  368.   link)
  369.     modename="$modename: link"
  370.     CC="$nonopt"
  371.     allow_undefined=yes
  372.     compile_command="$CC"
  373.     finalize_command="$CC"
  374.  
  375.     compile_shlibpath=
  376.     finalize_shlibpath=
  377.     deplibs=
  378.     dlfiles=
  379.     dlprefiles=
  380.     export_dynamic=no
  381.     hardcode_libdirs=
  382.     libobjs=
  383.     link_against_libtool_libs=
  384.     ltlibs=
  385.     objs=
  386.     prev=
  387.     prevarg=
  388.     release=
  389.     rpath=
  390.     perm_rpath=
  391.     temp_rpath=
  392.     vinfo=
  393.  
  394.     # We need to know -static, to get the right output filenames.
  395.     for arg
  396.     do
  397.       case "$arg" in
  398.       -all-static | -static)
  399.         if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
  400.         $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
  401.         fi
  402.         build_libtool_libs=no
  403.     build_old_libs=yes
  404.         break
  405.         ;;
  406.       esac
  407.     done
  408.  
  409.     # See if our shared archives depend on static archives.
  410.     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
  411.  
  412.     # Go through the arguments, transforming them on the way.
  413.     for arg
  414.     do
  415.       # If the previous option needs an argument, assign it.
  416.       if test -n "$prev"; then
  417.         case "$prev" in
  418.         output)
  419.           compile_command="$compile_command @OUTPUT@"
  420.           finalize_command="$finalize_command @OUTPUT@"
  421.           ;;
  422.         esac
  423.  
  424.         case "$prev" in
  425.         dlfiles|dlprefiles)
  426.           case "$arg" in
  427.           *.la | *.lo) ;;  # We handle these cases below.
  428.           *)
  429.             dlprefiles="$dlprefiles $arg"
  430.             test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
  431.             prev=
  432.             ;;
  433.           esac
  434.           ;;
  435.     release)
  436.       release="-$arg"
  437.       prev=
  438.       continue
  439.       ;;
  440.         rpath)
  441.           rpath="$rpath $arg"
  442.       prev=
  443.       continue
  444.       ;;
  445.         *)
  446.           eval "$prev=\"\$arg\""
  447.           prev=
  448.           continue
  449.           ;;
  450.         esac
  451.       fi
  452.  
  453.       prevarg="$arg"
  454.  
  455.       case "$arg" in
  456.       -all-static)
  457.     if test -n "$link_static_flag"; then
  458.           compile_command="$compile_command $link_static_flag"
  459.       finalize_command="$finalize_command $link_static_flag"
  460.         fi
  461.         continue
  462.     ;;
  463.  
  464.       -allow-undefined)
  465.     # FIXME: remove this flag sometime in the future.
  466.     $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
  467.     continue
  468.     ;;
  469.  
  470.       -dlopen)
  471.         prev=dlfiles
  472.         continue
  473.         ;;
  474.  
  475.       -dlpreopen)
  476.         prev=dlprefiles
  477.         continue
  478.         ;;
  479.  
  480.       -export-dynamic)
  481.         if test "$export_dynamic" != yes; then
  482.           export_dynamic=yes
  483.       if test -n "$export_dynamic_flag_spec"; then
  484.         arg=`eval \\$echo "$export_dynamic_flag_spec"`
  485.       else
  486.         arg=
  487.       fi
  488.  
  489.           # Add the symbol object into the linking commands.
  490.       compile_command="$compile_command @SYMFILE@"
  491.       finalize_command="$finalize_command @SYMFILE@"
  492.         fi
  493.         ;;
  494.  
  495.       -L*)
  496.         dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
  497.         case "$dir" in
  498.         /* | [A-Za-z]:\\*)
  499.       # Add the corresponding hardcode_libdir_flag, if it is not identical.
  500.           ;;
  501.         *)
  502.           $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
  503.           exit 1
  504.           ;;
  505.         esac
  506.         deplibs="$deplibs $arg"
  507.         ;;
  508.  
  509.       -l*) deplibs="$deplibs $arg" ;;
  510.  
  511.       -no-undefined)
  512.     allow_undefined=no
  513.     continue
  514.     ;;
  515.  
  516.       -o) prev=output ;;
  517.  
  518.       -release)
  519.     prev=release
  520.     continue
  521.     ;;
  522.  
  523.       -rpath)
  524.         prev=rpath
  525.         continue
  526.         ;;
  527.  
  528.       -static)
  529.     # If we have no pic_flag, then this is the same as -all-static.
  530.     if test -z "$pic_flag" && test -n "$link_static_flag"; then
  531.           compile_command="$compile_command $link_static_flag"
  532.       finalize_command="$finalize_command $link_static_flag"
  533.         fi
  534.     continue
  535.     ;;
  536.  
  537.       -version-info)
  538.         prev=vinfo
  539.         continue
  540.         ;;
  541.  
  542.       # Some other compiler flag.
  543.       -* | +*)
  544.     # Unknown arguments in both finalize_command and compile_command need
  545.     # to be aesthetically quoted because they are evaled later.
  546.     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  547.     case "$arg" in
  548.     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  549.       arg="\"$arg\""
  550.       ;;
  551.     esac
  552.         ;;
  553.  
  554.       *.o | *.a)
  555.         # A standard object.
  556.         objs="$objs $arg"
  557.         ;;
  558.  
  559.       *.lo)
  560.         # A library object.
  561.     if test "$prev" = dlfiles; then
  562.       dlfiles="$dlfiles $arg"
  563.       if test "$build_libtool_libs" = yes; then
  564.         prev=
  565.         continue
  566.       else
  567.         # If libtool objects are unsupported, then we need to preload.
  568.         prev=dlprefiles
  569.       fi
  570.     fi
  571.  
  572.     if test "$prev" = dlprefiles; then
  573.       # Preload the old-style object.
  574.       dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e 's/\.lo$/\.o/'`
  575.       prev=
  576.     fi
  577.     libobjs="$libobjs $arg"
  578.         ;;
  579.  
  580.       *.la)
  581.         # A libtool-controlled library.
  582.  
  583.         dlname=
  584.         libdir=
  585.         library_names=
  586.         old_library=
  587.  
  588.         # Check to see that this really is a libtool archive.
  589.         if (sed -e '2q' $arg | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
  590.         else
  591.           $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
  592.           exit 1
  593.         fi
  594.  
  595.         # If there is no directory component, then add one.
  596.         case "$arg" in
  597.         */* | *\\*) . $arg ;;
  598.         *) . ./$arg ;;
  599.         esac
  600.  
  601.         if test -z "$libdir"; then
  602.           $echo "$modename: \`$arg' contains no -rpath information" 1>&2
  603.           exit 1
  604.         fi
  605.  
  606.         # Get the name of the library we link against.
  607.         linklib=
  608.         for l in $old_library $library_names; do
  609.           linklib="$l"
  610.         done
  611.  
  612.         if test -z "$linklib"; then
  613.           $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
  614.           exit 1
  615.         fi
  616.  
  617.         # Find the relevant object directory and library name.
  618.         name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
  619.         dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
  620.         if test "X$dir" = "X$arg"; then
  621.           dir="$objdir"
  622.         else
  623.           dir="$dir/$objdir"
  624.         fi
  625.  
  626.         # This library was specified with -dlopen.
  627.         if test "$prev" = dlfiles; then
  628.           dlfiles="$dlfiles $arg"
  629.           if test -z "$dlname"; then
  630.             # If there is no dlname, we need to preload.
  631.             prev=dlprefiles
  632.           else
  633.             # We should not create a dependency on this library, but we
  634.         # may need any libraries it requires.
  635.         compile_command="$compile_command$dependency_libs"
  636.         finalize_command="$finalize_command$dependency_libs"
  637.             prev=
  638.             continue
  639.           fi
  640.         fi
  641.  
  642.         # The library was specified with -dlpreopen.
  643.         if test "$prev" = dlprefiles; then
  644.           # Prefer using a static library (so that no silly _DYNAMIC symbols
  645.           # are required to link).
  646.           if test -n "$old_library"; then
  647.             dlprefiles="$dlprefiles $dir/$old_library"
  648.           else
  649.             dlprefiles="$dlprefiles $dir/$linklib"
  650.           fi
  651.           prev=
  652.         fi
  653.  
  654.         if test "$build_libtool_libs" = yes && test -n "$library_names"; then
  655.           link_against_libtool_libs="$link_against_libtool_libs $arg"
  656.           if test -n "$shlibpath_var"; then
  657.             # Make sure the rpath contains only unique directories.
  658.             case "$temp_rpath " in
  659.             *" $dir "*) ;;
  660.             *) temp_rpath="$temp_rpath $dir" ;;
  661.             esac
  662.           fi
  663.  
  664.       # This is the magic to use -rpath.
  665.           if test -n "$hardcode_libdir_flag_spec"; then
  666.             if test -n "$hardcode_libdir_separator"; then
  667.               if test -z "$hardcode_libdirs"; then
  668.                 # Put the magic libdir with the hardcode flag.
  669.                 hardcode_libdirs="$libdir"
  670.                 libdir="@HARDCODE_LIBDIRS@"
  671.               else
  672.                 # Just accumulate the unique libdirs.
  673.         case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
  674.         *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  675.           ;;
  676.         *)
  677.           hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  678.           ;;
  679.         esac
  680.                 libdir=
  681.               fi
  682.             fi
  683.  
  684.             if test -n "$libdir"; then
  685.               flag=`eval \\$echo \"$hardcode_libdir_flag_spec\"`
  686.  
  687.               compile_command="$compile_command $flag"
  688.               finalize_command="$finalize_command $flag"
  689.             fi
  690.           elif test -n "$runpath_var"; then
  691.             # Do the same for the permanent run path.
  692.             case "$perm_rpath " in
  693.             *" $libdir "*) ;;
  694.             *) perm_rpath="$perm_rpath $libdir" ;;
  695.             esac
  696.           fi
  697.  
  698.  
  699.           case "$hardcode_action" in
  700.           immediate)
  701.             if test "$hardcode_direct" = no; then
  702.               compile_command="$compile_command $dir/$linklib"
  703.             elif test "$hardcode_minus_L" = no; then
  704.               compile_command="$compile_command -L$dir -l$name"
  705.             elif test "$hardcode_shlibpath_var" = no; then
  706.               compile_shlibpath="$compile_shlibpath$dir:"
  707.               compile_command="$compile_command -l$name"
  708.             fi
  709.             ;;
  710.  
  711.           relink)
  712.             # We need an absolute path.
  713.             case "$dir" in
  714.             /* | [A-Za-z]:\\*) ;;
  715.             *)
  716.               absdir=`cd "$dir" && pwd`
  717.               if test -z "$absdir"; then
  718.                 $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
  719.                 exit 1
  720.               fi
  721.               dir="$absdir"
  722.               ;;
  723.             esac
  724.  
  725.             if test "$hardcode_direct" = yes; then
  726.               compile_command="$compile_command $dir/$linklib"
  727.             elif test "$hardcode_minus_L" = yes; then
  728.               compile_command="$compile_command -L$dir -l$name"
  729.             elif test "$hardcode_shlibpath_var" = yes; then
  730.               compile_shlibpath="$compile_shlibpath$dir:"
  731.               compile_command="$compile_command -l$name"
  732.             fi
  733.             ;;
  734.  
  735.           *)
  736.             $echo "$modename: \`$hardcode_action' is an unknown hardcode action" 1>&2
  737.             exit 1
  738.             ;;
  739.           esac
  740.  
  741.           # Finalize command for both is simple: just hardcode it.
  742.           if test "$hardcode_direct" = yes; then
  743.             finalize_command="$finalize_command $libdir/$linklib"
  744.           elif test "$hardcode_minus_L" = yes; then
  745.             finalize_command="$finalize_command -L$libdir -l$name"
  746.           elif test "$hardcode_shlibpath_var" = yes; then
  747.             finalize_shlibpath="$finalize_shlibpath$libdir:"
  748.             finalize_command="$finalize_command -l$name"
  749.           else
  750.             # We cannot seem to hardcode it, guess we'll fake it.
  751.             finalize_command="$finalize_command -L$libdir -l$name"
  752.           fi
  753.         else
  754.           # Transform directly to old archives if we don't build new libraries.
  755.           if test -n "$pic_flag" && test -z "$old_library"; then
  756.             $echo "$modename: cannot find static library for \`$arg'" 1>&2
  757.             exit 1
  758.           fi
  759.  
  760.       # Here we assume that one of hardcode_direct or hardcode_minus_L
  761.       # is not unsupported.  This is valid on all known static and
  762.       # shared platforms.
  763.       if test "$hardcode_direct" != unsupported; then
  764.         test -n "$old_library" && linklib="$old_library"
  765.         compile_command="$compile_command $dir/$linklib"
  766.         finalize_command="$finalize_command $dir/$linklib"
  767.       else
  768.         compile_command="$compile_command -L$dir -l$name"
  769.         finalize_command="$finalize_command -L$dir -l$name"
  770.       fi
  771.         fi
  772.  
  773.     # Add in any libraries that this one depends upon.
  774.     compile_command="$compile_command$dependency_libs"
  775.     finalize_command="$finalize_command$dependency_libs"
  776.     continue
  777.         ;;
  778.  
  779.       # Some other compiler argument.
  780.       *)
  781.     # Unknown arguments in both finalize_command and compile_command need
  782.     # to be aesthetically quoted because they are evaled later.
  783.     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  784.     case "$arg" in
  785.     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  786.       arg="\"$arg\""
  787.       ;;
  788.     esac
  789.         ;;
  790.       esac
  791.  
  792.       # Now actually substitute the argument into the commands.
  793.       if test -n "$arg"; then
  794.     compile_command="$compile_command $arg"
  795.     finalize_command="$finalize_command $arg"
  796.       fi
  797.     done
  798.  
  799.     if test -n "$prev"; then
  800.       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
  801.       $echo "$help" 1>&2
  802.       exit 1
  803.     fi
  804.  
  805.     if test -n "$vinfo" && test -n "$release"; then
  806.       $echo "$modename: you cannot specify both \`-version-info' and \`-release'" 1>&2
  807.       $echo "$help" 1>&2
  808.       exit 1
  809.     fi
  810.  
  811.     oldlib=
  812.     oldobjs=
  813.     case "$output" in
  814.     "")
  815.       $echo "$modename: you must specify an output file" 1>&2
  816.       $echo "$help" 1>&2
  817.       exit 1
  818.       ;;
  819.  
  820.     */* | *\\*)
  821.       $echo "$modename: output file \`$output' must have no directory components" 1>&2
  822.       exit 1
  823.       ;;
  824.  
  825.     *.a)
  826.       # Now set the variables for building old libraries.
  827.       build_libtool_libs=no
  828.       build_old_libs=yes
  829.       oldlib="$output"
  830.       $show "$rm $oldlib"
  831.       $run $rm $oldlib
  832.       ;;
  833.  
  834.     *.la)
  835.       # Make sure we only generate libraries of the form `libNAME.la'.
  836.       case "$output" in
  837.       lib*) ;;
  838.       *)
  839.     $echo "$modename: libtool library \`$arg' must begin with \`lib'" 1>&2
  840.     $echo "$help" 1>&2
  841.     exit 1
  842.     ;;
  843.       esac
  844.  
  845.       name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
  846.       libname=`eval \\$echo \"$libname_spec\"`
  847.  
  848.       # All the library-specific variables (install_libdir is set above).
  849.       library_names=
  850.       old_library=
  851.       dlname=
  852.       current=0
  853.       revision=0
  854.       age=0
  855.  
  856.       if test -n "$objs"; then
  857.         $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
  858.         exit 1
  859.       fi
  860.  
  861.       # How the heck are we supposed to write a wrapper for a shared library?
  862.       if test -n "$link_against_libtool_libs"; then
  863.         $echo "$modename: libtool library \`$output' may not depend on uninstalled libraries:$link_against_libtool_libs" 1>&2
  864.         exit 1
  865.       fi
  866.  
  867.       if test -n "$dlfiles$dlprefiles"; then
  868.         $echo "$modename: warning: \`-dlopen' is ignored while creating libtool libraries" 1>&2
  869.         # Nullify the symbol file.
  870.         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  871.         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  872.       fi
  873.  
  874.       if test -z "$rpath"; then
  875.         $echo "$modename: you must specify an installation directory with \`-rpath'" 1>&2
  876.     $echo "$help" 1>&2
  877.         exit 1
  878.       fi
  879.  
  880.       set dummy $rpath
  881.       if test $# -gt 2; then
  882.     $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
  883.       fi
  884.       install_libdir="$2"
  885.  
  886.       # Parse the version information argument.
  887.       IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
  888.       set dummy $vinfo
  889.       IFS="$save_ifs"
  890.  
  891.       if test -n "$5"; then
  892.         $echo "$modename: too many parameters to \`-version-info'" 1>&2
  893.         $echo "$help" 1>&2
  894.         exit 1
  895.       fi
  896.  
  897.       test -n "$2" && current="$2"
  898.       test -n "$3" && revision="$3"
  899.       test -n "$4" && age="$4"
  900.  
  901.       # Check that each of the things are valid numbers.
  902.       case "$current" in
  903.       0 | [1-9] | [1-9][0-9]*) ;;
  904.       *)
  905.         $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
  906.         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
  907.         exit 1
  908.         ;;
  909.       esac
  910.  
  911.       case "$revision" in
  912.       0 | [1-9] | [1-9][0-9]*) ;;
  913.       *)
  914.         $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
  915.         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
  916.         exit 1
  917.         ;;
  918.       esac
  919.  
  920.       case "$age" in
  921.       0 | [1-9] | [1-9][0-9]*) ;;
  922.       *)
  923.         $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
  924.         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
  925.         exit 1
  926.         ;;
  927.       esac
  928.  
  929.       if test $age -gt $current; then
  930.         $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
  931.         $echo "$modename: \`$vinfo' is not valid version information" 1>&2
  932.         exit 1
  933.       fi
  934.  
  935.       # Calculate the version variables.
  936.       version_vars="version_type current age revision"
  937.       case "$version_type" in
  938.       none) ;;
  939.  
  940.       linux)
  941.         version_vars="$version_vars major versuffix"
  942.         major=`expr $current - $age`
  943.         versuffix="$major.$age.$revision"
  944.         ;;
  945.  
  946.       osf)
  947.         version_vars="$version_vars versuffix verstring"
  948.         major=`expr $current - $age`
  949.         versuffix="$current.$age.$revision"
  950.         verstring="$versuffix"
  951.  
  952.         # Add in all the interfaces that we are compatible with.
  953.         loop=$age
  954.         while test $loop != 0; do
  955.           iface=`expr $current - $loop`
  956.           loop=`expr $loop - 1`
  957.           verstring="$verstring:${iface}.0"
  958.         done
  959.  
  960.         # Make executables depend on our current version.
  961.         verstring="$verstring:${current}.0"
  962.         ;;
  963.  
  964.       sunos)
  965.         version_vars="$version_vars major versuffix"
  966.         major="$current"
  967.         versuffix="$current.$revision"
  968.         ;;
  969.  
  970.       *)
  971.         $echo "$modename: unknown library version type \`$version_type'" 1>&2
  972.         echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  973.         exit 1
  974.         ;;
  975.       esac
  976.  
  977.       # Create the output directory, or remove our outputs if we need to.
  978.       if test -d $objdir; then
  979.         $show "$rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*"
  980.         $run $rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*
  981.       else
  982.         $show "$mkdir $objdir"
  983.         $run $mkdir $objdir
  984.     status=$?
  985.     if test $status -eq 0 || test -d $objdir; then :
  986.     else
  987.       exit $status
  988.     fi
  989.       fi
  990.  
  991.       # Check to see if the archive will have undefined symbols.
  992.       if test "$allow_undefined" = yes; then
  993.         if test "$allow_undefined_flag" = unsupported; then
  994.           $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
  995.           build_libtool_libs=no
  996.       build_old_libs=yes
  997.         fi
  998.       else
  999.         # Don't allow undefined symbols.
  1000.         allow_undefined_flag="$no_undefined_flag"
  1001.       fi
  1002.  
  1003.       # Add libc to deplibs on all systems.
  1004.       dependency_libs="$deplibs"
  1005.       deplibs="$deplibs -lc"
  1006.  
  1007.       if test "$build_libtool_libs" = yes; then
  1008.         # Get the real and link names of the library.
  1009.         library_names=`eval \\$echo \"$library_names_spec\"`
  1010.         set dummy $library_names
  1011.         realname="$2"
  1012.         shift; shift
  1013.  
  1014.         if test -n "$soname_spec"; then
  1015.           soname=`eval \\$echo \"$soname_spec\"`
  1016.         else
  1017.           soname="$realname"
  1018.         fi
  1019.  
  1020.         lib="$objdir/$realname"
  1021.     for link
  1022.     do
  1023.       linknames="$linknames $link"
  1024.     done
  1025.  
  1026.         # Use standard objects if they are PIC.
  1027.         test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//g'`
  1028.  
  1029.         # Do each of the archive commands.
  1030.         cmds=`eval \\$echo \"$archive_cmds\"`
  1031.         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1032.         for cmd in $cmds; do
  1033.           IFS="$save_ifs"
  1034.           $show "$cmd"
  1035.           $run eval "$cmd" || exit $?
  1036.         done
  1037.         IFS="$save_ifs"
  1038.  
  1039.         # Create links to the real library.
  1040.         for linkname in $linknames; do
  1041.           $show "(cd $objdir && $LN_S $realname $linkname)"
  1042.           $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $?
  1043.         done
  1044.  
  1045.         # If -export-dynamic was specified, set the dlname.
  1046.         if test "$export_dynamic" = yes; then
  1047.           # On all known operating systems, these are identical.
  1048.           dlname="$soname"
  1049.         fi
  1050.       fi
  1051.  
  1052.       # Now set the variables for building old libraries.
  1053.       oldlib="$objdir/$libname.a"
  1054.       ;;
  1055.  
  1056.     *.lo | *.o)
  1057.       if test -n "$link_against_libtool_libs"; then
  1058.         $echo "$modename: error: cannot link libtool libraries into reloadable objects" 1>&2
  1059.         exit 1
  1060.       fi
  1061.  
  1062.       if test -n "$deplibs"; then
  1063.         $echo "$modename: warning: \`-l' and \`-L' are ignored while creating objects" 1>&2
  1064.       fi
  1065.  
  1066.       if test -n "$dlfiles$dlprefiles"; then
  1067.         $echo "$modename: warning: \`-dlopen' is ignored while creating objects" 1>&2
  1068.         # Nullify the symbol file.
  1069.         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  1070.         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  1071.       fi
  1072.  
  1073.       if test -n "$rpath"; then
  1074.         $echo "$modename: warning: \`-rpath' is ignored while creating objects" 1>&2
  1075.       fi
  1076.  
  1077.       if test -n "$vinfo"; then
  1078.         $echo "$modename: warning: \`-version-info' is ignored while creating objects" 1>&2
  1079.       fi
  1080.  
  1081.       if test -n "$release"; then
  1082.         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
  1083.       fi
  1084.  
  1085.       case "$output" in
  1086.       *.lo)
  1087.         if test -n "$objs"; then
  1088.           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
  1089.           exit 1
  1090.         fi
  1091.         libobj="$output"
  1092.         obj=`$echo "X$output" | $Xsed -e 's/\.lo$/.o/'`
  1093.         ;;
  1094.       *)
  1095.         libobj=
  1096.         obj="$output"
  1097.         ;;
  1098.       esac
  1099.  
  1100.       # Delete the old objects.
  1101.       $run $rm $obj $libobj
  1102.  
  1103.       # Create the old-style object.
  1104.       reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^       ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
  1105.  
  1106.       output="$obj"
  1107.       cmds=`eval \\$echo \"$reload_cmds\"`
  1108.       IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1109.       for cmd in $cmds; do
  1110.         IFS="$save_ifs"
  1111.         $show "$cmd"
  1112.         $run eval "$cmd" || exit $?
  1113.       done
  1114.       IFS="$save_ifs"
  1115.  
  1116.       # Exit if we aren't doing a library object file.
  1117.       test -z "$libobj" && exit 0
  1118.  
  1119.       if test "$build_libtool_libs" != yes; then
  1120.         # Create an invalid libtool object if no PIC, so that we don't
  1121.         # accidentally link it into a program.
  1122.         $show "echo timestamp > $libobj"
  1123.         $run eval "echo timestamp > $libobj" || exit $?
  1124.         exit 0
  1125.       fi
  1126.  
  1127.       if test -n "$pic_flag"; then
  1128.         # Only do commands if we really have different PIC objects.
  1129.         reload_objs="$libobjs"
  1130.         output="$libobj"
  1131.         cmds=`eval \\$echo \"$reload_cmds\"`
  1132.         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1133.         for cmd in $cmds; do
  1134.           IFS="$save_ifs"
  1135.           $show "$cmd"
  1136.           $run eval "$cmd" || exit $?
  1137.         done
  1138.         IFS="$save_ifs"
  1139.       else
  1140.         # Just create a symlink.
  1141.         $show "$LN_S $obj $libobj"
  1142.         $run $LN_S $obj $libobj || exit 1
  1143.       fi
  1144.  
  1145.       exit 0
  1146.       ;;
  1147.  
  1148.     *)
  1149.       if test -n "$vinfo"; then
  1150.         $echo "$modename: warning: \`-version-info' is ignored while linking programs" 1>&2
  1151.       fi
  1152.  
  1153.       if test -n "$release"; then
  1154.         $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2
  1155.       fi
  1156.  
  1157.       if test -n "$rpath"; then
  1158.     # If the user specified any rpath flags, then add them.
  1159.     for libdir in $rpath; do
  1160.           if test -n "$hardcode_libdir_flag_spec"; then
  1161.             if test -n "$hardcode_libdir_separator"; then
  1162.               if test -z "$hardcode_libdirs"; then
  1163.                 # Put the magic libdir with the hardcode flag.
  1164.                 hardcode_libdirs="$libdir"
  1165.                 libdir="@HARDCODE_LIBDIRS@"
  1166.               else
  1167.                 # Just accumulate the unique libdirs.
  1168.         case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
  1169.         *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  1170.           ;;
  1171.         *)
  1172.           hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  1173.           ;;
  1174.         esac
  1175.                 libdir=
  1176.               fi
  1177.             fi
  1178.  
  1179.             if test -n "$libdir"; then
  1180.               flag=`eval \\$echo \"$hardcode_libdir_flag_spec\"`
  1181.  
  1182.               compile_command="$compile_command $flag"
  1183.               finalize_command="$finalize_command $flag"
  1184.             fi
  1185.           elif test -n "$runpath_var"; then
  1186.             case "$perm_rpath " in
  1187.             *" $libdir "*) ;;
  1188.             *) perm_rpath="$perm_rpath $libdir" ;;
  1189.             esac
  1190.           fi
  1191.     done
  1192.       fi
  1193.  
  1194.       # Substitute the hardcoded libdirs into the compile commands.
  1195.       if test -n "$hardcode_libdir_separator"; then
  1196.     compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
  1197.     finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
  1198.       fi
  1199.  
  1200.       if test -n "$libobjs" && test "$build_old_libs" = yes; then
  1201.         # Transform all the library objects into standard objects.
  1202.         compile_command=`$echo "X$compile_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
  1203.         finalize_command=`$echo "X$finalize_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
  1204.       fi
  1205.  
  1206.       if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then
  1207.         dlsyms="${output}S.c"
  1208.       else
  1209.         dlsyms=
  1210.       fi
  1211.  
  1212.       if test -n "$dlsyms"; then
  1213.         # Add our own program objects to the preloaded list.
  1214.         dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'`
  1215.  
  1216.     # Discover the nlist of each of the dlfiles.
  1217.         nlist="$objdir/${output}.nm"
  1218.  
  1219.     if test -d $objdir; then
  1220.       $show "$rm $nlist ${nlist}T"
  1221.       $run $rm "$nlist" "${nlist}T"
  1222.     else
  1223.       $show "$mkdir $objdir"
  1224.       $run $mkdir $objdir
  1225.       status=$?
  1226.       if test $status -eq 0 || test -d $objdir; then :
  1227.       else
  1228.         exit $status
  1229.       fi
  1230.     fi
  1231.  
  1232.         for arg in $dlprefiles; do
  1233.       $show "extracting global C symbols from \`$arg'"
  1234.       $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
  1235.         done
  1236.  
  1237.         # Parse the name list into a source file.
  1238.         $show "creating $objdir/$dlsyms"
  1239.         if test -z "$run"; then
  1240.       # Make sure we at least have an empty file.
  1241.       test -f "$nlist" || : > "$nlist"
  1242.  
  1243.       # Try sorting and uniquifying the output.
  1244.       if sort "$nlist" | uniq > "$nlist"T; then
  1245.         mv -f "$nlist"T "$nlist"
  1246.         wcout=`wc "$nlist" 2>/dev/null`
  1247.         count=`echo "X$wcout" | $Xsed -e 's/^[     ]*\([0-9][0-9]*\).*$/\1/'`
  1248.         (test "$count" -ge 0) 2>/dev/null || count=-1
  1249.       else
  1250.         $rm "$nlist"T
  1251.         count=-1
  1252.       fi
  1253.  
  1254.       case "$dlsyms" in
  1255.       "") ;;
  1256.       *.c)
  1257.         $echo > "$objdir/$dlsyms" \
  1258. "/* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */
  1259. /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */
  1260.  
  1261. #ifdef __cplusplus
  1262. extern \"C\" {
  1263. #endif
  1264.  
  1265. /* Prevent the only kind of declaration conflicts we can make. */
  1266. #define dld_preloaded_symbol_count some_other_symbol
  1267. #define dld_preloaded_symbols some_other_symbol
  1268.  
  1269. /* External symbol declarations for the compiler. */"
  1270.  
  1271.         if test -f "$nlist"; then
  1272.           sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms"
  1273.         else
  1274.           echo '/* NONE */' >> "$objdir/$dlsyms"
  1275. EOF
  1276.         fi
  1277.  
  1278.         $echo >> "$objdir/$dlsyms" \
  1279. "
  1280. #undef dld_preloaded_symbol_count
  1281. #undef dld_preloaded_symbols
  1282.  
  1283. #if defined (__STDC__) && __STDC__
  1284. # define __ptr_t void *
  1285. #else
  1286. # define __ptr_t char *
  1287. #endif
  1288.  
  1289. /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */
  1290. int dld_preloaded_symbol_count = $count;
  1291.  
  1292. /* The mapping between symbol names and symbols. */
  1293. struct {
  1294.   char *name;
  1295.   __ptr_t address;
  1296. }
  1297. dld_preloaded_symbols[] =
  1298. {"
  1299.  
  1300.         if test -f "$nlist"; then
  1301.           sed 's/^\(.*\) \(.*\)$/  {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms"
  1302.         fi
  1303.  
  1304.         $echo >> "$objdir/$dlsyms" \
  1305. "  {0, (__ptr_t) 0}
  1306. };
  1307.  
  1308. #ifdef __cplusplus
  1309. }
  1310. #endif"
  1311.         ;;
  1312.  
  1313.       *)
  1314.         $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
  1315.         exit 1
  1316.         ;;
  1317.       esac
  1318.         fi
  1319.  
  1320.         # Now compile the dynamic symbol file.
  1321.         $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")"
  1322.         $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $?
  1323.  
  1324.         # Transform the symbol file into the correct name.
  1325.         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
  1326.         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"`
  1327.       elif test "$export_dynamic" != yes; then
  1328.         test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2
  1329.       else
  1330.         # We keep going just in case the user didn't refer to
  1331.         # dld_preloaded_symbols.  The linker will fail if global_symbol_pipe
  1332.         # really was required.
  1333.         $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
  1334.  
  1335.         # Nullify the symbol file.
  1336.         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  1337.         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  1338.       fi
  1339.  
  1340.       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
  1341.         # Replace the output file specification.
  1342.         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  1343.         finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  1344.  
  1345.         # We have no uninstalled library dependencies, so finalize right now.
  1346.         $show "$compile_command"
  1347.         $run eval "$compile_command"
  1348.         exit $?
  1349.       fi
  1350.  
  1351.       # Replace the output file specification.
  1352.       compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'`
  1353.       finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'`
  1354.  
  1355.       # Create the binary in the object directory, then wrap it.
  1356.       if test -d $objdir; then :
  1357.       else
  1358.         $show "$mkdir $objdir"
  1359.     $run $mkdir $objdir
  1360.     status=$?
  1361.     if test $status -eq 0 || test -d $objdir; then :
  1362.     else
  1363.       exit $status
  1364.     fi
  1365.       fi
  1366.  
  1367.       if test -n "$shlibpath_var"; then
  1368.         # We should set the shlibpath_var
  1369.         rpath=
  1370.         for dir in $temp_rpath; do
  1371.           case "$dir" in
  1372.           /* | [A-Za-z]:\\*)
  1373.             # Absolute path.
  1374.             rpath="$rpath$dir:"
  1375.             ;;
  1376.           *)
  1377.             # Relative path: add a thisdir entry.
  1378.             rpath="$rpath\$thisdir/$dir:"
  1379.             ;;
  1380.           esac
  1381.         done
  1382.         temp_rpath="$rpath"
  1383.       fi
  1384.  
  1385.       # Delete the old output file.
  1386.       $run $rm $output
  1387.  
  1388.       if test -n "$compile_shlibpath"; then
  1389.         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
  1390.       fi
  1391.       if test -n "$finalize_shlibpath"; then
  1392.         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
  1393.       fi
  1394.  
  1395.       if test -n "$runpath_var" && test -n "$perm_rpath"; then
  1396.         # We should set the runpath_var.
  1397.         rpath=
  1398.         for dir in $perm_rpath; do
  1399.           rpath="$rpath$dir:"
  1400.         done
  1401.         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
  1402.         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
  1403.       fi
  1404.  
  1405.       case "$hardcode_action" in
  1406.       relink)
  1407.         # AGH! Flame the AIX and HP-UX people for me, will ya?
  1408.         $echo "$modename: warning: using a buggy system linker" 1>&2
  1409.         $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2
  1410.         ;;
  1411.       esac
  1412.  
  1413.       $show "$compile_command"
  1414.       $run eval "$compile_command" || exit $?
  1415.  
  1416.       # Now create the wrapper script.
  1417.       $show "creating $output"
  1418.  
  1419.       # Quote the finalize command for shipping.
  1420.       finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"`
  1421.  
  1422.       # Quote $echo for shipping.
  1423.       qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
  1424.  
  1425.       # Only actually do things if our run command is non-null.
  1426.       if test -z "$run"; then
  1427.         $rm $output
  1428.         trap "$rm $output; exit 1" 1 2 15
  1429.  
  1430.         $echo > $output \
  1431. "#! /bin/sh
  1432.  
  1433. # $output - temporary wrapper script for $objdir/$output
  1434. # Generated by ltmain.sh - GNU $PACKAGE $VERSION
  1435. #
  1436. # The $output program cannot be directly executed until all the libtool
  1437. # libraries that it depends on are installed.
  1438. #
  1439. # This wrapper script should never be moved out of \``pwd`'.
  1440. # If it is, it will not operate correctly.
  1441.  
  1442. # Sed substitution that helps us do robust quoting.  It backslashifies
  1443. # metacharacters that are still active within double-quoted strings.
  1444. Xsed='sed -e s/^X//'
  1445. sed_quote_subst='$sed_quote_subst'
  1446.  
  1447. # The HP-UX ksh and POSIX shell print the target directory to stdout
  1448. # if CDPATH is set.
  1449. if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi
  1450.  
  1451. # This environment variable determines our operation mode.
  1452. if test \"\$libtool_install_magic\" = \"$magic\"; then
  1453.   # install mode needs the following variables:
  1454.   link_against_libtool_libs='$link_against_libtool_libs'
  1455.   finalize_command=\"$finalize_command\"
  1456. else
  1457.   # When we are sourced in execute mode, \$file and \$echo are already set.
  1458.   if test \"\$libtool_execute_magic\" = \"$magic\"; then :
  1459.   else
  1460.     echo=\"$qecho\"
  1461.     file=\"\$0\"
  1462.   fi
  1463. "
  1464.         $echo >> $output \
  1465. "
  1466.  
  1467.   # Find the directory that this script lives in.
  1468.   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
  1469.   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
  1470.  
  1471.   # Follow symbolic links until we get to the real thisdir.
  1472.   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
  1473.   while test -n \"\$file\"; do
  1474.     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
  1475.  
  1476.     # If there was a directory component, then change thisdir.
  1477.     if test \"x\$destdir\" != \"x\$file\"; then
  1478.       case \"\$destdir\" in
  1479.       /* | [A-Za-z]:\\*) thisdir=\"\$destdir\" ;;
  1480.       *) thisdir=\"\$thisdir/\$destdir\" ;;
  1481.       esac
  1482.     fi
  1483.  
  1484.     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
  1485.     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
  1486.   done
  1487.  
  1488.   # Try to get the absolute directory name.
  1489.   absdir=\`cd \"\$thisdir\" && pwd\`
  1490.   test -n \"\$absdir\" && thisdir=\"\$absdir\"
  1491.  
  1492.   progdir=\"\$thisdir/$objdir\"
  1493.   program='$output'
  1494.  
  1495.   if test -f \"\$progdir/\$program\"; then"
  1496.  
  1497.         # Export our shlibpath_var if we have one.
  1498.         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  1499.           $echo >> $output \
  1500. "    # Add our own library path to $shlibpath_var
  1501.     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
  1502.  
  1503.     # Some systems cannot cope with colon-terminated $shlibpath_var
  1504.     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\`
  1505.  
  1506.     export $shlibpath_var
  1507. "
  1508.         fi
  1509.  
  1510.         echo >> $output \
  1511. "    if test \"\$libtool_execute_magic\" != \"$magic\"; then
  1512.       # Run the actual program with our arguments.
  1513.       args=
  1514.       for arg
  1515.       do
  1516.         # Quote arguments (to preserve shell metacharacters).
  1517.     arg=\`\$echo \"X\$arg\" | \$Xsed -e \"\$sed_quote_subst\"\`
  1518.         args=\"\$args \\\"\$arg\\\"\"
  1519.       done
  1520.  
  1521.       # Export the path to the program.
  1522.       PATH=\"\$progdir:\$PATH\"
  1523.       export PATH
  1524.  
  1525.       eval \"exec \$program \$args\"
  1526.  
  1527.       \$echo \"\$0: cannot exec \$program \$args\"
  1528.       exit 1
  1529.     fi
  1530.   else
  1531.     # The program doesn't exist.
  1532.     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
  1533.     \$echo \"This script is just a wrapper for \$program.\" 1>&2
  1534.     echo \"See the $PACKAGE documentation for more information.\" 1>&2
  1535.     exit 1
  1536.   fi
  1537. fi"
  1538.         chmod +x $output
  1539.       fi
  1540.       exit 0
  1541.       ;;
  1542.     esac
  1543.  
  1544.     # See if we need to build an old-fashioned archive.
  1545.     if test "$build_old_libs" = "yes"; then
  1546.       # Transform .lo files to .o files.
  1547.       oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^   ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'`
  1548.  
  1549.       # Do each command in the archive commands.
  1550.       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
  1551.     cmds=`eval \\$echo \"$old_archive_from_new_cmds\"`
  1552.       else
  1553.     cmds=`eval \\$echo \"$old_archive_cmds\"`
  1554.       fi
  1555.       IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1556.       for cmd in $cmds; do
  1557.         IFS="$save_ifs"
  1558.         $show "$cmd"
  1559.         $run eval "$cmd" || exit $?
  1560.       done
  1561.       IFS="$save_ifs"
  1562.     fi
  1563.  
  1564.     # Now create the libtool archive.
  1565.     case "$output" in
  1566.     *.la)
  1567.       old_library=
  1568.       test "$build_old_libs" = yes && old_library="$libname.a"
  1569.  
  1570.       $show "creating $output"
  1571.  
  1572.       # Only create the output if not a dry run.
  1573.       if test -z "$run"; then
  1574.         echo > $output \
  1575. "# $output - a libtool library file
  1576. # Generated by ltmain.sh - GNU $PACKAGE $VERSION
  1577.  
  1578. # The name that we can dlopen(3).
  1579. dlname='$dlname'
  1580.  
  1581. # Names of this library.
  1582. library_names='$library_names'
  1583.  
  1584. # The name of the static archive.
  1585. old_library='$old_library'
  1586.  
  1587. # Libraries that this one depends upon.
  1588. dependency_libs='$dependency_libs'
  1589.  
  1590. # Version information for $libname.
  1591. current=$current
  1592. age=$age
  1593. revision=$revision
  1594.  
  1595. # Directory that this library needs to be installed in:
  1596. libdir='$install_libdir'"
  1597.       fi
  1598.  
  1599.       # Do a symbolic link so that the libtool archive can be found in
  1600.       # LD_LIBRARY_PATH before the program is installed.
  1601.       $show "(cd $objdir && $LN_S ../$output $output)"
  1602.       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit 1
  1603.       ;;
  1604.     esac
  1605.     exit 0
  1606.     ;;
  1607.  
  1608.   # libtool install mode
  1609.   install)
  1610.     modename="$modename: install"
  1611.  
  1612.     # There may be an optional /bin/sh argument at the beginning of
  1613.     # install_prog (especially on Windows NT).
  1614.     if test "$nonopt" = "$SHELL"; then
  1615.       # Aesthetically quote it.
  1616.       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
  1617.       case "$arg" in
  1618.       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  1619.     arg="\"$arg\""
  1620.     ;;
  1621.       esac
  1622.       install_prog="$arg "
  1623.       arg="$1"
  1624.       shift
  1625.     else
  1626.       install_prog=
  1627.       arg="$nonopt"
  1628.     fi
  1629.  
  1630.     # The real first argument should be the name of the installation program.
  1631.     # Aesthetically quote it.
  1632.     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1633.     case "$arg" in
  1634.     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  1635.       arg="\"$arg\""
  1636.       ;;
  1637.     esac
  1638.     install_prog="$install_prog$arg"
  1639.  
  1640.     # We need to accept at least all the BSD install flags.
  1641.     dest=
  1642.     files=
  1643.     opts=
  1644.     prev=
  1645.     install_type=
  1646.     isdir=
  1647.     stripme=
  1648.     for arg
  1649.     do
  1650.       if test -n "$dest"; then
  1651.         files="$files $dest"
  1652.         dest="$arg"
  1653.         continue
  1654.       fi
  1655.  
  1656.       case "$arg" in
  1657.       -d) isdir=yes ;;
  1658.       -f) prev="-f" ;;
  1659.       -g) prev="-g" ;;
  1660.       -m) prev="-m" ;;
  1661.       -o) prev="-o" ;;
  1662.       -s)
  1663.         stripme=" -s"
  1664.         continue
  1665.         ;;
  1666.       -*) ;;
  1667.  
  1668.       *)
  1669.         # If the previous option needed an argument, then skip it.
  1670.         if test -n "$prev"; then
  1671.           prev=
  1672.         else
  1673.           dest="$arg"
  1674.           continue
  1675.         fi
  1676.         ;;
  1677.       esac
  1678.  
  1679.       # Aesthetically quote the argument.
  1680.       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1681.       case "$arg" in
  1682.       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
  1683.     arg="\"$arg\""
  1684.     ;;
  1685.       esac
  1686.       install_prog="$install_prog $arg"
  1687.     done
  1688.  
  1689.     if test -z "$install_prog"; then
  1690.       $echo "$modename: you must specify an install program" 1>&2
  1691.       $echo "$help" 1>&2
  1692.       exit 1
  1693.     fi
  1694.  
  1695.     if test -n "$prev"; then
  1696.       $echo "$modename: the \`$prev' option requires an argument" 1>&2
  1697.       $echo "$help" 1>&2
  1698.       exit 1
  1699.     fi
  1700.  
  1701.     if test -z "$files"; then
  1702.       if test -z "$dest"; then
  1703.         $echo "$modename: no file or destination specified" 1>&2
  1704.       else
  1705.         $echo "$modename: you must specify a destination" 1>&2
  1706.       fi
  1707.       $echo "$help" 1>&2
  1708.       exit 1
  1709.     fi
  1710.  
  1711.     # Strip any trailing slash from the destination.
  1712.     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
  1713.  
  1714.     # Check to see that the destination is a directory.
  1715.     test -d "$dest" && isdir=yes
  1716.     if test -n "$isdir"; then
  1717.       destdir="$dest"
  1718.       destname=
  1719.     else
  1720.       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
  1721.       test "X$destdir" = "X$dest" && destdir=.
  1722.       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
  1723.  
  1724.       # Not a directory, so check to see that there is only one file specified.
  1725.       set dummy $files
  1726.       if test $# -gt 2; then
  1727.         $echo "$modename: \`$dest' is not a directory" 1>&2
  1728.         $echo "$help" 1>&2
  1729.         exit 1
  1730.       fi
  1731.     fi
  1732.     case "$destdir" in
  1733.     /* | [A-Za-z]:\\*) ;;
  1734.     *)
  1735.       for file in $files; do
  1736.         case "$file" in
  1737.         *.lo) ;;
  1738.         *)
  1739.           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
  1740.           $echo "$help" 1>&2
  1741.           exit 1
  1742.           ;;
  1743.         esac
  1744.       done
  1745.       ;;
  1746.     esac
  1747.  
  1748.     # This variable tells wrapper scripts just to set variables rather
  1749.     # than running their programs.
  1750.     libtool_install_magic="$magic"
  1751.  
  1752.     staticlibs=
  1753.     future_libdirs=
  1754.     current_libdirs=
  1755.     for file in $files; do
  1756.  
  1757.       # Do each installation.
  1758.       case "$file" in
  1759.       *.a)
  1760.         # Do the static libraries later.
  1761.         staticlibs="$staticlibs $file"
  1762.         ;;
  1763.  
  1764.       *.la)
  1765.         # Check to see that this really is a libtool archive.
  1766.         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
  1767.         else
  1768.           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
  1769.           $echo "$help" 1>&2
  1770.           exit 1
  1771.         fi
  1772.  
  1773.         library_names=
  1774.         old_library=
  1775.         # If there is no directory component, then add one.
  1776.         case "$file" in
  1777.         */* | *\\*) . $file ;;
  1778.         *) . ./$file ;;
  1779.         esac
  1780.  
  1781.         # Add the libdir to current_libdirs if it is the destination.
  1782.         if test "X$destdir" = "X$libdir"; then
  1783.           case "$current_libdirs " in
  1784.           *" $libdir "*) ;;
  1785.           *) current_libdirs="$current_libdirs $libdir" ;;
  1786.           esac
  1787.         else
  1788.           # Note the libdir as a future libdir.
  1789.           case "$future_libdirs " in
  1790.           *" $libdir "*) ;;
  1791.           *) future_libdirs="$future_libdirs $libdir" ;;
  1792.           esac
  1793.         fi
  1794.  
  1795.         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
  1796.         test "X$dir" = "X$file/" && dir=
  1797.         dir="$dir$objdir"
  1798.  
  1799.         # See the names of the shared library.
  1800.         set dummy $library_names
  1801.         if test -n "$2"; then
  1802.           realname="$2"
  1803.           shift
  1804.           shift
  1805.  
  1806.           # Install the shared library and build the symlinks.
  1807.           $show "$install_prog $dir/$realname $destdir/$realname"
  1808.           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
  1809.           test "X$dlname" = "X$realname" && dlname=
  1810.  
  1811.           if test $# -gt 0; then
  1812.             # Delete the old symlinks.
  1813.             rmcmd="$rm"
  1814.             for linkname
  1815.             do
  1816.               rmcmd="$rmcmd $destdir/$linkname"
  1817.             done
  1818.             $show "$rmcmd"
  1819.             $run $rmcmd
  1820.  
  1821.             # ... and create new ones.
  1822.             for linkname
  1823.             do
  1824.               test "X$dlname" = "X$linkname" && dlname=
  1825.               $show "(cd $destdir && $LN_S $realname $linkname)"
  1826.               $run eval "(cd $destdir && $LN_S $realname $linkname)"
  1827.             done
  1828.           fi
  1829.  
  1830.           if test -n "$dlname"; then
  1831.             # Install the dynamically-loadable library.
  1832.             $show "$install_prog $dir/$dlname $destdir/$dlname"
  1833.             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
  1834.           fi
  1835.  
  1836.           # Do each command in the postinstall commands.
  1837.           lib="$destdir/$realname"
  1838.           cmds=`eval \\$echo \"$postinstall_cmds\"`
  1839.           IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1840.           for cmd in $cmds; do
  1841.             IFS="$save_ifs"
  1842.             $show "$cmd"
  1843.             $run eval "$cmd" || exit $?
  1844.           done
  1845.           IFS="$save_ifs"
  1846.         fi
  1847.  
  1848.         # Install the pseudo-library for information purposes.
  1849.         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  1850.         $show "$install_prog $file $destdir/$name"
  1851.         $run eval "$install_prog $file $destdir/$name" || exit $?
  1852.  
  1853.         # Maybe install the static library, too.
  1854.         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
  1855.         ;;
  1856.  
  1857.       *.lo)
  1858.         # Install (i.e. copy) a libtool object.
  1859.  
  1860.         # Figure out destination file name, if it wasn't already specified.
  1861.         if test -n "$destname"; then
  1862.           destfile="$destdir/$destname"
  1863.         else
  1864.           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  1865.           destfile="$destdir/$destfile"
  1866.         fi
  1867.  
  1868.         # Deduce the name of the destination old-style object file.
  1869.         case "$destfile" in
  1870.         *.lo)
  1871.           staticdest=`$echo "X$destfile" | $Xsed -e 's/\.lo$/\.o/'`
  1872.           ;;
  1873.         *.o)
  1874.           staticdest="$destfile"
  1875.           destfile=
  1876.           ;;
  1877.         *)
  1878.           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
  1879.           $echo "$help" 1>&2
  1880.           exit 1
  1881.           ;;
  1882.         esac
  1883.  
  1884.         # Install the libtool object if requested.
  1885.         if test -n "$destfile"; then
  1886.           $show "$install_prog $file $destfile"
  1887.           $run eval "$install_prog $file $destfile" || exit $?
  1888.         fi
  1889.  
  1890.         # Install the old object if enabled.
  1891.         if test "$build_old_libs" = yes; then
  1892.           # Deduce the name of the old-style object file.
  1893.           staticobj=`$echo "X$file" | $Xsed -e 's/\.lo$/\.o/'`
  1894.  
  1895.           $show "$install_prog $staticobj $staticdest"
  1896.           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
  1897.         fi
  1898.         exit 0
  1899.         ;;
  1900.  
  1901.       *)
  1902.         # Do a test to see if this is really a libtool program.
  1903.         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
  1904.           link_against_libtool_libs=
  1905.           finalize_command=
  1906.  
  1907.           # If there is no directory component, then add one.
  1908.           case "$file" in
  1909.           */* | *\\*) . $file ;;
  1910.           *) . ./$file ;;
  1911.           esac
  1912.  
  1913.           # Check the variables that should have been set.
  1914.           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
  1915.             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
  1916.             exit 1
  1917.           fi
  1918.  
  1919.           finalize=yes
  1920.           for lib in $link_against_libtool_libs; do
  1921.             # Check to see that each library is installed.
  1922.             libdir=
  1923.             if test -f "$lib"; then
  1924.               # If there is no directory component, then add one.
  1925.               case "$lib" in
  1926.               */* | *\\*) . $lib ;;
  1927.               *) . ./$lib ;;
  1928.               esac
  1929.             fi
  1930.             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
  1931.             if test -z "$libdir"; then
  1932.               $echo "$modename: warning: \`$lib' contains no -rpath information" 1>&2
  1933.             elif test -f "$libfile"; then :
  1934.             else
  1935.               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
  1936.               finalize=no
  1937.             fi
  1938.           done
  1939.  
  1940.           if test "$hardcode_action" = relink; then
  1941.             if test "$finalize" = yes; then
  1942.               $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
  1943.               $show "$finalize_command"
  1944.               if $run eval "$finalize_command"; then :
  1945.               else
  1946.                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
  1947.                 continue
  1948.               fi
  1949.               file="$objdir/$file"T
  1950.             else
  1951.               $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
  1952.             fi
  1953.           else
  1954.             # Install the binary that we compiled earlier.
  1955.         file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
  1956.           fi
  1957.         fi
  1958.  
  1959.         $show "$install_prog$stripme $file $dest"
  1960.         $run eval "$install_prog\$stripme \$file \$dest" || exit $?
  1961.         ;;
  1962.       esac
  1963.     done
  1964.  
  1965.     for file in $staticlibs; do
  1966.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  1967.  
  1968.       # Set up the ranlib parameters.
  1969.       oldlib="$destdir/$name"
  1970.  
  1971.       $show "$install_prog $file $oldlib"
  1972.       $run eval "$install_prog \$file \$oldlib" || exit $?
  1973.  
  1974.       # Do each command in the postinstall commands.
  1975.       cmds=`eval \\$echo \"$old_postinstall_cmds\"`
  1976.       IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  1977.       for cmd in $cmds; do
  1978.         IFS="$save_ifs"
  1979.         $show "$cmd"
  1980.         $run eval "$cmd" || exit $?
  1981.       done
  1982.       IFS="$save_ifs"
  1983.     done
  1984.  
  1985.     if test -n "$future_libdirs"; then
  1986.       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
  1987.     fi
  1988.  
  1989.     if test -n "$current_libdirs"; then
  1990.       # Maybe just do a dry run.
  1991.       test -n "$run" && current_libdirs=" -n$current_libdirs"
  1992.       exec $SHELL $0 --finish$current_libdirs
  1993.       exit 1
  1994.     fi
  1995.  
  1996.     exit 0
  1997.     ;;
  1998.  
  1999.   # libtool finish mode
  2000.   finish)
  2001.     modename="$modename: finish"
  2002.     libdirs="$nonopt"
  2003.  
  2004.     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  2005.       for dir
  2006.       do
  2007.         libdirs="$libdirs $dir"
  2008.       done
  2009.  
  2010.       for libdir in $libdirs; do
  2011.     if test -n "$finish_cmds"; then
  2012.       # Do each command in the finish commands.
  2013.       cmds=`eval \\$echo \"$finish_cmds\"`
  2014.           IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  2015.           for cmd in $cmds; do
  2016.             IFS="$save_ifs"
  2017.             $show "$cmd"
  2018.             $run eval "$cmd"
  2019.           done
  2020.           IFS="$save_ifs"
  2021.     fi
  2022.     if test -n "$finish_eval"; then
  2023.       # Do the single finish_eval.
  2024.       cmds=`eval \\$echo \"$finish_eval\"`
  2025.       $run eval "$cmds"
  2026.     fi
  2027.       done
  2028.     fi
  2029.  
  2030.     echo "------------------------------------------------------------------------------"
  2031.     echo "Libraries have been installed in:"
  2032.     for libdir in $libdirs; do
  2033.       echo "   $libdir"
  2034.     done
  2035.     echo
  2036.     echo "To link against installed libraries in a given directory, LIBDIR,"
  2037.     echo "you must use the \`-LLIBDIR' flag during linking."
  2038.     echo
  2039.     echo " You will also need to do one of the following:"
  2040.     if test -n "$shlibpath_var"; then
  2041.       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
  2042.       echo "     during execution"
  2043.     fi
  2044.     if test -n "$runpath_var"; then
  2045.       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
  2046.       echo "     during linking"
  2047.     fi
  2048.     if test -n "$hardcode_libdir_flag_spec"; then
  2049.       libdir=LIBDIR
  2050.       flag=`eval \\$echo \"$hardcode_libdir_flag_spec\"`
  2051.  
  2052.       echo "   - use the \`$flag' linker flag"
  2053.     fi
  2054.     if test -f /etc/ld.so.conf; then
  2055.       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
  2056.     fi
  2057.     echo
  2058.     echo "See any operating system documentation about shared libraries for"
  2059.     echo "more information, such as the ld(1) and ld.so(8) manual pages."
  2060.     echo "------------------------------------------------------------------------------"
  2061.     exit 0
  2062.     ;;
  2063.  
  2064.   # libtool execute mode
  2065.   execute)
  2066.     modename="$modename: execute"
  2067.  
  2068.     # The first argument is the command name.
  2069.     cmd="$nonopt"
  2070.     if test -z "$cmd"; then
  2071.       $echo "$modename: you must specify a COMMAND" 1>&2
  2072.       $echo "$help"
  2073.       exit 1
  2074.     fi
  2075.  
  2076.     # Handle -dlopen flags immediately.
  2077.     for file in $execute_dlfiles; do
  2078.       if test -f "$file"; then :
  2079.       else
  2080.     $echo "$modename: \`$file' is not a file" 1>&2
  2081.     $echo "$help" 1>&2
  2082.     exit 1
  2083.       fi
  2084.  
  2085.       dir=
  2086.       case "$file" in
  2087.       *.la)
  2088.         # Check to see that this really is a libtool archive.
  2089.         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :
  2090.         else
  2091.           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
  2092.           $echo "$help" 1>&2
  2093.           exit 1
  2094.         fi
  2095.  
  2096.     # Read the libtool library.
  2097.     dlname=
  2098.     library_names=
  2099.  
  2100.         # If there is no directory component, then add one.
  2101.     case "$file" in
  2102.     */* | *\\*) . $file ;;
  2103.         *) . ./$file ;;
  2104.     esac
  2105.  
  2106.     # Skip this library if it cannot be dlopened.
  2107.     if test -z "$dlname"; then
  2108.       # Warn if it was a shared library.
  2109.       test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
  2110.       continue
  2111.     fi
  2112.  
  2113.     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2114.     test "X$dir" = "X$file" && dir=.
  2115.  
  2116.     if test -f "$dir/$objdir/$dlname"; then
  2117.       dir="$dir/$objdir"
  2118.     else
  2119.       $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
  2120.       exit 1
  2121.     fi
  2122.     ;;
  2123.  
  2124.       *.lo)
  2125.     # Just add the directory containing the .lo file.
  2126.     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2127.     test "X$dir" = "X$file" && dir=.
  2128.     ;;
  2129.  
  2130.       *)
  2131.     $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
  2132.         continue
  2133.     ;;
  2134.       esac
  2135.  
  2136.       # Get the absolute pathname.
  2137.       absdir=`cd "$dir" && pwd`
  2138.       test -n "$absdir" && dir="$absdir"
  2139.  
  2140.       # Now add the directory to shlibpath_var.
  2141.       if eval "test -z \"\$$shlibpath_var\""; then
  2142.     eval "$shlibpath_var=\"\$dir\""
  2143.       else
  2144.     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
  2145.       fi
  2146.     done
  2147.  
  2148.     # This variable tells wrapper scripts just to set shlibpath_var
  2149.     # rather than running their programs.
  2150.     libtool_execute_magic="$magic"
  2151.  
  2152.     # Check if any of the arguments is a wrapper script.
  2153.     args=
  2154.     for file
  2155.     do
  2156.       case "$file" in
  2157.       -*) ;;
  2158.       *)
  2159.         # Do a test to see if this is really a libtool program.
  2160.         if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
  2161.       # If there is no directory component, then add one.
  2162.       case "$file" in
  2163.       */* | *\\*) . $file ;;
  2164.       *) . ./$file ;;
  2165.       esac
  2166.  
  2167.       # Transform arg to wrapped name.
  2168.       file="$progdir/$program"
  2169.     fi
  2170.         ;;
  2171.       esac
  2172.       # Quote arguments (to preserve shell metacharacters).
  2173.       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
  2174.       args="$args \"$file\""
  2175.     done
  2176.  
  2177.     if test -z "$run"; then
  2178.       # Export the shlibpath_var.
  2179.       eval "export $shlibpath_var"
  2180.  
  2181.       # Now actually exec the command.
  2182.       eval "exec \$cmd$args"
  2183.  
  2184.       $echo "$modename: cannot exec \$cmd$args"
  2185.       exit 1
  2186.     else
  2187.       # Display what would be done.
  2188.       eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
  2189.       $echo "export $shlibpath_var"
  2190.       $echo "$cmd$args"
  2191.       exit 0
  2192.     fi
  2193.     ;;
  2194.  
  2195.   # libtool uninstall mode
  2196.   uninstall)
  2197.     modename="$modename: uninstall"
  2198.     rm="$nonopt"
  2199.     files=
  2200.  
  2201.     for arg
  2202.     do
  2203.       case "$arg" in
  2204.       -*) rm="$rm $arg" ;;
  2205.       *) files="$files $arg" ;;
  2206.       esac
  2207.     done
  2208.  
  2209.     if test -z "$rm"; then
  2210.       $echo "$modename: you must specify an RM program" 1>&2
  2211.       $echo "$help" 1>&2
  2212.       exit 1
  2213.     fi
  2214.  
  2215.     for file in $files; do
  2216.       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2217.       test "X$dir" = "X$file" && dir=.
  2218.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2219.  
  2220.       rmfiles="$file"
  2221.  
  2222.       case "$name" in
  2223.       *.la)
  2224.         # Possibly a libtool archive, so verify it.
  2225.         if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then
  2226.           . $dir/$name
  2227.  
  2228.           # Delete the libtool libraries and symlinks.
  2229.           for n in $library_names; do
  2230.             rmfiles="$rmfiles $dir/$n"
  2231.             test "X$n" = "X$dlname" && dlname=
  2232.           done
  2233.           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
  2234.           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
  2235.  
  2236.       $show "$rm $rmfiles"
  2237.       $run $rm $rmfiles
  2238.  
  2239.       if test -n "$library_names"; then
  2240.         # Do each command in the postuninstall commands.
  2241.         cmds=`eval \\$echo \"$postuninstall_cmds\"`
  2242.         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  2243.         for cmd in $cmds; do
  2244.           IFS="$save_ifs"
  2245.           $show "$cmd"
  2246.           $run eval "$cmd"
  2247.         done
  2248.         IFS="$save_ifs"
  2249.       fi
  2250.  
  2251.           if test -n "$old_library"; then
  2252.         # Do each command in the old_postuninstall commands.
  2253.         cmds=`eval \\$echo \"$old_postuninstall_cmds\"`
  2254.         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
  2255.         for cmd in $cmds; do
  2256.           IFS="$save_ifs"
  2257.           $show "$cmd"
  2258.           $run eval "$cmd"
  2259.         done
  2260.         IFS="$save_ifs"
  2261.       fi
  2262.  
  2263.           # FIXME: should reinstall the best remaining shared library.
  2264.         fi
  2265.         ;;
  2266.  
  2267.       *.lo)
  2268.         if test "$build_old_libs" = yes; then
  2269.           oldobj=`$echo "X$name" | $Xsed -e 's/\.lo$/\.o/'`
  2270.           rmfiles="$rmfiles $dir/$oldobj"
  2271.         fi
  2272.     $show "$rm $rmfiles"
  2273.     $run $rm $rmfiles
  2274.         ;;
  2275.  
  2276.       *)
  2277.           $show "$rm $rmfiles"
  2278.     $run $rm $rmfiles
  2279.     ;;
  2280.       esac
  2281.     done
  2282.     exit 0
  2283.     ;;
  2284.  
  2285.   "")
  2286.     $echo "$modename: you must specify a MODE" 1>&2
  2287.     $echo "$generic_help" 1>&2
  2288.     exit 1
  2289.     ;;
  2290.   esac
  2291.  
  2292.   $echo "$modename: invalid operation mode \`$mode'" 1>&2
  2293.   $echo "$generic_help" 1>&2
  2294.   exit 1
  2295. fi # test -z "$show_help"
  2296.  
  2297. # We need to display help for each of the modes.
  2298. case "$mode" in
  2299. "") $echo \
  2300. "Usage: $modename [OPTION]... [MODE-ARG]...
  2301.  
  2302. Provide generalized library-building support services.
  2303.  
  2304. -n, --dry-run         display commands without modifying any files
  2305.     --features        display configuration information and exit
  2306.     --finish          same as \`--mode=finish'
  2307.     --help            display this help message and exit
  2308.     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
  2309.     --quiet           same as \`--silent'
  2310.     --silent          don't print informational messages
  2311.     --version         print version information
  2312.  
  2313. MODE must be one of the following:
  2314.  
  2315.       compile         compile a source file into a libtool object
  2316.       execute         automatically set library path, then run a program
  2317.       finish          complete the installation of libtool libraries
  2318.       install         install libraries or executables
  2319.       link            create a library or an executable
  2320.       uninstall       remove libraries from an installed directory
  2321.  
  2322. MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
  2323. a more detailed description of MODE."
  2324.   exit 0
  2325.   ;;
  2326.  
  2327. compile)
  2328.   $echo \
  2329. "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
  2330.  
  2331. Compile a source file into a libtool library object.
  2332.  
  2333. COMPILE-COMMAND is a command to be used in creating a \`standard' object file
  2334. from the given SOURCEFILE.
  2335.  
  2336. The output file name is determined by removing the directory component from
  2337. SOURCEFILE, then substituting the C source code suffix \`.c' with the
  2338. library object suffix, \`.lo'."
  2339.   ;;
  2340.  
  2341. execute)
  2342.   $echo \
  2343. "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
  2344.  
  2345. Automatically set library path, then run a program.
  2346.  
  2347. This mode accepts the following additional options:
  2348.  
  2349.   -dlopen FILE      add the directory containing FILE to the library path
  2350.  
  2351. This mode sets the library path environment variable according to \`-dlopen'
  2352. flags.
  2353.  
  2354. If any of the ARGS are libtool executable wrappers, then they are translated
  2355. into their corresponding uninstalled binary, and any of their required library
  2356. directories are added to the library path.
  2357.  
  2358. Then, COMMAND is executed, with ARGS as arguments."
  2359.   ;;
  2360.  
  2361. finish)
  2362.   $echo \
  2363. "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
  2364.  
  2365. Complete the installation of libtool libraries.
  2366.  
  2367. Each LIBDIR is a directory that contains libtool libraries.
  2368.  
  2369. The commands that this mode executes may require superuser privileges.  Use
  2370. the \`--dry-run' option if you just want to see what would be executed."
  2371.   ;;
  2372.  
  2373. install)
  2374.   $echo \
  2375. "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
  2376.  
  2377. Install executables or libraries.
  2378.  
  2379. INSTALL-COMMAND is the installation command.  The first component should be
  2380. either the \`install' or \`cp' program.
  2381.  
  2382. The rest of the components are interpreted as arguments to that command (only
  2383. BSD-compatible install options are recognized)."
  2384.   ;;
  2385.  
  2386. link)
  2387.   $echo \
  2388. "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
  2389.  
  2390. Link object files or libraries together to form another library, or to
  2391. create an executable program.
  2392.  
  2393. LINK-COMMAND is a command using the C compiler that you would use to create
  2394. a program from several object files.
  2395.  
  2396. The following components of LINK-COMMAND are treated specially:
  2397.  
  2398.   -all-static       do not do any dynamic linking at all
  2399.   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
  2400.   -dlpreopen FILE   link in FILE and add its symbols to dld_preloaded_symbols
  2401.   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  2402.   -LLIBDIR          search LIBDIR for required installed libraries
  2403.   -lNAME            OUTPUT-FILE requires the installed library libNAME
  2404.   -no-undefined     declare that a library does not refer to external symbols
  2405.   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  2406.   -release RELEASE  specify package release information
  2407.   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  2408.   -static           do not do any dynamic linking of libtool libraries
  2409.   -version-info CURRENT[:REVISION[:AGE]]
  2410.                     specify library version info [each variable defaults to 0]
  2411.  
  2412. All other options (arguments beginning with \`-') are ignored.
  2413.  
  2414. Every other argument is treated as a filename.  Files ending in \`.la' are
  2415. treated as uninstalled libtool libraries, other files are standard or library
  2416. object files.
  2417.  
  2418. If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
  2419. library objects (\`.lo' files) may be specified, and \`-rpath' is required.
  2420.  
  2421. If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar'
  2422. and \`ranlib'.
  2423.  
  2424. If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is
  2425. created, otherwise an executable program is created."
  2426.   ;;
  2427.  
  2428. uninstall)
  2429.   $echo
  2430. "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
  2431.  
  2432. Remove libraries from an installation directory.
  2433.  
  2434. RM is the name of the program to use to delete files associated with each FILE
  2435. (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
  2436. to RM.
  2437.  
  2438. If FILE is a libtool library, all the files associated with it are deleted.
  2439. Otherwise, only FILE itself is deleted using RM."
  2440.   ;;
  2441.  
  2442. *)
  2443.   $echo "$modename: invalid operation mode \`$mode'" 1>&2
  2444.   $echo "$help" 1>&2
  2445.   exit 1
  2446.   ;;
  2447. esac
  2448.  
  2449. echo
  2450. $echo "Try \`$modename --help' for more information about other modes."
  2451.  
  2452. exit 0
  2453.  
  2454. # Local Variables:
  2455. # mode:shell-script
  2456. # sh-indentation:2
  2457. # End:
  2458.