ltmain.sh
上传用户:sy_wanhua
上传日期:2013-07-25
资源大小:3048k
文件大小:107k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

C/C++

  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-1999 Free Software Foundation, Inc.
  5. # Originally by 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. # Check that we have a working $echo.
  26. if test "X$1" = X--no-reexec; then
  27.   # Discard the --no-reexec flag, and continue.
  28.   shift
  29. elif test "X$1" = X--fallback-echo; then
  30.   # Avoid inline document here, it may be left over
  31.   :
  32. elif test "X`($echo 't') 2>/dev/null`" = 'Xt'; then
  33.   # Yippee, $echo works!
  34.   :
  35. else
  36.   # Restart under the correct shell, and then maybe $echo will work.
  37.   exec $SHELL "$0" --no-reexec ${1+"$@"}
  38. fi
  39. if test "X$1" = X--fallback-echo; then
  40.   # used as fallback echo
  41.   shift
  42.   cat <<EOF
  43. $*
  44. EOF
  45.   exit 0
  46. fi
  47. # The name of this program.
  48. progname=`$echo "$0" | sed 's%^.*/%%'`
  49. modename="$progname"
  50. # Constants.
  51. PROGRAM=ltmain.sh
  52. PACKAGE=libtool
  53. VERSION=1.3.3
  54. TIMESTAMP=" (1.385.2.181 1999/07/02 15:49:11)"
  55. default_mode=
  56. help="Try `$progname --help' for more information."
  57. magic="%%%MAGIC variable%%%"
  58. mkdir="mkdir"
  59. mv="mv -f"
  60. rm="rm -f"
  61. # Sed substitution that helps us do robust quoting.  It backslashifies
  62. # metacharacters that are still active within double-quoted strings.
  63. Xsed='sed -e 1s/^X//'
  64. sed_quote_subst='s/([\`\"$\\])/\1/g'
  65. SP2NL='tr 40 12'
  66. NL2SP='tr 1512 4040'
  67. # NLS nuisances.
  68. # Only set LANG and LC_ALL to C if already set.
  69. # These must not be set unconditionally because not all systems understand
  70. # e.g. LANG=C (notably SCO).
  71. # We save the old values to restore during execute mode.
  72. if test "${LC_ALL+set}" = set; then
  73.   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  74. fi
  75. if test "${LANG+set}" = set; then
  76.   save_LANG="$LANG"; LANG=C; export LANG
  77. fi
  78. if test "$LTCONFIG_VERSION" != "$VERSION"; then
  79.   echo "$modename: ltconfig version `$LTCONFIG_VERSION' does not match $PROGRAM version `$VERSION'" 1>&2
  80.   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  81.   exit 1
  82. fi
  83. if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  84.   echo "$modename: not configured to build any kind of library" 1>&2
  85.   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  86.   exit 1
  87. fi
  88. # Global variables.
  89. mode=$default_mode
  90. nonopt=
  91. prev=
  92. prevopt=
  93. run=
  94. show="$echo"
  95. show_help=
  96. execute_dlfiles=
  97. lo2o="s/\.lo$/.${objext}/"
  98. o2lo="s/\.${objext}$/.lo/"
  99. # Parse our command line options once, thoroughly.
  100. while test $# -gt 0
  101. do
  102.   arg="$1"
  103.   shift
  104.   case "$arg" in
  105.   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  106.   *) optarg= ;;
  107.   esac
  108.   # If the previous option needs an argument, assign it.
  109.   if test -n "$prev"; then
  110.     case "$prev" in
  111.     execute_dlfiles)
  112.       eval "$prev="$$prev $arg""
  113.       ;;
  114.     *)
  115.       eval "$prev=$arg"
  116.       ;;
  117.     esac
  118.     prev=
  119.     prevopt=
  120.     continue
  121.   fi
  122.   # Have we seen a non-optional argument yet?
  123.   case "$arg" in
  124.   --help)
  125.     show_help=yes
  126.     ;;
  127.   --version)
  128.     echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
  129.     exit 0
  130.     ;;
  131.   --config)
  132.     sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
  133.     exit 0
  134.     ;;
  135.   --debug)
  136.     echo "$progname: enabling shell trace mode"
  137.     set -x
  138.     ;;
  139.   --dry-run | -n)
  140.     run=:
  141.     ;;
  142.   --features)
  143.     echo "host: $host"
  144.     if test "$build_libtool_libs" = yes; then
  145.       echo "enable shared libraries"
  146.     else
  147.       echo "disable shared libraries"
  148.     fi
  149.     if test "$build_old_libs" = yes; then
  150.       echo "enable static libraries"
  151.     else
  152.       echo "disable static libraries"
  153.     fi
  154.     exit 0
  155.     ;;
  156.   --finish) mode="finish" ;;
  157.   --mode) prevopt="--mode" prev=mode ;;
  158.   --mode=*) mode="$optarg" ;;
  159.   --quiet | --silent)
  160.     show=:
  161.     ;;
  162.   -dlopen)
  163.     prevopt="-dlopen"
  164.     prev=execute_dlfiles
  165.     ;;
  166.   -*)
  167.     $echo "$modename: unrecognized option `$arg'" 1>&2
  168.     $echo "$help" 1>&2
  169.     exit 1
  170.     ;;
  171.   *)
  172.     nonopt="$arg"
  173.     break
  174.     ;;
  175.   esac
  176. done
  177. if test -n "$prevopt"; then
  178.   $echo "$modename: option `$prevopt' requires an argument" 1>&2
  179.   $echo "$help" 1>&2
  180.   exit 1
  181. fi
  182. if test -z "$show_help"; then
  183.   # Infer the operation mode.
  184.   if test -z "$mode"; then
  185.     case "$nonopt" in
  186.     *cc | *++ | gcc* | *-gcc*)
  187.       mode=link
  188.       for arg
  189.       do
  190. case "$arg" in
  191. -c)
  192.    mode=compile
  193.    break
  194.    ;;
  195. esac
  196.       done
  197.       ;;
  198.     *db | *dbx | *strace | *truss)
  199.       mode=execute
  200.       ;;
  201.     *install*|cp|mv)
  202.       mode=install
  203.       ;;
  204.     *rm)
  205.       mode=uninstall
  206.       ;;
  207.     *)
  208.       # If we have no mode, but dlfiles were specified, then do execute mode.
  209.       test -n "$execute_dlfiles" && mode=execute
  210.       # Just use the default operation mode.
  211.       if test -z "$mode"; then
  212. if test -n "$nonopt"; then
  213.   $echo "$modename: warning: cannot infer operation mode from `$nonopt'" 1>&2
  214. else
  215.   $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
  216. fi
  217.       fi
  218.       ;;
  219.     esac
  220.   fi
  221.   # Only execute mode is allowed to have -dlopen flags.
  222.   if test -n "$execute_dlfiles" && test "$mode" != execute; then
  223.     $echo "$modename: unrecognized option `-dlopen'" 1>&2
  224.     $echo "$help" 1>&2
  225.     exit 1
  226.   fi
  227.   # Change the help message to a mode-specific one.
  228.   generic_help="$help"
  229.   help="Try `$modename --help --mode=$mode' for more information."
  230.   # These modes are in order of execution frequency so that they run quickly.
  231.   case "$mode" in
  232.   # libtool compile mode
  233.   compile)
  234.     modename="$modename: compile"
  235.     # Get the compilation command and the source file.
  236.     base_compile=
  237.     lastarg=
  238.     srcfile="$nonopt"
  239.     suppress_output=
  240.     user_target=no
  241.     for arg
  242.     do
  243.       # Accept any command-line options.
  244.       case "$arg" in
  245.       -o)
  246. if test "$user_target" != "no"; then
  247.   $echo "$modename: you cannot specify `-o' more than once" 1>&2
  248.   exit 1
  249. fi
  250. user_target=next
  251. ;;
  252.       -static)
  253. build_old_libs=yes
  254. continue
  255. ;;
  256.       esac
  257.       case "$user_target" in
  258.       next)
  259. # The next one is the -o target name
  260. user_target=yes
  261. continue
  262. ;;
  263.       yes)
  264. # We got the output file
  265. user_target=set
  266. libobj="$arg"
  267. continue
  268. ;;
  269.       esac
  270.       # Accept the current argument as the source file.
  271.       lastarg="$srcfile"
  272.       srcfile="$arg"
  273.       # Aesthetically quote the previous argument.
  274.       # Backslashify any backslashes, double quotes, and dollar signs.
  275.       # These are the only characters that are still specially
  276.       # interpreted inside of double-quoted scrings.
  277.       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
  278.       # Double-quote args containing other shell metacharacters.
  279.       # Many Bourne shells cannot handle close brackets correctly in scan
  280.       # sets, so we specify it separately.
  281.       case "$lastarg" in
  282.       *[[~#^&*(){}|;<>?'  ]*|*]*)
  283. lastarg=""$lastarg""
  284. ;;
  285.       esac
  286.       # Add the previous argument to base_compile.
  287.       if test -z "$base_compile"; then
  288. base_compile="$lastarg"
  289.       else
  290. base_compile="$base_compile $lastarg"
  291.       fi
  292.     done
  293.     case "$user_target" in
  294.     set)
  295.       ;;
  296.     no)
  297.       # Get the name of the library object.
  298.       libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
  299.       ;;
  300.     *)
  301.       $echo "$modename: you must specify a target with `-o'" 1>&2
  302.       exit 1
  303.       ;;
  304.     esac
  305.     # Recognize several different file suffixes.
  306.     # If the user specifies -o file.o, it is replaced with file.lo
  307.     xform='[cCFSfmso]'
  308.     case "$libobj" in
  309.     *.ada) xform=ada ;;
  310.     *.adb) xform=adb ;;
  311.     *.ads) xform=ads ;;
  312.     *.asm) xform=asm ;;
  313.     *.c++) xform=c++ ;;
  314.     *.cc) xform=cc ;;
  315.     *.cpp) xform=cpp ;;
  316.     *.cxx) xform=cxx ;;
  317.     *.f90) xform=f90 ;;
  318.     *.for) xform=for ;;
  319.     esac
  320.     libobj=`$echo "X$libobj" | $Xsed -e "s/.$xform$/.lo/"`
  321.     case "$libobj" in
  322.     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
  323.     *)
  324.       $echo "$modename: cannot determine name of library object from `$libobj'" 1>&2
  325.       exit 1
  326.       ;;
  327.     esac
  328.     if test -z "$base_compile"; then
  329.       $echo "$modename: you must specify a compilation command" 1>&2
  330.       $echo "$help" 1>&2
  331.       exit 1
  332.     fi
  333.     # Delete any leftover library objects.
  334.     if test "$build_old_libs" = yes; then
  335.       removelist="$obj $libobj"
  336.     else
  337.       removelist="$libobj"
  338.     fi
  339.     $run $rm $removelist
  340.     trap "$run $rm $removelist; exit 1" 1 2 15
  341.     # Calculate the filename of the output object if compiler does
  342.     # not support -o with -c
  343.     if test "$compiler_c_o" = no; then
  344.       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%..*$%%'`.${objext}
  345.       lockfile="$output_obj.lock"
  346.       removelist="$removelist $output_obj $lockfile"
  347.       trap "$run $rm $removelist; exit 1" 1 2 15
  348.     else
  349.       need_locks=no
  350.       lockfile=
  351.     fi
  352.     # Lock this critical section if it is needed
  353.     # We use this script file to make the link, it avoids creating a new file
  354.     if test "$need_locks" = yes; then
  355.       until ln "$0" "$lockfile" 2>/dev/null; do
  356. $show "Waiting for $lockfile to be removed"
  357. sleep 2
  358.       done
  359.     elif test "$need_locks" = warn; then
  360.       if test -f "$lockfile"; then
  361. echo "
  362. *** ERROR, $lockfile exists and contains:
  363. `cat $lockfile 2>/dev/null`
  364. This indicates that another process is trying to use the same
  365. temporary object file, and libtool could not work around it because
  366. your compiler does not support `-c' and `-o' together.  If you
  367. repeat this compilation, it may succeed, by chance, but you had better
  368. avoid parallel builds (make -j) in this platform, or get a better
  369. compiler."
  370. $run $rm $removelist
  371. exit 1
  372.       fi
  373.       echo $srcfile > "$lockfile"
  374.     fi
  375.     if test -n "$fix_srcfile_path"; then
  376.       eval srcfile="$fix_srcfile_path"
  377.     fi
  378.     # Only build a PIC object if we are building libtool libraries.
  379.     if test "$build_libtool_libs" = yes; then
  380.       # Without this assignment, base_compile gets emptied.
  381.       fbsd_hideous_sh_bug=$base_compile
  382.       # All platforms use -DPIC, to notify preprocessed assembler code.
  383.       command="$base_compile $pic_flag -DPIC $srcfile"
  384.       if test "$build_old_libs" = yes; then
  385. lo_libobj="$libobj"
  386. dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
  387. if test "X$dir" = "X$libobj"; then
  388.   dir="$objdir"
  389. else
  390.   dir="$dir/$objdir"
  391. fi
  392. libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
  393. if test -d "$dir"; then
  394.   $show "$rm $libobj"
  395.   $run $rm $libobj
  396. else
  397.   $show "$mkdir $dir"
  398.   $run $mkdir $dir
  399.   status=$?
  400.   if test $status -ne 0 && test ! -d $dir; then
  401.     exit $status
  402.   fi
  403. fi
  404.       fi
  405.       if test "$compiler_o_lo" = yes; then
  406. output_obj="$libobj"
  407. command="$command -o $output_obj"
  408.       elif test "$compiler_c_o" = yes; then
  409. output_obj="$obj"
  410. command="$command -o $output_obj"
  411.       fi
  412.       $run $rm "$output_obj"
  413.       $show "$command"
  414.       if $run eval "$command"; then :
  415.       else
  416. test -n "$output_obj" && $run $rm $removelist
  417. exit 1
  418.       fi
  419.       if test "$need_locks" = warn &&
  420.  test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
  421. echo "
  422. *** ERROR, $lockfile contains:
  423. `cat $lockfile 2>/dev/null`
  424. but it should contain:
  425. $srcfile
  426. This indicates that another process is trying to use the same
  427. temporary object file, and libtool could not work around it because
  428. your compiler does not support `-c' and `-o' together.  If you
  429. repeat this compilation, it may succeed, by chance, but you had better
  430. avoid parallel builds (make -j) in this platform, or get a better
  431. compiler."
  432. $run $rm $removelist
  433. exit 1
  434.       fi
  435.       # Just move the object if needed, then go on to compile the next one
  436.       if test x"$output_obj" != x"$libobj"; then
  437. $show "$mv $output_obj $libobj"
  438. if $run $mv $output_obj $libobj; then :
  439. else
  440.   error=$?
  441.   $run $rm $removelist
  442.   exit $error
  443. fi
  444.       fi
  445.       # If we have no pic_flag, then copy the object into place and finish.
  446.       if test -z "$pic_flag" && test "$build_old_libs" = yes; then
  447. # Rename the .lo from within objdir to obj
  448. if test -f $obj; then
  449.   $show $rm $obj
  450.   $run $rm $obj
  451. fi
  452. $show "$mv $libobj $obj"
  453. if $run $mv $libobj $obj; then :
  454. else
  455.   error=$?
  456.   $run $rm $removelist
  457.   exit $error
  458. fi
  459. # Now arrange that obj and lo_libobj become the same file
  460. $show "$LN_S $obj $lo_libobj"
  461. if $run $LN_S $obj $lo_libobj; then
  462.   exit 0
  463. else
  464.   error=$?
  465.   $run $rm $removelist
  466.   exit $error
  467. fi
  468.       fi
  469.       # Allow error messages only from the first compilation.
  470.       suppress_output=' >/dev/null 2>&1'
  471.     fi
  472.     # Only build a position-dependent object if we build old libraries.
  473.     if test "$build_old_libs" = yes; then
  474.       command="$base_compile $srcfile"
  475.       if test "$compiler_c_o" = yes; then
  476. command="$command -o $obj"
  477. output_obj="$obj"
  478.       fi
  479.       # Suppress compiler output if we already did a PIC compilation.
  480.       command="$command$suppress_output"
  481.       $run $rm "$output_obj"
  482.       $show "$command"
  483.       if $run eval "$command"; then :
  484.       else
  485. $run $rm $removelist
  486. exit 1
  487.       fi
  488.       if test "$need_locks" = warn &&
  489.  test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
  490. echo "
  491. *** ERROR, $lockfile contains:
  492. `cat $lockfile 2>/dev/null`
  493. but it should contain:
  494. $srcfile
  495. This indicates that another process is trying to use the same
  496. temporary object file, and libtool could not work around it because
  497. your compiler does not support `-c' and `-o' together.  If you
  498. repeat this compilation, it may succeed, by chance, but you had better
  499. avoid parallel builds (make -j) in this platform, or get a better
  500. compiler."
  501. $run $rm $removelist
  502. exit 1
  503.       fi
  504.       # Just move the object if needed
  505.       if test x"$output_obj" != x"$obj"; then
  506. $show "$mv $output_obj $obj"
  507. if $run $mv $output_obj $obj; then :
  508. else
  509.   error=$?
  510.   $run $rm $removelist
  511.   exit $error
  512. fi
  513.       fi
  514.       # Create an invalid libtool object if no PIC, so that we do not
  515.       # accidentally link it into a program.
  516.       if test "$build_libtool_libs" != yes; then
  517. $show "echo timestamp > $libobj"
  518. $run eval "echo timestamp > $libobj" || exit $?
  519.       else
  520. # Move the .lo from within objdir
  521. $show "$mv $libobj $lo_libobj"
  522. if $run $mv $libobj $lo_libobj; then :
  523. else
  524.   error=$?
  525.   $run $rm $removelist
  526.   exit $error
  527. fi
  528.       fi
  529.     fi
  530.     # Unlock the critical section if it was locked
  531.     if test "$need_locks" != no; then
  532.       $rm "$lockfile"
  533.     fi
  534.     exit 0
  535.     ;;
  536.   # libtool link mode
  537.   link)
  538.     modename="$modename: link"
  539.     C_compiler="$CC" # save it, to compile generated C sources
  540.     CC="$nonopt"
  541.     case "$host" in
  542.     *-*-cygwin* | *-*-mingw* | *-*-os2*)
  543.       # It is impossible to link a dll without this setting, and
  544.       # we shouldn't force the makefile maintainer to figure out
  545.       # which system we are compiling for in order to pass an extra
  546.       # flag for every libtool invokation.
  547.       # allow_undefined=no
  548.       # FIXME: Unfortunately, there are problems with the above when trying
  549.       # to make a dll which has undefined symbols, in which case not
  550.       # even a static library is built.  For now, we need to specify
  551.       # -no-undefined on the libtool link line when we can be certain
  552.       # that all symbols are satisfied, otherwise we get a static library.
  553.       allow_undefined=yes
  554.       # This is a source program that is used to create dlls on Windows
  555.       # Don't remove nor modify the starting and closing comments
  556. # /* ltdll.c starts here */
  557. # #define WIN32_LEAN_AND_MEAN
  558. # #include <windows.h>
  559. # #undef WIN32_LEAN_AND_MEAN
  560. # #include <stdio.h>
  561. #
  562. # #ifndef __CYGWIN__
  563. # #  ifdef __CYGWIN32__
  564. # #    define __CYGWIN__ __CYGWIN32__
  565. # #  endif
  566. # #endif
  567. #
  568. # #ifdef __cplusplus
  569. # extern "C" {
  570. # #endif
  571. # BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
  572. # #ifdef __cplusplus
  573. # }
  574. # #endif
  575. #
  576. # #ifdef __CYGWIN__
  577. # #include <cygwin/cygwin_dll.h>
  578. # DECLARE_CYGWIN_DLL( DllMain );
  579. # #endif
  580. # HINSTANCE __hDllInstance_base;
  581. #
  582. # BOOL APIENTRY
  583. # DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
  584. # {
  585. #   __hDllInstance_base = hInst;
  586. #   return TRUE;
  587. # }
  588. # /* ltdll.c ends here */
  589.       # This is a source program that is used to create import libraries
  590.       # on Windows for dlls which lack them. Don't remove nor modify the
  591.       # starting and closing comments
  592. # /* impgen.c starts here */
  593. # /*   Copyright (C) 1999 Free Software Foundation, Inc.
  594. #  This file is part of GNU libtool.
  595. #  This program is free software; you can redistribute it and/or modify
  596. #  it under the terms of the GNU General Public License as published by
  597. #  the Free Software Foundation; either version 2 of the License, or
  598. #  (at your option) any later version.
  599. #  This program is distributed in the hope that it will be useful,
  600. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  601. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  602. #  GNU General Public License for more details.
  603. #  You should have received a copy of the GNU General Public License
  604. #  along with this program; if not, write to the Free Software
  605. #  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  606. #  */
  607. #  #include <stdio.h> /* for printf() */
  608. #  #include <unistd.h> /* for open(), lseek(), read() */
  609. #  #include <fcntl.h> /* for O_RDONLY, O_BINARY */
  610. #  #include <string.h> /* for strdup() */
  611. #  static unsigned int
  612. #  pe_get16 (fd, offset)
  613. #       int fd;
  614. #       int offset;
  615. #  {
  616. #    unsigned char b[2];
  617. #    lseek (fd, offset, SEEK_SET);
  618. #    read (fd, b, 2);
  619. #    return b[0] + (b[1]<<8);
  620. #  }
  621. #  static unsigned int
  622. #  pe_get32 (fd, offset)
  623. #      int fd;
  624. #      int offset;
  625. #  {
  626. #    unsigned char b[4];
  627. #    lseek (fd, offset, SEEK_SET);
  628. #    read (fd, b, 4);
  629. #    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
  630. #  }
  631. #  static unsigned int
  632. #  pe_as32 (ptr)
  633. #       void *ptr;
  634. #  {
  635. #    unsigned char *b = ptr;
  636. #    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
  637. #  }
  638. #  int
  639. #  main (argc, argv)
  640. #      int argc;
  641. #      char *argv[];
  642. #  {
  643. #      int dll;
  644. #      unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
  645. #      unsigned long export_rva, export_size, nsections, secptr, expptr;
  646. #      unsigned long name_rvas, nexp;
  647. #      unsigned char *expdata, *erva;
  648. #      char *filename, *dll_name;
  649. #      filename = argv[1];
  650. #      dll = open(filename, O_RDONLY|O_BINARY);
  651. #      if (!dll)
  652. #   return 1;
  653. #      dll_name = filename;
  654. #    
  655. #      for (i=0; filename[i]; i++)
  656. #   if (filename[i] == '/' || filename[i] == '\'  || filename[i] == ':')
  657. #       dll_name = filename + i +1;
  658. #      pe_header_offset = pe_get32 (dll, 0x3c);
  659. #      opthdr_ofs = pe_header_offset + 4 + 20;
  660. #      num_entries = pe_get32 (dll, opthdr_ofs + 92);
  661. #      if (num_entries < 1) /* no exports */
  662. #   return 1;
  663. #      export_rva = pe_get32 (dll, opthdr_ofs + 96);
  664. #      export_size = pe_get32 (dll, opthdr_ofs + 100);
  665. #      nsections = pe_get16 (dll, pe_header_offset + 4 +2);
  666. #      secptr = (pe_header_offset + 4 + 20 +
  667. #         pe_get16 (dll, pe_header_offset + 4 + 16));
  668. #      expptr = 0;
  669. #      for (i = 0; i < nsections; i++)
  670. #      {
  671. #   char sname[8];
  672. #   unsigned long secptr1 = secptr + 40 * i;
  673. #   unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
  674. #   unsigned long vsize = pe_get32 (dll, secptr1 + 16);
  675. #   unsigned long fptr = pe_get32 (dll, secptr1 + 20);
  676. #   lseek(dll, secptr1, SEEK_SET);
  677. #   read(dll, sname, 8);
  678. #   if (vaddr <= export_rva && vaddr+vsize > export_rva)
  679. #   {
  680. #       expptr = fptr + (export_rva - vaddr);
  681. #       if (export_rva + export_size > vaddr + vsize)
  682. #   export_size = vsize - (export_rva - vaddr);
  683. #       break;
  684. #   }
  685. #      }
  686. #      expdata = (unsigned char*)malloc(export_size);
  687. #      lseek (dll, expptr, SEEK_SET);
  688. #      read (dll, expdata, export_size);
  689. #      erva = expdata - export_rva;
  690. #      nexp = pe_as32 (expdata+24);
  691. #      name_rvas = pe_as32 (expdata+32);
  692. #      printf ("EXPORTSn");
  693. #      for (i = 0; i<nexp; i++)
  694. #      {
  695. #   unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
  696. #   printf ("t%s @ %ld ;n", erva+name_rva, 1+ i);
  697. #      }
  698. #      return 0;
  699. #  }
  700. # /* impgen.c ends here */
  701.       ;;
  702.     *)
  703.       allow_undefined=yes
  704.       ;;
  705.     esac
  706.     compile_command="$CC"
  707.     finalize_command="$CC"
  708.     compile_rpath=
  709.     finalize_rpath=
  710.     compile_shlibpath=
  711.     finalize_shlibpath=
  712.     convenience=
  713.     old_convenience=
  714.     deplibs=
  715.     linkopts=
  716.     if test -n "$shlibpath_var"; then
  717.       # get the directories listed in $shlibpath_var
  718.       eval lib_search_path=`$echo "X ${$shlibpath_var}" | $Xsed -e 's/:/ /g'`
  719.     else
  720.       lib_search_path=
  721.     fi
  722.     # now prepend the system-specific ones
  723.     eval lib_search_path="$sys_lib_search_path_spec$lib_search_path"
  724.     eval sys_lib_dlsearch_path="$sys_lib_dlsearch_path_spec"
  725.     
  726.     avoid_version=no
  727.     dlfiles=
  728.     dlprefiles=
  729.     dlself=no
  730.     export_dynamic=no
  731.     export_symbols=
  732.     export_symbols_regex=
  733.     generated=
  734.     libobjs=
  735.     link_against_libtool_libs=
  736.     ltlibs=
  737.     module=no
  738.     objs=
  739.     prefer_static_libs=no
  740.     preload=no
  741.     prev=
  742.     prevarg=
  743.     release=
  744.     rpath=
  745.     xrpath=
  746.     perm_rpath=
  747.     temp_rpath=
  748.     thread_safe=no
  749.     vinfo=
  750.     # We need to know -static, to get the right output filenames.
  751.     for arg
  752.     do
  753.       case "$arg" in
  754.       -all-static | -static)
  755. if test "X$arg" = "X-all-static"; then
  756.   if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
  757.     $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
  758.   fi
  759.   if test -n "$link_static_flag"; then
  760.     dlopen_self=$dlopen_self_static
  761.   fi
  762. else
  763.   if test -z "$pic_flag" && test -n "$link_static_flag"; then
  764.     dlopen_self=$dlopen_self_static
  765.   fi
  766. fi
  767. build_libtool_libs=no
  768. build_old_libs=yes
  769. prefer_static_libs=yes
  770. break
  771. ;;
  772.       esac
  773.     done
  774.     # See if our shared archives depend on static archives.
  775.     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
  776.     # Go through the arguments, transforming them on the way.
  777.     while test $# -gt 0; do
  778.       arg="$1"
  779.       shift
  780.       # If the previous option needs an argument, assign it.
  781.       if test -n "$prev"; then
  782. case "$prev" in
  783. output)
  784.   compile_command="$compile_command @OUTPUT@"
  785.   finalize_command="$finalize_command @OUTPUT@"
  786.   ;;
  787. esac
  788. case "$prev" in
  789. dlfiles|dlprefiles)
  790.   if test "$preload" = no; then
  791.     # Add the symbol object into the linking commands.
  792.     compile_command="$compile_command @SYMFILE@"
  793.     finalize_command="$finalize_command @SYMFILE@"
  794.     preload=yes
  795.   fi
  796.   case "$arg" in
  797.   *.la | *.lo) ;;  # We handle these cases below.
  798.   force)
  799.     if test "$dlself" = no; then
  800.       dlself=needless
  801.       export_dynamic=yes
  802.     fi
  803.     prev=
  804.     continue
  805.     ;;
  806.   self)
  807.     if test "$prev" = dlprefiles; then
  808.       dlself=yes
  809.     elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
  810.       dlself=yes
  811.     else
  812.       dlself=needless
  813.       export_dynamic=yes
  814.     fi
  815.     prev=
  816.     continue
  817.     ;;
  818.   *)
  819.     if test "$prev" = dlfiles; then
  820.       dlfiles="$dlfiles $arg"
  821.     else
  822.       dlprefiles="$dlprefiles $arg"
  823.     fi
  824.     prev=
  825.     ;;
  826.   esac
  827.   ;;
  828. expsyms)
  829.   export_symbols="$arg"
  830.   if test ! -f "$arg"; then
  831.     $echo "$modename: symbol file `$arg' does not exist"
  832.     exit 1
  833.   fi
  834.   prev=
  835.   continue
  836.   ;;
  837. expsyms_regex)
  838.   export_symbols_regex="$arg"
  839.   prev=
  840.   continue
  841.   ;;
  842. release)
  843.   release="-$arg"
  844.   prev=
  845.   continue
  846.   ;;
  847. rpath | xrpath)
  848.   # We need an absolute path.
  849.   case "$arg" in
  850.   [\/]* | [A-Za-z]:[\/]*) ;;
  851.   *)
  852.     $echo "$modename: only absolute run-paths are allowed" 1>&2
  853.     exit 1
  854.     ;;
  855.   esac
  856.   if test "$prev" = rpath; then
  857.     case "$rpath " in
  858.     *" $arg "*) ;;
  859.     *) rpath="$rpath $arg" ;;
  860.     esac
  861.   else
  862.     case "$xrpath " in
  863.     *" $arg "*) ;;
  864.     *) xrpath="$xrpath $arg" ;;
  865.     esac
  866.   fi
  867.   prev=
  868.   continue
  869.   ;;
  870. *)
  871.   eval "$prev="$arg""
  872.   prev=
  873.   continue
  874.   ;;
  875. esac
  876.       fi
  877.       prevarg="$arg"
  878.       case "$arg" in
  879.       -all-static)
  880. if test -n "$link_static_flag"; then
  881.   compile_command="$compile_command $link_static_flag"
  882.   finalize_command="$finalize_command $link_static_flag"
  883. fi
  884. continue
  885. ;;
  886.       -allow-undefined)
  887. # FIXME: remove this flag sometime in the future.
  888. $echo "$modename: `-allow-undefined' is deprecated because it is the default" 1>&2
  889. continue
  890. ;;
  891.       -avoid-version)
  892. avoid_version=yes
  893. continue
  894. ;;
  895.       -dlopen)
  896. prev=dlfiles
  897. continue
  898. ;;
  899.       -dlpreopen)
  900. prev=dlprefiles
  901. continue
  902. ;;
  903.       -export-dynamic)
  904. export_dynamic=yes
  905. continue
  906. ;;
  907.       -export-symbols | -export-symbols-regex)
  908. if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
  909.   $echo "$modename: not more than one -exported-symbols argument allowed"
  910.   exit 1
  911. fi
  912. if test "X$arg" = "X-export-symbols"; then
  913.   prev=expsyms
  914. else
  915.   prev=expsyms_regex
  916. fi
  917. continue
  918. ;;
  919.       -L*)
  920. dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
  921. # We need an absolute path.
  922. case "$dir" in
  923. [\/]* | [A-Za-z]:[\/]*) ;;
  924. *)
  925.   absdir=`cd "$dir" && pwd`
  926.   if test -z "$absdir"; then
  927.     $echo "$modename: warning: cannot determine absolute directory name of `$dir'" 1>&2
  928.     $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
  929.     absdir="$dir"
  930.   fi
  931.   dir="$absdir"
  932.   ;;
  933. esac
  934. case " $deplibs " in
  935. *" $arg "*) ;;
  936. *) deplibs="$deplibs $arg";;
  937. esac
  938. case " $lib_search_path " in
  939. *" $dir "*) ;;
  940. *) lib_search_path="$lib_search_path $dir";;
  941. esac
  942. case "$host" in
  943. *-*-cygwin* | *-*-mingw* | *-*-os2*)
  944.   dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
  945.   case ":$dllsearchpath:" in
  946.   ::) dllsearchpath="$dllsearchdir";;
  947.   *":$dllsearchdir:"*) ;;
  948.   *) dllsearchpath="$dllsearchpath:$dllsearchdir";;
  949.   esac
  950.   ;;
  951. esac
  952. ;;
  953.       -l*)
  954. if test "$arg" = "-lc"; then
  955.   case "$host" in
  956.   *-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
  957.     # These systems don't actually have c library (as such)
  958.     continue
  959.     ;;
  960.   esac
  961. elif test "$arg" = "-lm"; then
  962.   case "$host" in
  963.   *-*-cygwin* | *-*-beos*)
  964.     # These systems don't actually have math library (as such)
  965.     continue
  966.     ;;
  967.   esac
  968. fi
  969. deplibs="$deplibs $arg"
  970. ;;
  971.       -module)
  972. module=yes
  973. continue
  974. ;;
  975.       -no-undefined)
  976. allow_undefined=no
  977. continue
  978. ;;
  979.       -o) prev=output ;;
  980.       -release)
  981. prev=release
  982. continue
  983. ;;
  984.       -rpath)
  985. prev=rpath
  986. continue
  987. ;;
  988.       -R)
  989. prev=xrpath
  990. continue
  991. ;;
  992.       -R*)
  993. dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
  994. # We need an absolute path.
  995. case "$dir" in
  996. [\/]* | [A-Za-z]:[\/]*) ;;
  997. *)
  998.   $echo "$modename: only absolute run-paths are allowed" 1>&2
  999.   exit 1
  1000.   ;;
  1001. esac
  1002. case "$xrpath " in
  1003. *" $dir "*) ;;
  1004. *) xrpath="$xrpath $dir" ;;
  1005. esac
  1006. continue
  1007. ;;
  1008.       -static)
  1009. # If we have no pic_flag, then this is the same as -all-static.
  1010. if test -z "$pic_flag" && test -n "$link_static_flag"; then
  1011.   compile_command="$compile_command $link_static_flag"
  1012.   finalize_command="$finalize_command $link_static_flag"
  1013. fi
  1014. continue
  1015. ;;
  1016.       -thread-safe)
  1017. thread_safe=yes
  1018. continue
  1019. ;;
  1020.       -version-info)
  1021. prev=vinfo
  1022. continue
  1023. ;;
  1024.       # Some other compiler flag.
  1025.       -* | +*)
  1026. # Unknown arguments in both finalize_command and compile_command need
  1027. # to be aesthetically quoted because they are evaled later.
  1028. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1029. case "$arg" in
  1030. *[[~#^&*(){}|;<>?'  ]*|*]*)
  1031.   arg=""$arg""
  1032.   ;;
  1033. esac
  1034. ;;
  1035.       *.o | *.obj | *.a | *.lib)
  1036. # A standard object.
  1037. objs="$objs $arg"
  1038. ;;
  1039.       *.lo)
  1040. # A library object.
  1041. if test "$prev" = dlfiles; then
  1042.   dlfiles="$dlfiles $arg"
  1043.   if test "$build_libtool_libs" = yes && test "$dlopen" = yes; then
  1044.     prev=
  1045.     continue
  1046.   else
  1047.     # If libtool objects are unsupported, then we need to preload.
  1048.     prev=dlprefiles
  1049.   fi
  1050. fi
  1051. if test "$prev" = dlprefiles; then
  1052.   # Preload the old-style object.
  1053.   dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
  1054.   prev=
  1055. fi
  1056. libobjs="$libobjs $arg"
  1057. ;;
  1058.       *.la)
  1059. # A libtool-controlled library.
  1060. dlname=
  1061. libdir=
  1062. library_names=
  1063. old_library=
  1064. # Check to see that this really is a libtool archive.
  1065. if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
  1066. else
  1067.   $echo "$modename: `$arg' is not a valid libtool archive" 1>&2
  1068.   exit 1
  1069. fi
  1070. # If the library was installed with an old release of libtool,
  1071. # it will not redefine variable installed.
  1072. installed=yes
  1073. # Read the .la file
  1074. # If there is no directory component, then add one.
  1075. case "$arg" in
  1076. */* | *\*) . $arg ;;
  1077. *) . ./$arg ;;
  1078. esac
  1079. # Get the name of the library we link against.
  1080. linklib=
  1081. for l in $old_library $library_names; do
  1082.   linklib="$l"
  1083. done
  1084. if test -z "$linklib"; then
  1085.   $echo "$modename: cannot find name of link library for `$arg'" 1>&2
  1086.   exit 1
  1087. fi
  1088. # Find the relevant object directory and library name.
  1089. name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/.la$//' -e 's/^lib//'`
  1090. if test "X$installed" = Xyes; then
  1091.   dir="$libdir"
  1092. else
  1093.   dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
  1094.   if test "X$dir" = "X$arg"; then
  1095.     dir="$objdir"
  1096.   else
  1097.     dir="$dir/$objdir"
  1098.   fi
  1099. fi
  1100. if test -n "$dependency_libs"; then
  1101.   # Extract -R and -L from dependency_libs
  1102.   temp_deplibs=
  1103.   for deplib in $dependency_libs; do
  1104.     case "$deplib" in
  1105.     -R*) temp_xrpath=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
  1106.  case " $rpath $xrpath " in
  1107.  *" $temp_xrpath "*) ;;
  1108.  *) xrpath="$xrpath $temp_xrpath";;
  1109.  esac;;
  1110.     -L*) case "$compile_command $temp_deplibs " in
  1111.  *" $deplib "*) ;;
  1112.  *) temp_deplibs="$temp_deplibs $deplib";;
  1113.  esac
  1114.  temp_dir=`$echo "X$deplib" | $Xsed -e 's/^-L//'`
  1115.  case " $lib_search_path " in
  1116.  *" $temp_dir "*) ;;
  1117.  *) lib_search_path="$lib_search_path $temp_dir";;
  1118.  esac
  1119.  ;;
  1120.     *) temp_deplibs="$temp_deplibs $deplib";;
  1121.     esac
  1122.   done
  1123.   dependency_libs="$temp_deplibs"
  1124. fi
  1125. if test -z "$libdir"; then
  1126.   # It is a libtool convenience library, so add in its objects.
  1127.   convenience="$convenience $dir/$old_library"
  1128.   old_convenience="$old_convenience $dir/$old_library"
  1129.   deplibs="$deplibs$dependency_libs"
  1130.   compile_command="$compile_command $dir/$old_library$dependency_libs"
  1131.   finalize_command="$finalize_command $dir/$old_library$dependency_libs"
  1132.   continue
  1133. fi
  1134. # This library was specified with -dlopen.
  1135. if test "$prev" = dlfiles; then
  1136.   dlfiles="$dlfiles $arg"
  1137.   if test -z "$dlname" || test "$dlopen" != yes || test "$build_libtool_libs" = no; then
  1138.     # If there is no dlname, no dlopen support or we're linking statically,
  1139.     # we need to preload.
  1140.     prev=dlprefiles
  1141.   else
  1142.     # We should not create a dependency on this library, but we
  1143.     # may need any libraries it requires.
  1144.     compile_command="$compile_command$dependency_libs"
  1145.     finalize_command="$finalize_command$dependency_libs"
  1146.     prev=
  1147.     continue
  1148.   fi
  1149. fi
  1150. # The library was specified with -dlpreopen.
  1151. if test "$prev" = dlprefiles; then
  1152.   # Prefer using a static library (so that no silly _DYNAMIC symbols
  1153.   # are required to link).
  1154.   if test -n "$old_library"; then
  1155.     dlprefiles="$dlprefiles $dir/$old_library"
  1156.   else
  1157.     dlprefiles="$dlprefiles $dir/$linklib"
  1158.   fi
  1159.   prev=
  1160. fi
  1161. if test -n "$library_names" &&
  1162.    { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
  1163.   link_against_libtool_libs="$link_against_libtool_libs $arg"
  1164.   if test -n "$shlibpath_var"; then
  1165.     # Make sure the rpath contains only unique directories.
  1166.     case "$temp_rpath " in
  1167.     *" $dir "*) ;;
  1168.     *) temp_rpath="$temp_rpath $dir" ;;
  1169.     esac
  1170.   fi
  1171.   # We need an absolute path.
  1172.   case "$dir" in
  1173.   [\/] | [A-Za-z]:[\/]*) absdir="$dir" ;;
  1174.   *)
  1175.     absdir=`cd "$dir" && pwd`
  1176.     if test -z "$absdir"; then
  1177.       $echo "$modename: warning: cannot determine absolute directory name of `$dir'" 1>&2
  1178.       $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
  1179.       absdir="$dir"
  1180.     fi
  1181.     ;;
  1182.   esac
  1183.   
  1184.   # This is the magic to use -rpath.
  1185.   # Skip directories that are in the system default run-time
  1186.   # search path, unless they have been requested with -R.
  1187.   case " $sys_lib_dlsearch_path " in
  1188.   *" $absdir "*) ;;
  1189.   *)
  1190.     case "$compile_rpath " in
  1191.     *" $absdir "*) ;;
  1192.     *) compile_rpath="$compile_rpath $absdir" 
  1193.     esac
  1194.     ;;
  1195.   esac
  1196.   case " $sys_lib_dlsearch_path " in
  1197.   *" $libdir "*) ;;
  1198.   *)
  1199.     case "$finalize_rpath " in
  1200.     *" $libdir "*) ;;
  1201.     *) finalize_rpath="$finalize_rpath $libdir"
  1202.     esac
  1203.     ;;
  1204.   esac
  1205.   lib_linked=yes
  1206.   case "$hardcode_action" in
  1207.   immediate | unsupported)
  1208.     if test "$hardcode_direct" = no; then
  1209.       compile_command="$compile_command $dir/$linklib"
  1210.       deplibs="$deplibs $dir/$linklib"
  1211.       case "$host" in
  1212.       *-*-cygwin* | *-*-mingw* | *-*-os2*)
  1213. dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
  1214. if test -n "$dllsearchpath"; then
  1215.   dllsearchpath="$dllsearchpath:$dllsearchdir"
  1216. else
  1217.   dllsearchpath="$dllsearchdir"
  1218. fi
  1219. ;;
  1220.       esac
  1221.     elif test "$hardcode_minus_L" = no; then
  1222.       case "$host" in
  1223.       *-*-sunos*)
  1224. compile_shlibpath="$compile_shlibpath$dir:"
  1225. ;;
  1226.       esac
  1227.       case "$compile_command " in
  1228.       *" -L$dir "*) ;;
  1229.       *) compile_command="$compile_command -L$dir";;
  1230.       esac
  1231.       compile_command="$compile_command -l$name"
  1232.       deplibs="$deplibs -L$dir -l$name"
  1233.     elif test "$hardcode_shlibpath_var" = no; then
  1234.       case ":$compile_shlibpath:" in
  1235.       *":$dir:"*) ;;
  1236.       *) compile_shlibpath="$compile_shlibpath$dir:";;
  1237.       esac
  1238.       compile_command="$compile_command -l$name"
  1239.       deplibs="$deplibs -l$name"
  1240.     else
  1241.       lib_linked=no
  1242.     fi
  1243.     ;;
  1244.   relink)
  1245.     if test "$hardcode_direct" = yes; then
  1246.       compile_command="$compile_command $absdir/$linklib"
  1247.       deplibs="$deplibs $absdir/$linklib"
  1248.     elif test "$hardcode_minus_L" = yes; then
  1249.       case "$compile_command " in
  1250.       *" -L$absdir "*) ;;
  1251.       *) compile_command="$compile_command -L$absdir";;
  1252.       esac
  1253.       compile_command="$compile_command -l$name"
  1254.       deplibs="$deplibs -L$absdir -l$name"
  1255.     elif test "$hardcode_shlibpath_var" = yes; then
  1256.       case ":$compile_shlibpath:" in
  1257.       *":$absdir:"*) ;;
  1258.       *) compile_shlibpath="$compile_shlibpath$absdir:";;
  1259.       esac
  1260.       compile_command="$compile_command -l$name"
  1261.       deplibs="$deplibs -l$name"
  1262.     else
  1263.       lib_linked=no
  1264.     fi
  1265.     ;;
  1266.   *)
  1267.     lib_linked=no
  1268.     ;;
  1269.   esac
  1270.   if test "$lib_linked" != yes; then
  1271.     $echo "$modename: configuration error: unsupported hardcode properties"
  1272.     exit 1
  1273.   fi
  1274.   # Finalize command for both is simple: just hardcode it.
  1275.   if test "$hardcode_direct" = yes; then
  1276.     finalize_command="$finalize_command $libdir/$linklib"
  1277.   elif test "$hardcode_minus_L" = yes; then
  1278.     case "$finalize_command " in
  1279.     *" -L$libdir "*) ;;
  1280.     *) finalize_command="$finalize_command -L$libdir";;
  1281.     esac
  1282.     finalize_command="$finalize_command -l$name"
  1283.   elif test "$hardcode_shlibpath_var" = yes; then
  1284.     case ":$finalize_shlibpath:" in
  1285.     *":$libdir:"*) ;;
  1286.     *) finalize_shlibpath="$finalize_shlibpath$libdir:";;
  1287.     esac
  1288.     finalize_command="$finalize_command -l$name"
  1289.   else
  1290.     # We cannot seem to hardcode it, guess we'll fake it.
  1291.     case "$finalize_command " in
  1292.     *" -L$dir "*) ;;
  1293.     *) finalize_command="$finalize_command -L$libdir";;
  1294.     esac
  1295.     finalize_command="$finalize_command -l$name"
  1296.   fi
  1297. else
  1298.   # Transform directly to old archives if we don't build new libraries.
  1299.   if test -n "$pic_flag" && test -z "$old_library"; then
  1300.     $echo "$modename: cannot find static library for `$arg'" 1>&2
  1301.     exit 1
  1302.   fi
  1303.   # Here we assume that one of hardcode_direct or hardcode_minus_L
  1304.   # is not unsupported.  This is valid on all known static and
  1305.   # shared platforms.
  1306.   if test "$hardcode_direct" != unsupported; then
  1307.     test -n "$old_library" && linklib="$old_library"
  1308.     compile_command="$compile_command $dir/$linklib"
  1309.     finalize_command="$finalize_command $dir/$linklib"
  1310.   else
  1311.     case "$compile_command " in
  1312.     *" -L$dir "*) ;;
  1313.     *) compile_command="$compile_command -L$dir";;
  1314.     esac
  1315.     compile_command="$compile_command -l$name"
  1316.     case "$finalize_command " in
  1317.     *" -L$dir "*) ;;
  1318.     *) finalize_command="$finalize_command -L$dir";;
  1319.     esac
  1320.     finalize_command="$finalize_command -l$name"
  1321.   fi
  1322. fi
  1323. # Add in any libraries that this one depends upon.
  1324. compile_command="$compile_command$dependency_libs"
  1325. finalize_command="$finalize_command$dependency_libs"
  1326. continue
  1327. ;;
  1328.       # Some other compiler argument.
  1329.       *)
  1330. # Unknown arguments in both finalize_command and compile_command need
  1331. # to be aesthetically quoted because they are evaled later.
  1332. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1333. case "$arg" in
  1334. *[[~#^&*(){}|;<>?'  ]*|*]*)
  1335.   arg=""$arg""
  1336.   ;;
  1337. esac
  1338. ;;
  1339.       esac
  1340.       # Now actually substitute the argument into the commands.
  1341.       if test -n "$arg"; then
  1342. compile_command="$compile_command $arg"
  1343. finalize_command="$finalize_command $arg"
  1344.       fi
  1345.     done
  1346.     if test -n "$prev"; then
  1347.       $echo "$modename: the `$prevarg' option requires an argument" 1>&2
  1348.       $echo "$help" 1>&2
  1349.       exit 1
  1350.     fi
  1351.     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
  1352.       eval arg="$export_dynamic_flag_spec"
  1353.       compile_command="$compile_command $arg"
  1354.       finalize_command="$finalize_command $arg"
  1355.     fi
  1356.     oldlibs=
  1357.     # calculate the name of the file, without its directory
  1358.     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
  1359.     libobjs_save="$libobjs"
  1360.     case "$output" in
  1361.     "")
  1362.       $echo "$modename: you must specify an output file" 1>&2
  1363.       $echo "$help" 1>&2
  1364.       exit 1
  1365.       ;;
  1366.     *.a | *.lib)
  1367.       if test -n "$link_against_libtool_libs"; then
  1368. $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
  1369. exit 1
  1370.       fi
  1371.       if test -n "$deplibs"; then
  1372. $echo "$modename: warning: `-l' and `-L' are ignored for archives" 1>&2
  1373.       fi
  1374.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  1375. $echo "$modename: warning: `-dlopen' is ignored for archives" 1>&2
  1376.       fi
  1377.       if test -n "$rpath"; then
  1378. $echo "$modename: warning: `-rpath' is ignored for archives" 1>&2
  1379.       fi
  1380.       if test -n "$xrpath"; then
  1381. $echo "$modename: warning: `-R' is ignored for archives" 1>&2
  1382.       fi
  1383.       if test -n "$vinfo"; then
  1384. $echo "$modename: warning: `-version-info' is ignored for archives" 1>&2
  1385.       fi
  1386.       if test -n "$release"; then
  1387. $echo "$modename: warning: `-release' is ignored for archives" 1>&2
  1388.       fi
  1389.       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
  1390. $echo "$modename: warning: `-export-symbols' is ignored for archives" 1>&2
  1391.       fi
  1392.       # Now set the variables for building old libraries.
  1393.       build_libtool_libs=no
  1394.       oldlibs="$output"
  1395.       ;;
  1396.     *.la)
  1397.       # Make sure we only generate libraries of the form `libNAME.la'.
  1398.       case "$outputname" in
  1399.       lib*)
  1400. name=`$echo "X$outputname" | $Xsed -e 's/.la$//' -e 's/^lib//'`
  1401. eval libname="$libname_spec"
  1402. ;;
  1403.       *)
  1404. if test "$module" = no; then
  1405.   $echo "$modename: libtool library `$output' must begin with `lib'" 1>&2
  1406.   $echo "$help" 1>&2
  1407.   exit 1
  1408. fi
  1409. if test "$need_lib_prefix" != no; then
  1410.   # Add the "lib" prefix for modules if required
  1411.   name=`$echo "X$outputname" | $Xsed -e 's/.la$//'`
  1412.   eval libname="$libname_spec"
  1413. else
  1414.   libname=`$echo "X$outputname" | $Xsed -e 's/.la$//'`
  1415. fi
  1416. ;;
  1417.       esac
  1418.       output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
  1419.       if test "X$output_objdir" = "X$output"; then
  1420. output_objdir="$objdir"
  1421.       else
  1422. output_objdir="$output_objdir/$objdir"
  1423.       fi
  1424.       if test -n "$objs"; then
  1425. $echo "$modename: cannot build libtool library `$output' from non-libtool objects:$objs" 2>&1
  1426. exit 1
  1427.       fi
  1428.       # How the heck are we supposed to write a wrapper for a shared library?
  1429.       if test -n "$link_against_libtool_libs"; then
  1430.  $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
  1431.  exit 1
  1432.       fi
  1433.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  1434. $echo "$modename: warning: `-dlopen' is ignored for libtool libraries" 1>&2
  1435.       fi
  1436.       set dummy $rpath
  1437.       if test $# -gt 2; then
  1438. $echo "$modename: warning: ignoring multiple `-rpath's for a libtool library" 1>&2
  1439.       fi
  1440.       install_libdir="$2"
  1441.       oldlibs=
  1442.       if test -z "$rpath"; then
  1443. if test "$build_libtool_libs" = yes; then
  1444.   # Building a libtool convenience library.
  1445.   libext=al
  1446.   oldlibs="$output_objdir/$libname.$libext $oldlibs"
  1447.   build_libtool_libs=convenience
  1448.   build_old_libs=yes
  1449. fi
  1450. dependency_libs="$deplibs"
  1451. if test -n "$vinfo"; then
  1452.   $echo "$modename: warning: `-version-info' is ignored for convenience libraries" 1>&2
  1453. fi
  1454. if test -n "$release"; then
  1455.   $echo "$modename: warning: `-release' is ignored for convenience libraries" 1>&2
  1456. fi
  1457.       else
  1458. # Parse the version information argument.
  1459. IFS="${IFS=  }"; save_ifs="$IFS"; IFS=':'
  1460. set dummy $vinfo 0 0 0
  1461. IFS="$save_ifs"
  1462. if test -n "$8"; then
  1463.   $echo "$modename: too many parameters to `-version-info'" 1>&2
  1464.   $echo "$help" 1>&2
  1465.   exit 1
  1466. fi
  1467. current="$2"
  1468. revision="$3"
  1469. age="$4"
  1470. # Check that each of the things are valid numbers.
  1471. case "$current" in
  1472. 0 | [1-9] | [1-9][0-9]*) ;;
  1473. *)
  1474.   $echo "$modename: CURRENT `$current' is not a nonnegative integer" 1>&2
  1475.   $echo "$modename: `$vinfo' is not valid version information" 1>&2
  1476.   exit 1
  1477.   ;;
  1478. esac
  1479. case "$revision" in
  1480. 0 | [1-9] | [1-9][0-9]*) ;;
  1481. *)
  1482.   $echo "$modename: REVISION `$revision' is not a nonnegative integer" 1>&2
  1483.   $echo "$modename: `$vinfo' is not valid version information" 1>&2
  1484.   exit 1
  1485.   ;;
  1486. esac
  1487. case "$age" in
  1488. 0 | [1-9] | [1-9][0-9]*) ;;
  1489. *)
  1490.   $echo "$modename: AGE `$age' is not a nonnegative integer" 1>&2
  1491.   $echo "$modename: `$vinfo' is not valid version information" 1>&2
  1492.   exit 1
  1493.   ;;
  1494. esac
  1495. if test $age -gt $current; then
  1496.   $echo "$modename: AGE `$age' is greater than the current interface number `$current'" 1>&2
  1497.   $echo "$modename: `$vinfo' is not valid version information" 1>&2
  1498.   exit 1
  1499. fi
  1500. # Calculate the version variables.
  1501. major=
  1502. versuffix=
  1503. verstring=
  1504. case "$version_type" in
  1505. none) ;;
  1506. irix)
  1507.   major=`expr $current - $age + 1`
  1508.   versuffix="$major.$revision"
  1509.   verstring="sgi$major.$revision"
  1510.   # Add in all the interfaces that we are compatible with.
  1511.   loop=$revision
  1512.   while test $loop != 0; do
  1513.     iface=`expr $revision - $loop`
  1514.     loop=`expr $loop - 1`
  1515.     verstring="sgi$major.$iface:$verstring"
  1516.   done
  1517.   ;;
  1518. linux)
  1519.   major=.`expr $current - $age`
  1520.   versuffix="$major.$age.$revision"
  1521.   ;;
  1522. osf)
  1523.   major=`expr $current - $age`
  1524.   versuffix=".$current.$age.$revision"
  1525.   verstring="$current.$age.$revision"
  1526.   # Add in all the interfaces that we are compatible with.
  1527.   loop=$age
  1528.   while test $loop != 0; do
  1529.     iface=`expr $current - $loop`
  1530.     loop=`expr $loop - 1`
  1531.     verstring="$verstring:${iface}.0"
  1532.   done
  1533.   # Make executables depend on our current version.
  1534.   verstring="$verstring:${current}.0"
  1535.   ;;
  1536. sunos)
  1537.   major=".$current"
  1538.   versuffix=".$current.$revision"
  1539.   ;;
  1540. freebsd-aout)
  1541.   major=".$current"
  1542.   versuffix=".$current.$revision";
  1543.   ;;
  1544. freebsd-elf)
  1545.   major=".$current"
  1546.   versuffix=".$current";
  1547.   ;;
  1548. windows)
  1549.   # Like Linux, but with '-' rather than '.', since we only
  1550.   # want one extension on Windows 95.
  1551.   major=`expr $current - $age`
  1552.   versuffix="-$major-$age-$revision"
  1553.   ;;
  1554. *)
  1555.   $echo "$modename: unknown library version type `$version_type'" 1>&2
  1556.   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  1557.   exit 1
  1558.   ;;
  1559. esac
  1560. # Clear the version info if we defaulted, and they specified a release.
  1561. if test -z "$vinfo" && test -n "$release"; then
  1562.   major=
  1563.   verstring="0.0"
  1564.   if test "$need_version" = no; then
  1565.     versuffix=
  1566.   else
  1567.     versuffix=".0.0"
  1568.   fi
  1569. fi
  1570. # Remove version info from name if versioning should be avoided
  1571. if test "$avoid_version" = yes && test "$need_version" = no; then
  1572.   major=
  1573.   versuffix=
  1574.   verstring=""
  1575. fi
  1576. # Check to see if the archive will have undefined symbols.
  1577. if test "$allow_undefined" = yes; then
  1578.   if test "$allow_undefined_flag" = unsupported; then
  1579.     $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
  1580.     build_libtool_libs=no
  1581.     build_old_libs=yes
  1582.   fi
  1583. else
  1584.   # Don't allow undefined symbols.
  1585.   allow_undefined_flag="$no_undefined_flag"
  1586. fi
  1587. dependency_libs="$deplibs"
  1588. case "$host" in
  1589. *-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
  1590.   # these systems don't actually have a c library (as such)!
  1591.   ;;
  1592. *)
  1593.   # Add libc to deplibs on all other systems.
  1594.   deplibs="$deplibs -lc"
  1595.   ;;
  1596. esac
  1597.       fi
  1598.       # Create the output directory, or remove our outputs if we need to.
  1599.       if test -d $output_objdir; then
  1600. $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
  1601. $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
  1602.       else
  1603. $show "$mkdir $output_objdir"
  1604. $run $mkdir $output_objdir
  1605. status=$?
  1606. if test $status -ne 0 && test ! -d $output_objdir; then
  1607.   exit $status
  1608. fi
  1609.       fi
  1610.       # Now set the variables for building old libraries.
  1611.       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
  1612. oldlibs="$oldlibs $output_objdir/$libname.$libext"
  1613. # Transform .lo files to .o files.
  1614. oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/.'${libext}'$/d' -e "$lo2o" | $NL2SP`
  1615.       fi
  1616.       if test "$build_libtool_libs" = yes; then
  1617. # Transform deplibs into only deplibs that can be linked in shared.
  1618. name_save=$name
  1619. libname_save=$libname
  1620. release_save=$release
  1621. versuffix_save=$versuffix
  1622. major_save=$major
  1623. # I'm not sure if I'm treating the release correctly.  I think
  1624. # release should show up in the -l (ie -lgmp5) so we don't want to
  1625. # add it in twice.  Is that correct?
  1626. release=""
  1627. versuffix=""
  1628. major=""
  1629. newdeplibs=
  1630. droppeddeps=no
  1631. case "$deplibs_check_method" in
  1632. pass_all)
  1633.   # Don't check for shared/static.  Everything works.
  1634.   # This might be a little naive.  We might want to check
  1635.   # whether the library exists or not.  But this is on
  1636.   # osf3 & osf4 and I'm not really sure... Just
  1637.   # implementing what was already the behaviour.
  1638.   newdeplibs=$deplibs
  1639.   ;;
  1640. test_compile)
  1641.   # This code stresses the "libraries are programs" paradigm to its
  1642.   # limits. Maybe even breaks it.  We compile a program, linking it
  1643.   # against the deplibs as a proxy for the library.  Then we can check
  1644.   # whether they linked in statically or dynamically with ldd.
  1645.   $rm conftest.c
  1646.   cat > conftest.c <<EOF
  1647.   int main() { return 0; }
  1648. EOF
  1649.   $rm conftest
  1650.   $C_compiler -o conftest conftest.c $deplibs
  1651.   if test $? -eq 0 ; then
  1652.     ldd_output=`ldd conftest`
  1653.     for i in $deplibs; do
  1654.       name="`expr $i : '-l(.*)'`"
  1655.       # If $name is empty we are operating on a -L argument.
  1656.       if test "$name" != "" ; then
  1657. libname=`eval \$echo "$libname_spec"`
  1658. deplib_matches=`eval \$echo "$library_names_spec"`
  1659. set dummy $deplib_matches
  1660. deplib_match=$2
  1661. if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  1662.   newdeplibs="$newdeplibs $i"
  1663. else
  1664.   droppeddeps=yes
  1665.   echo
  1666.   echo "*** Warning: This library needs some functionality provided by $i."
  1667.   echo "*** I have the capability to make that library automatically link in when"
  1668.   echo "*** you link to this library.  But I can only do this if you have a"
  1669.   echo "*** shared version of the library, which you do not appear to have."
  1670. fi
  1671.       else
  1672. newdeplibs="$newdeplibs $i"
  1673.       fi
  1674.     done
  1675.   else
  1676.     # Error occured in the first compile.  Let's try to salvage the situation:
  1677.     # Compile a seperate program for each library.
  1678.     for i in $deplibs; do
  1679.       name="`expr $i : '-l(.*)'`"
  1680.      # If $name is empty we are operating on a -L argument.
  1681.       if test "$name" != "" ; then
  1682. $rm conftest
  1683. $C_compiler -o conftest conftest.c $i
  1684. # Did it work?
  1685. if test $? -eq 0 ; then
  1686.   ldd_output=`ldd conftest`
  1687.   libname=`eval \$echo "$libname_spec"`
  1688.   deplib_matches=`eval \$echo "$library_names_spec"`
  1689.   set dummy $deplib_matches
  1690.   deplib_match=$2
  1691.   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  1692.     newdeplibs="$newdeplibs $i"
  1693.   else
  1694.     droppeddeps=yes
  1695.     echo
  1696.     echo "*** Warning: This library needs some functionality provided by $i."
  1697.     echo "*** I have the capability to make that library automatically link in when"
  1698.     echo "*** you link to this library.  But I can only do this if you have a"
  1699.     echo "*** shared version of the library, which you do not appear to have."
  1700.   fi
  1701. else
  1702.   droppeddeps=yes
  1703.   echo
  1704.   echo "*** Warning!  Library $i is needed by this library but I was not able to"
  1705.   echo "***  make it link in!  You will probably need to install it or some"
  1706.   echo "*** library that it depends on before this library will be fully"
  1707.   echo "*** functional.  Installing it before continuing would be even better."
  1708. fi
  1709.       else
  1710. newdeplibs="$newdeplibs $i"
  1711.       fi
  1712.     done
  1713.   fi
  1714.   ;;
  1715. file_magic*)
  1716.   set dummy $deplibs_check_method
  1717.   file_magic_regex="`expr "$deplibs_check_method" : "$2 (.*)"`"
  1718.   for a_deplib in $deplibs; do
  1719.     name="`expr $a_deplib : '-l(.*)'`"
  1720.     # If $name is empty we are operating on a -L argument.
  1721.     if test "$name" != "" ; then
  1722.       libname=`eval \$echo "$libname_spec"`
  1723.       for i in $lib_search_path; do
  1724.     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  1725.     for potent_lib in $potential_libs; do
  1726.       # Follow soft links.
  1727.       if ls -lLd "$potent_lib" 2>/dev/null 
  1728.  | grep " -> " >/dev/null; then
  1729. continue 
  1730.       fi
  1731.       # The statement above tries to avoid entering an
  1732.       # endless loop below, in case of cyclic links.
  1733.       # We might still enter an endless loop, since a link
  1734.       # loop can be closed while we follow links,
  1735.       # but so what?
  1736.       potlib="$potent_lib"
  1737.       while test -h "$potlib" 2>/dev/null; do
  1738. potliblink=`ls -ld $potlib | sed 's/.* -> //'`
  1739. case "$potliblink" in
  1740. [\/]* | [A-Za-z]:[\/]*) potlib="$potliblink";;
  1741. *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
  1742. esac
  1743.       done
  1744.       if eval $file_magic_cmd "$potlib" 2>/dev/null 
  1745.  | sed 10q 
  1746.  | egrep "$file_magic_regex" > /dev/null; then
  1747. newdeplibs="$newdeplibs $a_deplib"
  1748. a_deplib=""
  1749. break 2
  1750.       fi
  1751.     done
  1752.       done
  1753.       if test -n "$a_deplib" ; then
  1754. droppeddeps=yes
  1755. echo
  1756. echo "*** Warning: This library needs some functionality provided by $a_deplib."
  1757. echo "*** I have the capability to make that library automatically link in when"
  1758. echo "*** you link to this library.  But I can only do this if you have a"
  1759. echo "*** shared version of the library, which you do not appear to have."
  1760.       fi
  1761.     else
  1762.       # Add a -L argument.
  1763.       newdeplibs="$newdeplibs $a_deplib"
  1764.     fi
  1765.   done # Gone through all deplibs.
  1766.   ;;
  1767. none | unknown | *)
  1768.   newdeplibs=""
  1769.   if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' 
  1770.        -e 's/ -[LR][^ ]*//g' -e 's/[  ]//g' |
  1771.      grep . >/dev/null; then
  1772.     echo
  1773.     if test "X$deplibs_check_method" = "Xnone"; then
  1774.       echo "*** Warning: inter-library dependencies are not supported in this platform."
  1775.     else
  1776.       echo "*** Warning: inter-library dependencies are not known to be supported."
  1777.     fi
  1778.     echo "*** All declared inter-library dependencies are being dropped."
  1779.     droppeddeps=yes
  1780.   fi
  1781.   ;;
  1782. esac
  1783. versuffix=$versuffix_save
  1784. major=$major_save
  1785. release=$release_save
  1786. libname=$libname_save
  1787. name=$name_save
  1788. if test "$droppeddeps" = yes; then
  1789.   if test "$module" = yes; then
  1790.     echo
  1791.     echo "*** Warning: libtool could not satisfy all declared inter-library"
  1792.     echo "*** dependencies of module $libname.  Therefore, libtool will create"
  1793.     echo "*** a static module, that should work as long as the dlopening"
  1794.     echo "*** application is linked with the -dlopen flag."
  1795.     if test -z "$global_symbol_pipe"; then
  1796.       echo
  1797.       echo "*** However, this would only work if libtool was able to extract symbol"
  1798.       echo "*** lists from a program, using `nm' or equivalent, but libtool could"
  1799.       echo "*** not find such a program.  So, this module is probably useless."
  1800.       echo "*** `nm' from GNU binutils and a full rebuild may help."
  1801.     fi
  1802.     if test "$build_old_libs" = no; then
  1803.       oldlibs="$output_objdir/$libname.$libext"
  1804.       build_libtool_libs=module
  1805.       build_old_libs=yes
  1806.     else
  1807.       build_libtool_libs=no
  1808.     fi
  1809.   else
  1810.     echo "*** The inter-library dependencies that have been dropped here will be"
  1811.     echo "*** automatically added whenever a program is linked with this library"
  1812.     echo "*** or is declared to -dlopen it."
  1813.   fi
  1814. fi
  1815. # Done checking deplibs!
  1816. deplibs=$newdeplibs
  1817.       fi
  1818.       # All the library-specific variables (install_libdir is set above).
  1819.       library_names=
  1820.       old_library=
  1821.       dlname=
  1822.       
  1823.       # Test again, we may have decided not to build it any more
  1824.       if test "$build_libtool_libs" = yes; then
  1825. # Get the real and link names of the library.
  1826. eval library_names="$library_names_spec"
  1827. set dummy $library_names
  1828. realname="$2"
  1829. shift; shift
  1830. if test -n "$soname_spec"; then
  1831.   eval soname="$soname_spec"
  1832. else
  1833.   soname="$realname"
  1834. fi
  1835. lib="$output_objdir/$realname"
  1836. for link
  1837. do
  1838.   linknames="$linknames $link"
  1839. done
  1840. # Ensure that we have .o objects for linkers which dislike .lo
  1841. # (e.g. aix) incase we are running --disable-static
  1842. for obj in $libobjs; do
  1843.   oldobj=`$echo "X$obj" | $Xsed -e "$lo2o"`
  1844.   if test ! -f $oldobj; then
  1845.     $show "${LN_S} $obj $oldobj"
  1846.     $run ${LN_S} $obj $oldobj || exit $?
  1847.   fi
  1848. done
  1849. # Use standard objects if they are pic
  1850. test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  1851. # Prepare the list of exported symbols
  1852. if test -z "$export_symbols"; then
  1853.   if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
  1854.     $show "generating symbol list for `$libname.la'"
  1855.     export_symbols="$output_objdir/$libname.exp"
  1856.     $run $rm $export_symbols
  1857.     eval cmds="$export_symbols_cmds"
  1858.     IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  1859.     for cmd in $cmds; do
  1860.       IFS="$save_ifs"
  1861.       $show "$cmd"
  1862.       $run eval "$cmd" || exit $?
  1863.     done
  1864.     IFS="$save_ifs"
  1865.     if test -n "$export_symbols_regex"; then
  1866.       $show "egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T""
  1867.       $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  1868.       $show "$mv "${export_symbols}T" "$export_symbols""
  1869.       $run eval '$mv "${export_symbols}T" "$export_symbols"'
  1870.     fi
  1871.   fi
  1872. fi
  1873. if test -n "$export_symbols" && test -n "$include_expsyms"; then
  1874.   $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
  1875. fi
  1876. if test -n "$convenience"; then
  1877.   if test -n "$whole_archive_flag_spec"; then
  1878.     eval libobjs="$libobjs $whole_archive_flag_spec"
  1879.   else
  1880.     gentop="$output_objdir/${outputname}x"
  1881.     $show "${rm}r $gentop"
  1882.     $run ${rm}r "$gentop"
  1883.     $show "mkdir $gentop"
  1884.     $run mkdir "$gentop"
  1885.     status=$?
  1886.     if test $status -ne 0 && test ! -d "$gentop"; then
  1887.       exit $status
  1888.     fi
  1889.     generated="$generated $gentop"
  1890.     for xlib in $convenience; do
  1891.       # Extract the objects.
  1892.       case "$xlib" in
  1893.       [\/]* | [A-Za-z]:[\/]*) xabs="$xlib" ;;
  1894.       *) xabs=`pwd`"/$xlib" ;;
  1895.       esac
  1896.       xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
  1897.       xdir="$gentop/$xlib"
  1898.       $show "${rm}r $xdir"
  1899.       $run ${rm}r "$xdir"
  1900.       $show "mkdir $xdir"
  1901.       $run mkdir "$xdir"
  1902.       status=$?
  1903.       if test $status -ne 0 && test ! -d "$xdir"; then
  1904. exit $status
  1905.       fi
  1906.       $show "(cd $xdir && $AR x $xabs)"
  1907.       $run eval "(cd $xdir && $AR x $xabs)" || exit $?
  1908.       libobjs="$libobjs "`find $xdir -name *.o -print -o -name *.lo -print | $NL2SP`
  1909.     done
  1910.   fi
  1911. fi
  1912. if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
  1913.   eval flag="$thread_safe_flag_spec"
  1914.   linkopts="$linkopts $flag"
  1915. fi
  1916. # Do each of the archive commands.
  1917. if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  1918.   eval cmds="$archive_expsym_cmds"
  1919. else
  1920.   eval cmds="$archive_cmds"
  1921. fi
  1922. IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  1923. for cmd in $cmds; do
  1924.   IFS="$save_ifs"
  1925.   $show "$cmd"
  1926.   $run eval "$cmd" || exit $?
  1927. done
  1928. IFS="$save_ifs"
  1929. # Create links to the real library.
  1930. for linkname in $linknames; do
  1931.   if test "$realname" != "$linkname"; then
  1932.     $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
  1933.     $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
  1934.   fi
  1935. done
  1936. # If -module or -export-dynamic was specified, set the dlname.
  1937. if test "$module" = yes || test "$export_dynamic" = yes; then
  1938.   # On all known operating systems, these are identical.
  1939.   dlname="$soname"
  1940. fi
  1941.       fi
  1942.       ;;
  1943.     *.lo | *.o | *.obj)
  1944.       if test -n "$link_against_libtool_libs"; then
  1945. $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
  1946. exit 1
  1947.       fi
  1948.       if test -n "$deplibs"; then
  1949. $echo "$modename: warning: `-l' and `-L' are ignored for objects" 1>&2
  1950.       fi
  1951.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  1952. $echo "$modename: warning: `-dlopen' is ignored for objects" 1>&2
  1953.       fi
  1954.       if test -n "$rpath"; then
  1955. $echo "$modename: warning: `-rpath' is ignored for objects" 1>&2
  1956.       fi
  1957.       if test -n "$xrpath"; then
  1958. $echo "$modename: warning: `-R' is ignored for objects" 1>&2
  1959.       fi
  1960.       if test -n "$vinfo"; then
  1961. $echo "$modename: warning: `-version-info' is ignored for objects" 1>&2
  1962.       fi
  1963.       if test -n "$release"; then
  1964. $echo "$modename: warning: `-release' is ignored for objects" 1>&2
  1965.       fi
  1966.       case "$output" in
  1967.       *.lo)
  1968. if test -n "$objs"; then
  1969.   $echo "$modename: cannot build library object `$output' from non-libtool objects" 1>&2
  1970.   exit 1
  1971. fi
  1972. libobj="$output"
  1973. obj=`$echo "X$output" | $Xsed -e "$lo2o"`
  1974. ;;
  1975.       *)
  1976. libobj=
  1977. obj="$output"
  1978. ;;
  1979.       esac
  1980.       # Delete the old objects.
  1981.       $run $rm $obj $libobj
  1982.       # Objects from convenience libraries.  This assumes
  1983.       # single-version convenience libraries.  Whenever we create
  1984.       # different ones for PIC/non-PIC, this we'll have to duplicate
  1985.       # the extraction.
  1986.       reload_conv_objs=
  1987.       gentop=
  1988.       # reload_cmds runs $LD directly, so let us get rid of
  1989.       # -Wl from whole_archive_flag_spec
  1990.       wl= 
  1991.       if test -n "$convenience"; then
  1992. if test -n "$whole_archive_flag_spec"; then
  1993.   eval reload_conv_objs="$reload_objs $whole_archive_flag_spec"
  1994. else
  1995.   gentop="$output_objdir/${obj}x"
  1996.   $show "${rm}r $gentop"
  1997.   $run ${rm}r "$gentop"
  1998.   $show "mkdir $gentop"
  1999.   $run mkdir "$gentop"
  2000.   status=$?
  2001.   if test $status -ne 0 && test ! -d "$gentop"; then
  2002.     exit $status
  2003.   fi
  2004.   generated="$generated $gentop"
  2005.   for xlib in $convenience; do
  2006.     # Extract the objects.
  2007.     case "$xlib" in
  2008.     [\/]* | [A-Za-z]:[\/]*) xabs="$xlib" ;;
  2009.     *) xabs=`pwd`"/$xlib" ;;
  2010.     esac
  2011.     xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
  2012.     xdir="$gentop/$xlib"
  2013.     $show "${rm}r $xdir"
  2014.     $run ${rm}r "$xdir"
  2015.     $show "mkdir $xdir"
  2016.     $run mkdir "$xdir"
  2017.     status=$?
  2018.     if test $status -ne 0 && test ! -d "$xdir"; then
  2019.       exit $status
  2020.     fi
  2021.     $show "(cd $xdir && $AR x $xabs)"
  2022.     $run eval "(cd $xdir && $AR x $xabs)" || exit $?
  2023.     reload_conv_objs="$reload_objs "`find $xdir -name *.o -print -o -name *.lo -print | $NL2SP`
  2024.   done
  2025. fi
  2026.       fi
  2027.       # Create the old-style object.
  2028.       reload_objs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/.'${libext}$'/d' -e '/.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs"
  2029.       output="$obj"
  2030.       eval cmds="$reload_cmds"
  2031.       IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  2032.       for cmd in $cmds; do
  2033. IFS="$save_ifs"
  2034. $show "$cmd"
  2035. $run eval "$cmd" || exit $?
  2036.       done
  2037.       IFS="$save_ifs"
  2038.       # Exit if we aren't doing a library object file.
  2039.       if test -z "$libobj"; then
  2040. if test -n "$gentop"; then
  2041.   $show "${rm}r $gentop"
  2042.   $run ${rm}r $gentop
  2043. fi
  2044. exit 0
  2045.       fi
  2046.       if test "$build_libtool_libs" != yes; then
  2047. if test -n "$gentop"; then
  2048.   $show "${rm}r $gentop"
  2049.   $run ${rm}r $gentop
  2050. fi
  2051. # Create an invalid libtool object if no PIC, so that we don't
  2052. # accidentally link it into a program.
  2053. $show "echo timestamp > $libobj"
  2054. $run eval "echo timestamp > $libobj" || exit $?
  2055. exit 0
  2056.       fi
  2057.       if test -n "$pic_flag"; then
  2058. # Only do commands if we really have different PIC objects.
  2059. reload_objs="$libobjs $reload_conv_objs"
  2060. output="$libobj"
  2061. eval cmds="$reload_cmds"
  2062. IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  2063. for cmd in $cmds; do
  2064.   IFS="$save_ifs"
  2065.   $show "$cmd"
  2066.   $run eval "$cmd" || exit $?
  2067. done
  2068. IFS="$save_ifs"
  2069.       else
  2070. # Just create a symlink.
  2071. $show $rm $libobj
  2072. $run $rm $libobj
  2073. $show "$LN_S $obj $libobj"
  2074. $run $LN_S $obj $libobj || exit $?
  2075.       fi
  2076.       if test -n "$gentop"; then
  2077. $show "${rm}r $gentop"
  2078. $run ${rm}r $gentop
  2079.       fi
  2080.       exit 0
  2081.       ;;
  2082.     # Anything else should be a program.
  2083.     *)
  2084.       if test -n "$vinfo"; then
  2085. $echo "$modename: warning: `-version-info' is ignored for programs" 1>&2
  2086.       fi
  2087.       if test -n "$release"; then
  2088. $echo "$modename: warning: `-release' is ignored for programs" 1>&2
  2089.       fi
  2090.       if test "$preload" = yes; then
  2091. if test "$dlopen" = unknown && test "$dlopen_self" = unknown &&
  2092.    test "$dlopen_self_static" = unknown; then
  2093.   $echo "$modename: warning: `AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
  2094. fi 
  2095.       fi
  2096.     
  2097.       if test -n "$rpath$xrpath"; then
  2098. # If the user specified any rpath flags, then add them.
  2099. for libdir in $rpath $xrpath; do
  2100.   # This is the magic to use -rpath.
  2101.   case "$compile_rpath " in
  2102.   *" $libdir "*) ;;
  2103.   *) compile_rpath="$compile_rpath $libdir" ;;
  2104.   esac
  2105.   case "$finalize_rpath " in
  2106.   *" $libdir "*) ;;
  2107.   *) finalize_rpath="$finalize_rpath $libdir" ;;
  2108.   esac
  2109. done
  2110.       fi
  2111.       # Now hardcode the library paths
  2112.       rpath=
  2113.       hardcode_libdirs=
  2114.       for libdir in $compile_rpath $finalize_rpath; do
  2115. if test -n "$hardcode_libdir_flag_spec"; then
  2116.   if test -n "$hardcode_libdir_separator"; then
  2117.     if test -z "$hardcode_libdirs"; then
  2118.       hardcode_libdirs="$libdir"
  2119.     else
  2120.       # Just accumulate the unique libdirs.
  2121.       case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
  2122.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  2123. ;;
  2124.       *)
  2125. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  2126. ;;
  2127.       esac
  2128.     fi
  2129.   else
  2130.     eval flag="$hardcode_libdir_flag_spec"
  2131.     rpath="$rpath $flag"
  2132.   fi
  2133. elif test -n "$runpath_var"; then
  2134.   case "$perm_rpath " in
  2135.   *" $libdir "*) ;;
  2136.   *) perm_rpath="$perm_rpath $libdir" ;;
  2137.   esac
  2138. fi
  2139.       done
  2140.       # Substitute the hardcoded libdirs into the rpath.
  2141.       if test -n "$hardcode_libdir_separator" &&
  2142.  test -n "$hardcode_libdirs"; then
  2143. libdir="$hardcode_libdirs"
  2144. eval rpath=" $hardcode_libdir_flag_spec"
  2145.       fi
  2146.       compile_rpath="$rpath"
  2147.       rpath=
  2148.       hardcode_libdirs=
  2149.       for libdir in $finalize_rpath; do
  2150. if test -n "$hardcode_libdir_flag_spec"; then
  2151.   if test -n "$hardcode_libdir_separator"; then
  2152.     if test -z "$hardcode_libdirs"; then
  2153.       hardcode_libdirs="$libdir"
  2154.     else
  2155.       # Just accumulate the unique libdirs.
  2156.       case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
  2157.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  2158. ;;
  2159.       *)
  2160. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  2161. ;;
  2162.       esac
  2163.     fi
  2164.   else
  2165.     eval flag="$hardcode_libdir_flag_spec"
  2166.     rpath="$rpath $flag"
  2167.   fi
  2168. elif test -n "$runpath_var"; then
  2169.   case "$finalize_perm_rpath " in
  2170.   *" $libdir "*) ;;
  2171.   *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
  2172.   esac
  2173. fi
  2174.       done
  2175.       # Substitute the hardcoded libdirs into the rpath.
  2176.       if test -n "$hardcode_libdir_separator" &&
  2177.  test -n "$hardcode_libdirs"; then
  2178. libdir="$hardcode_libdirs"
  2179. eval rpath=" $hardcode_libdir_flag_spec"
  2180.       fi
  2181.       finalize_rpath="$rpath"
  2182.       output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
  2183.       if test "X$output_objdir" = "X$output"; then
  2184. output_objdir="$objdir"
  2185.       else
  2186. output_objdir="$output_objdir/$objdir"
  2187.       fi
  2188.       # Create the binary in the object directory, then wrap it.
  2189.       if test ! -d $output_objdir; then
  2190. $show "$mkdir $output_objdir"
  2191. $run $mkdir $output_objdir
  2192. status=$?
  2193. if test $status -ne 0 && test ! -d $output_objdir; then
  2194.   exit $status
  2195. fi
  2196.       fi
  2197.       if test -n "$libobjs" && test "$build_old_libs" = yes; then
  2198. # Transform all the library objects into standard objects.
  2199. compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2200. finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2201.       fi
  2202.       dlsyms=
  2203.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  2204. if test -n "$NM" && test -n "$global_symbol_pipe"; then
  2205.   dlsyms="${outputname}S.c"
  2206. else
  2207.   $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
  2208. fi
  2209.       fi
  2210.       if test -n "$dlsyms"; then
  2211. case "$dlsyms" in
  2212. "") ;;
  2213. *.c)
  2214.   # Discover the nlist of each of the dlfiles.
  2215.   nlist="$output_objdir/${outputname}.nm"
  2216.   $show "$rm $nlist ${nlist}S ${nlist}T"
  2217.   $run $rm "$nlist" "${nlist}S" "${nlist}T"
  2218.   # Parse the name list into a source file.
  2219.   $show "creating $output_objdir/$dlsyms"
  2220.   test -z "$run" && $echo > "$output_objdir/$dlsyms" "
  2221. /* $dlsyms - symbol resolution table for `$outputname' dlsym emulation. */
  2222. /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
  2223. #ifdef __cplusplus
  2224. extern "C" {
  2225. #endif
  2226. /* Prevent the only kind of declaration conflicts we can make. */
  2227. #define lt_preloaded_symbols some_other_symbol
  2228. /* External symbol declarations for the compiler. */
  2229. "
  2230.   if test "$dlself" = yes; then
  2231.     $show "generating symbol list for `$output'"
  2232.     test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
  2233.     # Add our own program objects to the symbol list.
  2234.     progfiles=`$echo "X$objs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2235.     for arg in $progfiles; do
  2236.       $show "extracting global C symbols from `$arg'"
  2237.       $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
  2238.     done
  2239.     if test -n "$exclude_expsyms"; then
  2240.       $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
  2241.       $run eval '$mv "$nlist"T "$nlist"'
  2242.     fi
  2243.     
  2244.     if test -n "$export_symbols_regex"; then
  2245.       $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
  2246.       $run eval '$mv "$nlist"T "$nlist"'
  2247.     fi
  2248.     # Prepare the list of exported symbols
  2249.     if test -z "$export_symbols"; then
  2250.       export_symbols="$output_objdir/$output.exp"
  2251.       $run $rm $export_symbols
  2252.       $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* (.*)$/1/p' "'< "$nlist" > "$export_symbols"'
  2253.     else
  2254.       $run eval "sed -e 's/([][.*^$])/\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
  2255.       $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
  2256.       $run eval 'mv "$nlist"T "$nlist"'
  2257.     fi
  2258.   fi
  2259.   for arg in $dlprefiles; do
  2260.     $show "extracting global C symbols from `$arg'"
  2261.     name=`echo "$arg" | sed -e 's%^.*/%%'`
  2262.     $run eval 'echo ": $name " >> "$nlist"'
  2263.     $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
  2264.   done
  2265.   if test -z "$run"; then
  2266.     # Make sure we have at least an empty file.
  2267.     test -f "$nlist" || : > "$nlist"
  2268.     if test -n "$exclude_expsyms"; then
  2269.       egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
  2270.       $mv "$nlist"T "$nlist"
  2271.     fi
  2272.     # Try sorting and uniquifying the output.
  2273.     if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
  2274.       :
  2275.     else
  2276.       grep -v "^: " < "$nlist" > "$nlist"S
  2277.     fi
  2278.     if test -f "$nlist"S; then
  2279.       eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
  2280.     else
  2281.       echo '/* NONE */' >> "$output_objdir/$dlsyms"
  2282.     fi
  2283.     $echo >> "$output_objdir/$dlsyms" "
  2284. #undef lt_preloaded_symbols
  2285. #if defined (__STDC__) && __STDC__
  2286. # define lt_ptr_t void *
  2287. #else
  2288. # define lt_ptr_t char *
  2289. # define const
  2290. #endif
  2291. /* The mapping between symbol names and symbols. */
  2292. const struct {
  2293.   const char *name;
  2294.   lt_ptr_t address;
  2295. }
  2296. lt_preloaded_symbols[] =
  2297. {
  2298. "
  2299.     sed -n -e 's/^: ([^ ]*) $/  {"1", (lt_ptr_t) 0},/p' 
  2300. -e 's/^. ([^ ]*) ([^ ]*)$/  {"2", (lt_ptr_t) &2},/p' 
  2301.   < "$nlist" >> "$output_objdir/$dlsyms"
  2302.     $echo >> "$output_objdir/$dlsyms" "
  2303.   {0, (lt_ptr_t) 0}
  2304. };
  2305. /* This works around a problem in FreeBSD linker */
  2306. #ifdef FREEBSD_WORKAROUND
  2307. static const void *lt_preloaded_setup() {
  2308.   return lt_preloaded_symbols;
  2309. }
  2310. #endif
  2311. #ifdef __cplusplus
  2312. }
  2313. #endif
  2314. "
  2315.   fi
  2316.   pic_flag_for_symtable=
  2317.   case "$host" in
  2318.   # compiling the symbol table file with pic_flag works around
  2319.   # a FreeBSD bug that causes programs to crash when -lm is
  2320.   # linked before any other PIC object.  But we must not use
  2321.   # pic_flag when linking with -static.  The problem exists in
  2322.   # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
  2323.   *-*-freebsd2*|*-*-freebsd3.0*)
  2324.     case "$compile_command " in
  2325.     *" -static "*) ;;
  2326.     *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
  2327.     esac
  2328.   esac
  2329.   # Now compile the dynamic symbol file.
  2330.   $show "(cd $output_objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")"
  2331.   $run eval '(cd $output_objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
  2332.   # Clean up the generated files.
  2333.   $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
  2334.   $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
  2335.   # Transform the symbol file into the correct name.
  2336.   compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
  2337.   finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
  2338.   ;;
  2339. *)
  2340.   $echo "$modename: unknown suffix for `$dlsyms'" 1>&2
  2341.   exit 1
  2342.   ;;
  2343. esac
  2344.       else
  2345. # We keep going just in case the user didn't refer to
  2346. # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
  2347. # really was required.
  2348. # Nullify the symbol file.
  2349. compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  2350. finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  2351.       fi
  2352.       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
  2353. # Replace the output file specification.
  2354. compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  2355. link_command="$compile_command$compile_rpath"
  2356. # We have no uninstalled library dependencies, so finalize right now.
  2357. $show "$link_command"
  2358. $run eval "$link_command"
  2359. status=$?
  2360. # Delete the generated files.
  2361. if test -n "$dlsyms"; then
  2362.   $show "$rm $output_objdir/${outputname}S.${objext}"
  2363.   $run $rm "$output_objdir/${outputname}S.${objext}"
  2364. fi
  2365. exit $status
  2366.       fi
  2367.       if test -n "$shlibpath_var"; then
  2368. # We should set the shlibpath_var
  2369. rpath=
  2370. for dir in $temp_rpath; do
  2371.   case "$dir" in
  2372.   [\/]* | [A-Za-z]:[\/]*)
  2373.     # Absolute path.
  2374.     rpath="$rpath$dir:"
  2375.     ;;
  2376.   *)
  2377.     # Relative path: add a thisdir entry.
  2378.     rpath="$rpath$thisdir/$dir:"
  2379.     ;;
  2380.   esac
  2381. done
  2382. temp_rpath="$rpath"
  2383.       fi
  2384.       if test -n "$compile_shlibpath$finalize_shlibpath"; then
  2385. compile_command="$shlibpath_var="$compile_shlibpath$finalize_shlibpath$$shlibpath_var" $compile_command"
  2386.       fi
  2387.       if test -n "$finalize_shlibpath"; then
  2388. finalize_command="$shlibpath_var="$finalize_shlibpath$$shlibpath_var" $finalize_command"
  2389.       fi
  2390.       compile_var=
  2391.       finalize_var=
  2392.       if test -n "$runpath_var"; then
  2393. if test -n "$perm_rpath"; then
  2394.   # We should set the runpath_var.
  2395.   rpath=
  2396.   for dir in $perm_rpath; do
  2397.     rpath="$rpath$dir:"
  2398.   done
  2399.   compile_var="$runpath_var="$rpath$$runpath_var" "
  2400. fi
  2401. if test -n "$finalize_perm_rpath"; then
  2402.   # We should set the runpath_var.
  2403.   rpath=
  2404.   for dir in $finalize_perm_rpath; do
  2405.     rpath="$rpath$dir:"
  2406.   done
  2407.   finalize_var="$runpath_var="$rpath$$runpath_var" "
  2408. fi
  2409.       fi
  2410.       if test "$hardcode_action" = relink; then
  2411. # Fast installation is not supported
  2412. link_command="$compile_var$compile_command$compile_rpath"
  2413. relink_command="$finalize_var$finalize_command$finalize_rpath"
  2414. $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
  2415. $echo "$modename: `$output' will be relinked during installation" 1>&2
  2416.       else
  2417. if test "$fast_install" != no; then
  2418.   link_command="$finalize_var$compile_command$finalize_rpath"
  2419.   if test "$fast_install" = yes; then
  2420.     relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%$progdir/$file%g'`
  2421.   else
  2422.     # fast_install is set to needless
  2423.     relink_command=
  2424.   fi
  2425. else
  2426.   link_command="$compile_var$compile_command$compile_rpath"
  2427.   relink_command="$finalize_var$finalize_command$finalize_rpath"
  2428. fi
  2429.       fi
  2430.       # Replace the output file specification.
  2431.       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
  2432.       
  2433.       # Delete the old output files.
  2434.       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
  2435.       $show "$link_command"
  2436.       $run eval "$link_command" || exit $?
  2437.       # Now create the wrapper script.
  2438.       $show "creating $output"
  2439.       # Quote the relink command for shipping.
  2440.       if test -n "$relink_command"; then
  2441. relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
  2442.       fi
  2443.       # Quote $echo for shipping.
  2444.       if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
  2445. case "$0" in
  2446. [\/]* | [A-Za-z]:[\/]*) qecho="$SHELL $0 --fallback-echo";;
  2447. *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
  2448. esac
  2449. qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
  2450.       else
  2451. qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
  2452.       fi
  2453.       # Only actually do things if our run command is non-null.
  2454.       if test -z "$run"; then
  2455. # win32 will think the script is a binary if it has
  2456. # a .exe suffix, so we strip it off here.
  2457. case $output in
  2458.   *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
  2459. esac
  2460. $rm $output
  2461. trap "$rm $output; exit 1" 1 2 15
  2462. $echo > $output "
  2463. #! $SHELL
  2464. # $output - temporary wrapper script for $objdir/$outputname
  2465. # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  2466. #
  2467. # The $output program cannot be directly executed until all the libtool
  2468. # libraries that it depends on are installed.
  2469. #
  2470. # This wrapper script should never be moved out of the build directory.
  2471. # If it is, it will not operate correctly.
  2472. # Sed substitution that helps us do robust quoting.  It backslashifies
  2473. # metacharacters that are still active within double-quoted strings.
  2474. Xsed='sed -e 1s/^X//'
  2475. sed_quote_subst='$sed_quote_subst'
  2476. # The HP-UX ksh and POSIX shell print the target directory to stdout
  2477. # if CDPATH is set.
  2478. if test "${CDPATH+set}" = set; then CDPATH=; export CDPATH; fi
  2479. relink_command="$relink_command"
  2480. # This environment variable determines our operation mode.
  2481. if test "$libtool_install_magic" = "$magic"; then
  2482.   # install mode needs the following variable:
  2483.   link_against_libtool_libs='$link_against_libtool_libs'
  2484. else
  2485.   # When we are sourced in execute mode, $file and $echo are already set.
  2486.   if test "$libtool_execute_magic" != "$magic"; then
  2487.     echo="$qecho"
  2488.     file="$0"
  2489.     # Make sure echo works.
  2490.     if test "X$1" = X--no-reexec; then
  2491.       # Discard the --no-reexec flag, and continue.
  2492.       shift
  2493.     elif test "X`($echo 't') 2>/dev/null`" = 'Xt'; then
  2494.       # Yippee, $echo works!
  2495.       :
  2496.     else
  2497.       # Restart under the correct shell, and then maybe $echo will work.
  2498.       exec $SHELL "$0" --no-reexec ${1+"$@"}
  2499.     fi
  2500.   fi
  2501. "
  2502. $echo >> $output "
  2503.   # Find the directory that this script lives in.
  2504.   thisdir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2505.   test "x$thisdir" = "x$file" && thisdir=.
  2506.   # Follow symbolic links until we get to the real thisdir.
  2507.   file=`ls -ld "$file" | sed -n 's/.*-> //p'`
  2508.   while test -n "$file"; do
  2509.     destdir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2510.     # If there was a directory component, then change thisdir.
  2511.     if test "x$destdir" != "x$file"; then
  2512.       case "$destdir" in
  2513.       [\/]* | [A-Za-z]:[\/]*) thisdir="$destdir" ;;
  2514.       *) thisdir="$thisdir/$destdir" ;;
  2515.       esac
  2516.     fi
  2517.     file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2518.     file=`ls -ld "$thisdir/$file" | sed -n 's/.*-> //p'`
  2519.   done
  2520.   # Try to get the absolute directory name.
  2521.   absdir=`cd "$thisdir" && pwd`
  2522.   test -n "$absdir" && thisdir="$absdir"
  2523. "
  2524. if test "$fast_install" = yes; then
  2525.   echo >> $output "
  2526.   program=lt-'$outputname'
  2527.   progdir="$thisdir/$objdir"
  2528.   
  2529.   if test ! -f "$progdir/$program" || \
  2530.      { file=`ls -1dt "$progdir/$program" "$progdir/../$program" 2>/dev/null | sed 1q`; \
  2531.        test "X$file" != "X$progdir/$program"; }; then
  2532.     file="$$-$program"
  2533.     if test ! -d "$progdir"; then
  2534.       $mkdir "$progdir"
  2535.     else
  2536.       $rm "$progdir/$file"
  2537.     fi"
  2538.   echo >> $output "
  2539.     # relink executable if necessary
  2540.     if test -n "$relink_command"; then
  2541.       if (cd "$thisdir" && eval $relink_command); then :
  2542.       else
  2543. $rm "$progdir/$file"
  2544. exit 1
  2545.       fi
  2546.     fi
  2547.     $mv "$progdir/$file" "$progdir/$program" 2>/dev/null ||
  2548.     { $rm "$progdir/$program";
  2549.       $mv "$progdir/$file" "$progdir/$program"; }
  2550.     $rm "$progdir/$file"
  2551.   fi"
  2552. else
  2553.   echo >> $output "
  2554.   program='$outputname$exeext'
  2555.   progdir="$thisdir/$objdir"
  2556. "
  2557. fi
  2558. echo >> $output "
  2559.   if test -f "$progdir/$program"; then"
  2560. # Export our shlibpath_var if we have one.
  2561. if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  2562.   $echo >> $output "
  2563.     # Add our own library path to $shlibpath_var
  2564.     $shlibpath_var="$temp_rpath$$shlibpath_var"
  2565.     # Some systems cannot cope with colon-terminated $shlibpath_var
  2566.     # The second colon is a workaround for a bug in BeOS R4 sed
  2567.     $shlibpath_var=`$echo "X$$shlibpath_var" | $Xsed -e 's/::*$//'`
  2568.     export $shlibpath_var
  2569. "
  2570. fi
  2571. # fixup the dll searchpath if we need to.
  2572. if test -n "$dllsearchpath"; then
  2573.   $echo >> $output "
  2574.     # Add the dll search path components to the executable PATH
  2575.     PATH=$dllsearchpath:$PATH
  2576. "
  2577. fi
  2578. $echo >> $output "
  2579.     if test "$libtool_execute_magic" != "$magic"; then
  2580.       # Run the actual program with our arguments.
  2581. "
  2582. case $host in
  2583. *-*-cygwin* | *-*-mingw | *-*-os2*)
  2584.   # win32 systems need to use the prog path for dll
  2585.   # lookup to work
  2586.   $echo >> $output "
  2587.       exec $progdir\\$program ${1+"$@"}
  2588. "
  2589.   ;;
  2590. *)
  2591.   $echo >> $output "
  2592.       # Export the path to the program.
  2593.       PATH="$progdir:$PATH"
  2594.       export PATH
  2595.       exec $program ${1+"$@"}
  2596. "
  2597.   ;;
  2598. esac
  2599. $echo >> $output "
  2600.       $echo "$0: cannot exec $program ${1+"$@"}"
  2601.       exit 1
  2602.     fi
  2603.   else
  2604.     # The program doesn't exist.
  2605.     $echo "$0: error: $progdir/$program does not exist" 1>&2
  2606.     $echo "This script is just a wrapper for $program." 1>&2
  2607.     echo "See the $PACKAGE documentation for more information." 1>&2
  2608.     exit 1
  2609.   fi
  2610. fi
  2611. "
  2612. chmod +x $output
  2613.       fi
  2614.       exit 0
  2615.       ;;
  2616.     esac
  2617.     # See if we need to build an old-fashioned archive.
  2618.     for oldlib in $oldlibs; do
  2619.       if test "$build_libtool_libs" = convenience; then
  2620. oldobjs="$libobjs_save"
  2621. addlibs="$convenience"
  2622. build_libtool_libs=no
  2623.       else
  2624. if test "$build_libtool_libs" = module; then
  2625.   oldobjs="$libobjs_save"
  2626.   build_libtool_libs=no
  2627. else
  2628.   oldobjs="$objs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/.'${libext}'$/d' -e '/.lib$/d' -e "$lo2o" | $NL2SP`
  2629. fi
  2630. addlibs="$old_convenience"
  2631.       fi
  2632.       if test -n "$addlibs"; then
  2633. gentop="$output_objdir/${outputname}x"
  2634. $show "${rm}r $gentop"
  2635. $run ${rm}r "$gentop"
  2636. $show "mkdir $gentop"
  2637. $run mkdir "$gentop"
  2638. status=$?
  2639. if test $status -ne 0 && test ! -d "$gentop"; then
  2640.   exit $status
  2641. fi
  2642. generated="$generated $gentop"
  2643.   
  2644. # Add in members from convenience archives.
  2645. for xlib in $addlibs; do
  2646.   # Extract the objects.
  2647.   case "$xlib" in
  2648.   [\/]* | [A-Za-z]:[\/]*) xabs="$xlib" ;;
  2649.   *) xabs=`pwd`"/$xlib" ;;
  2650.   esac
  2651.   xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
  2652.   xdir="$gentop/$xlib"
  2653.   $show "${rm}r $xdir"
  2654.   $run ${rm}r "$xdir"
  2655.   $show "mkdir $xdir"
  2656.   $run mkdir "$xdir"
  2657.   status=$?
  2658.   if test $status -ne 0 && test ! -d "$xdir"; then
  2659.     exit $status
  2660.   fi
  2661.   $show "(cd $xdir && $AR x $xabs)"
  2662.   $run eval "(cd $xdir && $AR x $xabs)" || exit $?
  2663.   oldobjs="$oldobjs "`find $xdir -name *.${objext} -print -o -name *.lo -print | $NL2SP`
  2664. done
  2665.       fi
  2666.       # Do each command in the archive commands.
  2667.       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
  2668. eval cmds="$old_archive_from_new_cmds"
  2669.       else
  2670. # Ensure that we have .o objects in place incase we decided
  2671. # not to build a shared library, and have fallen back to building
  2672. # static libs even though --disable-static was passed!
  2673. for oldobj in $oldobjs; do
  2674.   if test ! -f $oldobj; then
  2675.     obj=`$echo "X$oldobj" | $Xsed -e "$o2lo"`
  2676.     $show "${LN_S} $obj $oldobj"
  2677.     $run ${LN_S} $obj $oldobj || exit $?
  2678.   fi
  2679. done
  2680. eval cmds="$old_archive_cmds"
  2681.       fi
  2682.       IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  2683.       for cmd in $cmds; do
  2684. IFS="$save_ifs"
  2685. $show "$cmd"
  2686. $run eval "$cmd" || exit $?
  2687.       done
  2688.       IFS="$save_ifs"
  2689.     done
  2690.     if test -n "$generated"; then
  2691.       $show "${rm}r$generated"
  2692.       $run ${rm}r$generated
  2693.     fi
  2694.     # Now create the libtool archive.
  2695.     case "$output" in
  2696.     *.la)
  2697.       old_library=
  2698.       test "$build_old_libs" = yes && old_library="$libname.$libext"
  2699.       $show "creating $output"
  2700.       if test -n "$xrpath"; then
  2701. temp_xrpath=
  2702. for libdir in $xrpath; do
  2703.   temp_xrpath="$temp_xrpath -R$libdir"
  2704. done
  2705. dependency_libs="$temp_xrpath $dependency_libs"
  2706.       fi
  2707.       # Only create the output if not a dry run.
  2708.       if test -z "$run"; then
  2709. for installed in no yes; do
  2710.   if test "$installed" = yes; then
  2711.     if test -z "$install_libdir"; then
  2712.       break
  2713.     fi
  2714.     output="$output_objdir/$outputname"i
  2715.   fi
  2716.   $rm $output
  2717.   $echo > $output "
  2718. # $outputname - a libtool library file
  2719. # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  2720. #
  2721. # Please DO NOT delete this file!
  2722. # It is necessary for linking the library.
  2723. # The name that we can dlopen(3).
  2724. dlname='$dlname'
  2725. # Names of this library.
  2726. library_names='$library_names'
  2727. # The name of the static archive.
  2728. old_library='$old_library'
  2729. # Libraries that this one depends upon.
  2730. dependency_libs='$dependency_libs'
  2731. # Version information for $libname.
  2732. current=$current
  2733. age=$age
  2734. revision=$revision
  2735. # Is this an already installed library?
  2736. installed=$installed
  2737. # Directory that this library needs to be installed in:
  2738. libdir='$install_libdir'
  2739. "
  2740. done
  2741.       fi
  2742.       # Do a symbolic link so that the libtool archive can be found in
  2743.       # LD_LIBRARY_PATH before the program is installed.
  2744.       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
  2745.       $run eval "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)" || exit $?
  2746.       ;;
  2747.     esac
  2748.     exit 0
  2749.     ;;
  2750.   # libtool install mode
  2751.   install)
  2752.     modename="$modename: install"
  2753.     # There may be an optional sh(1) argument at the beginning of
  2754.     # install_prog (especially on Windows NT).
  2755.     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh; then
  2756.       # Aesthetically quote it.
  2757.       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
  2758.       case "$arg" in
  2759.       *[[~#^&*(){}|;<>?'  ]*|*]*)
  2760. arg=""$arg""
  2761. ;;
  2762.       esac
  2763.       install_prog="$arg "
  2764.       arg="$1"
  2765.       shift
  2766.     else
  2767.       install_prog=
  2768.       arg="$nonopt"
  2769.     fi
  2770.     # The real first argument should be the name of the installation program.
  2771.     # Aesthetically quote it.
  2772.     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  2773.     case "$arg" in
  2774.     *[[~#^&*(){}|;<>?'  ]*|*]*)
  2775.       arg=""$arg""
  2776.       ;;
  2777.     esac
  2778.     install_prog="$install_prog$arg"
  2779.     # We need to accept at least all the BSD install flags.
  2780.     dest=
  2781.     files=
  2782.     opts=
  2783.     prev=
  2784.     install_type=
  2785.     isdir=no
  2786.     stripme=
  2787.     for arg
  2788.     do
  2789.       if test -n "$dest"; then
  2790. files="$files $dest"
  2791. dest="$arg"
  2792. continue
  2793.       fi
  2794.       case "$arg" in
  2795.       -d) isdir=yes ;;
  2796.       -f) prev="-f" ;;
  2797.       -g) prev="-g" ;;
  2798.       -m) prev="-m" ;;
  2799.       -o) prev="-o" ;;
  2800.       -s)
  2801. stripme=" -s"
  2802. continue
  2803. ;;
  2804.       -*) ;;
  2805.       *)
  2806. # If the previous option needed an argument, then skip it.
  2807. if test -n "$prev"; then
  2808.   prev=
  2809. else
  2810.   dest="$arg"
  2811.   continue
  2812. fi
  2813. ;;
  2814.       esac
  2815.       # Aesthetically quote the argument.
  2816.       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  2817.       case "$arg" in
  2818.       *[[~#^&*(){}|;<>?'  ]*|*]*)
  2819. arg=""$arg""
  2820. ;;
  2821.       esac
  2822.       install_prog="$install_prog $arg"
  2823.     done
  2824.     if test -z "$install_prog"; then
  2825.       $echo "$modename: you must specify an install program" 1>&2
  2826.       $echo "$help" 1>&2
  2827.       exit 1
  2828.     fi
  2829.     if test -n "$prev"; then
  2830.       $echo "$modename: the `$prev' option requires an argument" 1>&2
  2831.       $echo "$help" 1>&2
  2832.       exit 1
  2833.     fi
  2834.     if test -z "$files"; then
  2835.       if test -z "$dest"; then
  2836. $echo "$modename: no file or destination specified" 1>&2
  2837.       else
  2838. $echo "$modename: you must specify a destination" 1>&2
  2839.       fi
  2840.       $echo "$help" 1>&2
  2841.       exit 1
  2842.     fi
  2843.     # Strip any trailing slash from the destination.
  2844.     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
  2845.     # Check to see that the destination is a directory.
  2846.     test -d "$dest" && isdir=yes
  2847.     if test "$isdir" = yes; then
  2848.       destdir="$dest"
  2849.       destname=
  2850.     else
  2851.       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
  2852.       test "X$destdir" = "X$dest" && destdir=.
  2853.       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
  2854.       # Not a directory, so check to see that there is only one file specified.
  2855.       set dummy $files
  2856.       if test $# -gt 2; then
  2857. $echo "$modename: `$dest' is not a directory" 1>&2
  2858. $echo "$help" 1>&2
  2859. exit 1
  2860.       fi
  2861.     fi
  2862.     case "$destdir" in
  2863.     [\/]* | [A-Za-z]:[\/]*) ;;
  2864.     *)
  2865.       for file in $files; do
  2866. case "$file" in
  2867. *.lo) ;;
  2868. *)
  2869.   $echo "$modename: `$destdir' must be an absolute directory name" 1>&2
  2870.   $echo "$help" 1>&2
  2871.   exit 1
  2872.   ;;
  2873. esac
  2874.       done
  2875.       ;;
  2876.     esac
  2877.     # This variable tells wrapper scripts just to set variables rather
  2878.     # than running their programs.
  2879.     libtool_install_magic="$magic"
  2880.     staticlibs=
  2881.     future_libdirs=
  2882.     current_libdirs=
  2883.     for file in $files; do
  2884.       # Do each installation.
  2885.       case "$file" in
  2886.       *.a | *.lib)
  2887. # Do the static libraries later.
  2888. staticlibs="$staticlibs $file"
  2889. ;;
  2890.       *.la)
  2891. # Check to see that this really is a libtool archive.
  2892. if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
  2893. else
  2894.   $echo "$modename: `$file' is not a valid libtool archive" 1>&2
  2895.   $echo "$help" 1>&2
  2896.   exit 1
  2897. fi
  2898. library_names=
  2899. old_library=
  2900. # If there is no directory component, then add one.
  2901. case "$file" in
  2902. */* | *\*) . $file ;;
  2903. *) . ./$file ;;
  2904. esac
  2905. # Add the libdir to current_libdirs if it is the destination.
  2906. if test "X$destdir" = "X$libdir"; then
  2907.   case "$current_libdirs " in
  2908.   *" $libdir "*) ;;
  2909.   *) current_libdirs="$current_libdirs $libdir" ;;
  2910.   esac
  2911. else
  2912.   # Note the libdir as a future libdir.
  2913.   case "$future_libdirs " in
  2914.   *" $libdir "*) ;;
  2915.   *) future_libdirs="$future_libdirs $libdir" ;;
  2916.   esac
  2917. fi
  2918. dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
  2919. test "X$dir" = "X$file/" && dir=
  2920. dir="$dir$objdir"
  2921. # See the names of the shared library.
  2922. set dummy $library_names
  2923. if test -n "$2"; then
  2924.   realname="$2"
  2925.   shift
  2926.   shift
  2927.   # Install the shared library and build the symlinks.
  2928.   $show "$install_prog $dir/$realname $destdir/$realname"
  2929.   $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
  2930.   if test $# -gt 0; then
  2931.     # Delete the old symlinks, and create new ones.
  2932.     for linkname
  2933.     do
  2934.       if test "$linkname" != "$realname"; then
  2935. $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
  2936. $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
  2937.       fi
  2938.     done
  2939.   fi
  2940.   # Do each command in the postinstall commands.
  2941.   lib="$destdir/$realname"
  2942.   eval cmds="$postinstall_cmds"
  2943.   IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  2944.   for cmd in $cmds; do
  2945.     IFS="$save_ifs"
  2946.     $show "$cmd"
  2947.     $run eval "$cmd" || exit $?
  2948.   done
  2949.   IFS="$save_ifs"
  2950. fi
  2951. # Install the pseudo-library for information purposes.
  2952. name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2953. instname="$dir/$name"i
  2954. $show "$install_prog $instname $destdir/$name"
  2955. $run eval "$install_prog $instname $destdir/$name" || exit $?
  2956. # Maybe install the static library, too.
  2957. test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
  2958. ;;
  2959.       *.lo)
  2960. # Install (i.e. copy) a libtool object.
  2961. # Figure out destination file name, if it wasn't already specified.
  2962. if test -n "$destname"; then
  2963.   destfile="$destdir/$destname"
  2964. else
  2965.   destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2966.   destfile="$destdir/$destfile"
  2967. fi
  2968. # Deduce the name of the destination old-style object file.
  2969. case "$destfile" in
  2970. *.lo)
  2971.   staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
  2972.   ;;
  2973. *.o | *.obj)
  2974.   staticdest="$destfile"
  2975.   destfile=
  2976.   ;;
  2977. *)
  2978.   $echo "$modename: cannot copy a libtool object to `$destfile'" 1>&2
  2979.   $echo "$help" 1>&2
  2980.   exit 1
  2981.   ;;
  2982. esac
  2983. # Install the libtool object if requested.
  2984. if test -n "$destfile"; then
  2985.   $show "$install_prog $file $destfile"
  2986.   $run eval "$install_prog $file $destfile" || exit $?
  2987. fi
  2988. # Install the old object if enabled.
  2989. if test "$build_old_libs" = yes; then
  2990.   # Deduce the name of the old-style object file.
  2991.   staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
  2992.   $show "$install_prog $staticobj $staticdest"
  2993.   $run eval "$install_prog $staticobj $staticdest" || exit $?
  2994. fi
  2995. exit 0
  2996. ;;
  2997.       *)
  2998. # Figure out destination file name, if it wasn't already specified.
  2999. if test -n "$destname"; then
  3000.   destfile="$destdir/$destname"
  3001. else
  3002.   destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  3003.   destfile="$destdir/$destfile"
  3004. fi
  3005. # Do a test to see if this is really a libtool program.
  3006. if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  3007.   link_against_libtool_libs=
  3008.   relink_command=
  3009.   # If there is no directory component, then add one.
  3010.   case "$file" in
  3011.   */* | *\*) . $file ;;
  3012.   *) . ./$file ;;
  3013.   esac
  3014.   # Check the variables that should have been set.
  3015.   if test -z "$link_against_libtool_libs"; then
  3016.     $echo "$modename: invalid libtool wrapper script `$file'" 1>&2
  3017.     exit 1
  3018.   fi
  3019.   finalize=yes
  3020.   for lib in $link_against_libtool_libs; do
  3021.     # Check to see that each library is installed.
  3022.     libdir=
  3023.     if test -f "$lib"; then
  3024.       # If there is no directory component, then add one.
  3025.       case "$lib" in
  3026.       */* | *\*) . $lib ;;
  3027.       *) . ./$lib ;;
  3028.       esac
  3029.     fi
  3030.     libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
  3031.     if test -n "$libdir" && test ! -f "$libfile"; then
  3032.       $echo "$modename: warning: `$lib' has not been installed in `$libdir'" 1>&2
  3033.       finalize=no
  3034.     fi
  3035.   done
  3036.   outputname=
  3037.   if test "$fast_install" = no && test -n "$relink_command"; then
  3038.     if test "$finalize" = yes && test -z "$run"; then
  3039.       tmpdir="/tmp"
  3040.       test -n "$TMPDIR" && tmpdir="$TMPDIR"
  3041.       tmpdir="$tmpdir/libtool-$$"
  3042.       if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
  3043.       else
  3044. $echo "$modename: error: cannot create temporary directory `$tmpdir'" 1>&2
  3045. continue
  3046.       fi
  3047.       outputname="$tmpdir/$file"
  3048.       # Replace the output file specification.
  3049.       relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
  3050.       $show "$relink_command"
  3051.       if $run eval "$relink_command"; then :
  3052.       else
  3053. $echo "$modename: error: relink `$file' with the above command before installing it" 1>&2
  3054. ${rm}r "$tmpdir"
  3055. continue
  3056.       fi
  3057.       file="$outputname"
  3058.     else
  3059.       $echo "$modename: warning: cannot relink `$file'" 1>&2
  3060.     fi
  3061.   else
  3062.     # Install the binary that we compiled earlier.
  3063.     file=`$echo "X$file" | $Xsed -e "s%([^/]*)$%$objdir/1%"`
  3064.   fi
  3065. fi
  3066. $show "$install_prog$stripme $file $destfile"
  3067. $run eval "$install_prog$stripme $file $destfile" || exit $?
  3068. test -n "$outputname" && ${rm}r "$tmpdir"
  3069. ;;
  3070.       esac
  3071.     done
  3072.     for file in $staticlibs; do
  3073.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  3074.       # Set up the ranlib parameters.
  3075.       oldlib="$destdir/$name"
  3076.       $show "$install_prog $file $oldlib"
  3077.       $run eval "$install_prog $file $oldlib" || exit $?
  3078.       # Do each command in the postinstall commands.
  3079.       eval cmds="$old_postinstall_cmds"
  3080.       IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  3081.       for cmd in $cmds; do
  3082. IFS="$save_ifs"
  3083. $show "$cmd"
  3084. $run eval "$cmd" || exit $?
  3085.       done
  3086.       IFS="$save_ifs"
  3087.     done
  3088.     if test -n "$future_libdirs"; then
  3089.       $echo "$modename: warning: remember to run `$progname --finish$future_libdirs'" 1>&2
  3090.     fi
  3091.     if test -n "$current_libdirs"; then
  3092.       # Maybe just do a dry run.
  3093.       test -n "$run" && current_libdirs=" -n$current_libdirs"
  3094.       exec $SHELL $0 --finish$current_libdirs
  3095.       exit 1
  3096.     fi
  3097.     exit 0
  3098.     ;;
  3099.   # libtool finish mode
  3100.   finish)
  3101.     modename="$modename: finish"
  3102.     libdirs="$nonopt"
  3103.     admincmds=
  3104.     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  3105.       for dir
  3106.       do
  3107. libdirs="$libdirs $dir"
  3108.       done
  3109.       for libdir in $libdirs; do
  3110. if test -n "$finish_cmds"; then
  3111.   # Do each command in the finish commands.
  3112.   eval cmds="$finish_cmds"
  3113.   IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  3114.   for cmd in $cmds; do
  3115.     IFS="$save_ifs"
  3116.     $show "$cmd"
  3117.     $run eval "$cmd" || admincmds="$admincmds
  3118.        $cmd"
  3119.   done
  3120.   IFS="$save_ifs"
  3121. fi
  3122. if test -n "$finish_eval"; then
  3123.   # Do the single finish_eval.
  3124.   eval cmds="$finish_eval"
  3125.   $run eval "$cmds" || admincmds="$admincmds
  3126.        $cmds"
  3127. fi
  3128.       done
  3129.     fi
  3130.     # Exit here if they wanted silent mode.
  3131.     test "$show" = : && exit 0
  3132.     echo "----------------------------------------------------------------------"
  3133.     echo "Libraries have been installed in:"
  3134.     for libdir in $libdirs; do
  3135.       echo "   $libdir"
  3136.     done
  3137.     echo
  3138.     echo "If you ever happen to want to link against installed libraries"
  3139.     echo "in a given directory, LIBDIR, you must either use libtool, and"
  3140.     echo "specify the full pathname of the library, or use `-LLIBDIR'"
  3141.     echo "flag during linking and do at least one of the following:"
  3142.     if test -n "$shlibpath_var"; then
  3143.       echo "   - add LIBDIR to the `$shlibpath_var' environment variable"
  3144.       echo "     during execution"
  3145.     fi
  3146.     if test -n "$runpath_var"; then
  3147.       echo "   - add LIBDIR to the `$runpath_var' environment variable"
  3148.       echo "     during linking"
  3149.     fi
  3150.     if test -n "$hardcode_libdir_flag_spec"; then
  3151.       libdir=LIBDIR
  3152.       eval flag="$hardcode_libdir_flag_spec"
  3153.       echo "   - use the `$flag' linker flag"
  3154.     fi
  3155.     if test -n "$admincmds"; then
  3156.       echo "   - have your system administrator run these commands:$admincmds"
  3157.     fi
  3158.     if test -f /etc/ld.so.conf; then
  3159.       echo "   - have your system administrator add LIBDIR to `/etc/ld.so.conf'"
  3160.     fi
  3161.     echo
  3162.     echo "See any operating system documentation about shared libraries for"
  3163.     echo "more information, such as the ld(1) and ld.so(8) manual pages."
  3164.     echo "----------------------------------------------------------------------"
  3165.     exit 0
  3166.     ;;
  3167.   # libtool execute mode
  3168.   execute)
  3169.     modename="$modename: execute"
  3170.     # The first argument is the command name.
  3171.     cmd="$nonopt"
  3172.     if test -z "$cmd"; then
  3173.       $echo "$modename: you must specify a COMMAND" 1>&2
  3174.       $echo "$help"
  3175.       exit 1
  3176.     fi
  3177.     # Handle -dlopen flags immediately.
  3178.     for file in $execute_dlfiles; do
  3179.       if test ! -f "$file"; then
  3180. $echo "$modename: `$file' is not a file" 1>&2
  3181. $echo "$help" 1>&2
  3182. exit 1
  3183.       fi
  3184.       dir=
  3185.       case "$file" in
  3186.       *.la)
  3187. # Check to see that this really is a libtool archive.
  3188. if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
  3189. else
  3190.   $echo "$modename: `$lib' is not a valid libtool archive" 1>&2
  3191.   $echo "$help" 1>&2
  3192.   exit 1
  3193. fi
  3194. # Read the libtool library.
  3195. dlname=
  3196. library_names=
  3197. # If there is no directory component, then add one.
  3198. case "$file" in
  3199. */* | *\*) . $file ;;
  3200. *) . ./$file ;;
  3201. esac
  3202. # Skip this library if it cannot be dlopened.
  3203. if test -z "$dlname"; then
  3204.   # Warn if it was a shared library.
  3205.   test -n "$library_names" && $echo "$modename: warning: `$file' was not linked with `-export-dynamic'"
  3206.   continue
  3207. fi
  3208. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  3209. test "X$dir" = "X$file" && dir=.
  3210. if test -f "$dir/$objdir/$dlname"; then
  3211.   dir="$dir/$objdir"
  3212. else
  3213.   $echo "$modename: cannot find `$dlname' in `$dir' or `$dir/$objdir'" 1>&2
  3214.   exit 1
  3215. fi
  3216. ;;
  3217.       *.lo)
  3218. # Just add the directory containing the .lo file.
  3219. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  3220. test "X$dir" = "X$file" && dir=.
  3221. ;;
  3222.       *)
  3223. $echo "$modename: warning `-dlopen' is ignored for non-libtool libraries and objects" 1>&2
  3224. continue
  3225. ;;
  3226.       esac
  3227.       # Get the absolute pathname.
  3228.       absdir=`cd "$dir" && pwd`
  3229.       test -n "$absdir" && dir="$absdir"
  3230.       # Now add the directory to shlibpath_var.
  3231.       if eval "test -z "$$shlibpath_var""; then
  3232. eval "$shlibpath_var="$dir""
  3233.       else
  3234. eval "$shlibpath_var="$dir:$$shlibpath_var""
  3235.       fi
  3236.     done
  3237.     # This variable tells wrapper scripts just to set shlibpath_var
  3238.     # rather than running their programs.
  3239.     libtool_execute_magic="$magic"
  3240.     # Check if any of the arguments is a wrapper script.
  3241.     args=
  3242.     for file
  3243.     do
  3244.       case "$file" in
  3245.       -*) ;;
  3246.       *)
  3247. # Do a test to see if this is really a libtool program.
  3248. if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  3249.   # If there is no directory component, then add one.
  3250.   case "$file" in
  3251.   */* | *\*) . $file ;;
  3252.   *) . ./$file ;;
  3253.   esac
  3254.   # Transform arg to wrapped name.
  3255.   file="$progdir/$program"
  3256. fi
  3257. ;;
  3258.       esac
  3259.       # Quote arguments (to preserve shell metacharacters).
  3260.       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
  3261.       args="$args "$file""
  3262.     done
  3263.     if test -z "$run"; then
  3264.       # Export the shlibpath_var.
  3265.       eval "export $shlibpath_var"
  3266.       # Restore saved enviroment variables
  3267.       if test "${save_LC_ALL+set}" = set; then
  3268. LC_ALL="$save_LC_ALL"; export LC_ALL
  3269.       fi
  3270.       if test "${save_LANG+set}" = set; then
  3271. LANG="$save_LANG"; export LANG
  3272.       fi
  3273.       # Now actually exec the command.
  3274.       eval "exec $cmd$args"
  3275.       $echo "$modename: cannot exec $cmd$args"
  3276.       exit 1
  3277.     else
  3278.       # Display what would be done.
  3279.       eval "$echo "$shlibpath_var=$$shlibpath_var""
  3280.       $echo "export $shlibpath_var"
  3281.       $echo "$cmd$args"
  3282.       exit 0
  3283.     fi
  3284.     ;;
  3285.   # libtool uninstall mode
  3286.   uninstall)
  3287.     modename="$modename: uninstall"
  3288.     rm="$nonopt"
  3289.     files=
  3290.     for arg
  3291.     do
  3292.       case "$arg" in
  3293.       -*) rm="$rm $arg" ;;
  3294.       *) files="$files $arg" ;;
  3295.       esac
  3296.     done
  3297.     if test -z "$rm"; then
  3298.       $echo "$modename: you must specify an RM program" 1>&2
  3299.       $echo "$help" 1>&2
  3300.       exit 1
  3301.     fi
  3302.     for file in $files; do
  3303.       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  3304.       test "X$dir" = "X$file" && dir=.
  3305.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  3306.       rmfiles="$file"
  3307.       case "$name" in
  3308.       *.la)
  3309. # Possibly a libtool archive, so verify it.
  3310. if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  3311.   . $dir/$name
  3312.   # Delete the libtool libraries and symlinks.
  3313.   for n in $library_names; do
  3314.     rmfiles="$rmfiles $dir/$n"
  3315.   done
  3316.   test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
  3317.   $show "$rm $rmfiles"
  3318.   $run $rm $rmfiles
  3319.   if test -n "$library_names"; then
  3320.     # Do each command in the postuninstall commands.
  3321.     eval cmds="$postuninstall_cmds"
  3322.     IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  3323.     for cmd in $cmds; do
  3324.       IFS="$save_ifs"
  3325.       $show "$cmd"
  3326.       $run eval "$cmd"
  3327.     done
  3328.     IFS="$save_ifs"
  3329.   fi
  3330.   if test -n "$old_library"; then
  3331.     # Do each command in the old_postuninstall commands.
  3332.     eval cmds="$old_postuninstall_cmds"
  3333.     IFS="${IFS=  }"; save_ifs="$IFS"; IFS='~'
  3334.     for cmd in $cmds; do
  3335.       IFS="$save_ifs"
  3336.       $show "$cmd"
  3337.       $run eval "$cmd"
  3338.     done
  3339.     IFS="$save_ifs"
  3340.   fi
  3341.   # FIXME: should reinstall the best remaining shared library.
  3342. fi
  3343. ;;
  3344.       *.lo)
  3345. if test "$build_old_libs" = yes; then
  3346.   oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
  3347.   rmfiles="$rmfiles $dir/$oldobj"
  3348. fi
  3349. $show "$rm $rmfiles"
  3350. $run $rm $rmfiles
  3351. ;;
  3352.       *)
  3353. $show "$rm $rmfiles"
  3354. $run $rm $rmfiles
  3355. ;;
  3356.       esac
  3357.     done
  3358.     exit 0
  3359.     ;;
  3360.   "")
  3361.     $echo "$modename: you must specify a MODE" 1>&2
  3362.     $echo "$generic_help" 1>&2
  3363.     exit 1
  3364.     ;;
  3365.   esac
  3366.   $echo "$modename: invalid operation mode `$mode'" 1>&2
  3367.   $echo "$generic_help" 1>&2
  3368.   exit 1
  3369. fi # test -z "$show_help"
  3370. # We need to display help for each of the modes.
  3371. case "$mode" in
  3372. "") $echo 
  3373. "Usage: $modename [OPTION]... [MODE-ARG]...
  3374. Provide generalized library-building support services.
  3375.     --config          show all configuration variables
  3376.     --debug           enable verbose shell tracing
  3377. -n, --dry-run         display commands without modifying any files
  3378.     --features        display basic configuration information and exit
  3379.     --finish          same as `--mode=finish'
  3380.     --help            display this help message and exit
  3381.     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
  3382.     --quiet           same as `--silent'
  3383.     --silent          don't print informational messages
  3384.     --version         print version information
  3385. MODE must be one of the following:
  3386.       compile         compile a source file into a libtool object
  3387.       execute         automatically set library path, then run a program
  3388.       finish          complete the installation of libtool libraries
  3389.       install         install libraries or executables
  3390.       link            create a library or an executable
  3391.       uninstall       remove libraries from an installed directory
  3392. MODE-ARGS vary depending on the MODE.  Try `$modename --help --mode=MODE' for
  3393. a more detailed description of MODE."
  3394.   exit 0
  3395.   ;;
  3396. compile)
  3397.   $echo 
  3398. "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
  3399. Compile a source file into a libtool library object.
  3400. This mode accepts the following additional options:
  3401.   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  3402.   -static           always build a `.o' file suitable for static linking
  3403. COMPILE-COMMAND is a command to be used in creating a `standard' object file
  3404. from the given SOURCEFILE.
  3405. The output file name is determined by removing the directory component from
  3406. SOURCEFILE, then substituting the C source code suffix `.c' with the
  3407. library object suffix, `.lo'."
  3408.   ;;
  3409. execute)
  3410.   $echo 
  3411. "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
  3412. Automatically set library path, then run a program.
  3413. This mode accepts the following additional options:
  3414.   -dlopen FILE      add the directory containing FILE to the library path
  3415. This mode sets the library path environment variable according to `-dlopen'
  3416. flags.
  3417. If any of the ARGS are libtool executable wrappers, then they are translated
  3418. into their corresponding uninstalled binary, and any of their required library
  3419. directories are added to the library path.
  3420. Then, COMMAND is executed, with ARGS as arguments."
  3421.   ;;
  3422. finish)
  3423.   $echo 
  3424. "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
  3425. Complete the installation of libtool libraries.
  3426. Each LIBDIR is a directory that contains libtool libraries.
  3427. The commands that this mode executes may require superuser privileges.  Use
  3428. the `--dry-run' option if you just want to see what would be executed."
  3429.   ;;
  3430. install)
  3431.   $echo 
  3432. "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
  3433. Install executables or libraries.
  3434. INSTALL-COMMAND is the installation command.  The first component should be
  3435. either the `install' or `cp' program.
  3436. The rest of the components are interpreted as arguments to that command (only
  3437. BSD-compatible install options are recognized)."
  3438.   ;;
  3439. link)
  3440.   $echo 
  3441. "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
  3442. Link object files or libraries together to form another library, or to
  3443. create an executable program.
  3444. LINK-COMMAND is a command using the C compiler that you would use to create
  3445. a program from several object files.
  3446. The following components of LINK-COMMAND are treated specially:
  3447.   -all-static       do not do any dynamic linking at all
  3448.   -avoid-version    do not add a version suffix if possible
  3449.   -dlopen FILE      `-dlpreopen' FILE if it cannot be dlopened at runtime
  3450.   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  3451.   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  3452.   -export-symbols SYMFILE
  3453.     try to export only the symbols listed in SYMFILE
  3454.   -export-symbols-regex REGEX
  3455.     try to export only the symbols matching REGEX
  3456.   -LLIBDIR          search LIBDIR for required installed libraries
  3457.   -lNAME            OUTPUT-FILE requires the installed library libNAME
  3458.   -module           build a library that can dlopened
  3459.   -no-undefined     declare that a library does not refer to external symbols
  3460.   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  3461.   -release RELEASE  specify package release information
  3462.   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  3463.   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  3464.   -static           do not do any dynamic linking of libtool libraries
  3465.   -version-info CURRENT[:REVISION[:AGE]]
  3466.     specify library version info [each variable defaults to 0]
  3467. All other options (arguments beginning with `-') are ignored.
  3468. Every other argument is treated as a filename.  Files ending in `.la' are
  3469. treated as uninstalled libtool libraries, other files are standard or library
  3470. object files.
  3471. If the OUTPUT-FILE ends in `.la', then a libtool library is created,
  3472. only library objects (`.lo' files) may be specified, and `-rpath' is
  3473. required, except when creating a convenience library.
  3474. If OUTPUT-FILE ends in `.a' or `.lib', then a standard library is created
  3475. using `ar' and `ranlib', or on Windows using `lib'.
  3476. If OUTPUT-FILE ends in `.lo' or `.${objext}', then a reloadable object file
  3477. is created, otherwise an executable program is created."
  3478.   ;;
  3479. uninstall)
  3480.   $echo 
  3481. "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
  3482. Remove libraries from an installation directory.
  3483. RM is the name of the program to use to delete files associated with each FILE
  3484. (typically `/bin/rm').  RM-OPTIONS are options (such as `-f') to be passed
  3485. to RM.
  3486. If FILE is a libtool library, all the files associated with it are deleted.
  3487. Otherwise, only FILE itself is deleted using RM."
  3488.   ;;
  3489. *)
  3490.   $echo "$modename: invalid operation mode `$mode'" 1>&2
  3491.   $echo "$help" 1>&2
  3492.   exit 1
  3493.   ;;
  3494. esac
  3495. echo
  3496. $echo "Try `$modename --help' for more information about other modes."
  3497. exit 0
  3498. # Local Variables:
  3499. # mode:shell-script
  3500. # sh-indentation:2
  3501. # End: