ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-8/ltmain.sh
Revision: 1029
Committed: Sun Nov 8 13:10:50 2009 UTC (14 years, 4 months ago) by michael
Content type: text/x-sh
Original Path: ircd-hybrid-7.3/ltmain.sh
File size: 243942 byte(s)
Log Message:
- branch off trunk to create 7.3 branch

File Contents

# User Rev Content
1 michael 945 # Generated from ltmain.m4sh.
2    
3     # ltmain.sh (GNU libtool) 2.2.6
4     # 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 michael 912 # it under the terms of the GNU General Public License as published by
12     # the Free Software Foundation; either version 2 of the License, or
13     # (at your option) any later version.
14     #
15 michael 945 # As a special exception to the GNU General Public License,
16     # if you distribute this file as part of a program or library that
17     # is built using GNU Libtool, you may include this file under the
18     # same distribution terms that you use for the rest of that program.
19     #
20     # GNU Libtool is distributed in the hope that it will be useful, but
21 michael 912 # WITHOUT ANY WARRANTY; without even the implied warranty of
22     # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23     # General Public License for more details.
24     #
25     # You should have received a copy of the GNU General Public License
26 michael 945 # along with GNU Libtool; see the file COPYING. If not, a copy
27     # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28     # or obtained by writing to the Free Software Foundation, Inc.,
29     # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30    
31     # Usage: $progname [OPTION]... [MODE-ARG]...
32 michael 912 #
33 michael 945 # Provide generalized library-building support services.
34     #
35     # --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     # $progname: (GNU libtool) 2.2.6
69     # automake: $automake_version
70     # autoconf: $autoconf_version
71     #
72     # Report bugs to <bug-libtool@gnu.org>.
73 michael 912
74     PROGRAM=ltmain.sh
75     PACKAGE=libtool
76 michael 945 VERSION=2.2.6
77     TIMESTAMP=""
78     package_revision=1.3012
79 michael 912
80 michael 945 # define SED for historic ltconfig's generated by Libtool 1.3
81     test -z "$SED" && SED=sed
82    
83     # Be Bourne compatible
84 michael 912 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
85     emulate sh
86     NULLCMD=:
87     # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
88     # is contrary to our usage. Disable this feature.
89     alias -g '${1+"$@"}'='"$@"'
90     setopt NO_GLOB_SUBST
91     else
92     case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
93     fi
94     BIN_SH=xpg4; export BIN_SH # for Tru64
95     DUALCASE=1; export DUALCASE # for MKS sh
96    
97 michael 945 # NLS nuisances: We save the old values to restore during execute mode.
98 michael 912 # Only set LANG and LC_ALL to C if already set.
99     # These must not be set unconditionally because not all systems understand
100     # e.g. LANG=C (notably SCO).
101 michael 945 lt_user_locale=
102     lt_safe_locale=
103     for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
104 michael 912 do
105     eval "if test \"\${$lt_var+set}\" = set; then
106 michael 945 save_$lt_var=\$$lt_var
107     $lt_var=C
108 michael 912 export $lt_var
109 michael 945 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
110     lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
111 michael 912 fi"
112     done
113    
114 michael 945 $lt_unset CDPATH
115    
116    
117    
118    
119    
120     : ${CP="cp -f"}
121     : ${ECHO="echo"}
122     : ${EGREP="/bin/grep -E"}
123     : ${FGREP="/bin/grep -F"}
124     : ${GREP="/bin/grep"}
125     : ${LN_S="ln -s"}
126     : ${MAKE="make"}
127     : ${MKDIR="mkdir"}
128     : ${MV="mv -f"}
129     : ${RM="rm -f"}
130     : ${SED="/bin/sed"}
131     : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
132     : ${Xsed="$SED -e 1s/^X//"}
133    
134     # Global variables:
135     EXIT_SUCCESS=0
136     EXIT_FAILURE=1
137     EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
138     EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
139    
140     exit_status=$EXIT_SUCCESS
141    
142 michael 912 # Make sure IFS has a sensible default
143     lt_nl='
144     '
145     IFS=" $lt_nl"
146    
147 michael 945 dirname="s,/[^/]*$,,"
148     basename="s,^.*/,,"
149 michael 912
150 michael 945 # func_dirname_and_basename file append nondir_replacement
151     # perform func_basename and func_dirname in a single function
152     # call:
153     # dirname: Compute the dirname of FILE. If nonempty,
154     # add APPEND to the result, otherwise set result
155     # to NONDIR_REPLACEMENT.
156     # value returned in "$func_dirname_result"
157     # basename: Compute filename of FILE.
158     # value retuned in "$func_basename_result"
159     # Implementation must be kept synchronized with func_dirname
160     # and func_basename. For efficiency, we do not delegate to
161     # those functions but instead duplicate the functionality here.
162     func_dirname_and_basename ()
163     {
164     # Extract subdirectory from the argument.
165     func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
166     if test "X$func_dirname_result" = "X${1}"; then
167     func_dirname_result="${3}"
168     else
169     func_dirname_result="$func_dirname_result${2}"
170     fi
171     func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
172     }
173 michael 912
174 michael 945 # Generated shell functions inserted here.
175 michael 912
176 michael 945 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
177     # is ksh but when the shell is invoked as "sh" and the current value of
178     # the _XPG environment variable is not equal to 1 (one), the special
179     # positional parameter $0, within a function call, is the name of the
180     # function.
181     progpath="$0"
182    
183     # The name of this program:
184     # In the unlikely event $progname began with a '-', it would play havoc with
185     # func_echo (imagine progname=-n), so we prepend ./ in that case:
186     func_dirname_and_basename "$progpath"
187     progname=$func_basename_result
188     case $progname in
189     -*) progname=./$progname ;;
190     esac
191    
192     # Make sure we have an absolute path for reexecution:
193     case $progpath in
194     [\\/]*|[A-Za-z]:\\*) ;;
195     *[\\/]*)
196     progdir=$func_dirname_result
197     progdir=`cd "$progdir" && pwd`
198     progpath="$progdir/$progname"
199     ;;
200     *)
201     save_IFS="$IFS"
202     IFS=:
203     for progdir in $PATH; do
204     IFS="$save_IFS"
205     test -x "$progdir/$progname" && break
206     done
207     IFS="$save_IFS"
208     test -n "$progdir" || progdir=`pwd`
209     progpath="$progdir/$progname"
210     ;;
211     esac
212    
213     # Sed substitution that helps us do robust quoting. It backslashifies
214     # metacharacters that are still active within double-quoted strings.
215     Xsed="${SED}"' -e 1s/^X//'
216     sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
217    
218     # Same as above, but do not quote variable references.
219     double_quote_subst='s/\(["`\\]\)/\\\1/g'
220    
221     # Re-`\' parameter expansions in output of double_quote_subst that were
222     # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
223     # in input to double_quote_subst, that '$' was protected from expansion.
224     # Since each input `\' is now two `\'s, look for any number of runs of
225     # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
226     bs='\\'
227     bs2='\\\\'
228     bs4='\\\\\\\\'
229     dollar='\$'
230     sed_double_backslash="\
231     s/$bs4/&\\
232     /g
233     s/^$bs2$dollar/$bs&/
234     s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
235     s/\n//g"
236    
237     # Standard options:
238     opt_dry_run=false
239     opt_help=false
240     opt_quiet=false
241     opt_verbose=false
242     opt_warning=:
243    
244     # func_echo arg...
245     # Echo program name prefixed message, along with the current mode
246     # name if it has been set yet.
247     func_echo ()
248     {
249     $ECHO "$progname${mode+: }$mode: $*"
250     }
251    
252     # func_verbose arg...
253     # Echo program name prefixed message in verbose mode only.
254     func_verbose ()
255     {
256     $opt_verbose && func_echo ${1+"$@"}
257    
258     # A bug in bash halts the script if the last line of a function
259     # fails when set -e is in force, so we need another command to
260     # work around that:
261     :
262     }
263    
264     # func_error arg...
265     # Echo program name prefixed message to standard error.
266     func_error ()
267     {
268     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
269     }
270    
271     # func_warning arg...
272     # Echo program name prefixed warning message to standard error.
273     func_warning ()
274     {
275     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
276    
277     # bash bug again:
278     :
279     }
280    
281     # func_fatal_error arg...
282     # Echo program name prefixed message to standard error, and exit.
283     func_fatal_error ()
284     {
285     func_error ${1+"$@"}
286     exit $EXIT_FAILURE
287     }
288    
289     # func_fatal_help arg...
290     # Echo program name prefixed message to standard error, followed by
291     # a help hint, and exit.
292     func_fatal_help ()
293     {
294     func_error ${1+"$@"}
295     func_fatal_error "$help"
296     }
297     help="Try \`$progname --help' for more information." ## default
298    
299    
300     # func_grep expression filename
301     # Check whether EXPRESSION matches any line of FILENAME, without output.
302     func_grep ()
303     {
304     $GREP "$1" "$2" >/dev/null 2>&1
305     }
306    
307    
308     # func_mkdir_p directory-path
309     # Make sure the entire path to DIRECTORY-PATH is available.
310     func_mkdir_p ()
311     {
312     my_directory_path="$1"
313     my_dir_list=
314    
315     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
316    
317     # Protect directory names starting with `-'
318     case $my_directory_path in
319     -*) my_directory_path="./$my_directory_path" ;;
320     esac
321    
322     # While some portion of DIR does not yet exist...
323     while test ! -d "$my_directory_path"; do
324     # ...make a list in topmost first order. Use a colon delimited
325     # list incase some portion of path contains whitespace.
326     my_dir_list="$my_directory_path:$my_dir_list"
327    
328     # If the last portion added has no slash in it, the list is done
329     case $my_directory_path in */*) ;; *) break ;; esac
330    
331     # ...otherwise throw away the child directory and loop
332     my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
333     done
334     my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
335    
336     save_mkdir_p_IFS="$IFS"; IFS=':'
337     for my_dir in $my_dir_list; do
338     IFS="$save_mkdir_p_IFS"
339     # mkdir can fail with a `File exist' error if two processes
340     # try to create one of the directories concurrently. Don't
341     # stop in that case!
342     $MKDIR "$my_dir" 2>/dev/null || :
343     done
344     IFS="$save_mkdir_p_IFS"
345    
346     # Bail out if we (or some other process) failed to create a directory.
347     test -d "$my_directory_path" || \
348     func_fatal_error "Failed to create \`$1'"
349     fi
350     }
351    
352    
353 michael 912 # func_mktempdir [string]
354     # Make a temporary directory that won't clash with other running
355     # libtool processes, and avoids race conditions if possible. If
356     # given, STRING is the basename for that directory.
357     func_mktempdir ()
358     {
359     my_template="${TMPDIR-/tmp}/${1-$progname}"
360    
361 michael 945 if test "$opt_dry_run" = ":"; then
362 michael 912 # Return a directory name, but don't create it in dry-run mode
363     my_tmpdir="${my_template}-$$"
364     else
365    
366     # If mktemp works, use that first and foremost
367     my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
368    
369     if test ! -d "$my_tmpdir"; then
370 michael 945 # Failing that, at least try and use $RANDOM to avoid a race
371     my_tmpdir="${my_template}-${RANDOM-0}$$"
372 michael 912
373 michael 945 save_mktempdir_umask=`umask`
374     umask 0077
375     $MKDIR "$my_tmpdir"
376     umask $save_mktempdir_umask
377 michael 912 fi
378    
379     # If we're not in dry-run mode, bomb out on failure
380 michael 945 test -d "$my_tmpdir" || \
381     func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
382 michael 912 fi
383    
384 michael 945 $ECHO "X$my_tmpdir" | $Xsed
385 michael 912 }
386    
387    
388 michael 945 # func_quote_for_eval arg
389     # Aesthetically quote ARG to be evaled later.
390     # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
391     # is double-quoted, suitable for a subsequent eval, whereas
392     # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
393     # which are still active within double quotes backslashified.
394     func_quote_for_eval ()
395 michael 912 {
396 michael 945 case $1 in
397     *[\\\`\"\$]*)
398     func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
399     *)
400     func_quote_for_eval_unquoted_result="$1" ;;
401 michael 912 esac
402 michael 945
403     case $func_quote_for_eval_unquoted_result in
404     # Double-quote args containing shell metacharacters to delay
405     # word splitting, command substitution and and variable
406     # expansion for a subsequent eval.
407     # Many Bourne shells cannot handle close brackets correctly
408     # in scan sets, so we specify it separately.
409     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
410     func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
411     ;;
412     *)
413     func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
414     esac
415 michael 912 }
416    
417    
418 michael 945 # func_quote_for_expand arg
419     # Aesthetically quote ARG to be evaled later; same as above,
420     # but do not quote variable references.
421     func_quote_for_expand ()
422 michael 912 {
423 michael 945 case $1 in
424     *[\\\`\"]*)
425     my_arg=`$ECHO "X$1" | $Xsed \
426     -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
427 michael 912 *)
428 michael 945 my_arg="$1" ;;
429     esac
430    
431     case $my_arg in
432     # Double-quote args containing shell metacharacters to delay
433     # word splitting and command substitution for a subsequent eval.
434     # Many Bourne shells cannot handle close brackets correctly
435     # in scan sets, so we specify it separately.
436     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
437     my_arg="\"$my_arg\""
438     ;;
439     esac
440    
441     func_quote_for_expand_result="$my_arg"
442 michael 912 }
443    
444    
445 michael 945 # func_show_eval cmd [fail_exp]
446     # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
447     # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
448     # is given, then evaluate it.
449     func_show_eval ()
450 michael 912 {
451 michael 945 my_cmd="$1"
452     my_fail_exp="${2-:}"
453 michael 912
454 michael 945 ${opt_silent-false} || {
455     func_quote_for_expand "$my_cmd"
456     eval "func_echo $func_quote_for_expand_result"
457     }
458    
459     if ${opt_dry_run-false}; then :; else
460     eval "$my_cmd"
461     my_status=$?
462     if test "$my_status" -eq 0; then :; else
463     eval "(exit $my_status); $my_fail_exp"
464     fi
465 michael 912 fi
466     }
467    
468 michael 945
469     # func_show_eval_locale cmd [fail_exp]
470     # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
471     # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
472     # is given, then evaluate it. Use the saved locale for evaluation.
473     func_show_eval_locale ()
474 michael 912 {
475 michael 945 my_cmd="$1"
476     my_fail_exp="${2-:}"
477 michael 912
478 michael 945 ${opt_silent-false} || {
479     func_quote_for_expand "$my_cmd"
480     eval "func_echo $func_quote_for_expand_result"
481     }
482    
483     if ${opt_dry_run-false}; then :; else
484     eval "$lt_user_locale
485     $my_cmd"
486     my_status=$?
487     eval "$lt_safe_locale"
488     if test "$my_status" -eq 0; then :; else
489     eval "(exit $my_status); $my_fail_exp"
490     fi
491 michael 912 fi
492 michael 945 }
493 michael 912
494    
495 michael 945
496    
497    
498     # func_version
499     # Echo version message to standard output and exit.
500     func_version ()
501     {
502     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
503     s/^# //
504     s/^# *$//
505     s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
506     p
507     }' < "$progpath"
508     exit $?
509 michael 912 }
510    
511 michael 945 # func_usage
512     # Echo short help message to standard output and exit.
513     func_usage ()
514     {
515     $SED -n '/^# Usage:/,/# -h/ {
516     s/^# //
517     s/^# *$//
518     s/\$progname/'$progname'/
519     p
520     }' < "$progpath"
521     $ECHO
522     $ECHO "run \`$progname --help | more' for full usage"
523     exit $?
524     }
525 michael 912
526 michael 945 # func_help
527     # Echo long help message to standard output and exit.
528     func_help ()
529     {
530     $SED -n '/^# Usage:/,/# Report bugs to/ {
531     s/^# //
532     s/^# *$//
533     s*\$progname*'$progname'*
534     s*\$host*'"$host"'*
535     s*\$SHELL*'"$SHELL"'*
536     s*\$LTCC*'"$LTCC"'*
537     s*\$LTCFLAGS*'"$LTCFLAGS"'*
538     s*\$LD*'"$LD"'*
539     s/\$with_gnu_ld/'"$with_gnu_ld"'/
540     s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
541     s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
542     p
543     }' < "$progpath"
544     exit $?
545     }
546 michael 912
547 michael 945 # func_missing_arg argname
548     # Echo program name prefixed message to standard error and set global
549     # exit_cmd.
550     func_missing_arg ()
551     {
552     func_error "missing argument for $1"
553     exit_cmd=exit
554     }
555    
556     exit_cmd=:
557    
558    
559    
560    
561    
562     # Check that we have a working $ECHO.
563     if test "X$1" = X--no-reexec; then
564     # Discard the --no-reexec flag, and continue.
565 michael 912 shift
566 michael 945 elif test "X$1" = X--fallback-echo; then
567     # Avoid inline document here, it may be left over
568     :
569     elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
570     # Yippee, $ECHO works!
571     :
572     else
573     # Restart under the correct shell, and then maybe $ECHO will work.
574     exec $SHELL "$progpath" --no-reexec ${1+"$@"}
575     fi
576 michael 912
577 michael 945 if test "X$1" = X--fallback-echo; then
578     # used as fallback echo
579     shift
580     cat <<EOF
581     $*
582     EOF
583     exit $EXIT_SUCCESS
584     fi
585 michael 912
586 michael 945 magic="%%%MAGIC variable%%%"
587     magic_exe="%%%MAGIC EXE variable%%%"
588 michael 912
589 michael 945 # Global variables.
590     # $mode is unset
591     nonopt=
592     execute_dlfiles=
593     preserve_args=
594     lo2o="s/\\.lo\$/.${objext}/"
595     o2lo="s/\\.${objext}\$/.lo/"
596     extracted_archives=
597     extracted_serial=0
598 michael 912
599 michael 945 opt_dry_run=false
600     opt_duplicate_deps=false
601     opt_silent=false
602     opt_debug=:
603 michael 912
604 michael 945 # If this variable is set in any of the actions, the command in it
605     # will be execed at the end. This prevents here-documents from being
606     # left over by shells.
607     exec_cmd=
608 michael 912
609 michael 945 # func_fatal_configuration arg...
610     # Echo program name prefixed message to standard error, followed by
611     # a configuration failure hint, and exit.
612     func_fatal_configuration ()
613     {
614     func_error ${1+"$@"}
615     func_error "See the $PACKAGE documentation for more information."
616     func_fatal_error "Fatal configuration error."
617     }
618 michael 912
619    
620 michael 945 # func_config
621     # Display the configuration for all the tags in this script.
622     func_config ()
623     {
624     re_begincf='^# ### BEGIN LIBTOOL'
625     re_endcf='^# ### END LIBTOOL'
626 michael 912
627 michael 945 # Default configuration.
628     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
629    
630 michael 912 # Now print the configurations for the tags.
631     for tagname in $taglist; do
632 michael 945 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
633 michael 912 done
634 michael 945
635 michael 912 exit $?
636 michael 945 }
637 michael 912
638 michael 945 # func_features
639     # Display the features supported by this script.
640     func_features ()
641     {
642     $ECHO "host: $host"
643 michael 912 if test "$build_libtool_libs" = yes; then
644 michael 945 $ECHO "enable shared libraries"
645 michael 912 else
646 michael 945 $ECHO "disable shared libraries"
647 michael 912 fi
648     if test "$build_old_libs" = yes; then
649 michael 945 $ECHO "enable static libraries"
650 michael 912 else
651 michael 945 $ECHO "disable static libraries"
652 michael 912 fi
653 michael 945
654 michael 912 exit $?
655 michael 945 }
656 michael 912
657 michael 945 # func_enable_tag tagname
658     # Verify that TAGNAME is valid, and either flag an error and exit, or
659     # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
660     # variable here.
661     func_enable_tag ()
662     {
663     # Global variable:
664     tagname="$1"
665 michael 912
666 michael 945 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
667     re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
668     sed_extractcf="/$re_begincf/,/$re_endcf/p"
669 michael 912
670 michael 945 # Validate tagname.
671     case $tagname in
672     *[!-_A-Za-z0-9,/]*)
673     func_fatal_error "invalid tag name: $tagname"
674     ;;
675     esac
676 michael 912
677 michael 945 # Don't test for the "default" C tag, as we know it's
678     # there but not specially marked.
679     case $tagname in
680     CC) ;;
681     *)
682     if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
683     taglist="$taglist $tagname"
684 michael 912
685 michael 945 # Evaluate the configuration. Be careful to quote the path
686     # and the sed script, to avoid splitting on whitespace, but
687     # also don't use non-portable quotes within backquotes within
688     # quotes we have to do it in 2 steps:
689     extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
690     eval "$extractedcf"
691     else
692     func_error "ignoring unknown tag $tagname"
693     fi
694     ;;
695     esac
696     }
697    
698     # Parse options once, thoroughly. This comes as soon as possible in
699     # the script to make things like `libtool --version' happen quickly.
700     {
701    
702     # Shorthand for --mode=foo, only valid as the first argument
703     case $1 in
704     clean|clea|cle|cl)
705     shift; set dummy --mode clean ${1+"$@"}; shift
706 michael 912 ;;
707 michael 945 compile|compil|compi|comp|com|co|c)
708     shift; set dummy --mode compile ${1+"$@"}; shift
709 michael 912 ;;
710 michael 945 execute|execut|execu|exec|exe|ex|e)
711     shift; set dummy --mode execute ${1+"$@"}; shift
712 michael 912 ;;
713 michael 945 finish|finis|fini|fin|fi|f)
714     shift; set dummy --mode finish ${1+"$@"}; shift
715 michael 912 ;;
716 michael 945 install|instal|insta|inst|ins|in|i)
717     shift; set dummy --mode install ${1+"$@"}; shift
718 michael 912 ;;
719 michael 945 link|lin|li|l)
720     shift; set dummy --mode link ${1+"$@"}; shift
721     ;;
722     uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
723     shift; set dummy --mode uninstall ${1+"$@"}; shift
724     ;;
725 michael 912 esac
726    
727 michael 945 # Parse non-mode specific arguments:
728     while test "$#" -gt 0; do
729     opt="$1"
730     shift
731 michael 912
732 michael 945 case $opt in
733     --config) func_config ;;
734 michael 912
735 michael 945 --debug) preserve_args="$preserve_args $opt"
736     func_echo "enabling shell trace mode"
737     opt_debug='set -x'
738     $opt_debug
739     ;;
740 michael 912
741 michael 945 -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
742     execute_dlfiles="$execute_dlfiles $1"
743     shift
744     ;;
745 michael 912
746 michael 945 --dry-run | -n) opt_dry_run=: ;;
747     --features) func_features ;;
748     --finish) mode="finish" ;;
749    
750     --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
751     case $1 in
752     # Valid mode arguments:
753     clean) ;;
754     compile) ;;
755     execute) ;;
756     finish) ;;
757     install) ;;
758     link) ;;
759     relink) ;;
760     uninstall) ;;
761    
762     # Catch anything else as an error
763     *) func_error "invalid argument for $opt"
764     exit_cmd=exit
765     break
766     ;;
767     esac
768    
769     mode="$1"
770     shift
771     ;;
772    
773     --preserve-dup-deps)
774     opt_duplicate_deps=: ;;
775    
776     --quiet|--silent) preserve_args="$preserve_args $opt"
777     opt_silent=:
778     ;;
779    
780     --verbose| -v) preserve_args="$preserve_args $opt"
781     opt_silent=false
782     ;;
783    
784     --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
785     preserve_args="$preserve_args $opt $1"
786     func_enable_tag "$1" # tagname is set here
787     shift
788     ;;
789    
790     # Separate optargs to long options:
791     -dlopen=*|--mode=*|--tag=*)
792     func_opt_split "$opt"
793     set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
794     shift
795     ;;
796    
797     -\?|-h) func_usage ;;
798     --help) opt_help=: ;;
799     --version) func_version ;;
800    
801     -*) func_fatal_help "unrecognized option \`$opt'" ;;
802    
803     *) nonopt="$opt"
804     break
805     ;;
806     esac
807     done
808    
809    
810     case $host in
811     *cygwin* | *mingw* | *pw32* | *cegcc*)
812     # don't eliminate duplications in $postdeps and $predeps
813     opt_duplicate_compiler_generated_deps=:
814 michael 912 ;;
815 michael 945 *)
816     opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
817 michael 912 ;;
818 michael 945 esac
819 michael 912
820 michael 945 # Having warned about all mis-specified options, bail out if
821     # anything was wrong.
822     $exit_cmd $EXIT_FAILURE
823     }
824    
825     # func_check_version_match
826     # Ensure that we are using m4 macros, and libtool script from the same
827     # release of libtool.
828     func_check_version_match ()
829     {
830     if test "$package_revision" != "$macro_revision"; then
831     if test "$VERSION" != "$macro_version"; then
832     if test -z "$macro_version"; then
833     cat >&2 <<_LT_EOF
834     $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
835     $progname: definition of this LT_INIT comes from an older release.
836     $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
837     $progname: and run autoconf again.
838     _LT_EOF
839     else
840     cat >&2 <<_LT_EOF
841     $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
842     $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
843     $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
844     $progname: and run autoconf again.
845     _LT_EOF
846 michael 912 fi
847 michael 945 else
848     cat >&2 <<_LT_EOF
849     $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
850     $progname: but the definition of this LT_INIT comes from revision $macro_revision.
851     $progname: You should recreate aclocal.m4 with macros from revision $package_revision
852     $progname: of $PACKAGE $VERSION and run autoconf again.
853     _LT_EOF
854     fi
855    
856     exit $EXIT_MISMATCH
857 michael 912 fi
858 michael 945 }
859 michael 912
860 michael 945
861     ## ----------- ##
862     ## Main. ##
863     ## ----------- ##
864    
865     $opt_help || {
866     # Sanity checks first:
867     func_check_version_match
868    
869     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
870     func_fatal_configuration "not configured to build any kind of library"
871     fi
872    
873     test -z "$mode" && func_fatal_error "error: you must specify a MODE."
874    
875    
876     # Darwin sucks
877     eval std_shrext=\"$shrext_cmds\"
878    
879    
880 michael 912 # Only execute mode is allowed to have -dlopen flags.
881     if test -n "$execute_dlfiles" && test "$mode" != execute; then
882 michael 945 func_error "unrecognized option \`-dlopen'"
883     $ECHO "$help" 1>&2
884 michael 912 exit $EXIT_FAILURE
885     fi
886    
887     # Change the help message to a mode-specific one.
888     generic_help="$help"
889 michael 945 help="Try \`$progname --help --mode=$mode' for more information."
890     }
891 michael 912
892 michael 945
893     # func_lalib_p file
894     # True iff FILE is a libtool `.la' library or `.lo' object file.
895     # This function is only a basic sanity check; it will hardly flush out
896     # determined imposters.
897     func_lalib_p ()
898     {
899     test -f "$1" &&
900     $SED -e 4q "$1" 2>/dev/null \
901     | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
902     }
903    
904     # func_lalib_unsafe_p file
905     # True iff FILE is a libtool `.la' library or `.lo' object file.
906     # This function implements the same check as func_lalib_p without
907     # resorting to external programs. To this end, it redirects stdin and
908     # closes it afterwards, without saving the original file descriptor.
909     # As a safety measure, use it only where a negative result would be
910     # fatal anyway. Works if `file' does not exist.
911     func_lalib_unsafe_p ()
912     {
913     lalib_p=no
914     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
915     for lalib_p_l in 1 2 3 4
916     do
917     read lalib_p_line
918     case "$lalib_p_line" in
919     \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
920     esac
921     done
922     exec 0<&5 5<&-
923     fi
924     test "$lalib_p" = yes
925     }
926    
927     # func_ltwrapper_script_p file
928     # True iff FILE is a libtool wrapper script
929     # This function is only a basic sanity check; it will hardly flush out
930     # determined imposters.
931     func_ltwrapper_script_p ()
932     {
933     func_lalib_p "$1"
934     }
935    
936     # func_ltwrapper_executable_p file
937     # True iff FILE is a libtool wrapper executable
938     # This function is only a basic sanity check; it will hardly flush out
939     # determined imposters.
940     func_ltwrapper_executable_p ()
941     {
942     func_ltwrapper_exec_suffix=
943     case $1 in
944     *.exe) ;;
945     *) func_ltwrapper_exec_suffix=.exe ;;
946     esac
947     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
948     }
949    
950     # func_ltwrapper_scriptname file
951     # Assumes file is an ltwrapper_executable
952     # uses $file to determine the appropriate filename for a
953     # temporary ltwrapper_script.
954     func_ltwrapper_scriptname ()
955     {
956     func_ltwrapper_scriptname_result=""
957     if func_ltwrapper_executable_p "$1"; then
958     func_dirname_and_basename "$1" "" "."
959     func_stripname '' '.exe' "$func_basename_result"
960     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
961     fi
962     }
963    
964     # func_ltwrapper_p file
965     # True iff FILE is a libtool wrapper script or wrapper executable
966     # This function is only a basic sanity check; it will hardly flush out
967     # determined imposters.
968     func_ltwrapper_p ()
969     {
970     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
971     }
972    
973    
974     # func_execute_cmds commands fail_cmd
975     # Execute tilde-delimited COMMANDS.
976     # If FAIL_CMD is given, eval that upon failure.
977     # FAIL_CMD may read-access the current command in variable CMD!
978     func_execute_cmds ()
979     {
980     $opt_debug
981     save_ifs=$IFS; IFS='~'
982     for cmd in $1; do
983     IFS=$save_ifs
984     eval cmd=\"$cmd\"
985     func_show_eval "$cmd" "${2-:}"
986     done
987     IFS=$save_ifs
988     }
989    
990    
991     # func_source file
992     # Source FILE, adding directory component if necessary.
993     # Note that it is not necessary on cygwin/mingw to append a dot to
994     # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
995     # behavior happens only for exec(3), not for open(2)! Also, sourcing
996     # `FILE.' does not work on cygwin managed mounts.
997     func_source ()
998     {
999     $opt_debug
1000     case $1 in
1001     */* | *\\*) . "$1" ;;
1002     *) . "./$1" ;;
1003     esac
1004     }
1005    
1006    
1007     # func_infer_tag arg
1008     # Infer tagged configuration to use if any are available and
1009     # if one wasn't chosen via the "--tag" command line option.
1010     # Only attempt this if the compiler in the base compile
1011     # command doesn't match the default compiler.
1012     # arg is usually of the form 'gcc ...'
1013     func_infer_tag ()
1014     {
1015     $opt_debug
1016     if test -n "$available_tags" && test -z "$tagname"; then
1017     CC_quoted=
1018     for arg in $CC; do
1019     func_quote_for_eval "$arg"
1020     CC_quoted="$CC_quoted $func_quote_for_eval_result"
1021     done
1022     case $@ in
1023     # Blanks in the command may have been stripped by the calling shell,
1024     # but not from the CC environment variable when configure was run.
1025     " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1026     # Blanks at the start of $base_compile will cause this to fail
1027     # if we don't check for them as well.
1028     *)
1029     for z in $available_tags; do
1030     if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1031     # Evaluate the configuration.
1032     eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1033     CC_quoted=
1034     for arg in $CC; do
1035     # Double-quote args containing other shell metacharacters.
1036     func_quote_for_eval "$arg"
1037     CC_quoted="$CC_quoted $func_quote_for_eval_result"
1038     done
1039     case "$@ " in
1040     " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1041     # The compiler in the base compile command matches
1042     # the one in the tagged configuration.
1043     # Assume this is the tagged configuration we want.
1044     tagname=$z
1045     break
1046     ;;
1047     esac
1048     fi
1049     done
1050     # If $tagname still isn't set, then no tagged configuration
1051     # was found and let the user know that the "--tag" command
1052     # line option must be used.
1053     if test -z "$tagname"; then
1054     func_echo "unable to infer tagged configuration"
1055     func_fatal_error "specify a tag with \`--tag'"
1056     # else
1057     # func_verbose "using $tagname tagged configuration"
1058     fi
1059     ;;
1060     esac
1061     fi
1062     }
1063    
1064    
1065    
1066     # func_write_libtool_object output_name pic_name nonpic_name
1067     # Create a libtool object file (analogous to a ".la" file),
1068     # but don't create it if we're doing a dry run.
1069     func_write_libtool_object ()
1070     {
1071     write_libobj=${1}
1072     if test "$build_libtool_libs" = yes; then
1073     write_lobj=\'${2}\'
1074     else
1075     write_lobj=none
1076     fi
1077    
1078     if test "$build_old_libs" = yes; then
1079     write_oldobj=\'${3}\'
1080     else
1081     write_oldobj=none
1082     fi
1083    
1084     $opt_dry_run || {
1085     cat >${write_libobj}T <<EOF
1086     # $write_libobj - a libtool object file
1087     # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1088     #
1089     # Please DO NOT delete this file!
1090     # It is necessary for linking the library.
1091    
1092     # Name of the PIC object.
1093     pic_object=$write_lobj
1094    
1095     # Name of the non-PIC object
1096     non_pic_object=$write_oldobj
1097    
1098     EOF
1099     $MV "${write_libobj}T" "${write_libobj}"
1100     }
1101     }
1102    
1103     # func_mode_compile arg...
1104     func_mode_compile ()
1105     {
1106     $opt_debug
1107 michael 912 # Get the compilation command and the source file.
1108     base_compile=
1109     srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1110     suppress_opt=yes
1111     suppress_output=
1112     arg_mode=normal
1113     libobj=
1114     later=
1115 michael 945 pie_flag=
1116 michael 912
1117     for arg
1118     do
1119     case $arg_mode in
1120     arg )
1121     # do not "continue". Instead, add this to base_compile
1122     lastarg="$arg"
1123     arg_mode=normal
1124     ;;
1125    
1126     target )
1127     libobj="$arg"
1128     arg_mode=normal
1129     continue
1130     ;;
1131    
1132     normal )
1133     # Accept any command-line options.
1134     case $arg in
1135     -o)
1136 michael 945 test -n "$libobj" && \
1137     func_fatal_error "you cannot specify \`-o' more than once"
1138 michael 912 arg_mode=target
1139     continue
1140     ;;
1141    
1142 michael 945 -pie | -fpie | -fPIE)
1143     pie_flag="$pie_flag $arg"
1144     continue
1145     ;;
1146    
1147     -shared | -static | -prefer-pic | -prefer-non-pic)
1148 michael 912 later="$later $arg"
1149     continue
1150     ;;
1151    
1152     -no-suppress)
1153     suppress_opt=no
1154     continue
1155     ;;
1156    
1157     -Xcompiler)
1158     arg_mode=arg # the next one goes into the "base_compile" arg list
1159     continue # The current "srcfile" will either be retained or
1160     ;; # replaced later. I would guess that would be a bug.
1161    
1162     -Wc,*)
1163 michael 945 func_stripname '-Wc,' '' "$arg"
1164     args=$func_stripname_result
1165 michael 912 lastarg=
1166     save_ifs="$IFS"; IFS=','
1167 michael 945 for arg in $args; do
1168 michael 912 IFS="$save_ifs"
1169 michael 945 func_quote_for_eval "$arg"
1170     lastarg="$lastarg $func_quote_for_eval_result"
1171 michael 912 done
1172     IFS="$save_ifs"
1173 michael 945 func_stripname ' ' '' "$lastarg"
1174     lastarg=$func_stripname_result
1175 michael 912
1176     # Add the arguments to base_compile.
1177     base_compile="$base_compile $lastarg"
1178     continue
1179     ;;
1180    
1181 michael 945 *)
1182 michael 912 # Accept the current argument as the source file.
1183     # The previous "srcfile" becomes the current argument.
1184     #
1185     lastarg="$srcfile"
1186     srcfile="$arg"
1187     ;;
1188     esac # case $arg
1189     ;;
1190     esac # case $arg_mode
1191    
1192     # Aesthetically quote the previous argument.
1193 michael 945 func_quote_for_eval "$lastarg"
1194     base_compile="$base_compile $func_quote_for_eval_result"
1195 michael 912 done # for arg
1196    
1197     case $arg_mode in
1198     arg)
1199 michael 945 func_fatal_error "you must specify an argument for -Xcompile"
1200 michael 912 ;;
1201     target)
1202 michael 945 func_fatal_error "you must specify a target with \`-o'"
1203 michael 912 ;;
1204     *)
1205     # Get the name of the library object.
1206 michael 945 test -z "$libobj" && {
1207     func_basename "$srcfile"
1208     libobj="$func_basename_result"
1209     }
1210 michael 912 ;;
1211     esac
1212    
1213     # Recognize several different file suffixes.
1214     # If the user specifies -o file.o, it is replaced with file.lo
1215     case $libobj in
1216 michael 945 *.[cCFSifmso] | \
1217     *.ada | *.adb | *.ads | *.asm | \
1218     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1219     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
1220     func_xform "$libobj"
1221     libobj=$func_xform_result
1222     ;;
1223 michael 912 esac
1224    
1225     case $libobj in
1226 michael 945 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1227 michael 912 *)
1228 michael 945 func_fatal_error "cannot determine name of library object from \`$libobj'"
1229 michael 912 ;;
1230     esac
1231    
1232     func_infer_tag $base_compile
1233    
1234     for arg in $later; do
1235     case $arg in
1236 michael 945 -shared)
1237     test "$build_libtool_libs" != yes && \
1238     func_fatal_configuration "can not build a shared library"
1239     build_old_libs=no
1240     continue
1241     ;;
1242    
1243 michael 912 -static)
1244 michael 945 build_libtool_libs=no
1245 michael 912 build_old_libs=yes
1246     continue
1247     ;;
1248    
1249     -prefer-pic)
1250     pic_mode=yes
1251     continue
1252     ;;
1253    
1254     -prefer-non-pic)
1255     pic_mode=no
1256     continue
1257     ;;
1258     esac
1259     done
1260    
1261 michael 945 func_quote_for_eval "$libobj"
1262     test "X$libobj" != "X$func_quote_for_eval_result" \
1263     && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1264     && func_warning "libobj name \`$libobj' may not contain shell special characters."
1265     func_dirname_and_basename "$obj" "/" ""
1266     objname="$func_basename_result"
1267     xdir="$func_dirname_result"
1268 michael 912 lobj=${xdir}$objdir/$objname
1269    
1270 michael 945 test -z "$base_compile" && \
1271     func_fatal_help "you must specify a compilation command"
1272 michael 912
1273     # Delete any leftover library objects.
1274     if test "$build_old_libs" = yes; then
1275     removelist="$obj $lobj $libobj ${libobj}T"
1276     else
1277     removelist="$lobj $libobj ${libobj}T"
1278     fi
1279    
1280     # On Cygwin there's no "real" PIC flag so we must build both object types
1281     case $host_os in
1282 michael 945 cygwin* | mingw* | pw32* | os2* | cegcc*)
1283 michael 912 pic_mode=default
1284     ;;
1285     esac
1286     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1287     # non-PIC code in shared libraries is not supported
1288     pic_mode=default
1289     fi
1290    
1291     # Calculate the filename of the output object if compiler does
1292     # not support -o with -c
1293     if test "$compiler_c_o" = no; then
1294 michael 945 output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1295 michael 912 lockfile="$output_obj.lock"
1296     else
1297     output_obj=
1298     need_locks=no
1299     lockfile=
1300     fi
1301    
1302     # Lock this critical section if it is needed
1303     # We use this script file to make the link, it avoids creating a new file
1304     if test "$need_locks" = yes; then
1305 michael 945 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1306     func_echo "Waiting for $lockfile to be removed"
1307 michael 912 sleep 2
1308     done
1309     elif test "$need_locks" = warn; then
1310     if test -f "$lockfile"; then
1311 michael 945 $ECHO "\
1312 michael 912 *** ERROR, $lockfile exists and contains:
1313     `cat $lockfile 2>/dev/null`
1314    
1315     This indicates that another process is trying to use the same
1316     temporary object file, and libtool could not work around it because
1317     your compiler does not support \`-c' and \`-o' together. If you
1318     repeat this compilation, it may succeed, by chance, but you had better
1319     avoid parallel builds (make -j) in this platform, or get a better
1320     compiler."
1321    
1322 michael 945 $opt_dry_run || $RM $removelist
1323 michael 912 exit $EXIT_FAILURE
1324     fi
1325 michael 945 removelist="$removelist $output_obj"
1326     $ECHO "$srcfile" > "$lockfile"
1327 michael 912 fi
1328    
1329 michael 945 $opt_dry_run || $RM $removelist
1330     removelist="$removelist $lockfile"
1331     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1332    
1333 michael 912 if test -n "$fix_srcfile_path"; then
1334     eval srcfile=\"$fix_srcfile_path\"
1335     fi
1336 michael 945 func_quote_for_eval "$srcfile"
1337     qsrcfile=$func_quote_for_eval_result
1338 michael 912
1339     # Only build a PIC object if we are building libtool libraries.
1340     if test "$build_libtool_libs" = yes; then
1341     # Without this assignment, base_compile gets emptied.
1342     fbsd_hideous_sh_bug=$base_compile
1343    
1344     if test "$pic_mode" != no; then
1345     command="$base_compile $qsrcfile $pic_flag"
1346     else
1347     # Don't build PIC code
1348     command="$base_compile $qsrcfile"
1349     fi
1350    
1351 michael 945 func_mkdir_p "$xdir$objdir"
1352 michael 912
1353     if test -z "$output_obj"; then
1354     # Place PIC objects in $objdir
1355     command="$command -o $lobj"
1356     fi
1357    
1358 michael 945 func_show_eval_locale "$command" \
1359     'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1360 michael 912
1361     if test "$need_locks" = warn &&
1362     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1363 michael 945 $ECHO "\
1364 michael 912 *** ERROR, $lockfile contains:
1365     `cat $lockfile 2>/dev/null`
1366    
1367     but it should contain:
1368     $srcfile
1369    
1370     This indicates that another process is trying to use the same
1371     temporary object file, and libtool could not work around it because
1372     your compiler does not support \`-c' and \`-o' together. If you
1373     repeat this compilation, it may succeed, by chance, but you had better
1374     avoid parallel builds (make -j) in this platform, or get a better
1375     compiler."
1376    
1377 michael 945 $opt_dry_run || $RM $removelist
1378 michael 912 exit $EXIT_FAILURE
1379     fi
1380    
1381     # Just move the object if needed, then go on to compile the next one
1382     if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1383 michael 945 func_show_eval '$MV "$output_obj" "$lobj"' \
1384     'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1385 michael 912 fi
1386    
1387     # Allow error messages only from the first compilation.
1388     if test "$suppress_opt" = yes; then
1389 michael 945 suppress_output=' >/dev/null 2>&1'
1390 michael 912 fi
1391     fi
1392    
1393     # Only build a position-dependent object if we build old libraries.
1394     if test "$build_old_libs" = yes; then
1395     if test "$pic_mode" != yes; then
1396     # Don't build PIC code
1397 michael 945 command="$base_compile $qsrcfile$pie_flag"
1398 michael 912 else
1399     command="$base_compile $qsrcfile $pic_flag"
1400     fi
1401     if test "$compiler_c_o" = yes; then
1402     command="$command -o $obj"
1403     fi
1404    
1405     # Suppress compiler output if we already did a PIC compilation.
1406     command="$command$suppress_output"
1407 michael 945 func_show_eval_locale "$command" \
1408     '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1409 michael 912
1410     if test "$need_locks" = warn &&
1411     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1412 michael 945 $ECHO "\
1413 michael 912 *** ERROR, $lockfile contains:
1414     `cat $lockfile 2>/dev/null`
1415    
1416     but it should contain:
1417     $srcfile
1418    
1419     This indicates that another process is trying to use the same
1420     temporary object file, and libtool could not work around it because
1421     your compiler does not support \`-c' and \`-o' together. If you
1422     repeat this compilation, it may succeed, by chance, but you had better
1423     avoid parallel builds (make -j) in this platform, or get a better
1424     compiler."
1425    
1426 michael 945 $opt_dry_run || $RM $removelist
1427 michael 912 exit $EXIT_FAILURE
1428     fi
1429    
1430     # Just move the object if needed
1431     if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1432 michael 945 func_show_eval '$MV "$output_obj" "$obj"' \
1433     'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1434     fi
1435     fi
1436    
1437     $opt_dry_run || {
1438     func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1439    
1440     # Unlock the critical section if it was locked
1441     if test "$need_locks" != no; then
1442     removelist=$lockfile
1443     $RM "$lockfile"
1444     fi
1445     }
1446    
1447     exit $EXIT_SUCCESS
1448     }
1449    
1450     $opt_help || {
1451     test "$mode" = compile && func_mode_compile ${1+"$@"}
1452     }
1453    
1454     func_mode_help ()
1455     {
1456     # We need to display help for each of the modes.
1457     case $mode in
1458     "")
1459     # Generic help is extracted from the usage comments
1460     # at the start of this file.
1461     func_help
1462     ;;
1463    
1464     clean)
1465     $ECHO \
1466     "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1467    
1468     Remove files from the build directory.
1469    
1470     RM is the name of the program to use to delete files associated with each FILE
1471     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1472     to RM.
1473    
1474     If FILE is a libtool library, object or program, all the files associated
1475     with it are deleted. Otherwise, only FILE itself is deleted using RM."
1476     ;;
1477    
1478     compile)
1479     $ECHO \
1480     "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1481    
1482     Compile a source file into a libtool library object.
1483    
1484     This mode accepts the following additional options:
1485    
1486     -o OUTPUT-FILE set the output file name to OUTPUT-FILE
1487     -no-suppress do not suppress compiler output for multiple passes
1488     -prefer-pic try to building PIC objects only
1489     -prefer-non-pic try to building non-PIC objects only
1490     -shared do not build a \`.o' file suitable for static linking
1491     -static only build a \`.o' file suitable for static linking
1492    
1493     COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1494     from the given SOURCEFILE.
1495    
1496     The output file name is determined by removing the directory component from
1497     SOURCEFILE, then substituting the C source code suffix \`.c' with the
1498     library object suffix, \`.lo'."
1499     ;;
1500    
1501     execute)
1502     $ECHO \
1503     "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1504    
1505     Automatically set library path, then run a program.
1506    
1507     This mode accepts the following additional options:
1508    
1509     -dlopen FILE add the directory containing FILE to the library path
1510    
1511     This mode sets the library path environment variable according to \`-dlopen'
1512     flags.
1513    
1514     If any of the ARGS are libtool executable wrappers, then they are translated
1515     into their corresponding uninstalled binary, and any of their required library
1516     directories are added to the library path.
1517    
1518     Then, COMMAND is executed, with ARGS as arguments."
1519     ;;
1520    
1521     finish)
1522     $ECHO \
1523     "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1524    
1525     Complete the installation of libtool libraries.
1526    
1527     Each LIBDIR is a directory that contains libtool libraries.
1528    
1529     The commands that this mode executes may require superuser privileges. Use
1530     the \`--dry-run' option if you just want to see what would be executed."
1531     ;;
1532    
1533     install)
1534     $ECHO \
1535     "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1536    
1537     Install executables or libraries.
1538    
1539     INSTALL-COMMAND is the installation command. The first component should be
1540     either the \`install' or \`cp' program.
1541    
1542     The following components of INSTALL-COMMAND are treated specially:
1543    
1544     -inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1545    
1546     The rest of the components are interpreted as arguments to that command (only
1547     BSD-compatible install options are recognized)."
1548     ;;
1549    
1550     link)
1551     $ECHO \
1552     "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1553    
1554     Link object files or libraries together to form another library, or to
1555     create an executable program.
1556    
1557     LINK-COMMAND is a command using the C compiler that you would use to create
1558     a program from several object files.
1559    
1560     The following components of LINK-COMMAND are treated specially:
1561    
1562     -all-static do not do any dynamic linking at all
1563     -avoid-version do not add a version suffix if possible
1564     -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1565     -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1566     -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1567     -export-symbols SYMFILE
1568     try to export only the symbols listed in SYMFILE
1569     -export-symbols-regex REGEX
1570     try to export only the symbols matching REGEX
1571     -LLIBDIR search LIBDIR for required installed libraries
1572     -lNAME OUTPUT-FILE requires the installed library libNAME
1573     -module build a library that can dlopened
1574     -no-fast-install disable the fast-install mode
1575     -no-install link a not-installable executable
1576     -no-undefined declare that a library does not refer to external symbols
1577     -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1578     -objectlist FILE Use a list of object files found in FILE to specify objects
1579     -precious-files-regex REGEX
1580     don't remove output files matching REGEX
1581     -release RELEASE specify package release information
1582     -rpath LIBDIR the created library will eventually be installed in LIBDIR
1583     -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1584     -shared only do dynamic linking of libtool libraries
1585     -shrext SUFFIX override the standard shared library file extension
1586     -static do not do any dynamic linking of uninstalled libtool libraries
1587     -static-libtool-libs
1588     do not do any dynamic linking of libtool libraries
1589     -version-info CURRENT[:REVISION[:AGE]]
1590     specify library version info [each variable defaults to 0]
1591     -weak LIBNAME declare that the target provides the LIBNAME interface
1592    
1593     All other options (arguments beginning with \`-') are ignored.
1594    
1595     Every other argument is treated as a filename. Files ending in \`.la' are
1596     treated as uninstalled libtool libraries, other files are standard or library
1597     object files.
1598    
1599     If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1600     only library objects (\`.lo' files) may be specified, and \`-rpath' is
1601     required, except when creating a convenience library.
1602    
1603     If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1604     using \`ar' and \`ranlib', or on Windows using \`lib'.
1605    
1606     If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1607     is created, otherwise an executable program is created."
1608     ;;
1609    
1610     uninstall)
1611     $ECHO \
1612     "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1613    
1614     Remove libraries from an installation directory.
1615    
1616     RM is the name of the program to use to delete files associated with each FILE
1617     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1618     to RM.
1619    
1620     If FILE is a libtool library, all the files associated with it are deleted.
1621     Otherwise, only FILE itself is deleted using RM."
1622     ;;
1623    
1624     *)
1625     func_fatal_help "invalid operation mode \`$mode'"
1626     ;;
1627     esac
1628    
1629     $ECHO
1630     $ECHO "Try \`$progname --help' for more information about other modes."
1631    
1632     exit $?
1633     }
1634    
1635     # Now that we've collected a possible --mode arg, show help if necessary
1636     $opt_help && func_mode_help
1637    
1638    
1639     # func_mode_execute arg...
1640     func_mode_execute ()
1641     {
1642     $opt_debug
1643     # The first argument is the command name.
1644     cmd="$nonopt"
1645     test -z "$cmd" && \
1646     func_fatal_help "you must specify a COMMAND"
1647    
1648     # Handle -dlopen flags immediately.
1649     for file in $execute_dlfiles; do
1650     test -f "$file" \
1651     || func_fatal_help "\`$file' is not a file"
1652    
1653     dir=
1654     case $file in
1655     *.la)
1656     # Check to see that this really is a libtool archive.
1657     func_lalib_unsafe_p "$file" \
1658     || func_fatal_help "\`$lib' is not a valid libtool archive"
1659    
1660     # Read the libtool library.
1661     dlname=
1662     library_names=
1663     func_source "$file"
1664    
1665     # Skip this library if it cannot be dlopened.
1666     if test -z "$dlname"; then
1667     # Warn if it was a shared library.
1668     test -n "$library_names" && \
1669     func_warning "\`$file' was not linked with \`-export-dynamic'"
1670     continue
1671     fi
1672    
1673     func_dirname "$file" "" "."
1674     dir="$func_dirname_result"
1675    
1676     if test -f "$dir/$objdir/$dlname"; then
1677     dir="$dir/$objdir"
1678 michael 912 else
1679 michael 945 if test ! -f "$dir/$dlname"; then
1680     func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1681     fi
1682 michael 912 fi
1683 michael 945 ;;
1684    
1685     *.lo)
1686     # Just add the directory containing the .lo file.
1687     func_dirname "$file" "" "."
1688     dir="$func_dirname_result"
1689     ;;
1690    
1691     *)
1692     func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1693     continue
1694     ;;
1695     esac
1696    
1697     # Get the absolute pathname.
1698     absdir=`cd "$dir" && pwd`
1699     test -n "$absdir" && dir="$absdir"
1700    
1701     # Now add the directory to shlibpath_var.
1702     if eval "test -z \"\$$shlibpath_var\""; then
1703     eval "$shlibpath_var=\"\$dir\""
1704     else
1705     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1706 michael 912 fi
1707 michael 945 done
1708 michael 912
1709 michael 945 # This variable tells wrapper scripts just to set shlibpath_var
1710     # rather than running their programs.
1711     libtool_execute_magic="$magic"
1712 michael 912
1713 michael 945 # Check if any of the arguments is a wrapper script.
1714     args=
1715     for file
1716     do
1717     case $file in
1718     -*) ;;
1719     *)
1720     # Do a test to see if this is really a libtool program.
1721     if func_ltwrapper_script_p "$file"; then
1722     func_source "$file"
1723     # Transform arg to wrapped name.
1724     file="$progdir/$program"
1725     elif func_ltwrapper_executable_p "$file"; then
1726     func_ltwrapper_scriptname "$file"
1727     func_source "$func_ltwrapper_scriptname_result"
1728     # Transform arg to wrapped name.
1729     file="$progdir/$program"
1730     fi
1731     ;;
1732     esac
1733     # Quote arguments (to preserve shell metacharacters).
1734     func_quote_for_eval "$file"
1735     args="$args $func_quote_for_eval_result"
1736     done
1737    
1738     if test "X$opt_dry_run" = Xfalse; then
1739     if test -n "$shlibpath_var"; then
1740     # Export the shlibpath_var.
1741     eval "export $shlibpath_var"
1742     fi
1743    
1744     # Restore saved environment variables
1745     for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1746     do
1747     eval "if test \"\${save_$lt_var+set}\" = set; then
1748     $lt_var=\$save_$lt_var; export $lt_var
1749     else
1750     $lt_unset $lt_var
1751     fi"
1752     done
1753    
1754     # Now prepare to actually exec the command.
1755     exec_cmd="\$cmd$args"
1756 michael 912 else
1757 michael 945 # Display what would be done.
1758     if test -n "$shlibpath_var"; then
1759     eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1760     $ECHO "export $shlibpath_var"
1761     fi
1762     $ECHO "$cmd$args"
1763     exit $EXIT_SUCCESS
1764     fi
1765     }
1766 michael 912
1767 michael 945 test "$mode" = execute && func_mode_execute ${1+"$@"}
1768    
1769    
1770     # func_mode_finish arg...
1771     func_mode_finish ()
1772     {
1773     $opt_debug
1774     libdirs="$nonopt"
1775     admincmds=
1776    
1777     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1778     for dir
1779     do
1780     libdirs="$libdirs $dir"
1781     done
1782    
1783     for libdir in $libdirs; do
1784     if test -n "$finish_cmds"; then
1785     # Do each command in the finish commands.
1786     func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1787     '"$cmd"'"'
1788     fi
1789     if test -n "$finish_eval"; then
1790     # Do the single finish_eval.
1791     eval cmds=\"$finish_eval\"
1792     $opt_dry_run || eval "$cmds" || admincmds="$admincmds
1793     $cmds"
1794     fi
1795     done
1796 michael 912 fi
1797    
1798 michael 945 # Exit here if they wanted silent mode.
1799     $opt_silent && exit $EXIT_SUCCESS
1800 michael 912
1801 michael 945 $ECHO "X----------------------------------------------------------------------" | $Xsed
1802     $ECHO "Libraries have been installed in:"
1803     for libdir in $libdirs; do
1804     $ECHO " $libdir"
1805     done
1806     $ECHO
1807     $ECHO "If you ever happen to want to link against installed libraries"
1808     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1809     $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1810     $ECHO "flag during linking and do at least one of the following:"
1811     if test -n "$shlibpath_var"; then
1812     $ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
1813     $ECHO " during execution"
1814 michael 912 fi
1815 michael 945 if test -n "$runpath_var"; then
1816     $ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1817     $ECHO " during linking"
1818     fi
1819     if test -n "$hardcode_libdir_flag_spec"; then
1820     libdir=LIBDIR
1821     eval flag=\"$hardcode_libdir_flag_spec\"
1822 michael 912
1823 michael 945 $ECHO " - use the \`$flag' linker flag"
1824     fi
1825     if test -n "$admincmds"; then
1826     $ECHO " - have your system administrator run these commands:$admincmds"
1827     fi
1828     if test -f /etc/ld.so.conf; then
1829     $ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1830     fi
1831     $ECHO
1832    
1833     $ECHO "See any operating system documentation about shared libraries for"
1834     case $host in
1835     solaris2.[6789]|solaris2.1[0-9])
1836     $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1837     $ECHO "pages."
1838     ;;
1839     *)
1840     $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1841     ;;
1842     esac
1843     $ECHO "X----------------------------------------------------------------------" | $Xsed
1844 michael 912 exit $EXIT_SUCCESS
1845 michael 945 }
1846    
1847     test "$mode" = finish && func_mode_finish ${1+"$@"}
1848    
1849    
1850     # func_mode_install arg...
1851     func_mode_install ()
1852     {
1853     $opt_debug
1854     # There may be an optional sh(1) argument at the beginning of
1855     # install_prog (especially on Windows NT).
1856     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1857     # Allow the use of GNU shtool's install command.
1858     $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1859     # Aesthetically quote it.
1860     func_quote_for_eval "$nonopt"
1861     install_prog="$func_quote_for_eval_result "
1862     arg=$1
1863     shift
1864     else
1865     install_prog=
1866     arg=$nonopt
1867     fi
1868    
1869     # The real first argument should be the name of the installation program.
1870     # Aesthetically quote it.
1871     func_quote_for_eval "$arg"
1872     install_prog="$install_prog$func_quote_for_eval_result"
1873    
1874     # We need to accept at least all the BSD install flags.
1875     dest=
1876     files=
1877     opts=
1878     prev=
1879     install_type=
1880     isdir=no
1881     stripme=
1882     for arg
1883     do
1884     if test -n "$dest"; then
1885     files="$files $dest"
1886     dest=$arg
1887     continue
1888     fi
1889    
1890     case $arg in
1891     -d) isdir=yes ;;
1892     -f)
1893     case " $install_prog " in
1894     *[\\\ /]cp\ *) ;;
1895     *) prev=$arg ;;
1896     esac
1897     ;;
1898     -g | -m | -o)
1899     prev=$arg
1900     ;;
1901     -s)
1902     stripme=" -s"
1903     continue
1904     ;;
1905     -*)
1906     ;;
1907     *)
1908     # If the previous option needed an argument, then skip it.
1909     if test -n "$prev"; then
1910     prev=
1911     else
1912     dest=$arg
1913     continue
1914     fi
1915     ;;
1916     esac
1917    
1918     # Aesthetically quote the argument.
1919     func_quote_for_eval "$arg"
1920     install_prog="$install_prog $func_quote_for_eval_result"
1921     done
1922    
1923     test -z "$install_prog" && \
1924     func_fatal_help "you must specify an install program"
1925    
1926     test -n "$prev" && \
1927     func_fatal_help "the \`$prev' option requires an argument"
1928    
1929     if test -z "$files"; then
1930     if test -z "$dest"; then
1931     func_fatal_help "no file or destination specified"
1932     else
1933     func_fatal_help "you must specify a destination"
1934     fi
1935     fi
1936    
1937     # Strip any trailing slash from the destination.
1938     func_stripname '' '/' "$dest"
1939     dest=$func_stripname_result
1940    
1941     # Check to see that the destination is a directory.
1942     test -d "$dest" && isdir=yes
1943     if test "$isdir" = yes; then
1944     destdir="$dest"
1945     destname=
1946     else
1947     func_dirname_and_basename "$dest" "" "."
1948     destdir="$func_dirname_result"
1949     destname="$func_basename_result"
1950    
1951     # Not a directory, so check to see that there is only one file specified.
1952     set dummy $files; shift
1953     test "$#" -gt 1 && \
1954     func_fatal_help "\`$dest' is not a directory"
1955     fi
1956     case $destdir in
1957     [\\/]* | [A-Za-z]:[\\/]*) ;;
1958     *)
1959     for file in $files; do
1960     case $file in
1961     *.lo) ;;
1962     *)
1963     func_fatal_help "\`$destdir' must be an absolute directory name"
1964     ;;
1965     esac
1966     done
1967     ;;
1968     esac
1969    
1970     # This variable tells wrapper scripts just to set variables rather
1971     # than running their programs.
1972     libtool_install_magic="$magic"
1973    
1974     staticlibs=
1975     future_libdirs=
1976     current_libdirs=
1977     for file in $files; do
1978    
1979     # Do each installation.
1980     case $file in
1981     *.$libext)
1982     # Do the static libraries later.
1983     staticlibs="$staticlibs $file"
1984     ;;
1985    
1986     *.la)
1987     # Check to see that this really is a libtool archive.
1988     func_lalib_unsafe_p "$file" \
1989     || func_fatal_help "\`$file' is not a valid libtool archive"
1990    
1991     library_names=
1992     old_library=
1993     relink_command=
1994     func_source "$file"
1995    
1996     # Add the libdir to current_libdirs if it is the destination.
1997     if test "X$destdir" = "X$libdir"; then
1998     case "$current_libdirs " in
1999     *" $libdir "*) ;;
2000     *) current_libdirs="$current_libdirs $libdir" ;;
2001     esac
2002     else
2003     # Note the libdir as a future libdir.
2004     case "$future_libdirs " in
2005     *" $libdir "*) ;;
2006     *) future_libdirs="$future_libdirs $libdir" ;;
2007     esac
2008     fi
2009    
2010     func_dirname "$file" "/" ""
2011     dir="$func_dirname_result"
2012     dir="$dir$objdir"
2013    
2014     if test -n "$relink_command"; then
2015     # Determine the prefix the user has applied to our future dir.
2016     inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2017    
2018     # Don't allow the user to place us outside of our expected
2019     # location b/c this prevents finding dependent libraries that
2020     # are installed to the same prefix.
2021     # At present, this check doesn't affect windows .dll's that
2022     # are installed into $libdir/../bin (currently, that works fine)
2023     # but it's something to keep an eye on.
2024     test "$inst_prefix_dir" = "$destdir" && \
2025     func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2026    
2027     if test -n "$inst_prefix_dir"; then
2028     # Stick the inst_prefix_dir data into the link command.
2029     relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2030     else
2031     relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2032     fi
2033    
2034     func_warning "relinking \`$file'"
2035     func_show_eval "$relink_command" \
2036     'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2037     fi
2038    
2039     # See the names of the shared library.
2040     set dummy $library_names; shift
2041     if test -n "$1"; then
2042     realname="$1"
2043     shift
2044    
2045     srcname="$realname"
2046     test -n "$relink_command" && srcname="$realname"T
2047    
2048     # Install the shared library and build the symlinks.
2049     func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2050     'exit $?'
2051     tstripme="$stripme"
2052     case $host_os in
2053     cygwin* | mingw* | pw32* | cegcc*)
2054     case $realname in
2055     *.dll.a)
2056     tstripme=""
2057     ;;
2058     esac
2059     ;;
2060     esac
2061     if test -n "$tstripme" && test -n "$striplib"; then
2062     func_show_eval "$striplib $destdir/$realname" 'exit $?'
2063     fi
2064    
2065     if test "$#" -gt 0; then
2066     # Delete the old symlinks, and create new ones.
2067     # Try `ln -sf' first, because the `ln' binary might depend on
2068     # the symlink we replace! Solaris /bin/ln does not understand -f,
2069     # so we also need to try rm && ln -s.
2070     for linkname
2071     do
2072     test "$linkname" != "$realname" \
2073     && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2074     done
2075     fi
2076    
2077     # Do each command in the postinstall commands.
2078     lib="$destdir/$realname"
2079     func_execute_cmds "$postinstall_cmds" 'exit $?'
2080     fi
2081    
2082     # Install the pseudo-library for information purposes.
2083     func_basename "$file"
2084     name="$func_basename_result"
2085     instname="$dir/$name"i
2086     func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2087    
2088     # Maybe install the static library, too.
2089     test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2090     ;;
2091    
2092     *.lo)
2093     # Install (i.e. copy) a libtool object.
2094    
2095     # Figure out destination file name, if it wasn't already specified.
2096     if test -n "$destname"; then
2097     destfile="$destdir/$destname"
2098     else
2099     func_basename "$file"
2100     destfile="$func_basename_result"
2101     destfile="$destdir/$destfile"
2102     fi
2103    
2104     # Deduce the name of the destination old-style object file.
2105     case $destfile in
2106     *.lo)
2107     func_lo2o "$destfile"
2108     staticdest=$func_lo2o_result
2109     ;;
2110     *.$objext)
2111     staticdest="$destfile"
2112     destfile=
2113     ;;
2114     *)
2115     func_fatal_help "cannot copy a libtool object to \`$destfile'"
2116     ;;
2117     esac
2118    
2119     # Install the libtool object if requested.
2120     test -n "$destfile" && \
2121     func_show_eval "$install_prog $file $destfile" 'exit $?'
2122    
2123     # Install the old object if enabled.
2124     if test "$build_old_libs" = yes; then
2125     # Deduce the name of the old-style object file.
2126     func_lo2o "$file"
2127     staticobj=$func_lo2o_result
2128     func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2129     fi
2130     exit $EXIT_SUCCESS
2131     ;;
2132    
2133     *)
2134     # Figure out destination file name, if it wasn't already specified.
2135     if test -n "$destname"; then
2136     destfile="$destdir/$destname"
2137     else
2138     func_basename "$file"
2139     destfile="$func_basename_result"
2140     destfile="$destdir/$destfile"
2141     fi
2142    
2143     # If the file is missing, and there is a .exe on the end, strip it
2144     # because it is most likely a libtool script we actually want to
2145     # install
2146     stripped_ext=""
2147     case $file in
2148     *.exe)
2149     if test ! -f "$file"; then
2150     func_stripname '' '.exe' "$file"
2151     file=$func_stripname_result
2152     stripped_ext=".exe"
2153     fi
2154     ;;
2155     esac
2156    
2157     # Do a test to see if this is really a libtool program.
2158     case $host in
2159     *cygwin* | *mingw*)
2160     if func_ltwrapper_executable_p "$file"; then
2161     func_ltwrapper_scriptname "$file"
2162     wrapper=$func_ltwrapper_scriptname_result
2163     else
2164     func_stripname '' '.exe' "$file"
2165     wrapper=$func_stripname_result
2166     fi
2167     ;;
2168     *)
2169     wrapper=$file
2170     ;;
2171     esac
2172     if func_ltwrapper_script_p "$wrapper"; then
2173     notinst_deplibs=
2174     relink_command=
2175    
2176     func_source "$wrapper"
2177    
2178     # Check the variables that should have been set.
2179     test -z "$generated_by_libtool_version" && \
2180     func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2181    
2182     finalize=yes
2183     for lib in $notinst_deplibs; do
2184     # Check to see that each library is installed.
2185     libdir=
2186     if test -f "$lib"; then
2187     func_source "$lib"
2188     fi
2189     libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2190     if test -n "$libdir" && test ! -f "$libfile"; then
2191     func_warning "\`$lib' has not been installed in \`$libdir'"
2192     finalize=no
2193     fi
2194     done
2195    
2196     relink_command=
2197     func_source "$wrapper"
2198    
2199     outputname=
2200     if test "$fast_install" = no && test -n "$relink_command"; then
2201     $opt_dry_run || {
2202     if test "$finalize" = yes; then
2203     tmpdir=`func_mktempdir`
2204     func_basename "$file$stripped_ext"
2205     file="$func_basename_result"
2206     outputname="$tmpdir/$file"
2207     # Replace the output file specification.
2208     relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2209    
2210     $opt_silent || {
2211     func_quote_for_expand "$relink_command"
2212     eval "func_echo $func_quote_for_expand_result"
2213     }
2214     if eval "$relink_command"; then :
2215     else
2216     func_error "error: relink \`$file' with the above command before installing it"
2217     $opt_dry_run || ${RM}r "$tmpdir"
2218     continue
2219     fi
2220     file="$outputname"
2221     else
2222     func_warning "cannot relink \`$file'"
2223     fi
2224     }
2225     else
2226     # Install the binary that we compiled earlier.
2227     file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2228     fi
2229     fi
2230    
2231     # remove .exe since cygwin /usr/bin/install will append another
2232     # one anyway
2233     case $install_prog,$host in
2234     */usr/bin/install*,*cygwin*)
2235     case $file:$destfile in
2236     *.exe:*.exe)
2237     # this is ok
2238     ;;
2239     *.exe:*)
2240     destfile=$destfile.exe
2241     ;;
2242     *:*.exe)
2243     func_stripname '' '.exe' "$destfile"
2244     destfile=$func_stripname_result
2245     ;;
2246     esac
2247     ;;
2248     esac
2249     func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2250     $opt_dry_run || if test -n "$outputname"; then
2251     ${RM}r "$tmpdir"
2252     fi
2253     ;;
2254     esac
2255     done
2256    
2257     for file in $staticlibs; do
2258     func_basename "$file"
2259     name="$func_basename_result"
2260    
2261     # Set up the ranlib parameters.
2262     oldlib="$destdir/$name"
2263    
2264     func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2265    
2266     if test -n "$stripme" && test -n "$old_striplib"; then
2267     func_show_eval "$old_striplib $oldlib" 'exit $?'
2268     fi
2269    
2270     # Do each command in the postinstall commands.
2271     func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2272     done
2273    
2274     test -n "$future_libdirs" && \
2275     func_warning "remember to run \`$progname --finish$future_libdirs'"
2276    
2277     if test -n "$current_libdirs"; then
2278     # Maybe just do a dry run.
2279     $opt_dry_run && current_libdirs=" -n$current_libdirs"
2280     exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2281     else
2282     exit $EXIT_SUCCESS
2283     fi
2284     }
2285    
2286     test "$mode" = install && func_mode_install ${1+"$@"}
2287    
2288    
2289     # func_generate_dlsyms outputname originator pic_p
2290     # Extract symbols from dlprefiles and create ${outputname}S.o with
2291     # a dlpreopen symbol table.
2292     func_generate_dlsyms ()
2293     {
2294     $opt_debug
2295     my_outputname="$1"
2296     my_originator="$2"
2297     my_pic_p="${3-no}"
2298     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2299     my_dlsyms=
2300    
2301     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2302     if test -n "$NM" && test -n "$global_symbol_pipe"; then
2303     my_dlsyms="${my_outputname}S.c"
2304     else
2305     func_error "not configured to extract global symbols from dlpreopened files"
2306     fi
2307     fi
2308    
2309     if test -n "$my_dlsyms"; then
2310     case $my_dlsyms in
2311     "") ;;
2312     *.c)
2313     # Discover the nlist of each of the dlfiles.
2314     nlist="$output_objdir/${my_outputname}.nm"
2315    
2316     func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2317    
2318     # Parse the name list into a source file.
2319     func_verbose "creating $output_objdir/$my_dlsyms"
2320    
2321     $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2322     /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2323     /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2324    
2325     #ifdef __cplusplus
2326     extern \"C\" {
2327     #endif
2328    
2329     /* External symbol declarations for the compiler. */\
2330     "
2331    
2332     if test "$dlself" = yes; then
2333     func_verbose "generating symbol list for \`$output'"
2334    
2335     $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2336    
2337     # Add our own program objects to the symbol list.
2338     progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2339     for progfile in $progfiles; do
2340     func_verbose "extracting global C symbols from \`$progfile'"
2341     $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2342     done
2343    
2344     if test -n "$exclude_expsyms"; then
2345     $opt_dry_run || {
2346     eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2347     eval '$MV "$nlist"T "$nlist"'
2348     }
2349     fi
2350    
2351     if test -n "$export_symbols_regex"; then
2352     $opt_dry_run || {
2353     eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2354     eval '$MV "$nlist"T "$nlist"'
2355     }
2356     fi
2357    
2358     # Prepare the list of exported symbols
2359     if test -z "$export_symbols"; then
2360     export_symbols="$output_objdir/$outputname.exp"
2361     $opt_dry_run || {
2362     $RM $export_symbols
2363     eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2364     case $host in
2365     *cygwin* | *mingw* | *cegcc* )
2366     eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2367     eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2368     ;;
2369     esac
2370     }
2371     else
2372     $opt_dry_run || {
2373     eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2374     eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2375     eval '$MV "$nlist"T "$nlist"'
2376     case $host in
2377     *cygwin | *mingw* | *cegcc* )
2378     eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2379     eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2380     ;;
2381     esac
2382     }
2383     fi
2384     fi
2385    
2386     for dlprefile in $dlprefiles; do
2387     func_verbose "extracting global C symbols from \`$dlprefile'"
2388     func_basename "$dlprefile"
2389     name="$func_basename_result"
2390     $opt_dry_run || {
2391     eval '$ECHO ": $name " >> "$nlist"'
2392     eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2393     }
2394     done
2395    
2396     $opt_dry_run || {
2397     # Make sure we have at least an empty file.
2398     test -f "$nlist" || : > "$nlist"
2399    
2400     if test -n "$exclude_expsyms"; then
2401     $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2402     $MV "$nlist"T "$nlist"
2403     fi
2404    
2405     # Try sorting and uniquifying the output.
2406     if $GREP -v "^: " < "$nlist" |
2407     if sort -k 3 </dev/null >/dev/null 2>&1; then
2408     sort -k 3
2409     else
2410     sort +2
2411     fi |
2412     uniq > "$nlist"S; then
2413     :
2414     else
2415     $GREP -v "^: " < "$nlist" > "$nlist"S
2416     fi
2417    
2418     if test -f "$nlist"S; then
2419     eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2420     else
2421     $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2422     fi
2423    
2424     $ECHO >> "$output_objdir/$my_dlsyms" "\
2425    
2426     /* The mapping between symbol names and symbols. */
2427     typedef struct {
2428     const char *name;
2429     void *address;
2430     } lt_dlsymlist;
2431     "
2432     case $host in
2433     *cygwin* | *mingw* | *cegcc* )
2434     $ECHO >> "$output_objdir/$my_dlsyms" "\
2435     /* DATA imports from DLLs on WIN32 con't be const, because
2436     runtime relocations are performed -- see ld's documentation
2437     on pseudo-relocs. */"
2438     lt_dlsym_const= ;;
2439     *osf5*)
2440     echo >> "$output_objdir/$my_dlsyms" "\
2441     /* This system does not cope well with relocations in const data */"
2442     lt_dlsym_const= ;;
2443     *)
2444     lt_dlsym_const=const ;;
2445     esac
2446    
2447     $ECHO >> "$output_objdir/$my_dlsyms" "\
2448     extern $lt_dlsym_const lt_dlsymlist
2449     lt_${my_prefix}_LTX_preloaded_symbols[];
2450     $lt_dlsym_const lt_dlsymlist
2451     lt_${my_prefix}_LTX_preloaded_symbols[] =
2452     {\
2453     { \"$my_originator\", (void *) 0 },"
2454    
2455     case $need_lib_prefix in
2456     no)
2457     eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2458     ;;
2459     *)
2460     eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2461     ;;
2462     esac
2463     $ECHO >> "$output_objdir/$my_dlsyms" "\
2464     {0, (void *) 0}
2465     };
2466    
2467     /* This works around a problem in FreeBSD linker */
2468     #ifdef FREEBSD_WORKAROUND
2469     static const void *lt_preloaded_setup() {
2470     return lt_${my_prefix}_LTX_preloaded_symbols;
2471     }
2472     #endif
2473    
2474     #ifdef __cplusplus
2475     }
2476     #endif\
2477     "
2478     } # !$opt_dry_run
2479    
2480     pic_flag_for_symtable=
2481     case "$compile_command " in
2482     *" -static "*) ;;
2483     *)
2484     case $host in
2485     # compiling the symbol table file with pic_flag works around
2486     # a FreeBSD bug that causes programs to crash when -lm is
2487     # linked before any other PIC object. But we must not use
2488     # pic_flag when linking with -static. The problem exists in
2489     # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2490     *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2491     pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2492     *-*-hpux*)
2493     pic_flag_for_symtable=" $pic_flag" ;;
2494     *)
2495     if test "X$my_pic_p" != Xno; then
2496     pic_flag_for_symtable=" $pic_flag"
2497     fi
2498     ;;
2499     esac
2500     ;;
2501     esac
2502     symtab_cflags=
2503     for arg in $LTCFLAGS; do
2504     case $arg in
2505     -pie | -fpie | -fPIE) ;;
2506     *) symtab_cflags="$symtab_cflags $arg" ;;
2507     esac
2508     done
2509    
2510     # Now compile the dynamic symbol file.
2511     func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2512    
2513     # Clean up the generated files.
2514     func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2515    
2516     # Transform the symbol file into the correct name.
2517     symfileobj="$output_objdir/${my_outputname}S.$objext"
2518     case $host in
2519     *cygwin* | *mingw* | *cegcc* )
2520     if test -f "$output_objdir/$my_outputname.def"; then
2521     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2522     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2523     else
2524     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2525     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2526     fi
2527     ;;
2528     *)
2529     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2530     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2531     ;;
2532     esac
2533     ;;
2534     *)
2535     func_fatal_error "unknown suffix for \`$my_dlsyms'"
2536     ;;
2537     esac
2538     else
2539     # We keep going just in case the user didn't refer to
2540     # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2541     # really was required.
2542    
2543     # Nullify the symbol file.
2544     compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2545     finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2546     fi
2547     }
2548    
2549     # func_win32_libid arg
2550     # return the library type of file 'arg'
2551     #
2552     # Need a lot of goo to handle *both* DLLs and import libs
2553     # Has to be a shell function in order to 'eat' the argument
2554     # that is supplied when $file_magic_command is called.
2555     func_win32_libid ()
2556     {
2557     $opt_debug
2558     win32_libid_type="unknown"
2559     win32_fileres=`file -L $1 2>/dev/null`
2560     case $win32_fileres in
2561     *ar\ archive\ import\ library*) # definitely import
2562     win32_libid_type="x86 archive import"
2563 michael 912 ;;
2564 michael 945 *ar\ archive*) # could be an import, or static
2565     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2566     $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2567     win32_nmres=`eval $NM -f posix -A $1 |
2568     $SED -n -e '
2569     1,100{
2570     / I /{
2571     s,.*,import,
2572     p
2573     q
2574     }
2575     }'`
2576     case $win32_nmres in
2577     import*) win32_libid_type="x86 archive import";;
2578     *) win32_libid_type="x86 archive static";;
2579     esac
2580     fi
2581     ;;
2582     *DLL*)
2583     win32_libid_type="x86 DLL"
2584     ;;
2585     *executable*) # but shell scripts are "executable" too...
2586     case $win32_fileres in
2587     *MS\ Windows\ PE\ Intel*)
2588     win32_libid_type="x86 DLL"
2589     ;;
2590     esac
2591     ;;
2592     esac
2593     $ECHO "$win32_libid_type"
2594     }
2595 michael 912
2596 michael 945
2597    
2598     # func_extract_an_archive dir oldlib
2599     func_extract_an_archive ()
2600     {
2601     $opt_debug
2602     f_ex_an_ar_dir="$1"; shift
2603     f_ex_an_ar_oldlib="$1"
2604     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2605     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2606     :
2607     else
2608     func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2609     fi
2610     }
2611    
2612    
2613     # func_extract_archives gentop oldlib ...
2614     func_extract_archives ()
2615     {
2616     $opt_debug
2617     my_gentop="$1"; shift
2618     my_oldlibs=${1+"$@"}
2619     my_oldobjs=""
2620     my_xlib=""
2621     my_xabs=""
2622     my_xdir=""
2623    
2624     for my_xlib in $my_oldlibs; do
2625     # Extract the objects.
2626     case $my_xlib in
2627     [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2628     *) my_xabs=`pwd`"/$my_xlib" ;;
2629     esac
2630     func_basename "$my_xlib"
2631     my_xlib="$func_basename_result"
2632     my_xlib_u=$my_xlib
2633     while :; do
2634     case " $extracted_archives " in
2635     *" $my_xlib_u "*)
2636     func_arith $extracted_serial + 1
2637     extracted_serial=$func_arith_result
2638     my_xlib_u=lt$extracted_serial-$my_xlib ;;
2639     *) break ;;
2640     esac
2641     done
2642     extracted_archives="$extracted_archives $my_xlib_u"
2643     my_xdir="$my_gentop/$my_xlib_u"
2644    
2645     func_mkdir_p "$my_xdir"
2646    
2647     case $host in
2648     *-darwin*)
2649     func_verbose "Extracting $my_xabs"
2650     # Do not bother doing anything if just a dry run
2651     $opt_dry_run || {
2652     darwin_orig_dir=`pwd`
2653     cd $my_xdir || exit $?
2654     darwin_archive=$my_xabs
2655     darwin_curdir=`pwd`
2656     darwin_base_archive=`basename "$darwin_archive"`
2657     darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2658     if test -n "$darwin_arches"; then
2659     darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2660     darwin_arch=
2661     func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2662     for darwin_arch in $darwin_arches ; do
2663     func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2664     $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2665     cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2666     func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2667     cd "$darwin_curdir"
2668     $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2669     done # $darwin_arches
2670     ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2671     darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2672     darwin_file=
2673     darwin_files=
2674     for darwin_file in $darwin_filelist; do
2675     darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2676     $LIPO -create -output "$darwin_file" $darwin_files
2677     done # $darwin_filelist
2678     $RM -rf unfat-$$
2679     cd "$darwin_orig_dir"
2680     else
2681     cd $darwin_orig_dir
2682     func_extract_an_archive "$my_xdir" "$my_xabs"
2683     fi # $darwin_arches
2684     } # !$opt_dry_run
2685     ;;
2686     *)
2687     func_extract_an_archive "$my_xdir" "$my_xabs"
2688     ;;
2689     esac
2690     my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2691     done
2692    
2693     func_extract_archives_result="$my_oldobjs"
2694     }
2695    
2696    
2697    
2698     # func_emit_wrapper_part1 [arg=no]
2699     #
2700     # Emit the first part of a libtool wrapper script on stdout.
2701     # For more information, see the description associated with
2702     # func_emit_wrapper(), below.
2703     func_emit_wrapper_part1 ()
2704     {
2705     func_emit_wrapper_part1_arg1=no
2706     if test -n "$1" ; then
2707     func_emit_wrapper_part1_arg1=$1
2708     fi
2709    
2710     $ECHO "\
2711     #! $SHELL
2712    
2713     # $output - temporary wrapper script for $objdir/$outputname
2714     # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2715     #
2716     # The $output program cannot be directly executed until all the libtool
2717     # libraries that it depends on are installed.
2718     #
2719     # This wrapper script should never be moved out of the build directory.
2720     # If it is, it will not operate correctly.
2721    
2722     # Sed substitution that helps us do robust quoting. It backslashifies
2723     # metacharacters that are still active within double-quoted strings.
2724     Xsed='${SED} -e 1s/^X//'
2725     sed_quote_subst='$sed_quote_subst'
2726    
2727     # Be Bourne compatible
2728     if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2729     emulate sh
2730     NULLCMD=:
2731     # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2732     # is contrary to our usage. Disable this feature.
2733     alias -g '\${1+\"\$@\"}'='\"\$@\"'
2734     setopt NO_GLOB_SUBST
2735     else
2736     case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2737     fi
2738     BIN_SH=xpg4; export BIN_SH # for Tru64
2739     DUALCASE=1; export DUALCASE # for MKS sh
2740    
2741     # The HP-UX ksh and POSIX shell print the target directory to stdout
2742     # if CDPATH is set.
2743     (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2744    
2745     relink_command=\"$relink_command\"
2746    
2747     # This environment variable determines our operation mode.
2748     if test \"\$libtool_install_magic\" = \"$magic\"; then
2749     # install mode needs the following variables:
2750     generated_by_libtool_version='$macro_version'
2751     notinst_deplibs='$notinst_deplibs'
2752     else
2753     # When we are sourced in execute mode, \$file and \$ECHO are already set.
2754     if test \"\$libtool_execute_magic\" != \"$magic\"; then
2755     ECHO=\"$qecho\"
2756     file=\"\$0\"
2757     # Make sure echo works.
2758     if test \"X\$1\" = X--no-reexec; then
2759     # Discard the --no-reexec flag, and continue.
2760     shift
2761     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2762     # Yippee, \$ECHO works!
2763     :
2764     else
2765     # Restart under the correct shell, and then maybe \$ECHO will work.
2766     exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2767     fi
2768     fi\
2769     "
2770     $ECHO "\
2771    
2772     # Find the directory that this script lives in.
2773     thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2774     test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2775    
2776     # Follow symbolic links until we get to the real thisdir.
2777     file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2778     while test -n \"\$file\"; do
2779     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2780    
2781     # If there was a directory component, then change thisdir.
2782     if test \"x\$destdir\" != \"x\$file\"; then
2783     case \"\$destdir\" in
2784     [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2785     *) thisdir=\"\$thisdir/\$destdir\" ;;
2786     esac
2787     fi
2788    
2789     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2790     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2791     done
2792     "
2793     }
2794     # end: func_emit_wrapper_part1
2795    
2796     # func_emit_wrapper_part2 [arg=no]
2797     #
2798     # Emit the second part of a libtool wrapper script on stdout.
2799     # For more information, see the description associated with
2800     # func_emit_wrapper(), below.
2801     func_emit_wrapper_part2 ()
2802     {
2803     func_emit_wrapper_part2_arg1=no
2804     if test -n "$1" ; then
2805     func_emit_wrapper_part2_arg1=$1
2806     fi
2807    
2808     $ECHO "\
2809    
2810     # Usually 'no', except on cygwin/mingw when embedded into
2811     # the cwrapper.
2812     WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2813     if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2814     # special case for '.'
2815     if test \"\$thisdir\" = \".\"; then
2816     thisdir=\`pwd\`
2817     fi
2818     # remove .libs from thisdir
2819     case \"\$thisdir\" in
2820     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2821     $objdir ) thisdir=. ;;
2822     esac
2823     fi
2824    
2825     # Try to get the absolute directory name.
2826     absdir=\`cd \"\$thisdir\" && pwd\`
2827     test -n \"\$absdir\" && thisdir=\"\$absdir\"
2828     "
2829    
2830     if test "$fast_install" = yes; then
2831     $ECHO "\
2832     program=lt-'$outputname'$exeext
2833     progdir=\"\$thisdir/$objdir\"
2834    
2835     if test ! -f \"\$progdir/\$program\" ||
2836     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2837     test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2838    
2839     file=\"\$\$-\$program\"
2840    
2841     if test ! -d \"\$progdir\"; then
2842     $MKDIR \"\$progdir\"
2843     else
2844     $RM \"\$progdir/\$file\"
2845     fi"
2846    
2847     $ECHO "\
2848    
2849     # relink executable if necessary
2850     if test -n \"\$relink_command\"; then
2851     if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2852     else
2853     $ECHO \"\$relink_command_output\" >&2
2854     $RM \"\$progdir/\$file\"
2855     exit 1
2856     fi
2857     fi
2858    
2859     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2860     { $RM \"\$progdir/\$program\";
2861     $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2862     $RM \"\$progdir/\$file\"
2863     fi"
2864     else
2865     $ECHO "\
2866     program='$outputname'
2867     progdir=\"\$thisdir/$objdir\"
2868     "
2869     fi
2870    
2871     $ECHO "\
2872    
2873     if test -f \"\$progdir/\$program\"; then"
2874    
2875     # Export our shlibpath_var if we have one.
2876     if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2877     $ECHO "\
2878     # Add our own library path to $shlibpath_var
2879     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2880    
2881     # Some systems cannot cope with colon-terminated $shlibpath_var
2882     # The second colon is a workaround for a bug in BeOS R4 sed
2883     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2884    
2885     export $shlibpath_var
2886     "
2887     fi
2888    
2889     # fixup the dll searchpath if we need to.
2890     if test -n "$dllsearchpath"; then
2891     $ECHO "\
2892     # Add the dll search path components to the executable PATH
2893     PATH=$dllsearchpath:\$PATH
2894     "
2895     fi
2896    
2897     $ECHO "\
2898     if test \"\$libtool_execute_magic\" != \"$magic\"; then
2899     # Run the actual program with our arguments.
2900     "
2901     case $host in
2902     # Backslashes separate directories on plain windows
2903     *-*-mingw | *-*-os2* | *-cegcc*)
2904     $ECHO "\
2905     exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2906     "
2907     ;;
2908    
2909     *)
2910     $ECHO "\
2911     exec \"\$progdir/\$program\" \${1+\"\$@\"}
2912     "
2913     ;;
2914     esac
2915     $ECHO "\
2916     \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2917     exit 1
2918     fi
2919     else
2920     # The program doesn't exist.
2921     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2922     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2923     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2924     exit 1
2925     fi
2926     fi\
2927     "
2928     }
2929     # end: func_emit_wrapper_part2
2930    
2931    
2932     # func_emit_wrapper [arg=no]
2933     #
2934     # Emit a libtool wrapper script on stdout.
2935     # Don't directly open a file because we may want to
2936     # incorporate the script contents within a cygwin/mingw
2937     # wrapper executable. Must ONLY be called from within
2938     # func_mode_link because it depends on a number of variables
2939     # set therein.
2940     #
2941     # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2942     # variable will take. If 'yes', then the emitted script
2943     # will assume that the directory in which it is stored is
2944     # the $objdir directory. This is a cygwin/mingw-specific
2945     # behavior.
2946     func_emit_wrapper ()
2947     {
2948     func_emit_wrapper_arg1=no
2949     if test -n "$1" ; then
2950     func_emit_wrapper_arg1=$1
2951     fi
2952    
2953     # split this up so that func_emit_cwrapperexe_src
2954     # can call each part independently.
2955     func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2956     func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2957     }
2958    
2959    
2960     # func_to_host_path arg
2961     #
2962     # Convert paths to host format when used with build tools.
2963     # Intended for use with "native" mingw (where libtool itself
2964     # is running under the msys shell), or in the following cross-
2965     # build environments:
2966     # $build $host
2967     # mingw (msys) mingw [e.g. native]
2968     # cygwin mingw
2969     # *nix + wine mingw
2970     # where wine is equipped with the `winepath' executable.
2971     # In the native mingw case, the (msys) shell automatically
2972     # converts paths for any non-msys applications it launches,
2973     # but that facility isn't available from inside the cwrapper.
2974     # Similar accommodations are necessary for $host mingw and
2975     # $build cygwin. Calling this function does no harm for other
2976     # $host/$build combinations not listed above.
2977     #
2978     # ARG is the path (on $build) that should be converted to
2979     # the proper representation for $host. The result is stored
2980     # in $func_to_host_path_result.
2981     func_to_host_path ()
2982     {
2983     func_to_host_path_result="$1"
2984     if test -n "$1" ; then
2985 michael 912 case $host in
2986 michael 945 *mingw* )
2987     lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2988     case $build in
2989     *mingw* ) # actually, msys
2990     # awkward: cmd appends spaces to result
2991     lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2992     func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2993     $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2994     func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2995     $SED -e "$lt_sed_naive_backslashify"`
2996     ;;
2997     *cygwin* )
2998     func_to_host_path_tmp1=`cygpath -w "$1"`
2999     func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3000     $SED -e "$lt_sed_naive_backslashify"`
3001     ;;
3002     * )
3003     # Unfortunately, winepath does not exit with a non-zero
3004     # error code, so we are forced to check the contents of
3005     # stdout. On the other hand, if the command is not
3006     # found, the shell will set an exit code of 127 and print
3007     # *an error message* to stdout. So we must check for both
3008     # error code of zero AND non-empty stdout, which explains
3009     # the odd construction:
3010     func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3011     if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3012     func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3013     $SED -e "$lt_sed_naive_backslashify"`
3014     else
3015     # Allow warning below.
3016     func_to_host_path_result=""
3017     fi
3018     ;;
3019     esac
3020     if test -z "$func_to_host_path_result" ; then
3021     func_error "Could not determine host path corresponding to"
3022     func_error " '$1'"
3023     func_error "Continuing, but uninstalled executables may not work."
3024     # Fallback:
3025     func_to_host_path_result="$1"
3026     fi
3027     ;;
3028     esac
3029     fi
3030     }
3031     # end: func_to_host_path
3032    
3033     # func_to_host_pathlist arg
3034     #
3035     # Convert pathlists to host format when used with build tools.
3036     # See func_to_host_path(), above. This function supports the
3037     # following $build/$host combinations (but does no harm for
3038     # combinations not listed here):
3039     # $build $host
3040     # mingw (msys) mingw [e.g. native]
3041     # cygwin mingw
3042     # *nix + wine mingw
3043     #
3044     # Path separators are also converted from $build format to
3045     # $host format. If ARG begins or ends with a path separator
3046     # character, it is preserved (but converted to $host format)
3047     # on output.
3048     #
3049     # ARG is a pathlist (on $build) that should be converted to
3050     # the proper representation on $host. The result is stored
3051     # in $func_to_host_pathlist_result.
3052     func_to_host_pathlist ()
3053     {
3054     func_to_host_pathlist_result="$1"
3055     if test -n "$1" ; then
3056     case $host in
3057     *mingw* )
3058     lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3059     # Remove leading and trailing path separator characters from
3060     # ARG. msys behavior is inconsistent here, cygpath turns them
3061     # into '.;' and ';.', and winepath ignores them completely.
3062     func_to_host_pathlist_tmp2="$1"
3063     # Once set for this call, this variable should not be
3064     # reassigned. It is used in tha fallback case.
3065     func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3066     $SED -e 's|^:*||' -e 's|:*$||'`
3067     case $build in
3068     *mingw* ) # Actually, msys.
3069     # Awkward: cmd appends spaces to result.
3070     lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3071     func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3072     $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3073     func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3074     $SED -e "$lt_sed_naive_backslashify"`
3075     ;;
3076     *cygwin* )
3077     func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3078     func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3079     $SED -e "$lt_sed_naive_backslashify"`
3080     ;;
3081     * )
3082     # unfortunately, winepath doesn't convert pathlists
3083     func_to_host_pathlist_result=""
3084     func_to_host_pathlist_oldIFS=$IFS
3085     IFS=:
3086     for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3087     IFS=$func_to_host_pathlist_oldIFS
3088     if test -n "$func_to_host_pathlist_f" ; then
3089     func_to_host_path "$func_to_host_pathlist_f"
3090     if test -n "$func_to_host_path_result" ; then
3091     if test -z "$func_to_host_pathlist_result" ; then
3092     func_to_host_pathlist_result="$func_to_host_path_result"
3093     else
3094     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3095     fi
3096     fi
3097     fi
3098     IFS=:
3099     done
3100     IFS=$func_to_host_pathlist_oldIFS
3101     ;;
3102     esac
3103     if test -z "$func_to_host_pathlist_result" ; then
3104     func_error "Could not determine the host path(s) corresponding to"
3105     func_error " '$1'"
3106     func_error "Continuing, but uninstalled executables may not work."
3107     # Fallback. This may break if $1 contains DOS-style drive
3108     # specifications. The fix is not to complicate the expression
3109     # below, but for the user to provide a working wine installation
3110     # with winepath so that path translation in the cross-to-mingw
3111     # case works properly.
3112     lt_replace_pathsep_nix_to_dos="s|:|;|g"
3113     func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3114     $SED -e "$lt_replace_pathsep_nix_to_dos"`
3115     fi
3116     # Now, add the leading and trailing path separators back
3117     case "$1" in
3118     :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3119     ;;
3120     esac
3121     case "$1" in
3122     *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3123     ;;
3124     esac
3125     ;;
3126     esac
3127     fi
3128     }
3129     # end: func_to_host_pathlist
3130    
3131     # func_emit_cwrapperexe_src
3132     # emit the source code for a wrapper executable on stdout
3133     # Must ONLY be called from within func_mode_link because
3134     # it depends on a number of variable set therein.
3135     func_emit_cwrapperexe_src ()
3136     {
3137     cat <<EOF
3138    
3139     /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3140     Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3141    
3142     The $output program cannot be directly executed until all the libtool
3143     libraries that it depends on are installed.
3144    
3145     This wrapper executable should never be moved out of the build directory.
3146     If it is, it will not operate correctly.
3147    
3148     Currently, it simply execs the wrapper *script* "$SHELL $output",
3149     but could eventually absorb all of the scripts functionality and
3150     exec $objdir/$outputname directly.
3151     */
3152     EOF
3153     cat <<"EOF"
3154     #include <stdio.h>
3155     #include <stdlib.h>
3156     #ifdef _MSC_VER
3157     # include <direct.h>
3158     # include <process.h>
3159     # include <io.h>
3160     # define setmode _setmode
3161     #else
3162     # include <unistd.h>
3163     # include <stdint.h>
3164     # ifdef __CYGWIN__
3165     # include <io.h>
3166     # define HAVE_SETENV
3167     # ifdef __STRICT_ANSI__
3168     char *realpath (const char *, char *);
3169     int putenv (char *);
3170     int setenv (const char *, const char *, int);
3171     # endif
3172     # endif
3173     #endif
3174     #include <malloc.h>
3175     #include <stdarg.h>
3176     #include <assert.h>
3177     #include <string.h>
3178     #include <ctype.h>
3179     #include <errno.h>
3180     #include <fcntl.h>
3181     #include <sys/stat.h>
3182    
3183     #if defined(PATH_MAX)
3184     # define LT_PATHMAX PATH_MAX
3185     #elif defined(MAXPATHLEN)
3186     # define LT_PATHMAX MAXPATHLEN
3187     #else
3188     # define LT_PATHMAX 1024
3189     #endif
3190    
3191     #ifndef S_IXOTH
3192     # define S_IXOTH 0
3193     #endif
3194     #ifndef S_IXGRP
3195     # define S_IXGRP 0
3196     #endif
3197    
3198     #ifdef _MSC_VER
3199     # define S_IXUSR _S_IEXEC
3200     # define stat _stat
3201     # ifndef _INTPTR_T_DEFINED
3202     # define intptr_t int
3203     # endif
3204     #endif
3205    
3206     #ifndef DIR_SEPARATOR
3207     # define DIR_SEPARATOR '/'
3208     # define PATH_SEPARATOR ':'
3209     #endif
3210    
3211     #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3212     defined (__OS2__)
3213     # define HAVE_DOS_BASED_FILE_SYSTEM
3214     # define FOPEN_WB "wb"
3215     # ifndef DIR_SEPARATOR_2
3216     # define DIR_SEPARATOR_2 '\\'
3217     # endif
3218     # ifndef PATH_SEPARATOR_2
3219     # define PATH_SEPARATOR_2 ';'
3220     # endif
3221     #endif
3222    
3223     #ifndef DIR_SEPARATOR_2
3224     # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3225     #else /* DIR_SEPARATOR_2 */
3226     # define IS_DIR_SEPARATOR(ch) \
3227     (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3228     #endif /* DIR_SEPARATOR_2 */
3229    
3230     #ifndef PATH_SEPARATOR_2
3231     # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3232     #else /* PATH_SEPARATOR_2 */
3233     # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3234     #endif /* PATH_SEPARATOR_2 */
3235    
3236     #ifdef __CYGWIN__
3237     # define FOPEN_WB "wb"
3238     #endif
3239    
3240     #ifndef FOPEN_WB
3241     # define FOPEN_WB "w"
3242     #endif
3243     #ifndef _O_BINARY
3244     # define _O_BINARY 0
3245     #endif
3246    
3247     #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3248     #define XFREE(stale) do { \
3249     if (stale) { free ((void *) stale); stale = 0; } \
3250     } while (0)
3251    
3252     #undef LTWRAPPER_DEBUGPRINTF
3253     #if defined DEBUGWRAPPER
3254     # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3255     static void
3256     ltwrapper_debugprintf (const char *fmt, ...)
3257     {
3258     va_list args;
3259     va_start (args, fmt);
3260     (void) vfprintf (stderr, fmt, args);
3261     va_end (args);
3262     }
3263     #else
3264     # define LTWRAPPER_DEBUGPRINTF(args)
3265     #endif
3266    
3267     const char *program_name = NULL;
3268    
3269     void *xmalloc (size_t num);
3270     char *xstrdup (const char *string);
3271     const char *base_name (const char *name);
3272     char *find_executable (const char *wrapper);
3273     char *chase_symlinks (const char *pathspec);
3274     int make_executable (const char *path);
3275     int check_executable (const char *path);
3276     char *strendzap (char *str, const char *pat);
3277     void lt_fatal (const char *message, ...);
3278     void lt_setenv (const char *name, const char *value);
3279     char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3280     void lt_opt_process_env_set (const char *arg);
3281     void lt_opt_process_env_prepend (const char *arg);
3282     void lt_opt_process_env_append (const char *arg);
3283     int lt_split_name_value (const char *arg, char** name, char** value);
3284     void lt_update_exe_path (const char *name, const char *value);
3285     void lt_update_lib_path (const char *name, const char *value);
3286    
3287     static const char *script_text_part1 =
3288     EOF
3289    
3290     func_emit_wrapper_part1 yes |
3291     $SED -e 's/\([\\"]\)/\\\1/g' \
3292     -e 's/^/ "/' -e 's/$/\\n"/'
3293     echo ";"
3294     cat <<EOF
3295    
3296     static const char *script_text_part2 =
3297     EOF
3298     func_emit_wrapper_part2 yes |
3299     $SED -e 's/\([\\"]\)/\\\1/g' \
3300     -e 's/^/ "/' -e 's/$/\\n"/'
3301     echo ";"
3302    
3303     cat <<EOF
3304     const char * MAGIC_EXE = "$magic_exe";
3305     const char * LIB_PATH_VARNAME = "$shlibpath_var";
3306     EOF
3307    
3308     if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3309     func_to_host_pathlist "$temp_rpath"
3310     cat <<EOF
3311     const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3312     EOF
3313     else
3314     cat <<"EOF"
3315     const char * LIB_PATH_VALUE = "";
3316     EOF
3317     fi
3318    
3319     if test -n "$dllsearchpath"; then
3320     func_to_host_pathlist "$dllsearchpath:"
3321     cat <<EOF
3322     const char * EXE_PATH_VARNAME = "PATH";
3323     const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3324     EOF
3325     else
3326     cat <<"EOF"
3327     const char * EXE_PATH_VARNAME = "";
3328     const char * EXE_PATH_VALUE = "";
3329     EOF
3330     fi
3331    
3332     if test "$fast_install" = yes; then
3333     cat <<EOF
3334     const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3335     EOF
3336     else
3337     cat <<EOF
3338     const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3339     EOF
3340     fi
3341    
3342    
3343     cat <<"EOF"
3344    
3345     #define LTWRAPPER_OPTION_PREFIX "--lt-"
3346     #define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3347    
3348     static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3349     static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3350    
3351     static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3352    
3353     static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3354     static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";
3355     /* argument is putenv-style "foo=bar", value of foo is set to bar */
3356    
3357     static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3358     static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";
3359     /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3360    
3361     static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3362     static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";
3363     /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3364    
3365     int
3366     main (int argc, char *argv[])
3367     {
3368     char **newargz;
3369     int newargc;
3370     char *tmp_pathspec;
3371     char *actual_cwrapper_path;
3372     char *actual_cwrapper_name;
3373     char *target_name;
3374     char *lt_argv_zero;
3375     intptr_t rval = 127;
3376    
3377     int i;
3378    
3379     program_name = (char *) xstrdup (base_name (argv[0]));
3380     LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3381     LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3382    
3383     /* very simple arg parsing; don't want to rely on getopt */
3384     for (i = 1; i < argc; i++)
3385     {
3386     if (strcmp (argv[i], dumpscript_opt) == 0)
3387     {
3388     EOF
3389     case "$host" in
3390     *mingw* | *cygwin* )
3391     # make stdout use "unix" line endings
3392     echo " setmode(1,_O_BINARY);"
3393     ;;
3394     esac
3395    
3396     cat <<"EOF"
3397     printf ("%s", script_text_part1);
3398     printf ("%s", script_text_part2);
3399     return 0;
3400     }
3401     }
3402    
3403     newargz = XMALLOC (char *, argc + 1);
3404     tmp_pathspec = find_executable (argv[0]);
3405     if (tmp_pathspec == NULL)
3406     lt_fatal ("Couldn't find %s", argv[0]);
3407     LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3408     tmp_pathspec));
3409    
3410     actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3411     LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3412     actual_cwrapper_path));
3413     XFREE (tmp_pathspec);
3414    
3415     actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3416     strendzap (actual_cwrapper_path, actual_cwrapper_name);
3417    
3418     /* wrapper name transforms */
3419     strendzap (actual_cwrapper_name, ".exe");
3420     tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3421     XFREE (actual_cwrapper_name);
3422     actual_cwrapper_name = tmp_pathspec;
3423     tmp_pathspec = 0;
3424    
3425     /* target_name transforms -- use actual target program name; might have lt- prefix */
3426     target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3427     strendzap (target_name, ".exe");
3428     tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3429     XFREE (target_name);
3430     target_name = tmp_pathspec;
3431     tmp_pathspec = 0;
3432    
3433     LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3434     target_name));
3435     EOF
3436    
3437     cat <<EOF
3438     newargz[0] =
3439     XMALLOC (char, (strlen (actual_cwrapper_path) +
3440     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3441     strcpy (newargz[0], actual_cwrapper_path);
3442     strcat (newargz[0], "$objdir");
3443     strcat (newargz[0], "/");
3444     EOF
3445    
3446     cat <<"EOF"
3447     /* stop here, and copy so we don't have to do this twice */
3448     tmp_pathspec = xstrdup (newargz[0]);
3449    
3450     /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3451     strcat (newargz[0], actual_cwrapper_name);
3452    
3453     /* DO want the lt- prefix here if it exists, so use target_name */
3454     lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3455     XFREE (tmp_pathspec);
3456     tmp_pathspec = NULL;
3457     EOF
3458    
3459     case $host_os in
3460     mingw*)
3461     cat <<"EOF"
3462     {
3463     char* p;
3464     while ((p = strchr (newargz[0], '\\')) != NULL)
3465     {
3466     *p = '/';
3467     }
3468     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3469     {
3470     *p = '/';
3471     }
3472     }
3473     EOF
3474     ;;
3475     esac
3476    
3477     cat <<"EOF"
3478     XFREE (target_name);
3479     XFREE (actual_cwrapper_path);
3480     XFREE (actual_cwrapper_name);
3481    
3482     lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3483     lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3484     lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3485     lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3486    
3487     newargc=0;
3488     for (i = 1; i < argc; i++)
3489     {
3490     if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3491     {
3492     if (argv[i][env_set_opt_len] == '=')
3493     {
3494     const char *p = argv[i] + env_set_opt_len + 1;
3495     lt_opt_process_env_set (p);
3496     }
3497     else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3498     {
3499     lt_opt_process_env_set (argv[++i]); /* don't copy */
3500     }
3501     else
3502     lt_fatal ("%s missing required argument", env_set_opt);
3503     continue;
3504     }
3505     if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3506     {
3507     if (argv[i][env_prepend_opt_len] == '=')
3508     {
3509     const char *p = argv[i] + env_prepend_opt_len + 1;
3510     lt_opt_process_env_prepend (p);
3511     }
3512     else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3513     {
3514     lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3515     }
3516     else
3517     lt_fatal ("%s missing required argument", env_prepend_opt);
3518     continue;
3519     }
3520     if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3521     {
3522     if (argv[i][env_append_opt_len] == '=')
3523     {
3524     const char *p = argv[i] + env_append_opt_len + 1;
3525     lt_opt_process_env_append (p);
3526     }
3527     else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3528     {
3529     lt_opt_process_env_append (argv[++i]); /* don't copy */
3530     }
3531     else
3532     lt_fatal ("%s missing required argument", env_append_opt);
3533     continue;
3534     }
3535     if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3536     {
3537     /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3538     namespace, but it is not one of the ones we know about and
3539     have already dealt with, above (inluding dump-script), then
3540     report an error. Otherwise, targets might begin to believe
3541     they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3542     namespace. The first time any user complains about this, we'll
3543     need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3544     or a configure.ac-settable value.
3545     */
3546     lt_fatal ("Unrecognized option in %s namespace: '%s'",
3547     ltwrapper_option_prefix, argv[i]);
3548     }
3549     /* otherwise ... */
3550     newargz[++newargc] = xstrdup (argv[i]);
3551     }
3552     newargz[++newargc] = NULL;
3553    
3554     LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3555     for (i = 0; i < newargc; i++)
3556     {
3557     LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3558     }
3559    
3560     EOF
3561    
3562     case $host_os in
3563     mingw*)
3564     cat <<"EOF"
3565     /* execv doesn't actually work on mingw as expected on unix */
3566     rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3567     if (rval == -1)
3568     {
3569     /* failed to start process */
3570     LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3571     return 127;
3572     }
3573     return rval;
3574     EOF
3575     ;;
3576     *)
3577     cat <<"EOF"
3578     execv (lt_argv_zero, newargz);
3579     return rval; /* =127, but avoids unused variable warning */
3580     EOF
3581     ;;
3582     esac
3583    
3584     cat <<"EOF"
3585     }
3586    
3587     void *
3588     xmalloc (size_t num)
3589     {
3590     void *p = (void *) malloc (num);
3591     if (!p)
3592     lt_fatal ("Memory exhausted");
3593    
3594     return p;
3595     }
3596    
3597     char *
3598     xstrdup (const char *string)
3599     {
3600     return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3601     string) : NULL;
3602     }
3603    
3604     const char *
3605     base_name (const char *name)
3606     {
3607     const char *base;
3608    
3609     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3610     /* Skip over the disk name in MSDOS pathnames. */
3611     if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3612     name += 2;
3613     #endif
3614    
3615     for (base = name; *name; name++)
3616     if (IS_DIR_SEPARATOR (*name))
3617     base = name + 1;
3618     return base;
3619     }
3620    
3621     int
3622     check_executable (const char *path)
3623     {
3624     struct stat st;
3625    
3626     LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3627     path ? (*path ? path : "EMPTY!") : "NULL!"));
3628     if ((!path) || (!*path))
3629     return 0;
3630    
3631     if ((stat (path, &st) >= 0)
3632     && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3633     return 1;
3634     else
3635     return 0;
3636     }
3637    
3638     int
3639     make_executable (const char *path)
3640     {
3641     int rval = 0;
3642     struct stat st;
3643    
3644     LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3645     path ? (*path ? path : "EMPTY!") : "NULL!"));
3646     if ((!path) || (!*path))
3647     return 0;
3648    
3649     if (stat (path, &st) >= 0)
3650     {
3651     rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3652     }
3653     return rval;
3654     }
3655    
3656     /* Searches for the full path of the wrapper. Returns
3657     newly allocated full path name if found, NULL otherwise
3658     Does not chase symlinks, even on platforms that support them.
3659     */
3660     char *
3661     find_executable (const char *wrapper)
3662     {
3663     int has_slash = 0;
3664     const char *p;
3665     const char *p_next;
3666     /* static buffer for getcwd */
3667     char tmp[LT_PATHMAX + 1];
3668     int tmp_len;
3669     char *concat_name;
3670    
3671     LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3672     wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3673    
3674     if ((wrapper == NULL) || (*wrapper == '\0'))
3675     return NULL;
3676    
3677     /* Absolute path? */
3678     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3679     if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3680     {
3681     concat_name = xstrdup (wrapper);
3682     if (check_executable (concat_name))
3683     return concat_name;
3684     XFREE (concat_name);
3685     }
3686     else
3687     {
3688     #endif
3689     if (IS_DIR_SEPARATOR (wrapper[0]))
3690     {
3691     concat_name = xstrdup (wrapper);
3692     if (check_executable (concat_name))
3693     return concat_name;
3694     XFREE (concat_name);
3695     }
3696     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3697     }
3698     #endif
3699    
3700     for (p = wrapper; *p; p++)
3701     if (*p == '/')
3702     {
3703     has_slash = 1;
3704     break;
3705     }
3706     if (!has_slash)
3707     {
3708     /* no slashes; search PATH */
3709     const char *path = getenv ("PATH");
3710     if (path != NULL)
3711     {
3712     for (p = path; *p; p = p_next)
3713     {
3714     const char *q;
3715     size_t p_len;
3716     for (q = p; *q; q++)
3717     if (IS_PATH_SEPARATOR (*q))
3718     break;
3719     p_len = q - p;
3720     p_next = (*q == '\0' ? q : q + 1);
3721     if (p_len == 0)
3722     {
3723     /* empty path: current directory */
3724     if (getcwd (tmp, LT_PATHMAX) == NULL)
3725     lt_fatal ("getcwd failed");
3726     tmp_len = strlen (tmp);
3727     concat_name =
3728     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3729     memcpy (concat_name, tmp, tmp_len);
3730     concat_name[tmp_len] = '/';
3731     strcpy (concat_name + tmp_len + 1, wrapper);
3732     }
3733     else
3734     {
3735     concat_name =
3736     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3737     memcpy (concat_name, p, p_len);
3738     concat_name[p_len] = '/';
3739     strcpy (concat_name + p_len + 1, wrapper);
3740     }
3741     if (check_executable (concat_name))
3742     return concat_name;
3743     XFREE (concat_name);
3744     }
3745     }
3746     /* not found in PATH; assume curdir */
3747     }
3748     /* Relative path | not found in path: prepend cwd */
3749     if (getcwd (tmp, LT_PATHMAX) == NULL)
3750     lt_fatal ("getcwd failed");
3751     tmp_len = strlen (tmp);
3752     concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3753     memcpy (concat_name, tmp, tmp_len);
3754     concat_name[tmp_len] = '/';
3755     strcpy (concat_name + tmp_len + 1, wrapper);
3756    
3757     if (check_executable (concat_name))
3758     return concat_name;
3759     XFREE (concat_name);
3760     return NULL;
3761     }
3762    
3763     char *
3764     chase_symlinks (const char *pathspec)
3765     {
3766     #ifndef S_ISLNK
3767     return xstrdup (pathspec);
3768     #else
3769     char buf[LT_PATHMAX];
3770     struct stat s;
3771     char *tmp_pathspec = xstrdup (pathspec);
3772     char *p;
3773     int has_symlinks = 0;
3774     while (strlen (tmp_pathspec) && !has_symlinks)
3775     {
3776     LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3777     tmp_pathspec));
3778     if (lstat (tmp_pathspec, &s) == 0)
3779     {
3780     if (S_ISLNK (s.st_mode) != 0)
3781     {
3782     has_symlinks = 1;
3783     break;
3784     }
3785    
3786     /* search backwards for last DIR_SEPARATOR */
3787     p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3788     while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3789     p--;
3790     if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3791     {
3792     /* no more DIR_SEPARATORS left */
3793     break;
3794     }
3795     *p = '\0';
3796     }
3797     else
3798     {
3799     char *errstr = strerror (errno);
3800     lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3801     }
3802     }
3803     XFREE (tmp_pathspec);
3804    
3805     if (!has_symlinks)
3806     {
3807     return xstrdup (pathspec);
3808     }
3809    
3810     tmp_pathspec = realpath (pathspec, buf);
3811     if (tmp_pathspec == 0)
3812     {
3813     lt_fatal ("Could not follow symlinks for %s", pathspec);
3814     }
3815     return xstrdup (tmp_pathspec);
3816     #endif
3817     }
3818    
3819     char *
3820     strendzap (char *str, const char *pat)
3821     {
3822     size_t len, patlen;
3823    
3824     assert (str != NULL);
3825     assert (pat != NULL);
3826    
3827     len = strlen (str);
3828     patlen = strlen (pat);
3829    
3830     if (patlen <= len)
3831     {
3832     str += len - patlen;
3833     if (strcmp (str, pat) == 0)
3834     *str = '\0';
3835     }
3836     return str;
3837     }
3838    
3839     static void
3840     lt_error_core (int exit_status, const char *mode,
3841     const char *message, va_list ap)
3842     {
3843     fprintf (stderr, "%s: %s: ", program_name, mode);
3844     vfprintf (stderr, message, ap);
3845     fprintf (stderr, ".\n");
3846    
3847     if (exit_status >= 0)
3848     exit (exit_status);
3849     }
3850    
3851     void
3852     lt_fatal (const char *message, ...)
3853     {
3854     va_list ap;
3855     va_start (ap, message);
3856     lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3857     va_end (ap);
3858     }
3859    
3860     void
3861     lt_setenv (const char *name, const char *value)
3862     {
3863     LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3864     (name ? name : "<NULL>"),
3865     (value ? value : "<NULL>")));
3866     {
3867     #ifdef HAVE_SETENV
3868     /* always make a copy, for consistency with !HAVE_SETENV */
3869     char *str = xstrdup (value);
3870     setenv (name, str, 1);
3871     #else
3872     int len = strlen (name) + 1 + strlen (value) + 1;
3873     char *str = XMALLOC (char, len);
3874     sprintf (str, "%s=%s", name, value);
3875     if (putenv (str) != EXIT_SUCCESS)
3876     {
3877     XFREE (str);
3878     }
3879     #endif
3880     }
3881     }
3882    
3883     char *
3884     lt_extend_str (const char *orig_value, const char *add, int to_end)
3885     {
3886     char *new_value;
3887     if (orig_value && *orig_value)
3888     {
3889     int orig_value_len = strlen (orig_value);
3890     int add_len = strlen (add);
3891     new_value = XMALLOC (char, add_len + orig_value_len + 1);
3892     if (to_end)
3893     {
3894     strcpy (new_value, orig_value);
3895     strcpy (new_value + orig_value_len, add);
3896     }
3897     else
3898     {
3899     strcpy (new_value, add);
3900     strcpy (new_value + add_len, orig_value);
3901     }
3902     }
3903     else
3904     {
3905     new_value = xstrdup (add);
3906     }
3907     return new_value;
3908     }
3909    
3910     int
3911     lt_split_name_value (const char *arg, char** name, char** value)
3912     {
3913     const char *p;
3914     int len;
3915     if (!arg || !*arg)
3916     return 1;
3917    
3918     p = strchr (arg, (int)'=');
3919    
3920     if (!p)
3921     return 1;
3922    
3923     *value = xstrdup (++p);
3924    
3925     len = strlen (arg) - strlen (*value);
3926     *name = XMALLOC (char, len);
3927     strncpy (*name, arg, len-1);
3928     (*name)[len - 1] = '\0';
3929    
3930     return 0;
3931     }
3932    
3933     void
3934     lt_opt_process_env_set (const char *arg)
3935     {
3936     char *name = NULL;
3937     char *value = NULL;
3938    
3939     if (lt_split_name_value (arg, &name, &value) != 0)
3940     {
3941     XFREE (name);
3942     XFREE (value);
3943     lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3944     }
3945    
3946     lt_setenv (name, value);
3947     XFREE (name);
3948     XFREE (value);
3949     }
3950    
3951     void
3952     lt_opt_process_env_prepend (const char *arg)
3953     {
3954     char *name = NULL;
3955     char *value = NULL;
3956     char *new_value = NULL;
3957    
3958     if (lt_split_name_value (arg, &name, &value) != 0)
3959     {
3960     XFREE (name);
3961     XFREE (value);
3962     lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3963     }
3964    
3965     new_value = lt_extend_str (getenv (name), value, 0);
3966     lt_setenv (name, new_value);
3967     XFREE (new_value);
3968     XFREE (name);
3969     XFREE (value);
3970     }
3971    
3972     void
3973     lt_opt_process_env_append (const char *arg)
3974     {
3975     char *name = NULL;
3976     char *value = NULL;
3977     char *new_value = NULL;
3978    
3979     if (lt_split_name_value (arg, &name, &value) != 0)
3980     {
3981     XFREE (name);
3982     XFREE (value);
3983     lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3984     }
3985    
3986     new_value = lt_extend_str (getenv (name), value, 1);
3987     lt_setenv (name, new_value);
3988     XFREE (new_value);
3989     XFREE (name);
3990     XFREE (value);
3991     }
3992    
3993     void
3994     lt_update_exe_path (const char *name, const char *value)
3995     {
3996     LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3997     (name ? name : "<NULL>"),
3998     (value ? value : "<NULL>")));
3999    
4000     if (name && *name && value && *value)
4001     {
4002     char *new_value = lt_extend_str (getenv (name), value, 0);
4003     /* some systems can't cope with a ':'-terminated path #' */
4004     int len = strlen (new_value);
4005     while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4006     {
4007     new_value[len-1] = '\0';
4008     }
4009     lt_setenv (name, new_value);
4010     XFREE (new_value);
4011     }
4012     }
4013    
4014     void
4015     lt_update_lib_path (const char *name, const char *value)
4016     {
4017     LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4018     (name ? name : "<NULL>"),
4019     (value ? value : "<NULL>")));
4020    
4021     if (name && *name && value && *value)
4022     {
4023     char *new_value = lt_extend_str (getenv (name), value, 0);
4024     lt_setenv (name, new_value);
4025     XFREE (new_value);
4026     }
4027     }
4028    
4029    
4030     EOF
4031     }
4032     # end: func_emit_cwrapperexe_src
4033    
4034     # func_mode_link arg...
4035     func_mode_link ()
4036     {
4037     $opt_debug
4038     case $host in
4039     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4040 michael 912 # It is impossible to link a dll without this setting, and
4041     # we shouldn't force the makefile maintainer to figure out
4042     # which system we are compiling for in order to pass an extra
4043     # flag for every libtool invocation.
4044     # allow_undefined=no
4045    
4046     # FIXME: Unfortunately, there are problems with the above when trying
4047     # to make a dll which has undefined symbols, in which case not
4048     # even a static library is built. For now, we need to specify
4049     # -no-undefined on the libtool link line when we can be certain
4050     # that all symbols are satisfied, otherwise we get a static library.
4051     allow_undefined=yes
4052     ;;
4053     *)
4054     allow_undefined=yes
4055     ;;
4056     esac
4057 michael 945 libtool_args=$nonopt
4058 michael 912 base_compile="$nonopt $@"
4059 michael 945 compile_command=$nonopt
4060     finalize_command=$nonopt
4061 michael 912
4062     compile_rpath=
4063     finalize_rpath=
4064     compile_shlibpath=
4065     finalize_shlibpath=
4066     convenience=
4067     old_convenience=
4068     deplibs=
4069     old_deplibs=
4070     compiler_flags=
4071     linker_flags=
4072     dllsearchpath=
4073     lib_search_path=`pwd`
4074     inst_prefix_dir=
4075 michael 945 new_inherited_linker_flags=
4076 michael 912
4077     avoid_version=no
4078     dlfiles=
4079     dlprefiles=
4080     dlself=no
4081     export_dynamic=no
4082     export_symbols=
4083     export_symbols_regex=
4084     generated=
4085     libobjs=
4086     ltlibs=
4087     module=no
4088     no_install=no
4089     objs=
4090     non_pic_objects=
4091     precious_files_regex=
4092     prefer_static_libs=no
4093     preload=no
4094     prev=
4095     prevarg=
4096     release=
4097     rpath=
4098     xrpath=
4099     perm_rpath=
4100     temp_rpath=
4101     thread_safe=no
4102     vinfo=
4103     vinfo_number=no
4104 michael 945 weak_libs=
4105     single_module="${wl}-single_module"
4106 michael 912 func_infer_tag $base_compile
4107    
4108     # We need to know -static, to get the right output filenames.
4109     for arg
4110     do
4111     case $arg in
4112 michael 945 -shared)
4113     test "$build_libtool_libs" != yes && \
4114     func_fatal_configuration "can not build a shared library"
4115     build_old_libs=no
4116     break
4117     ;;
4118 michael 912 -all-static | -static | -static-libtool-libs)
4119     case $arg in
4120     -all-static)
4121     if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4122 michael 945 func_warning "complete static linking is impossible in this configuration"
4123 michael 912 fi
4124     if test -n "$link_static_flag"; then
4125     dlopen_self=$dlopen_self_static
4126     fi
4127     prefer_static_libs=yes
4128     ;;
4129     -static)
4130     if test -z "$pic_flag" && test -n "$link_static_flag"; then
4131     dlopen_self=$dlopen_self_static
4132     fi
4133     prefer_static_libs=built
4134     ;;
4135     -static-libtool-libs)
4136     if test -z "$pic_flag" && test -n "$link_static_flag"; then
4137     dlopen_self=$dlopen_self_static
4138     fi
4139     prefer_static_libs=yes
4140     ;;
4141     esac
4142     build_libtool_libs=no
4143     build_old_libs=yes
4144     break
4145     ;;
4146     esac
4147     done
4148    
4149     # See if our shared archives depend on static archives.
4150     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4151    
4152     # Go through the arguments, transforming them on the way.
4153     while test "$#" -gt 0; do
4154     arg="$1"
4155     shift
4156 michael 945 func_quote_for_eval "$arg"
4157     qarg=$func_quote_for_eval_unquoted_result
4158     func_append libtool_args " $func_quote_for_eval_result"
4159 michael 912
4160     # If the previous option needs an argument, assign it.
4161     if test -n "$prev"; then
4162     case $prev in
4163     output)
4164 michael 945 func_append compile_command " @OUTPUT@"
4165     func_append finalize_command " @OUTPUT@"
4166 michael 912 ;;
4167     esac
4168    
4169     case $prev in
4170     dlfiles|dlprefiles)
4171     if test "$preload" = no; then
4172     # Add the symbol object into the linking commands.
4173 michael 945 func_append compile_command " @SYMFILE@"
4174     func_append finalize_command " @SYMFILE@"
4175 michael 912 preload=yes
4176     fi
4177     case $arg in
4178     *.la | *.lo) ;; # We handle these cases below.
4179     force)
4180     if test "$dlself" = no; then
4181     dlself=needless
4182     export_dynamic=yes
4183     fi
4184     prev=
4185     continue
4186     ;;
4187     self)
4188     if test "$prev" = dlprefiles; then
4189     dlself=yes
4190     elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4191     dlself=yes
4192     else
4193     dlself=needless
4194     export_dynamic=yes
4195     fi
4196     prev=
4197     continue
4198     ;;
4199     *)
4200     if test "$prev" = dlfiles; then
4201     dlfiles="$dlfiles $arg"
4202     else
4203     dlprefiles="$dlprefiles $arg"
4204     fi
4205     prev=
4206     continue
4207     ;;
4208     esac
4209     ;;
4210     expsyms)
4211     export_symbols="$arg"
4212 michael 945 test -f "$arg" \
4213     || func_fatal_error "symbol file \`$arg' does not exist"
4214 michael 912 prev=
4215     continue
4216     ;;
4217     expsyms_regex)
4218     export_symbols_regex="$arg"
4219     prev=
4220     continue
4221     ;;
4222 michael 945 framework)
4223     case $host in
4224     *-*-darwin*)
4225     case "$deplibs " in
4226     *" $qarg.ltframework "*) ;;
4227     *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4228     ;;
4229     esac
4230     ;;
4231     esac
4232 michael 912 prev=
4233     continue
4234     ;;
4235 michael 945 inst_prefix)
4236     inst_prefix_dir="$arg"
4237 michael 912 prev=
4238     continue
4239     ;;
4240     objectlist)
4241     if test -f "$arg"; then
4242     save_arg=$arg
4243     moreargs=
4244 michael 945 for fil in `cat "$save_arg"`
4245 michael 912 do
4246     # moreargs="$moreargs $fil"
4247     arg=$fil
4248     # A libtool-controlled object.
4249    
4250     # Check to see that this really is a libtool object.
4251 michael 945 if func_lalib_unsafe_p "$arg"; then
4252 michael 912 pic_object=
4253     non_pic_object=
4254    
4255     # Read the .lo file
4256 michael 945 func_source "$arg"
4257 michael 912
4258 michael 945 if test -z "$pic_object" ||
4259 michael 912 test -z "$non_pic_object" ||
4260 michael 945 test "$pic_object" = none &&
4261 michael 912 test "$non_pic_object" = none; then
4262 michael 945 func_fatal_error "cannot find name of object for \`$arg'"
4263 michael 912 fi
4264    
4265     # Extract subdirectory from the argument.
4266 michael 945 func_dirname "$arg" "/" ""
4267     xdir="$func_dirname_result"
4268 michael 912
4269     if test "$pic_object" != none; then
4270     # Prepend the subdirectory the object is found in.
4271     pic_object="$xdir$pic_object"
4272    
4273     if test "$prev" = dlfiles; then
4274     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4275     dlfiles="$dlfiles $pic_object"
4276     prev=
4277     continue
4278     else
4279     # If libtool objects are unsupported, then we need to preload.
4280     prev=dlprefiles
4281     fi
4282     fi
4283    
4284     # CHECK ME: I think I busted this. -Ossama
4285     if test "$prev" = dlprefiles; then
4286     # Preload the old-style object.
4287     dlprefiles="$dlprefiles $pic_object"
4288     prev=
4289     fi
4290    
4291     # A PIC object.
4292 michael 945 func_append libobjs " $pic_object"
4293 michael 912 arg="$pic_object"
4294     fi
4295    
4296     # Non-PIC object.
4297     if test "$non_pic_object" != none; then
4298     # Prepend the subdirectory the object is found in.
4299     non_pic_object="$xdir$non_pic_object"
4300    
4301     # A standard non-PIC object
4302 michael 945 func_append non_pic_objects " $non_pic_object"
4303 michael 912 if test -z "$pic_object" || test "$pic_object" = none ; then
4304     arg="$non_pic_object"
4305     fi
4306     else
4307     # If the PIC object exists, use it instead.
4308     # $xdir was prepended to $pic_object above.
4309     non_pic_object="$pic_object"
4310 michael 945 func_append non_pic_objects " $non_pic_object"
4311 michael 912 fi
4312     else
4313     # Only an error if not doing a dry-run.
4314 michael 945 if $opt_dry_run; then
4315 michael 912 # Extract subdirectory from the argument.
4316 michael 945 func_dirname "$arg" "/" ""
4317     xdir="$func_dirname_result"
4318 michael 912
4319 michael 945 func_lo2o "$arg"
4320     pic_object=$xdir$objdir/$func_lo2o_result
4321     non_pic_object=$xdir$func_lo2o_result
4322     func_append libobjs " $pic_object"
4323     func_append non_pic_objects " $non_pic_object"
4324     else
4325     func_fatal_error "\`$arg' is not a valid libtool object"
4326 michael 912 fi
4327     fi
4328     done
4329     else
4330 michael 945 func_fatal_error "link input file \`$arg' does not exist"
4331 michael 912 fi
4332     arg=$save_arg
4333     prev=
4334     continue
4335     ;;
4336 michael 945 precious_regex)
4337     precious_files_regex="$arg"
4338     prev=
4339     continue
4340     ;;
4341     release)
4342     release="-$arg"
4343     prev=
4344     continue
4345     ;;
4346 michael 912 rpath | xrpath)
4347     # We need an absolute path.
4348     case $arg in
4349     [\\/]* | [A-Za-z]:[\\/]*) ;;
4350     *)
4351 michael 945 func_fatal_error "only absolute run-paths are allowed"
4352 michael 912 ;;
4353     esac
4354     if test "$prev" = rpath; then
4355     case "$rpath " in
4356     *" $arg "*) ;;
4357     *) rpath="$rpath $arg" ;;
4358     esac
4359     else
4360     case "$xrpath " in
4361     *" $arg "*) ;;
4362     *) xrpath="$xrpath $arg" ;;
4363     esac
4364     fi
4365     prev=
4366     continue
4367     ;;
4368 michael 945 shrext)
4369     shrext_cmds="$arg"
4370 michael 912 prev=
4371     continue
4372     ;;
4373 michael 945 weak)
4374     weak_libs="$weak_libs $arg"
4375 michael 912 prev=
4376     continue
4377     ;;
4378     xcclinker)
4379     linker_flags="$linker_flags $qarg"
4380     compiler_flags="$compiler_flags $qarg"
4381     prev=
4382 michael 945 func_append compile_command " $qarg"
4383     func_append finalize_command " $qarg"
4384 michael 912 continue
4385     ;;
4386 michael 945 xcompiler)
4387     compiler_flags="$compiler_flags $qarg"
4388 michael 912 prev=
4389 michael 945 func_append compile_command " $qarg"
4390     func_append finalize_command " $qarg"
4391 michael 912 continue
4392     ;;
4393 michael 945 xlinker)
4394     linker_flags="$linker_flags $qarg"
4395     compiler_flags="$compiler_flags $wl$qarg"
4396 michael 912 prev=
4397 michael 945 func_append compile_command " $wl$qarg"
4398     func_append finalize_command " $wl$qarg"
4399 michael 912 continue
4400     ;;
4401     *)
4402     eval "$prev=\"\$arg\""
4403     prev=
4404     continue
4405     ;;
4406     esac
4407     fi # test -n "$prev"
4408    
4409     prevarg="$arg"
4410    
4411     case $arg in
4412     -all-static)
4413     if test -n "$link_static_flag"; then
4414 michael 945 # See comment for -static flag below, for more details.
4415     func_append compile_command " $link_static_flag"
4416     func_append finalize_command " $link_static_flag"
4417 michael 912 fi
4418     continue
4419     ;;
4420    
4421     -allow-undefined)
4422     # FIXME: remove this flag sometime in the future.
4423 michael 945 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4424 michael 912 ;;
4425    
4426     -avoid-version)
4427     avoid_version=yes
4428     continue
4429     ;;
4430    
4431     -dlopen)
4432     prev=dlfiles
4433     continue
4434     ;;
4435    
4436     -dlpreopen)
4437     prev=dlprefiles
4438     continue
4439     ;;
4440    
4441     -export-dynamic)
4442     export_dynamic=yes
4443     continue
4444     ;;
4445    
4446     -export-symbols | -export-symbols-regex)
4447     if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4448 michael 945 func_fatal_error "more than one -exported-symbols argument is not allowed"
4449 michael 912 fi
4450     if test "X$arg" = "X-export-symbols"; then
4451     prev=expsyms
4452     else
4453     prev=expsyms_regex
4454     fi
4455     continue
4456     ;;
4457    
4458 michael 945 -framework)
4459     prev=framework
4460 michael 912 continue
4461     ;;
4462    
4463     -inst-prefix-dir)
4464     prev=inst_prefix
4465     continue
4466     ;;
4467    
4468     # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4469     # so, if we see these flags be careful not to treat them like -L
4470     -L[A-Z][A-Z]*:*)
4471     case $with_gcc/$host in
4472     no/*-*-irix* | /*-*-irix*)
4473 michael 945 func_append compile_command " $arg"
4474     func_append finalize_command " $arg"
4475 michael 912 ;;
4476     esac
4477     continue
4478     ;;
4479    
4480     -L*)
4481 michael 945 func_stripname '-L' '' "$arg"
4482     dir=$func_stripname_result
4483     if test -z "$dir"; then
4484     if test "$#" -gt 0; then
4485     func_fatal_error "require no space between \`-L' and \`$1'"
4486     else
4487     func_fatal_error "need path for \`-L' option"
4488     fi
4489     fi
4490 michael 912 # We need an absolute path.
4491     case $dir in
4492     [\\/]* | [A-Za-z]:[\\/]*) ;;
4493     *)
4494     absdir=`cd "$dir" && pwd`
4495 michael 945 test -z "$absdir" && \
4496     func_fatal_error "cannot determine absolute directory name of \`$dir'"
4497 michael 912 dir="$absdir"
4498     ;;
4499     esac
4500     case "$deplibs " in
4501     *" -L$dir "*) ;;
4502     *)
4503     deplibs="$deplibs -L$dir"
4504     lib_search_path="$lib_search_path $dir"
4505     ;;
4506     esac
4507     case $host in
4508 michael 945 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4509     testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4510 michael 912 case :$dllsearchpath: in
4511     *":$dir:"*) ;;
4512 michael 945 ::) dllsearchpath=$dir;;
4513 michael 912 *) dllsearchpath="$dllsearchpath:$dir";;
4514     esac
4515     case :$dllsearchpath: in
4516     *":$testbindir:"*) ;;
4517 michael 945 ::) dllsearchpath=$testbindir;;
4518 michael 912 *) dllsearchpath="$dllsearchpath:$testbindir";;
4519     esac
4520     ;;
4521     esac
4522     continue
4523     ;;
4524    
4525     -l*)
4526     if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4527     case $host in
4528 michael 945 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4529 michael 912 # These systems don't actually have a C or math library (as such)
4530     continue
4531     ;;
4532     *-*-os2*)
4533     # These systems don't actually have a C library (as such)
4534     test "X$arg" = "X-lc" && continue
4535     ;;
4536     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4537     # Do not include libc due to us having libc/libc_r.
4538     test "X$arg" = "X-lc" && continue
4539     ;;
4540     *-*-rhapsody* | *-*-darwin1.[012])
4541     # Rhapsody C and math libraries are in the System framework
4542 michael 945 deplibs="$deplibs System.ltframework"
4543 michael 912 continue
4544     ;;
4545     *-*-sco3.2v5* | *-*-sco5v6*)
4546     # Causes problems with __ctype
4547     test "X$arg" = "X-lc" && continue
4548     ;;
4549     *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4550     # Compiler inserts libc in the correct place for threads to work
4551     test "X$arg" = "X-lc" && continue
4552     ;;
4553     esac
4554     elif test "X$arg" = "X-lc_r"; then
4555     case $host in
4556     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4557     # Do not include libc_r directly, use -pthread flag.
4558     continue
4559     ;;
4560     esac
4561     fi
4562     deplibs="$deplibs $arg"
4563     continue
4564     ;;
4565    
4566 michael 945 -module)
4567     module=yes
4568     continue
4569     ;;
4570    
4571 michael 912 # Tru64 UNIX uses -model [arg] to determine the layout of C++
4572     # classes, name mangling, and exception handling.
4573 michael 945 # Darwin uses the -arch flag to determine output architecture.
4574     -model|-arch|-isysroot)
4575 michael 912 compiler_flags="$compiler_flags $arg"
4576 michael 945 func_append compile_command " $arg"
4577     func_append finalize_command " $arg"
4578 michael 912 prev=xcompiler
4579     continue
4580     ;;
4581    
4582 michael 945 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4583 michael 912 compiler_flags="$compiler_flags $arg"
4584 michael 945 func_append compile_command " $arg"
4585     func_append finalize_command " $arg"
4586     case "$new_inherited_linker_flags " in
4587     *" $arg "*) ;;
4588     * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4589     esac
4590 michael 912 continue
4591     ;;
4592    
4593 michael 945 -multi_module)
4594     single_module="${wl}-multi_module"
4595 michael 912 continue
4596     ;;
4597    
4598     -no-fast-install)
4599     fast_install=no
4600     continue
4601     ;;
4602    
4603     -no-install)
4604     case $host in
4605 michael 945 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4606 michael 912 # The PATH hackery in wrapper scripts is required on Windows
4607     # and Darwin in order for the loader to find any dlls it needs.
4608 michael 945 func_warning "\`-no-install' is ignored for $host"
4609     func_warning "assuming \`-no-fast-install' instead"
4610 michael 912 fast_install=no
4611     ;;
4612     *) no_install=yes ;;
4613     esac
4614     continue
4615     ;;
4616    
4617     -no-undefined)
4618     allow_undefined=no
4619     continue
4620     ;;
4621    
4622     -objectlist)
4623     prev=objectlist
4624     continue
4625     ;;
4626    
4627     -o) prev=output ;;
4628    
4629     -precious-files-regex)
4630     prev=precious_regex
4631     continue
4632     ;;
4633    
4634     -release)
4635     prev=release
4636     continue
4637     ;;
4638    
4639     -rpath)
4640     prev=rpath
4641     continue
4642     ;;
4643    
4644     -R)
4645     prev=xrpath
4646     continue
4647     ;;
4648    
4649     -R*)
4650 michael 945 func_stripname '-R' '' "$arg"
4651     dir=$func_stripname_result
4652 michael 912 # We need an absolute path.
4653     case $dir in
4654     [\\/]* | [A-Za-z]:[\\/]*) ;;
4655     *)
4656 michael 945 func_fatal_error "only absolute run-paths are allowed"
4657 michael 912 ;;
4658     esac
4659     case "$xrpath " in
4660     *" $dir "*) ;;
4661     *) xrpath="$xrpath $dir" ;;
4662     esac
4663     continue
4664     ;;
4665    
4666 michael 945 -shared)
4667     # The effects of -shared are defined in a previous loop.
4668     continue
4669     ;;
4670    
4671     -shrext)
4672     prev=shrext
4673     continue
4674     ;;
4675    
4676 michael 912 -static | -static-libtool-libs)
4677     # The effects of -static are defined in a previous loop.
4678     # We used to do the same as -all-static on platforms that
4679     # didn't have a PIC flag, but the assumption that the effects
4680     # would be equivalent was wrong. It would break on at least
4681     # Digital Unix and AIX.
4682     continue
4683     ;;
4684    
4685     -thread-safe)
4686     thread_safe=yes
4687     continue
4688     ;;
4689    
4690     -version-info)
4691     prev=vinfo
4692     continue
4693     ;;
4694 michael 945
4695 michael 912 -version-number)
4696     prev=vinfo
4697     vinfo_number=yes
4698     continue
4699     ;;
4700    
4701 michael 945 -weak)
4702     prev=weak
4703     continue
4704     ;;
4705    
4706 michael 912 -Wc,*)
4707 michael 945 func_stripname '-Wc,' '' "$arg"
4708     args=$func_stripname_result
4709 michael 912 arg=
4710     save_ifs="$IFS"; IFS=','
4711     for flag in $args; do
4712     IFS="$save_ifs"
4713 michael 945 func_quote_for_eval "$flag"
4714     arg="$arg $wl$func_quote_for_eval_result"
4715     compiler_flags="$compiler_flags $func_quote_for_eval_result"
4716 michael 912 done
4717     IFS="$save_ifs"
4718 michael 945 func_stripname ' ' '' "$arg"
4719     arg=$func_stripname_result
4720 michael 912 ;;
4721    
4722     -Wl,*)
4723 michael 945 func_stripname '-Wl,' '' "$arg"
4724     args=$func_stripname_result
4725 michael 912 arg=
4726     save_ifs="$IFS"; IFS=','
4727     for flag in $args; do
4728     IFS="$save_ifs"
4729 michael 945 func_quote_for_eval "$flag"
4730     arg="$arg $wl$func_quote_for_eval_result"
4731     compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4732     linker_flags="$linker_flags $func_quote_for_eval_result"
4733 michael 912 done
4734     IFS="$save_ifs"
4735 michael 945 func_stripname ' ' '' "$arg"
4736     arg=$func_stripname_result
4737 michael 912 ;;
4738    
4739     -Xcompiler)
4740     prev=xcompiler
4741     continue
4742     ;;
4743    
4744     -Xlinker)
4745     prev=xlinker
4746     continue
4747     ;;
4748    
4749     -XCClinker)
4750     prev=xcclinker
4751     continue
4752     ;;
4753    
4754 michael 945 # -msg_* for osf cc
4755     -msg_*)
4756     func_quote_for_eval "$arg"
4757     arg="$func_quote_for_eval_result"
4758     ;;
4759    
4760     # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4761     # -r[0-9][0-9]* specifies the processor on the SGI compiler
4762     # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4763     # +DA*, +DD* enable 64-bit mode on the HP compiler
4764     # -q* pass through compiler args for the IBM compiler
4765     # -m*, -t[45]*, -txscale* pass through architecture-specific
4766     # compiler args for GCC
4767     # -F/path gives path to uninstalled frameworks, gcc on darwin
4768     # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4769     # @file GCC response files
4770     -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4771     -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4772     func_quote_for_eval "$arg"
4773     arg="$func_quote_for_eval_result"
4774     func_append compile_command " $arg"
4775     func_append finalize_command " $arg"
4776     compiler_flags="$compiler_flags $arg"
4777     continue
4778     ;;
4779    
4780 michael 912 # Some other compiler flag.
4781     -* | +*)
4782 michael 945 func_quote_for_eval "$arg"
4783     arg="$func_quote_for_eval_result"
4784 michael 912 ;;
4785    
4786     *.$objext)
4787     # A standard object.
4788     objs="$objs $arg"
4789     ;;
4790    
4791     *.lo)
4792     # A libtool-controlled object.
4793    
4794     # Check to see that this really is a libtool object.
4795 michael 945 if func_lalib_unsafe_p "$arg"; then
4796 michael 912 pic_object=
4797     non_pic_object=
4798    
4799     # Read the .lo file
4800 michael 945 func_source "$arg"
4801 michael 912
4802 michael 945 if test -z "$pic_object" ||
4803 michael 912 test -z "$non_pic_object" ||
4804 michael 945 test "$pic_object" = none &&
4805 michael 912 test "$non_pic_object" = none; then
4806 michael 945 func_fatal_error "cannot find name of object for \`$arg'"
4807 michael 912 fi
4808    
4809     # Extract subdirectory from the argument.
4810 michael 945 func_dirname "$arg" "/" ""
4811     xdir="$func_dirname_result"
4812 michael 912
4813     if test "$pic_object" != none; then
4814     # Prepend the subdirectory the object is found in.
4815     pic_object="$xdir$pic_object"
4816    
4817     if test "$prev" = dlfiles; then
4818     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4819     dlfiles="$dlfiles $pic_object"
4820     prev=
4821     continue
4822     else
4823     # If libtool objects are unsupported, then we need to preload.
4824     prev=dlprefiles
4825     fi
4826     fi
4827    
4828     # CHECK ME: I think I busted this. -Ossama
4829     if test "$prev" = dlprefiles; then
4830     # Preload the old-style object.
4831     dlprefiles="$dlprefiles $pic_object"
4832     prev=
4833     fi
4834    
4835     # A PIC object.
4836 michael 945 func_append libobjs " $pic_object"
4837 michael 912 arg="$pic_object"
4838     fi
4839    
4840     # Non-PIC object.
4841     if test "$non_pic_object" != none; then
4842     # Prepend the subdirectory the object is found in.
4843     non_pic_object="$xdir$non_pic_object"
4844    
4845     # A standard non-PIC object
4846 michael 945 func_append non_pic_objects " $non_pic_object"
4847 michael 912 if test -z "$pic_object" || test "$pic_object" = none ; then
4848     arg="$non_pic_object"
4849     fi
4850     else
4851     # If the PIC object exists, use it instead.
4852     # $xdir was prepended to $pic_object above.
4853     non_pic_object="$pic_object"
4854 michael 945 func_append non_pic_objects " $non_pic_object"
4855 michael 912 fi
4856     else
4857     # Only an error if not doing a dry-run.
4858 michael 945 if $opt_dry_run; then
4859 michael 912 # Extract subdirectory from the argument.
4860 michael 945 func_dirname "$arg" "/" ""
4861     xdir="$func_dirname_result"
4862 michael 912
4863 michael 945 func_lo2o "$arg"
4864     pic_object=$xdir$objdir/$func_lo2o_result
4865     non_pic_object=$xdir$func_lo2o_result
4866     func_append libobjs " $pic_object"
4867     func_append non_pic_objects " $non_pic_object"
4868     else
4869     func_fatal_error "\`$arg' is not a valid libtool object"
4870 michael 912 fi
4871     fi
4872     ;;
4873    
4874     *.$libext)
4875     # An archive.
4876     deplibs="$deplibs $arg"
4877     old_deplibs="$old_deplibs $arg"
4878     continue
4879     ;;
4880    
4881     *.la)
4882     # A libtool-controlled library.
4883    
4884     if test "$prev" = dlfiles; then
4885     # This library was specified with -dlopen.
4886     dlfiles="$dlfiles $arg"
4887     prev=
4888     elif test "$prev" = dlprefiles; then
4889     # The library was specified with -dlpreopen.
4890     dlprefiles="$dlprefiles $arg"
4891     prev=
4892     else
4893     deplibs="$deplibs $arg"
4894     fi
4895     continue
4896     ;;
4897    
4898     # Some other compiler argument.
4899     *)
4900     # Unknown arguments in both finalize_command and compile_command need
4901     # to be aesthetically quoted because they are evaled later.
4902 michael 945 func_quote_for_eval "$arg"
4903     arg="$func_quote_for_eval_result"
4904 michael 912 ;;
4905     esac # arg
4906    
4907     # Now actually substitute the argument into the commands.
4908     if test -n "$arg"; then
4909 michael 945 func_append compile_command " $arg"
4910     func_append finalize_command " $arg"
4911 michael 912 fi
4912     done # argument parsing loop
4913    
4914 michael 945 if test "$module" = yes ; then
4915     # [Mandriva] dropping ld option "--no-undefined" which is wrong for plugins
4916     linker_flags=`$ECHO "X $linker_flags" | $Xsed -e 's/ --no-undefined//'`
4917     compiler_flags=`$ECHO "X $compiler_flags" | $Xsed -e 's/ -Wl,--no-undefined//'`
4918 michael 912 fi
4919    
4920 michael 945 test -n "$prev" && \
4921     func_fatal_help "the \`$prevarg' option requires an argument"
4922    
4923 michael 912 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4924     eval arg=\"$export_dynamic_flag_spec\"
4925 michael 945 func_append compile_command " $arg"
4926     func_append finalize_command " $arg"
4927 michael 912 fi
4928    
4929     oldlibs=
4930     # calculate the name of the file, without its directory
4931 michael 945 func_basename "$output"
4932     outputname="$func_basename_result"
4933 michael 912 libobjs_save="$libobjs"
4934    
4935     if test -n "$shlibpath_var"; then
4936     # get the directories listed in $shlibpath_var
4937 michael 945 eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4938 michael 912 else
4939     shlib_search_path=
4940     fi
4941     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4942     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4943    
4944 michael 945 func_dirname "$output" "/" ""
4945     output_objdir="$func_dirname_result$objdir"
4946 michael 912 # Create the object directory.
4947 michael 945 func_mkdir_p "$output_objdir"
4948 michael 912
4949     # Determine the type of output
4950     case $output in
4951     "")
4952 michael 945 func_fatal_help "you must specify an output file"
4953 michael 912 ;;
4954     *.$libext) linkmode=oldlib ;;
4955     *.lo | *.$objext) linkmode=obj ;;
4956     *.la) linkmode=lib ;;
4957     *) linkmode=prog ;; # Anything else should be a program.
4958     esac
4959    
4960     specialdeplibs=
4961    
4962     libs=
4963     # Find all interdependent deplibs by searching for libraries
4964     # that are linked more than once (e.g. -la -lb -la)
4965     for deplib in $deplibs; do
4966 michael 945 if $opt_duplicate_deps ; then
4967 michael 912 case "$libs " in
4968     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4969     esac
4970     fi
4971     libs="$libs $deplib"
4972     done
4973    
4974     if test "$linkmode" = lib; then
4975     libs="$predeps $libs $compiler_lib_search_path $postdeps"
4976    
4977     # Compute libraries that are listed more than once in $predeps
4978     # $postdeps and mark them as special (i.e., whose duplicates are
4979     # not to be eliminated).
4980     pre_post_deps=
4981 michael 945 if $opt_duplicate_compiler_generated_deps; then
4982 michael 912 for pre_post_dep in $predeps $postdeps; do
4983     case "$pre_post_deps " in
4984     *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4985     esac
4986     pre_post_deps="$pre_post_deps $pre_post_dep"
4987     done
4988     fi
4989     pre_post_deps=
4990     fi
4991    
4992     deplibs=
4993     newdependency_libs=
4994     newlib_search_path=
4995     need_relink=no # whether we're linking any uninstalled libtool libraries
4996     notinst_deplibs= # not-installed libtool libraries
4997 michael 945 notinst_path= # paths that contain not-installed libtool libraries
4998    
4999 michael 912 case $linkmode in
5000     lib)
5001 michael 945 passes="conv dlpreopen link"
5002 michael 912 for file in $dlfiles $dlprefiles; do
5003     case $file in
5004     *.la) ;;
5005     *)
5006 michael 945 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5007 michael 912 ;;
5008     esac
5009     done
5010     ;;
5011     prog)
5012     compile_deplibs=
5013     finalize_deplibs=
5014     alldeplibs=no
5015     newdlfiles=
5016     newdlprefiles=
5017     passes="conv scan dlopen dlpreopen link"
5018     ;;
5019     *) passes="conv"
5020     ;;
5021     esac
5022 michael 945
5023 michael 912 for pass in $passes; do
5024 michael 945 # The preopen pass in lib mode reverses $deplibs; put it back here
5025     # so that -L comes before libs that need it for instance...
5026     if test "$linkmode,$pass" = "lib,link"; then
5027     ## FIXME: Find the place where the list is rebuilt in the wrong
5028     ## order, and fix it there properly
5029     tmp_deplibs=
5030     for deplib in $deplibs; do
5031     tmp_deplibs="$deplib $tmp_deplibs"
5032     done
5033     deplibs="$tmp_deplibs"
5034     fi
5035    
5036 michael 912 if test "$linkmode,$pass" = "lib,link" ||
5037     test "$linkmode,$pass" = "prog,scan"; then
5038     libs="$deplibs"
5039     deplibs=
5040     fi
5041     if test "$linkmode" = prog; then
5042     case $pass in
5043     dlopen) libs="$dlfiles" ;;
5044     dlpreopen) libs="$dlprefiles" ;;
5045 michael 945 link)
5046     libs="$deplibs %DEPLIBS%"
5047     test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
5048     ;;
5049 michael 912 esac
5050     fi
5051 michael 945 if test "$linkmode,$pass" = "lib,dlpreopen"; then
5052     # Collect and forward deplibs of preopened libtool libs
5053     for lib in $dlprefiles; do
5054     # Ignore non-libtool-libs
5055     dependency_libs=
5056     case $lib in
5057     *.la) func_source "$lib" ;;
5058     esac
5059    
5060     # Collect preopened libtool deplibs, except any this library
5061     # has declared as weak libs
5062     for deplib in $dependency_libs; do
5063     deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5064     case " $weak_libs " in
5065     *" $deplib_base "*) ;;
5066     *) deplibs="$deplibs $deplib" ;;
5067     esac
5068     done
5069     done
5070     libs="$dlprefiles"
5071     fi
5072 michael 912 if test "$pass" = dlopen; then
5073     # Collect dlpreopened libraries
5074     save_deplibs="$deplibs"
5075     deplibs=
5076     fi
5077 michael 945
5078 michael 912 for deplib in $libs; do
5079     lib=
5080     found=no
5081     case $deplib in
5082     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5083     if test "$linkmode,$pass" = "prog,link"; then
5084     compile_deplibs="$deplib $compile_deplibs"
5085     finalize_deplibs="$deplib $finalize_deplibs"
5086     else
5087     compiler_flags="$compiler_flags $deplib"
5088 michael 945 if test "$linkmode" = lib ; then
5089     case "$new_inherited_linker_flags " in
5090     *" $deplib "*) ;;
5091     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5092     esac
5093     fi
5094 michael 912 fi
5095     continue
5096     ;;
5097     -l*)
5098     if test "$linkmode" != lib && test "$linkmode" != prog; then
5099 michael 945 func_warning "\`-l' is ignored for archives/objects"
5100 michael 912 continue
5101     fi
5102 michael 945 func_stripname '-l' '' "$deplib"
5103     name=$func_stripname_result
5104     if test "$linkmode" = lib; then
5105     searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5106     else
5107     searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5108     fi
5109     for searchdir in $searchdirs; do
5110 michael 912 for search_ext in .la $std_shrext .so .a; do
5111     # Search the libtool library
5112     lib="$searchdir/lib${name}${search_ext}"
5113     if test -f "$lib"; then
5114     if test "$search_ext" = ".la"; then
5115     found=yes
5116     else
5117     found=no
5118     fi
5119     break 2
5120     fi
5121     done
5122     done
5123     if test "$found" != yes; then
5124     # deplib doesn't seem to be a libtool library
5125     if test "$linkmode,$pass" = "prog,link"; then
5126     compile_deplibs="$deplib $compile_deplibs"
5127     finalize_deplibs="$deplib $finalize_deplibs"
5128     else
5129     deplibs="$deplib $deplibs"
5130     test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5131     fi
5132     continue
5133     else # deplib is a libtool library
5134     # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5135     # We need to do some special things here, and not later.
5136     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5137     case " $predeps $postdeps " in
5138     *" $deplib "*)
5139 michael 945 if func_lalib_p "$lib"; then
5140 michael 912 library_names=
5141     old_library=
5142 michael 945 func_source "$lib"
5143 michael 912 for l in $old_library $library_names; do
5144     ll="$l"
5145     done
5146     if test "X$ll" = "X$old_library" ; then # only static version available
5147     found=no
5148 michael 945 func_dirname "$lib" "" "."
5149     ladir="$func_dirname_result"
5150 michael 912 lib=$ladir/$old_library
5151     if test "$linkmode,$pass" = "prog,link"; then
5152     compile_deplibs="$deplib $compile_deplibs"
5153     finalize_deplibs="$deplib $finalize_deplibs"
5154     else
5155     deplibs="$deplib $deplibs"
5156     test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5157     fi
5158     continue
5159     fi
5160     fi
5161 michael 945 ;;
5162 michael 912 *) ;;
5163     esac
5164     fi
5165     fi
5166     ;; # -l
5167 michael 945 *.ltframework)
5168     if test "$linkmode,$pass" = "prog,link"; then
5169     compile_deplibs="$deplib $compile_deplibs"
5170     finalize_deplibs="$deplib $finalize_deplibs"
5171     else
5172     deplibs="$deplib $deplibs"
5173     if test "$linkmode" = lib ; then
5174     case "$new_inherited_linker_flags " in
5175     *" $deplib "*) ;;
5176     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5177     esac
5178     fi
5179     fi
5180     continue
5181     ;;
5182 michael 912 -L*)
5183     case $linkmode in
5184     lib)
5185     deplibs="$deplib $deplibs"
5186     test "$pass" = conv && continue
5187     newdependency_libs="$deplib $newdependency_libs"
5188 michael 945 func_stripname '-L' '' "$deplib"
5189     newlib_search_path="$newlib_search_path $func_stripname_result"
5190 michael 912 ;;
5191     prog)
5192     if test "$pass" = conv; then
5193     deplibs="$deplib $deplibs"
5194     continue
5195     fi
5196     if test "$pass" = scan; then
5197     deplibs="$deplib $deplibs"
5198     else
5199     compile_deplibs="$deplib $compile_deplibs"
5200     finalize_deplibs="$deplib $finalize_deplibs"
5201     fi
5202 michael 945 func_stripname '-L' '' "$deplib"
5203     newlib_search_path="$newlib_search_path $func_stripname_result"
5204 michael 912 ;;
5205     *)
5206 michael 945 func_warning "\`-L' is ignored for archives/objects"
5207 michael 912 ;;
5208     esac # linkmode
5209     continue
5210     ;; # -L
5211     -R*)
5212     if test "$pass" = link; then
5213 michael 945 func_stripname '-R' '' "$deplib"
5214     dir=$func_stripname_result
5215 michael 912 # Make sure the xrpath contains only unique directories.
5216     case "$xrpath " in
5217     *" $dir "*) ;;
5218     *) xrpath="$xrpath $dir" ;;
5219     esac
5220     fi
5221     deplibs="$deplib $deplibs"
5222     continue
5223     ;;
5224     *.la) lib="$deplib" ;;
5225     *.$libext)
5226     if test "$pass" = conv; then
5227     deplibs="$deplib $deplibs"
5228     continue
5229     fi
5230     case $linkmode in
5231     lib)
5232 michael 945 # Linking convenience modules into shared libraries is allowed,
5233     # but linking other static libraries is non-portable.
5234     case " $dlpreconveniencelibs " in
5235     *" $deplib "*) ;;
5236     *)
5237     valid_a_lib=no
5238     case $deplibs_check_method in
5239     match_pattern*)
5240     set dummy $deplibs_check_method; shift
5241     match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5242     if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5243 michael 912 | $EGREP "$match_pattern_regex" > /dev/null; then
5244 michael 945 valid_a_lib=yes
5245     fi
5246     ;;
5247     pass_all)
5248 michael 912 valid_a_lib=yes
5249     ;;
5250 michael 945 esac
5251     if test "$valid_a_lib" != yes; then
5252     $ECHO
5253     $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5254     $ECHO "*** I have the capability to make that library automatically link in when"
5255     $ECHO "*** you link to this library. But I can only do this if you have a"
5256     $ECHO "*** shared version of the library, which you do not appear to have"
5257     $ECHO "*** because the file extensions .$libext of this argument makes me believe"
5258     $ECHO "*** that it is just a static archive that I should not use here."
5259     else
5260     $ECHO
5261     $ECHO "*** Warning: Linking the shared library $output against the"
5262     $ECHO "*** static library $deplib is not portable!"
5263     deplibs="$deplib $deplibs"
5264     fi
5265     ;;
5266     esac
5267 michael 912 continue
5268     ;;
5269     prog)
5270     if test "$pass" != link; then
5271     deplibs="$deplib $deplibs"
5272     else
5273     compile_deplibs="$deplib $compile_deplibs"
5274     finalize_deplibs="$deplib $finalize_deplibs"
5275     fi
5276     continue
5277     ;;
5278     esac # linkmode
5279     ;; # *.$libext
5280     *.lo | *.$objext)
5281     if test "$pass" = conv; then
5282     deplibs="$deplib $deplibs"
5283     elif test "$linkmode" = prog; then
5284     if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5285     # If there is no dlopen support or we're linking statically,
5286     # we need to preload.
5287     newdlprefiles="$newdlprefiles $deplib"
5288     compile_deplibs="$deplib $compile_deplibs"
5289     finalize_deplibs="$deplib $finalize_deplibs"
5290     else
5291     newdlfiles="$newdlfiles $deplib"
5292     fi
5293     fi
5294     continue
5295     ;;
5296     %DEPLIBS%)
5297     alldeplibs=yes
5298     continue
5299     ;;
5300     esac # case $deplib
5301 michael 945
5302 michael 912 if test "$found" = yes || test -f "$lib"; then :
5303     else
5304 michael 945 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5305 michael 912 fi
5306    
5307     # Check to see that this really is a libtool archive.
5308 michael 945 func_lalib_unsafe_p "$lib" \
5309     || func_fatal_error "\`$lib' is not a valid libtool archive"
5310 michael 912
5311 michael 945 func_dirname "$lib" "" "."
5312     ladir="$func_dirname_result"
5313 michael 912
5314     dlname=
5315     dlopen=
5316     dlpreopen=
5317     libdir=
5318     library_names=
5319     old_library=
5320 michael 945 inherited_linker_flags=
5321 michael 912 # If the library was installed with an old release of libtool,
5322     # it will not redefine variables installed, or shouldnotlink
5323     installed=yes
5324     shouldnotlink=no
5325     avoidtemprpath=
5326    
5327    
5328     # Read the .la file
5329 michael 945 func_source "$lib"
5330 michael 912
5331 michael 945 # Convert "-framework foo" to "foo.ltframework"
5332     if test -n "$inherited_linker_flags"; then
5333     tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5334     for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5335     case " $new_inherited_linker_flags " in
5336     *" $tmp_inherited_linker_flag "*) ;;
5337     *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5338     esac
5339     done
5340     fi
5341     dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5342 michael 912 if test "$linkmode,$pass" = "lib,link" ||
5343     test "$linkmode,$pass" = "prog,scan" ||
5344     { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5345     test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5346     test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5347     fi
5348    
5349     if test "$pass" = conv; then
5350     # Only check for convenience libraries
5351     deplibs="$lib $deplibs"
5352     if test -z "$libdir"; then
5353     if test -z "$old_library"; then
5354 michael 945 func_fatal_error "cannot find name of link library for \`$lib'"
5355 michael 912 fi
5356     # It is a libtool convenience library, so add in its objects.
5357     convenience="$convenience $ladir/$objdir/$old_library"
5358     old_convenience="$old_convenience $ladir/$objdir/$old_library"
5359     elif test "$linkmode" != prog && test "$linkmode" != lib; then
5360 michael 945 func_fatal_error "\`$lib' is not a convenience library"
5361 michael 912 fi
5362 michael 945 tmp_libs=
5363     for deplib in $dependency_libs; do
5364     deplibs="$deplib $deplibs"
5365     if $opt_duplicate_deps ; then
5366     case "$tmp_libs " in
5367     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5368     esac
5369     fi
5370     tmp_libs="$tmp_libs $deplib"
5371     done
5372 michael 912 continue
5373     fi # $pass = conv
5374    
5375    
5376     # Get the name of the library we link against.
5377     linklib=
5378     for l in $old_library $library_names; do
5379     linklib="$l"
5380     done
5381     if test -z "$linklib"; then
5382 michael 945 func_fatal_error "cannot find name of link library for \`$lib'"
5383 michael 912 fi
5384    
5385     # This library was specified with -dlopen.
5386     if test "$pass" = dlopen; then
5387     if test -z "$libdir"; then
5388 michael 945 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5389 michael 912 fi
5390     if test -z "$dlname" ||
5391     test "$dlopen_support" != yes ||
5392     test "$build_libtool_libs" = no; then
5393     # If there is no dlname, no dlopen support or we're linking
5394     # statically, we need to preload. We also need to preload any
5395     # dependent libraries so libltdl's deplib preloader doesn't
5396     # bomb out in the load deplibs phase.
5397     dlprefiles="$dlprefiles $lib $dependency_libs"
5398     else
5399     newdlfiles="$newdlfiles $lib"
5400     fi
5401     continue
5402     fi # $pass = dlopen
5403    
5404     # We need an absolute path.
5405     case $ladir in
5406     [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5407     *)
5408     abs_ladir=`cd "$ladir" && pwd`
5409     if test -z "$abs_ladir"; then
5410 michael 945 func_warning "cannot determine absolute directory name of \`$ladir'"
5411     func_warning "passing it literally to the linker, although it might fail"
5412 michael 912 abs_ladir="$ladir"
5413     fi
5414     ;;
5415     esac
5416 michael 945 func_basename "$lib"
5417     laname="$func_basename_result"
5418 michael 912
5419     # Find the relevant object directory and library name.
5420     if test "X$installed" = Xyes; then
5421     if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5422 michael 945 func_warning "library \`$lib' was moved."
5423 michael 912 dir="$ladir"
5424     absdir="$abs_ladir"
5425     libdir="$abs_ladir"
5426     else
5427     dir="$libdir"
5428     absdir="$libdir"
5429     fi
5430     test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5431     else
5432     if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5433     dir="$ladir"
5434     absdir="$abs_ladir"
5435     # Remove this search path later
5436     notinst_path="$notinst_path $abs_ladir"
5437     else
5438     dir="$ladir/$objdir"
5439     absdir="$abs_ladir/$objdir"
5440     # Remove this search path later
5441     notinst_path="$notinst_path $abs_ladir"
5442     fi
5443     fi # $installed = yes
5444 michael 945 func_stripname 'lib' '.la' "$laname"
5445     name=$func_stripname_result
5446 michael 912
5447     # This library was specified with -dlpreopen.
5448     if test "$pass" = dlpreopen; then
5449 michael 945 if test -z "$libdir" && test "$linkmode" = prog; then
5450     func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5451 michael 912 fi
5452     # Prefer using a static library (so that no silly _DYNAMIC symbols
5453     # are required to link).
5454     if test -n "$old_library"; then
5455     newdlprefiles="$newdlprefiles $dir/$old_library"
5456 michael 945 # Keep a list of preopened convenience libraries to check
5457     # that they are being used correctly in the link pass.
5458     test -z "$libdir" && \
5459     dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5460 michael 912 # Otherwise, use the dlname, so that lt_dlopen finds it.
5461     elif test -n "$dlname"; then
5462     newdlprefiles="$newdlprefiles $dir/$dlname"
5463     else
5464     newdlprefiles="$newdlprefiles $dir/$linklib"
5465     fi
5466     fi # $pass = dlpreopen
5467    
5468     if test -z "$libdir"; then
5469     # Link the convenience library
5470     if test "$linkmode" = lib; then
5471     deplibs="$dir/$old_library $deplibs"
5472     elif test "$linkmode,$pass" = "prog,link"; then
5473     compile_deplibs="$dir/$old_library $compile_deplibs"
5474     finalize_deplibs="$dir/$old_library $finalize_deplibs"
5475     else
5476     deplibs="$lib $deplibs" # used for prog,scan pass
5477     fi
5478     continue
5479     fi
5480    
5481    
5482     if test "$linkmode" = prog && test "$pass" != link; then
5483     newlib_search_path="$newlib_search_path $ladir"
5484     deplibs="$lib $deplibs"
5485    
5486     linkalldeplibs=no
5487     if test "$link_all_deplibs" != no || test -z "$library_names" ||
5488     test "$build_libtool_libs" = no; then
5489     linkalldeplibs=yes
5490     fi
5491    
5492     tmp_libs=
5493     for deplib in $dependency_libs; do
5494     case $deplib in
5495 michael 945 -L*) func_stripname '-L' '' "$deplib"
5496     newlib_search_path="$newlib_search_path $func_stripname_result"
5497     ;;
5498 michael 912 esac
5499     # Need to link against all dependency_libs?
5500     if test "$linkalldeplibs" = yes; then
5501     deplibs="$deplib $deplibs"
5502     else
5503     # Need to hardcode shared library paths
5504     # or/and link against static libraries
5505     newdependency_libs="$deplib $newdependency_libs"
5506     fi
5507 michael 945 if $opt_duplicate_deps ; then
5508 michael 912 case "$tmp_libs " in
5509     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5510     esac
5511     fi
5512     tmp_libs="$tmp_libs $deplib"
5513     done # for deplib
5514     continue
5515     fi # $linkmode = prog...
5516    
5517     if test "$linkmode,$pass" = "prog,link"; then
5518     if test -n "$library_names" &&
5519     { { test "$prefer_static_libs" = no ||
5520 michael 945 test "$prefer_static_libs,$installed" = "built,yes"; } ||
5521 michael 912 test -z "$old_library"; }; then
5522     # We need to hardcode the library path
5523     if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5524     # Make sure the rpath contains only unique directories.
5525 michael 945 case "$temp_rpath:" in
5526     *"$absdir:"*) ;;
5527     *) temp_rpath="$temp_rpath$absdir:" ;;
5528 michael 912 esac
5529     fi
5530    
5531     # Hardcode the library path.
5532     # Skip directories that are in the system default run-time
5533     # search path.
5534     case " $sys_lib_dlsearch_path " in
5535     *" $absdir "*) ;;
5536     *)
5537     case "$compile_rpath " in
5538     *" $absdir "*) ;;
5539     *) compile_rpath="$compile_rpath $absdir"
5540     esac
5541     ;;
5542     esac
5543     case " $sys_lib_dlsearch_path " in
5544     *" $libdir "*) ;;
5545     *)
5546     case "$finalize_rpath " in
5547     *" $libdir "*) ;;
5548     *) finalize_rpath="$finalize_rpath $libdir"
5549     esac
5550     ;;
5551     esac
5552     fi # $linkmode,$pass = prog,link...
5553    
5554     if test "$alldeplibs" = yes &&
5555     { test "$deplibs_check_method" = pass_all ||
5556     { test "$build_libtool_libs" = yes &&
5557     test -n "$library_names"; }; }; then
5558     # We only need to search for static libraries
5559     continue
5560     fi
5561     fi
5562    
5563     link_static=no # Whether the deplib will be linked statically
5564     use_static_libs=$prefer_static_libs
5565 michael 945 if test "$use_static_libs" = built && test "$installed" = yes; then
5566 michael 912 use_static_libs=no
5567     fi
5568     if test -n "$library_names" &&
5569     { test "$use_static_libs" = no || test -z "$old_library"; }; then
5570 michael 945 case $host in
5571     *cygwin* | *mingw* | *cegcc*)
5572     # No point in relinking DLLs because paths are not encoded
5573     notinst_deplibs="$notinst_deplibs $lib"
5574     need_relink=no
5575     ;;
5576     *)
5577     if test "$installed" = no; then
5578     notinst_deplibs="$notinst_deplibs $lib"
5579     need_relink=yes
5580     fi
5581     ;;
5582     esac
5583 michael 912 # This is a shared library
5584    
5585 michael 945 # Warn about portability, can't link against -module's on some
5586     # systems (darwin). Don't bleat about dlopened modules though!
5587     dlopenmodule=""
5588     for dlpremoduletest in $dlprefiles; do
5589     if test "X$dlpremoduletest" = "X$lib"; then
5590     dlopenmodule="$dlpremoduletest"
5591     break
5592     fi
5593     done
5594     if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5595     $ECHO
5596 michael 912 if test "$linkmode" = prog; then
5597 michael 945 $ECHO "*** Warning: Linking the executable $output against the loadable module"
5598 michael 912 else
5599 michael 945 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5600 michael 912 fi
5601 michael 945 $ECHO "*** $linklib is not portable!"
5602 michael 912 fi
5603     if test "$linkmode" = lib &&
5604     test "$hardcode_into_libs" = yes; then
5605     # Hardcode the library path.
5606     # Skip directories that are in the system default run-time
5607     # search path.
5608     case " $sys_lib_dlsearch_path " in
5609     *" $absdir "*) ;;
5610     *)
5611     case "$compile_rpath " in
5612     *" $absdir "*) ;;
5613     *) compile_rpath="$compile_rpath $absdir"
5614     esac
5615     ;;
5616     esac
5617     case " $sys_lib_dlsearch_path " in
5618     *" $libdir "*) ;;
5619     *)
5620     case "$finalize_rpath " in
5621     *" $libdir "*) ;;
5622     *) finalize_rpath="$finalize_rpath $libdir"
5623     esac
5624     ;;
5625     esac
5626     fi
5627    
5628     if test -n "$old_archive_from_expsyms_cmds"; then
5629     # figure out the soname
5630     set dummy $library_names
5631 michael 945 shift
5632     realname="$1"
5633     shift
5634     libname=`eval "\\$ECHO \"$libname_spec\""`
5635 michael 912 # use dlname if we got it. it's perfectly good, no?
5636     if test -n "$dlname"; then
5637     soname="$dlname"
5638     elif test -n "$soname_spec"; then
5639     # bleh windows
5640     case $host in
5641 michael 945 *cygwin* | mingw* | *cegcc*)
5642     func_arith $current - $age
5643     major=$func_arith_result
5644 michael 912 versuffix="-$major"
5645     ;;
5646     esac
5647     eval soname=\"$soname_spec\"
5648     else
5649     soname="$realname"
5650     fi
5651    
5652     # Make a new name for the extract_expsyms_cmds to use
5653     soroot="$soname"
5654 michael 945 func_basename "$soroot"
5655     soname="$func_basename_result"
5656     func_stripname 'lib' '.dll' "$soname"
5657     newlib=libimp-$func_stripname_result.a
5658 michael 912
5659     # If the library has no export list, then create one now
5660     if test -f "$output_objdir/$soname-def"; then :
5661     else
5662 michael 945 func_verbose "extracting exported symbol list from \`$soname'"
5663     func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5664 michael 912 fi
5665    
5666     # Create $newlib
5667     if test -f "$output_objdir/$newlib"; then :; else
5668 michael 945 func_verbose "generating import library for \`$soname'"
5669     func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5670 michael 912 fi
5671     # make sure the library variables are pointing to the new library
5672     dir=$output_objdir
5673     linklib=$newlib
5674     fi # test -n "$old_archive_from_expsyms_cmds"
5675    
5676     if test "$linkmode" = prog || test "$mode" != relink; then
5677     add_shlibpath=
5678     add_dir=
5679     add=
5680     lib_linked=yes
5681     case $hardcode_action in
5682     immediate | unsupported)
5683     if test "$hardcode_direct" = no; then
5684     add="$dir/$linklib"
5685     case $host in
5686     *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5687     *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5688     *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5689     *-*-unixware7*) add_dir="-L$dir" ;;
5690     *-*-darwin* )
5691 michael 945 # if the lib is a (non-dlopened) module then we can not
5692     # link against it, someone is ignoring the earlier warnings
5693 michael 912 if /usr/bin/file -L $add 2> /dev/null |
5694 michael 945 $GREP ": [^:]* bundle" >/dev/null ; then
5695     if test "X$dlopenmodule" != "X$lib"; then
5696     $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5697     if test -z "$old_library" ; then
5698     $ECHO
5699     $ECHO "*** And there doesn't seem to be a static archive available"
5700     $ECHO "*** The link will probably fail, sorry"
5701     else
5702     add="$dir/$old_library"
5703     fi
5704     elif test -n "$old_library"; then
5705     add="$dir/$old_library"
5706 michael 912 fi
5707     fi
5708     esac
5709     elif test "$hardcode_minus_L" = no; then
5710     case $host in
5711     *-*-sunos*) add_shlibpath="$dir" ;;
5712     esac
5713     add_dir="-L$dir"
5714     add="-l$name"
5715     elif test "$hardcode_shlibpath_var" = no; then
5716     add_shlibpath="$dir"
5717     add="-l$name"
5718     else
5719     lib_linked=no
5720     fi
5721     ;;
5722     relink)
5723 michael 945 if test "$hardcode_direct" = yes &&
5724     test "$hardcode_direct_absolute" = no; then
5725 michael 912 add="$dir/$linklib"
5726     elif test "$hardcode_minus_L" = yes; then
5727     add_dir="-L$dir"
5728     # Try looking first in the location we're being installed to.
5729     if test -n "$inst_prefix_dir"; then
5730     case $libdir in
5731     [\\/]*)
5732     add_dir="$add_dir -L$inst_prefix_dir$libdir"
5733     ;;
5734     esac
5735     fi
5736     add="-l$name"
5737     elif test "$hardcode_shlibpath_var" = yes; then
5738     add_shlibpath="$dir"
5739     add="-l$name"
5740     else
5741     lib_linked=no
5742     fi
5743     ;;
5744     *) lib_linked=no ;;
5745     esac
5746    
5747     if test "$lib_linked" != yes; then
5748 michael 945 func_fatal_configuration "unsupported hardcode properties"
5749 michael 912 fi
5750    
5751     if test -n "$add_shlibpath"; then
5752     case :$compile_shlibpath: in
5753     *":$add_shlibpath:"*) ;;
5754     *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5755     esac
5756     fi
5757     if test "$linkmode" = prog; then
5758     test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5759     test -n "$add" && compile_deplibs="$add $compile_deplibs"
5760     else
5761     test -n "$add_dir" && deplibs="$add_dir $deplibs"
5762     test -n "$add" && deplibs="$add $deplibs"
5763 michael 945 if test "$hardcode_direct" != yes &&
5764     test "$hardcode_minus_L" != yes &&
5765 michael 912 test "$hardcode_shlibpath_var" = yes; then
5766     case :$finalize_shlibpath: in
5767     *":$libdir:"*) ;;
5768     *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5769     esac
5770     fi
5771     fi
5772     fi
5773    
5774     if test "$linkmode" = prog || test "$mode" = relink; then
5775     add_shlibpath=
5776     add_dir=
5777     add=
5778     # Finalize command for both is simple: just hardcode it.
5779 michael 945 if test "$hardcode_direct" = yes &&
5780     test "$hardcode_direct_absolute" = no; then
5781 michael 912 add="$libdir/$linklib"
5782     elif test "$hardcode_minus_L" = yes; then
5783     add_dir="-L$libdir"
5784     add="-l$name"
5785     elif test "$hardcode_shlibpath_var" = yes; then
5786     case :$finalize_shlibpath: in
5787     *":$libdir:"*) ;;
5788     *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5789     esac
5790     add="-l$name"
5791     elif test "$hardcode_automatic" = yes; then
5792     if test -n "$inst_prefix_dir" &&
5793     test -f "$inst_prefix_dir$libdir/$linklib" ; then
5794 michael 945 add="$inst_prefix_dir$libdir/$linklib"
5795 michael 912 else
5796 michael 945 add="$libdir/$linklib"
5797 michael 912 fi
5798     else
5799     # We cannot seem to hardcode it, guess we'll fake it.
5800     add_dir="-L$libdir"
5801     # Try looking first in the location we're being installed to.
5802     if test -n "$inst_prefix_dir"; then
5803     case $libdir in
5804     [\\/]*)
5805     add_dir="$add_dir -L$inst_prefix_dir$libdir"
5806     ;;
5807     esac
5808     fi
5809     add="-l$name"
5810     fi
5811    
5812     if test "$linkmode" = prog; then
5813     test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5814     test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5815     else
5816     test -n "$add_dir" && deplibs="$add_dir $deplibs"
5817     test -n "$add" && deplibs="$add $deplibs"
5818     fi
5819     fi
5820     elif test "$linkmode" = prog; then
5821     # Here we assume that one of hardcode_direct or hardcode_minus_L
5822     # is not unsupported. This is valid on all known static and
5823     # shared platforms.
5824     if test "$hardcode_direct" != unsupported; then
5825     test -n "$old_library" && linklib="$old_library"
5826     compile_deplibs="$dir/$linklib $compile_deplibs"
5827     finalize_deplibs="$dir/$linklib $finalize_deplibs"
5828     else
5829     compile_deplibs="-l$name -L$dir $compile_deplibs"
5830     finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5831     fi
5832     elif test "$build_libtool_libs" = yes; then
5833     # Not a shared library
5834     if test "$deplibs_check_method" != pass_all; then
5835     # We're trying link a shared library against a static one
5836     # but the system doesn't support it.
5837    
5838     # Just print a warning and add the library to dependency_libs so
5839     # that the program can be linked against the static library.
5840 michael 945 $ECHO
5841     $ECHO "*** Warning: This system can not link to static lib archive $lib."
5842     $ECHO "*** I have the capability to make that library automatically link in when"
5843     $ECHO "*** you link to this library. But I can only do this if you have a"
5844     $ECHO "*** shared version of the library, which you do not appear to have."
5845 michael 912 if test "$module" = yes; then
5846 michael 945 $ECHO "*** But as you try to build a module library, libtool will still create "
5847     $ECHO "*** a static module, that should work as long as the dlopening application"
5848     $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5849 michael 912 if test -z "$global_symbol_pipe"; then
5850 michael 945 $ECHO
5851     $ECHO "*** However, this would only work if libtool was able to extract symbol"
5852     $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5853     $ECHO "*** not find such a program. So, this module is probably useless."
5854     $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5855 michael 912 fi
5856     if test "$build_old_libs" = no; then
5857     build_libtool_libs=module
5858     build_old_libs=yes
5859     else
5860     build_libtool_libs=no
5861     fi
5862     fi
5863     else
5864     deplibs="$dir/$old_library $deplibs"
5865     link_static=yes
5866     fi
5867     fi # link shared/static library?
5868    
5869     if test "$linkmode" = lib; then
5870     if test -n "$dependency_libs" &&
5871     { test "$hardcode_into_libs" != yes ||
5872     test "$build_old_libs" = yes ||
5873     test "$link_static" = yes; }; then
5874     # Extract -R from dependency_libs
5875     temp_deplibs=
5876     for libdir in $dependency_libs; do
5877     case $libdir in
5878 michael 945 -R*) func_stripname '-R' '' "$libdir"
5879     temp_xrpath=$func_stripname_result
5880 michael 912 case " $xrpath " in
5881     *" $temp_xrpath "*) ;;
5882     *) xrpath="$xrpath $temp_xrpath";;
5883     esac;;
5884     *) temp_deplibs="$temp_deplibs $libdir";;
5885     esac
5886     done
5887     dependency_libs="$temp_deplibs"
5888     fi
5889    
5890     newlib_search_path="$newlib_search_path $absdir"
5891     # Link against this library
5892     test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5893     # ... and its dependency_libs
5894     tmp_libs=
5895     for deplib in $dependency_libs; do
5896     newdependency_libs="$deplib $newdependency_libs"
5897 michael 945 if $opt_duplicate_deps ; then
5898 michael 912 case "$tmp_libs " in
5899     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5900     esac
5901     fi
5902     tmp_libs="$tmp_libs $deplib"
5903     done
5904    
5905     if test "$link_all_deplibs" != no; then
5906     # Add the search paths of all dependency libraries
5907     for deplib in $dependency_libs; do
5908     case $deplib in
5909     -L*) path="$deplib" ;;
5910     *.la)
5911 michael 945 func_dirname "$deplib" "" "."
5912     dir="$func_dirname_result"
5913 michael 912 # We need an absolute path.
5914     case $dir in
5915     [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5916     *)
5917     absdir=`cd "$dir" && pwd`
5918     if test -z "$absdir"; then
5919 michael 945 func_warning "cannot determine absolute directory name of \`$dir'"
5920 michael 912 absdir="$dir"
5921     fi
5922     ;;
5923     esac
5924 michael 945 if $GREP "^installed=no" $deplib > /dev/null; then
5925 michael 912 case $host in
5926     *-*-darwin*)
5927 michael 945 depdepl=
5928 michael 912 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5929     if test -n "$deplibrary_names" ; then
5930     for tmp in $deplibrary_names ; do
5931     depdepl=$tmp
5932     done
5933 michael 945 if test -f "$absdir/$objdir/$depdepl" ; then
5934     depdepl="$absdir/$objdir/$depdepl"
5935     darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5936     if test -z "$darwin_install_name"; then
5937     darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5938     fi
5939     compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5940     linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5941     path=
5942 michael 912 fi
5943     fi
5944     ;;
5945     *)
5946 michael 945 path="-L$absdir/$objdir"
5947 michael 912 ;;
5948     esac
5949 michael 945 else
5950     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5951     test -z "$libdir" && \
5952     func_fatal_error "\`$deplib' is not a valid libtool archive"
5953     test "$absdir" != "$libdir" && \
5954     func_warning "\`$deplib' seems to be moved"
5955    
5956     path="-L$absdir"
5957     fi
5958 michael 912 ;;
5959     esac
5960     case " $deplibs " in
5961     *" $path "*) ;;
5962     *) deplibs="$path $deplibs" ;;
5963     esac
5964     done
5965     fi # link_all_deplibs != no
5966     fi # linkmode = lib
5967     done # for deplib in $libs
5968 michael 945 if test "$pass" = link; then
5969     if test "$linkmode" = "prog"; then
5970     compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5971     finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5972     else
5973     compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5974     fi
5975     fi
5976 michael 912 dependency_libs="$newdependency_libs"
5977     if test "$pass" = dlpreopen; then
5978     # Link the dlpreopened libraries before other libraries
5979     for deplib in $save_deplibs; do
5980     deplibs="$deplib $deplibs"
5981     done
5982     fi
5983     if test "$pass" != dlopen; then
5984     if test "$pass" != conv; then
5985     # Make sure lib_search_path contains only unique directories.
5986     lib_search_path=
5987     for dir in $newlib_search_path; do
5988     case "$lib_search_path " in
5989     *" $dir "*) ;;
5990     *) lib_search_path="$lib_search_path $dir" ;;
5991     esac
5992     done
5993     newlib_search_path=
5994     fi
5995    
5996     if test "$linkmode,$pass" != "prog,link"; then
5997     vars="deplibs"
5998     else
5999     vars="compile_deplibs finalize_deplibs"
6000     fi
6001     for var in $vars dependency_libs; do
6002     # Add libraries to $var in reverse order
6003     eval tmp_libs=\"\$$var\"
6004     new_libs=
6005     for deplib in $tmp_libs; do
6006     # FIXME: Pedantically, this is the right thing to do, so
6007     # that some nasty dependency loop isn't accidentally
6008     # broken:
6009     #new_libs="$deplib $new_libs"
6010     # Pragmatically, this seems to cause very few problems in
6011     # practice:
6012     case $deplib in
6013     -L*) new_libs="$deplib $new_libs" ;;
6014     -R*) ;;
6015     *)
6016     # And here is the reason: when a library appears more
6017     # than once as an explicit dependence of a library, or
6018     # is implicitly linked in more than once by the
6019     # compiler, it is considered special, and multiple
6020     # occurrences thereof are not removed. Compare this
6021     # with having the same library being listed as a
6022     # dependency of multiple other libraries: in this case,
6023     # we know (pedantically, we assume) the library does not
6024     # need to be listed more than once, so we keep only the
6025     # last copy. This is not always right, but it is rare
6026     # enough that we require users that really mean to play
6027     # such unportable linking tricks to link the library
6028     # using -Wl,-lname, so that libtool does not consider it
6029     # for duplicate removal.
6030     case " $specialdeplibs " in
6031     *" $deplib "*) new_libs="$deplib $new_libs" ;;
6032     *)
6033     case " $new_libs " in
6034     *" $deplib "*) ;;
6035     *) new_libs="$deplib $new_libs" ;;
6036     esac
6037     ;;
6038     esac
6039     ;;
6040     esac
6041     done
6042     tmp_libs=
6043     for deplib in $new_libs; do
6044     case $deplib in
6045     -L*)
6046     case " $tmp_libs " in
6047     *" $deplib "*) ;;
6048     *) tmp_libs="$tmp_libs $deplib" ;;
6049     esac
6050     ;;
6051     *) tmp_libs="$tmp_libs $deplib" ;;
6052     esac
6053     done
6054     eval $var=\"$tmp_libs\"
6055     done # for var
6056     fi
6057     # Last step: remove runtime libs from dependency_libs
6058     # (they stay in deplibs)
6059     tmp_libs=
6060     for i in $dependency_libs ; do
6061     case " $predeps $postdeps $compiler_lib_search_path " in
6062     *" $i "*)
6063     i=""
6064     ;;
6065     esac
6066     if test -n "$i" ; then
6067     tmp_libs="$tmp_libs $i"
6068     fi
6069     done
6070     dependency_libs=$tmp_libs
6071     done # for pass
6072     if test "$linkmode" = prog; then
6073     dlfiles="$newdlfiles"
6074 michael 945 fi
6075     if test "$linkmode" = prog || test "$linkmode" = lib; then
6076 michael 912 dlprefiles="$newdlprefiles"
6077     fi
6078    
6079     case $linkmode in
6080     oldlib)
6081     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6082 michael 945 func_warning "\`-dlopen' is ignored for archives"
6083 michael 912 fi
6084    
6085 michael 945 case " $deplibs" in
6086     *\ -l* | *\ -L*)
6087     func_warning "\`-l' and \`-L' are ignored for archives" ;;
6088     esac
6089 michael 912
6090 michael 945 test -n "$rpath" && \
6091     func_warning "\`-rpath' is ignored for archives"
6092 michael 912
6093 michael 945 test -n "$xrpath" && \
6094     func_warning "\`-R' is ignored for archives"
6095 michael 912
6096 michael 945 test -n "$vinfo" && \
6097     func_warning "\`-version-info/-version-number' is ignored for archives"
6098 michael 912
6099 michael 945 test -n "$release" && \
6100     func_warning "\`-release' is ignored for archives"
6101 michael 912
6102 michael 945 test -n "$export_symbols$export_symbols_regex" && \
6103     func_warning "\`-export-symbols' is ignored for archives"
6104    
6105 michael 912 # Now set the variables for building old libraries.
6106     build_libtool_libs=no
6107     oldlibs="$output"
6108     objs="$objs$old_deplibs"
6109     ;;
6110    
6111     lib)
6112     # Make sure we only generate libraries of the form `libNAME.la'.
6113     case $outputname in
6114     lib*)
6115 michael 945 func_stripname 'lib' '.la' "$outputname"
6116     name=$func_stripname_result
6117 michael 912 eval shared_ext=\"$shrext_cmds\"
6118     eval libname=\"$libname_spec\"
6119     ;;
6120     *)
6121 michael 945 test "$module" = no && \
6122     func_fatal_help "libtool library \`$output' must begin with \`lib'"
6123    
6124 michael 912 if test "$need_lib_prefix" != no; then
6125     # Add the "lib" prefix for modules if required
6126 michael 945 func_stripname '' '.la' "$outputname"
6127     name=$func_stripname_result
6128 michael 912 eval shared_ext=\"$shrext_cmds\"
6129     eval libname=\"$libname_spec\"
6130     else
6131 michael 945 func_stripname '' '.la' "$outputname"
6132     libname=$func_stripname_result
6133 michael 912 fi
6134     ;;
6135     esac
6136    
6137     if test -n "$objs"; then
6138     if test "$deplibs_check_method" != pass_all; then
6139 michael 945 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6140 michael 912 else
6141 michael 945 $ECHO
6142     $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6143     $ECHO "*** objects $objs is not portable!"
6144 michael 912 libobjs="$libobjs $objs"
6145     fi
6146     fi
6147    
6148 michael 945 test "$dlself" != no && \
6149     func_warning "\`-dlopen self' is ignored for libtool libraries"
6150 michael 912
6151     set dummy $rpath
6152 michael 945 shift
6153     test "$#" -gt 1 && \
6154     func_warning "ignoring multiple \`-rpath's for a libtool library"
6155 michael 912
6156 michael 945 install_libdir="$1"
6157    
6158 michael 912 oldlibs=
6159     if test -z "$rpath"; then
6160     if test "$build_libtool_libs" = yes; then
6161     # Building a libtool convenience library.
6162     # Some compilers have problems with a `.al' extension so
6163     # convenience libraries should have the same extension an
6164     # archive normally would.
6165     oldlibs="$output_objdir/$libname.$libext $oldlibs"
6166     build_libtool_libs=convenience
6167     build_old_libs=yes
6168     fi
6169    
6170 michael 945 test -n "$vinfo" && \
6171     func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6172 michael 912
6173 michael 945 test -n "$release" && \
6174     func_warning "\`-release' is ignored for convenience libraries"
6175 michael 912 else
6176    
6177     # Parse the version information argument.
6178     save_ifs="$IFS"; IFS=':'
6179     set dummy $vinfo 0 0 0
6180 michael 945 shift
6181 michael 912 IFS="$save_ifs"
6182    
6183 michael 945 test -n "$7" && \
6184     func_fatal_help "too many parameters to \`-version-info'"
6185 michael 912
6186     # convert absolute version numbers to libtool ages
6187     # this retains compatibility with .la files and attempts
6188     # to make the code below a bit more comprehensible
6189    
6190     case $vinfo_number in
6191     yes)
6192 michael 945 number_major="$1"
6193     number_minor="$2"
6194     number_revision="$3"
6195 michael 912 #
6196     # There are really only two kinds -- those that
6197     # use the current revision as the major version
6198     # and those that subtract age and use age as
6199     # a minor version. But, then there is irix
6200     # which has an extra 1 added just for fun
6201     #
6202     case $version_type in
6203     darwin|linux|osf|windows|none)
6204 michael 945 func_arith $number_major + $number_minor
6205     current=$func_arith_result
6206 michael 912 age="$number_minor"
6207     revision="$number_revision"
6208     ;;
6209     freebsd-aout|freebsd-elf|sunos)
6210     current="$number_major"
6211     revision="$number_minor"
6212     age="0"
6213     ;;
6214     irix|nonstopux)
6215 michael 945 func_arith $number_major + $number_minor
6216     current=$func_arith_result
6217 michael 912 age="$number_minor"
6218     revision="$number_minor"
6219     lt_irix_increment=no
6220     ;;
6221     esac
6222     ;;
6223     no)
6224 michael 945 current="$1"
6225     revision="$2"
6226     age="$3"
6227 michael 912 ;;
6228     esac
6229    
6230     # Check that each of the things are valid numbers.
6231     case $current in
6232     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6233     *)
6234 michael 945 func_error "CURRENT \`$current' must be a nonnegative integer"
6235     func_fatal_error "\`$vinfo' is not valid version information"
6236 michael 912 ;;
6237     esac
6238    
6239     case $revision in
6240     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6241     *)
6242 michael 945 func_error "REVISION \`$revision' must be a nonnegative integer"
6243     func_fatal_error "\`$vinfo' is not valid version information"
6244 michael 912 ;;
6245     esac
6246    
6247     case $age in
6248     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6249     *)
6250 michael 945 func_error "AGE \`$age' must be a nonnegative integer"
6251     func_fatal_error "\`$vinfo' is not valid version information"
6252 michael 912 ;;
6253     esac
6254    
6255     if test "$age" -gt "$current"; then
6256 michael 945 func_error "AGE \`$age' is greater than the current interface number \`$current'"
6257     func_fatal_error "\`$vinfo' is not valid version information"
6258 michael 912 fi
6259    
6260     # Calculate the version variables.
6261     major=
6262     versuffix=
6263     verstring=
6264     case $version_type in
6265     none) ;;
6266    
6267     darwin)
6268     # Like Linux, but with the current version available in
6269     # verstring for coding it into the library header
6270 michael 945 func_arith $current - $age
6271     major=.$func_arith_result
6272 michael 912 versuffix="$major.$age.$revision"
6273     # Darwin ld doesn't like 0 for these options...
6274 michael 945 func_arith $current + 1
6275     minor_current=$func_arith_result
6276 michael 912 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6277     verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6278     ;;
6279    
6280     freebsd-aout)
6281     major=".$current"
6282     versuffix=".$current.$revision";
6283     ;;
6284    
6285     freebsd-elf)
6286     major=".$current"
6287 michael 945 versuffix=".$current"
6288 michael 912 ;;
6289    
6290     irix | nonstopux)
6291     if test "X$lt_irix_increment" = "Xno"; then
6292 michael 945 func_arith $current - $age
6293 michael 912 else
6294 michael 945 func_arith $current - $age + 1
6295 michael 912 fi
6296 michael 945 major=$func_arith_result
6297    
6298 michael 912 case $version_type in
6299     nonstopux) verstring_prefix=nonstopux ;;
6300     *) verstring_prefix=sgi ;;
6301     esac
6302     verstring="$verstring_prefix$major.$revision"
6303    
6304     # Add in all the interfaces that we are compatible with.
6305     loop=$revision
6306     while test "$loop" -ne 0; do
6307 michael 945 func_arith $revision - $loop
6308     iface=$func_arith_result
6309     func_arith $loop - 1
6310     loop=$func_arith_result
6311 michael 912 verstring="$verstring_prefix$major.$iface:$verstring"
6312     done
6313    
6314     # Before this point, $major must not contain `.'.
6315     major=.$major
6316     versuffix="$major.$revision"
6317     ;;
6318    
6319     linux)
6320 michael 945 func_arith $current - $age
6321     major=.$func_arith_result
6322 michael 912 versuffix="$major.$age.$revision"
6323     ;;
6324    
6325     osf)
6326 michael 945 func_arith $current - $age
6327     major=.$func_arith_result
6328 michael 912 versuffix=".$current.$age.$revision"
6329     verstring="$current.$age.$revision"
6330    
6331     # Add in all the interfaces that we are compatible with.
6332     loop=$age
6333     while test "$loop" -ne 0; do
6334 michael 945 func_arith $current - $loop
6335     iface=$func_arith_result
6336     func_arith $loop - 1
6337     loop=$func_arith_result
6338 michael 912 verstring="$verstring:${iface}.0"
6339     done
6340    
6341     # Make executables depend on our current version.
6342     verstring="$verstring:${current}.0"
6343     ;;
6344    
6345 michael 945 qnx)
6346     major=".$current"
6347     versuffix=".$current"
6348     ;;
6349    
6350 michael 912 sunos)
6351     major=".$current"
6352     versuffix=".$current.$revision"
6353     ;;
6354    
6355     windows)
6356     # Use '-' rather than '.', since we only want one
6357     # extension on DOS 8.3 filesystems.
6358 michael 945 func_arith $current - $age
6359     major=$func_arith_result
6360 michael 912 versuffix="-$major"
6361     ;;
6362    
6363     *)
6364 michael 945 func_fatal_configuration "unknown library version type \`$version_type'"
6365 michael 912 ;;
6366     esac
6367    
6368     # Clear the version info if we defaulted, and they specified a release.
6369     if test -z "$vinfo" && test -n "$release"; then
6370     major=
6371     case $version_type in
6372     darwin)
6373     # we can't check for "0.0" in archive_cmds due to quoting
6374     # problems, so we reset it completely
6375     verstring=
6376     ;;
6377     *)
6378     verstring="0.0"
6379     ;;
6380     esac
6381     if test "$need_version" = no; then
6382     versuffix=
6383     else
6384     versuffix=".0.0"
6385     fi
6386     fi
6387    
6388     # Remove version info from name if versioning should be avoided
6389     if test "$avoid_version" = yes && test "$need_version" = no; then
6390     major=
6391     versuffix=
6392     verstring=""
6393     fi
6394    
6395     # Check to see if the archive will have undefined symbols.
6396     if test "$allow_undefined" = yes; then
6397     if test "$allow_undefined_flag" = unsupported; then
6398 michael 945 func_warning "undefined symbols not allowed in $host shared libraries"
6399 michael 912 build_libtool_libs=no
6400     build_old_libs=yes
6401     fi
6402     else
6403     # Don't allow undefined symbols.
6404     allow_undefined_flag="$no_undefined_flag"
6405     fi
6406 michael 945
6407 michael 912 fi
6408    
6409 michael 945 func_generate_dlsyms "$libname" "$libname" "yes"
6410     libobjs="$libobjs $symfileobj"
6411     test "X$libobjs" = "X " && libobjs=
6412    
6413 michael 912 if test "$mode" != relink; then
6414     # Remove our outputs, but don't remove object files since they
6415     # may have been created when compiling PIC objects.
6416     removelist=
6417 michael 945 tempremovelist=`$ECHO "$output_objdir/*"`
6418 michael 912 for p in $tempremovelist; do
6419     case $p in
6420 michael 945 *.$objext | *.gcno)
6421 michael 912 ;;
6422     $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6423     if test "X$precious_files_regex" != "X"; then
6424 michael 945 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6425     then
6426 michael 912 continue
6427     fi
6428     fi
6429     removelist="$removelist $p"
6430     ;;
6431     *) ;;
6432     esac
6433     done
6434 michael 945 test -n "$removelist" && \
6435     func_show_eval "${RM}r \$removelist"
6436 michael 912 fi
6437    
6438     # Now set the variables for building old libraries.
6439     if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6440     oldlibs="$oldlibs $output_objdir/$libname.$libext"
6441    
6442     # Transform .lo files to .o files.
6443 michael 945 oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6444 michael 912 fi
6445    
6446     # Eliminate all temporary directories.
6447     #for path in $notinst_path; do
6448 michael 945 # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6449     # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6450     # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6451 michael 912 #done
6452    
6453     if test -n "$xrpath"; then
6454     # If the user specified any rpath flags, then add them.
6455     temp_xrpath=
6456     for libdir in $xrpath; do
6457     temp_xrpath="$temp_xrpath -R$libdir"
6458     case "$finalize_rpath " in
6459     *" $libdir "*) ;;
6460     *) finalize_rpath="$finalize_rpath $libdir" ;;
6461     esac
6462     done
6463     if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6464     dependency_libs="$temp_xrpath $dependency_libs"
6465     fi
6466     fi
6467    
6468     # Make sure dlfiles contains only unique files that won't be dlpreopened
6469     old_dlfiles="$dlfiles"
6470     dlfiles=
6471     for lib in $old_dlfiles; do
6472     case " $dlprefiles $dlfiles " in
6473     *" $lib "*) ;;
6474     *) dlfiles="$dlfiles $lib" ;;
6475     esac
6476     done
6477    
6478     # Make sure dlprefiles contains only unique files
6479     old_dlprefiles="$dlprefiles"
6480     dlprefiles=
6481     for lib in $old_dlprefiles; do
6482     case "$dlprefiles " in
6483     *" $lib "*) ;;
6484     *) dlprefiles="$dlprefiles $lib" ;;
6485     esac
6486     done
6487    
6488     if test "$build_libtool_libs" = yes; then
6489     if test -n "$rpath"; then
6490     case $host in
6491 michael 945 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6492 michael 912 # these systems don't actually have a c library (as such)!
6493     ;;
6494     *-*-rhapsody* | *-*-darwin1.[012])
6495     # Rhapsody C library is in the System framework
6496 michael 945 deplibs="$deplibs System.ltframework"
6497 michael 912 ;;
6498     *-*-netbsd*)
6499     # Don't link with libc until the a.out ld.so is fixed.
6500     ;;
6501     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6502     # Do not include libc due to us having libc/libc_r.
6503     ;;
6504     *-*-sco3.2v5* | *-*-sco5v6*)
6505     # Causes problems with __ctype
6506     ;;
6507     *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6508     # Compiler inserts libc in the correct place for threads to work
6509     ;;
6510 michael 945 *)
6511 michael 912 # Add libc to deplibs on all other systems if necessary.
6512     if test "$build_libtool_need_lc" = "yes"; then
6513     deplibs="$deplibs -lc"
6514     fi
6515     ;;
6516     esac
6517     fi
6518    
6519     # Transform deplibs into only deplibs that can be linked in shared.
6520     name_save=$name
6521     libname_save=$libname
6522     release_save=$release
6523     versuffix_save=$versuffix
6524     major_save=$major
6525     # I'm not sure if I'm treating the release correctly. I think
6526     # release should show up in the -l (ie -lgmp5) so we don't want to
6527     # add it in twice. Is that correct?
6528     release=""
6529     versuffix=""
6530     major=""
6531     newdeplibs=
6532     droppeddeps=no
6533     case $deplibs_check_method in
6534     pass_all)
6535     # Don't check for shared/static. Everything works.
6536     # This might be a little naive. We might want to check
6537     # whether the library exists or not. But this is on
6538     # osf3 & osf4 and I'm not really sure... Just
6539     # implementing what was already the behavior.
6540     newdeplibs=$deplibs
6541     ;;
6542     test_compile)
6543     # This code stresses the "libraries are programs" paradigm to its
6544     # limits. Maybe even breaks it. We compile a program, linking it
6545     # against the deplibs as a proxy for the library. Then we can check
6546     # whether they linked in statically or dynamically with ldd.
6547 michael 945 $opt_dry_run || $RM conftest.c
6548 michael 912 cat > conftest.c <<EOF
6549     int main() { return 0; }
6550     EOF
6551 michael 945 $opt_dry_run || $RM conftest
6552 michael 912 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6553     ldd_output=`ldd conftest`
6554     for i in $deplibs; do
6555 michael 945 case $i in
6556     -l*)
6557     func_stripname -l '' "$i"
6558     name=$func_stripname_result
6559 michael 912 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6560     case " $predeps $postdeps " in
6561     *" $i "*)
6562     newdeplibs="$newdeplibs $i"
6563     i=""
6564     ;;
6565     esac
6566 michael 945 fi
6567 michael 912 if test -n "$i" ; then
6568 michael 945 libname=`eval "\\$ECHO \"$libname_spec\""`
6569     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6570     set dummy $deplib_matches; shift
6571     deplib_match=$1
6572 michael 912 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6573     newdeplibs="$newdeplibs $i"
6574     else
6575     droppeddeps=yes
6576 michael 945 $ECHO
6577     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6578     $ECHO "*** I have the capability to make that library automatically link in when"
6579     $ECHO "*** you link to this library. But I can only do this if you have a"
6580     $ECHO "*** shared version of the library, which I believe you do not have"
6581     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
6582     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6583 michael 912 fi
6584     fi
6585 michael 945 ;;
6586     *)
6587 michael 912 newdeplibs="$newdeplibs $i"
6588 michael 945 ;;
6589     esac
6590 michael 912 done
6591     else
6592     # Error occurred in the first compile. Let's try to salvage
6593     # the situation: Compile a separate program for each library.
6594     for i in $deplibs; do
6595 michael 945 case $i in
6596     -l*)
6597     func_stripname -l '' "$i"
6598     name=$func_stripname_result
6599     $opt_dry_run || $RM conftest
6600 michael 912 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6601     ldd_output=`ldd conftest`
6602     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6603     case " $predeps $postdeps " in
6604     *" $i "*)
6605     newdeplibs="$newdeplibs $i"
6606     i=""
6607     ;;
6608     esac
6609     fi
6610     if test -n "$i" ; then
6611 michael 945 libname=`eval "\\$ECHO \"$libname_spec\""`
6612     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6613     set dummy $deplib_matches; shift
6614     deplib_match=$1
6615 michael 912 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6616     newdeplibs="$newdeplibs $i"
6617     else
6618     droppeddeps=yes
6619 michael 945 $ECHO
6620     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6621     $ECHO "*** I have the capability to make that library automatically link in when"
6622     $ECHO "*** you link to this library. But I can only do this if you have a"
6623     $ECHO "*** shared version of the library, which you do not appear to have"
6624     $ECHO "*** because a test_compile did reveal that the linker did not use this one"
6625     $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6626 michael 912 fi
6627     fi
6628     else
6629     droppeddeps=yes
6630 michael 945 $ECHO
6631     $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6632     $ECHO "*** make it link in! You will probably need to install it or some"
6633     $ECHO "*** library that it depends on before this library will be fully"
6634     $ECHO "*** functional. Installing it before continuing would be even better."
6635 michael 912 fi
6636 michael 945 ;;
6637     *)
6638 michael 912 newdeplibs="$newdeplibs $i"
6639 michael 945 ;;
6640     esac
6641 michael 912 done
6642     fi
6643     ;;
6644     file_magic*)
6645 michael 945 set dummy $deplibs_check_method; shift
6646     file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6647 michael 912 for a_deplib in $deplibs; do
6648 michael 945 case $a_deplib in
6649     -l*)
6650     func_stripname -l '' "$a_deplib"
6651     name=$func_stripname_result
6652 michael 912 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6653     case " $predeps $postdeps " in
6654     *" $a_deplib "*)
6655     newdeplibs="$newdeplibs $a_deplib"
6656     a_deplib=""
6657     ;;
6658     esac
6659     fi
6660     if test -n "$a_deplib" ; then
6661 michael 945 libname=`eval "\\$ECHO \"$libname_spec\""`
6662 michael 912 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6663     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6664     for potent_lib in $potential_libs; do
6665     # Follow soft links.
6666 michael 945 if ls -lLd "$potent_lib" 2>/dev/null |
6667     $GREP " -> " >/dev/null; then
6668 michael 912 continue
6669     fi
6670     # The statement above tries to avoid entering an
6671     # endless loop below, in case of cyclic links.
6672     # We might still enter an endless loop, since a link
6673     # loop can be closed while we follow links,
6674     # but so what?
6675     potlib="$potent_lib"
6676     while test -h "$potlib" 2>/dev/null; do
6677     potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6678     case $potliblink in
6679     [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6680 michael 945 *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6681 michael 912 esac
6682     done
6683 michael 945 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6684     $SED -e 10q |
6685     $EGREP "$file_magic_regex" > /dev/null; then
6686 michael 912 newdeplibs="$newdeplibs $a_deplib"
6687     a_deplib=""
6688     break 2
6689     fi
6690     done
6691     done
6692     fi
6693     if test -n "$a_deplib" ; then
6694     droppeddeps=yes
6695 michael 945 $ECHO
6696     $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6697     $ECHO "*** I have the capability to make that library automatically link in when"
6698     $ECHO "*** you link to this library. But I can only do this if you have a"
6699     $ECHO "*** shared version of the library, which you do not appear to have"
6700     $ECHO "*** because I did check the linker path looking for a file starting"
6701 michael 912 if test -z "$potlib" ; then
6702 michael 945 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6703 michael 912 else
6704 michael 945 $ECHO "*** with $libname and none of the candidates passed a file format test"
6705     $ECHO "*** using a file magic. Last file checked: $potlib"
6706 michael 912 fi
6707     fi
6708 michael 945 ;;
6709     *)
6710 michael 912 # Add a -L argument.
6711     newdeplibs="$newdeplibs $a_deplib"
6712 michael 945 ;;
6713     esac
6714 michael 912 done # Gone through all deplibs.
6715     ;;
6716     match_pattern*)
6717 michael 945 set dummy $deplibs_check_method; shift
6718     match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6719 michael 912 for a_deplib in $deplibs; do
6720 michael 945 case $a_deplib in
6721     -l*)
6722     func_stripname -l '' "$a_deplib"
6723     name=$func_stripname_result
6724 michael 912 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6725     case " $predeps $postdeps " in
6726     *" $a_deplib "*)
6727     newdeplibs="$newdeplibs $a_deplib"
6728     a_deplib=""
6729     ;;
6730     esac
6731     fi
6732     if test -n "$a_deplib" ; then
6733 michael 945 libname=`eval "\\$ECHO \"$libname_spec\""`
6734 michael 912 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6735     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6736     for potent_lib in $potential_libs; do
6737     potlib="$potent_lib" # see symlink-check above in file_magic test
6738 michael 945 if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6739     $EGREP "$match_pattern_regex" > /dev/null; then
6740 michael 912 newdeplibs="$newdeplibs $a_deplib"
6741     a_deplib=""
6742     break 2
6743     fi
6744     done
6745     done
6746     fi
6747     if test -n "$a_deplib" ; then
6748     droppeddeps=yes
6749 michael 945 $ECHO
6750     $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6751     $ECHO "*** I have the capability to make that library automatically link in when"
6752     $ECHO "*** you link to this library. But I can only do this if you have a"
6753     $ECHO "*** shared version of the library, which you do not appear to have"
6754     $ECHO "*** because I did check the linker path looking for a file starting"
6755 michael 912 if test -z "$potlib" ; then
6756 michael 945 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6757 michael 912 else
6758 michael 945 $ECHO "*** with $libname and none of the candidates passed a file format test"
6759     $ECHO "*** using a regex pattern. Last file checked: $potlib"
6760 michael 912 fi
6761     fi
6762 michael 945 ;;
6763     *)
6764 michael 912 # Add a -L argument.
6765     newdeplibs="$newdeplibs $a_deplib"
6766 michael 945 ;;
6767     esac
6768 michael 912 done # Gone through all deplibs.
6769     ;;
6770     none | unknown | *)
6771     newdeplibs=""
6772 michael 945 tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6773     -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6774 michael 912 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6775     for i in $predeps $postdeps ; do
6776     # can't use Xsed below, because $i might contain '/'
6777 michael 945 tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6778 michael 912 done
6779     fi
6780 michael 945 if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6781     $GREP . >/dev/null; then
6782     $ECHO
6783 michael 912 if test "X$deplibs_check_method" = "Xnone"; then
6784 michael 945 $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6785 michael 912 else
6786 michael 945 $ECHO "*** Warning: inter-library dependencies are not known to be supported."
6787 michael 912 fi
6788 michael 945 $ECHO "*** All declared inter-library dependencies are being dropped."
6789 michael 912 droppeddeps=yes
6790     fi
6791     ;;
6792     esac
6793     versuffix=$versuffix_save
6794     major=$major_save
6795     release=$release_save
6796     libname=$libname_save
6797     name=$name_save
6798    
6799     case $host in
6800     *-*-rhapsody* | *-*-darwin1.[012])
6801 michael 945 # On Rhapsody replace the C library with the System framework
6802     newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6803 michael 912 ;;
6804     esac
6805    
6806     if test "$droppeddeps" = yes; then
6807     if test "$module" = yes; then
6808 michael 945 $ECHO
6809     $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6810     $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6811     $ECHO "*** a static module, that should work as long as the dlopening"
6812     $ECHO "*** application is linked with the -dlopen flag."
6813 michael 912 if test -z "$global_symbol_pipe"; then
6814 michael 945 $ECHO
6815     $ECHO "*** However, this would only work if libtool was able to extract symbol"
6816     $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6817     $ECHO "*** not find such a program. So, this module is probably useless."
6818     $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6819 michael 912 fi
6820     if test "$build_old_libs" = no; then
6821     oldlibs="$output_objdir/$libname.$libext"
6822     build_libtool_libs=module
6823     build_old_libs=yes
6824     else
6825     build_libtool_libs=no
6826     fi
6827     else
6828 michael 945 $ECHO "*** The inter-library dependencies that have been dropped here will be"
6829     $ECHO "*** automatically added whenever a program is linked with this library"
6830     $ECHO "*** or is declared to -dlopen it."
6831 michael 912
6832     if test "$allow_undefined" = no; then
6833 michael 945 $ECHO
6834     $ECHO "*** Since this library must not contain undefined symbols,"
6835     $ECHO "*** because either the platform does not support them or"
6836     $ECHO "*** it was explicitly requested with -no-undefined,"
6837     $ECHO "*** libtool will only create a static version of it."
6838 michael 912 if test "$build_old_libs" = no; then
6839     oldlibs="$output_objdir/$libname.$libext"
6840     build_libtool_libs=module
6841     build_old_libs=yes
6842     else
6843     build_libtool_libs=no
6844     fi
6845     fi
6846     fi
6847     fi
6848     # Done checking deplibs!
6849     deplibs=$newdeplibs
6850     fi
6851 michael 945 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
6852     case $host in
6853     *-*-darwin*)
6854     newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6855     new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6856     deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6857     ;;
6858     esac
6859 michael 912
6860     # move library search paths that coincide with paths to not yet
6861     # installed libraries to the beginning of the library search list
6862     new_libs=
6863     for path in $notinst_path; do
6864     case " $new_libs " in
6865     *" -L$path/$objdir "*) ;;
6866     *)
6867     case " $deplibs " in
6868     *" -L$path/$objdir "*)
6869     new_libs="$new_libs -L$path/$objdir" ;;
6870     esac
6871     ;;
6872     esac
6873     done
6874     for deplib in $deplibs; do
6875     case $deplib in
6876     -L*)
6877     case " $new_libs " in
6878     *" $deplib "*) ;;
6879     *) new_libs="$new_libs $deplib" ;;
6880     esac
6881     ;;
6882     *) new_libs="$new_libs $deplib" ;;
6883     esac
6884     done
6885     deplibs="$new_libs"
6886    
6887     # All the library-specific variables (install_libdir is set above).
6888     library_names=
6889     old_library=
6890     dlname=
6891    
6892     # Test again, we may have decided not to build it any more
6893     if test "$build_libtool_libs" = yes; then
6894     if test "$hardcode_into_libs" = yes; then
6895     # Hardcode the library paths
6896     hardcode_libdirs=
6897     dep_rpath=
6898     rpath="$finalize_rpath"
6899     test "$mode" != relink && rpath="$compile_rpath$rpath"
6900     for libdir in $rpath; do
6901     if test -n "$hardcode_libdir_flag_spec"; then
6902     if test -n "$hardcode_libdir_separator"; then
6903     if test -z "$hardcode_libdirs"; then
6904     hardcode_libdirs="$libdir"
6905     else
6906     # Just accumulate the unique libdirs.
6907     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6908     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6909     ;;
6910     *)
6911     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6912     ;;
6913     esac
6914     fi
6915     else
6916     eval flag=\"$hardcode_libdir_flag_spec\"
6917     dep_rpath="$dep_rpath $flag"
6918     fi
6919     elif test -n "$runpath_var"; then
6920     case "$perm_rpath " in
6921     *" $libdir "*) ;;
6922     *) perm_rpath="$perm_rpath $libdir" ;;
6923     esac
6924     fi
6925     done
6926     # Substitute the hardcoded libdirs into the rpath.
6927     if test -n "$hardcode_libdir_separator" &&
6928     test -n "$hardcode_libdirs"; then
6929     libdir="$hardcode_libdirs"
6930     if test -n "$hardcode_libdir_flag_spec_ld"; then
6931 michael 945 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6932 michael 912 else
6933     eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6934     fi
6935     fi
6936     if test -n "$runpath_var" && test -n "$perm_rpath"; then
6937     # We should set the runpath_var.
6938     rpath=
6939     for dir in $perm_rpath; do
6940     rpath="$rpath$dir:"
6941     done
6942     eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6943     fi
6944     test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6945     fi
6946    
6947     shlibpath="$finalize_shlibpath"
6948     test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6949     if test -n "$shlibpath"; then
6950     eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6951     fi
6952    
6953     # Get the real and link names of the library.
6954     eval shared_ext=\"$shrext_cmds\"
6955     eval library_names=\"$library_names_spec\"
6956     set dummy $library_names
6957 michael 945 shift
6958     realname="$1"
6959     shift
6960 michael 912
6961     if test -n "$soname_spec"; then
6962     eval soname=\"$soname_spec\"
6963     else
6964     soname="$realname"
6965     fi
6966     if test -z "$dlname"; then
6967     dlname=$soname
6968     fi
6969    
6970     lib="$output_objdir/$realname"
6971     linknames=
6972     for link
6973     do
6974     linknames="$linknames $link"
6975     done
6976    
6977     # Use standard objects if they are pic
6978 michael 945 test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6979     test "X$libobjs" = "X " && libobjs=
6980 michael 912
6981 michael 945 delfiles=
6982     if test -n "$export_symbols" && test -n "$include_expsyms"; then
6983     $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6984     export_symbols="$output_objdir/$libname.uexp"
6985     delfiles="$delfiles $export_symbols"
6986     fi
6987    
6988     orig_export_symbols=
6989     case $host_os in
6990     cygwin* | mingw* | cegcc*)
6991     if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6992     # exporting using user supplied symfile
6993     if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6994     # and it's NOT already a .def file. Must figure out
6995     # which of the given symbols are data symbols and tag
6996     # them as such. So, trigger use of export_symbols_cmds.
6997     # export_symbols gets reassigned inside the "prepare
6998     # the list of exported symbols" if statement, so the
6999     # include_expsyms logic still works.
7000     orig_export_symbols="$export_symbols"
7001     export_symbols=
7002     always_export_symbols=yes
7003     fi
7004     fi
7005     ;;
7006     esac
7007    
7008 michael 912 # Prepare the list of exported symbols
7009     if test -z "$export_symbols"; then
7010     if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7011 michael 945 func_verbose "generating symbol list for \`$libname.la'"
7012 michael 912 export_symbols="$output_objdir/$libname.exp"
7013 michael 945 $opt_dry_run || $RM $export_symbols
7014 michael 912 cmds=$export_symbols_cmds
7015     save_ifs="$IFS"; IFS='~'
7016     for cmd in $cmds; do
7017     IFS="$save_ifs"
7018     eval cmd=\"$cmd\"
7019 michael 945 func_len " $cmd"
7020     len=$func_len_result
7021     if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7022     func_show_eval "$cmd" 'exit $?'
7023     skipped_export=false
7024 michael 912 else
7025 michael 945 # The command line is too long to execute in one step.
7026     func_verbose "using reloadable object file for export list..."
7027     skipped_export=:
7028 michael 912 # Break out early, otherwise skipped_export may be
7029     # set to false by a later but shorter cmd.
7030     break
7031     fi
7032     done
7033     IFS="$save_ifs"
7034 michael 945 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7035     func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7036     func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7037 michael 912 fi
7038     fi
7039     fi
7040    
7041     if test -n "$export_symbols" && test -n "$include_expsyms"; then
7042 michael 945 tmp_export_symbols="$export_symbols"
7043     test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7044     $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7045 michael 912 fi
7046    
7047 michael 945 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7048     # The given exports_symbols file has to be filtered, so filter it.
7049     func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7050     # FIXME: $output_objdir/$libname.filter potentially contains lots of
7051     # 's' commands which not all seds can handle. GNU sed should be fine
7052     # though. Also, the filter scales superlinearly with the number of
7053     # global variables. join(1) would be nice here, but unfortunately
7054     # isn't a blessed tool.
7055     $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7056     delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7057     export_symbols=$output_objdir/$libname.def
7058     $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7059     fi
7060    
7061 michael 912 tmp_deplibs=
7062 michael 945 inst_prefix_arg=
7063 michael 912 for test_deplib in $deplibs; do
7064 michael 945 case " $convenience " in
7065     *" $test_deplib "*) ;;
7066     *)
7067     if test -n "$inst_prefix_dir" && (echo "$test_deplib" | grep -- "$inst_prefix_dir" >/dev/null); then
7068     inst_prefix_arg="$inst_prefix_arg $test_deplib"
7069     else
7070 michael 912 tmp_deplibs="$tmp_deplibs $test_deplib"
7071 michael 945 fi
7072     ;;
7073     esac
7074 michael 912 done
7075     deplibs="$tmp_deplibs"
7076 michael 945 if test -n "$inst_prefix_arg"; then
7077     deplibs="$inst_prefix_arg $deplibs"
7078     fi
7079 michael 912
7080     if test -n "$convenience"; then
7081 michael 945 if test -n "$whole_archive_flag_spec" &&
7082     test "$compiler_needs_object" = yes &&
7083     test -z "$libobjs"; then
7084     # extract the archives, so we have objects to list.
7085     # TODO: could optimize this to just extract one archive.
7086     whole_archive_flag_spec=
7087     fi
7088 michael 912 if test -n "$whole_archive_flag_spec"; then
7089     save_libobjs=$libobjs
7090     eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7091 michael 945 test "X$libobjs" = "X " && libobjs=
7092 michael 912 else
7093     gentop="$output_objdir/${outputname}x"
7094     generated="$generated $gentop"
7095    
7096     func_extract_archives $gentop $convenience
7097     libobjs="$libobjs $func_extract_archives_result"
7098 michael 945 test "X$libobjs" = "X " && libobjs=
7099 michael 912 fi
7100     fi
7101 michael 945
7102 michael 912 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7103     eval flag=\"$thread_safe_flag_spec\"
7104     linker_flags="$linker_flags $flag"
7105     fi
7106    
7107     # Make a backup of the uninstalled library when relinking
7108     if test "$mode" = relink; then
7109 michael 945 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7110 michael 912 fi
7111    
7112     # Do each of the archive commands.
7113     if test "$module" = yes && test -n "$module_cmds" ; then
7114     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7115     eval test_cmds=\"$module_expsym_cmds\"
7116     cmds=$module_expsym_cmds
7117     else
7118     eval test_cmds=\"$module_cmds\"
7119     cmds=$module_cmds
7120     fi
7121     else
7122 michael 945 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7123     eval test_cmds=\"$archive_expsym_cmds\"
7124     cmds=$archive_expsym_cmds
7125     else
7126     eval test_cmds=\"$archive_cmds\"
7127     cmds=$archive_cmds
7128 michael 912 fi
7129     fi
7130    
7131     if test "X$skipped_export" != "X:" &&
7132 michael 945 func_len " $test_cmds" &&
7133     len=$func_len_result &&
7134     test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7135 michael 912 :
7136     else
7137 michael 945 # The command line is too long to link in one step, link piecewise
7138     # or, if using GNU ld and skipped_export is not :, use a linker
7139     # script.
7140 michael 912
7141     # Save the value of $output and $libobjs because we want to
7142     # use them later. If we have whole_archive_flag_spec, we
7143     # want to use save_libobjs as it was before
7144     # whole_archive_flag_spec was expanded, because we can't
7145     # assume the linker understands whole_archive_flag_spec.
7146     # This may have to be revisited, in case too many
7147     # convenience libraries get linked in and end up exceeding
7148     # the spec.
7149     if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7150     save_libobjs=$libobjs
7151     fi
7152     save_output=$output
7153 michael 945 output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7154 michael 912
7155     # Clear the reloadable object creation command queue and
7156     # initialize k to one.
7157     test_cmds=
7158     concat_cmds=
7159     objlist=
7160     last_robj=
7161     k=1
7162 michael 945
7163     if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7164     output=${output_objdir}/${output_la}.lnkscript
7165     func_verbose "creating GNU ld script: $output"
7166     $ECHO 'INPUT (' > $output
7167     for obj in $save_libobjs
7168     do
7169     $ECHO "$obj" >> $output
7170     done
7171     $ECHO ')' >> $output
7172     delfiles="$delfiles $output"
7173     elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7174     output=${output_objdir}/${output_la}.lnk
7175     func_verbose "creating linker input file list: $output"
7176     : > $output
7177     set x $save_libobjs
7178     shift
7179     firstobj=
7180     if test "$compiler_needs_object" = yes; then
7181     firstobj="$1 "
7182     shift
7183     fi
7184     for obj
7185     do
7186     $ECHO "$obj" >> $output
7187     done
7188     delfiles="$delfiles $output"
7189     output=$firstobj\"$file_list_spec$output\"
7190     else
7191     if test -n "$save_libobjs"; then
7192     func_verbose "creating reloadable object files..."
7193     output=$output_objdir/$output_la-${k}.$objext
7194     eval test_cmds=\"$reload_cmds\"
7195     func_len " $test_cmds"
7196     len0=$func_len_result
7197     len=$len0
7198    
7199     # Loop over the list of objects to be linked.
7200     for obj in $save_libobjs
7201     do
7202     func_len " $obj"
7203     func_arith $len + $func_len_result
7204     len=$func_arith_result
7205     if test "X$objlist" = X ||
7206     test "$len" -lt "$max_cmd_len"; then
7207     func_append objlist " $obj"
7208     else
7209     # The command $test_cmds is almost too long, add a
7210     # command to the queue.
7211     if test "$k" -eq 1 ; then
7212     # The first file doesn't have a previous command to add.
7213     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7214     else
7215     # All subsequent reloadable object files will link in
7216     # the last one created.
7217     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7218     fi
7219     last_robj=$output_objdir/$output_la-${k}.$objext
7220     func_arith $k + 1
7221     k=$func_arith_result
7222     output=$output_objdir/$output_la-${k}.$objext
7223     objlist=$obj
7224     func_len " $last_robj"
7225     func_arith $len0 + $func_len_result
7226     len=$func_arith_result
7227     fi
7228     done
7229     # Handle the remaining objects by creating one last
7230     # reloadable object file. All subsequent reloadable object
7231     # files will link in the last one created.
7232     test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7233     eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7234     if test -n "$last_robj"; then
7235     eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7236     fi
7237     delfiles="$delfiles $output"
7238    
7239 michael 912 else
7240 michael 945 output=
7241     fi
7242    
7243     if ${skipped_export-false}; then
7244     func_verbose "generating symbol list for \`$libname.la'"
7245     export_symbols="$output_objdir/$libname.exp"
7246     $opt_dry_run || $RM $export_symbols
7247     libobjs=$output
7248     # Append the command to create the export file.
7249     test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7250     eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7251     if test -n "$last_robj"; then
7252     eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7253 michael 912 fi
7254     fi
7255    
7256 michael 945 test -n "$save_libobjs" &&
7257     func_verbose "creating a temporary reloadable object file: $output"
7258 michael 912
7259 michael 945 # Loop through the commands generated above and execute them.
7260     save_ifs="$IFS"; IFS='~'
7261     for cmd in $concat_cmds; do
7262     IFS="$save_ifs"
7263     $opt_silent || {
7264     func_quote_for_expand "$cmd"
7265     eval "func_echo $func_quote_for_expand_result"
7266     }
7267     $opt_dry_run || eval "$cmd" || {
7268     lt_exit=$?
7269 michael 912
7270 michael 945 # Restore the uninstalled library and exit
7271     if test "$mode" = relink; then
7272     ( cd "$output_objdir" && \
7273     $RM "${realname}T" && \
7274     $MV "${realname}U" "$realname" )
7275     fi
7276 michael 912
7277 michael 945 exit $lt_exit
7278     }
7279     done
7280 michael 912 IFS="$save_ifs"
7281    
7282 michael 945 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7283     func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7284     func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7285     fi
7286     fi
7287    
7288     if ${skipped_export-false}; then
7289     if test -n "$export_symbols" && test -n "$include_expsyms"; then
7290     tmp_export_symbols="$export_symbols"
7291     test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7292     $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7293     fi
7294    
7295     if test -n "$orig_export_symbols"; then
7296     # The given exports_symbols file has to be filtered, so filter it.
7297     func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7298     # FIXME: $output_objdir/$libname.filter potentially contains lots of
7299     # 's' commands which not all seds can handle. GNU sed should be fine
7300     # though. Also, the filter scales superlinearly with the number of
7301     # global variables. join(1) would be nice here, but unfortunately
7302     # isn't a blessed tool.
7303     $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7304     delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7305     export_symbols=$output_objdir/$libname.def
7306     $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7307     fi
7308     fi
7309    
7310 michael 912 libobjs=$output
7311     # Restore the value of output.
7312     output=$save_output
7313    
7314     if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7315     eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7316 michael 945 test "X$libobjs" = "X " && libobjs=
7317 michael 912 fi
7318     # Expand the library linking commands again to reset the
7319     # value of $libobjs for piecewise linking.
7320    
7321     # Do each of the archive commands.
7322     if test "$module" = yes && test -n "$module_cmds" ; then
7323     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7324     cmds=$module_expsym_cmds
7325     else
7326     cmds=$module_cmds
7327     fi
7328     else
7329 michael 945 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7330     cmds=$archive_expsym_cmds
7331     else
7332     cmds=$archive_cmds
7333 michael 912 fi
7334     fi
7335 michael 945 fi
7336 michael 912
7337 michael 945 if test -n "$delfiles"; then
7338     # Append the command to remove temporary files to $cmds.
7339     eval cmds=\"\$cmds~\$RM $delfiles\"
7340 michael 912 fi
7341 michael 945
7342     # Add any objects from preloaded convenience libraries
7343     if test -n "$dlprefiles"; then
7344     gentop="$output_objdir/${outputname}x"
7345     generated="$generated $gentop"
7346    
7347     func_extract_archives $gentop $dlprefiles
7348     libobjs="$libobjs $func_extract_archives_result"
7349     test "X$libobjs" = "X " && libobjs=
7350     fi
7351    
7352 michael 912 save_ifs="$IFS"; IFS='~'
7353     for cmd in $cmds; do
7354     IFS="$save_ifs"
7355     eval cmd=\"$cmd\"
7356 michael 945 $opt_silent || {
7357     func_quote_for_expand "$cmd"
7358     eval "func_echo $func_quote_for_expand_result"
7359     }
7360     $opt_dry_run || eval "$cmd" || {
7361 michael 912 lt_exit=$?
7362    
7363     # Restore the uninstalled library and exit
7364     if test "$mode" = relink; then
7365 michael 945 ( cd "$output_objdir" && \
7366     $RM "${realname}T" && \
7367     $MV "${realname}U" "$realname" )
7368 michael 912 fi
7369    
7370     exit $lt_exit
7371     }
7372     done
7373     IFS="$save_ifs"
7374    
7375     # Restore the uninstalled library and exit
7376     if test "$mode" = relink; then
7377 michael 945 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7378 michael 912
7379     if test -n "$convenience"; then
7380     if test -z "$whole_archive_flag_spec"; then
7381 michael 945 func_show_eval '${RM}r "$gentop"'
7382 michael 912 fi
7383     fi
7384    
7385     exit $EXIT_SUCCESS
7386     fi
7387    
7388     # Create links to the real library.
7389     for linkname in $linknames; do
7390     if test "$realname" != "$linkname"; then
7391 michael 945 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7392 michael 912 fi
7393     done
7394    
7395     # If -module or -export-dynamic was specified, set the dlname.
7396     if test "$module" = yes || test "$export_dynamic" = yes; then
7397     # On all known operating systems, these are identical.
7398     dlname="$soname"
7399     fi
7400     fi
7401     ;;
7402    
7403     obj)
7404     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7405 michael 945 func_warning "\`-dlopen' is ignored for objects"
7406 michael 912 fi
7407    
7408 michael 945 case " $deplibs" in
7409     *\ -l* | *\ -L*)
7410     func_warning "\`-l' and \`-L' are ignored for objects" ;;
7411     esac
7412 michael 912
7413 michael 945 test -n "$rpath" && \
7414     func_warning "\`-rpath' is ignored for objects"
7415 michael 912
7416 michael 945 test -n "$xrpath" && \
7417     func_warning "\`-R' is ignored for objects"
7418 michael 912
7419 michael 945 test -n "$vinfo" && \
7420     func_warning "\`-version-info' is ignored for objects"
7421 michael 912
7422 michael 945 test -n "$release" && \
7423     func_warning "\`-release' is ignored for objects"
7424    
7425 michael 912 case $output in
7426     *.lo)
7427 michael 945 test -n "$objs$old_deplibs" && \
7428     func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7429    
7430     libobj=$output
7431     func_lo2o "$libobj"
7432     obj=$func_lo2o_result
7433 michael 912 ;;
7434     *)
7435     libobj=
7436     obj="$output"
7437     ;;
7438     esac
7439    
7440     # Delete the old objects.
7441 michael 945 $opt_dry_run || $RM $obj $libobj
7442 michael 912
7443     # Objects from convenience libraries. This assumes
7444     # single-version convenience libraries. Whenever we create
7445     # different ones for PIC/non-PIC, this we'll have to duplicate
7446     # the extraction.
7447     reload_conv_objs=
7448     gentop=
7449     # reload_cmds runs $LD directly, so let us get rid of
7450     # -Wl from whole_archive_flag_spec and hope we can get by with
7451     # turning comma into space..
7452     wl=
7453    
7454     if test -n "$convenience"; then
7455     if test -n "$whole_archive_flag_spec"; then
7456     eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7457 michael 945 reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7458 michael 912 else
7459     gentop="$output_objdir/${obj}x"
7460     generated="$generated $gentop"
7461    
7462     func_extract_archives $gentop $convenience
7463     reload_conv_objs="$reload_objs $func_extract_archives_result"
7464     fi
7465     fi
7466    
7467     # Create the old-style object.
7468 michael 945 reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7469 michael 912
7470     output="$obj"
7471 michael 945 func_execute_cmds "$reload_cmds" 'exit $?'
7472 michael 912
7473     # Exit if we aren't doing a library object file.
7474     if test -z "$libobj"; then
7475     if test -n "$gentop"; then
7476 michael 945 func_show_eval '${RM}r "$gentop"'
7477 michael 912 fi
7478    
7479     exit $EXIT_SUCCESS
7480     fi
7481    
7482     if test "$build_libtool_libs" != yes; then
7483     if test -n "$gentop"; then
7484 michael 945 func_show_eval '${RM}r "$gentop"'
7485 michael 912 fi
7486    
7487     # Create an invalid libtool object if no PIC, so that we don't
7488     # accidentally link it into a program.
7489     # $show "echo timestamp > $libobj"
7490 michael 945 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7491 michael 912 exit $EXIT_SUCCESS
7492     fi
7493    
7494     if test -n "$pic_flag" || test "$pic_mode" != default; then
7495     # Only do commands if we really have different PIC objects.
7496     reload_objs="$libobjs $reload_conv_objs"
7497     output="$libobj"
7498 michael 945 func_execute_cmds "$reload_cmds" 'exit $?'
7499 michael 912 fi
7500    
7501     if test -n "$gentop"; then
7502 michael 945 func_show_eval '${RM}r "$gentop"'
7503 michael 912 fi
7504    
7505     exit $EXIT_SUCCESS
7506     ;;
7507    
7508     prog)
7509     case $host in
7510 michael 945 *cygwin*) func_stripname '' '.exe' "$output"
7511     output=$func_stripname_result.exe;;
7512 michael 912 esac
7513 michael 945 test -n "$vinfo" && \
7514     func_warning "\`-version-info' is ignored for programs"
7515 michael 912
7516 michael 945 test -n "$release" && \
7517     func_warning "\`-release' is ignored for programs"
7518 michael 912
7519 michael 945 test "$preload" = yes \
7520     && test "$dlopen_support" = unknown \
7521     && test "$dlopen_self" = unknown \
7522     && test "$dlopen_self_static" = unknown && \
7523     func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7524 michael 912
7525     case $host in
7526     *-*-rhapsody* | *-*-darwin1.[012])
7527     # On Rhapsody replace the C library is the System framework
7528 michael 945 compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7529     finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7530 michael 912 ;;
7531     esac
7532    
7533     case $host in
7534 michael 945 *-*-darwin*)
7535     # Don't allow lazy linking, it breaks C++ global constructors
7536     # But is supposedly fixed on 10.4 or later (yay!).
7537     if test "$tagname" = CXX ; then
7538     case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7539     10.[0123])
7540     compile_command="$compile_command ${wl}-bind_at_load"
7541     finalize_command="$finalize_command ${wl}-bind_at_load"
7542     ;;
7543     esac
7544     fi
7545     # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7546     compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7547     finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7548     ;;
7549 michael 912 esac
7550    
7551    
7552     # move library search paths that coincide with paths to not yet
7553     # installed libraries to the beginning of the library search list
7554     new_libs=
7555     for path in $notinst_path; do
7556     case " $new_libs " in
7557     *" -L$path/$objdir "*) ;;
7558     *)
7559     case " $compile_deplibs " in
7560     *" -L$path/$objdir "*)
7561     new_libs="$new_libs -L$path/$objdir" ;;
7562     esac
7563     ;;
7564     esac
7565     done
7566     for deplib in $compile_deplibs; do
7567     case $deplib in
7568     -L*)
7569     case " $new_libs " in
7570     *" $deplib "*) ;;
7571     *) new_libs="$new_libs $deplib" ;;
7572     esac
7573     ;;
7574     *) new_libs="$new_libs $deplib" ;;
7575     esac
7576     done
7577     compile_deplibs="$new_libs"
7578    
7579    
7580     compile_command="$compile_command $compile_deplibs"
7581     finalize_command="$finalize_command $finalize_deplibs"
7582    
7583     if test -n "$rpath$xrpath"; then
7584     # If the user specified any rpath flags, then add them.
7585     for libdir in $rpath $xrpath; do
7586     # This is the magic to use -rpath.
7587     case "$finalize_rpath " in
7588     *" $libdir "*) ;;
7589     *) finalize_rpath="$finalize_rpath $libdir" ;;
7590     esac
7591     done
7592     fi
7593    
7594     # Now hardcode the library paths
7595     rpath=
7596     hardcode_libdirs=
7597     for libdir in $compile_rpath $finalize_rpath; do
7598     if test -n "$hardcode_libdir_flag_spec"; then
7599     if test -n "$hardcode_libdir_separator"; then
7600     if test -z "$hardcode_libdirs"; then
7601     hardcode_libdirs="$libdir"
7602     else
7603     # Just accumulate the unique libdirs.
7604     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7605     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7606     ;;
7607     *)
7608     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7609     ;;
7610     esac
7611     fi
7612     else
7613     eval flag=\"$hardcode_libdir_flag_spec\"
7614     rpath="$rpath $flag"
7615     fi
7616     elif test -n "$runpath_var"; then
7617     case "$perm_rpath " in
7618     *" $libdir "*) ;;
7619     *) perm_rpath="$perm_rpath $libdir" ;;
7620     esac
7621     fi
7622     case $host in
7623 michael 945 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7624     testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7625 michael 912 case :$dllsearchpath: in
7626     *":$libdir:"*) ;;
7627 michael 945 ::) dllsearchpath=$libdir;;
7628 michael 912 *) dllsearchpath="$dllsearchpath:$libdir";;
7629     esac
7630     case :$dllsearchpath: in
7631     *":$testbindir:"*) ;;
7632 michael 945 ::) dllsearchpath=$testbindir;;
7633 michael 912 *) dllsearchpath="$dllsearchpath:$testbindir";;
7634     esac
7635     ;;
7636     esac
7637     done
7638     # Substitute the hardcoded libdirs into the rpath.
7639     if test -n "$hardcode_libdir_separator" &&
7640     test -n "$hardcode_libdirs"; then
7641     libdir="$hardcode_libdirs"
7642     eval rpath=\" $hardcode_libdir_flag_spec\"
7643     fi
7644     compile_rpath="$rpath"
7645    
7646     rpath=
7647     hardcode_libdirs=
7648     for libdir in $finalize_rpath; do
7649     if test -n "$hardcode_libdir_flag_spec"; then
7650     if test -n "$hardcode_libdir_separator"; then
7651     if test -z "$hardcode_libdirs"; then
7652     hardcode_libdirs="$libdir"
7653     else
7654     # Just accumulate the unique libdirs.
7655     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7656     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7657     ;;
7658     *)
7659     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7660     ;;
7661     esac
7662     fi
7663     else
7664     eval flag=\"$hardcode_libdir_flag_spec\"
7665     rpath="$rpath $flag"
7666     fi
7667     elif test -n "$runpath_var"; then
7668     case "$finalize_perm_rpath " in
7669     *" $libdir "*) ;;
7670     *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7671     esac
7672     fi
7673     done
7674     # Substitute the hardcoded libdirs into the rpath.
7675     if test -n "$hardcode_libdir_separator" &&
7676     test -n "$hardcode_libdirs"; then
7677     libdir="$hardcode_libdirs"
7678     eval rpath=\" $hardcode_libdir_flag_spec\"
7679     fi
7680     finalize_rpath="$rpath"
7681    
7682     if test -n "$libobjs" && test "$build_old_libs" = yes; then
7683     # Transform all the library objects into standard objects.
7684 michael 945 compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7685     finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7686 michael 912 fi
7687    
7688 michael 945 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7689 michael 912
7690 michael 945 # template prelinking step
7691     if test -n "$prelink_cmds"; then
7692     func_execute_cmds "$prelink_cmds" 'exit $?'
7693 michael 912 fi
7694    
7695 michael 945 wrappers_required=yes
7696     case $host in
7697     *cygwin* | *mingw* )
7698     if test "$build_libtool_libs" != yes; then
7699     wrappers_required=no
7700     fi
7701     ;;
7702     *cegcc)
7703     # Disable wrappers for cegcc, we are cross compiling anyway.
7704     wrappers_required=no
7705     ;;
7706     *)
7707     if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7708     wrappers_required=no
7709     fi
7710     ;;
7711     esac
7712     if test "$wrappers_required" = no; then
7713 michael 912 # Replace the output file specification.
7714 michael 945 compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7715 michael 912 link_command="$compile_command$compile_rpath"
7716    
7717     # We have no uninstalled library dependencies, so finalize right now.
7718 michael 945 exit_status=0
7719     func_show_eval "$link_command" 'exit_status=$?'
7720 michael 912
7721     # Delete the generated files.
7722 michael 945 if test -f "$output_objdir/${outputname}S.${objext}"; then
7723     func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7724 michael 912 fi
7725    
7726     exit $exit_status
7727     fi
7728    
7729     if test -n "$compile_shlibpath$finalize_shlibpath"; then
7730     compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7731     fi
7732     if test -n "$finalize_shlibpath"; then
7733     finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7734     fi
7735    
7736     compile_var=
7737     finalize_var=
7738     if test -n "$runpath_var"; then
7739     if test -n "$perm_rpath"; then
7740     # We should set the runpath_var.
7741     rpath=
7742     for dir in $perm_rpath; do
7743     rpath="$rpath$dir:"
7744     done
7745     compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7746     fi
7747     if test -n "$finalize_perm_rpath"; then
7748     # We should set the runpath_var.
7749     rpath=
7750     for dir in $finalize_perm_rpath; do
7751     rpath="$rpath$dir:"
7752     done
7753     finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7754     fi
7755     fi
7756    
7757     if test "$no_install" = yes; then
7758     # We don't need to create a wrapper script.
7759     link_command="$compile_var$compile_command$compile_rpath"
7760     # Replace the output file specification.
7761 michael 945 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7762 michael 912 # Delete the old output file.
7763 michael 945 $opt_dry_run || $RM $output
7764 michael 912 # Link the executable and exit
7765 michael 945 func_show_eval "$link_command" 'exit $?'
7766 michael 912 exit $EXIT_SUCCESS
7767     fi
7768    
7769     if test "$hardcode_action" = relink; then
7770     # Fast installation is not supported
7771     link_command="$compile_var$compile_command$compile_rpath"
7772     relink_command="$finalize_var$finalize_command$finalize_rpath"
7773    
7774 michael 945 func_warning "this platform does not like uninstalled shared libraries"
7775     func_warning "\`$output' will be relinked during installation"
7776 michael 912 else
7777     if test "$fast_install" != no; then
7778     link_command="$finalize_var$compile_command$finalize_rpath"
7779     if test "$fast_install" = yes; then
7780 michael 945 relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7781 michael 912 else
7782     # fast_install is set to needless
7783     relink_command=
7784     fi
7785     else
7786     link_command="$compile_var$compile_command$compile_rpath"
7787     relink_command="$finalize_var$finalize_command$finalize_rpath"
7788     fi
7789     fi
7790    
7791     # Replace the output file specification.
7792 michael 945 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7793 michael 912
7794     # Delete the old output files.
7795 michael 945 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7796 michael 912
7797 michael 945 func_show_eval "$link_command" 'exit $?'
7798 michael 912
7799     # Now create the wrapper script.
7800 michael 945 func_verbose "creating $output"
7801 michael 912
7802     # Quote the relink command for shipping.
7803     if test -n "$relink_command"; then
7804     # Preserve any variables that may affect compiler behavior
7805     for var in $variables_saved_for_relink; do
7806     if eval test -z \"\${$var+set}\"; then
7807 michael 945 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7808 michael 912 elif eval var_value=\$$var; test -z "$var_value"; then
7809     relink_command="$var=; export $var; $relink_command"
7810     else
7811 michael 945 func_quote_for_eval "$var_value"
7812     relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7813 michael 912 fi
7814     done
7815     relink_command="(cd `pwd`; $relink_command)"
7816 michael 945 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7817 michael 912 fi
7818    
7819 michael 945 # Quote $ECHO for shipping.
7820     if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7821 michael 912 case $progpath in
7822     [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7823     *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7824     esac
7825 michael 945 qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7826 michael 912 else
7827 michael 945 qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7828 michael 912 fi
7829    
7830 michael 945 # Only actually do things if not in dry run mode.
7831     $opt_dry_run || {
7832 michael 912 # win32 will think the script is a binary if it has
7833     # a .exe suffix, so we strip it off here.
7834     case $output in
7835 michael 945 *.exe) func_stripname '' '.exe' "$output"
7836     output=$func_stripname_result ;;
7837 michael 912 esac
7838     # test for cygwin because mv fails w/o .exe extensions
7839     case $host in
7840     *cygwin*)
7841     exeext=.exe
7842 michael 945 func_stripname '' '.exe' "$outputname"
7843     outputname=$func_stripname_result ;;
7844 michael 912 *) exeext= ;;
7845     esac
7846     case $host in
7847     *cygwin* | *mingw* )
7848 michael 945 func_dirname_and_basename "$output" "" "."
7849     output_name=$func_basename_result
7850     output_path=$func_dirname_result
7851     cwrappersource="$output_path/$objdir/lt-$output_name.c"
7852     cwrapper="$output_path/$output_name.exe"
7853     $RM $cwrappersource $cwrapper
7854     trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7855 michael 912
7856 michael 945 func_emit_cwrapperexe_src > $cwrappersource
7857 michael 912
7858 michael 945 # The wrapper executable is built using the $host compiler,
7859     # because it contains $host paths and files. If cross-
7860     # compiling, it, like the target executable, must be
7861     # executed on the $host or under an emulation environment.
7862     $opt_dry_run || {
7863     $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7864     $STRIP $cwrapper
7865     }
7866 michael 912
7867 michael 945 # Now, create the wrapper script for func_source use:
7868     func_ltwrapper_scriptname $cwrapper
7869     $RM $func_ltwrapper_scriptname_result
7870     trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7871     $opt_dry_run || {
7872     # note: this script will not be executed, so do not chmod.
7873     if test "x$build" = "x$host" ; then
7874     $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7875     else
7876     func_emit_wrapper no > $func_ltwrapper_scriptname_result
7877     fi
7878     }
7879 michael 912 ;;
7880 michael 945 * )
7881     $RM $output
7882     trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7883 michael 912
7884 michael 945 func_emit_wrapper no > $output
7885     chmod +x $output
7886 michael 912 ;;
7887     esac
7888 michael 945 }
7889 michael 912 exit $EXIT_SUCCESS
7890     ;;
7891     esac
7892    
7893     # See if we need to build an old-fashioned archive.
7894     for oldlib in $oldlibs; do
7895    
7896     if test "$build_libtool_libs" = convenience; then
7897 michael 945 oldobjs="$libobjs_save $symfileobj"
7898 michael 912 addlibs="$convenience"
7899     build_libtool_libs=no
7900     else
7901     if test "$build_libtool_libs" = module; then
7902     oldobjs="$libobjs_save"
7903     build_libtool_libs=no
7904     else
7905     oldobjs="$old_deplibs $non_pic_objects"
7906 michael 945 if test "$preload" = yes && test -f "$symfileobj"; then
7907     oldobjs="$oldobjs $symfileobj"
7908     fi
7909 michael 912 fi
7910     addlibs="$old_convenience"
7911     fi
7912    
7913     if test -n "$addlibs"; then
7914     gentop="$output_objdir/${outputname}x"
7915     generated="$generated $gentop"
7916    
7917     func_extract_archives $gentop $addlibs
7918     oldobjs="$oldobjs $func_extract_archives_result"
7919     fi
7920    
7921     # Do each command in the archive commands.
7922     if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7923 michael 945 cmds=$old_archive_from_new_cmds
7924 michael 912 else
7925 michael 945
7926     # Add any objects from preloaded convenience libraries
7927     if test -n "$dlprefiles"; then
7928     gentop="$output_objdir/${outputname}x"
7929     generated="$generated $gentop"
7930    
7931     func_extract_archives $gentop $dlprefiles
7932     oldobjs="$oldobjs $func_extract_archives_result"
7933     fi
7934    
7935 michael 912 # POSIX demands no paths to be encoded in archives. We have
7936     # to avoid creating archives with duplicate basenames if we
7937     # might have to extract them afterwards, e.g., when creating a
7938     # static archive out of a convenience library, or when linking
7939     # the entirety of a libtool archive into another (currently
7940     # not supported by libtool).
7941     if (for obj in $oldobjs
7942     do
7943 michael 945 func_basename "$obj"
7944     $ECHO "$func_basename_result"
7945 michael 912 done | sort | sort -uc >/dev/null 2>&1); then
7946     :
7947     else
7948 michael 945 $ECHO "copying selected object files to avoid basename conflicts..."
7949     gentop="$output_objdir/${outputname}x"
7950     generated="$generated $gentop"
7951     func_mkdir_p "$gentop"
7952 michael 912 save_oldobjs=$oldobjs
7953     oldobjs=
7954     counter=1
7955     for obj in $save_oldobjs
7956     do
7957 michael 945 func_basename "$obj"
7958     objbase="$func_basename_result"
7959 michael 912 case " $oldobjs " in
7960     " ") oldobjs=$obj ;;
7961     *[\ /]"$objbase "*)
7962     while :; do
7963     # Make sure we don't pick an alternate name that also
7964     # overlaps.
7965     newobj=lt$counter-$objbase
7966 michael 945 func_arith $counter + 1
7967     counter=$func_arith_result
7968 michael 912 case " $oldobjs " in
7969     *[\ /]"$newobj "*) ;;
7970     *) if test ! -f "$gentop/$newobj"; then break; fi ;;
7971     esac
7972     done
7973 michael 945 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7974 michael 912 oldobjs="$oldobjs $gentop/$newobj"
7975     ;;
7976     *) oldobjs="$oldobjs $obj" ;;
7977     esac
7978     done
7979     fi
7980     eval cmds=\"$old_archive_cmds\"
7981    
7982 michael 945 func_len " $cmds"
7983     len=$func_len_result
7984     if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7985 michael 912 cmds=$old_archive_cmds
7986     else
7987     # the command line is too long to link in one step, link in parts
7988 michael 945 func_verbose "using piecewise archive linking..."
7989 michael 912 save_RANLIB=$RANLIB
7990     RANLIB=:
7991     objlist=
7992     concat_cmds=
7993     save_oldobjs=$oldobjs
7994 michael 945 oldobjs=
7995 michael 912 # Is there a better way of finding the last object in the list?
7996     for obj in $save_oldobjs
7997     do
7998     last_oldobj=$obj
7999     done
8000 michael 945 eval test_cmds=\"$old_archive_cmds\"
8001     func_len " $test_cmds"
8002     len0=$func_len_result
8003     len=$len0
8004 michael 912 for obj in $save_oldobjs
8005     do
8006 michael 945 func_len " $obj"
8007     func_arith $len + $func_len_result
8008     len=$func_arith_result
8009     func_append objlist " $obj"
8010     if test "$len" -lt "$max_cmd_len"; then
8011 michael 912 :
8012     else
8013     # the above command should be used before it gets too long
8014     oldobjs=$objlist
8015     if test "$obj" = "$last_oldobj" ; then
8016 michael 945 RANLIB=$save_RANLIB
8017 michael 912 fi
8018     test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8019     eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8020     objlist=
8021 michael 945 len=$len0
8022 michael 912 fi
8023     done
8024     RANLIB=$save_RANLIB
8025     oldobjs=$objlist
8026     if test "X$oldobjs" = "X" ; then
8027     eval cmds=\"\$concat_cmds\"
8028     else
8029     eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8030     fi
8031     fi
8032     fi
8033 michael 945 func_execute_cmds "$cmds" 'exit $?'
8034 michael 912 done
8035    
8036 michael 945 test -n "$generated" && \
8037     func_show_eval "${RM}r$generated"
8038 michael 912
8039     # Now create the libtool archive.
8040     case $output in
8041     *.la)
8042     old_library=
8043     test "$build_old_libs" = yes && old_library="$libname.$libext"
8044 michael 945 func_verbose "creating $output"
8045 michael 912
8046     # Preserve any variables that may affect compiler behavior
8047     for var in $variables_saved_for_relink; do
8048     if eval test -z \"\${$var+set}\"; then
8049 michael 945 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8050 michael 912 elif eval var_value=\$$var; test -z "$var_value"; then
8051     relink_command="$var=; export $var; $relink_command"
8052     else
8053 michael 945 func_quote_for_eval "$var_value"
8054     relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8055 michael 912 fi
8056     done
8057     # Quote the link command for shipping.
8058     relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8059 michael 945 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8060 michael 912 if test "$hardcode_automatic" = yes ; then
8061     relink_command=
8062     fi
8063    
8064     # Only create the output if not a dry run.
8065 michael 945 $opt_dry_run || {
8066 michael 912 for installed in no yes; do
8067     if test "$installed" = yes; then
8068     if test -z "$install_libdir"; then
8069     break
8070     fi
8071     output="$output_objdir/$outputname"i
8072     # Replace all uninstalled libtool libraries with the installed ones
8073     newdependency_libs=
8074     for deplib in $dependency_libs; do
8075     case $deplib in
8076     *.la)
8077 michael 945 func_basename "$deplib"
8078     name="$func_basename_result"
8079 michael 912 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8080 michael 945 test -z "$libdir" && \
8081     func_fatal_error "\`$deplib' is not a valid libtool archive"
8082 michael 912 newdependency_libs="$newdependency_libs $libdir/$name"
8083     ;;
8084     *) newdependency_libs="$newdependency_libs $deplib" ;;
8085     esac
8086     done
8087     dependency_libs="$newdependency_libs"
8088     newdlfiles=
8089 michael 945
8090 michael 912 for lib in $dlfiles; do
8091 michael 945 case $lib in
8092     *.la)
8093     func_basename "$lib"
8094     name="$func_basename_result"
8095     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8096     test -z "$libdir" && \
8097     func_fatal_error "\`$lib' is not a valid libtool archive"
8098     newdlfiles="$newdlfiles $libdir/$name"
8099     ;;
8100     *) newdlfiles="$newdlfiles $lib" ;;
8101     esac
8102 michael 912 done
8103     dlfiles="$newdlfiles"
8104     newdlprefiles=
8105     for lib in $dlprefiles; do
8106 michael 945 case $lib in
8107     *.la)
8108     # Only pass preopened files to the pseudo-archive (for
8109     # eventual linking with the app. that links it) if we
8110     # didn't already link the preopened objects directly into
8111     # the library:
8112     func_basename "$lib"
8113     name="$func_basename_result"
8114     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8115     test -z "$libdir" && \
8116     func_fatal_error "\`$lib' is not a valid libtool archive"
8117     newdlprefiles="$newdlprefiles $libdir/$name"
8118     ;;
8119     esac
8120 michael 912 done
8121     dlprefiles="$newdlprefiles"
8122     else
8123     newdlfiles=
8124     for lib in $dlfiles; do
8125     case $lib in
8126     [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8127     *) abs=`pwd`"/$lib" ;;
8128     esac
8129     newdlfiles="$newdlfiles $abs"
8130     done
8131     dlfiles="$newdlfiles"
8132     newdlprefiles=
8133     for lib in $dlprefiles; do
8134     case $lib in
8135     [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8136     *) abs=`pwd`"/$lib" ;;
8137     esac
8138     newdlprefiles="$newdlprefiles $abs"
8139     done
8140     dlprefiles="$newdlprefiles"
8141     fi
8142 michael 945 $RM $output
8143 michael 912 # place dlname in correct position for cygwin
8144     tdlname=$dlname
8145     case $host,$output,$installed,$module,$dlname in
8146 michael 945 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8147 michael 912 esac
8148 michael 945 $ECHO > $output "\
8149 michael 912 # $outputname - a libtool library file
8150 michael 945 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8151 michael 912 #
8152     # Please DO NOT delete this file!
8153     # It is necessary for linking the library.
8154    
8155     # The name that we can dlopen(3).
8156     dlname='$tdlname'
8157    
8158     # Names of this library.
8159     library_names='$library_names'
8160    
8161     # The name of the static archive.
8162     old_library='$old_library'
8163    
8164 michael 945 # Linker flags that can not go in dependency_libs.
8165     inherited_linker_flags='$new_inherited_linker_flags'
8166    
8167 michael 912 # Libraries that this one depends upon.
8168     dependency_libs='$dependency_libs'
8169    
8170 michael 945 # Names of additional weak libraries provided by this library
8171     weak_library_names='$weak_libs'
8172    
8173 michael 912 # Version information for $libname.
8174     current=$current
8175     age=$age
8176     revision=$revision
8177    
8178     # Is this an already installed library?
8179     installed=$installed
8180    
8181     # Should we warn about portability when linking against -modules?
8182     shouldnotlink=$module
8183    
8184     # Files to dlopen/dlpreopen
8185     dlopen='$dlfiles'
8186     dlpreopen='$dlprefiles'
8187    
8188     # Directory that this library needs to be installed in:
8189     libdir='$install_libdir'"
8190     if test "$installed" = no && test "$need_relink" = yes; then
8191 michael 945 $ECHO >> $output "\
8192 michael 912 relink_command=\"$relink_command\""
8193     fi
8194     done
8195 michael 945 }
8196 michael 912
8197     # Do a symbolic link so that the libtool archive can be found in
8198     # LD_LIBRARY_PATH before the program is installed.
8199 michael 945 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8200 michael 912 ;;
8201     esac
8202     exit $EXIT_SUCCESS
8203 michael 945 }
8204 michael 912
8205 michael 945 { test "$mode" = link || test "$mode" = relink; } &&
8206     func_mode_link ${1+"$@"}
8207 michael 912
8208    
8209 michael 945 # func_mode_uninstall arg...
8210     func_mode_uninstall ()
8211     {
8212     $opt_debug
8213     RM="$nonopt"
8214 michael 912 files=
8215     rmforce=
8216     exit_status=0
8217    
8218     # This variable tells wrapper scripts just to set variables rather
8219     # than running their programs.
8220     libtool_install_magic="$magic"
8221    
8222     for arg
8223     do
8224     case $arg in
8225 michael 945 -f) RM="$RM $arg"; rmforce=yes ;;
8226     -*) RM="$RM $arg" ;;
8227 michael 912 *) files="$files $arg" ;;
8228     esac
8229     done
8230    
8231 michael 945 test -z "$RM" && \
8232     func_fatal_help "you must specify an RM program"
8233 michael 912
8234     rmdirs=
8235    
8236     origobjdir="$objdir"
8237     for file in $files; do
8238 michael 945 func_dirname "$file" "" "."
8239     dir="$func_dirname_result"
8240     if test "X$dir" = X.; then
8241 michael 912 objdir="$origobjdir"
8242     else
8243     objdir="$dir/$origobjdir"
8244     fi
8245 michael 945 func_basename "$file"
8246     name="$func_basename_result"
8247 michael 912 test "$mode" = uninstall && objdir="$dir"
8248    
8249     # Remember objdir for removal later, being careful to avoid duplicates
8250     if test "$mode" = clean; then
8251     case " $rmdirs " in
8252     *" $objdir "*) ;;
8253     *) rmdirs="$rmdirs $objdir" ;;
8254     esac
8255     fi
8256    
8257     # Don't error if the file doesn't exist and rm -f was used.
8258 michael 945 if { test -L "$file"; } >/dev/null 2>&1 ||
8259     { test -h "$file"; } >/dev/null 2>&1 ||
8260     test -f "$file"; then
8261 michael 912 :
8262     elif test -d "$file"; then
8263     exit_status=1
8264     continue
8265     elif test "$rmforce" = yes; then
8266     continue
8267     fi
8268    
8269     rmfiles="$file"
8270    
8271     case $name in
8272     *.la)
8273     # Possibly a libtool archive, so verify it.
8274 michael 945 if func_lalib_p "$file"; then
8275     func_source $dir/$name
8276 michael 912
8277     # Delete the libtool libraries and symlinks.
8278     for n in $library_names; do
8279     rmfiles="$rmfiles $objdir/$n"
8280     done
8281     test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8282    
8283     case "$mode" in
8284     clean)
8285     case " $library_names " in
8286     # " " in the beginning catches empty $dlname
8287     *" $dlname "*) ;;
8288     *) rmfiles="$rmfiles $objdir/$dlname" ;;
8289     esac
8290 michael 945 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8291 michael 912 ;;
8292     uninstall)
8293     if test -n "$library_names"; then
8294     # Do each command in the postuninstall commands.
8295 michael 945 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8296 michael 912 fi
8297    
8298     if test -n "$old_library"; then
8299     # Do each command in the old_postuninstall commands.
8300 michael 945 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8301 michael 912 fi
8302     # FIXME: should reinstall the best remaining shared library.
8303     ;;
8304     esac
8305     fi
8306     ;;
8307    
8308     *.lo)
8309     # Possibly a libtool object, so verify it.
8310 michael 945 if func_lalib_p "$file"; then
8311 michael 912
8312     # Read the .lo file
8313 michael 945 func_source $dir/$name
8314 michael 912
8315     # Add PIC object to the list of files to remove.
8316 michael 945 if test -n "$pic_object" &&
8317     test "$pic_object" != none; then
8318 michael 912 rmfiles="$rmfiles $dir/$pic_object"
8319     fi
8320    
8321     # Add non-PIC object to the list of files to remove.
8322 michael 945 if test -n "$non_pic_object" &&
8323     test "$non_pic_object" != none; then
8324 michael 912 rmfiles="$rmfiles $dir/$non_pic_object"
8325     fi
8326     fi
8327     ;;
8328    
8329     *)
8330     if test "$mode" = clean ; then
8331     noexename=$name
8332     case $file in
8333     *.exe)
8334 michael 945 func_stripname '' '.exe' "$file"
8335     file=$func_stripname_result
8336     func_stripname '' '.exe' "$name"
8337     noexename=$func_stripname_result
8338 michael 912 # $file with .exe has already been added to rmfiles,
8339     # add $file without .exe
8340     rmfiles="$rmfiles $file"
8341     ;;
8342     esac
8343     # Do a test to see if this is a libtool program.
8344 michael 945 if func_ltwrapper_p "$file"; then
8345     if func_ltwrapper_executable_p "$file"; then
8346     func_ltwrapper_scriptname "$file"
8347     relink_command=
8348     func_source $func_ltwrapper_scriptname_result
8349     rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8350     else
8351     relink_command=
8352     func_source $dir/$noexename
8353     fi
8354 michael 912
8355     # note $name still contains .exe if it was in $file originally
8356     # as does the version of $file that was added into $rmfiles
8357     rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8358     if test "$fast_install" = yes && test -n "$relink_command"; then
8359     rmfiles="$rmfiles $objdir/lt-$name"
8360     fi
8361     if test "X$noexename" != "X$name" ; then
8362     rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8363     fi
8364     fi
8365     fi
8366     ;;
8367     esac
8368 michael 945 func_show_eval "$RM $rmfiles" 'exit_status=1'
8369 michael 912 done
8370     objdir="$origobjdir"
8371    
8372     # Try to remove the ${objdir}s in the directories where we deleted files
8373     for dir in $rmdirs; do
8374     if test -d "$dir"; then
8375 michael 945 func_show_eval "rmdir $dir >/dev/null 2>&1"
8376 michael 912 fi
8377     done
8378    
8379     exit $exit_status
8380 michael 945 }
8381 michael 912
8382 michael 945 { test "$mode" = uninstall || test "$mode" = clean; } &&
8383     func_mode_uninstall ${1+"$@"}
8384 michael 912
8385 michael 945 test -z "$mode" && {
8386     help="$generic_help"
8387     func_fatal_help "you must specify a MODE"
8388     }
8389 michael 912
8390 michael 945 test -z "$exec_cmd" && \
8391     func_fatal_help "invalid operation mode \`$mode'"
8392    
8393 michael 912 if test -n "$exec_cmd"; then
8394 michael 945 eval exec "$exec_cmd"
8395 michael 912 exit $EXIT_FAILURE
8396     fi
8397    
8398 michael 945 exit $exit_status
8399 michael 912
8400    
8401     # The TAGs below are defined such that we never get into a situation
8402     # in which we disable both kinds of libraries. Given conflicting
8403     # choices, we go for a static library, that is the most portable,
8404     # since we can't tell whether shared libraries were disabled because
8405     # the user asked for that or because the platform doesn't support
8406     # them. This is particularly important on AIX, because we don't
8407     # support having both static and shared libraries enabled at the same
8408     # time on that platform, so we default to a shared-only configuration.
8409     # If a disable-shared tag is given, we'll fallback to a static-only
8410     # configuration. But we'll never go from static-only to shared-only.
8411    
8412     # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8413 michael 945 build_libtool_libs=no
8414     build_old_libs=yes
8415 michael 912 # ### END LIBTOOL TAG CONFIG: disable-shared
8416    
8417     # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8418 michael 945 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8419 michael 912 # ### END LIBTOOL TAG CONFIG: disable-static
8420    
8421     # Local Variables:
8422     # mode:shell-script
8423     # sh-indentation:2
8424     # End:
8425 michael 945 # vi:sw=2
8426    

Properties

Name Value
svn:eol-style native
svn:executable *