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