/[svn]/ircd-hybrid-8/ltmain.sh
ViewVC logotype

Annotation of /ircd-hybrid-8/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1155 - (hide annotations)
Tue Aug 9 20:27:45 2011 UTC (11 years, 4 months ago) by michael
Original Path: ircd-hybrid/ltmain.sh
File MIME type: application/x-shellscript
File size: 282745 byte(s)
- recreate "trunk"

1 michael 945
2 michael 1107 # libtool (GNU libtool) 2.4
3 michael 945 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4    
5 michael 1094 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6     # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
7 michael 945 # This is free software; see the source for copying conditions. There is NO
8     # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9    
10     # GNU Libtool is free software; you can redistribute it and/or modify
11 michael 912 # it under the terms of the GNU General Public License as published by
12     # the Free Software Foundation; either version 2 of the License, or
13     # (at your option) any later version.
14     #
15 michael 945 # As a special exception to the GNU General Public License,
16     # if you distribute this file as part of a program or library that
17     # is built using GNU Libtool, you may include this file under the
18     # same distribution terms that you use for the rest of that program.
19     #
20     # GNU Libtool is distributed in the hope that it will be useful, but
21 michael 912 # WITHOUT ANY WARRANTY; without even the implied warranty of
22     # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23     # General Public License for more details.
24     #
25     # You should have received a copy of the GNU General Public License
26 michael 945 # along with GNU Libtool; see the file COPYING. If not, a copy
27     # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28     # or obtained by writing to the Free Software Foundation, Inc.,
29     # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30    
31     # Usage: $progname [OPTION]... [MODE-ARG]...
32 michael 912 #
33 michael 945 # Provide generalized library-building support services.
34     #
35 michael 1094 # --config show all configuration variables
36     # --debug enable verbose shell tracing
37     # -n, --dry-run display commands without modifying any files
38     # --features display basic configuration information and exit
39     # --mode=MODE use operation mode MODE
40     # --preserve-dup-deps don't remove duplicate dependency libraries
41     # --quiet, --silent don't print informational messages
42     # --no-quiet, --no-silent
43     # print informational messages (default)
44     # --tag=TAG use configuration variables from tag TAG
45     # -v, --verbose print more informational messages than default
46     # --no-verbose don't print the extra informational messages
47     # --version print version information
48     # -h, --help, --help-all print short, long, or detailed help message
49 michael 945 #
50     # MODE must be one of the following:
51     #
52 michael 1094 # clean remove files from the build directory
53     # compile compile a source file into a libtool object
54     # execute automatically set library path, then run a program
55     # finish complete the installation of libtool libraries
56     # install install libraries or executables
57     # link create a library or an executable
58     # uninstall remove libraries from an installed directory
59 michael 945 #
60 michael 1094 # MODE-ARGS vary depending on the MODE. When passed as first option,
61     # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
62 michael 945 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
63     #
64     # When reporting a bug, please describe a test case to reproduce it and
65     # include the following information:
66     #
67 michael 1094 # host-triplet: $host
68     # shell: $SHELL
69     # compiler: $LTCC
70     # compiler flags: $LTCFLAGS
71     # linker: $LD (gnu? $with_gnu_ld)
72 michael 1107 # $progname: (GNU libtool) 2.4
73 michael 1094 # automake: $automake_version
74     # autoconf: $autoconf_version
75 michael 945 #
76     # Report bugs to <bug-libtool@gnu.org>.
77 michael 1107 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
78     # General help using GNU software: <http://www.gnu.org/gethelp/>.
79 michael 912
80 michael 1094 PROGRAM=libtool
81 michael 912 PACKAGE=libtool
82 michael 1107 VERSION=2.4
83 michael 945 TIMESTAMP=""
84 michael 1107 package_revision=1.3293
85 michael 912
86 michael 945 # Be Bourne compatible
87 michael 912 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
88     emulate sh
89     NULLCMD=:
90     # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91     # is contrary to our usage. Disable this feature.
92     alias -g '${1+"$@"}'='"$@"'
93     setopt NO_GLOB_SUBST
94     else
95     case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
96     fi
97     BIN_SH=xpg4; export BIN_SH # for Tru64
98     DUALCASE=1; export DUALCASE # for MKS sh
99    
100 michael 1094 # A function that is used when there is no print builtin or printf.
101     func_fallback_echo ()
102     {
103     eval 'cat <<_LTECHO_EOF
104     $1
105     _LTECHO_EOF'
106     }
107    
108 michael 945 # NLS nuisances: We save the old values to restore during execute mode.
109     lt_user_locale=
110     lt_safe_locale=
111     for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
112 michael 912 do
113     eval "if test \"\${$lt_var+set}\" = set; then
114 michael 945 save_$lt_var=\$$lt_var
115     $lt_var=C
116 michael 912 export $lt_var
117 michael 945 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
118     lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
119 michael 912 fi"
120     done
121 michael 1094 LC_ALL=C
122     LANGUAGE=C
123     export LANGUAGE LC_ALL
124 michael 912
125 michael 945 $lt_unset CDPATH
126    
127    
128 michael 1094 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
129     # is ksh but when the shell is invoked as "sh" and the current value of
130     # the _XPG environment variable is not equal to 1 (one), the special
131     # positional parameter $0, within a function call, is the name of the
132     # function.
133     progpath="$0"
134 michael 945
135    
136    
137     : ${CP="cp -f"}
138 michael 1094 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
139     : ${EGREP="grep -E"}
140     : ${FGREP="grep -F"}
141     : ${GREP="grep"}
142 michael 945 : ${LN_S="ln -s"}
143     : ${MAKE="make"}
144     : ${MKDIR="mkdir"}
145     : ${MV="mv -f"}
146     : ${RM="rm -f"}
147 michael 1094 : ${SED="sed"}
148 michael 945 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
149     : ${Xsed="$SED -e 1s/^X//"}
150    
151     # Global variables:
152     EXIT_SUCCESS=0
153     EXIT_FAILURE=1
154     EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
155     EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
156    
157     exit_status=$EXIT_SUCCESS
158    
159 michael 912 # Make sure IFS has a sensible default
160     lt_nl='
161     '
162     IFS=" $lt_nl"
163    
164 michael 945 dirname="s,/[^/]*$,,"
165     basename="s,^.*/,,"
166 michael 912
167 michael 1107 # func_dirname file append nondir_replacement
168     # Compute the dirname of FILE. If nonempty, add APPEND to the result,
169     # otherwise set result to NONDIR_REPLACEMENT.
170     func_dirname ()
171     {
172     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
173     if test "X$func_dirname_result" = "X${1}"; then
174     func_dirname_result="${3}"
175     else
176     func_dirname_result="$func_dirname_result${2}"
177     fi
178     } # func_dirname may be replaced by extended shell implementation
179    
180    
181     # func_basename file
182     func_basename ()
183     {
184     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
185     } # func_basename may be replaced by extended shell implementation
186    
187    
188 michael 945 # func_dirname_and_basename file append nondir_replacement
189     # perform func_basename and func_dirname in a single function
190     # call:
191     # dirname: Compute the dirname of FILE. If nonempty,
192     # add APPEND to the result, otherwise set result
193     # to NONDIR_REPLACEMENT.
194     # value returned in "$func_dirname_result"
195     # basename: Compute filename of FILE.
196     # value retuned in "$func_basename_result"
197     # Implementation must be kept synchronized with func_dirname
198     # and func_basename. For efficiency, we do not delegate to
199     # those functions but instead duplicate the functionality here.
200     func_dirname_and_basename ()
201     {
202 michael 1107 # Extract subdirectory from the argument.
203     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
204     if test "X$func_dirname_result" = "X${1}"; then
205     func_dirname_result="${3}"
206     else
207     func_dirname_result="$func_dirname_result${2}"
208     fi
209     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
210     } # func_dirname_and_basename may be replaced by extended shell implementation
211 michael 912
212    
213 michael 1107 # func_stripname prefix suffix name
214     # strip PREFIX and SUFFIX off of NAME.
215     # PREFIX and SUFFIX must not contain globbing or regex special
216     # characters, hashes, percent signs, but SUFFIX may contain a leading
217     # dot (in which case that matches only a dot).
218     # func_strip_suffix prefix name
219     func_stripname ()
220     {
221     case ${2} in
222     .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
223     *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
224     esac
225     } # func_stripname may be replaced by extended shell implementation
226    
227    
228 michael 1094 # These SED scripts presuppose an absolute path with a trailing slash.
229     pathcar='s,^/\([^/]*\).*$,\1,'
230     pathcdr='s,^/[^/]*,,'
231     removedotparts=':dotsl
232     s@/\./@/@g
233     t dotsl
234     s,/\.$,/,'
235     collapseslashes='s@/\{1,\}@/@g'
236     finalslash='s,/*$,/,'
237 michael 945
238 michael 1094 # func_normal_abspath PATH
239     # Remove doubled-up and trailing slashes, "." path components,
240     # and cancel out any ".." path components in PATH after making
241     # it an absolute path.
242     # value returned in "$func_normal_abspath_result"
243     func_normal_abspath ()
244     {
245     # Start from root dir and reassemble the path.
246     func_normal_abspath_result=
247     func_normal_abspath_tpath=$1
248     func_normal_abspath_altnamespace=
249     case $func_normal_abspath_tpath in
250     "")
251     # Empty path, that just means $cwd.
252     func_stripname '' '/' "`pwd`"
253     func_normal_abspath_result=$func_stripname_result
254     return
255     ;;
256     # The next three entries are used to spot a run of precisely
257     # two leading slashes without using negated character classes;
258     # we take advantage of case's first-match behaviour.
259     ///*)
260     # Unusual form of absolute path, do nothing.
261     ;;
262     //*)
263     # Not necessarily an ordinary path; POSIX reserves leading '//'
264     # and for example Cygwin uses it to access remote file shares
265     # over CIFS/SMB, so we conserve a leading double slash if found.
266     func_normal_abspath_altnamespace=/
267     ;;
268     /*)
269     # Absolute path, do nothing.
270     ;;
271     *)
272     # Relative path, prepend $cwd.
273     func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
274     ;;
275     esac
276     # Cancel out all the simple stuff to save iterations. We also want
277     # the path to end with a slash for ease of parsing, so make sure
278     # there is one (and only one) here.
279     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
280     -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
281     while :; do
282     # Processed it all yet?
283     if test "$func_normal_abspath_tpath" = / ; then
284     # If we ascended to the root using ".." the result may be empty now.
285     if test -z "$func_normal_abspath_result" ; then
286     func_normal_abspath_result=/
287     fi
288     break
289     fi
290     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
291     -e "$pathcar"`
292     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
293     -e "$pathcdr"`
294     # Figure out what to do with it
295     case $func_normal_abspath_tcomponent in
296     "")
297     # Trailing empty path component, ignore it.
298     ;;
299     ..)
300     # Parent dir; strip last assembled component from result.
301     func_dirname "$func_normal_abspath_result"
302     func_normal_abspath_result=$func_dirname_result
303     ;;
304     *)
305     # Actual path component, append it.
306     func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
307     ;;
308     esac
309     done
310     # Restore leading double-slash if one was found on entry.
311     func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
312     }
313    
314     # func_relative_path SRCDIR DSTDIR
315     # generates a relative path from SRCDIR to DSTDIR, with a trailing
316     # slash if non-empty, suitable for immediately appending a filename
317     # without needing to append a separator.
318     # value returned in "$func_relative_path_result"
319     func_relative_path ()
320     {
321     func_relative_path_result=
322     func_normal_abspath "$1"
323     func_relative_path_tlibdir=$func_normal_abspath_result
324     func_normal_abspath "$2"
325     func_relative_path_tbindir=$func_normal_abspath_result
326    
327     # Ascend the tree starting from libdir
328     while :; do
329     # check if we have found a prefix of bindir
330     case $func_relative_path_tbindir in
331     $func_relative_path_tlibdir)
332     # found an exact match
333     func_relative_path_tcancelled=
334     break
335     ;;
336     $func_relative_path_tlibdir*)
337     # found a matching prefix
338     func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
339     func_relative_path_tcancelled=$func_stripname_result
340     if test -z "$func_relative_path_result"; then
341     func_relative_path_result=.
342     fi
343     break
344     ;;
345     *)
346     func_dirname $func_relative_path_tlibdir
347     func_relative_path_tlibdir=${func_dirname_result}
348     if test "x$func_relative_path_tlibdir" = x ; then
349     # Have to descend all the way to the root!
350     func_relative_path_result=../$func_relative_path_result
351     func_relative_path_tcancelled=$func_relative_path_tbindir
352     break
353     fi
354     func_relative_path_result=../$func_relative_path_result
355     ;;
356     esac
357     done
358    
359     # Now calculate path; take care to avoid doubling-up slashes.
360     func_stripname '' '/' "$func_relative_path_result"
361     func_relative_path_result=$func_stripname_result
362     func_stripname '/' '/' "$func_relative_path_tcancelled"
363     if test "x$func_stripname_result" != x ; then
364     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
365     fi
366    
367     # Normalisation. If bindir is libdir, return empty string,
368     # else relative path ending with a slash; either way, target
369     # file name can be directly appended.
370     if test ! -z "$func_relative_path_result"; then
371     func_stripname './' '' "$func_relative_path_result/"
372     func_relative_path_result=$func_stripname_result
373     fi
374     }
375    
376 michael 945 # The name of this program:
377     func_dirname_and_basename "$progpath"
378     progname=$func_basename_result
379    
380     # Make sure we have an absolute path for reexecution:
381     case $progpath in
382     [\\/]*|[A-Za-z]:\\*) ;;
383     *[\\/]*)
384     progdir=$func_dirname_result
385     progdir=`cd "$progdir" && pwd`
386     progpath="$progdir/$progname"
387     ;;
388     *)
389     save_IFS="$IFS"
390     IFS=:
391     for progdir in $PATH; do
392     IFS="$save_IFS"
393     test -x "$progdir/$progname" && break
394     done
395     IFS="$save_IFS"
396     test -n "$progdir" || progdir=`pwd`
397     progpath="$progdir/$progname"
398     ;;
399     esac
400    
401     # Sed substitution that helps us do robust quoting. It backslashifies
402     # metacharacters that are still active within double-quoted strings.
403     Xsed="${SED}"' -e 1s/^X//'
404     sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
405    
406     # Same as above, but do not quote variable references.
407     double_quote_subst='s/\(["`\\]\)/\\\1/g'
408    
409 michael 1107 # Sed substitution that turns a string into a regex matching for the
410     # string literally.
411     sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
412    
413     # Sed substitution that converts a w32 file name or path
414     # which contains forward slashes, into one that contains
415     # (escaped) backslashes. A very naive implementation.
416     lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
417    
418 michael 945 # Re-`\' parameter expansions in output of double_quote_subst that were
419     # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
420     # in input to double_quote_subst, that '$' was protected from expansion.
421     # Since each input `\' is now two `\'s, look for any number of runs of
422     # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
423     bs='\\'
424     bs2='\\\\'
425     bs4='\\\\\\\\'
426     dollar='\$'
427     sed_double_backslash="\
428     s/$bs4/&\\
429     /g
430     s/^$bs2$dollar/$bs&/
431     s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
432     s/\n//g"
433    
434     # Standard options:
435     opt_dry_run=false
436     opt_help=false
437     opt_quiet=false
438     opt_verbose=false
439     opt_warning=:
440    
441     # func_echo arg...
442     # Echo program name prefixed message, along with the current mode
443     # name if it has been set yet.
444     func_echo ()
445     {
446 michael 1107 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
447 michael 945 }
448    
449     # func_verbose arg...
450     # Echo program name prefixed message in verbose mode only.
451     func_verbose ()
452     {
453     $opt_verbose && func_echo ${1+"$@"}
454    
455     # A bug in bash halts the script if the last line of a function
456     # fails when set -e is in force, so we need another command to
457     # work around that:
458     :
459     }
460    
461 michael 1094 # func_echo_all arg...
462     # Invoke $ECHO with all args, space-separated.
463     func_echo_all ()
464     {
465     $ECHO "$*"
466     }
467    
468 michael 945 # func_error arg...
469     # Echo program name prefixed message to standard error.
470     func_error ()
471     {
472 michael 1107 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
473 michael 945 }
474    
475     # func_warning arg...
476     # Echo program name prefixed warning message to standard error.
477     func_warning ()
478     {
479 michael 1107 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
480 michael 945
481     # bash bug again:
482     :
483     }
484    
485     # func_fatal_error arg...
486     # Echo program name prefixed message to standard error, and exit.
487     func_fatal_error ()
488     {
489     func_error ${1+"$@"}
490     exit $EXIT_FAILURE
491     }
492    
493     # func_fatal_help arg...
494     # Echo program name prefixed message to standard error, followed by
495     # a help hint, and exit.
496     func_fatal_help ()
497     {
498     func_error ${1+"$@"}
499     func_fatal_error "$help"
500     }
501     help="Try \`$progname --help' for more information." ## default
502    
503    
504     # func_grep expression filename
505     # Check whether EXPRESSION matches any line of FILENAME, without output.
506     func_grep ()
507     {
508     $GREP "$1" "$2" >/dev/null 2>&1
509     }
510    
511    
512     # func_mkdir_p directory-path
513     # Make sure the entire path to DIRECTORY-PATH is available.
514     func_mkdir_p ()
515     {
516     my_directory_path="$1"
517     my_dir_list=
518    
519     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
520    
521     # Protect directory names starting with `-'
522     case $my_directory_path in
523     -*) my_directory_path="./$my_directory_path" ;;
524     esac
525    
526     # While some portion of DIR does not yet exist...
527     while test ! -d "$my_directory_path"; do
528     # ...make a list in topmost first order. Use a colon delimited
529     # list incase some portion of path contains whitespace.
530     my_dir_list="$my_directory_path:$my_dir_list"
531    
532     # If the last portion added has no slash in it, the list is done
533     case $my_directory_path in */*) ;; *) break ;; esac
534    
535     # ...otherwise throw away the child directory and loop
536 michael 1094 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
537 michael 945 done
538 michael 1094 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
539 michael 945
540     save_mkdir_p_IFS="$IFS"; IFS=':'
541     for my_dir in $my_dir_list; do
542     IFS="$save_mkdir_p_IFS"
543     # mkdir can fail with a `File exist' error if two processes
544     # try to create one of the directories concurrently. Don't
545     # stop in that case!
546     $MKDIR "$my_dir" 2>/dev/null || :
547     done
548     IFS="$save_mkdir_p_IFS"
549    
550     # Bail out if we (or some other process) failed to create a directory.
551     test -d "$my_directory_path" || \
552     func_fatal_error "Failed to create \`$1'"
553     fi
554     }
555    
556    
557 michael 912 # func_mktempdir [string]
558     # Make a temporary directory that won't clash with other running
559     # libtool processes, and avoids race conditions if possible. If
560     # given, STRING is the basename for that directory.
561     func_mktempdir ()
562     {
563     my_template="${TMPDIR-/tmp}/${1-$progname}"
564    
565 michael 945 if test "$opt_dry_run" = ":"; then
566 michael 912 # Return a directory name, but don't create it in dry-run mode
567     my_tmpdir="${my_template}-$$"
568     else
569    
570     # If mktemp works, use that first and foremost
571     my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
572    
573     if test ! -d "$my_tmpdir"; then
574 michael 945 # Failing that, at least try and use $RANDOM to avoid a race
575     my_tmpdir="${my_template}-${RANDOM-0}$$"
576 michael 912
577 michael 945 save_mktempdir_umask=`umask`
578     umask 0077
579     $MKDIR "$my_tmpdir"
580     umask $save_mktempdir_umask
581 michael 912 fi
582    
583     # If we're not in dry-run mode, bomb out on failure
584 michael 945 test -d "$my_tmpdir" || \
585     func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
586 michael 912 fi
587    
588 michael 1094 $ECHO "$my_tmpdir"
589 michael 912 }
590    
591    
592 michael 945 # func_quote_for_eval arg
593     # Aesthetically quote ARG to be evaled later.
594     # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
595     # is double-quoted, suitable for a subsequent eval, whereas
596     # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
597     # which are still active within double quotes backslashified.
598     func_quote_for_eval ()
599 michael 912 {
600 michael 945 case $1 in
601     *[\\\`\"\$]*)
602 michael 1094 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
603 michael 945 *)
604     func_quote_for_eval_unquoted_result="$1" ;;
605 michael 912 esac
606 michael 945
607     case $func_quote_for_eval_unquoted_result in
608     # Double-quote args containing shell metacharacters to delay
609     # word splitting, command substitution and and variable
610     # expansion for a subsequent eval.
611     # Many Bourne shells cannot handle close brackets correctly
612     # in scan sets, so we specify it separately.
613     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
614     func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
615     ;;
616     *)
617     func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
618     esac
619 michael 912 }
620    
621    
622 michael 945 # func_quote_for_expand arg
623     # Aesthetically quote ARG to be evaled later; same as above,
624     # but do not quote variable references.
625     func_quote_for_expand ()
626 michael 912 {
627 michael 945 case $1 in
628     *[\\\`\"]*)
629 michael 1094 my_arg=`$ECHO "$1" | $SED \
630 michael 945 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
631 michael 912 *)
632 michael 945 my_arg="$1" ;;
633     esac
634    
635     case $my_arg in
636     # Double-quote args containing shell metacharacters to delay
637     # word splitting and command substitution for a subsequent eval.
638     # Many Bourne shells cannot handle close brackets correctly
639     # in scan sets, so we specify it separately.
640     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
641     my_arg="\"$my_arg\""
642     ;;
643     esac
644    
645     func_quote_for_expand_result="$my_arg"
646 michael 912 }
647    
648    
649 michael 945 # func_show_eval cmd [fail_exp]
650     # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
651     # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
652     # is given, then evaluate it.
653     func_show_eval ()
654 michael 912 {
655 michael 945 my_cmd="$1"
656     my_fail_exp="${2-:}"
657 michael 912
658 michael 945 ${opt_silent-false} || {
659     func_quote_for_expand "$my_cmd"
660     eval "func_echo $func_quote_for_expand_result"
661     }
662    
663     if ${opt_dry_run-false}; then :; else
664     eval "$my_cmd"
665     my_status=$?
666     if test "$my_status" -eq 0; then :; else
667     eval "(exit $my_status); $my_fail_exp"
668     fi
669 michael 912 fi
670     }
671    
672 michael 945
673     # func_show_eval_locale cmd [fail_exp]
674     # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
675     # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
676     # is given, then evaluate it. Use the saved locale for evaluation.
677     func_show_eval_locale ()
678 michael 912 {
679 michael 945 my_cmd="$1"
680     my_fail_exp="${2-:}"
681 michael 912
682 michael 945 ${opt_silent-false} || {
683     func_quote_for_expand "$my_cmd"
684     eval "func_echo $func_quote_for_expand_result"
685     }
686    
687     if ${opt_dry_run-false}; then :; else
688     eval "$lt_user_locale
689     $my_cmd"
690     my_status=$?
691     eval "$lt_safe_locale"
692     if test "$my_status" -eq 0; then :; else
693     eval "(exit $my_status); $my_fail_exp"
694     fi
695 michael 912 fi
696 michael 945 }
697 michael 912
698 michael 1107 # func_tr_sh
699     # Turn $1 into a string suitable for a shell variable name.
700     # Result is stored in $func_tr_sh_result. All characters
701     # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
702     # if $1 begins with a digit, a '_' is prepended as well.
703     func_tr_sh ()
704     {
705     case $1 in
706     [0-9]* | *[!a-zA-Z0-9_]*)
707     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
708     ;;
709     * )
710     func_tr_sh_result=$1
711     ;;
712     esac
713     }
714 michael 912
715 michael 1107
716 michael 945 # func_version
717     # Echo version message to standard output and exit.
718     func_version ()
719     {
720 michael 1107 $opt_debug
721    
722 michael 1094 $SED -n '/(C)/!b go
723     :more
724     /\./!{
725     N
726     s/\n# / /
727     b more
728     }
729     :go
730     /^# '$PROGRAM' (GNU /,/# warranty; / {
731 michael 945 s/^# //
732     s/^# *$//
733     s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
734     p
735     }' < "$progpath"
736     exit $?
737 michael 912 }
738    
739 michael 945 # func_usage
740     # Echo short help message to standard output and exit.
741     func_usage ()
742     {
743 michael 1107 $opt_debug
744    
745 michael 1094 $SED -n '/^# Usage:/,/^# *.*--help/ {
746 michael 945 s/^# //
747     s/^# *$//
748     s/\$progname/'$progname'/
749     p
750     }' < "$progpath"
751 michael 1094 echo
752 michael 945 $ECHO "run \`$progname --help | more' for full usage"
753     exit $?
754     }
755 michael 912
756 michael 1094 # func_help [NOEXIT]
757     # Echo long help message to standard output and exit,
758     # unless 'noexit' is passed as argument.
759 michael 945 func_help ()
760     {
761 michael 1107 $opt_debug
762    
763 michael 945 $SED -n '/^# Usage:/,/# Report bugs to/ {
764 michael 1107 :print
765 michael 945 s/^# //
766     s/^# *$//
767     s*\$progname*'$progname'*
768     s*\$host*'"$host"'*
769     s*\$SHELL*'"$SHELL"'*
770     s*\$LTCC*'"$LTCC"'*
771     s*\$LTCFLAGS*'"$LTCFLAGS"'*
772     s*\$LD*'"$LD"'*
773     s/\$with_gnu_ld/'"$with_gnu_ld"'/
774     s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
775     s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
776     p
777 michael 1107 d
778     }
779     /^# .* home page:/b print
780     /^# General help using/b print
781     ' < "$progpath"
782 michael 1094 ret=$?
783     if test -z "$1"; then
784     exit $ret
785     fi
786 michael 945 }
787 michael 912
788 michael 945 # func_missing_arg argname
789     # Echo program name prefixed message to standard error and set global
790     # exit_cmd.
791     func_missing_arg ()
792     {
793 michael 1107 $opt_debug
794    
795 michael 1094 func_error "missing argument for $1."
796 michael 945 exit_cmd=exit
797     }
798    
799 michael 1107
800     # func_split_short_opt shortopt
801     # Set func_split_short_opt_name and func_split_short_opt_arg shell
802     # variables after splitting SHORTOPT after the 2nd character.
803     func_split_short_opt ()
804     {
805     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
806     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
807    
808     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
809     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
810     } # func_split_short_opt may be replaced by extended shell implementation
811    
812    
813     # func_split_long_opt longopt
814     # Set func_split_long_opt_name and func_split_long_opt_arg shell
815     # variables after splitting LONGOPT at the `=' sign.
816     func_split_long_opt ()
817     {
818     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
819     my_sed_long_arg='1s/^--[^=]*=//'
820    
821     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
822     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
823     } # func_split_long_opt may be replaced by extended shell implementation
824    
825 michael 945 exit_cmd=:
826    
827    
828    
829    
830    
831     magic="%%%MAGIC variable%%%"
832     magic_exe="%%%MAGIC EXE variable%%%"
833 michael 912
834 michael 945 # Global variables.
835     nonopt=
836     preserve_args=
837     lo2o="s/\\.lo\$/.${objext}/"
838     o2lo="s/\\.${objext}\$/.lo/"
839     extracted_archives=
840     extracted_serial=0
841 michael 912
842 michael 945 # If this variable is set in any of the actions, the command in it
843     # will be execed at the end. This prevents here-documents from being
844     # left over by shells.
845     exec_cmd=
846 michael 912
847 michael 1107 # func_append var value
848     # Append VALUE to the end of shell variable VAR.
849     func_append ()
850     {
851     eval "${1}=\$${1}\${2}"
852     } # func_append may be replaced by extended shell implementation
853    
854     # func_append_quoted var value
855     # Quote VALUE and append to the end of shell variable VAR, separated
856     # by a space.
857     func_append_quoted ()
858     {
859     func_quote_for_eval "${2}"
860     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
861     } # func_append_quoted may be replaced by extended shell implementation
862    
863    
864     # func_arith arithmetic-term...
865     func_arith ()
866     {
867     func_arith_result=`expr "${@}"`
868     } # func_arith may be replaced by extended shell implementation
869    
870    
871     # func_len string
872     # STRING may not start with a hyphen.
873     func_len ()
874     {
875     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
876     } # func_len may be replaced by extended shell implementation
877    
878    
879     # func_lo2o object
880     func_lo2o ()
881     {
882     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
883     } # func_lo2o may be replaced by extended shell implementation
884    
885    
886     # func_xform libobj-or-source
887     func_xform ()
888     {
889     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
890     } # func_xform may be replaced by extended shell implementation
891    
892    
893 michael 945 # func_fatal_configuration arg...
894     # Echo program name prefixed message to standard error, followed by
895     # a configuration failure hint, and exit.
896     func_fatal_configuration ()
897     {
898     func_error ${1+"$@"}
899     func_error "See the $PACKAGE documentation for more information."
900     func_fatal_error "Fatal configuration error."
901     }
902 michael 912
903    
904 michael 945 # func_config
905     # Display the configuration for all the tags in this script.
906     func_config ()
907     {
908     re_begincf='^# ### BEGIN LIBTOOL'
909     re_endcf='^# ### END LIBTOOL'
910 michael 912
911 michael 945 # Default configuration.
912     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
913    
914 michael 912 # Now print the configurations for the tags.
915     for tagname in $taglist; do
916 michael 945 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
917 michael 912 done
918 michael 945
919 michael 912 exit $?
920 michael 945 }
921 michael 912
922 michael 945 # func_features
923     # Display the features supported by this script.
924     func_features ()
925     {
926 michael 1094 echo "host: $host"
927 michael 912 if test "$build_libtool_libs" = yes; then
928 michael 1094 echo "enable shared libraries"
929 michael 912 else
930 michael 1094 echo "disable shared libraries"
931 michael 912 fi
932     if test "$build_old_libs" = yes; then
933 michael 1094 echo "enable static libraries"
934 michael 912 else
935 michael 1094 echo "disable static libraries"
936 michael 912 fi
937 michael 945
938 michael 912 exit $?
939 michael 945 }
940 michael 912
941 michael 945 # func_enable_tag tagname
942     # Verify that TAGNAME is valid, and either flag an error and exit, or
943     # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
944     # variable here.
945     func_enable_tag ()
946     {
947     # Global variable:
948     tagname="$1"
949 michael 912
950 michael 945 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
951     re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
952     sed_extractcf="/$re_begincf/,/$re_endcf/p"
953 michael 912
954 michael 945 # Validate tagname.
955     case $tagname in
956     *[!-_A-Za-z0-9,/]*)
957     func_fatal_error "invalid tag name: $tagname"
958     ;;
959     esac
960 michael 912
961 michael 945 # Don't test for the "default" C tag, as we know it's
962     # there but not specially marked.
963     case $tagname in
964     CC) ;;
965     *)
966     if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
967     taglist="$taglist $tagname"
968 michael 912
969 michael 945 # Evaluate the configuration. Be careful to quote the path
970     # and the sed script, to avoid splitting on whitespace, but
971     # also don't use non-portable quotes within backquotes within
972     # quotes we have to do it in 2 steps:
973     extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
974     eval "$extractedcf"
975     else
976     func_error "ignoring unknown tag $tagname"
977     fi
978     ;;
979     esac
980     }
981    
982 michael 1107 # func_check_version_match
983     # Ensure that we are using m4 macros, and libtool script from the same
984     # release of libtool.
985     func_check_version_match ()
986 michael 945 {
987 michael 1107 if test "$package_revision" != "$macro_revision"; then
988     if test "$VERSION" != "$macro_version"; then
989     if test -z "$macro_version"; then
990     cat >&2 <<_LT_EOF
991     $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
992     $progname: definition of this LT_INIT comes from an older release.
993     $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
994     $progname: and run autoconf again.
995     _LT_EOF
996     else
997     cat >&2 <<_LT_EOF
998     $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
999     $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1000     $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1001     $progname: and run autoconf again.
1002     _LT_EOF
1003     fi
1004     else
1005     cat >&2 <<_LT_EOF
1006     $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1007     $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1008     $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1009     $progname: of $PACKAGE $VERSION and run autoconf again.
1010     _LT_EOF
1011     fi
1012 michael 945
1013 michael 1107 exit $EXIT_MISMATCH
1014     fi
1015     }
1016 michael 912
1017 michael 1107
1018     # Shorthand for --mode=foo, only valid as the first argument
1019     case $1 in
1020     clean|clea|cle|cl)
1021     shift; set dummy --mode clean ${1+"$@"}; shift
1022     ;;
1023     compile|compil|compi|comp|com|co|c)
1024     shift; set dummy --mode compile ${1+"$@"}; shift
1025     ;;
1026     execute|execut|execu|exec|exe|ex|e)
1027     shift; set dummy --mode execute ${1+"$@"}; shift
1028     ;;
1029     finish|finis|fini|fin|fi|f)
1030     shift; set dummy --mode finish ${1+"$@"}; shift
1031     ;;
1032     install|instal|insta|inst|ins|in|i)
1033     shift; set dummy --mode install ${1+"$@"}; shift
1034     ;;
1035     link|lin|li|l)
1036     shift; set dummy --mode link ${1+"$@"}; shift
1037     ;;
1038     uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1039     shift; set dummy --mode uninstall ${1+"$@"}; shift
1040     ;;
1041     esac
1042    
1043    
1044    
1045     # Option defaults:
1046     opt_debug=:
1047     opt_dry_run=false
1048     opt_config=false
1049     opt_preserve_dup_deps=false
1050     opt_features=false
1051     opt_finish=false
1052     opt_help=false
1053     opt_help_all=false
1054     opt_silent=:
1055     opt_verbose=:
1056     opt_silent=false
1057     opt_verbose=false
1058    
1059    
1060     # Parse options once, thoroughly. This comes as soon as possible in the
1061     # script to make things like `--version' happen as quickly as we can.
1062     {
1063     # this just eases exit handling
1064     while test $# -gt 0; do
1065 michael 945 opt="$1"
1066     shift
1067     case $opt in
1068 michael 1107 --debug|-x) opt_debug='set -x'
1069 michael 945 func_echo "enabling shell trace mode"
1070     $opt_debug
1071     ;;
1072 michael 1107 --dry-run|--dryrun|-n)
1073     opt_dry_run=:
1074 michael 945 ;;
1075 michael 1107 --config)
1076     opt_config=:
1077     func_config
1078     ;;
1079     --dlopen|-dlopen)
1080     optarg="$1"
1081     opt_dlopen="${opt_dlopen+$opt_dlopen
1082     }$optarg"
1083 michael 945 shift
1084     ;;
1085     --preserve-dup-deps)
1086 michael 1107 opt_preserve_dup_deps=:
1087 michael 945 ;;
1088 michael 1107 --features)
1089     opt_features=:
1090     func_features
1091     ;;
1092     --finish)
1093     opt_finish=:
1094     set dummy --mode finish ${1+"$@"}; shift
1095     ;;
1096     --help)
1097     opt_help=:
1098     ;;
1099     --help-all)
1100     opt_help_all=:
1101     opt_help=': help-all'
1102     ;;
1103     --mode)
1104     test $# = 0 && func_missing_arg $opt && break
1105     optarg="$1"
1106     opt_mode="$optarg"
1107     case $optarg in
1108     # Valid mode arguments:
1109     clean|compile|execute|finish|install|link|relink|uninstall) ;;
1110 michael 945
1111 michael 1107 # Catch anything else as an error
1112     *) func_error "invalid argument for $opt"
1113     exit_cmd=exit
1114     break
1115     ;;
1116     esac
1117     shift
1118 michael 1094 ;;
1119 michael 1107 --no-silent|--no-quiet)
1120 michael 945 opt_silent=false
1121 michael 1107 func_append preserve_args " $opt"
1122 michael 945 ;;
1123 michael 1107 --no-verbose)
1124 michael 1094 opt_verbose=false
1125 michael 1107 func_append preserve_args " $opt"
1126 michael 1094 ;;
1127 michael 1107 --silent|--quiet)
1128     opt_silent=:
1129     func_append preserve_args " $opt"
1130     opt_verbose=false
1131     ;;
1132     --verbose|-v)
1133     opt_verbose=:
1134     func_append preserve_args " $opt"
1135     opt_silent=false
1136     ;;
1137     --tag)
1138     test $# = 0 && func_missing_arg $opt && break
1139     optarg="$1"
1140     opt_tag="$optarg"
1141     func_append preserve_args " $opt $optarg"
1142     func_enable_tag "$optarg"
1143 michael 945 shift
1144     ;;
1145    
1146 michael 1107 -\?|-h) func_usage ;;
1147     --help) func_help ;;
1148     --version) func_version ;;
1149    
1150 michael 945 # Separate optargs to long options:
1151 michael 1107 --*=*)
1152     func_split_long_opt "$opt"
1153     set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1154 michael 945 shift
1155     ;;
1156    
1157 michael 1107 # Separate non-argument short options:
1158     -\?*|-h*|-n*|-v*)
1159     func_split_short_opt "$opt"
1160     set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1161     shift
1162     ;;
1163 michael 945
1164 michael 1107 --) break ;;
1165     -*) func_fatal_help "unrecognized option \`$opt'" ;;
1166     *) set dummy "$opt" ${1+"$@"}; shift; break ;;
1167 michael 945 esac
1168     done
1169    
1170 michael 1107 # Validate options:
1171 michael 945
1172 michael 1107 # save first non-option argument
1173     if test "$#" -gt 0; then
1174     nonopt="$opt"
1175     shift
1176     fi
1177    
1178     # preserve --debug
1179     test "$opt_debug" = : || func_append preserve_args " --debug"
1180    
1181 michael 945 case $host in
1182     *cygwin* | *mingw* | *pw32* | *cegcc*)
1183     # don't eliminate duplications in $postdeps and $predeps
1184     opt_duplicate_compiler_generated_deps=:
1185 michael 912 ;;
1186 michael 945 *)
1187 michael 1107 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1188 michael 912 ;;
1189 michael 945 esac
1190 michael 912
1191 michael 1107 $opt_help || {
1192     # Sanity checks first:
1193     func_check_version_match
1194 michael 945
1195 michael 1107 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1196     func_fatal_configuration "not configured to build any kind of library"
1197 michael 945 fi
1198    
1199 michael 1107 # Darwin sucks
1200     eval std_shrext=\"$shrext_cmds\"
1201 michael 912
1202 michael 1107 # Only execute mode is allowed to have -dlopen flags.
1203     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1204     func_error "unrecognized option \`-dlopen'"
1205     $ECHO "$help" 1>&2
1206     exit $EXIT_FAILURE
1207     fi
1208 michael 945
1209 michael 1107 # Change the help message to a mode-specific one.
1210     generic_help="$help"
1211     help="Try \`$progname --help --mode=$opt_mode' for more information."
1212     }
1213 michael 945
1214    
1215 michael 1107 # Bail if the options were screwed
1216     $exit_cmd $EXIT_FAILURE
1217     }
1218 michael 945
1219    
1220    
1221    
1222 michael 1107 ## ----------- ##
1223     ## Main. ##
1224     ## ----------- ##
1225 michael 945
1226     # func_lalib_p file
1227     # True iff FILE is a libtool `.la' library or `.lo' object file.
1228     # This function is only a basic sanity check; it will hardly flush out
1229     # determined imposters.
1230     func_lalib_p ()
1231     {
1232     test -f "$1" &&
1233     $SED -e 4q "$1" 2>/dev/null \
1234     | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1235     }
1236    
1237     # func_lalib_unsafe_p file
1238     # True iff FILE is a libtool `.la' library or `.lo' object file.
1239     # This function implements the same check as func_lalib_p without
1240     # resorting to external programs. To this end, it redirects stdin and
1241     # closes it afterwards, without saving the original file descriptor.
1242     # As a safety measure, use it only where a negative result would be
1243     # fatal anyway. Works if `file' does not exist.
1244     func_lalib_unsafe_p ()
1245     {
1246     lalib_p=no
1247     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1248     for lalib_p_l in 1 2 3 4
1249     do
1250     read lalib_p_line
1251     case "$lalib_p_line" in
1252     \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1253     esac
1254     done
1255     exec 0<&5 5<&-
1256     fi
1257     test "$lalib_p" = yes
1258     }
1259    
1260     # func_ltwrapper_script_p file
1261     # True iff FILE is a libtool wrapper script
1262     # This function is only a basic sanity check; it will hardly flush out
1263     # determined imposters.
1264     func_ltwrapper_script_p ()
1265     {
1266     func_lalib_p "$1"
1267     }
1268    
1269     # func_ltwrapper_executable_p file
1270     # True iff FILE is a libtool wrapper executable
1271     # This function is only a basic sanity check; it will hardly flush out
1272     # determined imposters.
1273     func_ltwrapper_executable_p ()
1274     {
1275     func_ltwrapper_exec_suffix=
1276     case $1 in
1277     *.exe) ;;
1278     *) func_ltwrapper_exec_suffix=.exe ;;
1279     esac
1280     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1281     }
1282    
1283     # func_ltwrapper_scriptname file
1284     # Assumes file is an ltwrapper_executable
1285     # uses $file to determine the appropriate filename for a
1286     # temporary ltwrapper_script.
1287     func_ltwrapper_scriptname ()
1288     {
1289 michael 1107 func_dirname_and_basename "$1" "" "."
1290     func_stripname '' '.exe' "$func_basename_result"
1291     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1292 michael 945 }
1293    
1294     # func_ltwrapper_p file
1295     # True iff FILE is a libtool wrapper script or wrapper executable
1296     # This function is only a basic sanity check; it will hardly flush out
1297     # determined imposters.
1298     func_ltwrapper_p ()
1299     {
1300     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1301     }
1302    
1303    
1304     # func_execute_cmds commands fail_cmd
1305     # Execute tilde-delimited COMMANDS.
1306     # If FAIL_CMD is given, eval that upon failure.
1307     # FAIL_CMD may read-access the current command in variable CMD!
1308     func_execute_cmds ()
1309     {
1310     $opt_debug
1311     save_ifs=$IFS; IFS='~'
1312     for cmd in $1; do
1313     IFS=$save_ifs
1314     eval cmd=\"$cmd\"
1315     func_show_eval "$cmd" "${2-:}"
1316     done
1317     IFS=$save_ifs
1318     }
1319    
1320    
1321     # func_source file
1322     # Source FILE, adding directory component if necessary.
1323     # Note that it is not necessary on cygwin/mingw to append a dot to
1324     # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1325     # behavior happens only for exec(3), not for open(2)! Also, sourcing
1326     # `FILE.' does not work on cygwin managed mounts.
1327     func_source ()
1328     {
1329     $opt_debug
1330     case $1 in
1331     */* | *\\*) . "$1" ;;
1332     *) . "./$1" ;;
1333     esac
1334     }
1335    
1336    
1337 michael 1107 # func_resolve_sysroot PATH
1338     # Replace a leading = in PATH with a sysroot. Store the result into
1339     # func_resolve_sysroot_result
1340     func_resolve_sysroot ()
1341     {
1342     func_resolve_sysroot_result=$1
1343     case $func_resolve_sysroot_result in
1344     =*)
1345     func_stripname '=' '' "$func_resolve_sysroot_result"
1346     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1347     ;;
1348     esac
1349     }
1350    
1351     # func_replace_sysroot PATH
1352     # If PATH begins with the sysroot, replace it with = and
1353     # store the result into func_replace_sysroot_result.
1354     func_replace_sysroot ()
1355     {
1356     case "$lt_sysroot:$1" in
1357     ?*:"$lt_sysroot"*)
1358     func_stripname "$lt_sysroot" '' "$1"
1359     func_replace_sysroot_result="=$func_stripname_result"
1360     ;;
1361     *)
1362     # Including no sysroot.
1363     func_replace_sysroot_result=$1
1364     ;;
1365     esac
1366     }
1367    
1368 michael 945 # func_infer_tag arg
1369     # Infer tagged configuration to use if any are available and
1370     # if one wasn't chosen via the "--tag" command line option.
1371     # Only attempt this if the compiler in the base compile
1372     # command doesn't match the default compiler.
1373     # arg is usually of the form 'gcc ...'
1374     func_infer_tag ()
1375     {
1376     $opt_debug
1377     if test -n "$available_tags" && test -z "$tagname"; then
1378     CC_quoted=
1379     for arg in $CC; do
1380 michael 1107 func_append_quoted CC_quoted "$arg"
1381 michael 945 done
1382 michael 1094 CC_expanded=`func_echo_all $CC`
1383     CC_quoted_expanded=`func_echo_all $CC_quoted`
1384 michael 945 case $@ in
1385     # Blanks in the command may have been stripped by the calling shell,
1386     # but not from the CC environment variable when configure was run.
1387 michael 1094 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388     " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1389 michael 945 # Blanks at the start of $base_compile will cause this to fail
1390     # if we don't check for them as well.
1391     *)
1392     for z in $available_tags; do
1393     if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1394     # Evaluate the configuration.
1395     eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1396     CC_quoted=
1397     for arg in $CC; do
1398     # Double-quote args containing other shell metacharacters.
1399 michael 1107 func_append_quoted CC_quoted "$arg"
1400 michael 945 done
1401 michael 1094 CC_expanded=`func_echo_all $CC`
1402     CC_quoted_expanded=`func_echo_all $CC_quoted`
1403 michael 945 case "$@ " in
1404 michael 1094 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405     " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1406 michael 945 # The compiler in the base compile command matches
1407     # the one in the tagged configuration.
1408     # Assume this is the tagged configuration we want.
1409     tagname=$z
1410     break
1411     ;;
1412     esac
1413     fi
1414     done
1415     # If $tagname still isn't set, then no tagged configuration
1416     # was found and let the user know that the "--tag" command
1417     # line option must be used.
1418     if test -z "$tagname"; then
1419     func_echo "unable to infer tagged configuration"
1420     func_fatal_error "specify a tag with \`--tag'"
1421     # else
1422     # func_verbose "using $tagname tagged configuration"
1423     fi
1424     ;;
1425     esac
1426     fi
1427     }
1428    
1429    
1430    
1431     # func_write_libtool_object output_name pic_name nonpic_name
1432     # Create a libtool object file (analogous to a ".la" file),
1433     # but don't create it if we're doing a dry run.
1434     func_write_libtool_object ()
1435     {
1436     write_libobj=${1}
1437     if test "$build_libtool_libs" = yes; then
1438     write_lobj=\'${2}\'
1439     else
1440     write_lobj=none
1441     fi
1442    
1443     if test "$build_old_libs" = yes; then
1444     write_oldobj=\'${3}\'
1445     else
1446     write_oldobj=none
1447     fi
1448    
1449     $opt_dry_run || {
1450     cat >${write_libobj}T <<EOF
1451     # $write_libobj - a libtool object file
1452     # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1453     #
1454     # Please DO NOT delete this file!
1455     # It is necessary for linking the library.
1456    
1457     # Name of the PIC object.
1458     pic_object=$write_lobj
1459    
1460     # Name of the non-PIC object
1461     non_pic_object=$write_oldobj
1462    
1463     EOF
1464     $MV "${write_libobj}T" "${write_libobj}"
1465     }
1466     }
1467    
1468 michael 1107
1469     ##################################################
1470     # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1471     ##################################################
1472    
1473     # func_convert_core_file_wine_to_w32 ARG
1474     # Helper function used by file name conversion functions when $build is *nix,
1475     # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1476     # correctly configured wine environment available, with the winepath program
1477     # in $build's $PATH.
1478     #
1479     # ARG is the $build file name to be converted to w32 format.
1480     # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1481     # be empty on error (or when ARG is empty)
1482     func_convert_core_file_wine_to_w32 ()
1483     {
1484     $opt_debug
1485     func_convert_core_file_wine_to_w32_result="$1"
1486     if test -n "$1"; then
1487     # Unfortunately, winepath does not exit with a non-zero error code, so we
1488     # are forced to check the contents of stdout. On the other hand, if the
1489     # command is not found, the shell will set an exit code of 127 and print
1490     # *an error message* to stdout. So we must check for both error code of
1491     # zero AND non-empty stdout, which explains the odd construction:
1492     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1493     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1494     func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1495     $SED -e "$lt_sed_naive_backslashify"`
1496     else
1497     func_convert_core_file_wine_to_w32_result=
1498     fi
1499     fi
1500     }
1501     # end: func_convert_core_file_wine_to_w32
1502    
1503    
1504     # func_convert_core_path_wine_to_w32 ARG
1505     # Helper function used by path conversion functions when $build is *nix, and
1506     # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1507     # configured wine environment available, with the winepath program in $build's
1508     # $PATH. Assumes ARG has no leading or trailing path separator characters.
1509     #
1510     # ARG is path to be converted from $build format to win32.
1511     # Result is available in $func_convert_core_path_wine_to_w32_result.
1512     # Unconvertible file (directory) names in ARG are skipped; if no directory names
1513     # are convertible, then the result may be empty.
1514     func_convert_core_path_wine_to_w32 ()
1515     {
1516     $opt_debug
1517     # unfortunately, winepath doesn't convert paths, only file names
1518     func_convert_core_path_wine_to_w32_result=""
1519     if test -n "$1"; then
1520     oldIFS=$IFS
1521     IFS=:
1522     for func_convert_core_path_wine_to_w32_f in $1; do
1523     IFS=$oldIFS
1524     func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1525     if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1526     if test -z "$func_convert_core_path_wine_to_w32_result"; then
1527     func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1528     else
1529     func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1530     fi
1531     fi
1532     done
1533     IFS=$oldIFS
1534     fi
1535     }
1536     # end: func_convert_core_path_wine_to_w32
1537    
1538    
1539     # func_cygpath ARGS...
1540     # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1541     # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1542     # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1543     # (2), returns the Cygwin file name or path in func_cygpath_result (input
1544     # file name or path is assumed to be in w32 format, as previously converted
1545     # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1546     # or path in func_cygpath_result (input file name or path is assumed to be in
1547     # Cygwin format). Returns an empty string on error.
1548     #
1549     # ARGS are passed to cygpath, with the last one being the file name or path to
1550     # be converted.
1551     #
1552     # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1553     # environment variable; do not put it in $PATH.
1554     func_cygpath ()
1555     {
1556     $opt_debug
1557     if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1558     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1559     if test "$?" -ne 0; then
1560     # on failure, ensure result is empty
1561     func_cygpath_result=
1562     fi
1563     else
1564     func_cygpath_result=
1565     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1566     fi
1567     }
1568     #end: func_cygpath
1569    
1570    
1571     # func_convert_core_msys_to_w32 ARG
1572     # Convert file name or path ARG from MSYS format to w32 format. Return
1573     # result in func_convert_core_msys_to_w32_result.
1574     func_convert_core_msys_to_w32 ()
1575     {
1576     $opt_debug
1577     # awkward: cmd appends spaces to result
1578     func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1579     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1580     }
1581     #end: func_convert_core_msys_to_w32
1582    
1583    
1584     # func_convert_file_check ARG1 ARG2
1585     # Verify that ARG1 (a file name in $build format) was converted to $host
1586     # format in ARG2. Otherwise, emit an error message, but continue (resetting
1587     # func_to_host_file_result to ARG1).
1588     func_convert_file_check ()
1589     {
1590     $opt_debug
1591     if test -z "$2" && test -n "$1" ; then
1592     func_error "Could not determine host file name corresponding to"
1593     func_error " \`$1'"
1594     func_error "Continuing, but uninstalled executables may not work."
1595     # Fallback:
1596     func_to_host_file_result="$1"
1597     fi
1598     }
1599     # end func_convert_file_check
1600    
1601    
1602     # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1603     # Verify that FROM_PATH (a path in $build format) was converted to $host
1604     # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1605     # func_to_host_file_result to a simplistic fallback value (see below).
1606     func_convert_path_check ()
1607     {
1608     $opt_debug
1609     if test -z "$4" && test -n "$3"; then
1610     func_error "Could not determine the host path corresponding to"
1611     func_error " \`$3'"
1612     func_error "Continuing, but uninstalled executables may not work."
1613     # Fallback. This is a deliberately simplistic "conversion" and
1614     # should not be "improved". See libtool.info.
1615     if test "x$1" != "x$2"; then
1616     lt_replace_pathsep_chars="s|$1|$2|g"
1617     func_to_host_path_result=`echo "$3" |
1618     $SED -e "$lt_replace_pathsep_chars"`
1619     else
1620     func_to_host_path_result="$3"
1621     fi
1622     fi
1623     }
1624     # end func_convert_path_check
1625    
1626    
1627     # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1628     # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1629     # and appending REPL if ORIG matches BACKPAT.
1630     func_convert_path_front_back_pathsep ()
1631     {
1632     $opt_debug
1633     case $4 in
1634     $1 ) func_to_host_path_result="$3$func_to_host_path_result"
1635     ;;
1636     esac
1637     case $4 in
1638     $2 ) func_append func_to_host_path_result "$3"
1639     ;;
1640     esac
1641     }
1642     # end func_convert_path_front_back_pathsep
1643    
1644    
1645     ##################################################
1646     # $build to $host FILE NAME CONVERSION FUNCTIONS #
1647     ##################################################
1648     # invoked via `$to_host_file_cmd ARG'
1649     #
1650     # In each case, ARG is the path to be converted from $build to $host format.
1651     # Result will be available in $func_to_host_file_result.
1652    
1653    
1654     # func_to_host_file ARG
1655     # Converts the file name ARG from $build format to $host format. Return result
1656     # in func_to_host_file_result.
1657     func_to_host_file ()
1658     {
1659     $opt_debug
1660     $to_host_file_cmd "$1"
1661     }
1662     # end func_to_host_file
1663    
1664    
1665     # func_to_tool_file ARG LAZY
1666     # converts the file name ARG from $build format to toolchain format. Return
1667     # result in func_to_tool_file_result. If the conversion in use is listed
1668     # in (the comma separated) LAZY, no conversion takes place.
1669     func_to_tool_file ()
1670     {
1671     $opt_debug
1672     case ,$2, in
1673     *,"$to_tool_file_cmd",*)
1674     func_to_tool_file_result=$1
1675     ;;
1676     *)
1677     $to_tool_file_cmd "$1"
1678     func_to_tool_file_result=$func_to_host_file_result
1679     ;;
1680     esac
1681     }
1682     # end func_to_tool_file
1683    
1684    
1685     # func_convert_file_noop ARG
1686     # Copy ARG to func_to_host_file_result.
1687     func_convert_file_noop ()
1688     {
1689     func_to_host_file_result="$1"
1690     }
1691     # end func_convert_file_noop
1692    
1693    
1694     # func_convert_file_msys_to_w32 ARG
1695     # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1696     # conversion to w32 is not available inside the cwrapper. Returns result in
1697     # func_to_host_file_result.
1698     func_convert_file_msys_to_w32 ()
1699     {
1700     $opt_debug
1701     func_to_host_file_result="$1"
1702     if test -n "$1"; then
1703     func_convert_core_msys_to_w32 "$1"
1704     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1705     fi
1706     func_convert_file_check "$1" "$func_to_host_file_result"
1707     }
1708     # end func_convert_file_msys_to_w32
1709    
1710    
1711     # func_convert_file_cygwin_to_w32 ARG
1712     # Convert file name ARG from Cygwin to w32 format. Returns result in
1713     # func_to_host_file_result.
1714     func_convert_file_cygwin_to_w32 ()
1715     {
1716     $opt_debug
1717     func_to_host_file_result="$1"
1718     if test -n "$1"; then
1719     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1720     # LT_CYGPATH in this case.
1721     func_to_host_file_result=`cygpath -m "$1"`
1722     fi
1723     func_convert_file_check "$1" "$func_to_host_file_result"
1724     }
1725     # end func_convert_file_cygwin_to_w32
1726    
1727    
1728     # func_convert_file_nix_to_w32 ARG
1729     # Convert file name ARG from *nix to w32 format. Requires a wine environment
1730     # and a working winepath. Returns result in func_to_host_file_result.
1731     func_convert_file_nix_to_w32 ()
1732     {
1733     $opt_debug
1734     func_to_host_file_result="$1"
1735     if test -n "$1"; then
1736     func_convert_core_file_wine_to_w32 "$1"
1737     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1738     fi
1739     func_convert_file_check "$1" "$func_to_host_file_result"
1740     }
1741     # end func_convert_file_nix_to_w32
1742    
1743    
1744     # func_convert_file_msys_to_cygwin ARG
1745     # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1746     # Returns result in func_to_host_file_result.
1747     func_convert_file_msys_to_cygwin ()
1748     {
1749     $opt_debug
1750     func_to_host_file_result="$1"
1751     if test -n "$1"; then
1752     func_convert_core_msys_to_w32 "$1"
1753     func_cygpath -u "$func_convert_core_msys_to_w32_result"
1754     func_to_host_file_result="$func_cygpath_result"
1755     fi
1756     func_convert_file_check "$1" "$func_to_host_file_result"
1757     }
1758     # end func_convert_file_msys_to_cygwin
1759    
1760    
1761     # func_convert_file_nix_to_cygwin ARG
1762     # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1763     # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1764     # in func_to_host_file_result.
1765     func_convert_file_nix_to_cygwin ()
1766     {
1767     $opt_debug
1768     func_to_host_file_result="$1"
1769     if test -n "$1"; then
1770     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1771     func_convert_core_file_wine_to_w32 "$1"
1772     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1773     func_to_host_file_result="$func_cygpath_result"
1774     fi
1775     func_convert_file_check "$1" "$func_to_host_file_result"
1776     }
1777     # end func_convert_file_nix_to_cygwin
1778    
1779    
1780     #############################################
1781     # $build to $host PATH CONVERSION FUNCTIONS #
1782     #############################################
1783     # invoked via `$to_host_path_cmd ARG'
1784     #
1785     # In each case, ARG is the path to be converted from $build to $host format.
1786     # The result will be available in $func_to_host_path_result.
1787     #
1788     # Path separators are also converted from $build format to $host format. If
1789     # ARG begins or ends with a path separator character, it is preserved (but
1790     # converted to $host format) on output.
1791     #
1792     # All path conversion functions are named using the following convention:
1793     # file name conversion function : func_convert_file_X_to_Y ()
1794     # path conversion function : func_convert_path_X_to_Y ()
1795     # where, for any given $build/$host combination the 'X_to_Y' value is the
1796     # same. If conversion functions are added for new $build/$host combinations,
1797     # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1798     # will break.
1799    
1800    
1801     # func_init_to_host_path_cmd
1802     # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1803     # appropriate value, based on the value of $to_host_file_cmd.
1804     to_host_path_cmd=
1805     func_init_to_host_path_cmd ()
1806     {
1807     $opt_debug
1808     if test -z "$to_host_path_cmd"; then
1809     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1810     to_host_path_cmd="func_convert_path_${func_stripname_result}"
1811     fi
1812     }
1813    
1814    
1815     # func_to_host_path ARG
1816     # Converts the path ARG from $build format to $host format. Return result
1817     # in func_to_host_path_result.
1818     func_to_host_path ()
1819     {
1820     $opt_debug
1821     func_init_to_host_path_cmd
1822     $to_host_path_cmd "$1"
1823     }
1824     # end func_to_host_path
1825    
1826    
1827     # func_convert_path_noop ARG
1828     # Copy ARG to func_to_host_path_result.
1829     func_convert_path_noop ()
1830     {
1831     func_to_host_path_result="$1"
1832     }
1833     # end func_convert_path_noop
1834    
1835    
1836     # func_convert_path_msys_to_w32 ARG
1837     # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1838     # conversion to w32 is not available inside the cwrapper. Returns result in
1839     # func_to_host_path_result.
1840     func_convert_path_msys_to_w32 ()
1841     {
1842     $opt_debug
1843     func_to_host_path_result="$1"
1844     if test -n "$1"; then
1845     # Remove leading and trailing path separator characters from ARG. MSYS
1846     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1847     # and winepath ignores them completely.
1848     func_stripname : : "$1"
1849     func_to_host_path_tmp1=$func_stripname_result
1850     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1851     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1852     func_convert_path_check : ";" \
1853     "$func_to_host_path_tmp1" "$func_to_host_path_result"
1854     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1855     fi
1856     }
1857     # end func_convert_path_msys_to_w32
1858    
1859    
1860     # func_convert_path_cygwin_to_w32 ARG
1861     # Convert path ARG from Cygwin to w32 format. Returns result in
1862     # func_to_host_file_result.
1863     func_convert_path_cygwin_to_w32 ()
1864     {
1865     $opt_debug
1866     func_to_host_path_result="$1"
1867     if test -n "$1"; then
1868     # See func_convert_path_msys_to_w32:
1869     func_stripname : : "$1"
1870     func_to_host_path_tmp1=$func_stripname_result
1871     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1872     func_convert_path_check : ";" \
1873     "$func_to_host_path_tmp1" "$func_to_host_path_result"
1874     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1875     fi
1876     }
1877     # end func_convert_path_cygwin_to_w32
1878    
1879    
1880     # func_convert_path_nix_to_w32 ARG
1881     # Convert path ARG from *nix to w32 format. Requires a wine environment and
1882     # a working winepath. Returns result in func_to_host_file_result.
1883     func_convert_path_nix_to_w32 ()
1884     {
1885     $opt_debug
1886     func_to_host_path_result="$1"
1887     if test -n "$1"; then
1888     # See func_convert_path_msys_to_w32:
1889     func_stripname : : "$1"
1890     func_to_host_path_tmp1=$func_stripname_result
1891     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1892     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1893     func_convert_path_check : ";" \
1894     "$func_to_host_path_tmp1" "$func_to_host_path_result"
1895     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1896     fi
1897     }
1898     # end func_convert_path_nix_to_w32
1899    
1900    
1901     # func_convert_path_msys_to_cygwin ARG
1902     # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1903     # Returns result in func_to_host_file_result.
1904     func_convert_path_msys_to_cygwin ()
1905     {
1906     $opt_debug
1907     func_to_host_path_result="$1"
1908     if test -n "$1"; then
1909     # See func_convert_path_msys_to_w32:
1910     func_stripname : : "$1"
1911     func_to_host_path_tmp1=$func_stripname_result
1912     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1913     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1914     func_to_host_path_result="$func_cygpath_result"
1915     func_convert_path_check : : \
1916     "$func_to_host_path_tmp1" "$func_to_host_path_result"
1917     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1918     fi
1919     }
1920     # end func_convert_path_msys_to_cygwin
1921    
1922    
1923     # func_convert_path_nix_to_cygwin ARG
1924     # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1925     # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1926     # func_to_host_file_result.
1927     func_convert_path_nix_to_cygwin ()
1928     {
1929     $opt_debug
1930     func_to_host_path_result="$1"
1931     if test -n "$1"; then
1932     # Remove leading and trailing path separator characters from
1933     # ARG. msys behavior is inconsistent here, cygpath turns them
1934     # into '.;' and ';.', and winepath ignores them completely.
1935     func_stripname : : "$1"
1936     func_to_host_path_tmp1=$func_stripname_result
1937     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1938     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1939     func_to_host_path_result="$func_cygpath_result"
1940     func_convert_path_check : : \
1941     "$func_to_host_path_tmp1" "$func_to_host_path_result"
1942     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1943     fi
1944     }
1945     # end func_convert_path_nix_to_cygwin
1946    
1947    
1948 michael 945 # func_mode_compile arg...
1949     func_mode_compile ()
1950     {
1951     $opt_debug
1952 michael 912 # Get the compilation command and the source file.
1953     base_compile=
1954     srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1955     suppress_opt=yes
1956     suppress_output=
1957     arg_mode=normal
1958     libobj=
1959     later=
1960 michael 945 pie_flag=
1961 michael 912
1962     for arg
1963     do
1964     case $arg_mode in
1965     arg )
1966     # do not "continue". Instead, add this to base_compile
1967     lastarg="$arg"
1968     arg_mode=normal
1969     ;;
1970    
1971     target )
1972     libobj="$arg"
1973     arg_mode=normal
1974     continue
1975     ;;
1976    
1977     normal )
1978     # Accept any command-line options.
1979     case $arg in
1980     -o)
1981 michael 945 test -n "$libobj" && \
1982     func_fatal_error "you cannot specify \`-o' more than once"
1983 michael 912 arg_mode=target
1984     continue
1985     ;;
1986    
1987 michael 945 -pie | -fpie | -fPIE)
1988 michael 1107 func_append pie_flag " $arg"
1989 michael 945 continue
1990     ;;
1991    
1992     -shared | -static | -prefer-pic | -prefer-non-pic)
1993 michael 1107 func_append later " $arg"
1994 michael 912 continue
1995     ;;
1996    
1997     -no-suppress)
1998     suppress_opt=no
1999     continue
2000     ;;
2001    
2002     -Xcompiler)
2003     arg_mode=arg # the next one goes into the "base_compile" arg list
2004     continue # The current "srcfile" will either be retained or
2005     ;; # replaced later. I would guess that would be a bug.
2006    
2007     -Wc,*)
2008 michael 945 func_stripname '-Wc,' '' "$arg"
2009     args=$func_stripname_result
2010 michael 912 lastarg=
2011     save_ifs="$IFS"; IFS=','
2012 michael 945 for arg in $args; do
2013 michael 912 IFS="$save_ifs"
2014 michael 1107 func_append_quoted lastarg "$arg"
2015 michael 912 done
2016     IFS="$save_ifs"
2017 michael 945 func_stripname ' ' '' "$lastarg"
2018     lastarg=$func_stripname_result
2019 michael 912
2020     # Add the arguments to base_compile.
2021 michael 1107 func_append base_compile " $lastarg"
2022 michael 912 continue
2023     ;;
2024    
2025 michael 945 *)
2026 michael 912 # Accept the current argument as the source file.
2027     # The previous "srcfile" becomes the current argument.
2028     #
2029     lastarg="$srcfile"
2030     srcfile="$arg"
2031     ;;
2032     esac # case $arg
2033     ;;
2034     esac # case $arg_mode
2035    
2036     # Aesthetically quote the previous argument.
2037 michael 1107 func_append_quoted base_compile "$lastarg"
2038 michael 912 done # for arg
2039    
2040     case $arg_mode in
2041     arg)
2042 michael 945 func_fatal_error "you must specify an argument for -Xcompile"
2043 michael 912 ;;
2044     target)
2045 michael 945 func_fatal_error "you must specify a target with \`-o'"
2046 michael 912 ;;
2047     *)
2048     # Get the name of the library object.
2049 michael 945 test -z "$libobj" && {
2050     func_basename "$srcfile"
2051     libobj="$func_basename_result"
2052     }
2053 michael 912 ;;
2054     esac
2055    
2056     # Recognize several different file suffixes.
2057     # If the user specifies -o file.o, it is replaced with file.lo
2058     case $libobj in
2059 michael 945 *.[cCFSifmso] | \
2060     *.ada | *.adb | *.ads | *.asm | \
2061     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2062 michael 1094 *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
2063 michael 945 func_xform "$libobj"
2064     libobj=$func_xform_result
2065     ;;
2066 michael 912 esac
2067    
2068     case $libobj in
2069 michael 945 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2070 michael 912 *)
2071 michael 945 func_fatal_error "cannot determine name of library object from \`$libobj'"
2072 michael 912 ;;
2073     esac
2074    
2075     func_infer_tag $base_compile
2076    
2077     for arg in $later; do
2078     case $arg in
2079 michael 945 -shared)
2080     test "$build_libtool_libs" != yes && \
2081     func_fatal_configuration "can not build a shared library"
2082     build_old_libs=no
2083     continue
2084     ;;
2085    
2086 michael 912 -static)
2087 michael 945 build_libtool_libs=no
2088 michael 912 build_old_libs=yes
2089     continue
2090     ;;
2091    
2092     -prefer-pic)
2093     pic_mode=yes
2094     continue
2095     ;;
2096    
2097     -prefer-non-pic)
2098     pic_mode=no
2099     continue
2100     ;;
2101     esac
2102     done
2103    
2104 michael 945 func_quote_for_eval "$libobj"
2105     test "X$libobj" != "X$func_quote_for_eval_result" \
2106     && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2107     && func_warning "libobj name \`$libobj' may not contain shell special characters."
2108     func_dirname_and_basename "$obj" "/" ""
2109     objname="$func_basename_result"
2110     xdir="$func_dirname_result"
2111 michael 912 lobj=${xdir}$objdir/$objname
2112    
2113 michael 945 test -z "$base_compile" && \
2114     func_fatal_help "you must specify a compilation command"
2115 michael 912
2116     # Delete any leftover library objects.
2117     if test "$build_old_libs" = yes; then
2118     removelist="$obj $lobj $libobj ${libobj}T"
2119     else
2120     removelist="$lobj $libobj ${libobj}T"
2121     fi
2122    
2123     # On Cygwin there's no "real" PIC flag so we must build both object types
2124     case $host_os in
2125 michael 945 cygwin* | mingw* | pw32* | os2* | cegcc*)
2126 michael 912 pic_mode=default
2127     ;;
2128     esac
2129     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2130     # non-PIC code in shared libraries is not supported
2131     pic_mode=default
2132     fi
2133    
2134     # Calculate the filename of the output object if compiler does
2135     # not support -o with -c
2136     if test "$compiler_c_o" = no; then
2137 michael 1094 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2138 michael 912 lockfile="$output_obj.lock"
2139     else
2140     output_obj=
2141     need_locks=no
2142     lockfile=
2143     fi
2144    
2145     # Lock this critical section if it is needed
2146     # We use this script file to make the link, it avoids creating a new file
2147     if test "$need_locks" = yes; then
2148 michael 945 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2149     func_echo "Waiting for $lockfile to be removed"
2150 michael 912 sleep 2
2151     done
2152     elif test "$need_locks" = warn; then
2153     if test -f "$lockfile"; then
2154 michael 945 $ECHO "\
2155 michael 912 *** ERROR, $lockfile exists and contains:
2156     `cat $lockfile 2>/dev/null`
2157    
2158     This indicates that another process is trying to use the same
2159     temporary object file, and libtool could not work around it because
2160     your compiler does not support \`-c' and \`-o' together. If you
2161     repeat this compilation, it may succeed, by chance, but you had better
2162     avoid parallel builds (make -j) in this platform, or get a better
2163     compiler."
2164    
2165 michael 945 $opt_dry_run || $RM $removelist
2166 michael 912 exit $EXIT_FAILURE
2167     fi
2168 michael 1107 func_append removelist " $output_obj"
2169 michael 945 $ECHO "$srcfile" > "$lockfile"
2170 michael 912 fi
2171    
2172 michael 945 $opt_dry_run || $RM $removelist
2173 michael 1107 func_append removelist " $lockfile"
2174 michael 945 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2175    
2176 michael 1107 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177     srcfile=$func_to_tool_file_result
2178 michael 945 func_quote_for_eval "$srcfile"
2179     qsrcfile=$func_quote_for_eval_result
2180 michael 912
2181     # Only build a PIC object if we are building libtool libraries.
2182     if test "$build_libtool_libs" = yes; then
2183     # Without this assignment, base_compile gets emptied.
2184     fbsd_hideous_sh_bug=$base_compile
2185    
2186     if test "$pic_mode" != no; then
2187     command="$base_compile $qsrcfile $pic_flag"
2188     else
2189     # Don't build PIC code
2190     command="$base_compile $qsrcfile"
2191     fi
2192    
2193 michael 945 func_mkdir_p "$xdir$objdir"
2194 michael 912
2195     if test -z "$output_obj"; then
2196     # Place PIC objects in $objdir
2197 michael 1107 func_append command " -o $lobj"
2198 michael 912 fi
2199    
2200 michael 945 func_show_eval_locale "$command" \
2201     'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2202 michael 912
2203     if test "$need_locks" = warn &&
2204     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2205 michael 945 $ECHO "\
2206 michael 912 *** ERROR, $lockfile contains:
2207     `cat $lockfile 2>/dev/null`
2208    
2209     but it should contain:
2210     $srcfile
2211    
2212     This indicates that another process is trying to use the same
2213     temporary object file, and libtool could not work around it because
2214     your compiler does not support \`-c' and \`-o' together. If you
2215     repeat this compilation, it may succeed, by chance, but you had better
2216     avoid parallel builds (make -j) in this platform, or get a better
2217     compiler."
2218    
2219 michael 945 $opt_dry_run || $RM $removelist
2220 michael 912 exit $EXIT_FAILURE
2221     fi
2222    
2223     # Just move the object if needed, then go on to compile the next one
2224     if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2225 michael 945 func_show_eval '$MV "$output_obj" "$lobj"' \
2226     'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2227 michael 912 fi
2228    
2229     # Allow error messages only from the first compilation.
2230     if test "$suppress_opt" = yes; then
2231 michael 945 suppress_output=' >/dev/null 2>&1'
2232 michael 912 fi
2233     fi
2234    
2235     # Only build a position-dependent object if we build old libraries.
2236     if test "$build_old_libs" = yes; then
2237     if test "$pic_mode" != yes; then
2238     # Don't build PIC code
2239 michael 945 command="$base_compile $qsrcfile$pie_flag"
2240 michael 912 else
2241     command="$base_compile $qsrcfile $pic_flag"
2242     fi
2243     if test "$compiler_c_o" = yes; then
2244 michael 1107 func_append command " -o $obj"
2245 michael 912 fi
2246    
2247     # Suppress compiler output if we already did a PIC compilation.
2248 michael 1107 func_append command "$suppress_output"
2249 michael 945 func_show_eval_locale "$command" \
2250     '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2251 michael 912
2252     if test "$need_locks" = warn &&
2253     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2254 michael 945 $ECHO "\
2255 michael 912 *** ERROR, $lockfile contains:
2256     `cat $lockfile 2>/dev/null`
2257    
2258     but it should contain:
2259     $srcfile
2260    
2261     This indicates that another process is trying to use the same
2262     temporary object file, and libtool could not work around it because
2263     your compiler does not support \`-c' and \`-o' together. If you
2264     repeat this compilation, it may succeed, by chance, but you had better
2265     avoid parallel builds (make -j) in this platform, or get a better
2266     compiler."
2267    
2268 michael 945 $opt_dry_run || $RM $removelist
2269 michael 912 exit $EXIT_FAILURE
2270     fi
2271    
2272     # Just move the object if needed
2273     if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2274 michael 945 func_show_eval '$MV "$output_obj" "$obj"' \
2275     'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2276     fi
2277     fi
2278    
2279     $opt_dry_run || {
2280     func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2281    
2282     # Unlock the critical section if it was locked
2283     if test "$need_locks" != no; then
2284     removelist=$lockfile
2285     $RM "$lockfile"
2286     fi
2287     }
2288    
2289     exit $EXIT_SUCCESS
2290     }
2291    
2292     $opt_help || {
2293 michael 1107 test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2294 michael 945 }
2295    
2296     func_mode_help ()
2297     {
2298     # We need to display help for each of the modes.
2299 michael 1107 case $opt_mode in
2300 michael 945 "")
2301     # Generic help is extracted from the usage comments
2302     # at the start of this file.
2303     func_help
2304     ;;
2305    
2306     clean)
2307     $ECHO \
2308     "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2309    
2310     Remove files from the build directory.
2311    
2312     RM is the name of the program to use to delete files associated with each FILE
2313     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2314     to RM.
2315    
2316     If FILE is a libtool library, object or program, all the files associated
2317     with it are deleted. Otherwise, only FILE itself is deleted using RM."
2318     ;;
2319    
2320     compile)
2321     $ECHO \
2322     "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2323    
2324     Compile a source file into a libtool library object.
2325    
2326     This mode accepts the following additional options:
2327    
2328     -o OUTPUT-FILE set the output file name to OUTPUT-FILE
2329     -no-suppress do not suppress compiler output for multiple passes
2330 michael 1094 -prefer-pic try to build PIC objects only
2331     -prefer-non-pic try to build non-PIC objects only
2332 michael 945 -shared do not build a \`.o' file suitable for static linking
2333     -static only build a \`.o' file suitable for static linking
2334 michael 1094 -Wc,FLAG pass FLAG directly to the compiler
2335 michael 945
2336     COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2337     from the given SOURCEFILE.
2338    
2339     The output file name is determined by removing the directory component from
2340     SOURCEFILE, then substituting the C source code suffix \`.c' with the
2341     library object suffix, \`.lo'."
2342     ;;
2343    
2344     execute)
2345     $ECHO \
2346     "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2347    
2348     Automatically set library path, then run a program.
2349    
2350     This mode accepts the following additional options:
2351    
2352     -dlopen FILE add the directory containing FILE to the library path
2353    
2354     This mode sets the library path environment variable according to \`-dlopen'
2355     flags.
2356    
2357     If any of the ARGS are libtool executable wrappers, then they are translated
2358     into their corresponding uninstalled binary, and any of their required library
2359     directories are added to the library path.
2360    
2361     Then, COMMAND is executed, with ARGS as arguments."
2362     ;;
2363    
2364     finish)
2365     $ECHO \
2366     "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2367    
2368     Complete the installation of libtool libraries.
2369    
2370     Each LIBDIR is a directory that contains libtool libraries.
2371    
2372     The commands that this mode executes may require superuser privileges. Use
2373     the \`--dry-run' option if you just want to see what would be executed."
2374     ;;
2375    
2376     install)
2377     $ECHO \
2378     "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2379    
2380     Install executables or libraries.
2381    
2382     INSTALL-COMMAND is the installation command. The first component should be
2383     either the \`install' or \`cp' program.
2384    
2385     The following components of INSTALL-COMMAND are treated specially:
2386    
2387 michael 1094 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2388 michael 945
2389     The rest of the components are interpreted as arguments to that command (only
2390     BSD-compatible install options are recognized)."
2391     ;;
2392    
2393     link)
2394     $ECHO \
2395     "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2396    
2397     Link object files or libraries together to form another library, or to
2398     create an executable program.
2399    
2400     LINK-COMMAND is a command using the C compiler that you would use to create
2401     a program from several object files.
2402    
2403     The following components of LINK-COMMAND are treated specially:
2404    
2405     -all-static do not do any dynamic linking at all
2406     -avoid-version do not add a version suffix if possible
2407 michael 1094 -bindir BINDIR specify path to binaries directory (for systems where
2408     libraries must be found in the PATH setting at runtime)
2409 michael 945 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2410     -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2411     -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2412     -export-symbols SYMFILE
2413     try to export only the symbols listed in SYMFILE
2414     -export-symbols-regex REGEX
2415     try to export only the symbols matching REGEX
2416     -LLIBDIR search LIBDIR for required installed libraries
2417     -lNAME OUTPUT-FILE requires the installed library libNAME
2418     -module build a library that can dlopened
2419     -no-fast-install disable the fast-install mode
2420     -no-install link a not-installable executable
2421     -no-undefined declare that a library does not refer to external symbols
2422     -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2423     -objectlist FILE Use a list of object files found in FILE to specify objects
2424     -precious-files-regex REGEX
2425     don't remove output files matching REGEX
2426     -release RELEASE specify package release information
2427     -rpath LIBDIR the created library will eventually be installed in LIBDIR
2428     -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2429     -shared only do dynamic linking of libtool libraries
2430     -shrext SUFFIX override the standard shared library file extension
2431     -static do not do any dynamic linking of uninstalled libtool libraries
2432     -static-libtool-libs
2433     do not do any dynamic linking of libtool libraries
2434     -version-info CURRENT[:REVISION[:AGE]]
2435     specify library version info [each variable defaults to 0]
2436     -weak LIBNAME declare that the target provides the LIBNAME interface
2437 michael 1094 -Wc,FLAG
2438     -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2439     -Wl,FLAG
2440     -Xlinker FLAG pass linker-specific FLAG directly to the linker
2441     -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2442 michael 945
2443     All other options (arguments beginning with \`-') are ignored.
2444    
2445     Every other argument is treated as a filename. Files ending in \`.la' are
2446     treated as uninstalled libtool libraries, other files are standard or library
2447     object files.
2448    
2449     If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2450     only library objects (\`.lo' files) may be specified, and \`-rpath' is
2451     required, except when creating a convenience library.
2452    
2453     If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2454     using \`ar' and \`ranlib', or on Windows using \`lib'.
2455    
2456     If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2457     is created, otherwise an executable program is created."
2458     ;;
2459    
2460     uninstall)
2461     $ECHO \
2462     "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2463    
2464     Remove libraries from an installation directory.
2465    
2466     RM is the name of the program to use to delete files associated with each FILE
2467     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2468     to RM.
2469    
2470     If FILE is a libtool library, all the files associated with it are deleted.
2471     Otherwise, only FILE itself is deleted using RM."
2472     ;;
2473    
2474     *)
2475 michael 1107 func_fatal_help "invalid operation mode \`$opt_mode'"
2476 michael 945 ;;
2477     esac
2478    
2479 michael 1094 echo
2480 michael 945 $ECHO "Try \`$progname --help' for more information about other modes."
2481     }
2482    
2483 michael 1094 # Now that we've collected a possible --mode arg, show help if necessary
2484     if $opt_help; then
2485     if test "$opt_help" = :; then
2486     func_mode_help
2487     else
2488     {
2489     func_help noexit
2490 michael 1107 for opt_mode in compile link execute install finish uninstall clean; do
2491 michael 1094 func_mode_help
2492     done
2493     } | sed -n '1p; 2,$s/^Usage:/ or: /p'
2494     {
2495     func_help noexit
2496 michael 1107 for opt_mode in compile link execute install finish uninstall clean; do
2497 michael 1094 echo
2498     func_mode_help
2499     done
2500     } |
2501     sed '1d
2502     /^When reporting/,/^Report/{
2503     H
2504     d
2505     }
2506     $x
2507     /information about other modes/d
2508     /more detailed .*MODE/d
2509     s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2510     fi
2511     exit $?
2512     fi
2513 michael 945
2514    
2515     # func_mode_execute arg...
2516     func_mode_execute ()
2517     {
2518     $opt_debug
2519     # The first argument is the command name.
2520     cmd="$nonopt"
2521     test -z "$cmd" && \
2522     func_fatal_help "you must specify a COMMAND"
2523    
2524     # Handle -dlopen flags immediately.
2525 michael 1107 for file in $opt_dlopen; do
2526 michael 945 test -f "$file" \
2527     || func_fatal_help "\`$file' is not a file"
2528    
2529     dir=
2530     case $file in
2531     *.la)
2532 michael 1107 func_resolve_sysroot "$file"
2533     file=$func_resolve_sysroot_result
2534    
2535 michael 945 # Check to see that this really is a libtool archive.
2536     func_lalib_unsafe_p "$file" \
2537     || func_fatal_help "\`$lib' is not a valid libtool archive"
2538    
2539     # Read the libtool library.
2540     dlname=
2541     library_names=
2542     func_source "$file"
2543    
2544     # Skip this library if it cannot be dlopened.
2545     if test -z "$dlname"; then
2546     # Warn if it was a shared library.
2547     test -n "$library_names" && \
2548     func_warning "\`$file' was not linked with \`-export-dynamic'"
2549     continue
2550     fi
2551    
2552     func_dirname "$file" "" "."
2553     dir="$func_dirname_result"
2554    
2555     if test -f "$dir/$objdir/$dlname"; then
2556 michael 1107 func_append dir "/$objdir"
2557 michael 912 else
2558 michael 945 if test ! -f "$dir/$dlname"; then
2559     func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2560     fi
2561 michael 912 fi
2562 michael 945 ;;
2563    
2564     *.lo)
2565     # Just add the directory containing the .lo file.
2566     func_dirname "$file" "" "."
2567     dir="$func_dirname_result"
2568     ;;
2569    
2570     *)
2571     func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2572     continue
2573     ;;
2574     esac
2575    
2576     # Get the absolute pathname.
2577     absdir=`cd "$dir" && pwd`
2578     test -n "$absdir" && dir="$absdir"
2579    
2580     # Now add the directory to shlibpath_var.
2581     if eval "test -z \"\$$shlibpath_var\""; then
2582     eval "$shlibpath_var=\"\$dir\""
2583     else
2584     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2585 michael 912 fi
2586 michael 945 done
2587 michael 912
2588 michael 945 # This variable tells wrapper scripts just to set shlibpath_var
2589     # rather than running their programs.
2590     libtool_execute_magic="$magic"
2591 michael 912
2592 michael 945 # Check if any of the arguments is a wrapper script.
2593     args=
2594     for file
2595     do
2596     case $file in
2597 michael 1094 -* | *.la | *.lo ) ;;
2598 michael 945 *)
2599     # Do a test to see if this is really a libtool program.
2600     if func_ltwrapper_script_p "$file"; then
2601     func_source "$file"
2602     # Transform arg to wrapped name.
2603     file="$progdir/$program"
2604     elif func_ltwrapper_executable_p "$file"; then
2605     func_ltwrapper_scriptname "$file"
2606     func_source "$func_ltwrapper_scriptname_result"
2607     # Transform arg to wrapped name.
2608     file="$progdir/$program"
2609     fi
2610     ;;
2611     esac
2612     # Quote arguments (to preserve shell metacharacters).
2613 michael 1107 func_append_quoted args "$file"
2614 michael 945 done
2615    
2616     if test "X$opt_dry_run" = Xfalse; then
2617     if test -n "$shlibpath_var"; then
2618     # Export the shlibpath_var.
2619     eval "export $shlibpath_var"
2620     fi
2621    
2622     # Restore saved environment variables
2623     for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2624     do
2625     eval "if test \"\${save_$lt_var+set}\" = set; then
2626     $lt_var=\$save_$lt_var; export $lt_var
2627     else
2628     $lt_unset $lt_var
2629     fi"
2630     done
2631    
2632     # Now prepare to actually exec the command.
2633     exec_cmd="\$cmd$args"
2634 michael 912 else
2635 michael 945 # Display what would be done.
2636     if test -n "$shlibpath_var"; then
2637     eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2638 michael 1094 echo "export $shlibpath_var"
2639 michael 945 fi
2640     $ECHO "$cmd$args"
2641     exit $EXIT_SUCCESS
2642     fi
2643     }
2644 michael 912
2645 michael 1107 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2646 michael 945
2647    
2648     # func_mode_finish arg...
2649     func_mode_finish ()
2650     {
2651     $opt_debug
2652 michael 1107 libs=
2653     libdirs=
2654 michael 945 admincmds=
2655    
2656 michael 1107 for opt in "$nonopt" ${1+"$@"}
2657     do
2658     if test -d "$opt"; then
2659     func_append libdirs " $opt"
2660    
2661     elif test -f "$opt"; then
2662     if func_lalib_unsafe_p "$opt"; then
2663     func_append libs " $opt"
2664     else
2665     func_warning "\`$opt' is not a valid libtool archive"
2666     fi
2667    
2668     else
2669     func_fatal_error "invalid argument \`$opt'"
2670     fi
2671     done
2672    
2673     if test -n "$libs"; then
2674     if test -n "$lt_sysroot"; then
2675     sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2676     sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2677     else
2678     sysroot_cmd=
2679     fi
2680    
2681     # Remove sysroot references
2682     if $opt_dry_run; then
2683     for lib in $libs; do
2684     echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2685     done
2686     else
2687     tmpdir=`func_mktempdir`
2688     for lib in $libs; do
2689     sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2690     > $tmpdir/tmp-la
2691     mv -f $tmpdir/tmp-la $lib
2692     done
2693     ${RM}r "$tmpdir"
2694     fi
2695     fi
2696    
2697 michael 945 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2698     for libdir in $libdirs; do
2699     if test -n "$finish_cmds"; then
2700     # Do each command in the finish commands.
2701     func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2702     '"$cmd"'"'
2703     fi
2704     if test -n "$finish_eval"; then
2705     # Do the single finish_eval.
2706     eval cmds=\"$finish_eval\"
2707 michael 1107 $opt_dry_run || eval "$cmds" || func_append admincmds "
2708 michael 945 $cmds"
2709     fi
2710     done
2711 michael 912 fi
2712    
2713 michael 945 # Exit here if they wanted silent mode.
2714     $opt_silent && exit $EXIT_SUCCESS
2715 michael 912
2716 michael 1107 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2717     echo "----------------------------------------------------------------------"
2718     echo "Libraries have been installed in:"
2719     for libdir in $libdirs; do
2720     $ECHO " $libdir"
2721     done
2722     echo
2723     echo "If you ever happen to want to link against installed libraries"
2724     echo "in a given directory, LIBDIR, you must either use libtool, and"
2725     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2726     echo "flag during linking and do at least one of the following:"
2727     if test -n "$shlibpath_var"; then
2728     echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2729     echo " during execution"
2730     fi
2731     if test -n "$runpath_var"; then
2732     echo " - add LIBDIR to the \`$runpath_var' environment variable"
2733     echo " during linking"
2734     fi
2735     if test -n "$hardcode_libdir_flag_spec"; then
2736     libdir=LIBDIR
2737     eval flag=\"$hardcode_libdir_flag_spec\"
2738 michael 912
2739 michael 1107 $ECHO " - use the \`$flag' linker flag"
2740     fi
2741     if test -n "$admincmds"; then
2742     $ECHO " - have your system administrator run these commands:$admincmds"
2743     fi
2744     if test -f /etc/ld.so.conf; then
2745     echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2746     fi
2747     echo
2748    
2749     echo "See any operating system documentation about shared libraries for"
2750     case $host in
2751     solaris2.[6789]|solaris2.1[0-9])
2752     echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2753     echo "pages."
2754     ;;
2755     *)
2756     echo "more information, such as the ld(1) and ld.so(8) manual pages."
2757     ;;
2758     esac
2759     echo "----------------------------------------------------------------------"
2760 michael 945 fi
2761 michael 912 exit $EXIT_SUCCESS
2762 michael 945 }
2763    
2764 michael 1107 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2765 michael 945
2766    
2767     # func_mode_install arg...
2768     func_mode_install ()
2769     {
2770     $opt_debug
2771     # There may be an optional sh(1) argument at the beginning of
2772     # install_prog (especially on Windows NT).
2773     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2774     # Allow the use of GNU shtool's install command.
2775 michael 1094 case $nonopt in *shtool*) :;; *) false;; esac; then
2776 michael 945 # Aesthetically quote it.
2777     func_quote_for_eval "$nonopt"
2778     install_prog="$func_quote_for_eval_result "
2779     arg=$1
2780     shift
2781     else
2782     install_prog=
2783     arg=$nonopt
2784     fi
2785    
2786     # The real first argument should be the name of the installation program.
2787     # Aesthetically quote it.
2788     func_quote_for_eval "$arg"
2789 michael 1107 func_append install_prog "$func_quote_for_eval_result"
2790 michael 1094 install_shared_prog=$install_prog
2791     case " $install_prog " in
2792     *[\\\ /]cp\ *) install_cp=: ;;
2793     *) install_cp=false ;;
2794     esac
2795 michael 945
2796     # We need to accept at least all the BSD install flags.
2797     dest=
2798     files=
2799     opts=
2800     prev=
2801     install_type=
2802     isdir=no
2803     stripme=
2804 michael 1094 no_mode=:
2805 michael 945 for arg
2806     do
2807 michael 1094 arg2=
2808 michael 945 if test -n "$dest"; then
2809 michael 1107 func_append files " $dest"
2810 michael 945 dest=$arg
2811     continue
2812     fi
2813    
2814     case $arg in
2815     -d) isdir=yes ;;
2816     -f)
2817 michael 1094 if $install_cp; then :; else
2818     prev=$arg
2819     fi
2820 michael 945 ;;
2821     -g | -m | -o)
2822     prev=$arg
2823     ;;
2824     -s)
2825     stripme=" -s"
2826     continue
2827     ;;
2828     -*)
2829     ;;
2830     *)
2831     # If the previous option needed an argument, then skip it.
2832     if test -n "$prev"; then
2833 michael 1094 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2834     arg2=$install_override_mode
2835     no_mode=false
2836     fi
2837 michael 945 prev=
2838     else
2839     dest=$arg
2840     continue
2841     fi
2842     ;;
2843     esac
2844    
2845     # Aesthetically quote the argument.
2846     func_quote_for_eval "$arg"
2847 michael 1107 func_append install_prog " $func_quote_for_eval_result"
2848 michael 1094 if test -n "$arg2"; then
2849     func_quote_for_eval "$arg2"
2850     fi
2851 michael 1107 func_append install_shared_prog " $func_quote_for_eval_result"
2852 michael 945 done
2853    
2854     test -z "$install_prog" && \
2855     func_fatal_help "you must specify an install program"
2856    
2857     test -n "$prev" && \
2858     func_fatal_help "the \`$prev' option requires an argument"
2859    
2860 michael 1094 if test -n "$install_override_mode" && $no_mode; then
2861     if $install_cp; then :; else
2862     func_quote_for_eval "$install_override_mode"
2863 michael 1107 func_append install_shared_prog " -m $func_quote_for_eval_result"
2864 michael 1094 fi
2865     fi
2866    
2867 michael 945 if test -z "$files"; then
2868     if test -z "$dest"; then
2869     func_fatal_help "no file or destination specified"
2870     else
2871     func_fatal_help "you must specify a destination"
2872     fi
2873     fi
2874    
2875     # Strip any trailing slash from the destination.
2876     func_stripname '' '/' "$dest"
2877     dest=$func_stripname_result
2878    
2879     # Check to see that the destination is a directory.
2880     test -d "$dest" && isdir=yes
2881     if test "$isdir" = yes; then
2882     destdir="$dest"
2883     destname=
2884     else
2885     func_dirname_and_basename "$dest" "" "."
2886     destdir="$func_dirname_result"
2887     destname="$func_basename_result"
2888    
2889     # Not a directory, so check to see that there is only one file specified.
2890     set dummy $files; shift
2891     test "$#" -gt 1 && \
2892     func_fatal_help "\`$dest' is not a directory"
2893     fi
2894     case $destdir in
2895     [\\/]* | [A-Za-z]:[\\/]*) ;;
2896     *)
2897     for file in $files; do
2898     case $file in
2899     *.lo) ;;
2900     *)
2901     func_fatal_help "\`$destdir' must be an absolute directory name"
2902     ;;
2903     esac
2904     done
2905     ;;
2906     esac
2907    
2908     # This variable tells wrapper scripts just to set variables rather
2909     # than running their programs.
2910     libtool_install_magic="$magic"
2911    
2912     staticlibs=
2913     future_libdirs=
2914     current_libdirs=
2915     for file in $files; do
2916    
2917     # Do each installation.
2918     case $file in
2919     *.$libext)
2920     # Do the static libraries later.
2921 michael 1107 func_append staticlibs " $file"
2922 michael 945 ;;
2923    
2924     *.la)
2925 michael 1107 func_resolve_sysroot "$file"
2926     file=$func_resolve_sysroot_result
2927    
2928 michael 945 # Check to see that this really is a libtool archive.
2929     func_lalib_unsafe_p "$file" \
2930     || func_fatal_help "\`$file' is not a valid libtool archive"
2931    
2932     library_names=
2933     old_library=
2934     relink_command=
2935     func_source "$file"
2936    
2937     # Add the libdir to current_libdirs if it is the destination.
2938     if test "X$destdir" = "X$libdir"; then
2939     case "$current_libdirs " in
2940     *" $libdir "*) ;;
2941 michael 1107 *) func_append current_libdirs " $libdir" ;;
2942 michael 945 esac
2943     else
2944     # Note the libdir as a future libdir.
2945     case "$future_libdirs " in
2946     *" $libdir "*) ;;
2947 michael 1107 *) func_append future_libdirs " $libdir" ;;
2948 michael 945 esac
2949     fi
2950    
2951     func_dirname "$file" "/" ""
2952     dir="$func_dirname_result"
2953 michael 1107 func_append dir "$objdir"
2954 michael 945
2955     if test -n "$relink_command"