/[svn]/ircd-hybrid-7.3/libltdl/config/ltmain.sh
ViewVC logotype

Annotation of /ircd-hybrid-7.3/libltdl/config/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1084 - (hide annotations)
Sat Mar 13 23:24:10 2010 UTC (11 years, 7 months ago) by michael
File MIME type: application/x-shellscript
File size: 243248 byte(s)
- libtoolize

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