OSDN Git Service

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