ltmain.sh
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:217k
源码类别:

网格计算

开发平台:

Java

  1. # Generated from ltmain.m4sh.
  2. # ltmain.sh (GNU libtool) 2.2
  3. # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
  4. # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
  5. # This is free software; see the source for copying conditions.  There is NO
  6. # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  7. # GNU Libtool 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. # As a special exception to the GNU General Public License,
  13. # if you distribute this file as part of a program or library that
  14. # is built using GNU Libtool, you may include this file under the
  15. # same distribution terms that you use for the rest of that program.
  16. #
  17. # GNU Libtool is distributed in the hope that it will be useful, but
  18. # WITHOUT ANY WARRANTY; without even the implied warranty of
  19. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20. # General Public License for more details.
  21. #
  22. # You should have received a copy of the GNU General Public License
  23. # along with GNU Libtool; see the file COPYING.  If not, a copy
  24. # can be downloaded from http://www.gnu.org/licenses/gpl.html,
  25. # or obtained by writing to the Free Software Foundation, Inc.,
  26. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  27. # Usage: $progname [OPTION]... [MODE-ARG]...
  28. #
  29. # Provide generalized library-building support services.
  30. #
  31. #     --config             show all configuration variables
  32. #     --debug              enable verbose shell tracing
  33. # -n, --dry-run            display commands without modifying any files
  34. #     --features           display basic configuration information and exit
  35. #     --mode=MODE          use operation mode MODE
  36. #     --preserve-dup-deps  don't remove duplicate dependency libraries
  37. #     --quiet, --silent    don't print informational messages
  38. #     --tag=TAG            use configuration variables from tag TAG
  39. # -v, --verbose            print informational messages (default)
  40. #     --version            print version information
  41. # -h, --help               print short or long help message
  42. #
  43. # MODE must be one of the following:
  44. #
  45. #       clean              remove files from the build directory
  46. #       compile            compile a source file into a libtool object
  47. #       execute            automatically set library path, then run a program
  48. #       finish             complete the installation of libtool libraries
  49. #       install            install libraries or executables
  50. #       link               create a library or an executable
  51. #       uninstall          remove libraries from an installed directory
  52. #
  53. # MODE-ARGS vary depending on the MODE.
  54. # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
  55. #
  56. # When reporting a bug, please describe a test case to reproduce it and
  57. # include the following information:
  58. #
  59. #       host-triplet: $host
  60. #       shell: $SHELL
  61. #       compiler: $LTCC
  62. #       compiler flags: $LTCFLAGS
  63. #       linker: $LD (gnu? $with_gnu_ld)
  64. #       $progname: (GNU libtool) 2.2
  65. #       automake: $automake_version
  66. #       autoconf: $autoconf_version
  67. #
  68. # Report bugs to <bug-libtool@gnu.org>.
  69. PROGRAM=ltmain.sh
  70. PACKAGE=libtool
  71. VERSION=2.2
  72. TIMESTAMP=""
  73. package_revision=1.2599
  74. # Be Bourne compatible
  75. if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  76.   emulate sh
  77.   NULLCMD=:
  78.   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  79.   # is contrary to our usage.  Disable this feature.
  80.   alias -g '${1+"$@"}'='"$@"'
  81.   setopt NO_GLOB_SUBST
  82. else
  83.   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
  84. fi
  85. BIN_SH=xpg4; export BIN_SH # for Tru64
  86. DUALCASE=1; export DUALCASE # for MKS sh
  87. # NLS nuisances: We save the old values to restore during execute mode.
  88. # Only set LANG and LC_ALL to C if already set.
  89. # These must not be set unconditionally because not all systems understand
  90. # e.g. LANG=C (notably SCO).
  91. for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
  92. do
  93.   eval "if test "${$lt_var+set}" = set; then
  94.           save_$lt_var=$$lt_var
  95.           $lt_var=C
  96.   export $lt_var
  97. fi"
  98. done
  99. $lt_unset CDPATH
  100. : ${CP="cp -f"}
  101. : ${ECHO="echo"}
  102. : ${EGREP="/usr/bin/grep -E"}
  103. : ${FGREP="/usr/bin/grep -F"}
  104. : ${GREP="/usr/bin/grep"}
  105. : ${LN_S="ln -s"}
  106. : ${MAKE="make"}
  107. : ${MKDIR="mkdir"}
  108. : ${MV="mv -f"}
  109. : ${RM="rm -f"}
  110. : ${SED="/usr/bin/sed"}
  111. : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
  112. : ${Xsed="$SED -e 1s/^X//"}
  113. # Global variables:
  114. EXIT_SUCCESS=0
  115. EXIT_FAILURE=1
  116. EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
  117. EXIT_SKIP=77   # $? = 77 is used to indicate a skipped test to automake.
  118. exit_status=$EXIT_SUCCESS
  119. # Make sure IFS has a sensible default
  120. lt_nl='
  121. '
  122. IFS="  $lt_nl"
  123. dirname="s,/[^/]*$,,"
  124. basename="s,^.*/,,"
  125. # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
  126. # is ksh but when the shell is invoked as "sh" and the current value of
  127. # the _XPG environment variable is not equal to 1 (one), the special
  128. # positional parameter $0, within a function call, is the name of the
  129. # function.
  130. progpath="$0"
  131. # The name of this program:
  132. # In the unlikely event $progname began with a '-', it would play havoc with
  133. # func_echo (imagine progname=-n), so we prepend ./ in that case:
  134. progname=`$ECHO "X$progpath" | $Xsed -e "$basename" -e 's,^-,./-,'`
  135. # Make sure we have an absolute path for reexecution:
  136. case $progpath in
  137.   [\/]*|[A-Za-z]:\*) ;;
  138.   *[\/]*)
  139.      progdir=`$ECHO "X$progpath" | $Xsed -e "$dirname"`
  140.      progdir=`cd "$progdir" && pwd`
  141.      progpath="$progdir/$progname"
  142.      ;;
  143.   *)
  144.      save_IFS="$IFS"
  145.      IFS=:
  146.      for progdir in $PATH; do
  147.        IFS="$save_IFS"
  148.        test -x "$progdir/$progname" && break
  149.      done
  150.      IFS="$save_IFS"
  151.      test -n "$progdir" || progdir=`pwd`
  152.      progpath="$progdir/$progname"
  153.      ;;
  154. esac
  155. # Sed substitution that helps us do robust quoting.  It backslashifies
  156. # metacharacters that are still active within double-quoted strings.
  157. Xsed="${SED}"' -e 1s/^X//'
  158. sed_quote_subst='s/([`"$\])/\1/g'
  159. # Same as above, but do not quote variable references.
  160. double_quote_subst='s/(["`\])/\1/g'
  161. # Re-`' parameter expansions in output of double_quote_subst that were
  162. # `'-ed in input to the same.  If an odd number of `' preceded a '$'
  163. # in input to double_quote_subst, that '$' was protected from expansion.
  164. # Since each input `' is now two `'s, look for any number of runs of
  165. # four `'s followed by two `'s and then a '$'.  `' that '$'.
  166. bs='\'
  167. bs2='\\'
  168. bs4='\\\\'
  169. dollar='$'
  170. sed_double_backslash="
  171.   s/$bs4/&\
  172. /g
  173.   s/^$bs2$dollar/$bs&/
  174.   s/\([^$bs]\)$bs2$dollar/\1$bs2$bs$dollar/g
  175.   s/n//g"
  176. # Standard options:
  177. opt_dry_run=false
  178. opt_help=false
  179. opt_quiet=false
  180. opt_verbose=false
  181. # func_echo arg...
  182. # Echo program name prefixed message, along with the current mode
  183. # name if it has been set yet.
  184. func_echo ()
  185. {
  186.     $ECHO "$progname${mode+: }$mode: $*"
  187. }
  188. # func_verbose arg...
  189. # Echo program name prefixed message in verbose mode only.
  190. func_verbose ()
  191. {
  192.     $opt_verbose && func_echo ${1+"$@"}
  193.     # A bug in bash halts the script if the last line of a function
  194.     # fails when set -e is in force, so we need another command to
  195.     # work around that:
  196.     :
  197. }
  198. # func_error arg...
  199. # Echo program name prefixed message to standard error.
  200. func_error ()
  201. {
  202.     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
  203. }
  204. # func_warning arg...
  205. # Echo program name prefixed warning message to standard error.
  206. func_warning ()
  207. {
  208.     $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
  209. }
  210. # func_fatal_error arg...
  211. # Echo program name prefixed message to standard error, and exit.
  212. func_fatal_error ()
  213. {
  214.     func_error ${1+"$@"}
  215.     exit $EXIT_FAILURE
  216. }
  217. # func_fatal_help arg...
  218. # Echo program name prefixed message to standard error, followed by
  219. # a help hint, and exit.
  220. func_fatal_help ()
  221. {
  222.     func_error ${1+"$@"}
  223.     func_fatal_error "$help"
  224. }
  225. help="Try `$progname --help' for more information."  ## default
  226. # func_grep expression filename
  227. # Check whether EXPRESSION matches any line of FILENAME, without output.
  228. func_grep ()
  229. {
  230.     $GREP "$1" "$2" >/dev/null 2>&1
  231. }
  232. # func_mkdir_p directory-path
  233. # Make sure the entire path to DIRECTORY-PATH is available.
  234. func_mkdir_p ()
  235. {
  236.     my_directory_path="$1"
  237.     my_dir_list=
  238.     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
  239.       # Protect directory names starting with `-'
  240.       case $my_directory_path in
  241.         -*) my_directory_path="./$my_directory_path" ;;
  242.       esac
  243.       # While some portion of DIR does not yet exist...
  244.       while test ! -d "$my_directory_path"; do
  245.         # ...make a list in topmost first order.  Use a colon delimited
  246. # list incase some portion of path contains whitespace.
  247.         my_dir_list="$my_directory_path:$my_dir_list"
  248.         # If the last portion added has no slash in it, the list is done
  249.         case $my_directory_path in */*) ;; *) break ;; esac
  250.         # ...otherwise throw away the child directory and loop
  251.         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
  252.       done
  253.       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
  254.       save_mkdir_p_IFS="$IFS"; IFS=':'
  255.       for my_dir in $my_dir_list; do
  256. IFS="$save_mkdir_p_IFS"
  257.         # mkdir can fail with a `File exist' error if two processes
  258.         # try to create one of the directories concurrently.  Don't
  259.         # stop in that case!
  260.         $MKDIR "$my_dir" 2>/dev/null || :
  261.       done
  262.       IFS="$save_mkdir_p_IFS"
  263.       # Bail out if we (or some other process) failed to create a directory.
  264.       test -d "$my_directory_path" || 
  265.         func_fatal_error "Failed to create `$1'"
  266.     fi
  267. }
  268. # func_mktempdir [string]
  269. # Make a temporary directory that won't clash with other running
  270. # libtool processes, and avoids race conditions if possible.  If
  271. # given, STRING is the basename for that directory.
  272. func_mktempdir ()
  273. {
  274.     my_template="${TMPDIR-/tmp}/${1-$progname}"
  275.     if test "$opt_dry_run" = ":"; then
  276.       # Return a directory name, but don't create it in dry-run mode
  277.       my_tmpdir="${my_template}-$$"
  278.     else
  279.       # If mktemp works, use that first and foremost
  280.       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
  281.       if test ! -d "$my_tmpdir"; then
  282.         # Failing that, at least try and use $RANDOM to avoid a race
  283.         my_tmpdir="${my_template}-${RANDOM-0}$$"
  284.         save_mktempdir_umask=`umask`
  285.         umask 0077
  286.         $MKDIR "$my_tmpdir"
  287.         umask $save_mktempdir_umask
  288.       fi
  289.       # If we're not in dry-run mode, bomb out on failure
  290.       test -d "$my_tmpdir" || 
  291.         func_fatal_error "cannot create temporary directory `$my_tmpdir'"
  292.     fi
  293.     $ECHO "X$my_tmpdir" | $Xsed
  294. }
  295. # func_quote_for_eval arg
  296. # Aesthetically quote ARG to be evaled later.
  297. # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
  298. # is double-quoted, suitable for a subsequent eval, whereas
  299. # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
  300. # which are still active within double quotes backslashified.
  301. func_quote_for_eval ()
  302. {
  303.     case $1 in
  304.       *[\`"$]*)
  305. func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
  306.       *)
  307.         func_quote_for_eval_unquoted_result="$1" ;;
  308.     esac
  309.     case $func_quote_for_eval_unquoted_result in
  310.       # Double-quote args containing shell metacharacters to delay
  311.       # word splitting, command substitution and and variable
  312.       # expansion for a subsequent eval.
  313.       # Many Bourne shells cannot handle close brackets correctly
  314.       # in scan sets, so we specify it separately.
  315.       *[[~#^&*(){}|;<>?'  ]*|*]*|"")
  316.         func_quote_for_eval_result=""$func_quote_for_eval_unquoted_result""
  317.         ;;
  318.       *)
  319.         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
  320.     esac
  321. }
  322. # func_quote_for_expand arg
  323. # Aesthetically quote ARG to be evaled later; same as above,
  324. # but do not quote variable references.
  325. func_quote_for_expand ()
  326. {
  327.     case $1 in
  328.       *[\`"]*)
  329. my_arg=`$ECHO "X$1" | $Xsed 
  330.     -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
  331.       *)
  332.         my_arg="$1" ;;
  333.     esac
  334.     case $my_arg in
  335.       # Double-quote args containing shell metacharacters to delay
  336.       # word splitting and command substitution for a subsequent eval.
  337.       # Many Bourne shells cannot handle close brackets correctly
  338.       # in scan sets, so we specify it separately.
  339.       *[[~#^&*(){}|;<>?'  ]*|*]*|"")
  340.         my_arg=""$my_arg""
  341.         ;;
  342.     esac
  343.     func_quote_for_expand_result="$my_arg"
  344. }
  345. # func_show_eval cmd [fail_exp]
  346. # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
  347. # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
  348. # is given, then evaluate it.
  349. func_show_eval ()
  350. {
  351.     my_cmd="$1"
  352.     my_fail_exp="${2-:}"
  353.     ${opt_silent-false} || {
  354.       func_quote_for_expand "$my_cmd"
  355.       eval "func_echo $func_quote_for_expand_result"
  356.     }
  357.     if ${opt_dry_run-false}; then :; else
  358.       eval "$my_cmd"
  359.       my_status=$?
  360.       if test "$my_status" -eq 0; then :; else
  361. eval "(exit $my_status); $my_fail_exp"
  362.       fi
  363.     fi
  364. }
  365. # func_version
  366. # Echo version message to standard output and exit.
  367. func_version ()
  368. {
  369.     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
  370.         s/^# //
  371. s/^# *$//
  372.         s/((C))[ 0-9,-]*( [1-9][0-9]*)/12/
  373.         p
  374.      }' < "$progpath"
  375.      exit $?
  376. }
  377. # func_usage
  378. # Echo short help message to standard output and exit.
  379. func_usage ()
  380. {
  381.     $SED -n '/^# Usage:/,/# -h/ {
  382.         s/^# //
  383. s/^# *$//
  384. s/$progname/'$progname'/
  385. p
  386.     }' < "$progpath"
  387.     $ECHO
  388.     $ECHO "run `$progname --help | more' for full usage"
  389.     exit $?
  390. }
  391. # func_help
  392. # Echo long help message to standard output and exit.
  393. func_help ()
  394. {
  395.     $SED -n '/^# Usage:/,/# Report bugs to/ {
  396.         s/^# //
  397. s/^# *$//
  398. s*$progname*'$progname'*
  399. s*$host*'"$host"'*
  400. s*$SHELL*'"$SHELL"'*
  401. s*$LTCC*'"$LTCC"'*
  402. s*$LTCFLAGS*'"$LTCFLAGS"'*
  403. s*$LD*'"$LD"'*
  404. s/$with_gnu_ld/'"$with_gnu_ld"'/
  405. s/$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
  406. s/$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
  407. p
  408.      }' < "$progpath"
  409.     exit $?
  410. }
  411. # func_missing_arg argname
  412. # Echo program name prefixed message to standard error and set global
  413. # exit_cmd.
  414. func_missing_arg ()
  415. {
  416.     func_error "missing argument for $1"
  417.     exit_cmd=exit
  418. }
  419. exit_cmd=:
  420. # Check that we have a working $ECHO.
  421. if test "X$1" = X--no-reexec; then
  422.   # Discard the --no-reexec flag, and continue.
  423.   shift
  424. elif test "X$1" = X--fallback-echo; then
  425.   # Avoid inline document here, it may be left over
  426.   :
  427. elif test "X`{ $ECHO 't'; } 2>/dev/null`" = 'Xt'; then
  428.   # Yippee, $ECHO works!
  429.   :
  430. else
  431.   # Restart under the correct shell, and then maybe $ECHO will work.
  432.   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
  433. fi
  434. if test "X$1" = X--fallback-echo; then
  435.   # used as fallback echo
  436.   shift
  437.   cat <<EOF
  438. $*
  439. EOF
  440.   exit $EXIT_SUCCESS
  441. fi
  442. magic="%%%MAGIC variable%%%"
  443. magic_exe="%%%MAGIC EXE variable%%%"
  444. # Global variables.
  445. # $mode is unset
  446. nonopt=
  447. execute_dlfiles=
  448. preserve_args=
  449. lo2o="s/\.lo$/.${objext}/"
  450. o2lo="s/\.${objext}$/.lo/"
  451. extracted_archives=
  452. extracted_serial=0
  453. opt_dry_run=false
  454. opt_duplicate_deps=false
  455. opt_silent=false
  456. opt_debug=:
  457. # If this variable is set in any of the actions, the command in it
  458. # will be execed at the end.  This prevents here-documents from being
  459. # left over by shells.
  460. exec_cmd=
  461. # func_fatal_configuration arg...
  462. # Echo program name prefixed message to standard error, followed by
  463. # a configuration failure hint, and exit.
  464. func_fatal_configuration ()
  465. {
  466.     func_error ${1+"$@"}
  467.     func_error "See the $PACKAGE documentation for more information."
  468.     func_fatal_error "Fatal configuration error."
  469. }
  470. # func_config
  471. # Display the configuration for all the tags in this script.
  472. func_config ()
  473. {
  474.     re_begincf='^# ### BEGIN LIBTOOL'
  475.     re_endcf='^# ### END LIBTOOL'
  476.     # Default configuration.
  477.     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,$d" < "$progpath"
  478.     # Now print the configurations for the tags.
  479.     for tagname in $taglist; do
  480.       $SED -n "/$re_begincf TAG CONFIG: $tagname$/,/$re_endcf TAG CONFIG: $tagname$/p" < "$progpath"
  481.     done
  482.     exit $?
  483. }
  484. # func_features
  485. # Display the features supported by this script.
  486. func_features ()
  487. {
  488.     $ECHO "host: $host"
  489.     if test "$build_libtool_libs" = yes; then
  490.       $ECHO "enable shared libraries"
  491.     else
  492.       $ECHO "disable shared libraries"
  493.     fi
  494.     if test "$build_old_libs" = yes; then
  495.       $ECHO "enable static libraries"
  496.     else
  497.       $ECHO "disable static libraries"
  498.     fi
  499.     exit $?
  500. }
  501. # func_enable_tag tagname
  502. # Verify that TAGNAME is valid, and either flag an error and exit, or
  503. # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
  504. # variable here.
  505. func_enable_tag ()
  506. {
  507.   # Global variable:
  508.   tagname="$1"
  509.   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$"
  510.   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname$"
  511.   sed_extractcf="/$re_begincf/,/$re_endcf/p"
  512.   # Validate tagname.
  513.   case $tagname in
  514.     *[!-_A-Za-z0-9,/]*)
  515.       func_fatal_error "invalid tag name: $tagname"
  516.       ;;
  517.   esac
  518.   # Don't test for the "default" C tag, as we know it's
  519.   # there but not specially marked.
  520.   case $tagname in
  521.     CC) ;;
  522.     *)
  523.       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
  524. taglist="$taglist $tagname"
  525. # Evaluate the configuration.  Be careful to quote the path
  526. # and the sed script, to avoid splitting on whitespace, but
  527. # also don't use non-portable quotes within backquotes within
  528. # quotes we have to do it in 2 steps:
  529. extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
  530. eval "$extractedcf"
  531.       else
  532. func_error "ignoring unknown tag $tagname"
  533.       fi
  534.       ;;
  535.   esac
  536. }
  537. func_mode_help ()
  538. {
  539.     # We need to display help for each of the modes.
  540.     case $mode in
  541.       "")
  542.         # Generic help is extracted from the usage comments
  543.         # at the start of this file.
  544.         func_help
  545.         ;;
  546.       clean)
  547.         $ECHO 
  548. "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
  549. Remove files from the build directory.
  550. RM is the name of the program to use to delete files associated with each FILE
  551. (typically `/bin/rm').  RM-OPTIONS are options (such as `-f') to be passed
  552. to RM.
  553. If FILE is a libtool library, object or program, all the files associated
  554. with it are deleted. Otherwise, only FILE itself is deleted using RM."
  555.         ;;
  556.       compile)
  557.       $ECHO 
  558. "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
  559. Compile a source file into a libtool library object.
  560. This mode accepts the following additional options:
  561.   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  562.   -no-suppress      do not suppress compiler output for multiple passes
  563.   -prefer-pic       try to building PIC objects only
  564.   -prefer-non-pic   try to building non-PIC objects only
  565.   -shared           do not build a `.o' file suitable for static linking
  566.   -static           only build a `.o' file suitable for static linking
  567. COMPILE-COMMAND is a command to be used in creating a `standard' object file
  568. from the given SOURCEFILE.
  569. The output file name is determined by removing the directory component from
  570. SOURCEFILE, then substituting the C source code suffix `.c' with the
  571. library object suffix, `.lo'."
  572.         ;;
  573.       execute)
  574.         $ECHO 
  575. "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
  576. Automatically set library path, then run a program.
  577. This mode accepts the following additional options:
  578.   -dlopen FILE      add the directory containing FILE to the library path
  579. This mode sets the library path environment variable according to `-dlopen'
  580. flags.
  581. If any of the ARGS are libtool executable wrappers, then they are translated
  582. into their corresponding uninstalled binary, and any of their required library
  583. directories are added to the library path.
  584. Then, COMMAND is executed, with ARGS as arguments."
  585.         ;;
  586.       finish)
  587.         $ECHO 
  588. "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
  589. Complete the installation of libtool libraries.
  590. Each LIBDIR is a directory that contains libtool libraries.
  591. The commands that this mode executes may require superuser privileges.  Use
  592. the `--dry-run' option if you just want to see what would be executed."
  593.         ;;
  594.       install)
  595.         $ECHO 
  596. "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
  597. Install executables or libraries.
  598. INSTALL-COMMAND is the installation command.  The first component should be
  599. either the `install' or `cp' program.
  600. The following components of INSTALL-COMMAND are treated specially:
  601.   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
  602. The rest of the components are interpreted as arguments to that command (only
  603. BSD-compatible install options are recognized)."
  604.         ;;
  605.       link)
  606.         $ECHO 
  607. "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
  608. Link object files or libraries together to form another library, or to
  609. create an executable program.
  610. LINK-COMMAND is a command using the C compiler that you would use to create
  611. a program from several object files.
  612. The following components of LINK-COMMAND are treated specially:
  613.   -all-static       do not do any dynamic linking at all
  614.   -avoid-version    do not add a version suffix if possible
  615.   -dlopen FILE      `-dlpreopen' FILE if it cannot be dlopened at runtime
  616.   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  617.   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  618.   -export-symbols SYMFILE
  619.                     try to export only the symbols listed in SYMFILE
  620.   -export-symbols-regex REGEX
  621.                     try to export only the symbols matching REGEX
  622.   -LLIBDIR          search LIBDIR for required installed libraries
  623.   -lNAME            OUTPUT-FILE requires the installed library libNAME
  624.   -module           build a library that can dlopened
  625.   -no-fast-install  disable the fast-install mode
  626.   -no-install       link a not-installable executable
  627.   -no-undefined     declare that a library does not refer to external symbols
  628.   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  629.   -objectlist FILE  Use a list of object files found in FILE to specify objects
  630.   -precious-files-regex REGEX
  631.                     don't remove output files matching REGEX
  632.   -release RELEASE  specify package release information
  633.   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  634.   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  635.   -shared           only do dynamic linking of libtool libraries
  636.   -shrext SUFFIX    override the standard shared library file extension
  637.   -static           do not do any dynamic linking of uninstalled libtool libraries
  638.   -static-libtool-libs
  639.                     do not do any dynamic linking of libtool libraries
  640.   -version-info CURRENT[:REVISION[:AGE]]
  641.                     specify library version info [each variable defaults to 0]
  642.   -weak LIBNAME     declare that the target provides the LIBNAME interface
  643. All other options (arguments beginning with `-') are ignored.
  644. Every other argument is treated as a filename.  Files ending in `.la' are
  645. treated as uninstalled libtool libraries, other files are standard or library
  646. object files.
  647. If the OUTPUT-FILE ends in `.la', then a libtool library is created,
  648. only library objects (`.lo' files) may be specified, and `-rpath' is
  649. required, except when creating a convenience library.
  650. If OUTPUT-FILE ends in `.a' or `.lib', then a standard library is created
  651. using `ar' and `ranlib', or on Windows using `lib'.
  652. If OUTPUT-FILE ends in `.lo' or `.${objext}', then a reloadable object file
  653. is created, otherwise an executable program is created."
  654.         ;;
  655.       uninstall)
  656.         $ECHO 
  657. "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
  658. Remove libraries from an installation directory.
  659. RM is the name of the program to use to delete files associated with each FILE
  660. (typically `/bin/rm').  RM-OPTIONS are options (such as `-f') to be passed
  661. to RM.
  662. If FILE is a libtool library, all the files associated with it are deleted.
  663. Otherwise, only FILE itself is deleted using RM."
  664.         ;;
  665.       *)
  666.         func_fatal_help "invalid operation mode `$mode'"
  667.         ;;
  668.     esac
  669.     $ECHO
  670.     $ECHO "Try `$progname --help' for more information about other modes."
  671.     exit $?
  672. }
  673. # Generated shell functions inserted here.
  674. # Parse options once, thoroughly.  This comes as soon as possible in
  675. # the script to make things like `libtool --version' happen quickly.
  676. {
  677.   # Shorthand for --mode=foo, only valid as the first argument
  678.   case $1 in
  679.   clean|clea|cle|cl)
  680.     shift; set dummy --mode clean ${1+"$@"}; shift
  681.     ;;
  682.   compile|compil|compi|comp|com|co|c)
  683.     shift; set dummy --mode compile ${1+"$@"}; shift
  684.     ;;
  685.   execute|execut|execu|exec|exe|ex|e)
  686.     shift; set dummy --mode execute ${1+"$@"}; shift
  687.     ;;
  688.   finish|finis|fini|fin|fi|f)
  689.     shift; set dummy --mode finish ${1+"$@"}; shift
  690.     ;;
  691.   install|instal|insta|inst|ins|in|i)
  692.     shift; set dummy --mode install ${1+"$@"}; shift
  693.     ;;
  694.   link|lin|li|l)
  695.     shift; set dummy --mode link ${1+"$@"}; shift
  696.     ;;
  697.   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
  698.     shift; set dummy --mode uninstall ${1+"$@"}; shift
  699.     ;;
  700.   esac
  701.   # Parse non-mode specific arguments:
  702.   while test "$#" -gt 0; do
  703.     opt="$1"
  704.     shift
  705.     case $opt in
  706.       --config) func_config ;;
  707.       --debug) preserve_args="$preserve_args $opt"
  708. func_echo "enabling shell trace mode"
  709. opt_debug='set -x'
  710. $opt_debug
  711. ;;
  712.       -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
  713. execute_dlfiles="$execute_dlfiles $1"
  714. shift
  715. ;;
  716.       --dry-run | -n) opt_dry_run=: ;;
  717.       --features)       func_features ;;
  718.       --finish) mode="finish" ;;
  719.       --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
  720. case $1 in
  721.   # Valid mode arguments:
  722.   clean) ;;
  723.   compile) ;;
  724.   execute) ;;
  725.   finish) ;;
  726.   install) ;;
  727.   link) ;;
  728.   relink) ;;
  729.   uninstall) ;;
  730.   # Catch anything else as an error
  731.   *) func_error "invalid argument for $opt"
  732.      exit_cmd=exit
  733.      break
  734.      ;;
  735.         esac
  736. mode="$1"
  737. shift
  738. ;;
  739.       --preserve-dup-deps)
  740. opt_duplicate_deps=: ;;
  741.       --quiet|--silent) preserve_args="$preserve_args $opt"
  742. opt_silent=:
  743. ;;
  744.       --verbose| -v) preserve_args="$preserve_args $opt"
  745. opt_silent=false
  746. ;;
  747.       --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
  748. preserve_args="$preserve_args $opt $1"
  749. func_enable_tag "$1" # tagname is set here
  750. shift
  751. ;;
  752.       # Separate optargs to long options:
  753.       -dlopen=*|--mode=*|--tag=*)
  754. func_opt_split "$opt"
  755. set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
  756. shift
  757. ;;
  758.       -?|-h) func_usage ;;
  759.       --help) opt_help=: ;;
  760.       --version) func_version ;;
  761.       -*) func_fatal_help "unrecognized option `$opt'" ;;
  762.       *) nonopt="$opt"
  763. break
  764. ;;
  765.     esac
  766.   done
  767.   # Now that we've collected a possible --mode arg, show help if necessary
  768.   $opt_help && func_mode_help
  769.   case $host in
  770.     *cygwin* | *mingw* | *pw32*)
  771.       # don't eliminate duplications in $postdeps and $predeps
  772.       opt_duplicate_compiler_generated_deps=:
  773.       ;;
  774.     *)
  775.       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
  776.       ;;
  777.   esac
  778.   # Having warned about all mis-specified options, bail out if
  779.   # anything was wrong.
  780.   $exit_cmd $EXIT_FAILURE
  781. }
  782. # func_check_version_match
  783. # Ensure that we are using m4 macros, and libtool script from the same
  784. # release of libtool.
  785. func_check_version_match ()
  786. {
  787.   if test "$package_revision" != "$macro_revision"; then
  788.     if test "$VERSION" != "$macro_version"; then
  789.       if test -z "$macro_version"; then
  790.         cat >&2 <<_LT_EOF
  791. $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
  792. $progname: definition of this LT_INIT comes from an older release.
  793. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
  794. $progname: and run autoconf again.
  795. _LT_EOF
  796.       else
  797.         cat >&2 <<_LT_EOF
  798. $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
  799. $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
  800. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
  801. $progname: and run autoconf again.
  802. _LT_EOF
  803.       fi
  804.     else
  805.       cat >&2 <<_LT_EOF
  806. $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
  807. $progname: but the definition of this LT_INIT comes from revision $macro_revision.
  808. $progname: You should recreate aclocal.m4 with macros from revision $package_revision
  809. $progname: of $PACKAGE $VERSION and run autoconf again.
  810. _LT_EOF
  811.     fi
  812.     exit $EXIT_MISMATCH
  813.   fi
  814. }
  815. ## ----------- ##
  816. ##    Main.    ##
  817. ## ----------- ##
  818. {
  819.   # Sanity checks first:
  820.   func_check_version_match
  821.   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  822.     func_fatal_configuration "not configured to build any kind of library"
  823.   fi
  824.   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
  825.   # Darwin sucks
  826.   eval std_shrext="$shrext_cmds"
  827.   # Only execute mode is allowed to have -dlopen flags.
  828.   if test -n "$execute_dlfiles" && test "$mode" != execute; then
  829.     func_error "unrecognized option `-dlopen'"
  830.     $ECHO "$help" 1>&2
  831.     exit $EXIT_FAILURE
  832.   fi
  833.   # Change the help message to a mode-specific one.
  834.   generic_help="$help"
  835.   help="Try `$progname --help --mode=$mode' for more information."
  836. }
  837. # func_lalib_p file
  838. # True iff FILE is a libtool `.la' library or `.lo' object file.
  839. # This function is only a basic sanity check; it will hardly flush out
  840. # determined imposters.
  841. func_lalib_p ()
  842. {
  843.     $SED -e 4q "$1" 2>/dev/null 
  844.       | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
  845. }
  846. # func_lalib_unsafe_p file
  847. # True iff FILE is a libtool `.la' library or `.lo' object file.
  848. # This function implements the same check as func_lalib_p without
  849. # resorting to external programs.  To this end, it redirects stdin and
  850. # closes it afterwards, without saving the original file descriptor.
  851. # As a safety measure, use it only where a negative result would be
  852. # fatal anyway.  Works if `file' does not exist.
  853. func_lalib_unsafe_p ()
  854. {
  855.     lalib_p=no
  856.     if test -r "$1" && exec 5<&1 <"$1"; then
  857. for lalib_p_l in 1 2 3 4
  858. do
  859.     read lalib_p_line
  860.     case "$lalib_p_line" in
  861. # Generated by *$PACKAGE* ) lalib_p=yes; break;;
  862.     esac
  863. done
  864. exec 1<&5 5<&-
  865.     fi
  866.     test "$lalib_p" = yes
  867. }
  868. # func_ltwrapper_script_p file
  869. # True iff FILE is a libtool wrapper script
  870. # This function is only a basic sanity check; it will hardly flush out
  871. # determined imposters.
  872. func_ltwrapper_script_p ()
  873. {
  874.     func_lalib_p "$1"
  875. }
  876. # func_ltwrapper_executable_p file
  877. # True iff FILE is a libtool wrapper executable
  878. # This function is only a basic sanity check; it will hardly flush out
  879. # determined imposters.
  880. func_ltwrapper_executable_p ()
  881. {
  882.     func_ltwrapper_exec_suffix=
  883.     case $1 in
  884.     *.exe) ;;
  885.     *) func_ltwrapper_exec_suffix=.exe ;;
  886.     esac
  887.     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
  888. }
  889. # func_ltwrapper_scriptname file
  890. # Assumes file is an ltwrapper_executable
  891. # uses $file to determine the appropriate filename for a
  892. # temporary ltwrapper_script.
  893. func_ltwrapper_scriptname ()
  894. {
  895.     func_ltwrapper_scriptname_result=""
  896.     if func_ltwrapper_executable_p "$1"; then
  897. func_dirname_and_basename "$1" "" "."
  898. func_stripname '' '.exe' "$func_basename_result"
  899. func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
  900.     fi
  901. }
  902. # func_ltwrapper_p file
  903. # True iff FILE is a libtool wrapper script or wrapper executable
  904. # This function is only a basic sanity check; it will hardly flush out
  905. # determined imposters.
  906. func_ltwrapper_p ()
  907. {
  908.     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
  909. }
  910. # func_execute_cmds commands fail_cmd
  911. # Execute tilde-delimited COMMANDS.
  912. # If FAIL_CMD is given, eval that upon failure.
  913. # FAIL_CMD may read-access the current command in variable CMD!
  914. func_execute_cmds ()
  915. {
  916.     $opt_debug
  917.     save_ifs=$IFS; IFS='~'
  918.     for cmd in $1; do
  919.       IFS=$save_ifs
  920.       eval cmd="$cmd"
  921.       func_show_eval "$cmd" "${2-:}"
  922.     done
  923.     IFS=$save_ifs
  924. }
  925. # func_source file
  926. # Source FILE, adding directory component if necessary.
  927. # Note that it is not necessary on cygwin/mingw to append a dot to
  928. # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
  929. # behavior happens only for exec(3), not for open(2)!  Also, sourcing
  930. # `FILE.' does not work on cygwin managed mounts.
  931. func_source ()
  932. {
  933.     $opt_debug
  934.     case $1 in
  935.     */* | *\*) . "$1" ;;
  936.     *) . "./$1" ;;
  937.     esac
  938. }
  939. # func_win32_libid arg
  940. # return the library type of file 'arg'
  941. #
  942. # Need a lot of goo to handle *both* DLLs and import libs
  943. # Has to be a shell function in order to 'eat' the argument
  944. # that is supplied when $file_magic_command is called.
  945. func_win32_libid ()
  946. {
  947.   $opt_debug
  948.   win32_libid_type="unknown"
  949.   win32_fileres=`file -L $1 2>/dev/null`
  950.   case $win32_fileres in
  951.   *ar archive import library*) # definitely import
  952.     win32_libid_type="x86 archive import"
  953.     ;;
  954.   *ar archive*) # could be an import, or static
  955.     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
  956.        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
  957.       win32_nmres=`eval $NM -f posix -A $1 |
  958. $SED -n -e '
  959.     1,100{
  960. / I /{
  961.     s,.*,import,
  962.     p
  963.     q
  964. }
  965.     }'`
  966.       case $win32_nmres in
  967.       import*)  win32_libid_type="x86 archive import";;
  968.       *)        win32_libid_type="x86 archive static";;
  969.       esac
  970.     fi
  971.     ;;
  972.   *DLL*)
  973.     win32_libid_type="x86 DLL"
  974.     ;;
  975.   *executable*) # but shell scripts are "executable" too...
  976.     case $win32_fileres in
  977.     *MS Windows PE Intel*)
  978.       win32_libid_type="x86 DLL"
  979.       ;;
  980.     esac
  981.     ;;
  982.   esac
  983.   $ECHO "$win32_libid_type"
  984. }
  985. # func_infer_tag arg
  986. # Infer tagged configuration to use if any are available and
  987. # if one wasn't chosen via the "--tag" command line option.
  988. # Only attempt this if the compiler in the base compile
  989. # command doesn't match the default compiler.
  990. # arg is usually of the form 'gcc ...'
  991. func_infer_tag ()
  992. {
  993.     $opt_debug
  994.     if test -n "$available_tags" && test -z "$tagname"; then
  995.       CC_quoted=
  996.       for arg in $CC; do
  997.         func_quote_for_eval "$arg"
  998. CC_quoted="$CC_quoted $func_quote_for_eval_result"
  999.       done
  1000.       case $@ in
  1001.       # Blanks in the command may have been stripped by the calling shell,
  1002.       # but not from the CC environment variable when configure was run.
  1003.       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
  1004.       # Blanks at the start of $base_compile will cause this to fail
  1005.       # if we don't check for them as well.
  1006.       *)
  1007. for z in $available_tags; do
  1008.   if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
  1009.     # Evaluate the configuration.
  1010.     eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
  1011.     CC_quoted=
  1012.     for arg in $CC; do
  1013.       # Double-quote args containing other shell metacharacters.
  1014.       func_quote_for_eval "$arg"
  1015.       CC_quoted="$CC_quoted $func_quote_for_eval_result"
  1016.     done
  1017.     case "$@ " in
  1018.       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
  1019.       # The compiler in the base compile command matches
  1020.       # the one in the tagged configuration.
  1021.       # Assume this is the tagged configuration we want.
  1022.       tagname=$z
  1023.       break
  1024.       ;;
  1025.     esac
  1026.   fi
  1027. done
  1028. # If $tagname still isn't set, then no tagged configuration
  1029. # was found and let the user know that the "--tag" command
  1030. # line option must be used.
  1031. if test -z "$tagname"; then
  1032.   func_echo "unable to infer tagged configuration"
  1033.   func_fatal_error "specify a tag with `--tag'"
  1034. # else
  1035. #   func_verbose "using $tagname tagged configuration"
  1036. fi
  1037. ;;
  1038.       esac
  1039.     fi
  1040. }
  1041. # func_generate_dlsyms outputname originator pic_p
  1042. # Extract symbols from dlprefiles and create ${outputname}S.o with
  1043. # a dlpreopen symbol table.
  1044. func_generate_dlsyms ()
  1045. {
  1046.     $opt_debug
  1047.     my_outputname="$1"
  1048.     my_originator="$2"
  1049.     my_pic_p="${3-no}"
  1050.     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
  1051.     my_dlsyms=
  1052.     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  1053.       if test -n "$NM" && test -n "$global_symbol_pipe"; then
  1054. my_dlsyms="${my_outputname}S.c"
  1055.       else
  1056. func_error "not configured to extract global symbols from dlpreopened files"
  1057.       fi
  1058.     fi
  1059.     if test -n "$my_dlsyms"; then
  1060.       case $my_dlsyms in
  1061.       "") ;;
  1062.       *.c)
  1063. # Discover the nlist of each of the dlfiles.
  1064. nlist="$output_objdir/${my_outputname}.nm"
  1065. func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
  1066. # Parse the name list into a source file.
  1067. func_verbose "creating $output_objdir/$my_dlsyms"
  1068. $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "
  1069. /* $my_dlsyms - symbol resolution table for `$my_outputname' dlsym emulation. */
  1070. /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
  1071. #ifdef __cplusplus
  1072. extern "C" {
  1073. #endif
  1074. /* External symbol declarations for the compiler. */
  1075. "
  1076. if test "$dlself" = yes; then
  1077.   func_verbose "generating symbol list for `$output'"
  1078.   $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
  1079.   # Add our own program objects to the symbol list.
  1080.   progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  1081.   for progfile in $progfiles; do
  1082.     func_verbose "extracting global C symbols from `$progfile'"
  1083.     $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
  1084.   done
  1085.   if test -n "$exclude_expsyms"; then
  1086.     $opt_dry_run || {
  1087.       eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
  1088.       eval '$MV "$nlist"T "$nlist"'
  1089.     }
  1090.   fi
  1091.   if test -n "$export_symbols_regex"; then
  1092.     $opt_dry_run || {
  1093.       eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
  1094.       eval '$MV "$nlist"T "$nlist"'
  1095.     }
  1096.   fi
  1097.   # Prepare the list of exported symbols
  1098.   if test -z "$export_symbols"; then
  1099.     export_symbols="$output_objdir/$outputname.exp"
  1100.     $opt_dry_run || {
  1101.       $RM $export_symbols
  1102.       eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* (.*)$/1/p' "'< "$nlist" > "$export_symbols"'
  1103.       case $host in
  1104.       *cygwin* | *mingw* )
  1105.                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
  1106.                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
  1107.         ;;
  1108.       esac
  1109.     }
  1110.   else
  1111.     $opt_dry_run || {
  1112.       eval "${SED} -e 's/([].[*^$])/\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
  1113.       eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
  1114.       eval '$MV "$nlist"T "$nlist"'
  1115.       case $host in
  1116.         *cygwin | *mingw* )
  1117.           eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
  1118.           eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
  1119.           ;;
  1120.       esac
  1121.     }
  1122.   fi
  1123. fi
  1124. for dlprefile in $dlprefiles; do
  1125.   func_verbose "extracting global C symbols from `$dlprefile'"
  1126.   func_basename "$dlprefile"
  1127.   name="$func_basename_result"
  1128.   $opt_dry_run || {
  1129.     eval '$ECHO ": $name " >> "$nlist"'
  1130.     eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
  1131.   }
  1132. done
  1133. $opt_dry_run || {
  1134.   # Make sure we have at least an empty file.
  1135.   test -f "$nlist" || : > "$nlist"
  1136.   if test -n "$exclude_expsyms"; then
  1137.     $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
  1138.     $MV "$nlist"T "$nlist"
  1139.   fi
  1140.   # Try sorting and uniquifying the output.
  1141.   if $GREP -v "^: " < "$nlist" |
  1142.       if sort -k 3 </dev/null >/dev/null 2>&1; then
  1143. sort -k 3
  1144.       else
  1145. sort +2
  1146.       fi |
  1147.       uniq > "$nlist"S; then
  1148.     :
  1149.   else
  1150.     $GREP -v "^: " < "$nlist" > "$nlist"S
  1151.   fi
  1152.   if test -f "$nlist"S; then
  1153.     eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
  1154.   else
  1155.     $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
  1156.   fi
  1157.   $ECHO >> "$output_objdir/$my_dlsyms" "
  1158. /* The mapping between symbol names and symbols.  */
  1159. typedef struct {
  1160.   const char *name;
  1161.   void *address;
  1162. } lt_dlsymlist;
  1163. "
  1164.   case $host in
  1165.   *cygwin* | *mingw* )
  1166.     $ECHO >> "$output_objdir/$my_dlsyms" "
  1167. /* DATA imports from DLLs on WIN32 con't be const, because
  1168.    runtime relocations are performed -- see ld's documentation
  1169.    on pseudo-relocs.  */"
  1170.     lt_dlsym_const= ;;
  1171.   *osf5*)
  1172.     echo >> "$output_objdir/$my_dlsyms" "
  1173. /* This system does not cope well with relocations in const data */"
  1174.     lt_dlsym_const= ;;
  1175.   *)
  1176.     lt_dlsym_const=const ;;
  1177.   esac
  1178.   $ECHO >> "$output_objdir/$my_dlsyms" "
  1179. extern $lt_dlsym_const lt_dlsymlist
  1180. lt_${my_prefix}_LTX_preloaded_symbols[];
  1181. $lt_dlsym_const lt_dlsymlist
  1182. lt_${my_prefix}_LTX_preloaded_symbols[] =
  1183. {
  1184.   { "$my_originator", (void *) 0 },"
  1185.   case $need_lib_prefix in
  1186.   no)
  1187.     eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
  1188.     ;;
  1189.   *)
  1190.     eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
  1191.     ;;
  1192.   esac
  1193.   $ECHO >> "$output_objdir/$my_dlsyms" "
  1194.   {0, (void *) 0}
  1195. };
  1196. /* This works around a problem in FreeBSD linker */
  1197. #ifdef FREEBSD_WORKAROUND
  1198. static const void *lt_preloaded_setup() {
  1199.   return lt_${my_prefix}_LTX_preloaded_symbols;
  1200. }
  1201. #endif
  1202. #ifdef __cplusplus
  1203. }
  1204. #endif
  1205. "
  1206. } # !$opt_dry_run
  1207. pic_flag_for_symtable=
  1208. case "$compile_command " in
  1209. *" -static "*) ;;
  1210. *)
  1211.   case $host in
  1212.   # compiling the symbol table file with pic_flag works around
  1213.   # a FreeBSD bug that causes programs to crash when -lm is
  1214.   # linked before any other PIC object.  But we must not use
  1215.   # pic_flag when linking with -static.  The problem exists in
  1216.   # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
  1217.   *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
  1218.     pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
  1219.   *-*-hpux*)
  1220.     pic_flag_for_symtable=" $pic_flag"  ;;
  1221.   *)
  1222.     if test "X$my_pic_p" != Xno; then
  1223.       pic_flag_for_symtable=" $pic_flag"
  1224.     fi
  1225.     ;;
  1226.   esac
  1227.   ;;
  1228. esac
  1229. symtab_cflags=
  1230. for arg in $LTCFLAGS; do
  1231.   case $arg in
  1232.   -pie | -fpie | -fPIE) ;;
  1233.   *) symtab_cflags="$symtab_cflags $arg" ;;
  1234.   esac
  1235. done
  1236. # Now compile the dynamic symbol file.
  1237. func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
  1238. # Clean up the generated files.
  1239. func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
  1240. # Transform the symbol file into the correct name.
  1241. symfileobj="$output_objdir/${my_outputname}S.$objext"
  1242. case $host in
  1243. *cygwin* | *mingw* )
  1244.   if test -f "$output_objdir/$my_outputname.def"; then
  1245.     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
  1246.     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
  1247.   else
  1248.     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
  1249.     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
  1250.   fi
  1251.   ;;
  1252. *)
  1253.   compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
  1254.   finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
  1255.   ;;
  1256. esac
  1257. ;;
  1258.       *)
  1259. func_fatal_error "unknown suffix for `$my_dlsyms'"
  1260. ;;
  1261.       esac
  1262.     else
  1263.       # We keep going just in case the user didn't refer to
  1264.       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
  1265.       # really was required.
  1266.       # Nullify the symbol file.
  1267.       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  1268.       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  1269.     fi
  1270. }
  1271. # func_extract_an_archive dir oldlib
  1272. func_extract_an_archive ()
  1273. {
  1274.     $opt_debug
  1275.     f_ex_an_ar_dir="$1"; shift
  1276.     f_ex_an_ar_oldlib="$1"
  1277.     func_show_eval "(cd $f_ex_an_ar_dir && $AR x "$f_ex_an_ar_oldlib")" 'exit $?'
  1278.     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
  1279.      :
  1280.     else
  1281.       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
  1282.     fi
  1283. }
  1284. # func_extract_archives gentop oldlib ...
  1285. func_extract_archives ()
  1286. {
  1287.     $opt_debug
  1288.     my_gentop="$1"; shift
  1289.     my_oldlibs=${1+"$@"}
  1290.     my_oldobjs=""
  1291.     my_xlib=""
  1292.     my_xabs=""
  1293.     my_xdir=""
  1294.     for my_xlib in $my_oldlibs; do
  1295.       # Extract the objects.
  1296.       case $my_xlib in
  1297. [\/]* | [A-Za-z]:[\/]*) my_xabs="$my_xlib" ;;
  1298. *) my_xabs=`pwd`"/$my_xlib" ;;
  1299.       esac
  1300.       func_basename "$my_xlib"
  1301.       my_xlib="$func_basename_result"
  1302.       my_xlib_u=$my_xlib
  1303.       while :; do
  1304.         case " $extracted_archives " in
  1305. *" $my_xlib_u "*)
  1306.   extracted_serial=`expr $extracted_serial + 1`
  1307.   my_xlib_u=lt$extracted_serial-$my_xlib ;;
  1308. *) break ;;
  1309. esac
  1310.       done
  1311.       extracted_archives="$extracted_archives $my_xlib_u"
  1312.       my_xdir="$my_gentop/$my_xlib_u"
  1313.       func_mkdir_p "$my_xdir"
  1314.       case $host in
  1315.       *-darwin*)
  1316. func_verbose "Extracting $my_xabs"
  1317. # Do not bother doing anything if just a dry run
  1318. $opt_dry_run || {
  1319.   darwin_orig_dir=`pwd`
  1320.   cd $my_xdir || exit $?
  1321.   darwin_archive=$my_xabs
  1322.   darwin_curdir=`pwd`
  1323.   darwin_base_archive=`basename "$darwin_archive"`
  1324.   darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
  1325.   if test -n "$darwin_arches"; then
  1326.     darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
  1327.     darwin_arch=
  1328.     func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
  1329.     for darwin_arch in  $darwin_arches ; do
  1330.       func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
  1331.       lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
  1332.       cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
  1333.       func_extract_an_archive "`pwd`" "${darwin_base_archive}"
  1334.       cd "$darwin_curdir"
  1335.       $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
  1336.     done # $darwin_arches
  1337.             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
  1338.     darwin_filelist=`find unfat-$$ -type f -name *.o -print -o -name *.lo -print| xargs basename | sort -u | $NL2SP`
  1339.     darwin_file=
  1340.     darwin_files=
  1341.     for darwin_file in $darwin_filelist; do
  1342.       darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
  1343.       lipo -create -output "$darwin_file" $darwin_files
  1344.     done # $darwin_filelist
  1345.     $RM -rf unfat-$$
  1346.     cd "$darwin_orig_dir"
  1347.   else
  1348.     cd $darwin_orig_dir
  1349.     func_extract_an_archive "$my_xdir" "$my_xabs"
  1350.   fi # $darwin_arches
  1351. } # !$opt_dry_run
  1352. ;;
  1353.       *)
  1354.         func_extract_an_archive "$my_xdir" "$my_xabs"
  1355. ;;
  1356.       esac
  1357.       my_oldobjs="$my_oldobjs "`find $my_xdir -name *.$objext -print -o -name *.lo -print | $NL2SP`
  1358.     done
  1359.     func_extract_archives_result="$my_oldobjs"
  1360. }
  1361. # func_write_libtool_object output_name pic_name nonpic_name
  1362. # Create a libtool object file (analogous to a ".la" file),
  1363. # but don't create it if we're doing a dry run.
  1364. func_write_libtool_object ()
  1365. {
  1366.     write_libobj=${1}
  1367.     if test "$build_libtool_libs" = yes; then
  1368.       write_lobj='${2}'
  1369.     else
  1370.       write_lobj=none
  1371.     fi
  1372.     if test "$build_old_libs" = yes; then
  1373.       write_oldobj='${3}'
  1374.     else
  1375.       write_oldobj=none
  1376.     fi
  1377.     $opt_dry_run || {
  1378.       cat >${write_libobj}T <<EOF
  1379. # $write_libobj - a libtool object file
  1380. # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
  1381. #
  1382. # Please DO NOT delete this file!
  1383. # It is necessary for linking the library.
  1384. # Name of the PIC object.
  1385. pic_object=$write_lobj
  1386. # Name of the non-PIC object
  1387. non_pic_object=$write_oldobj
  1388. EOF
  1389.       mv -f "${write_libobj}T" "${write_libobj}"
  1390.     }
  1391. }
  1392. # func_mode_compile arg...
  1393. func_mode_compile ()
  1394. {
  1395.     $opt_debug
  1396.     # Get the compilation command and the source file.
  1397.     base_compile=
  1398.     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
  1399.     suppress_opt=yes
  1400.     suppress_output=
  1401.     arg_mode=normal
  1402.     libobj=
  1403.     later=
  1404.     pie_flag=
  1405.     for arg
  1406.     do
  1407.       case $arg_mode in
  1408.       arg  )
  1409. # do not "continue".  Instead, add this to base_compile
  1410. lastarg="$arg"
  1411. arg_mode=normal
  1412. ;;
  1413.       target )
  1414. libobj="$arg"
  1415. arg_mode=normal
  1416. continue
  1417. ;;
  1418.       normal )
  1419. # Accept any command-line options.
  1420. case $arg in
  1421. -o)
  1422.   test -n "$libobj" && 
  1423.     func_fatal_error "you cannot specify `-o' more than once"
  1424.   arg_mode=target
  1425.   continue
  1426.   ;;
  1427. -pie | -fpie | -fPIE)
  1428.           pie_flag="$pie_flag $arg"
  1429.   continue
  1430.   ;;
  1431. -shared | -static | -prefer-pic | -prefer-non-pic)
  1432.   later="$later $arg"
  1433.   continue
  1434.   ;;
  1435. -no-suppress)
  1436.   suppress_opt=no
  1437.   continue
  1438.   ;;
  1439. -Xcompiler)
  1440.   arg_mode=arg  #  the next one goes into the "base_compile" arg list
  1441.   continue      #  The current "srcfile" will either be retained or
  1442.   ;;            #  replaced later.  I would guess that would be a bug.
  1443. -Wc,*)
  1444.   func_stripname '-Wc,' '' "$arg"
  1445.   args=$func_stripname_result
  1446.   lastarg=
  1447.   save_ifs="$IFS"; IFS=','
  1448.   for arg in $args; do
  1449.     IFS="$save_ifs"
  1450.     func_quote_for_eval "$arg"
  1451.     lastarg="$lastarg $func_quote_for_eval_result"
  1452.   done
  1453.   IFS="$save_ifs"
  1454.   func_stripname ' ' '' "$lastarg"
  1455.   lastarg=$func_stripname_result
  1456.   # Add the arguments to base_compile.
  1457.   base_compile="$base_compile $lastarg"
  1458.   continue
  1459.   ;;
  1460. *)
  1461.   # Accept the current argument as the source file.
  1462.   # The previous "srcfile" becomes the current argument.
  1463.   #
  1464.   lastarg="$srcfile"
  1465.   srcfile="$arg"
  1466.   ;;
  1467. esac  #  case $arg
  1468. ;;
  1469.       esac    #  case $arg_mode
  1470.       # Aesthetically quote the previous argument.
  1471.       func_quote_for_eval "$lastarg"
  1472.       base_compile="$base_compile $func_quote_for_eval_result"
  1473.     done # for arg
  1474.     case $arg_mode in
  1475.     arg)
  1476.       func_fatal_error "you must specify an argument for -Xcompile"
  1477.       ;;
  1478.     target)
  1479.       func_fatal_error "you must specify a target with `-o'"
  1480.       ;;
  1481.     *)
  1482.       # Get the name of the library object.
  1483.       test -z "$libobj" && {
  1484. func_basename "$srcfile"
  1485. libobj="$func_basename_result"
  1486.       }
  1487.       ;;
  1488.     esac
  1489.     # Recognize several different file suffixes.
  1490.     # If the user specifies -o file.o, it is replaced with file.lo
  1491.     xform='[cCFSifmso]'
  1492.     case $libobj in
  1493.     *.ada) xform=ada ;;
  1494.     *.adb) xform=adb ;;
  1495.     *.ads) xform=ads ;;
  1496.     *.asm) xform=asm ;;
  1497.     *.c++) xform=c++ ;;
  1498.     *.cc) xform=cc ;;
  1499.     *.ii) xform=ii ;;
  1500.     *.class) xform=class ;;
  1501.     *.cpp) xform=cpp ;;
  1502.     *.cxx) xform=cxx ;;
  1503.     *.[fF][09]?) xform='[fF][09].' ;;
  1504.     *.for) xform=for ;;
  1505.     *.java) xform=java ;;
  1506.     *.obj) xform=obj ;;
  1507.     *.sx) xform=sx ;;
  1508.     esac
  1509.     libobj=`$ECHO "X$libobj" | $Xsed -e "s/.$xform$/.lo/"`
  1510.     case $libobj in
  1511.     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
  1512.     *)
  1513.       func_fatal_error "cannot determine name of library object from `$libobj'"
  1514.       ;;
  1515.     esac
  1516.     func_infer_tag $base_compile
  1517.     for arg in $later; do
  1518.       case $arg in
  1519.       -shared)
  1520. test "$build_libtool_libs" != yes && 
  1521.   func_fatal_configuration "can not build a shared library"
  1522. build_old_libs=no
  1523. continue
  1524. ;;
  1525.       -static)
  1526. build_libtool_libs=no
  1527. build_old_libs=yes
  1528. continue
  1529. ;;
  1530.       -prefer-pic)
  1531. pic_mode=yes
  1532. continue
  1533. ;;
  1534.       -prefer-non-pic)
  1535. pic_mode=no
  1536. continue
  1537. ;;
  1538.       esac
  1539.     done
  1540.     func_quote_for_eval "$libobj"
  1541.     test "X$libobj" != "X$func_quote_for_eval_result" 
  1542.       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'  &()|`$[]' 
  1543.       && func_warning "libobj name `$libobj' may not contain shell special characters."
  1544.     func_dirname_and_basename "$obj" "/" ""
  1545.     objname="$func_basename_result"
  1546.     xdir="$func_dirname_result"
  1547.     lobj=${xdir}$objdir/$objname
  1548.     test -z "$base_compile" && 
  1549.       func_fatal_help "you must specify a compilation command"
  1550.     # Delete any leftover library objects.
  1551.     if test "$build_old_libs" = yes; then
  1552.       removelist="$obj $lobj $libobj ${libobj}T"
  1553.     else
  1554.       removelist="$lobj $libobj ${libobj}T"
  1555.     fi
  1556.     $opt_dry_run || $RM $removelist
  1557.     trap "$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE" 1 2 15
  1558.     # On Cygwin there's no "real" PIC flag so we must build both object types
  1559.     case $host_os in
  1560.     cygwin* | mingw* | pw32* | os2*)
  1561.       pic_mode=default
  1562.       ;;
  1563.     esac
  1564.     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
  1565.       # non-PIC code in shared libraries is not supported
  1566.       pic_mode=default
  1567.     fi
  1568.     # Calculate the filename of the output object if compiler does
  1569.     # not support -o with -c
  1570.     if test "$compiler_c_o" = no; then
  1571.       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%.[^.]*$%%'`.${objext}
  1572.       lockfile="$output_obj.lock"
  1573.       removelist="$removelist $output_obj $lockfile"
  1574.       trap "$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE" 1 2 15
  1575.     else
  1576.       output_obj=
  1577.       need_locks=no
  1578.       lockfile=
  1579.     fi
  1580.     # Lock this critical section if it is needed
  1581.     # We use this script file to make the link, it avoids creating a new file
  1582.     if test "$need_locks" = yes; then
  1583.       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
  1584. func_echo "Waiting for $lockfile to be removed"
  1585. sleep 2
  1586.       done
  1587.     elif test "$need_locks" = warn; then
  1588.       if test -f "$lockfile"; then
  1589. $ECHO "
  1590. *** ERROR, $lockfile exists and contains:
  1591. `cat $lockfile 2>/dev/null`
  1592. This indicates that another process is trying to use the same
  1593. temporary object file, and libtool could not work around it because
  1594. your compiler does not support `-c' and `-o' together.  If you
  1595. repeat this compilation, it may succeed, by chance, but you had better
  1596. avoid parallel builds (make -j) in this platform, or get a better
  1597. compiler."
  1598. $opt_dry_run || $RM $removelist
  1599. exit $EXIT_FAILURE
  1600.       fi
  1601.       $ECHO "$srcfile" > "$lockfile"
  1602.     fi
  1603.     if test -n "$fix_srcfile_path"; then
  1604.       eval srcfile="$fix_srcfile_path"
  1605.     fi
  1606.     func_quote_for_eval "$srcfile"
  1607.     qsrcfile=$func_quote_for_eval_result
  1608.     $opt_dry_run || $RM "$libobj" "${libobj}T"
  1609.     # Only build a PIC object if we are building libtool libraries.
  1610.     if test "$build_libtool_libs" = yes; then
  1611.       # Without this assignment, base_compile gets emptied.
  1612.       fbsd_hideous_sh_bug=$base_compile
  1613.       if test "$pic_mode" != no; then
  1614. command="$base_compile $qsrcfile $pic_flag"
  1615.       else
  1616. # Don't build PIC code
  1617. command="$base_compile $qsrcfile"
  1618.       fi
  1619.       func_mkdir_p "$xdir$objdir"
  1620.       if test -z "$output_obj"; then
  1621. # Place PIC objects in $objdir
  1622. command="$command -o $lobj"
  1623.       fi
  1624.       $opt_dry_run || $RM "$lobj" "$output_obj"
  1625.       func_show_eval "$command"
  1626.           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
  1627.       if test "$need_locks" = warn &&
  1628.  test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
  1629. $ECHO "
  1630. *** ERROR, $lockfile contains:
  1631. `cat $lockfile 2>/dev/null`
  1632. but it should contain:
  1633. $srcfile
  1634. This indicates that another process is trying to use the same
  1635. temporary object file, and libtool could not work around it because
  1636. your compiler does not support `-c' and `-o' together.  If you
  1637. repeat this compilation, it may succeed, by chance, but you had better
  1638. avoid parallel builds (make -j) in this platform, or get a better
  1639. compiler."
  1640. $opt_dry_run || $RM $removelist
  1641. exit $EXIT_FAILURE
  1642.       fi
  1643.       # Just move the object if needed, then go on to compile the next one
  1644.       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
  1645. func_show_eval '$MV "$output_obj" "$lobj"' 
  1646.   'error=$?; $opt_dry_run || $RM $removelist; exit $error'
  1647.       fi
  1648.       # Allow error messages only from the first compilation.
  1649.       if test "$suppress_opt" = yes; then
  1650. suppress_output=' >/dev/null 2>&1'
  1651.       fi
  1652.     fi
  1653.     # Only build a position-dependent object if we build old libraries.
  1654.     if test "$build_old_libs" = yes; then
  1655.       if test "$pic_mode" != yes; then
  1656. # Don't build PIC code
  1657. command="$base_compile $qsrcfile$pie_flag"
  1658.       else
  1659. command="$base_compile $qsrcfile $pic_flag"
  1660.       fi
  1661.       if test "$compiler_c_o" = yes; then
  1662. command="$command -o $obj"
  1663.       fi
  1664.       # Suppress compiler output if we already did a PIC compilation.
  1665.       command="$command$suppress_output"
  1666.       $opt_dry_run || $RM "$obj" "$output_obj"
  1667.       func_show_eval "$command" 
  1668.         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
  1669.       if test "$need_locks" = warn &&
  1670.  test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
  1671. $ECHO "
  1672. *** ERROR, $lockfile contains:
  1673. `cat $lockfile 2>/dev/null`
  1674. but it should contain:
  1675. $srcfile
  1676. This indicates that another process is trying to use the same
  1677. temporary object file, and libtool could not work around it because
  1678. your compiler does not support `-c' and `-o' together.  If you
  1679. repeat this compilation, it may succeed, by chance, but you had better
  1680. avoid parallel builds (make -j) in this platform, or get a better
  1681. compiler."
  1682. $opt_dry_run || $RM $removelist
  1683. exit $EXIT_FAILURE
  1684.       fi
  1685.       # Just move the object if needed
  1686.       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
  1687. func_show_eval '$MV "$output_obj" "$obj"' 
  1688.   'error=$?; $opt_dry_run || $RM $removelist; exit $error'
  1689.       fi
  1690.     fi
  1691.     $opt_dry_run || {
  1692.       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
  1693.       # Unlock the critical section if it was locked
  1694.       if test "$need_locks" != no; then
  1695.         $RM "$lockfile"
  1696.       fi
  1697.     }
  1698.     exit $EXIT_SUCCESS
  1699. }
  1700. test "$mode" = compile && func_mode_compile ${1+"$@"}
  1701. # func_mode_execute arg...
  1702. func_mode_execute ()
  1703. {
  1704.     $opt_debug
  1705.     # The first argument is the command name.
  1706.     cmd="$nonopt"
  1707.     test -z "$cmd" && 
  1708.       func_fatal_help "you must specify a COMMAND"
  1709.     # Handle -dlopen flags immediately.
  1710.     for file in $execute_dlfiles; do
  1711.       test -f "$file" 
  1712. || func_fatal_help "`$file' is not a file"
  1713.       dir=
  1714.       case $file in
  1715.       *.la)
  1716. # Check to see that this really is a libtool archive.
  1717. func_lalib_unsafe_p "$file" 
  1718.   || func_fatal_help "`$lib' is not a valid libtool archive"
  1719. # Read the libtool library.
  1720. dlname=
  1721. library_names=
  1722. func_source "$file"
  1723. # Skip this library if it cannot be dlopened.
  1724. if test -z "$dlname"; then
  1725.   # Warn if it was a shared library.
  1726.   test -n "$library_names" && 
  1727.     func_warning "`$file' was not linked with `-export-dynamic'"
  1728.   continue
  1729. fi
  1730. func_dirname "$file" "" "."
  1731. dir="$func_dirname_result"
  1732. if test -f "$dir/$objdir/$dlname"; then
  1733.   dir="$dir/$objdir"
  1734. else
  1735.   if test ! -f "$dir/$dlname"; then
  1736.     func_fatal_error "cannot find `$dlname' in `$dir' or `$dir/$objdir'"
  1737.   fi
  1738. fi
  1739. ;;
  1740.       *.lo)
  1741. # Just add the directory containing the .lo file.
  1742. func_dirname "$file" "" "."
  1743. dir="$func_dirname_result"
  1744. ;;
  1745.       *)
  1746. func_warning "`-dlopen' is ignored for non-libtool libraries and objects"
  1747. continue
  1748. ;;
  1749.       esac
  1750.       # Get the absolute pathname.
  1751.       absdir=`cd "$dir" && pwd`
  1752.       test -n "$absdir" && dir="$absdir"
  1753.       # Now add the directory to shlibpath_var.
  1754.       if eval "test -z "$$shlibpath_var""; then
  1755. eval "$shlibpath_var="$dir""
  1756.       else
  1757. eval "$shlibpath_var="$dir:$$shlibpath_var""
  1758.       fi
  1759.     done
  1760.     # This variable tells wrapper scripts just to set shlibpath_var
  1761.     # rather than running their programs.
  1762.     libtool_execute_magic="$magic"
  1763.     # Check if any of the arguments is a wrapper script.
  1764.     args=
  1765.     for file
  1766.     do
  1767.       case $file in
  1768.       -*) ;;
  1769.       *)
  1770. # Do a test to see if this is really a libtool program.
  1771. if func_ltwrapper_script_p "$file"; then
  1772.   func_source "$file"
  1773. elif func_ltwrapper_executable_p "$file"; then
  1774.   func_ltwrapper_scriptname "$file"
  1775.   func_source "$func_ltwrapper_scriptname_result"
  1776. fi
  1777. # Transform arg to wrapped name.
  1778. file="$progdir/$program"
  1779. ;;
  1780.       esac
  1781.       # Quote arguments (to preserve shell metacharacters).
  1782.       func_quote_for_eval "$file"
  1783.       args="$args $func_quote_for_eval_result"
  1784.     done
  1785.     if test "X$opt_dry_run" = Xfalse; then
  1786.       if test -n "$shlibpath_var"; then
  1787. # Export the shlibpath_var.
  1788. eval "export $shlibpath_var"
  1789.       fi
  1790.       # Restore saved environment variables
  1791.       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
  1792.       do
  1793. eval "if test "${save_$lt_var+set}" = set; then
  1794.                 $lt_var=$save_$lt_var; export $lt_var
  1795.       else
  1796. $lt_unset $lt_var
  1797.       fi"
  1798.       done
  1799.       # Now prepare to actually exec the command.
  1800.       exec_cmd="$cmd$args"
  1801.     else
  1802.       # Display what would be done.
  1803.       if test -n "$shlibpath_var"; then
  1804. eval "$ECHO "$shlibpath_var=$$shlibpath_var""
  1805. $ECHO "export $shlibpath_var"
  1806.       fi
  1807.       $ECHO "$cmd$args"
  1808.       exit $EXIT_SUCCESS
  1809.     fi
  1810. }
  1811. test "$mode" = execute && func_mode_execute ${1+"$@"}
  1812. # func_mode_finish arg...
  1813. func_mode_finish ()
  1814. {
  1815.     $opt_debug
  1816.     libdirs="$nonopt"
  1817.     admincmds=
  1818.     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  1819.       for dir
  1820.       do
  1821. libdirs="$libdirs $dir"
  1822.       done
  1823.       for libdir in $libdirs; do
  1824. if test -n "$finish_cmds"; then
  1825.   # Do each command in the finish commands.
  1826.   func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
  1827. '"$cmd"'"'
  1828. fi
  1829. if test -n "$finish_eval"; then
  1830.   # Do the single finish_eval.
  1831.   eval cmds="$finish_eval"
  1832.   $opt_dry_run || eval "$cmds" || admincmds="$admincmds
  1833.        $cmds"
  1834. fi
  1835.       done
  1836.     fi
  1837.     # Exit here if they wanted silent mode.
  1838.     $opt_silent && exit $EXIT_SUCCESS
  1839.     $ECHO "X----------------------------------------------------------------------" | $Xsed
  1840.     $ECHO "Libraries have been installed in:"
  1841.     for libdir in $libdirs; do
  1842.       $ECHO "   $libdir"
  1843.     done
  1844.     $ECHO
  1845.     $ECHO "If you ever happen to want to link against installed libraries"
  1846.     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
  1847.     $ECHO "specify the full pathname of the library, or use the `-LLIBDIR'"
  1848.     $ECHO "flag during linking and do at least one of the following:"
  1849.     if test -n "$shlibpath_var"; then
  1850.       $ECHO "   - add LIBDIR to the `$shlibpath_var' environment variable"
  1851.       $ECHO "     during execution"
  1852.     fi
  1853.     if test -n "$runpath_var"; then
  1854.       $ECHO "   - add LIBDIR to the `$runpath_var' environment variable"
  1855.       $ECHO "     during linking"
  1856.     fi
  1857.     if test -n "$hardcode_libdir_flag_spec"; then
  1858.       libdir=LIBDIR
  1859.       eval flag="$hardcode_libdir_flag_spec"
  1860.       $ECHO "   - use the `$flag' linker flag"
  1861.     fi
  1862.     if test -n "$admincmds"; then
  1863.       $ECHO "   - have your system administrator run these commands:$admincmds"
  1864.     fi
  1865.     if test -f /etc/ld.so.conf; then
  1866.       $ECHO "   - have your system administrator add LIBDIR to `/etc/ld.so.conf'"
  1867.     fi
  1868.     $ECHO
  1869.     $ECHO "See any operating system documentation about shared libraries for"
  1870.     case $host in
  1871.       solaris2.[6789]|solaris2.1[0-9])
  1872.         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
  1873. $ECHO "pages."
  1874. ;;
  1875.       *)
  1876.         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
  1877.         ;;
  1878.     esac
  1879.     $ECHO "X----------------------------------------------------------------------" | $Xsed
  1880.     exit $EXIT_SUCCESS
  1881. }
  1882. test "$mode" = finish && func_mode_finish ${1+"$@"}
  1883. # func_mode_install arg...
  1884. func_mode_install ()
  1885. {
  1886.     $opt_debug
  1887.     # There may be an optional sh(1) argument at the beginning of
  1888.     # install_prog (especially on Windows NT).
  1889.     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
  1890.        # Allow the use of GNU shtool's install command.
  1891.        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
  1892.       # Aesthetically quote it.
  1893.       func_quote_for_eval "$nonopt"
  1894.       install_prog="$func_quote_for_eval_result "
  1895.       arg=$1
  1896.       shift
  1897.     else
  1898.       install_prog=
  1899.       arg=$nonopt
  1900.     fi
  1901.     # The real first argument should be the name of the installation program.
  1902.     # Aesthetically quote it.
  1903.     func_quote_for_eval "$arg"
  1904.     install_prog="$install_prog$func_quote_for_eval_result"
  1905.     # We need to accept at least all the BSD install flags.
  1906.     dest=
  1907.     files=
  1908.     opts=
  1909.     prev=
  1910.     install_type=
  1911.     isdir=no
  1912.     stripme=
  1913.     for arg
  1914.     do
  1915.       if test -n "$dest"; then
  1916. files="$files $dest"
  1917. dest=$arg
  1918. continue
  1919.       fi
  1920.       case $arg in
  1921.       -d) isdir=yes ;;
  1922.       -f)
  1923. case " $install_prog " in
  1924. *[\ /]cp *) ;;
  1925. *) prev=$arg ;;
  1926. esac
  1927. ;;
  1928.       -g | -m | -o)
  1929. prev=$arg
  1930. ;;
  1931.       -s)
  1932. stripme=" -s"
  1933. continue
  1934. ;;
  1935.       -*)
  1936. ;;
  1937.       *)
  1938. # If the previous option needed an argument, then skip it.
  1939. if test -n "$prev"; then
  1940.   prev=
  1941. else
  1942.   dest=$arg
  1943.   continue
  1944. fi
  1945. ;;
  1946.       esac
  1947.       # Aesthetically quote the argument.
  1948.       func_quote_for_eval "$arg"
  1949.       install_prog="$install_prog $func_quote_for_eval_result"
  1950.     done
  1951.     test -z "$install_prog" && 
  1952.       func_fatal_help "you must specify an install program"
  1953.     test -n "$prev" && 
  1954.       func_fatal_help "the `$prev' option requires an argument"
  1955.     if test -z "$files"; then
  1956.       if test -z "$dest"; then
  1957. func_fatal_help "no file or destination specified"
  1958.       else
  1959. func_fatal_help "you must specify a destination"
  1960.       fi
  1961.     fi
  1962.     # Strip any trailing slash from the destination.
  1963.     func_stripname '' '/' "$dest"
  1964.     dest=$func_stripname_result
  1965.     # Check to see that the destination is a directory.
  1966.     test -d "$dest" && isdir=yes
  1967.     if test "$isdir" = yes; then
  1968.       destdir="$dest"
  1969.       destname=
  1970.     else
  1971.       func_dirname_and_basename "$dest" "" "."
  1972.       destdir="$func_dirname_result"
  1973.       destname="$func_basename_result"
  1974.       # Not a directory, so check to see that there is only one file specified.
  1975.       set dummy $files; shift
  1976.       test "$#" -gt 1 && 
  1977. func_fatal_help "`$dest' is not a directory"
  1978.     fi
  1979.     case $destdir in
  1980.     [\/]* | [A-Za-z]:[\/]*) ;;
  1981.     *)
  1982.       for file in $files; do
  1983. case $file in
  1984. *.lo) ;;
  1985. *)
  1986.   func_fatal_help "`$destdir' must be an absolute directory name"
  1987.   ;;
  1988. esac
  1989.       done
  1990.       ;;
  1991.     esac
  1992.     # This variable tells wrapper scripts just to set variables rather
  1993.     # than running their programs.
  1994.     libtool_install_magic="$magic"
  1995.     staticlibs=
  1996.     future_libdirs=
  1997.     current_libdirs=
  1998.     for file in $files; do
  1999.       # Do each installation.
  2000.       case $file in
  2001.       *.$libext)
  2002. # Do the static libraries later.
  2003. staticlibs="$staticlibs $file"
  2004. ;;
  2005.       *.la)
  2006. # Check to see that this really is a libtool archive.
  2007. func_lalib_unsafe_p "$file" 
  2008.   || func_fatal_help "`$file' is not a valid libtool archive"
  2009. library_names=
  2010. old_library=
  2011. relink_command=
  2012. func_source "$file"
  2013. # Add the libdir to current_libdirs if it is the destination.
  2014. if test "X$destdir" = "X$libdir"; then
  2015.   case "$current_libdirs " in
  2016.   *" $libdir "*) ;;
  2017.   *) current_libdirs="$current_libdirs $libdir" ;;
  2018.   esac
  2019. else
  2020.   # Note the libdir as a future libdir.
  2021.   case "$future_libdirs " in
  2022.   *" $libdir "*) ;;
  2023.   *) future_libdirs="$future_libdirs $libdir" ;;
  2024.   esac
  2025. fi
  2026. func_dirname "$file" "/" ""
  2027. dir="$func_dirname_result"
  2028. dir="$dir$objdir"
  2029. if test -n "$relink_command"; then
  2030.   # Determine the prefix the user has applied to our future dir.
  2031.   inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir$%%"`
  2032.   # Don't allow the user to place us outside of our expected
  2033.   # location b/c this prevents finding dependent libraries that
  2034.   # are installed to the same prefix.
  2035.   # At present, this check doesn't affect windows .dll's that
  2036.   # are installed into $libdir/../bin (currently, that works fine)
  2037.   # but it's something to keep an eye on.
  2038.   test "$inst_prefix_dir" = "$destdir" && 
  2039.     func_fatal_error "error: cannot install `$file' to a directory not ending in $libdir"
  2040.   if test -n "$inst_prefix_dir"; then
  2041.     # Stick the inst_prefix_dir data into the link command.
  2042.     relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
  2043.   else
  2044.     relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
  2045.   fi
  2046.   func_warning "relinking `$file'"
  2047.   func_show_eval "$relink_command" 
  2048.     'func_fatal_error "error: relink `$file''' with the above command before installing it"'
  2049. fi
  2050. # See the names of the shared library.
  2051. set dummy $library_names; shift
  2052. if test -n "$1"; then
  2053.   realname="$1"
  2054.   shift
  2055.   srcname="$realname"
  2056.   test -n "$relink_command" && srcname="$realname"T
  2057.   # Install the shared library and build the symlinks.
  2058.   func_show_eval "$install_prog $dir/$srcname $destdir/$realname" 
  2059.       'exit $?'
  2060.   tstripme="$stripme"
  2061.   case $host_os in
  2062.   cygwin* | mingw* | pw32*)
  2063.     case $realname in
  2064.     *.dll.a)
  2065.       tstripme=""
  2066.       ;;
  2067.     esac
  2068.     ;;
  2069.   esac
  2070.   if test -n "$tstripme" && test -n "$striplib"; then
  2071.     func_show_eval "$striplib $destdir/$realname" 'exit $?'
  2072.   fi
  2073.   if test "$#" -gt 0; then
  2074.     # Delete the old symlinks, and create new ones.
  2075.     # Try `ln -sf' first, because the `ln' binary might depend on
  2076.     # the symlink we replace!  Solaris /bin/ln does not understand -f,
  2077.     # so we also need to try rm && ln -s.
  2078.     for linkname
  2079.     do
  2080.       test "$linkname" != "$realname" 
  2081. && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
  2082.     done
  2083.   fi
  2084.   # Do each command in the postinstall commands.
  2085.   lib="$destdir/$realname"
  2086.   func_execute_cmds "$postinstall_cmds" 'exit $?'
  2087. fi
  2088. # Install the pseudo-library for information purposes.
  2089. func_basename "$file"
  2090. name="$func_basename_result"
  2091. instname="$dir/$name"i
  2092. func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
  2093. # Maybe install the static library, too.
  2094. test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
  2095. ;;
  2096.       *.lo)
  2097. # Install (i.e. copy) a libtool object.
  2098. # Figure out destination file name, if it wasn't already specified.
  2099. if test -n "$destname"; then
  2100.   destfile="$destdir/$destname"
  2101. else
  2102.   func_basename "$file"
  2103.   destfile="$func_basename_result"
  2104.   destfile="$destdir/$destfile"
  2105. fi
  2106. # Deduce the name of the destination old-style object file.
  2107. case $destfile in
  2108. *.lo)
  2109.   func_lo2o "$destfile"
  2110.   staticdest=$func_lo2o_result
  2111.   ;;
  2112. *.$objext)
  2113.   staticdest="$destfile"
  2114.   destfile=
  2115.   ;;
  2116. *)
  2117.   func_fatal_help "cannot copy a libtool object to `$destfile'"
  2118.   ;;
  2119. esac
  2120. # Install the libtool object if requested.
  2121. test -n "$destfile" && 
  2122.   func_show_eval "$install_prog $file $destfile" 'exit $?'
  2123. # Install the old object if enabled.
  2124. if test "$build_old_libs" = yes; then
  2125.   # Deduce the name of the old-style object file.
  2126.   func_lo2o "$file"
  2127.   staticobj=$func_lo2o_result
  2128.   func_show_eval "$install_prog $staticobj $staticdest" 'exit $?'
  2129. fi
  2130. exit $EXIT_SUCCESS
  2131. ;;
  2132.       *)
  2133. # Figure out destination file name, if it wasn't already specified.
  2134. if test -n "$destname"; then
  2135.   destfile="$destdir/$destname"
  2136. else
  2137.   func_basename "$file"
  2138.   destfile="$func_basename_result"
  2139.   destfile="$destdir/$destfile"
  2140. fi
  2141. # If the file is missing, and there is a .exe on the end, strip it
  2142. # because it is most likely a libtool script we actually want to
  2143. # install
  2144. stripped_ext=""
  2145. case $file in
  2146.   *.exe)
  2147.     if test ! -f "$file"; then
  2148.       func_stripname '' '.exe' "$file"
  2149.       file=$func_stripname_result
  2150.       stripped_ext=".exe"
  2151.     fi
  2152.     ;;
  2153. esac
  2154. # Do a test to see if this is really a libtool program.
  2155. case $host in
  2156. *cygwin*|*mingw*)
  2157.     if func_ltwrapper_executable_p "$file"; then
  2158.       func_ltwrapper_scriptname "$file"
  2159.       wrapper=$func_ltwrapper_scriptname_result
  2160.     else
  2161.       func_stripname '' '.exe' "$file"
  2162.       wrapper=$func_stripname_result
  2163.     fi
  2164.     ;;
  2165. *)
  2166.     wrapper=$file
  2167.     ;;
  2168. esac
  2169. if func_ltwrapper_script_p "$wrapper"; then
  2170.   notinst_deplibs=
  2171.   relink_command=
  2172.   func_source "$wrapper"
  2173.   # Check the variables that should have been set.
  2174.   test -z "$generated_by_libtool_version" && 
  2175.     func_fatal_error "invalid libtool wrapper script `$wrapper'"
  2176.   finalize=yes
  2177.   for lib in $notinst_deplibs; do
  2178.     # Check to see that each library is installed.
  2179.     libdir=
  2180.     if test -f "$lib"; then
  2181.       func_source "$lib"
  2182.     fi
  2183.     libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
  2184.     if test -n "$libdir" && test ! -f "$libfile"; then
  2185.       func_warning "`$lib' has not been installed in `$libdir'"
  2186.       finalize=no
  2187.     fi
  2188.   done
  2189.   relink_command=
  2190.   func_source "$wrapper"
  2191.   outputname=
  2192.   if test "$fast_install" = no && test -n "$relink_command"; then
  2193.     $opt_dry_run || {
  2194.       if test "$finalize" = yes; then
  2195.         tmpdir=`func_mktempdir`
  2196. func_basename "$file$stripped_ext"
  2197. file="$func_basename_result"
  2198.         outputname="$tmpdir/$file"
  2199.         # Replace the output file specification.
  2200.         relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
  2201.         $opt_silent || {
  2202.           func_quote_for_expand "$relink_command"
  2203.   eval "func_echo $func_quote_for_expand_result"
  2204.         }
  2205.         if eval "$relink_command"; then :
  2206.           else
  2207.   func_error "error: relink `$file' with the above command before installing it"
  2208.   $opt_dry_run || ${RM}r "$tmpdir"
  2209.   continue
  2210.         fi
  2211.         file="$outputname"
  2212.       else
  2213.         func_warning "cannot relink `$file'"
  2214.       fi
  2215.     }
  2216.   else
  2217.     # Install the binary that we compiled earlier.
  2218.     file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%([^/]*)$%$objdir/1%"`
  2219.   fi
  2220. fi
  2221. # remove .exe since cygwin /usr/bin/install will append another
  2222. # one anyway
  2223. case $install_prog,$host in
  2224. */usr/bin/install*,*cygwin*)
  2225.   case $file:$destfile in
  2226.   *.exe:*.exe)
  2227.     # this is ok
  2228.     ;;
  2229.   *.exe:*)
  2230.     destfile=$destfile.exe
  2231.     ;;
  2232.   *:*.exe)
  2233.     func_stripname '' '.exe' "$destfile"
  2234.     destfile=$func_stripname_result
  2235.     ;;
  2236.   esac
  2237.   ;;
  2238. esac
  2239. func_show_eval "$install_prog$stripme $file $destfile" 'exit $?'
  2240. $opt_dry_run || if test -n "$outputname"; then
  2241.   ${RM}r "$tmpdir"
  2242. fi
  2243. ;;
  2244.       esac
  2245.     done
  2246.     for file in $staticlibs; do
  2247.       func_basename "$file"
  2248.       name="$func_basename_result"
  2249.       # Set up the ranlib parameters.
  2250.       oldlib="$destdir/$name"
  2251.       func_show_eval "$install_prog $file $oldlib" 'exit $?'
  2252.       if test -n "$stripme" && test -n "$old_striplib"; then
  2253. func_show_eval "$old_striplib $oldlib" 'exit $?'
  2254.       fi
  2255.       # Do each command in the postinstall commands.
  2256.       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
  2257.     done
  2258.     test -n "$future_libdirs" && 
  2259.       func_warning "remember to run `$progname --finish$future_libdirs'"
  2260.     if test -n "$current_libdirs"; then
  2261.       # Maybe just do a dry run.
  2262.       $opt_dry_run && current_libdirs=" -n$current_libdirs"
  2263.       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
  2264.     else
  2265.       exit $EXIT_SUCCESS
  2266.     fi
  2267. }
  2268. test "$mode" = install && func_mode_install ${1+"$@"}
  2269. # func_emit_wrapper arg
  2270. #
  2271. # emit a libtool wrapper script on stdout
  2272. # don't directly open a file because we may want to
  2273. # incorporate the script contents within a cygwin/mingw
  2274. # wrapper executable.  Must ONLY be called from within
  2275. # func_mode_link because it depends on a number of variable
  2276. # set therein.
  2277. #
  2278. # arg is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
  2279. # variable will take.  If 'yes', then the emitted script
  2280. # will assume that the directory in which it is stored is
  2281. # the '.lib' directory.  This is a cygwin/mingw-specific
  2282. # behavior.
  2283. func_emit_wrapper ()
  2284. {
  2285. func_emit_wrapper_arg1=no
  2286. if test -n "$1" ; then
  2287.   func_emit_wrapper_arg1=$1
  2288. fi
  2289. $ECHO "
  2290. #! $SHELL
  2291. # $output - temporary wrapper script for $objdir/$outputname
  2292. # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
  2293. #
  2294. # The $output program cannot be directly executed until all the libtool
  2295. # libraries that it depends on are installed.
  2296. #
  2297. # This wrapper script should never be moved out of the build directory.
  2298. # If it is, it will not operate correctly.
  2299. # Sed substitution that helps us do robust quoting.  It backslashifies
  2300. # metacharacters that are still active within double-quoted strings.
  2301. Xsed='${SED} -e 1s/^X//'
  2302. sed_quote_subst='$sed_quote_subst'
  2303. # Be Bourne compatible
  2304. if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  2305.   emulate sh
  2306.   NULLCMD=:
  2307.   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  2308.   # is contrary to our usage.  Disable this feature.
  2309.   alias -g '${1+"$@"}'='"$@"'
  2310.   setopt NO_GLOB_SUBST
  2311. else
  2312.   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
  2313. fi
  2314. BIN_SH=xpg4; export BIN_SH # for Tru64
  2315. DUALCASE=1; export DUALCASE # for MKS sh
  2316. # The HP-UX ksh and POSIX shell print the target directory to stdout
  2317. # if CDPATH is set.
  2318. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
  2319. relink_command="$relink_command"
  2320. # This environment variable determines our operation mode.
  2321. if test "$libtool_install_magic" = "$magic"; then
  2322.   # install mode needs the following variables:
  2323.   generated_by_libtool_version='$macro_version'
  2324.   notinst_deplibs='$notinst_deplibs'
  2325. else
  2326.   # When we are sourced in execute mode, $file and $ECHO are already set.
  2327.   if test "$libtool_execute_magic" != "$magic"; then
  2328.     ECHO="$qecho"
  2329.     file="$0"
  2330.     # Make sure echo works.
  2331.     if test "X$1" = X--no-reexec; then
  2332.       # Discard the --no-reexec flag, and continue.
  2333.       shift
  2334.     elif test "X`{ $ECHO 't'; } 2>/dev/null`" = 'Xt'; then
  2335.       # Yippee, $ECHO works!
  2336.       :
  2337.     else
  2338.       # Restart under the correct shell, and then maybe $ECHO will work.
  2339.       exec $SHELL "$0" --no-reexec ${1+"$@"}
  2340.     fi
  2341.   fi
  2342. "
  2343. $ECHO "
  2344.   # Find the directory that this script lives in.
  2345.   thisdir=`$ECHO "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2346.   test "x$thisdir" = "x$file" && thisdir=.
  2347.   # Follow symbolic links until we get to the real thisdir.
  2348.   file=`ls -ld "$file" | ${SED} -n 's/.*-> //p'`
  2349.   while test -n "$file"; do
  2350.     destdir=`$ECHO "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2351.     # If there was a directory component, then change thisdir.
  2352.     if test "x$destdir" != "x$file"; then
  2353.       case "$destdir" in
  2354.       [\\/]* | [A-Za-z]:[\\/]*) thisdir="$destdir" ;;
  2355.       *) thisdir="$thisdir/$destdir" ;;
  2356.       esac
  2357.     fi
  2358.     file=`$ECHO "X$file" | $Xsed -e 's%^.*/%%'`
  2359.     file=`ls -ld "$thisdir/$file" | ${SED} -n 's/.*-> //p'`
  2360.   done
  2361.   # Usually 'no', except on cygwin/mingw when embedded into
  2362.   # the cwrapper.
  2363.   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
  2364.   if test "$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR" = "yes"; then
  2365.     # special case for '.'
  2366.     if test "$thisdir" = "."; then
  2367.       thisdir=`pwd`
  2368.     fi
  2369.     # remove .libs from thisdir
  2370.     case "$thisdir" in
  2371.     *[\\/]$objdir ) thisdir=`$ECHO "X$thisdir" | $Xsed -e 's%[\\/][^\\/]*$%%'` ;;
  2372.     $objdir )   thisdir=. ;;
  2373.     esac
  2374.   fi
  2375.   # Try to get the absolute directory name.
  2376.   absdir=`cd "$thisdir" && pwd`
  2377.   test -n "$absdir" && thisdir="$absdir"
  2378. "
  2379. if test "$fast_install" = yes; then
  2380.   $ECHO "
  2381.   program=lt-'$outputname'$exeext
  2382.   progdir="$thisdir/$objdir"
  2383.   if test ! -f "$progdir/$program" ||
  2384.      { file=`ls -1dt "$progdir/$program" "$progdir/../$program" 2>/dev/null | ${SED} 1q`; \
  2385.        test "X$file" != "X$progdir/$program"; }; then
  2386.     file="$$-$program"
  2387.     if test ! -d "$progdir"; then
  2388.       $MKDIR "$progdir"
  2389.     else
  2390.       $RM "$progdir/$file"
  2391.     fi"
  2392.   $ECHO "
  2393.     # relink executable if necessary
  2394.     if test -n "$relink_command"; then
  2395.       if relink_command_output=`eval $relink_command 2>&1`; then :
  2396.       else
  2397. $ECHO "$relink_command_output" >&2
  2398. $RM "$progdir/$file"
  2399. exit 1
  2400.       fi
  2401.     fi
  2402.     $MV "$progdir/$file" "$progdir/$program" 2>/dev/null ||
  2403.     { $RM "$progdir/$program";
  2404.       $MV "$progdir/$file" "$progdir/$program"; }
  2405.     $RM "$progdir/$file"
  2406.   fi"
  2407. else
  2408.   $ECHO "
  2409.   program='$outputname'
  2410.   progdir="$thisdir/$objdir"
  2411. "
  2412. fi
  2413. $ECHO "
  2414.   if test -f "$progdir/$program"; then"
  2415. # Export our shlibpath_var if we have one.
  2416. if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  2417.   $ECHO "
  2418.     # Add our own library path to $shlibpath_var
  2419.     $shlibpath_var="$temp_rpath$$shlibpath_var"
  2420.     # Some systems cannot cope with colon-terminated $shlibpath_var
  2421.     # The second colon is a workaround for a bug in BeOS R4 sed
  2422.     $shlibpath_var=`$ECHO "X$$shlibpath_var" | $Xsed -e 's/::*$//'`
  2423.     export $shlibpath_var
  2424. "
  2425. fi
  2426. # fixup the dll searchpath if we need to.
  2427. if test -n "$dllsearchpath"; then
  2428.   $ECHO "
  2429.     # Add the dll search path components to the executable PATH
  2430.     PATH=$dllsearchpath:$PATH
  2431. "
  2432. fi
  2433. $ECHO "
  2434.     if test "$libtool_execute_magic" != "$magic"; then
  2435.       # Run the actual program with our arguments.
  2436. "
  2437. case $host in
  2438. # Backslashes separate directories on plain windows
  2439. *-*-mingw | *-*-os2*)
  2440.   $ECHO "
  2441.       exec "$progdir\\$program" ${1+"$@"}
  2442. "
  2443.   ;;
  2444. *)
  2445.   $ECHO "
  2446.       exec "$progdir/$program" ${1+"$@"}
  2447. "
  2448.   ;;
  2449. esac
  2450. $ECHO "
  2451.       $ECHO "$0: cannot exec $program $*"
  2452.       exit 1
  2453.     fi
  2454.   else
  2455.     # The program doesn't exist.
  2456.     $ECHO "$0: error: \`$progdir/$program' does not exist" 1>&2
  2457.     $ECHO "This script is just a wrapper for $program." 1>&2
  2458.     $ECHO "See the $PACKAGE documentation for more information." 1>&2
  2459.     exit 1
  2460.   fi
  2461. fi
  2462. "
  2463. }
  2464. # end: func_emit_wrapper
  2465. # func_emit_cwrapperexe_src
  2466. # emit the source code for a wrapper executable on stdout
  2467. # Must ONLY be called from within func_mode_link because
  2468. # it depends on a number of variable set therein.
  2469. func_emit_cwrapperexe_src ()
  2470. {
  2471. cat <<EOF
  2472. /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
  2473.    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
  2474.    The $output program cannot be directly executed until all the libtool
  2475.    libraries that it depends on are installed.
  2476.    This wrapper executable should never be moved out of the build directory.
  2477.    If it is, it will not operate correctly.
  2478.    Currently, it simply execs the wrapper *script* "$SHELL $output",
  2479.    but could eventually absorb all of the scripts functionality and
  2480.    exec $objdir/$outputname directly.
  2481. */
  2482. EOF
  2483.     cat <<"EOF"
  2484. #include <stdio.h>
  2485. #include <stdlib.h>
  2486. #ifdef _MSC_VER
  2487. # include <direct.h>
  2488. # include <process.h>
  2489. #else
  2490. # include <unistd.h>
  2491. # include <stdint.h>
  2492. #endif
  2493. #include <malloc.h>
  2494. #include <stdarg.h>
  2495. #include <assert.h>
  2496. #include <string.h>
  2497. #include <ctype.h>
  2498. #include <errno.h>
  2499. #include <sys/stat.h>
  2500. #if defined(PATH_MAX)
  2501. # define LT_PATHMAX PATH_MAX
  2502. #elif defined(MAXPATHLEN)
  2503. # define LT_PATHMAX MAXPATHLEN
  2504. #else
  2505. # define LT_PATHMAX 1024
  2506. #endif
  2507. #ifndef S_IXOTH
  2508. # define S_IXOTH 0
  2509. #endif
  2510. #ifndef S_IXGRP
  2511. # define S_IXGRP 0
  2512. #endif
  2513. #ifdef _MSC_VER
  2514. # define S_IXUSR _S_IEXEC
  2515. # define stat _stat
  2516. # ifndef _INTPTR_T_DEFINED
  2517. #  define intptr_t int
  2518. # endif
  2519. #endif
  2520. #ifndef DIR_SEPARATOR
  2521. # define DIR_SEPARATOR '/'
  2522. # define PATH_SEPARATOR ':'
  2523. #endif
  2524. #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || 
  2525.   defined (__OS2__)
  2526. # define HAVE_DOS_BASED_FILE_SYSTEM
  2527. # ifndef DIR_SEPARATOR_2
  2528. #  define DIR_SEPARATOR_2 '\'
  2529. # endif
  2530. # ifndef PATH_SEPARATOR_2
  2531. #  define PATH_SEPARATOR_2 ';'
  2532. # endif
  2533. #endif
  2534. #ifndef DIR_SEPARATOR_2
  2535. # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
  2536. #else /* DIR_SEPARATOR_2 */
  2537. # define IS_DIR_SEPARATOR(ch) 
  2538. (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
  2539. #endif /* DIR_SEPARATOR_2 */
  2540. #ifndef PATH_SEPARATOR_2
  2541. # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
  2542. #else /* PATH_SEPARATOR_2 */
  2543. # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
  2544. #endif /* PATH_SEPARATOR_2 */
  2545. #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
  2546. #define XFREE(stale) do { 
  2547.   if (stale) { free ((void *) stale); stale = 0; } 
  2548. } while (0)
  2549. #undef LTWRAPPER_DEBUGPRINTF
  2550. #if defined DEBUGWRAPPER
  2551. # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
  2552. static void
  2553. ltwrapper_debugprintf (const char *fmt, ...)
  2554. {
  2555.     va_list args;
  2556.     va_start (args, fmt);
  2557.     (void) vfprintf (stderr, fmt, args);
  2558.     va_end (args);
  2559. }
  2560. #else
  2561. # define LTWRAPPER_DEBUGPRINTF(args)
  2562. #endif
  2563. const char *program_name = NULL;
  2564. void *xmalloc (size_t num);
  2565. char *xstrdup (const char *string);
  2566. const char *base_name (const char *name);
  2567. char *find_executable (const char *wrapper);
  2568. char *chase_symlinks (const char *pathspec);
  2569. int make_executable (const char *path);
  2570. int check_executable (const char *path);
  2571. char *strendzap (char *str, const char *pat);
  2572. void lt_fatal (const char *message, ...);
  2573. static const char *script_text =
  2574. EOF
  2575.     func_emit_wrapper yes |
  2576.         $SED -e 's/([\"])/\1/g' 
  2577.              -e 's/^/  "/' -e 's/$/\n"/'
  2578.     echo ";"
  2579.     cat <<EOF
  2580. const char * MAGIC_EXE = "$magic_exe";
  2581. int
  2582. main (int argc, char *argv[])
  2583. {
  2584.   char **newargz;
  2585.   char *tmp_pathspec;
  2586.   char *actual_cwrapper_path;
  2587.   char *shwrapper_name;
  2588.   intptr_t rval = 127;
  2589.   FILE *shwrapper;
  2590.   const char *dumpscript_opt = "--lt-dump-script";
  2591.   int i;
  2592.   program_name = (char *) xstrdup (base_name (argv[0]));
  2593.   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %sn", argv[0]));
  2594.   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %sn", program_name));
  2595.   /* very simple arg parsing; don't want to rely on getopt */
  2596.   for (i = 1; i < argc; i++)
  2597.     {
  2598.       if (strcmp (argv[i], dumpscript_opt) == 0)
  2599. {
  2600.   printf ("%s", script_text);
  2601.   return 0;
  2602. }
  2603.     }
  2604.   newargz = XMALLOC (char *, argc + 2);
  2605. EOF
  2606.     if test -n "$TARGETSHELL" ; then
  2607.       # no path translation at all
  2608.       lt_newargv0=$TARGETSHELL
  2609.     else
  2610.       case "$host" in
  2611. *mingw* )
  2612.   # awkward: cmd appends spaces to result
  2613.   lt_sed_strip_trailing_spaces="s/[ ]*$//"
  2614.   lt_newargv0=`( cmd //c echo $SHELL | $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo $SHELL`
  2615.   case $lt_newargv0 in
  2616.     *.exe | *.EXE) ;;
  2617.     *) lt_newargv0=$lt_newargv0.exe ;;
  2618.   esac
  2619.   ;;
  2620. * ) lt_newargv0=$SHELL ;;
  2621.       esac
  2622.     fi
  2623. cat <<EOF
  2624.   newargz[0] = (char *) xstrdup ("$lt_newargv0");
  2625. EOF
  2626.     cat <<"EOF"
  2627.   tmp_pathspec = find_executable (argv[0]);
  2628.   if (tmp_pathspec == NULL)
  2629.     lt_fatal ("Couldn't find %s", argv[0]);
  2630.   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %sn",
  2631.   tmp_pathspec));
  2632.   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
  2633.   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %sn",
  2634.   actual_cwrapper_path));
  2635.   XFREE (tmp_pathspec);
  2636.   shwrapper_name = (char *) xstrdup (base_name (actual_cwrapper_path));
  2637.   strendzap (actual_cwrapper_path, shwrapper_name);
  2638.   /* shwrapper_name transforms */
  2639.   strendzap (shwrapper_name, ".exe");
  2640.   tmp_pathspec = XMALLOC (char, (strlen (shwrapper_name) +
  2641.  strlen ("_ltshwrapperTMP") + 1));
  2642.   strcpy (tmp_pathspec, shwrapper_name);
  2643.   strcat (tmp_pathspec, "_ltshwrapperTMP");
  2644.   XFREE (shwrapper_name);
  2645.   shwrapper_name = tmp_pathspec;
  2646.   tmp_pathspec = 0;
  2647.   LTWRAPPER_DEBUGPRINTF (("(main) libtool shell wrapper name: %sn",
  2648.   shwrapper_name));
  2649. EOF
  2650.     cat <<EOF
  2651.   newargz[1] =
  2652.     XMALLOC (char, (strlen (actual_cwrapper_path) +
  2653.     strlen ("$objdir") + 1 + strlen (shwrapper_name) + 1));
  2654.   strcpy (newargz[1], actual_cwrapper_path);
  2655.   strcat (newargz[1], "$objdir");
  2656.   strcat (newargz[1], "/");
  2657.   strcat (newargz[1], shwrapper_name);
  2658. EOF
  2659.     case $host_os in
  2660.       mingw*)
  2661.     cat <<"EOF"
  2662.   {
  2663.     char* p;
  2664.     while ((p = strchr (newargz[1], '\')) != NULL)
  2665.       {
  2666. *p = '/';
  2667.       }
  2668.   }
  2669. EOF
  2670.     ;;
  2671.     esac
  2672.     cat <<"EOF"
  2673.   XFREE (shwrapper_name);
  2674.   XFREE (actual_cwrapper_path);
  2675.   /* note: do NOT use "wt" here! -- defer to underlying
  2676.    * mount type on cygwin
  2677.    */
  2678.   if ((shwrapper = fopen (newargz[1], "w")) == 0)
  2679.     {
  2680.       lt_fatal ("Could not open %s for writing", newargz[1]);
  2681.     }
  2682.   fprintf (shwrapper, "%s", script_text);
  2683.   fclose (shwrapper);
  2684.   make_executable (newargz[1]);
  2685.   for (i = 1; i < argc; i++)
  2686.     newargz[i + 1] = xstrdup (argv[i]);
  2687.   newargz[argc + 1] = NULL;
  2688.   for (i = 0; i < argc + 1; i++)
  2689.     {
  2690.       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %sn", i, newargz[i]));
  2691.     }
  2692. EOF
  2693.     case $host_os in
  2694.       mingw*)
  2695. cat <<EOF
  2696.   /* execv doesn't actually work on mingw as expected on unix */
  2697.   rval = _spawnv (_P_WAIT, "$lt_newargv0", (const char * const *) newargz);
  2698.   if (rval == -1)
  2699.     {
  2700.       /* failed to start process */
  2701.       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target "$lt_newargv0": errno = %dn", errno));
  2702.       return 127;
  2703.     }
  2704.   return rval;
  2705. }
  2706. EOF
  2707. ;;
  2708.       *)
  2709. cat <<EOF
  2710.   execv ("$lt_newargv0", newargz);
  2711.   return rval; /* =127, but avoids unused variable warning */
  2712. }
  2713. EOF
  2714. ;;
  2715.     esac
  2716.     cat <<"EOF"
  2717. void *
  2718. xmalloc (size_t num)
  2719. {
  2720.   void *p = (void *) malloc (num);
  2721.   if (!p)
  2722.     lt_fatal ("Memory exhausted");
  2723.   return p;
  2724. }
  2725. char *
  2726. xstrdup (const char *string)
  2727. {
  2728.   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
  2729.   string) : NULL;
  2730. }
  2731. const char *
  2732. base_name (const char *name)
  2733. {
  2734.   const char *base;
  2735. #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  2736.   /* Skip over the disk name in MSDOS pathnames. */
  2737.   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
  2738.     name += 2;
  2739. #endif
  2740.   for (base = name; *name; name++)
  2741.     if (IS_DIR_SEPARATOR (*name))
  2742.       base = name + 1;
  2743.   return base;
  2744. }
  2745. int
  2746. check_executable (const char *path)
  2747. {
  2748.   struct stat st;
  2749.   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %sn",
  2750.   path ? (*path ? path : "EMPTY!") : "NULL!"));
  2751.   if ((!path) || (!*path))
  2752.     return 0;
  2753.   if ((stat (path, &st) >= 0)
  2754.       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
  2755.     return 1;
  2756.   else
  2757.     return 0;
  2758. }
  2759. int
  2760. make_executable (const char *path)
  2761. {
  2762.   int rval = 0;
  2763.   struct stat st;
  2764.   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %sn",
  2765.   path ? (*path ? path : "EMPTY!") : "NULL!"));
  2766.   if ((!path) || (!*path))
  2767.     return 0;
  2768.   if (stat (path, &st) >= 0)
  2769.     {
  2770.       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
  2771.     }
  2772.   return rval;
  2773. }
  2774. /* Searches for the full path of the wrapper.  Returns
  2775.    newly allocated full path name if found, NULL otherwise
  2776.    Does not chase symlinks, even on platforms that support them.
  2777. */
  2778. char *
  2779. find_executable (const char *wrapper)
  2780. {
  2781.   int has_slash = 0;
  2782.   const char *p;
  2783.   const char *p_next;
  2784.   /* static buffer for getcwd */
  2785.   char tmp[LT_PATHMAX + 1];
  2786.   int tmp_len;
  2787.   char *concat_name;
  2788.   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %sn",
  2789.   wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
  2790.   if ((wrapper == NULL) || (*wrapper == ''))
  2791.     return NULL;
  2792.   /* Absolute path? */
  2793. #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  2794.   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
  2795.     {
  2796.       concat_name = xstrdup (wrapper);
  2797.       if (check_executable (concat_name))
  2798. return concat_name;
  2799.       XFREE (concat_name);
  2800.     }
  2801.   else
  2802.     {
  2803. #endif
  2804.       if (IS_DIR_SEPARATOR (wrapper[0]))
  2805. {
  2806.   concat_name = xstrdup (wrapper);
  2807.   if (check_executable (concat_name))
  2808.     return concat_name;
  2809.   XFREE (concat_name);
  2810. }
  2811. #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  2812.     }
  2813. #endif
  2814.   for (p = wrapper; *p; p++)
  2815.     if (*p == '/')
  2816.       {
  2817. has_slash = 1;
  2818. break;
  2819.       }
  2820.   if (!has_slash)
  2821.     {
  2822.       /* no slashes; search PATH */
  2823.       const char *path = getenv ("PATH");
  2824.       if (path != NULL)
  2825. {
  2826.   for (p = path; *p; p = p_next)
  2827.     {
  2828.       const char *q;
  2829.       size_t p_len;
  2830.       for (q = p; *q; q++)
  2831. if (IS_PATH_SEPARATOR (*q))
  2832.   break;
  2833.       p_len = q - p;
  2834.       p_next = (*q == '' ? q : q + 1);
  2835.       if (p_len == 0)
  2836. {
  2837.   /* empty path: current directory */
  2838.   if (getcwd (tmp, LT_PATHMAX) == NULL)
  2839.     lt_fatal ("getcwd failed");
  2840.   tmp_len = strlen (tmp);
  2841.   concat_name =
  2842.     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
  2843.   memcpy (concat_name, tmp, tmp_len);
  2844.   concat_name[tmp_len] = '/';
  2845.   strcpy (concat_name + tmp_len + 1, wrapper);
  2846. }
  2847.       else
  2848. {
  2849.   concat_name =
  2850.     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
  2851.   memcpy (concat_name, p, p_len);
  2852.   concat_name[p_len] = '/';
  2853.   strcpy (concat_name + p_len + 1, wrapper);
  2854. }
  2855.       if (check_executable (concat_name))
  2856. return concat_name;
  2857.       XFREE (concat_name);
  2858.     }
  2859. }
  2860.       /* not found in PATH; assume curdir */
  2861.     }
  2862.   /* Relative path | not found in path: prepend cwd */
  2863.   if (getcwd (tmp, LT_PATHMAX) == NULL)
  2864.     lt_fatal ("getcwd failed");
  2865.   tmp_len = strlen (tmp);
  2866.   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
  2867.   memcpy (concat_name, tmp, tmp_len);
  2868.   concat_name[tmp_len] = '/';
  2869.   strcpy (concat_name + tmp_len + 1, wrapper);
  2870.   if (check_executable (concat_name))
  2871.     return concat_name;
  2872.   XFREE (concat_name);
  2873.   return NULL;
  2874. }
  2875. char *
  2876. chase_symlinks (const char *pathspec)
  2877. {
  2878. #ifndef S_ISLNK
  2879.   return xstrdup (pathspec);
  2880. #else
  2881.   char buf[LT_PATHMAX];
  2882.   struct stat s;
  2883.   char *tmp_pathspec = xstrdup (pathspec);
  2884.   char *p;
  2885.   int has_symlinks = 0;
  2886.   while (strlen (tmp_pathspec) && !has_symlinks)
  2887.     {
  2888.       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %sn",
  2889.       tmp_pathspec));
  2890.       if (lstat (tmp_pathspec, &s) == 0)
  2891. {
  2892.   if (S_ISLNK (s.st_mode) != 0)
  2893.     {
  2894.       has_symlinks = 1;
  2895.       break;
  2896.     }
  2897.   /* search backwards for last DIR_SEPARATOR */
  2898.   p = tmp_pathspec + strlen (tmp_pathspec) - 1;
  2899.   while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
  2900.     p--;
  2901.   if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
  2902.     {
  2903.       /* no more DIR_SEPARATORS left */
  2904.       break;
  2905.     }
  2906.   *p = '';
  2907. }
  2908.       else
  2909. {
  2910.   char *errstr = strerror (errno);
  2911.   lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
  2912. }
  2913.     }
  2914.   XFREE (tmp_pathspec);
  2915.   if (!has_symlinks)
  2916.     {
  2917.       return xstrdup (pathspec);
  2918.     }
  2919.   tmp_pathspec = realpath (pathspec, buf);
  2920.   if (tmp_pathspec == 0)
  2921.     {
  2922.       lt_fatal ("Could not follow symlinks for %s", pathspec);
  2923.     }
  2924.   return xstrdup (tmp_pathspec);
  2925. #endif
  2926. }
  2927. char *
  2928. strendzap (char *str, const char *pat)
  2929. {
  2930.   size_t len, patlen;
  2931.   assert (str != NULL);
  2932.   assert (pat != NULL);
  2933.   len = strlen (str);
  2934.   patlen = strlen (pat);
  2935.   if (patlen <= len)
  2936.     {
  2937.       str += len - patlen;
  2938.       if (strcmp (str, pat) == 0)
  2939. *str = '';
  2940.     }
  2941.   return str;
  2942. }
  2943. static void
  2944. lt_error_core (int exit_status, const char *mode,
  2945.        const char *message, va_list ap)
  2946. {
  2947.   fprintf (stderr, "%s: %s: ", program_name, mode);
  2948.   vfprintf (stderr, message, ap);
  2949.   fprintf (stderr, ".n");
  2950.   if (exit_status >= 0)
  2951.     exit (exit_status);
  2952. }
  2953. void
  2954. lt_fatal (const char *message, ...)
  2955. {
  2956.   va_list ap;
  2957.   va_start (ap, message);
  2958.   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
  2959.   va_end (ap);
  2960. }
  2961. EOF
  2962. }
  2963. # end: func_emit_cwrapperexe_src
  2964. # func_mode_link arg...
  2965. func_mode_link ()
  2966. {
  2967.     $opt_debug
  2968.     case $host in
  2969.     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
  2970.       # It is impossible to link a dll without this setting, and
  2971.       # we shouldn't force the makefile maintainer to figure out
  2972.       # which system we are compiling for in order to pass an extra
  2973.       # flag for every libtool invocation.
  2974.       # allow_undefined=no
  2975.       # FIXME: Unfortunately, there are problems with the above when trying
  2976.       # to make a dll which has undefined symbols, in which case not
  2977.       # even a static library is built.  For now, we need to specify
  2978.       # -no-undefined on the libtool link line when we can be certain
  2979.       # that all symbols are satisfied, otherwise we get a static library.
  2980.       allow_undefined=yes
  2981.       ;;
  2982.     *)
  2983.       allow_undefined=yes
  2984.       ;;
  2985.     esac
  2986.     libtool_args=$nonopt
  2987.     base_compile="$nonopt $@"
  2988.     compile_command=$nonopt
  2989.     finalize_command=$nonopt
  2990.     compile_rpath=
  2991.     finalize_rpath=
  2992.     compile_shlibpath=
  2993.     finalize_shlibpath=
  2994.     convenience=
  2995.     old_convenience=
  2996.     deplibs=
  2997.     old_deplibs=
  2998.     compiler_flags=
  2999.     linker_flags=
  3000.     dllsearchpath=
  3001.     lib_search_path=`pwd`
  3002.     inst_prefix_dir=
  3003.     new_inherited_linker_flags=
  3004.     avoid_version=no
  3005.     dlfiles=
  3006.     dlprefiles=
  3007.     dlself=no
  3008.     export_dynamic=no
  3009.     export_symbols=
  3010.     export_symbols_regex=
  3011.     generated=
  3012.     libobjs=
  3013.     ltlibs=
  3014.     module=no
  3015.     no_install=no
  3016.     objs=
  3017.     non_pic_objects=
  3018.     precious_files_regex=
  3019.     prefer_static_libs=no
  3020.     preload=no
  3021.     prev=
  3022.     prevarg=
  3023.     release=
  3024.     rpath=
  3025.     xrpath=
  3026.     perm_rpath=
  3027.     temp_rpath=
  3028.     thread_safe=no
  3029.     vinfo=
  3030.     vinfo_number=no
  3031.     weak_libs=
  3032.     single_module="${wl}-single_module"
  3033.     func_infer_tag $base_compile
  3034.     # We need to know -static, to get the right output filenames.
  3035.     for arg
  3036.     do
  3037.       case $arg in
  3038.       -shared)
  3039. test "$build_libtool_libs" != yes && 
  3040.   func_fatal_configuration "can not build a shared library"
  3041. build_old_libs=no
  3042. break
  3043. ;;
  3044.       -all-static | -static | -static-libtool-libs)
  3045. case $arg in
  3046. -all-static)
  3047.   if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
  3048.     func_warning "complete static linking is impossible in this configuration"
  3049.   fi
  3050.   if test -n "$link_static_flag"; then
  3051.     dlopen_self=$dlopen_self_static
  3052.     # See comment for -static flag below, for more details.
  3053.     func_append compile_command " $link_static_flag"
  3054.     func_append finalize_command " $link_static_flag"
  3055.   fi
  3056.   prefer_static_libs=yes
  3057.   ;;
  3058. -static)
  3059.   if test -z "$pic_flag" && test -n "$link_static_flag"; then
  3060.     dlopen_self=$dlopen_self_static
  3061.   fi
  3062.   prefer_static_libs=built
  3063.   ;;
  3064. -static-libtool-libs)
  3065.   if test -z "$pic_flag" && test -n "$link_static_flag"; then
  3066.     dlopen_self=$dlopen_self_static
  3067.   fi
  3068.   prefer_static_libs=yes
  3069.   ;;
  3070. esac
  3071. build_libtool_libs=no
  3072. build_old_libs=yes
  3073. break
  3074. ;;
  3075.       esac
  3076.     done
  3077.     # See if our shared archives depend on static archives.
  3078.     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
  3079.     # Go through the arguments, transforming them on the way.
  3080.     while test "$#" -gt 0; do
  3081.       arg="$1"
  3082.       shift
  3083.       func_quote_for_eval "$arg"
  3084.       qarg=$func_quote_for_eval_unquoted_result
  3085.       func_append libtool_args " $func_quote_for_eval_result"
  3086.       # If the previous option needs an argument, assign it.
  3087.       if test -n "$prev"; then
  3088. case $prev in
  3089. output)
  3090.   func_append compile_command " @OUTPUT@"
  3091.   func_append finalize_command " @OUTPUT@"
  3092.   ;;
  3093. esac
  3094. case $prev in
  3095. dlfiles|dlprefiles)
  3096.   if test "$preload" = no; then
  3097.     # Add the symbol object into the linking commands.
  3098.     func_append compile_command " @SYMFILE@"
  3099.     func_append finalize_command " @SYMFILE@"
  3100.     preload=yes
  3101.   fi
  3102.   case $arg in
  3103.   *.la | *.lo) ;;  # We handle these cases below.
  3104.   force)
  3105.     if test "$dlself" = no; then
  3106.       dlself=needless
  3107.       export_dynamic=yes
  3108.     fi
  3109.     prev=
  3110.     continue
  3111.     ;;
  3112.   self)
  3113.     if test "$prev" = dlprefiles; then
  3114.       dlself=yes
  3115.     elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
  3116.       dlself=yes
  3117.     else
  3118.       dlself=needless
  3119.       export_dynamic=yes
  3120.     fi
  3121.     prev=
  3122.     continue
  3123.     ;;
  3124.   *)
  3125.     if test "$prev" = dlfiles; then
  3126.       dlfiles="$dlfiles $arg"
  3127.     else
  3128.       dlprefiles="$dlprefiles $arg"
  3129.     fi
  3130.     prev=
  3131.     continue
  3132.     ;;
  3133.   esac
  3134.   ;;
  3135. expsyms)
  3136.   export_symbols="$arg"
  3137.   test -f "$arg" 
  3138.     || func_fatal_error "symbol file `$arg' does not exist"
  3139.   prev=
  3140.   continue
  3141.   ;;
  3142. expsyms_regex)
  3143.   export_symbols_regex="$arg"
  3144.   prev=
  3145.   continue
  3146.   ;;
  3147. framework)
  3148.   case $host in
  3149.     *-*-darwin*)
  3150.       case "$deplibs " in
  3151. *" $qarg.ltframework "*) ;;
  3152. *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
  3153.    ;;
  3154.       esac
  3155.       ;;
  3156.   esac
  3157.   prev=
  3158.   continue
  3159.   ;;
  3160. inst_prefix)
  3161.   inst_prefix_dir="$arg"
  3162.   prev=
  3163.   continue
  3164.   ;;
  3165. objectlist)
  3166.   if test -f "$arg"; then
  3167.     save_arg=$arg
  3168.     moreargs=
  3169.     for fil in `cat "$save_arg"`
  3170.     do
  3171. #       moreargs="$moreargs $fil"
  3172.       arg=$fil
  3173.       # A libtool-controlled object.
  3174.       # Check to see that this really is a libtool object.
  3175.       if func_lalib_unsafe_p "$arg"; then
  3176. pic_object=
  3177. non_pic_object=
  3178. # Read the .lo file
  3179. func_source "$arg"
  3180. if test -z "$pic_object" ||
  3181.    test -z "$non_pic_object" ||
  3182.    test "$pic_object" = none &&
  3183.    test "$non_pic_object" = none; then
  3184.   func_fatal_error "cannot find name of object for `$arg'"
  3185. fi
  3186. # Extract subdirectory from the argument.
  3187. func_dirname "$arg" "/" ""
  3188. xdir="$func_dirname_result"
  3189. if test "$pic_object" != none; then
  3190.   # Prepend the subdirectory the object is found in.
  3191.   pic_object="$xdir$pic_object"
  3192.   if test "$prev" = dlfiles; then
  3193.     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
  3194.       dlfiles="$dlfiles $pic_object"
  3195.       prev=
  3196.       continue
  3197.     else
  3198.       # If libtool objects are unsupported, then we need to preload.
  3199.       prev=dlprefiles
  3200.     fi
  3201.   fi
  3202.   # CHECK ME:  I think I busted this.  -Ossama
  3203.   if test "$prev" = dlprefiles; then
  3204.     # Preload the old-style object.
  3205.     dlprefiles="$dlprefiles $pic_object"
  3206.     prev=
  3207.   fi
  3208.   # A PIC object.
  3209.   func_append libobjs " $pic_object"
  3210.   arg="$pic_object"
  3211. fi
  3212. # Non-PIC object.
  3213. if test "$non_pic_object" != none; then
  3214.   # Prepend the subdirectory the object is found in.
  3215.   non_pic_object="$xdir$non_pic_object"
  3216.   # A standard non-PIC object
  3217.   func_append non_pic_objects " $non_pic_object"
  3218.   if test -z "$pic_object" || test "$pic_object" = none ; then
  3219.     arg="$non_pic_object"
  3220.   fi
  3221. else
  3222.   # If the PIC object exists, use it instead.
  3223.   # $xdir was prepended to $pic_object above.
  3224.   non_pic_object="$pic_object"
  3225.   func_append non_pic_objects " $non_pic_object"
  3226. fi
  3227.       else
  3228. # Only an error if not doing a dry-run.
  3229. if $opt_dry_run; then
  3230.   # Extract subdirectory from the argument.
  3231.   func_dirname "$arg" "/" ""
  3232.   xdir="$func_dirname_result"
  3233.   func_lo2o "$arg"
  3234.   pic_object=$xdir$objdir/$func_lo2o_result
  3235.   non_pic_object=$xdir$func_lo2o_result
  3236.   func_append libobjs " $pic_object"
  3237.   func_append non_pic_objects " $non_pic_object"
  3238.         else
  3239.   func_fatal_error "`$arg' is not a valid libtool object"
  3240. fi
  3241.       fi
  3242.     done
  3243.   else
  3244.     func_fatal_error "link input file `$arg' does not exist"
  3245.   fi
  3246.   arg=$save_arg
  3247.   prev=
  3248.   continue
  3249.   ;;
  3250. precious_regex)
  3251.   precious_files_regex="$arg"
  3252.   prev=
  3253.   continue
  3254.   ;;
  3255. release)
  3256.   release="-$arg"
  3257.   prev=
  3258.   continue
  3259.   ;;
  3260. rpath | xrpath)
  3261.   # We need an absolute path.
  3262.   case $arg in
  3263.   [\/]* | [A-Za-z]:[\/]*) ;;
  3264.   *)
  3265.     func_fatal_error "only absolute run-paths are allowed"
  3266.     ;;
  3267.   esac
  3268.   if test "$prev" = rpath; then
  3269.     case "$rpath " in
  3270.     *" $arg "*) ;;
  3271.     *) rpath="$rpath $arg" ;;
  3272.     esac
  3273.   else
  3274.     case "$xrpath " in
  3275.     *" $arg "*) ;;
  3276.     *) xrpath="$xrpath $arg" ;;
  3277.     esac
  3278.   fi
  3279.   prev=
  3280.   continue
  3281.   ;;
  3282. shrext)
  3283.   shrext_cmds="$arg"
  3284.   prev=
  3285.   continue
  3286.   ;;
  3287. weak)
  3288.   weak_libs="$weak_libs $arg"
  3289.   prev=
  3290.   continue
  3291.   ;;
  3292. xcclinker)
  3293.   linker_flags="$linker_flags $qarg"
  3294.   compiler_flags="$compiler_flags $qarg"
  3295.   prev=
  3296.   func_append compile_command " $qarg"
  3297.   func_append finalize_command " $qarg"
  3298.   continue
  3299.   ;;
  3300. xcompiler)
  3301.   compiler_flags="$compiler_flags $qarg"
  3302.   prev=
  3303.   func_append compile_command " $qarg"
  3304.   func_append finalize_command " $qarg"
  3305.   continue
  3306.   ;;
  3307. xlinker)
  3308.   linker_flags="$linker_flags $qarg"
  3309.   compiler_flags="$compiler_flags $wl$qarg"
  3310.   prev=
  3311.   func_append compile_command " $wl$qarg"
  3312.   func_append finalize_command " $wl$qarg"
  3313.   continue
  3314.   ;;
  3315. *)
  3316.   eval "$prev="$arg""
  3317.   prev=
  3318.   continue
  3319.   ;;
  3320. esac
  3321.       fi # test -n "$prev"
  3322.       prevarg="$arg"
  3323.       case $arg in
  3324.       -all-static)
  3325. # The effects of -all-static are defined in a previous loop.
  3326. continue
  3327. ;;
  3328.       -allow-undefined)
  3329. # FIXME: remove this flag sometime in the future.
  3330. func_fatal_error "`-allow-undefined' must not be used because it is the default"
  3331. ;;
  3332.       -avoid-version)
  3333. avoid_version=yes
  3334. continue
  3335. ;;
  3336.       -dlopen)
  3337. prev=dlfiles
  3338. continue
  3339. ;;
  3340.       -dlpreopen)
  3341. prev=dlprefiles
  3342. continue
  3343. ;;
  3344.       -export-dynamic)
  3345. export_dynamic=yes
  3346. continue
  3347. ;;
  3348.       -export-symbols | -export-symbols-regex)
  3349. if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
  3350.   func_fatal_error "more than one -exported-symbols argument is not allowed"
  3351. fi
  3352. if test "X$arg" = "X-export-symbols"; then
  3353.   prev=expsyms
  3354. else
  3355.   prev=expsyms_regex
  3356. fi
  3357. continue
  3358. ;;
  3359.       -framework)
  3360. prev=framework
  3361. continue
  3362. ;;
  3363.       -inst-prefix-dir)
  3364. prev=inst_prefix
  3365. continue
  3366. ;;
  3367.       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
  3368.       # so, if we see these flags be careful not to treat them like -L
  3369.       -L[A-Z][A-Z]*:*)
  3370. case $with_gcc/$host in
  3371. no/*-*-irix* | /*-*-irix*)
  3372.   func_append compile_command " $arg"
  3373.   func_append finalize_command " $arg"