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