/[pcre]/code/trunk/ltmain.sh
ViewVC logotype

Contents of /code/trunk/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log


Revision 87 - (show annotations) (download) (as text)
Sat Feb 24 21:41:21 2007 UTC (7 years, 1 month ago) by nigel
File MIME type: application/x-sh
File size: 200488 byte(s)
Load pcre-6.5 into code/trunk.

1 # ltmain.sh - Provide generalized library-building support services.
2 # NOTE: Changing this file will not affect anything until you rerun configure.
3 #
4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
5 # Free Software Foundation, Inc.
6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #
13 # This program is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 # General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 #
22 # As a special exception to the GNU General Public License, if you
23 # distribute this file as part of a program that contains a
24 # configuration script generated by Autoconf, you may include it under
25 # the same distribution terms that you use for the rest of that program.
26
27 basename="s,^.*/,,g"
28
29 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
30 # is ksh but when the shell is invoked as "sh" and the current value of
31 # the _XPG environment variable is not equal to 1 (one), the special
32 # positional parameter $0, within a function call, is the name of the
33 # function.
34 progpath="$0"
35
36 # define SED for historic ltconfig's generated by Libtool 1.3
37 test -z "$SED" && SED=sed
38
39 # The name of this program:
40 progname=`echo "$progpath" | $SED $basename`
41 modename="$progname"
42
43 # Global variables:
44 EXIT_SUCCESS=0
45 EXIT_FAILURE=1
46
47 PROGRAM=ltmain.sh
48 PACKAGE=libtool
49 VERSION=1.5.22
50 TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
51
52 # See if we are running on zsh, and set the options which allow our
53 # commands through without removal of \ escapes.
54 if test -n "${ZSH_VERSION+set}" ; then
55 setopt NO_GLOB_SUBST
56 fi
57 # Same for EGREP, and just to be sure, do LTCC as well
58 if test "X$EGREP" = X ; then
59 EGREP=egrep
60 fi
61 if test "X$LTCC" = X ; then
62 LTCC=${CC-gcc}
63 fi
64
65 # Check that we have a working $echo.
66 if test "X$1" = X--no-reexec; then
67 # Discard the --no-reexec flag, and continue.
68 shift
69 elif test "X$1" = X--fallback-echo; then
70 # Avoid inline document here, it may be left over
71 :
72 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
73 # Yippee, $echo works!
74 :
75 else
76 # Restart under the correct shell, and then maybe $echo will work.
77 exec $SHELL "$progpath" --no-reexec ${1+"$@"}
78 fi
79
80 if test "X$1" = X--fallback-echo; then
81 # used as fallback echo
82 shift
83 cat <<EOF
84 $*
85 EOF
86 exit $EXIT_SUCCESS
87 fi
88
89 default_mode=
90 help="Try \`$progname --help' for more information."
91 magic="%%%MAGIC variable%%%"
92 mkdir="mkdir"
93 mv="mv -f"
94 rm="rm -f"
95
96 # Sed substitution that helps us do robust quoting. It backslashifies
97 # metacharacters that are still active within double-quoted strings.
98 Xsed="${SED}"' -e 1s/^X//'
99 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
100 # test EBCDIC or ASCII
101 case `echo X|tr X '\101'` in
102 A) # ASCII based system
103 # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
104 SP2NL='tr \040 \012'
105 NL2SP='tr \015\012 \040\040'
106 ;;
107 *) # EBCDIC based system
108 SP2NL='tr \100 \n'
109 NL2SP='tr \r\n \100\100'
110 ;;
111 esac
112
113 # NLS nuisances.
114 # Only set LANG and LC_ALL to C if already set.
115 # These must not be set unconditionally because not all systems understand
116 # e.g. LANG=C (notably SCO).
117 # We save the old values to restore during execute mode.
118 if test "${LC_ALL+set}" = set; then
119 save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
120 fi
121 if test "${LANG+set}" = set; then
122 save_LANG="$LANG"; LANG=C; export LANG
123 fi
124
125 # Make sure IFS has a sensible default
126 lt_nl='
127 '
128 IFS=" $lt_nl"
129
130 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
131 $echo "$modename: not configured to build any kind of library" 1>&2
132 $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
133 exit $EXIT_FAILURE
134 fi
135
136 # Global variables.
137 mode=$default_mode
138 nonopt=
139 prev=
140 prevopt=
141 run=
142 show="$echo"
143 show_help=
144 execute_dlfiles=
145 duplicate_deps=no
146 preserve_args=
147 lo2o="s/\\.lo\$/.${objext}/"
148 o2lo="s/\\.${objext}\$/.lo/"
149
150 if test -z "$max_cmd_len"; then
151 i=0
152 testring="ABCD"
153 new_result=
154
155 # If test is not a shell built-in, we'll probably end up computing a
156 # maximum length that is only half of the actual maximum length, but
157 # we can't tell.
158 while (test "X"`$SHELL $0 --fallback-echo "X$testring" 2>/dev/null` \
159 = "XX$testring") >/dev/null 2>&1 &&
160 new_result=`expr "X$testring" : ".*" 2>&1` &&
161 max_cmd_len="$new_result" &&
162 test "$i" != 17 # 1/2 MB should be enough
163 do
164 i=`expr $i + 1`
165 testring="$testring$testring"
166 done
167 testring=
168 # Add a significant safety factor because C++ compilers can tack on massive
169 # amounts of additional arguments before passing them to the linker.
170 # It appears as though 1/2 is a usable value.
171 max_cmd_len=`expr $max_cmd_len \/ 2`
172 fi
173
174 #####################################
175 # Shell function definitions:
176 # This seems to be the best place for them
177
178 # func_mktempdir [string]
179 # Make a temporary directory that won't clash with other running
180 # libtool processes, and avoids race conditions if possible. If
181 # given, STRING is the basename for that directory.
182 func_mktempdir ()
183 {
184 my_template="${TMPDIR-/tmp}/${1-$progname}"
185
186 if test "$run" = ":"; then
187 # Return a directory name, but don't create it in dry-run mode
188 my_tmpdir="${my_template}-$$"
189 else
190
191 # If mktemp works, use that first and foremost
192 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
193
194 if test ! -d "$my_tmpdir"; then
195 # Failing that, at least try and use $RANDOM to avoid a race
196 my_tmpdir="${my_template}-${RANDOM-0}$$"
197
198 save_mktempdir_umask=`umask`
199 umask 0077
200 $mkdir "$my_tmpdir"
201 umask $save_mktempdir_umask
202 fi
203
204 # If we're not in dry-run mode, bomb out on failure
205 test -d "$my_tmpdir" || {
206 $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
207 exit $EXIT_FAILURE
208 }
209 fi
210
211 $echo "X$my_tmpdir" | $Xsed
212 }
213
214
215 # func_win32_libid arg
216 # return the library type of file 'arg'
217 #
218 # Need a lot of goo to handle *both* DLLs and import libs
219 # Has to be a shell function in order to 'eat' the argument
220 # that is supplied when $file_magic_command is called.
221 func_win32_libid ()
222 {
223 win32_libid_type="unknown"
224 win32_fileres=`file -L $1 2>/dev/null`
225 case $win32_fileres in
226 *ar\ archive\ import\ library*) # definitely import
227 win32_libid_type="x86 archive import"
228 ;;
229 *ar\ archive*) # could be an import, or static
230 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
231 $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
232 win32_nmres=`eval $NM -f posix -A $1 | \
233 $SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`
234 case $win32_nmres in
235 import*) win32_libid_type="x86 archive import";;
236 *) win32_libid_type="x86 archive static";;
237 esac
238 fi
239 ;;
240 *DLL*)
241 win32_libid_type="x86 DLL"
242 ;;
243 *executable*) # but shell scripts are "executable" too...
244 case $win32_fileres in
245 *MS\ Windows\ PE\ Intel*)
246 win32_libid_type="x86 DLL"
247 ;;
248 esac
249 ;;
250 esac
251 $echo $win32_libid_type
252 }
253
254
255 # func_infer_tag arg
256 # Infer tagged configuration to use if any are available and
257 # if one wasn't chosen via the "--tag" command line option.
258 # Only attempt this if the compiler in the base compile
259 # command doesn't match the default compiler.
260 # arg is usually of the form 'gcc ...'
261 func_infer_tag ()
262 {
263 if test -n "$available_tags" && test -z "$tagname"; then
264 CC_quoted=
265 for arg in $CC; do
266 case $arg in
267 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
268 arg="\"$arg\""
269 ;;
270 esac
271 CC_quoted="$CC_quoted $arg"
272 done
273 case $@ in
274 # Blanks in the command may have been stripped by the calling shell,
275 # but not from the CC environment variable when configure was run.
276 " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
277 # Blanks at the start of $base_compile will cause this to fail
278 # if we don't check for them as well.
279 *)
280 for z in $available_tags; do
281 if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
282 # Evaluate the configuration.
283 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
284 CC_quoted=
285 for arg in $CC; do
286 # Double-quote args containing other shell metacharacters.
287 case $arg in
288 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
289 arg="\"$arg\""
290 ;;
291 esac
292 CC_quoted="$CC_quoted $arg"
293 done
294 # user sometimes does CC=<HOST>-gcc so we need to match that to 'gcc'
295 trimedcc=`echo ${CC} | $SED -e "s/${host}-//g"`
296 # and sometimes libtool has CC=<HOST>-gcc but user does CC=gcc
297 extendcc=${host}-${CC}
298 # and sometimes libtool has CC=<OLDHOST>-gcc but user has CC=<NEWHOST>-gcc
299 # (Gentoo-specific hack because we always export $CHOST)
300 mungedcc=${CHOST-${host}}-${trimedcc}
301 case "$@ " in
302 "cc "* | " cc "* | "${host}-cc "* | " ${host}-cc "*|\
303 "gcc "* | " gcc "* | "${host}-gcc "* | " ${host}-gcc "*)
304 tagname=CC
305 break ;;
306 "$trimedcc "* | " $trimedcc "* | "`$echo $trimedcc` "* | " `$echo $trimedcc` "*|\
307 "$extendcc "* | " $extendcc "* | "`$echo $extendcc` "* | " `$echo $extendcc` "*|\
308 "$mungedcc "* | " $mungedcc "* | "`$echo $mungedcc` "* | " `$echo $mungedcc` "*|\
309 " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
310 # The compiler in the base compile command matches
311 # the one in the tagged configuration.
312 # Assume this is the tagged configuration we want.
313 tagname=$z
314 break
315 ;;
316 esac
317 fi
318 done
319 # If $tagname still isn't set, then no tagged configuration
320 # was found and let the user know that the "--tag" command
321 # line option must be used.
322 if test -z "$tagname"; then
323 $echo "$modename: unable to infer tagged configuration"
324 $echo "$modename: specify a tag with \`--tag'" 1>&2
325 exit $EXIT_FAILURE
326 # else
327 # $echo "$modename: using $tagname tagged configuration"
328 fi
329 ;;
330 esac
331 fi
332 }
333
334
335 # func_extract_an_archive dir oldlib
336 func_extract_an_archive ()
337 {
338 f_ex_an_ar_dir="$1"; shift
339 f_ex_an_ar_oldlib="$1"
340
341 $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
342 $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
343 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
344 :
345 else
346 $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
347 exit $EXIT_FAILURE
348 fi
349 }
350
351 # func_extract_archives gentop oldlib ...
352 func_extract_archives ()
353 {
354 my_gentop="$1"; shift
355 my_oldlibs=${1+"$@"}
356 my_oldobjs=""
357 my_xlib=""
358 my_xabs=""
359 my_xdir=""
360 my_status=""
361
362 $show "${rm}r $my_gentop"
363 $run ${rm}r "$my_gentop"
364 $show "$mkdir $my_gentop"
365 $run $mkdir "$my_gentop"
366 my_status=$?
367 if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
368 exit $my_status
369 fi
370
371 for my_xlib in $my_oldlibs; do
372 # Extract the objects.
373 case $my_xlib in
374 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
375 *) my_xabs=`pwd`"/$my_xlib" ;;
376 esac
377 my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
378 my_xdir="$my_gentop/$my_xlib"
379
380 $show "${rm}r $my_xdir"
381 $run ${rm}r "$my_xdir"
382 $show "$mkdir $my_xdir"
383 $run $mkdir "$my_xdir"
384 exit_status=$?
385 if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
386 exit $exit_status
387 fi
388 case $host in
389 *-darwin*)
390 $show "Extracting $my_xabs"
391 # Do not bother doing anything if just a dry run
392 if test -z "$run"; then
393 darwin_orig_dir=`pwd`
394 cd $my_xdir || exit $?
395 darwin_archive=$my_xabs
396 darwin_curdir=`pwd`
397 darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
398 darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
399 if test -n "$darwin_arches"; then
400 darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
401 darwin_arch=
402 $show "$darwin_base_archive has multiple architectures $darwin_arches"
403 for darwin_arch in $darwin_arches ; do
404 mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
405 lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
406 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
407 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
408 cd "$darwin_curdir"
409 $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
410 done # $darwin_arches
411 ## Okay now we have a bunch of thin objects, gotta fatten them up :)
412 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
413 darwin_file=
414 darwin_files=
415 for darwin_file in $darwin_filelist; do
416 darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
417 lipo -create -output "$darwin_file" $darwin_files
418 done # $darwin_filelist
419 ${rm}r unfat-$$
420 cd "$darwin_orig_dir"
421 else
422 cd "$darwin_orig_dir"
423 func_extract_an_archive "$my_xdir" "$my_xabs"
424 fi # $darwin_arches
425 fi # $run
426 ;;
427 *)
428 func_extract_an_archive "$my_xdir" "$my_xabs"
429 ;;
430 esac
431 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
432 done
433 func_extract_archives_result="$my_oldobjs"
434 }
435 # End of Shell function definitions
436 #####################################
437
438 # Darwin sucks
439 eval std_shrext=\"$shrext_cmds\"
440
441 disable_libs=no
442
443 # Parse our command line options once, thoroughly.
444 while test "$#" -gt 0
445 do
446 arg="$1"
447 shift
448
449 case $arg in
450 -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
451 *) optarg= ;;
452 esac
453
454 # If the previous option needs an argument, assign it.
455 if test -n "$prev"; then
456 case $prev in
457 execute_dlfiles)
458 execute_dlfiles="$execute_dlfiles $arg"
459 ;;
460 tag)
461 tagname="$arg"
462 preserve_args="${preserve_args}=$arg"
463
464 # Check whether tagname contains only valid characters
465 case $tagname in
466 *[!-_A-Za-z0-9,/]*)
467 $echo "$progname: invalid tag name: $tagname" 1>&2
468 exit $EXIT_FAILURE
469 ;;
470 esac
471
472 case $tagname in
473 CC)
474 # Don't test for the "default" C tag, as we know, it's there, but
475 # not specially marked.
476 ;;
477 *)
478 if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
479 taglist="$taglist $tagname"
480 # Evaluate the configuration.
481 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
482 else
483 $echo "$progname: ignoring unknown tag $tagname" 1>&2
484 fi
485 ;;
486 esac
487 ;;
488 *)
489 eval "$prev=\$arg"
490 ;;
491 esac
492
493 prev=
494 prevopt=
495 continue
496 fi
497
498 # Have we seen a non-optional argument yet?
499 case $arg in
500 --help)
501 show_help=yes
502 ;;
503
504 --version)
505 $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
506 $echo
507 $echo "Copyright (C) 2005 Free Software Foundation, Inc."
508 $echo "This is free software; see the source for copying conditions. There is NO"
509 $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
510 exit $?
511 ;;
512
513 --config)
514 ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
515 # Now print the configurations for the tags.
516 for tagname in $taglist; do
517 ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
518 done
519 exit $?
520 ;;
521
522 --debug)
523 $echo "$progname: enabling shell trace mode"
524 set -x
525 preserve_args="$preserve_args $arg"
526 ;;
527
528 --dry-run | -n)
529 run=:
530 ;;
531
532 --features)
533 $echo "host: $host"
534 if test "$build_libtool_libs" = yes; then
535 $echo "enable shared libraries"
536 else
537 $echo "disable shared libraries"
538 fi
539 if test "$build_old_libs" = yes; then
540 $echo "enable static libraries"
541 else
542 $echo "disable static libraries"
543 fi
544 exit $?
545 ;;
546
547 --finish) mode="finish" ;;
548
549 --mode) prevopt="--mode" prev=mode ;;
550 --mode=*) mode="$optarg" ;;
551
552 --preserve-dup-deps) duplicate_deps="yes" ;;
553
554 --quiet | --silent)
555 show=:
556 preserve_args="$preserve_args $arg"
557 ;;
558
559 --tag)
560 prevopt="--tag"
561 prev=tag
562 preserve_args="$preserve_args --tag"
563 ;;
564 --tag=*)
565 set tag "$optarg" ${1+"$@"}
566 shift
567 prev=tag
568 preserve_args="$preserve_args --tag"
569 ;;
570
571 -dlopen)
572 prevopt="-dlopen"
573 prev=execute_dlfiles
574 ;;
575
576 -*)
577 $echo "$modename: unrecognized option \`$arg'" 1>&2
578 $echo "$help" 1>&2
579 exit $EXIT_FAILURE
580 ;;
581
582 *)
583 nonopt="$arg"
584 break
585 ;;
586 esac
587 done
588
589 if test -n "$prevopt"; then
590 $echo "$modename: option \`$prevopt' requires an argument" 1>&2
591 $echo "$help" 1>&2
592 exit $EXIT_FAILURE
593 fi
594
595 case $disable_libs in
596 no)
597 ;;
598 shared)
599 build_libtool_libs=no
600 build_old_libs=yes
601 ;;
602 static)
603 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
604 ;;
605 esac
606
607 # If this variable is set in any of the actions, the command in it
608 # will be execed at the end. This prevents here-documents from being
609 # left over by shells.
610 exec_cmd=
611
612 if test -z "$show_help"; then
613
614 # Infer the operation mode.
615 if test -z "$mode"; then
616 $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
617 $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
618 case $nonopt in
619 *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
620 mode=link
621 for arg
622 do
623 case $arg in
624 -c)
625 mode=compile
626 break
627 ;;
628 esac
629 done
630 ;;
631 *db | *dbx | *strace | *truss)
632 mode=execute
633 ;;
634 *install*|cp|mv)
635 mode=install
636 ;;
637 *rm)
638 mode=uninstall
639 ;;
640 *)
641 # If we have no mode, but dlfiles were specified, then do execute mode.
642 test -n "$execute_dlfiles" && mode=execute
643
644 # Just use the default operation mode.
645 if test -z "$mode"; then
646 if test -n "$nonopt"; then
647 $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
648 else
649 $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
650 fi
651 fi
652 ;;
653 esac
654 fi
655
656 # Only execute mode is allowed to have -dlopen flags.
657 if test -n "$execute_dlfiles" && test "$mode" != execute; then
658 $echo "$modename: unrecognized option \`-dlopen'" 1>&2
659 $echo "$help" 1>&2
660 exit $EXIT_FAILURE
661 fi
662
663 # Change the help message to a mode-specific one.
664 generic_help="$help"
665 help="Try \`$modename --help --mode=$mode' for more information."
666
667 # These modes are in order of execution frequency so that they run quickly.
668 case $mode in
669 # libtool compile mode
670 compile)
671 modename="$modename: compile"
672 # Get the compilation command and the source file.
673 base_compile=
674 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
675 suppress_opt=yes
676 suppress_output=
677 arg_mode=normal
678 libobj=
679 later=
680
681 for arg
682 do
683 case $arg_mode in
684 arg )
685 # do not "continue". Instead, add this to base_compile
686 lastarg="$arg"
687 arg_mode=normal
688 ;;
689
690 target )
691 libobj="$arg"
692 arg_mode=normal
693 continue
694 ;;
695
696 normal )
697 # Accept any command-line options.
698 case $arg in
699 -o)
700 if test -n "$libobj" ; then
701 $echo "$modename: you cannot specify \`-o' more than once" 1>&2
702 exit $EXIT_FAILURE
703 fi
704 arg_mode=target
705 continue
706 ;;
707
708 -static | -prefer-pic | -prefer-non-pic)
709 later="$later $arg"
710 continue
711 ;;
712
713 -no-suppress)
714 suppress_opt=no
715 continue
716 ;;
717
718 -Xcompiler)
719 arg_mode=arg # the next one goes into the "base_compile" arg list
720 continue # The current "srcfile" will either be retained or
721 ;; # replaced later. I would guess that would be a bug.
722
723 -Wc,*)
724 args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
725 lastarg=
726 save_ifs="$IFS"; IFS=','
727 for arg in $args; do
728 IFS="$save_ifs"
729
730 # Double-quote args containing other shell metacharacters.
731 # Many Bourne shells cannot handle close brackets correctly
732 # in scan sets, so we specify it separately.
733 case $arg in
734 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
735 arg="\"$arg\""
736 ;;
737 esac
738 lastarg="$lastarg $arg"
739 done
740 IFS="$save_ifs"
741 lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
742
743 # Add the arguments to base_compile.
744 base_compile="$base_compile $lastarg"
745 continue
746 ;;
747
748 * )
749 # Accept the current argument as the source file.
750 # The previous "srcfile" becomes the current argument.
751 #
752 lastarg="$srcfile"
753 srcfile="$arg"
754 ;;
755 esac # case $arg
756 ;;
757 esac # case $arg_mode
758
759 # Aesthetically quote the previous argument.
760 lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
761
762 case $lastarg in
763 # Double-quote args containing other shell metacharacters.
764 # Many Bourne shells cannot handle close brackets correctly
765 # in scan sets, and some SunOS ksh mistreat backslash-escaping
766 # in scan sets (worked around with variable expansion),
767 # and furthermore cannot handle '|' '&' '(' ')' in scan sets
768 # at all, so we specify them separately.
769 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
770 lastarg="\"$lastarg\""
771 ;;
772 esac
773
774 base_compile="$base_compile $lastarg"
775 done # for arg
776
777 case $arg_mode in
778 arg)
779 $echo "$modename: you must specify an argument for -Xcompile"
780 exit $EXIT_FAILURE
781 ;;
782 target)
783 $echo "$modename: you must specify a target with \`-o'" 1>&2
784 exit $EXIT_FAILURE
785 ;;
786 *)
787 # Get the name of the library object.
788 [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
789 ;;
790 esac
791
792 # Recognize several different file suffixes.
793 # If the user specifies -o file.o, it is replaced with file.lo
794 xform='[cCFSifmso]'
795 case $libobj in
796 *.ada) xform=ada ;;
797 *.adb) xform=adb ;;
798 *.ads) xform=ads ;;
799 *.asm) xform=asm ;;
800 *.c++) xform=c++ ;;
801 *.cc) xform=cc ;;
802 *.ii) xform=ii ;;
803 *.class) xform=class ;;
804 *.cpp) xform=cpp ;;
805 *.cxx) xform=cxx ;;
806 *.f90) xform=f90 ;;
807 *.for) xform=for ;;
808 *.java) xform=java ;;
809 esac
810
811 libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
812
813 case $libobj in
814 *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
815 *)
816 $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
817 exit $EXIT_FAILURE
818 ;;
819 esac
820
821 func_infer_tag $base_compile
822
823 for arg in $later; do
824 case $arg in
825 -static)
826 build_old_libs=yes
827 continue
828 ;;
829
830 -prefer-pic)
831 pic_mode=yes
832 continue
833 ;;
834
835 -prefer-non-pic)
836 pic_mode=no
837 continue
838 ;;
839 esac
840 done
841
842 qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
843 case $qlibobj in
844 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
845 qlibobj="\"$qlibobj\"" ;;
846 esac
847 test "X$libobj" != "X$qlibobj" \
848 && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' &()|`$[]' \
849 && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
850 objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
851 xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
852 if test "X$xdir" = "X$obj"; then
853 xdir=
854 else
855 xdir=$xdir/
856 fi
857 lobj=${xdir}$objdir/$objname
858
859 if test -z "$base_compile"; then
860 $echo "$modename: you must specify a compilation command" 1>&2
861 $echo "$help" 1>&2
862 exit $EXIT_FAILURE
863 fi
864
865 # Delete any leftover library objects.
866 if test "$build_old_libs" = yes; then
867 removelist="$obj $lobj $libobj ${libobj}T"
868 else
869 removelist="$lobj $libobj ${libobj}T"
870 fi
871
872 $run $rm $removelist
873 trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
874
875 # On Cygwin there's no "real" PIC flag so we must build both object types
876 case $host_os in
877 cygwin* | mingw* | pw32* | os2*)
878 pic_mode=default
879 ;;
880 esac
881 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
882 # non-PIC code in shared libraries is not supported
883 pic_mode=default
884 fi
885
886 # Calculate the filename of the output object if compiler does
887 # not support -o with -c
888 if test "$compiler_c_o" = no; then
889 output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
890 lockfile="$output_obj.lock"
891 removelist="$removelist $output_obj $lockfile"
892 trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
893 else
894 output_obj=
895 need_locks=no
896 lockfile=
897 fi
898
899 # Lock this critical section if it is needed
900 # We use this script file to make the link, it avoids creating a new file
901 if test "$need_locks" = yes; then
902 until $run ln "$srcfile" "$lockfile" 2>/dev/null; do
903 $show "Waiting for $lockfile to be removed"
904 sleep 2
905 done
906 elif test "$need_locks" = warn; then
907 if test -f "$lockfile"; then
908 $echo "\
909 *** ERROR, $lockfile exists and contains:
910 `cat $lockfile 2>/dev/null`
911
912 This indicates that another process is trying to use the same
913 temporary object file, and libtool could not work around it because
914 your compiler does not support \`-c' and \`-o' together. If you
915 repeat this compilation, it may succeed, by chance, but you had better
916 avoid parallel builds (make -j) in this platform, or get a better
917 compiler."
918
919 $run $rm $removelist
920 exit $EXIT_FAILURE
921 fi
922 $echo "$srcfile" > "$lockfile"
923 fi
924
925 if test -n "$fix_srcfile_path"; then
926 eval srcfile=\"$fix_srcfile_path\"
927 fi
928 qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
929 case $qsrcfile in
930 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
931 qsrcfile="\"$qsrcfile\"" ;;
932 esac
933
934 $run $rm "$libobj" "${libobj}T"
935
936 # Create a libtool object file (analogous to a ".la" file),
937 # but don't create it if we're doing a dry run.
938 test -z "$run" && cat > ${libobj}T <<EOF
939 # $libobj - a libtool object file
940 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
941 #
942 # Please DO NOT delete this file!
943 # It is necessary for linking the library.
944
945 # Name of the PIC object.
946 EOF
947
948 # Only build a PIC object if we are building libtool libraries.
949 if test "$build_libtool_libs" = yes; then
950 # Without this assignment, base_compile gets emptied.
951 fbsd_hideous_sh_bug=$base_compile
952
953 if test "$pic_mode" != no; then
954 command="$base_compile $qsrcfile $pic_flag"
955 else
956 # Don't build PIC code
957 command="$base_compile $qsrcfile"
958 fi
959
960 if test ! -d "${xdir}$objdir"; then
961 $show "$mkdir ${xdir}$objdir"
962 $run $mkdir ${xdir}$objdir
963 exit_status=$?
964 if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
965 exit $exit_status
966 fi
967 fi
968
969 if test -z "$output_obj"; then
970 # Place PIC objects in $objdir
971 command="$command -o $lobj"
972 fi
973
974 $run $rm "$lobj" "$output_obj"
975
976 $show "$command"
977 if $run eval "$command"; then :
978 else
979 test -n "$output_obj" && $run $rm $removelist
980 exit $EXIT_FAILURE
981 fi
982
983 if test "$need_locks" = warn &&
984 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
985 $echo "\
986 *** ERROR, $lockfile contains:
987 `cat $lockfile 2>/dev/null`
988
989 but it should contain:
990 $srcfile
991
992 This indicates that another process is trying to use the same
993 temporary object file, and libtool could not work around it because
994 your compiler does not support \`-c' and \`-o' together. If you
995 repeat this compilation, it may succeed, by chance, but you had better
996 avoid parallel builds (make -j) in this platform, or get a better
997 compiler."
998
999 $run $rm $removelist
1000 exit $EXIT_FAILURE
1001 fi
1002
1003 # Just move the object if needed, then go on to compile the next one
1004 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1005 $show "$mv $output_obj $lobj"
1006 if $run $mv $output_obj $lobj; then :
1007 else
1008 error=$?
1009 $run $rm $removelist
1010 exit $error
1011 fi
1012 fi
1013
1014 # Append the name of the PIC object to the libtool object file.
1015 test -z "$run" && cat >> ${libobj}T <<EOF
1016 pic_object='$objdir/$objname'
1017
1018 EOF
1019
1020 # Allow error messages only from the first compilation.
1021 if test "$suppress_opt" = yes; then
1022 suppress_output=' >/dev/null 2>&1'
1023 fi
1024 else
1025 # No PIC object so indicate it doesn't exist in the libtool
1026 # object file.
1027 test -z "$run" && cat >> ${libobj}T <<EOF
1028 pic_object=none
1029
1030 EOF
1031 fi
1032
1033 # Only build a position-dependent object if we build old libraries.
1034 if test "$build_old_libs" = yes; then
1035 if test "$pic_mode" != yes; then
1036 # Don't build PIC code
1037 command="$base_compile $qsrcfile"
1038 else
1039 command="$base_compile $qsrcfile $pic_flag"
1040 fi
1041 if test "$compiler_c_o" = yes; then
1042 command="$command -o $obj"
1043 fi
1044
1045 # Suppress compiler output if we already did a PIC compilation.
1046 command="$command$suppress_output"
1047 $run $rm "$obj" "$output_obj"
1048 $show "$command"
1049 if $run eval "$command"; then :
1050 else
1051 $run $rm $removelist
1052 exit $EXIT_FAILURE
1053 fi
1054
1055 if test "$need_locks" = warn &&
1056 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1057 $echo "\
1058 *** ERROR, $lockfile contains:
1059 `cat $lockfile 2>/dev/null`
1060
1061 but it should contain:
1062 $srcfile
1063
1064 This indicates that another process is trying to use the same
1065 temporary object file, and libtool could not work around it because
1066 your compiler does not support \`-c' and \`-o' together. If you
1067 repeat this compilation, it may succeed, by chance, but you had better
1068 avoid parallel builds (make -j) in this platform, or get a better
1069 compiler."
1070
1071 $run $rm $removelist
1072 exit $EXIT_FAILURE
1073 fi
1074
1075 # Just move the object if needed
1076 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1077 $show "$mv $output_obj $obj"
1078 if $run $mv $output_obj $obj; then :
1079 else
1080 error=$?
1081 $run $rm $removelist
1082 exit $error
1083 fi
1084 fi
1085
1086 # Append the name of the non-PIC object the libtool object file.
1087 # Only append if the libtool object file exists.
1088 test -z "$run" && cat >> ${libobj}T <<EOF
1089 # Name of the non-PIC object.
1090 non_pic_object='$objname'
1091
1092 EOF
1093 else
1094 # Append the name of the non-PIC object the libtool object file.
1095 # Only append if the libtool object file exists.
1096 test -z "$run" && cat >> ${libobj}T <<EOF
1097 # Name of the non-PIC object.
1098 non_pic_object=none
1099
1100 EOF
1101 fi
1102
1103 $run $mv "${libobj}T" "${libobj}"
1104
1105 # Unlock the critical section if it was locked
1106 if test "$need_locks" != no; then
1107 $run $rm "$lockfile"
1108 fi
1109
1110 exit $EXIT_SUCCESS
1111 ;;
1112
1113 # libtool link mode
1114 link | relink)
1115 modename="$modename: link"
1116 case $host in
1117 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1118 # It is impossible to link a dll without this setting, and
1119 # we shouldn't force the makefile maintainer to figure out
1120 # which system we are compiling for in order to pass an extra
1121 # flag for every libtool invocation.
1122 # allow_undefined=no
1123
1124 # FIXME: Unfortunately, there are problems with the above when trying
1125 # to make a dll which has undefined symbols, in which case not
1126 # even a static library is built. For now, we need to specify
1127 # -no-undefined on the libtool link line when we can be certain
1128 # that all symbols are satisfied, otherwise we get a static library.
1129 allow_undefined=yes
1130 ;;
1131 *)
1132 allow_undefined=yes
1133 ;;
1134 esac
1135 libtool_args="$nonopt"
1136 base_compile="$nonopt $@"
1137 compile_command="$nonopt"
1138 finalize_command="$nonopt"
1139
1140 compile_rpath=
1141 finalize_rpath=
1142 compile_shlibpath=
1143 finalize_shlibpath=
1144 convenience=
1145 old_convenience=
1146 deplibs=
1147 old_deplibs=
1148 compiler_flags=
1149 linker_flags=
1150 dllsearchpath=
1151 lib_search_path=`pwd`
1152 inst_prefix_dir=
1153
1154 avoid_version=no
1155 dlfiles=
1156 dlprefiles=
1157 dlself=no
1158 export_dynamic=no
1159 export_symbols=
1160 export_symbols_regex=
1161 generated=
1162 libobjs=
1163 ltlibs=
1164 module=no
1165 no_install=no
1166 objs=
1167 non_pic_objects=
1168 notinst_path= # paths that contain not-installed libtool libraries
1169 precious_files_regex=
1170 prefer_static_libs=no
1171 preload=no
1172 prev=
1173 prevarg=
1174 release=
1175 rpath=
1176 xrpath=
1177 perm_rpath=
1178 temp_rpath=
1179 thread_safe=no
1180 vinfo=
1181 vinfo_number=no
1182
1183 func_infer_tag $base_compile
1184
1185 # We need to know -static, to get the right output filenames.
1186 for arg
1187 do
1188 case $arg in
1189 -all-static | -static)
1190 if test "X$arg" = "X-all-static"; then
1191 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1192 $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1193 fi
1194 if test -n "$link_static_flag"; then
1195 dlopen_self=$dlopen_self_static
1196 fi
1197 prefer_static_libs=yes
1198 else
1199 if test -z "$pic_flag" && test -n "$link_static_flag"; then
1200 dlopen_self=$dlopen_self_static
1201 fi
1202 prefer_static_libs=built
1203 fi
1204 build_libtool_libs=no
1205 build_old_libs=yes
1206 break
1207 ;;
1208 esac
1209 done
1210
1211 # See if our shared archives depend on static archives.
1212 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1213
1214 # Go through the arguments, transforming them on the way.
1215 while test "$#" -gt 0; do
1216 arg="$1"
1217 shift
1218 case $arg in
1219 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1220 qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1221 ;;
1222 *) qarg=$arg ;;
1223 esac
1224 libtool_args="$libtool_args $qarg"
1225
1226 # If the previous option needs an argument, assign it.
1227 if test -n "$prev"; then
1228 case $prev in
1229 output)
1230 compile_command="$compile_command @OUTPUT@"
1231 finalize_command="$finalize_command @OUTPUT@"
1232 ;;
1233 esac
1234
1235 case $prev in
1236 dlfiles|dlprefiles)
1237 if test "$preload" = no; then
1238 # Add the symbol object into the linking commands.
1239 compile_command="$compile_command @SYMFILE@"
1240 finalize_command="$finalize_command @SYMFILE@"
1241 preload=yes
1242 fi
1243 case $arg in
1244 *.la | *.lo) ;; # We handle these cases below.
1245 force)
1246 if test "$dlself" = no; then
1247 dlself=needless
1248 export_dynamic=yes
1249 fi
1250 prev=
1251 continue
1252 ;;
1253 self)
1254 if test "$prev" = dlprefiles; then
1255 dlself=yes
1256 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1257 dlself=yes
1258 else
1259 dlself=needless
1260 export_dynamic=yes
1261 fi
1262 prev=
1263 continue
1264 ;;
1265 *)
1266 if test "$prev" = dlfiles; then
1267 dlfiles="$dlfiles $arg"
1268 else
1269 dlprefiles="$dlprefiles $arg"
1270 fi
1271 prev=
1272 continue
1273 ;;
1274 esac
1275 ;;
1276 expsyms)
1277 export_symbols="$arg"
1278 if test ! -f "$arg"; then
1279 $echo "$modename: symbol file \`$arg' does not exist"
1280 exit $EXIT_FAILURE
1281 fi
1282 prev=
1283 continue
1284 ;;
1285 expsyms_regex)
1286 export_symbols_regex="$arg"
1287 prev=
1288 continue
1289 ;;
1290 inst_prefix)
1291 inst_prefix_dir="$arg"
1292 prev=
1293 continue
1294 ;;
1295 precious_regex)
1296 precious_files_regex="$arg"
1297 prev=
1298 continue
1299 ;;
1300 release)
1301 release="-$arg"
1302 prev=
1303 continue
1304 ;;
1305 objectlist)
1306 if test -f "$arg"; then
1307 save_arg=$arg
1308 moreargs=
1309 for fil in `cat $save_arg`
1310 do
1311 # moreargs="$moreargs $fil"
1312 arg=$fil
1313 # A libtool-controlled object.
1314
1315 # Check to see that this really is a libtool object.
1316 if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1317 pic_object=
1318 non_pic_object=
1319
1320 # Read the .lo file
1321 # If there is no directory component, then add one.
1322 case $arg in
1323 */* | *\\*) . $arg ;;
1324 *) . ./$arg ;;
1325 esac
1326
1327 if test -z "$pic_object" || \
1328 test -z "$non_pic_object" ||
1329 test "$pic_object" = none && \
1330 test "$non_pic_object" = none; then
1331 $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1332 exit $EXIT_FAILURE
1333 fi
1334
1335 # Extract subdirectory from the argument.
1336 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1337 if test "X$xdir" = "X$arg"; then
1338 xdir=
1339 else
1340 xdir="$xdir/"
1341 fi
1342
1343 if test "$pic_object" != none; then
1344 # Prepend the subdirectory the object is found in.
1345 pic_object="$xdir$pic_object"
1346
1347 if test "$prev" = dlfiles; then
1348 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1349 dlfiles="$dlfiles $pic_object"
1350 prev=
1351 continue
1352 else
1353 # If libtool objects are unsupported, then we need to preload.
1354 prev=dlprefiles
1355 fi
1356 fi
1357
1358 # CHECK ME: I think I busted this. -Ossama
1359 if test "$prev" = dlprefiles; then
1360 # Preload the old-style object.
1361 dlprefiles="$dlprefiles $pic_object"
1362 prev=
1363 fi
1364
1365 # A PIC object.
1366 libobjs="$libobjs $pic_object"
1367 arg="$pic_object"
1368 fi
1369
1370 # Non-PIC object.
1371 if test "$non_pic_object" != none; then
1372 # Prepend the subdirectory the object is found in.
1373 non_pic_object="$xdir$non_pic_object"
1374
1375 # A standard non-PIC object
1376 non_pic_objects="$non_pic_objects $non_pic_object"
1377 if test -z "$pic_object" || test "$pic_object" = none ; then
1378 arg="$non_pic_object"
1379 fi
1380 else
1381 # If the PIC object exists, use it instead.
1382 # $xdir was prepended to $pic_object above.
1383 non_pic_object="$pic_object"
1384 non_pic_objects="$non_pic_objects $non_pic_object"
1385 fi
1386 else
1387 # Only an error if not doing a dry-run.
1388 if test -z "$run"; then
1389 $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1390 exit $EXIT_FAILURE
1391 else
1392 # Dry-run case.
1393
1394 # Extract subdirectory from the argument.
1395 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1396 if test "X$xdir" = "X$arg"; then
1397 xdir=
1398 else
1399 xdir="$xdir/"
1400 fi
1401
1402 pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1403 non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1404 libobjs="$libobjs $pic_object"
1405 non_pic_objects="$non_pic_objects $non_pic_object"
1406 fi
1407 fi
1408 done
1409 else
1410 $echo "$modename: link input file \`$save_arg' does not exist"
1411 exit $EXIT_FAILURE
1412 fi
1413 arg=$save_arg
1414 prev=
1415 continue
1416 ;;
1417 rpath | xrpath)
1418 # We need an absolute path.
1419 case $arg in
1420 [\\/]* | [A-Za-z]:[\\/]*) ;;
1421 *)
1422 $echo "$modename: only absolute run-paths are allowed" 1>&2
1423 exit $EXIT_FAILURE
1424 ;;
1425 esac
1426 if test "$prev" = rpath; then
1427 case "$rpath " in
1428 *" $arg "*) ;;
1429 *) rpath="$rpath $arg" ;;
1430 esac
1431 else
1432 case "$xrpath " in
1433 *" $arg "*) ;;
1434 *) xrpath="$xrpath $arg" ;;
1435 esac
1436 fi
1437 prev=
1438 continue
1439 ;;
1440 xcompiler)
1441 compiler_flags="$compiler_flags $qarg"
1442 prev=
1443 compile_command="$compile_command $qarg"
1444 finalize_command="$finalize_command $qarg"
1445 continue
1446 ;;
1447 xlinker)
1448 linker_flags="$linker_flags $qarg"
1449 compiler_flags="$compiler_flags $wl$qarg"
1450 prev=
1451 compile_command="$compile_command $wl$qarg"
1452 finalize_command="$finalize_command $wl$qarg"
1453 continue
1454 ;;
1455 xcclinker)
1456 linker_flags="$linker_flags $qarg"
1457 compiler_flags="$compiler_flags $qarg"
1458 prev=
1459 compile_command="$compile_command $qarg"
1460 finalize_command="$finalize_command $qarg"
1461 continue
1462 ;;
1463 shrext)
1464 shrext_cmds="$arg"
1465 prev=
1466 continue
1467 ;;
1468 darwin_framework|darwin_framework_skip)
1469 test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
1470 compile_command="$compile_command $arg"
1471 finalize_command="$finalize_command $arg"
1472 prev=
1473 continue
1474 ;;
1475 *)
1476 eval "$prev=\"\$arg\""
1477 prev=
1478 continue
1479 ;;
1480 esac
1481 fi # test -n "$prev"
1482
1483 prevarg="$arg"
1484
1485 case $arg in
1486 -all-static)
1487 if test -n "$link_static_flag"; then
1488 compile_command="$compile_command $link_static_flag"
1489 finalize_command="$finalize_command $link_static_flag"
1490 fi
1491 continue
1492 ;;
1493
1494 -allow-undefined)
1495 # FIXME: remove this flag sometime in the future.
1496 $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1497 continue
1498 ;;
1499
1500 -avoid-version)
1501 avoid_version=yes
1502 continue
1503 ;;
1504
1505 -dlopen)
1506 prev=dlfiles
1507 continue
1508 ;;
1509
1510 -dlpreopen)
1511 prev=dlprefiles
1512 continue
1513 ;;
1514
1515 -export-dynamic)
1516 export_dynamic=yes
1517 continue
1518 ;;
1519
1520 -export-symbols | -export-symbols-regex)
1521 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1522 $echo "$modename: more than one -exported-symbols argument is not allowed"
1523 exit $EXIT_FAILURE
1524 fi
1525 if test "X$arg" = "X-export-symbols"; then
1526 prev=expsyms
1527 else
1528 prev=expsyms_regex
1529 fi
1530 continue
1531 ;;
1532
1533 -framework|-arch|-isysroot)
1534 case " $CC " in
1535 *" ${arg} ${1} "* | *" ${arg} ${1} "*)
1536 prev=darwin_framework_skip ;;
1537 *) compiler_flags="$compiler_flags $arg"
1538 prev=darwin_framework ;;
1539 esac
1540 compile_command="$compile_command $arg"
1541 finalize_command="$finalize_command $arg"
1542 continue
1543 ;;
1544
1545 -inst-prefix-dir)
1546 prev=inst_prefix
1547 continue
1548 ;;
1549
1550 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1551 # so, if we see these flags be careful not to treat them like -L
1552 -L[A-Z][A-Z]*:*)
1553 case $with_gcc/$host in
1554 no/*-*-irix* | /*-*-irix*)
1555 compile_command="$compile_command $arg"
1556 finalize_command="$finalize_command $arg"
1557 ;;
1558 esac
1559 continue
1560 ;;
1561
1562 -L*)
1563 dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1564 # We need an absolute path.
1565 case $dir in
1566 [\\/]* | [A-Za-z]:[\\/]*) ;;
1567 *)
1568 absdir=`cd "$dir" && pwd`
1569 if test -z "$absdir"; then
1570 $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1571 absdir="$dir"
1572 notinst_path="$notinst_path $dir"
1573 fi
1574 dir="$absdir"
1575 ;;
1576 esac
1577 case "$deplibs " in
1578 *" -L$dir "*) ;;
1579 *)
1580 deplibs="$deplibs -L$dir"
1581 lib_search_path="$lib_search_path $dir"
1582 ;;
1583 esac
1584 case $host in
1585 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1586 testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
1587 case :$dllsearchpath: in
1588 *":$dir:"*) ;;
1589 *) dllsearchpath="$dllsearchpath:$dir";;
1590 esac
1591 case :$dllsearchpath: in
1592 *":$testbindir:"*) ;;
1593 *) dllsearchpath="$dllsearchpath:$testbindir";;
1594 esac
1595 ;;
1596 esac
1597 continue
1598 ;;
1599
1600 -l*)
1601 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1602 case $host in
1603 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
1604 # These systems don't actually have a C or math library (as such)
1605 continue
1606 ;;
1607 *-*-os2*)
1608 # These systems don't actually have a C library (as such)
1609 test "X$arg" = "X-lc" && continue
1610 ;;
1611 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1612 # Do not include libc due to us having libc/libc_r.
1613 test "X$arg" = "X-lc" && continue
1614 ;;
1615 *-*-rhapsody* | *-*-darwin1.[012])
1616 # Rhapsody C and math libraries are in the System framework
1617 deplibs="$deplibs -framework System"
1618 continue
1619 ;;
1620 *-*-sco3.2v5* | *-*-sco5v6*)
1621 # Causes problems with __ctype
1622 test "X$arg" = "X-lc" && continue
1623 ;;
1624 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
1625 # Compiler inserts libc in the correct place for threads to work
1626 test "X$arg" = "X-lc" && continue
1627 ;;
1628 esac
1629 elif test "X$arg" = "X-lc_r"; then
1630 case $host in
1631 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1632 # Do not include libc_r directly, use -pthread flag.
1633 continue
1634 ;;
1635 esac
1636 fi
1637 deplibs="$deplibs $arg"
1638 continue
1639 ;;
1640
1641 # Tru64 UNIX uses -model [arg] to determine the layout of C++
1642 # classes, name mangling, and exception handling.
1643 -model)
1644 compile_command="$compile_command $arg"
1645 compiler_flags="$compiler_flags $arg"
1646 finalize_command="$finalize_command $arg"
1647 prev=xcompiler
1648 continue
1649 ;;
1650
1651 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1652 compiler_flags="$compiler_flags $arg"
1653 compile_command="$compile_command $arg"
1654 finalize_command="$finalize_command $arg"
1655 continue
1656 ;;
1657
1658 -module)
1659 module=yes
1660 continue
1661 ;;
1662
1663 # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1664 # -r[0-9][0-9]* specifies the processor on the SGI compiler
1665 # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1666 # +DA*, +DD* enable 64-bit mode on the HP compiler
1667 # -q* pass through compiler args for the IBM compiler
1668 # -m* pass through architecture-specific compiler args for GCC
1669 # -m*, -t[45]*, -txscale* pass through architecture-specific
1670 # compiler args for GCC
1671 # -pg pass through profiling flag for GCC
1672 # @file GCC response files
1673 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*|-pg| \
1674 -t[45]*|-txscale*|@*)
1675
1676 # Unknown arguments in both finalize_command and compile_command need
1677 # to be aesthetically quoted because they are evaled later.
1678 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1679 case $arg in
1680 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1681 arg="\"$arg\""
1682 ;;
1683 esac
1684 compile_command="$compile_command $arg"
1685 finalize_command="$finalize_command $arg"
1686 compiler_flags="$compiler_flags $arg"
1687 continue
1688 ;;
1689
1690 -shrext)
1691 prev=shrext
1692 continue
1693 ;;
1694
1695 -no-fast-install)
1696 fast_install=no
1697 continue
1698 ;;
1699
1700 -no-install)
1701 case $host in
1702 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1703 # The PATH hackery in wrapper scripts is required on Windows
1704 # in order for the loader to find any dlls it needs.
1705 $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1706 $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1707 fast_install=no
1708 ;;
1709 *) no_install=yes ;;
1710 esac
1711 continue
1712 ;;
1713
1714 -no-undefined)
1715 allow_undefined=no
1716 continue
1717 ;;
1718
1719 -objectlist)
1720 prev=objectlist
1721 continue
1722 ;;
1723
1724 -o) prev=output ;;
1725
1726 -precious-files-regex)
1727 prev=precious_regex
1728 continue
1729 ;;
1730
1731 -release)
1732 prev=release
1733 continue
1734 ;;
1735
1736 -rpath)
1737 prev=rpath
1738 continue
1739 ;;
1740
1741 -R)
1742 prev=xrpath
1743 continue
1744 ;;
1745
1746 -R*)
1747 dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1748 # We need an absolute path.
1749 case $dir in
1750 [\\/]* | [A-Za-z]:[\\/]*) ;;
1751 *)
1752 $echo "$modename: only absolute run-paths are allowed" 1>&2
1753 exit $EXIT_FAILURE
1754 ;;
1755 esac
1756 case "$xrpath " in
1757 *" $dir "*) ;;
1758 *) xrpath="$xrpath $dir" ;;
1759 esac
1760 continue
1761 ;;
1762
1763 -static)
1764 # The effects of -static are defined in a previous loop.
1765 # We used to do the same as -all-static on platforms that
1766 # didn't have a PIC flag, but the assumption that the effects
1767 # would be equivalent was wrong. It would break on at least
1768 # Digital Unix and AIX.
1769 continue
1770 ;;
1771
1772 -thread-safe)
1773 thread_safe=yes
1774 continue
1775 ;;
1776
1777 -version-info)
1778 prev=vinfo
1779 continue
1780 ;;
1781 -version-number)
1782 prev=vinfo
1783 vinfo_number=yes
1784 continue
1785 ;;
1786
1787 -Wc,*)
1788 args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1789 arg=
1790 save_ifs="$IFS"; IFS=','
1791 for flag in $args; do
1792 IFS="$save_ifs"
1793 case $flag in
1794 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1795 flag="\"$flag\""
1796 ;;
1797 esac
1798 arg="$arg $wl$flag"
1799 compiler_flags="$compiler_flags $flag"
1800 done
1801 IFS="$save_ifs"
1802 arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1803 ;;
1804
1805 -Wl,*)
1806 args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1807 arg=
1808 save_ifs="$IFS"; IFS=','
1809 for flag in $args; do
1810 IFS="$save_ifs"
1811 case $flag in
1812 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1813 flag="\"$flag\""
1814 ;;
1815 esac
1816 arg="$arg $wl$flag"
1817 compiler_flags="$compiler_flags $wl$flag"
1818 linker_flags="$linker_flags $flag"
1819 done
1820 IFS="$save_ifs"
1821 arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1822 ;;
1823
1824 -Xcompiler)
1825 prev=xcompiler
1826 continue
1827 ;;
1828
1829 -Xlinker)
1830 prev=xlinker
1831 continue
1832 ;;
1833
1834 -XCClinker)
1835 prev=xcclinker
1836 continue
1837 ;;
1838
1839 # Some other compiler flag.
1840 -* | +*)
1841 # Unknown arguments in both finalize_command and compile_command need
1842 # to be aesthetically quoted because they are evaled later.
1843 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1844 case $arg in
1845 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1846 arg="\"$arg\""
1847 ;;
1848 esac
1849 ;;
1850
1851 *.$objext)
1852 # A standard object.
1853 objs="$objs $arg"
1854 ;;
1855
1856 *.lo)
1857 # A libtool-controlled object.
1858
1859 # Check to see that this really is a libtool object.
1860 if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1861 pic_object=
1862 non_pic_object=
1863
1864 # Read the .lo file
1865 # If there is no directory component, then add one.
1866 case $arg in
1867 */* | *\\*) . $arg ;;
1868 *) . ./$arg ;;
1869 esac
1870
1871 if test -z "$pic_object" || \
1872 test -z "$non_pic_object" ||
1873 test "$pic_object" = none && \
1874 test "$non_pic_object" = none; then
1875 $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1876 exit $EXIT_FAILURE
1877 fi
1878
1879 # Extract subdirectory from the argument.
1880 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1881 if test "X$xdir" = "X$arg"; then
1882 xdir=
1883 else
1884 xdir="$xdir/"
1885 fi
1886
1887 if test "$pic_object" != none; then
1888 # Prepend the subdirectory the object is found in.
1889 pic_object="$xdir$pic_object"
1890
1891 if test "$prev" = dlfiles; then
1892 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1893 dlfiles="$dlfiles $pic_object"
1894 prev=
1895 continue
1896 else
1897 # If libtool objects are unsupported, then we need to preload.
1898 prev=dlprefiles
1899 fi
1900 fi
1901
1902 # CHECK ME: I think I busted this. -Ossama
1903 if test "$prev" = dlprefiles; then
1904 # Preload the old-style object.
1905 dlprefiles="$dlprefiles $pic_object"
1906 prev=
1907 fi
1908
1909 # A PIC object.
1910 libobjs="$libobjs $pic_object"
1911 arg="$pic_object"
1912 fi
1913
1914 # Non-PIC object.
1915 if test "$non_pic_object" != none; then
1916 # Prepend the subdirectory the object is found in.
1917 non_pic_object="$xdir$non_pic_object"
1918
1919 # A standard non-PIC object
1920 non_pic_objects="$non_pic_objects $non_pic_object"
1921 if test -z "$pic_object" || test "$pic_object" = none ; then
1922 arg="$non_pic_object"
1923 fi
1924 else
1925 # If the PIC object exists, use it instead.
1926 # $xdir was prepended to $pic_object above.
1927 non_pic_object="$pic_object"
1928 non_pic_objects="$non_pic_objects $non_pic_object"
1929 fi
1930 else
1931 # Only an error if not doing a dry-run.
1932 if test -z "$run"; then
1933 $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1934 exit $EXIT_FAILURE
1935 else
1936 # Dry-run case.
1937
1938 # Extract subdirectory from the argument.
1939 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1940 if test "X$xdir" = "X$arg"; then
1941 xdir=
1942 else
1943 xdir="$xdir/"
1944 fi
1945
1946 pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1947 non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1948 libobjs="$libobjs $pic_object"
1949 non_pic_objects="$non_pic_objects $non_pic_object"
1950 fi
1951 fi
1952 ;;
1953
1954 *.$libext)
1955 # An archive.
1956 deplibs="$deplibs $arg"
1957 old_deplibs="$old_deplibs $arg"
1958 continue
1959 ;;
1960
1961 *.la)
1962 # A libtool-controlled library.
1963
1964 if test "$prev" = dlfiles; then
1965 # This library was specified with -dlopen.
1966 dlfiles="$dlfiles $arg"
1967 prev=
1968 elif test "$prev" = dlprefiles; then
1969 # The library was specified with -dlpreopen.
1970 dlprefiles="$dlprefiles $arg"
1971 prev=
1972 else
1973 deplibs="$deplibs $arg"
1974 fi
1975 continue
1976 ;;
1977
1978 # Some other compiler argument.
1979 *)
1980 # Unknown arguments in both finalize_command and compile_command need
1981 # to be aesthetically quoted because they are evaled later.
1982 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1983 case $arg in
1984 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1985 arg="\"$arg\""
1986 ;;
1987 esac
1988 ;;
1989 esac # arg
1990
1991 # Now actually substitute the argument into the commands.
1992 if test -n "$arg"; then
1993 compile_command="$compile_command $arg"
1994 finalize_command="$finalize_command $arg"
1995 fi
1996 done # argument parsing loop
1997
1998 if test -n "$prev"; then
1999 $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
2000 $echo "$help" 1>&2
2001 exit $EXIT_FAILURE
2002 fi
2003
2004 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
2005 eval arg=\"$export_dynamic_flag_spec\"
2006 compile_command="$compile_command $arg"
2007 finalize_command="$finalize_command $arg"
2008 fi
2009
2010 oldlibs=
2011 # calculate the name of the file, without its directory
2012 outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
2013 libobjs_save="$libobjs"
2014
2015 if test -n "$shlibpath_var"; then
2016 # get the directories listed in $shlibpath_var
2017 eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
2018 else
2019 shlib_search_path=
2020 fi
2021 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
2022 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
2023
2024 output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
2025 if test "X$output_objdir" = "X$output"; then
2026 output_objdir="$objdir"
2027 else
2028 output_objdir="$output_objdir/$objdir"
2029 fi
2030 # Create the object directory.
2031 if test ! -d "$output_objdir"; then
2032 $show "$mkdir $output_objdir"
2033 $run $mkdir $output_objdir
2034 exit_status=$?
2035 if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
2036 exit $exit_status
2037 fi
2038 fi
2039
2040 # Determine the type of output
2041 case $output in
2042 "")
2043 $echo "$modename: you must specify an output file" 1>&2
2044 $echo "$help" 1>&2
2045 exit $EXIT_FAILURE
2046 ;;
2047 *.$libext) linkmode=oldlib ;;
2048 *.lo | *.$objext) linkmode=obj ;;
2049 *.la) linkmode=lib ;;
2050 *) linkmode=prog ;; # Anything else should be a program.
2051 esac
2052
2053 case $host in
2054 *cygwin* | *mingw* | *pw32*)
2055 # don't eliminate duplications in $postdeps and $predeps
2056 duplicate_compiler_generated_deps=yes
2057 ;;
2058 *)
2059 duplicate_compiler_generated_deps=$duplicate_deps
2060 ;;
2061 esac
2062 specialdeplibs=
2063
2064 libs=
2065 # Find all interdependent deplibs by searching for libraries
2066 # that are linked more than once (e.g. -la -lb -la)
2067 for deplib in $deplibs; do
2068 if test "X$duplicate_deps" = "Xyes" ; then
2069 case "$libs " in
2070 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2071 esac
2072 fi
2073 libs="$libs $deplib"
2074 done
2075
2076 if test "$linkmode" = lib; then
2077 libs="$predeps $libs $compiler_lib_search_path $postdeps"
2078
2079 # Compute libraries that are listed more than once in $predeps
2080 # $postdeps and mark them as special (i.e., whose duplicates are
2081 # not to be eliminated).
2082 pre_post_deps=
2083 if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
2084 for pre_post_dep in $predeps $postdeps; do
2085 case "$pre_post_deps " in
2086 *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
2087 esac
2088 pre_post_deps="$pre_post_deps $pre_post_dep"
2089 done
2090 fi
2091 pre_post_deps=
2092 fi
2093
2094 deplibs=
2095 newdependency_libs=
2096 newlib_search_path=
2097 need_relink=no # whether we're linking any uninstalled libtool libraries
2098 notinst_deplibs= # not-installed libtool libraries
2099 case $linkmode in
2100 lib)
2101 passes="conv link"
2102 for file in $dlfiles $dlprefiles; do
2103 case $file in
2104 *.la) ;;
2105 *)
2106 $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2107 exit $EXIT_FAILURE
2108 ;;
2109 esac
2110 done
2111 ;;
2112 prog)
2113 compile_deplibs=
2114 finalize_deplibs=
2115 alldeplibs=no
2116 newdlfiles=
2117 newdlprefiles=
2118 passes="conv scan dlopen dlpreopen link"
2119 ;;
2120 *) passes="conv"
2121 ;;
2122 esac
2123 for pass in $passes; do
2124 if test "$linkmode,$pass" = "lib,link" ||
2125 test "$linkmode,$pass" = "prog,scan"; then
2126 libs="$deplibs"
2127 deplibs=
2128 fi
2129 if test "$linkmode" = prog; then
2130 case $pass in
2131 dlopen) libs="$dlfiles" ;;
2132 dlpreopen) libs="$dlprefiles" ;;
2133 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
2134 esac
2135 fi
2136 if test "$pass" = dlopen; then
2137 # Collect dlpreopened libraries
2138 save_deplibs="$deplibs"
2139 deplibs=
2140 fi
2141 for deplib in $libs; do
2142 lib=
2143 found=no
2144 case $deplib in
2145 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
2146 if test "$linkmode,$pass" = "prog,link"; then
2147 compile_deplibs="$deplib $compile_deplibs"
2148 finalize_deplibs="$deplib $finalize_deplibs"
2149 else
2150 compiler_flags="$compiler_flags $deplib"
2151 fi
2152 continue
2153 ;;
2154 -l*)
2155 if test "$linkmode" != lib && test "$linkmode" != prog; then
2156 $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2157 continue
2158 fi
2159 name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2160 for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
2161 for search_ext in .la $std_shrext .so .a; do
2162 # Search the libtool library
2163 lib="$searchdir/lib${name}${search_ext}"
2164 if test -f "$lib"; then
2165 if test "$search_ext" = ".la"; then
2166 found=yes
2167 else
2168 found=no
2169 fi
2170 break 2
2171 fi
2172 done
2173 done
2174 if test "$found" != yes; then
2175 # deplib doesn't seem to be a libtool library
2176 if test "$linkmode,$pass" = "prog,link"; then
2177 compile_deplibs="$deplib $compile_deplibs"
2178 finalize_deplibs="$deplib $finalize_deplibs"
2179 else
2180 deplibs="$deplib $deplibs"
2181 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2182 fi
2183 continue
2184 else # deplib is a libtool library
2185 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2186 # We need to do some special things here, and not later.
2187 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2188 case " $predeps $postdeps " in
2189 *" $deplib "*)
2190 if (${SED} -e '2q' $lib |
2191 grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2192 library_names=
2193 old_library=
2194 case $lib in
2195 */* | *\\*) . $lib ;;
2196 *) . ./$lib ;;
2197 esac
2198 for l in $old_library $library_names; do
2199 ll="$l"
2200 done
2201 if test "X$ll" = "X$old_library" ; then # only static version available
2202 found=no
2203 ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2204 test "X$ladir" = "X$lib" && ladir="."
2205 lib=$ladir/$old_library
2206 if test "$linkmode,$pass" = "prog,link"; then
2207 compile_deplibs="$deplib $compile_deplibs"
2208 finalize_deplibs="$deplib $finalize_deplibs"
2209 else
2210 deplibs="$deplib $deplibs"
2211 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2212 fi
2213 continue
2214 fi
2215 fi
2216 ;;
2217 *) ;;
2218 esac
2219 fi
2220 fi
2221 ;; # -l
2222 -L*)
2223 case $linkmode in
2224 lib)
2225 deplibs="$deplib $deplibs"
2226 test "$pass" = conv && continue
2227 newdependency_libs="$deplib $newdependency_libs"
2228 newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2229 ;;
2230 prog)
2231 if test "$pass" = conv; then
2232 deplibs="$deplib $deplibs"
2233 continue
2234 fi
2235 if test "$pass" = scan; then
2236 deplibs="$deplib $deplibs"
2237 else
2238 compile_deplibs="$deplib $compile_deplibs"
2239 finalize_deplibs="$deplib $finalize_deplibs"
2240 fi
2241 newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2242 ;;
2243 *)
2244 $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2245 ;;
2246 esac # linkmode
2247 continue
2248 ;; # -L
2249 -R*)
2250 if test "$pass" = link; then
2251 dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2252 # Make sure the xrpath contains only unique directories.
2253 case "$xrpath " in
2254 *" $dir "*) ;;
2255 *) xrpath="$xrpath $dir" ;;
2256 esac
2257 fi
2258 deplibs="$deplib $deplibs"
2259 continue
2260 ;;
2261 *.la) lib="$deplib" ;;
2262 *.$libext)
2263 if test "$pass" = conv; then
2264 deplibs="$deplib $deplibs"
2265 continue
2266 fi
2267 case $linkmode in
2268 lib)
2269 valid_a_lib=no
2270 case $deplibs_check_method in
2271 match_pattern*)
2272 set dummy $deplibs_check_method
2273 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2274 if eval $echo \"$deplib\" 2>/dev/null \
2275 | $SED 10q \
2276 | $EGREP "$match_pattern_regex" > /dev/null; then
2277 valid_a_lib=yes
2278 fi
2279 ;;
2280 pass_all)
2281 valid_a_lib=yes
2282 ;;
2283 esac
2284 if test "$valid_a_lib" != yes; then
2285 $echo
2286 $echo "*** Warning: Trying to link with static lib archive $deplib."
2287 $echo "*** I have the capability to make that library automatically link in when"
2288 $echo "*** you link to this library. But I can only do this if you have a"
2289 $echo "*** shared version of the library, which you do not appear to have"
2290 $echo "*** because the file extensions .$libext of this argument makes me believe"
2291 $echo "*** that it is just a static archive that I should not used here."
2292 else
2293 $echo
2294 $echo "*** Warning: Linking the shared library $output against the"
2295 $echo "*** static library $deplib is not portable!"
2296 deplibs="$deplib $deplibs"
2297 fi
2298 continue
2299 ;;
2300 prog)
2301 if test "$pass" != link; then
2302 deplibs="$deplib $deplibs"
2303 else
2304 compile_deplibs="$deplib $compile_deplibs"
2305 finalize_deplibs="$deplib $finalize_deplibs"
2306 fi
2307 continue
2308 ;;
2309 esac # linkmode
2310 ;; # *.$libext
2311 *.lo | *.$objext)
2312 if test "$pass" = conv; then
2313 deplibs="$deplib $deplibs"
2314 elif test "$linkmode" = prog; then
2315 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2316 # If there is no dlopen support or we're linking statically,
2317 # we need to preload.
2318 newdlprefiles="$newdlprefiles $deplib"
2319 compile_deplibs="$deplib $compile_deplibs"
2320 finalize_deplibs="$deplib $finalize_deplibs"
2321 else
2322 newdlfiles="$newdlfiles $deplib"
2323 fi
2324 fi
2325 continue
2326 ;;
2327 %DEPLIBS%)
2328 alldeplibs=yes
2329 continue
2330 ;;
2331 esac # case $deplib
2332 if test "$found" = yes || test -f "$lib"; then :
2333 else
2334 $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2335 exit $EXIT_FAILURE
2336 fi
2337
2338 # Check to see that this really is a libtool archive.
2339 if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2340 else
2341 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2342 exit $EXIT_FAILURE
2343 fi
2344
2345 ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2346 test "X$ladir" = "X$lib" && ladir="."
2347
2348 dlname=
2349 dlopen=
2350 dlpreopen=
2351 libdir=
2352 library_names=
2353 old_library=
2354 # If the library was installed with an old release of libtool,
2355 # it will not redefine variables installed, or shouldnotlink
2356 installed=yes
2357 shouldnotlink=no
2358 avoidtemprpath=
2359
2360
2361 # Read the .la file
2362 case $lib in
2363 */* | *\\*) . $lib ;;
2364 *) . ./$lib ;;
2365 esac
2366
2367 if test "$linkmode,$pass" = "lib,link" ||
2368 test "$linkmode,$pass" = "prog,scan" ||
2369 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2370 test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2371 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2372 fi
2373
2374 if test "$pass" = conv; then
2375 # Only check for convenience libraries
2376 deplibs="$lib $deplibs"
2377 if test -z "$libdir"; then
2378 if test -z "$old_library"; then
2379 $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2380 exit $EXIT_FAILURE
2381 fi
2382 # It is a libtool convenience library, so add in its objects.
2383 convenience="$convenience $ladir/$objdir/$old_library"
2384 old_convenience="$old_convenience $ladir/$objdir/$old_library"
2385 tmp_libs=
2386 for deplib in $dependency_libs; do
2387 deplibs="$deplib $deplibs"
2388 if test "X$duplicate_deps" = "Xyes" ; then
2389 case "$tmp_libs " in
2390 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2391 esac
2392 fi
2393 tmp_libs="$tmp_libs $deplib"
2394 done
2395 elif test "$linkmode" != prog && test "$linkmode" != lib; then
2396 $echo "$modename: \`$lib' is not a convenience library" 1>&2
2397 exit $EXIT_FAILURE
2398 fi
2399 continue
2400 fi # $pass = conv
2401
2402
2403 # Get the name of the library we link against.
2404 linklib=
2405 for l in $old_library $library_names; do
2406 linklib="$l"
2407 done
2408 if test -z "$linklib"; then
2409 $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2410 exit $EXIT_FAILURE
2411 fi
2412
2413 # This library was specified with -dlopen.
2414 if test "$pass" = dlopen; then
2415 if test -z "$libdir"; then
2416 $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2417 exit $EXIT_FAILURE
2418 fi
2419 if test -z "$dlname" ||
2420 test "$dlopen_support" != yes ||
2421 test "$build_libtool_libs" = no; then
2422 # If there is no dlname, no dlopen support or we're linking
2423 # statically, we need to preload. We also need to preload any
2424 # dependent libraries so libltdl's deplib preloader doesn't
2425 # bomb out in the load deplibs phase.
2426 dlprefiles="$dlprefiles $lib $dependency_libs"
2427 else
2428 newdlfiles="$newdlfiles $lib"
2429 fi
2430 continue
2431 fi # $pass = dlopen
2432
2433 # We need an absolute path.
2434 case $ladir in
2435 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2436 *)
2437 abs_ladir=`cd "$ladir" && pwd`
2438 if test -z "$abs_ladir"; then
2439 $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2440 $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2441 abs_ladir="$ladir"
2442 fi
2443 ;;
2444 esac
2445 laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2446
2447 # Find the relevant object directory and library name.
2448 if test "X$installed" = Xyes; then
2449 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2450 $echo "$modename: warning: library \`$lib' was moved." 1>&2
2451 dir="$ladir"
2452 absdir="$abs_ladir"
2453 libdir="$abs_ladir"
2454 else
2455 dir="$libdir"
2456 absdir="$libdir"
2457 fi
2458 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2459 else
2460 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2461 dir="$ladir"
2462 absdir="$abs_ladir"
2463 # Remove this search path later
2464 notinst_path="$notinst_path $abs_ladir"
2465 else
2466 dir="$ladir/$objdir"
2467 absdir="$abs_ladir/$objdir"
2468 # Remove this search path later
2469 notinst_path="$notinst_path $abs_ladir"
2470 fi
2471 fi # $installed = yes
2472 name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2473
2474 # This library was specified with -dlpreopen.
2475 if test "$pass" = dlpreopen; then
2476 if test -z "$libdir"; then
2477 $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2478 exit $EXIT_FAILURE
2479 fi
2480 # Prefer using a static library (so that no silly _DYNAMIC symbols
2481 # are required to link).
2482 if test -n "$old_library"; then
2483 newdlprefiles="$newdlprefiles $dir/$old_library"
2484 # Otherwise, use the dlname, so that lt_dlopen finds it.
2485 elif test -n "$dlname"; then
2486 newdlprefiles="$newdlprefiles $dir/$dlname"
2487 else
2488 newdlprefiles="$newdlprefiles $dir/$linklib"
2489 fi
2490 fi # $pass = dlpreopen
2491
2492 if test -z "$libdir"; then
2493 # Link the convenience library
2494 if test "$linkmode" = lib; then
2495 deplibs="$dir/$old_library $deplibs"
2496 elif test "$linkmode,$pass" = "prog,link"; then
2497 compile_deplibs="$dir/$old_library $compile_deplibs"
2498 finalize_deplibs="$dir/$old_library $finalize_deplibs"
2499 else
2500 deplibs="$lib $deplibs" # used for prog,scan pass
2501 fi
2502 continue
2503 fi
2504
2505
2506 if test "$linkmode" = prog && test "$pass" != link; then
2507 newlib_search_path="$newlib_search_path $ladir"
2508 deplibs="$lib $deplibs"
2509
2510 linkalldeplibs=no
2511 if test "$link_all_deplibs" != no || test -z "$library_names" ||
2512 test "$build_libtool_libs" = no; then
2513 linkalldeplibs=yes
2514 fi
2515
2516 tmp_libs=
2517 for deplib in $dependency_libs; do
2518 case $deplib in
2519 -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2520 esac
2521 # Need to link against all dependency_libs?
2522 if test "$linkalldeplibs" = yes; then
2523 deplibs="$deplib $deplibs"
2524 else
2525 # Need to hardcode shared library paths
2526 # or/and link against static libraries
2527 newdependency_libs="$deplib $newdependency_libs"
2528 fi
2529 if test "X$duplicate_deps" = "Xyes" ; then
2530 case "$tmp_libs " in
2531 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2532 esac
2533 fi
2534 tmp_libs="$tmp_libs $deplib"
2535 done # for deplib
2536 continue
2537 fi # $linkmode = prog...
2538
2539 if test "$linkmode,$pass" = "prog,link"; then
2540 if test -n "$library_names" &&
2541 { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2542 # We need to hardcode the library path
2543 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2544 # Make sure the rpath contains only unique directories.
2545 case "$temp_rpath " in
2546 *" $dir "*) ;;
2547 *" $absdir "*) ;;
2548 *) temp_rpath="$temp_rpath $absdir" ;;
2549 esac
2550 fi
2551
2552 # Hardcode the library path.
2553 # Skip directories that are in the system default run-time
2554 # search path.
2555 case " $sys_lib_dlsearch_path " in
2556 *" $absdir "*) ;;
2557 *)
2558 case "$compile_rpath " in
2559 *" $absdir "*) ;;
2560 *) compile_rpath="$compile_rpath $absdir"
2561 esac
2562 ;;
2563 esac
2564 case " $sys_lib_dlsearch_path " in
2565 *" $libdir "*) ;;
2566 *)
2567 case "$finalize_rpath " in
2568 *" $libdir "*) ;;
2569 *) finalize_rpath="$finalize_rpath $libdir"
2570 esac
2571 ;;
2572 esac
2573 fi # $linkmode,$pass = prog,link...
2574
2575 if test "$alldeplibs" = yes &&
2576 { test "$deplibs_check_method" = pass_all ||
2577 { test "$build_libtool_libs" = yes &&
2578 test -n "$library_names"; }; }; then
2579 # We only need to search for static libraries
2580 continue
2581 fi
2582 fi
2583
2584 link_static=no # Whether the deplib will be linked statically
2585 use_static_libs=$prefer_static_libs
2586 if test "$use_static_libs" = built && test "$installed" = yes ; then
2587 use_static_libs=no
2588 fi
2589 if test -n "$library_names" &&
2590 { test "$use_static_libs" = no || test -z "$old_library"; }; then
2591 if test "$installed" = no; then
2592 notinst_deplibs="$notinst_deplibs $lib"
2593 need_relink=yes
2594 fi
2595 # This is a shared library
2596
2597 # Warn about portability, can't link against -module's on
2598 # some systems (darwin)
2599 if test "$shouldnotlink" = yes && test "$pass" = link ; then
2600 $echo
2601 if test "$linkmode" = prog; then
2602 $echo "*** Warning: Linking the executable $output against the loadable module"
2603 else
2604 $echo "*** Warning: Linking the shared library $output against the loadable module"
2605 fi
2606 $echo "*** $linklib is not portable!"
2607 fi
2608 if test "$linkmode" = lib &&
2609 test "$hardcode_into_libs" = yes; then
2610 # Hardcode the library path.
2611 # Skip directories that are in the system default run-time
2612 # search path.
2613 case " $sys_lib_dlsearch_path " in
2614 *" $absdir "*) ;;
2615 *)
2616 case "$compile_rpath " in
2617 *" $absdir "*) ;;
2618 *) compile_rpath="$compile_rpath $absdir"
2619 esac
2620 ;;
2621 esac
2622 case " $sys_lib_dlsearch_path " in
2623 *" $libdir "*) ;;
2624 *)
2625 case "$finalize_rpath " in
2626 *" $libdir "*) ;;
2627 *) finalize_rpath="$finalize_rpath $libdir"
2628 esac
2629 ;;
2630 esac
2631 fi
2632
2633 if test -n "$old_archive_from_expsyms_cmds"; then
2634 # figure out the soname
2635 set dummy $library_names
2636 realname="$2"
2637 shift; shift
2638 libname=`eval \\$echo \"$libname_spec\"`
2639 # use dlname if we got it. it's perfectly good, no?
2640 if test -n "$dlname"; then
2641 soname="$dlname"
2642 elif test -n "$soname_spec"; then
2643 # bleh windows
2644 case $host in
2645 *cygwin* | mingw*)
2646 major=`expr $current - $age`
2647 versuffix="-$major"
2648 ;;
2649 esac
2650 eval soname=\"$soname_spec\"
2651 else
2652 soname="$realname"
2653 fi
2654
2655 # Make a new name for the extract_expsyms_cmds to use
2656 soroot="$soname"
2657 soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2658 newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2659
2660 # If the library has no export list, then create one now
2661 if test -f "$output_objdir/$soname-def"; then :
2662 else
2663 $show "extracting exported symbol list from \`$soname'"
2664 save_ifs="$IFS"; IFS='~'
2665 cmds=$extract_expsyms_cmds
2666 for cmd in $cmds; do
2667 IFS="$save_ifs"
2668 eval cmd=\"$cmd\"
2669 $show "$cmd"
2670 $run eval "$cmd" || exit $?
2671 done
2672 IFS="$save_ifs"
2673 fi
2674
2675 # Create $newlib
2676 if test -f "$output_objdir/$newlib"; then :; else
2677 $show "generating import library for \`$soname'"
2678 save_ifs="$IFS"; IFS='~'
2679 cmds=$old_archive_from_expsyms_cmds
2680 for cmd in $cmds; do
2681 IFS="$save_ifs"
2682 eval cmd=\"$cmd\"
2683 $show "$cmd"
2684 $run eval "$cmd" || exit $?
2685 done
2686 IFS="$save_ifs"
2687 fi
2688 # make sure the library variables are pointing to the new library
2689 dir=$output_objdir
2690 linklib=$newlib
2691 fi # test -n "$old_archive_from_expsyms_cmds"
2692
2693 if test "$linkmode" = prog || test "$mode" != relink; then
2694 add_shlibpath=
2695 add_dir=
2696 add=
2697 lib_linked=yes
2698 case $hardcode_action in
2699 immediate | unsupported)
2700 if test "$hardcode_direct" = no; then
2701 add="$dir/$linklib"
2702 case $host in
2703 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
2704 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
2705 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2706 *-*-unixware7*) add_dir="-L$dir" ;;
2707 *-*-darwin* )
2708 # if the lib is a module then we can not link against
2709 # it, someone is ignoring the new warnings I added
2710 if /usr/bin/file -L $add 2> /dev/null |
2711 $EGREP ": [^:]* bundle" >/dev/null ; then
2712 $echo "** Warning, lib $linklib is a module, not a shared library"
2713 if test -z "$old_library" ; then
2714 $echo
2715 $echo "** And there doesn't seem to be a static archive available"
2716 $echo "** The link will probably fail, sorry"
2717 else
2718 add="$dir/$old_library"
2719 fi
2720 fi
2721 esac
2722 elif test "$hardcode_minus_L" = no; then
2723 case $host in
2724 *-*-sunos*) add_shlibpath="$dir" ;;
2725 esac
2726 add_dir="-L$dir"
2727 add="-l$name"
2728 elif test "$hardcode_shlibpath_var" = no; then
2729 add_shlibpath="$dir"
2730 add="-l$name"
2731 else
2732 lib_linked=no
2733 fi
2734 ;;
2735 relink)
2736 if test "$hardcode_direct" = yes; then
2737 add="$dir/$linklib"
2738 elif test "$hardcode_minus_L" = yes; then
2739 add_dir="-L$dir"
2740 # Try looking first in the location we're being installed to.
2741 if test -n "$inst_prefix_dir"; then
2742 case $libdir in
2743 [\\/]*)
2744 add_dir="$add_dir -L$inst_prefix_dir$libdir"
2745 ;;
2746 esac
2747 fi
2748 add="-l$name"
2749 elif test "$hardcode_shlibpath_var" = yes; then
2750 add_shlibpath="$dir"
2751 add="-l$name"
2752 else
2753 lib_linked=no
2754 fi
2755 ;;
2756 *) lib_linked=no ;;
2757 esac
2758
2759 if test "$lib_linked" != yes; then
2760 $echo "$modename: configuration error: unsupported hardcode properties"
2761 exit $EXIT_FAILURE
2762 fi
2763
2764 if test -n "$add_shlibpath"; then
2765 case :$compile_shlibpath: in
2766 *":$add_shlibpath:"*) ;;
2767 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2768 esac
2769 fi
2770 if test "$linkmode" = prog; then
2771 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2772 test -n "$add" && compile_deplibs="$add $compile_deplibs"
2773 else
2774 test -n "$add_dir" && deplibs="$add_dir $deplibs"
2775 test -n "$add" && deplibs="$add $deplibs"
2776 if test "$hardcode_direct" != yes && \
2777 test "$hardcode_minus_L" != yes && \
2778 test "$hardcode_shlibpath_var" = yes; then
2779 case :$finalize_shlibpath: in
2780 *":$libdir:"*) ;;
2781 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2782 esac
2783 fi
2784 fi
2785 fi
2786
2787 if test "$linkmode" = prog || test "$mode" = relink; then
2788 add_shlibpath=
2789 add_dir=
2790 add=
2791 # Finalize command for both is simple: just hardcode it.
2792 if test "$hardcode_direct" = yes; then
2793 add="$libdir/$linklib"
2794 elif test "$hardcode_minus_L" = yes; then
2795 add_dir="-L$libdir"
2796 add="-l$name"
2797 elif test "$hardcode_shlibpath_var" = yes; then
2798 case :$finalize_shlibpath: in
2799 *":$libdir:"*) ;;
2800 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2801 esac
2802 add="-l$name"
2803 elif test "$hardcode_automatic" = yes; then
2804 if test -n "$inst_prefix_dir" &&
2805 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2806 add="$inst_prefix_dir$libdir/$linklib"
2807 else
2808 add="$libdir/$linklib"
2809 fi
2810 else
2811 # We cannot seem to hardcode it, guess we'll fake it.
2812 add_dir="-L$libdir"
2813 # Try looking first in the location we're being installed to.
2814 if test -n "$inst_prefix_dir"; then
2815 case $libdir in
2816 [\\/]*)
2817 add_dir="$add_dir -L$inst_prefix_dir$libdir"
2818 ;;
2819 esac
2820 fi
2821 add="-l$name"
2822 fi
2823
2824 if test "$linkmode" = prog; then
2825 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2826 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2827 else
2828 test -n "$add_dir" && deplibs="$add_dir $deplibs"
2829 test -n "$add" && deplibs="$add $deplibs"
2830 fi
2831 fi
2832 elif test "$linkmode" = prog; then
2833 # Here we assume that one of hardcode_direct or hardcode_minus_L
2834 # is not unsupported. This is valid on all known static and
2835 # shared platforms.
2836 if test "$hardcode_direct" != unsupported; then
2837 test -n "$old_library" && linklib="$old_library"
2838 compile_deplibs="$dir/$linklib $compile_deplibs"
2839 finalize_deplibs="$dir/$linklib $finalize_deplibs"
2840 else
2841 compile_deplibs="-l$name -L$dir $compile_deplibs"
2842 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2843 fi
2844 elif test "$build_libtool_libs" = yes; then
2845 # Not a shared library
2846 if test "$deplibs_check_method" != pass_all; then
2847 # We're trying link a shared library against a static one
2848 # but the system doesn't support it.
2849
2850 # Just print a warning and add the library to dependency_libs so
2851 # that the program can be linked against the static library.
2852 $echo
2853 $echo "*** Warning: This system can not link to static lib archive $lib."
2854 $echo "*** I have the capability to make that library automatically link in when"
2855 $echo "*** you link to this library. But I can only do this if you have a"
2856 $echo "*** shared version of the library, which you do not appear to have."
2857 if test "$module" = yes; then
2858 $echo "*** But as you try to build a module library, libtool will still create "
2859 $echo "*** a static module, that should work as long as the dlopening application"
2860 $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2861 if test -z "$global_symbol_pipe"; then
2862 $echo
2863 $echo "*** However, this would only work if libtool was able to extract symbol"
2864 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2865 $echo "*** not find such a program. So, this module is probably useless."
2866 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2867 fi
2868 if test "$build_old_libs" = no; then
2869 build_libtool_libs=module
2870 build_old_libs=yes
2871 else
2872 build_libtool_libs=no
2873 fi
2874 fi
2875 else
2876 deplibs="$dir/$old_library $deplibs"
2877 link_static=yes
2878 fi
2879 fi # link shared/static library?
2880
2881 if test "$linkmode" = lib; then
2882 if test -n "$dependency_libs" &&
2883 { test "$hardcode_into_libs" != yes ||
2884 test "$build_old_libs" = yes ||
2885 test "$link_static" = yes; }; then
2886 # Extract -R from dependency_libs
2887 temp_deplibs=
2888 for libdir in $dependency_libs; do
2889 case $libdir in
2890 -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2891 case " $xrpath " in
2892 *" $temp_xrpath "*) ;;
2893 *) xrpath="$xrpath $temp_xrpath";;
2894 esac;;
2895 *) temp_deplibs="$temp_deplibs $libdir";;
2896 esac
2897 done
2898 dependency_libs="$temp_deplibs"
2899 fi
2900
2901 newlib_search_path="$newlib_search_path $absdir"
2902 # Link against this library
2903 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2904 # ... and its dependency_libs
2905 tmp_libs=
2906 for deplib in $dependency_libs; do
2907 newdependency_libs="$deplib $newdependency_libs"
2908 if test "X$duplicate_deps" = "Xyes" ; then
2909 case "$tmp_libs " in
2910 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2911 esac
2912 fi
2913 tmp_libs="$tmp_libs $deplib"
2914 done
2915
2916 if test "$link_all_deplibs" != no; then
2917 # Add the search paths of all dependency libraries
2918 for deplib in $dependency_libs; do
2919 case $deplib in
2920 -L*) path="$deplib" ;;
2921 *.la)
2922 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2923 test "X$dir" = "X$deplib" && dir="."
2924 # We need an absolute path.
2925 case $dir in
2926 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2927 *)
2928 absdir=`cd "$dir" && pwd`
2929 if test -z "$absdir"; then
2930 $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2931 absdir="$dir"
2932 fi
2933 ;;
2934 esac
2935 if grep "^installed=no" $deplib > /dev/null; then
2936 path="$absdir/$objdir"
2937 else
2938 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2939 if test -z "$libdir"; then
2940 $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2941 exit $EXIT_FAILURE
2942 fi
2943 if test "$absdir" != "$libdir"; then
2944 $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2945 fi
2946 path="$absdir"
2947 fi
2948 depdepl=
2949 case $host in
2950 *-*-darwin*)
2951 # we do not want to link against static libs,
2952 # but need to link against shared
2953 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2954 if test -n "$deplibrary_names" ; then
2955 for tmp in $deplibrary_names ; do
2956 depdepl=$tmp
2957 done
2958 if test -f "$path/$depdepl" ; then
2959 depdepl="$path/$depdepl"
2960 fi
2961 # do not add paths which are already there
2962 case " $newlib_search_path " in
2963 *" $path "*) ;;
2964 *) newlib_search_path="$newlib_search_path $path";;
2965 esac
2966 fi
2967 path=""
2968 ;;
2969 *)
2970 path="-L$path"
2971 ;;
2972 esac
2973 ;;
2974 -l*)
2975 case $host in
2976 *-*-darwin*)
2977 # Again, we only want to link against shared libraries
2978 eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2979 for tmp in $newlib_search_path ; do
2980 if test -f "$tmp/lib$tmp_libs.dylib" ; then
2981 eval depdepl="$tmp/lib$tmp_libs.dylib"
2982 break
2983 fi
2984 done
2985 path=""
2986 ;;
2987 *) continue ;;
2988 esac
2989 ;;
2990 *) continue ;;
2991 esac
2992 case " $deplibs " in
2993 *" $path "*) ;;
2994 *) deplibs="$path $deplibs" ;;
2995 esac
2996 case " $deplibs " in
2997 *" $depdepl "*) ;;
2998 *) deplibs="$depdepl $deplibs" ;;
2999 esac
3000 done
3001 fi # link_all_deplibs != no
3002 fi # linkmode = lib
3003 done # for deplib in $libs
3004 dependency_libs="$newdependency_libs"
3005 if test "$pass" = dlpreopen; then
3006 # Link the dlpreopened libraries before other libraries
3007 for deplib in $save_deplibs; do
3008 deplibs="$deplib $deplibs"
3009 done
3010 fi
3011 if test "$pass" != dlopen; then
3012 if test "$pass" != conv; then
3013 # Make sure lib_search_path contains only unique directories.
3014 lib_search_path=
3015 for dir in $newlib_search_path; do
3016 case "$lib_search_path " in
3017 *" $dir "*) ;;
3018 *) lib_search_path="$lib_search_path $dir" ;;
3019 esac
3020 done
3021 newlib_search_path=
3022 fi
3023
3024 if test "$linkmode,$pass" != "prog,link"; then
3025 vars="deplibs"
3026 else
3027 vars="compile_deplibs finalize_deplibs"
3028 fi
3029 for var in $vars dependency_libs; do
3030 # Add libraries to $var in reverse order
3031 eval tmp_libs=\"\$$var\"
3032 new_libs=
3033 for deplib in $tmp_libs; do
3034 # FIXME: Pedantically, this is the right thing to do, so
3035 # that some nasty dependency loop isn't accidentally
3036 # broken:
3037 #new_libs="$deplib $new_libs"
3038 # Pragmatically, this seems to cause very few problems in
3039 # practice:
3040 case $deplib in
3041 -L*) new_libs="$deplib $new_libs" ;;
3042 -R*) ;;
3043 *)
3044 # And here is the reason: when a library appears more
3045 # than once as an explicit dependence of a library, or
3046 # is implicitly linked in more than once by the
3047 # compiler, it is considered special, and multiple
3048 # occurrences thereof are not removed. Compare this
3049 # with having the same library being listed as a
3050 # dependency of multiple other libraries: in this case,
3051 # we know (pedantically, we assume) the library does not
3052 # need to be listed more than once, so we keep only the
3053 # last copy. This is not always right, but it is rare
3054 # enough that we require users that really mean to play
3055 # such unportable linking tricks to link the library
3056 # using -Wl,-lname, so that libtool does not consider it
3057 # for duplicate removal.
3058 case " $specialdeplibs " in
3059 *" $deplib "*) new_libs="$deplib $new_libs" ;;
3060 *)
3061 case " $new_libs " in
3062 *" $deplib "*) ;;
3063 *) new_libs="$deplib $new_libs" ;;
3064 esac
3065 ;;
3066 esac
3067 ;;
3068 esac
3069 done
3070 tmp_libs=
3071 for deplib in $new_libs; do
3072 case $deplib in
3073 -L*)
3074 case " $tmp_libs " in
3075 *" $deplib "*) ;;
3076 *) tmp_libs="$tmp_libs $deplib" ;;
3077 esac
3078 ;;
3079 *) tmp_libs="$tmp_libs $deplib" ;;
3080 esac
3081 done
3082 eval $var=\"$tmp_libs\"
3083 done # for var
3084 fi
3085 # Last step: remove runtime libs from dependency_libs
3086 # (they stay in deplibs)
3087 tmp_libs=
3088 for i in $dependency_libs ; do
3089 case " $predeps $postdeps $compiler_lib_search_path " in
3090 *" $i "*)
3091 i=""
3092 ;;
3093 esac
3094 if test -n "$i" ; then
3095 tmp_libs="$tmp_libs $i"
3096 fi
3097 done
3098 dependency_libs=$tmp_libs
3099 done # for pass
3100 if test "$linkmode" = prog; then
3101 dlfiles="$newdlfiles"
3102 dlprefiles="$newdlprefiles"
3103 fi
3104
3105 case $linkmode in
3106 oldlib)
3107 if test -n "$deplibs"; then
3108 $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
3109 fi
3110
3111 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3112 $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3113 fi
3114
3115 if test -n "$rpath"; then
3116 $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3117 fi
3118
3119 if test -n "$xrpath"; then
3120 $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3121 fi
3122
3123 if test -n "$vinfo"; then
3124 $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3125 fi
3126
3127 if test -n "$release"; then
3128 $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3129 fi
3130
3131 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3132 $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3133 fi
3134
3135 # Now set the variables for building old libraries.
3136 build_libtool_libs=no
3137 oldlibs="$output"
3138 objs="$objs$old_deplibs"
3139 ;;
3140
3141 lib)
3142 # Make sure we only generate libraries of the form `libNAME.la'.
3143 case $outputname in
3144 lib*)
3145 name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3146 eval shared_ext=\"$shrext_cmds\"
3147 eval libname=\"$libname_spec\"
3148 ;;
3149 *)
3150 if test "$module" = no; then
3151 $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3152 $echo "$help" 1>&2
3153 exit $EXIT_FAILURE
3154 fi
3155 if test "$need_lib_prefix" != no; then
3156 # Add the "lib" prefix for modules if required
3157 name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3158 eval shared_ext=\"$shrext_cmds\"
3159 eval libname=\"$libname_spec\"
3160 else
3161 libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3162 fi
3163 ;;
3164 esac
3165
3166 if test -n "$objs"; then
3167 if test "$deplibs_check_method" != pass_all; then
3168 $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3169 exit $EXIT_FAILURE
3170 else
3171 $echo
3172 $echo "*** Warning: Linking the shared library $output against the non-libtool"
3173 $echo "*** objects $objs is not portable!"
3174 libobjs="$libobjs $objs"
3175 fi
3176 fi
3177
3178 if test "$dlself" != no; then
3179 $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3180 fi
3181
3182 set dummy $rpath
3183 if test "$#" -gt 2; then
3184 $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3185 fi
3186 install_libdir="$2"
3187
3188 oldlibs=
3189 if test -z "$rpath"; then
3190 if test "$build_libtool_libs" = yes; then
3191 # Building a libtool convenience library.
3192 # Some compilers have problems with a `.al' extension so
3193 # convenience libraries should have the same extension an
3194 # archive normally would.
3195 oldlibs="$output_objdir/$libname.$libext $oldlibs"
3196 build_libtool_libs=convenience
3197 build_old_libs=yes
3198 fi
3199
3200 if test -n "$vinfo"; then
3201 $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3202 fi
3203
3204 if test -n "$release"; then
3205 $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3206 fi
3207 else
3208
3209 # Parse the version information argument.
3210 save_ifs="$IFS"; IFS=':'
3211 set dummy $vinfo 0 0 0
3212 IFS="$save_ifs"
3213
3214 if test -n "$8"; then
3215 $echo "$modename: too many parameters to \`-version-info'" 1>&2
3216 $echo "$help" 1>&2
3217 exit $EXIT_FAILURE
3218 fi
3219
3220 # convert absolute version numbers to libtool ages
3221 # this retains compatibility with .la files and attempts
3222 # to make the code below a bit more comprehensible
3223
3224 case $vinfo_number in
3225 yes)
3226 number_major="$2"
3227 number_minor="$3"
3228 number_revision="$4"
3229 #
3230 # There are really only two kinds -- those that
3231 # use the current revision as the major version
3232 # and those that subtract age and use age as
3233 # a minor version. But, then there is irix
3234 # which has an extra 1 added just for fun
3235 #
3236 case $version_type in
3237 darwin|linux|osf|windows)
3238 current=`expr $number_major + $number_minor`
3239 age="$number_minor"
3240 revision="$number_revision"
3241 ;;
3242 freebsd-aout|freebsd-elf|sunos)
3243 current="$number_major"
3244 revision="$number_minor"
3245 age="0"
3246 ;;
3247 irix|nonstopux)
3248 current=`expr $number_major + $number_minor - 1`
3249 age="$number_minor"
3250 revision="$number_minor"
3251 ;;
3252 esac
3253 ;;
3254 no)
3255 current="$2"
3256 revision="$3"
3257 age="$4"
3258 ;;
3259 esac
3260
3261 # Check that each of the things are valid numbers.
3262 case $current in
3263 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]) ;;
3264 *)
3265 $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3266 $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3267 exit $EXIT_FAILURE
3268 ;;
3269 esac
3270
3271 case $revision in
3272 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]) ;;
3273 *)
3274 $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3275 $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3276 exit $EXIT_FAILURE
3277 ;;
3278 esac
3279
3280 case $age in
3281 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]) ;;
3282 *)
3283 $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3284 $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3285 exit $EXIT_FAILURE
3286 ;;
3287 esac
3288
3289 if test "$age" -gt "$current"; then
3290 $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3291 $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3292 exit $EXIT_FAILURE
3293 fi
3294
3295 # Calculate the version variables.
3296 major=
3297 versuffix=
3298 verstring=
3299 case $version_type in
3300 none) ;;
3301
3302 darwin)
3303 # Like Linux, but with the current version available in
3304 # verstring for coding it into the library header
3305 major=.`expr $current - $age`
3306 versuffix="$major.$age.$revision"
3307 # Darwin ld doesn't like 0 for these options...
3308 minor_current=`expr $current + 1`
3309 verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3310 ;;
3311
3312 freebsd-aout)
3313 major=".$current"
3314 versuffix=".$current.$revision";
3315 ;;
3316
3317 freebsd-elf)
3318 major=".$current"
3319 versuffix=".$current";
3320 ;;
3321
3322 irix | nonstopux)
3323 major=`expr $current - $age + 1`
3324
3325 case $version_type in
3326 nonstopux) verstring_prefix=nonstopux ;;
3327 *) verstring_prefix=sgi ;;
3328 esac
3329 verstring="$verstring_prefix$major.$revision"
3330
3331 # Add in all the interfaces that we are compatible with.
3332 loop=$revision
3333 while test "$loop" -ne 0; do
3334 iface=`expr $revision - $loop`
3335 loop=`expr $loop - 1`
3336 verstring="$verstring_prefix$major.$iface:$verstring"
3337 done
3338
3339 # Before this point, $major must not contain `.'.
3340 major=.$major
3341 versuffix="$major.$revision"
3342 ;;
3343
3344 linux)
3345 major=.`expr $current - $age`
3346 versuffix="$major.$age.$revision"
3347 ;;
3348
3349 osf)
3350 major=.`expr $current - $age`
3351 versuffix=".$current.$age.$revision"
3352 verstring="$current.$age.$revision"
3353
3354 # Add in all the interfaces that we are compatible with.
3355 loop=$age
3356 while test "$loop" -ne 0; do
3357 iface=`expr $current - $loop`
3358 loop=`expr $loop - 1`
3359 verstring="$verstring:${iface}.0"
3360 done
3361
3362 # Make executables depend on our current version.
3363 verstring="$verstring:${current}.0"
3364 ;;
3365
3366 sunos)
3367 major=".$current"
3368 versuffix=".$current.$revision"
3369 ;;
3370
3371 windows)
3372 # Use '-' rather than '.', since we only want one
3373 # extension on DOS 8.3 filesystems.
3374 major=`expr $current - $age`
3375 versuffix="-$major"
3376 ;;
3377
3378 *)
3379 $echo "$modename: unknown library version type \`$version_type'" 1>&2
3380 $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
3381 exit $EXIT_FAILURE
3382 ;;
3383 esac
3384
3385 # Clear the version info if we defaulted, and they specified a release.
3386 if test -z "$vinfo" && test -n "$release"; then
3387 major=
3388 case $version_type in
3389 darwin)
3390 # we can't check for "0.0" in archive_cmds due to quoting
3391 # problems, so we reset it completely
3392 verstring=
3393 ;;
3394 *)
3395 verstring="0.0"
3396 ;;
3397 esac
3398 if test "$need_version" = no; then
3399 versuffix=
3400 else
3401 versuffix=".0.0"
3402 fi
3403 fi
3404
3405 # Remove version info from name if versioning should be avoided
3406 if test "$avoid_version" = yes && test "$need_version" = no; then
3407 major=
3408 versuffix=
3409 verstring=""
3410 fi
3411
3412 # Check to see if the archive will have undefined symbols.
3413 if test "$allow_undefined" = yes; then
3414 if test "$allow_undefined_flag" = unsupported; then
3415 $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3416 build_libtool_libs=no
3417 build_old_libs=yes
3418 fi
3419 else
3420 # Don't allow undefined symbols.
3421 allow_undefined_flag="$no_undefined_flag"
3422 fi
3423 fi
3424
3425 if test "$mode" != relink; then
3426 # Remove our outputs, but don't remove object files since they
3427 # may have been created when compiling PIC objects.
3428 removelist=
3429 tempremovelist=`$echo "$output_objdir/*"`
3430 for p in $tempremovelist; do
3431 case $p in
3432 *.$objext)
3433 ;;
3434 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3435 if test "X$precious_files_regex" != "X"; then
3436 if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3437 then
3438 continue
3439 fi
3440 fi
3441 removelist="$removelist $p"
3442 ;;
3443 *) ;;
3444 esac
3445 done
3446 if test -n "$removelist"; then
3447 $show "${rm}r $removelist"
3448 $run ${rm}r $removelist
3449 fi
3450 fi
3451
3452 # Now set the variables for building old libraries.
3453 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3454 oldlibs="$oldlibs $output_objdir/$libname.$libext"
3455
3456 # Transform .lo files to .o files.
3457 oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3458 fi
3459
3460 # Eliminate all temporary directories.
3461 for path in $notinst_path; do
3462 lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3463 deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3464 dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
3465 done
3466
3467 if test -n "$xrpath"; then
3468 # If the user specified any rpath flags, then add them.
3469 temp_xrpath=
3470 for libdir in $xrpath; do
3471 temp_xrpath="$temp_xrpath -R$libdir"
3472 case "$finalize_rpath " in
3473 *" $libdir "*) ;;
3474 *) finalize_rpath="$finalize_rpath $libdir" ;;
3475 esac
3476 done
3477 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3478 dependency_libs="$temp_xrpath $dependency_libs"
3479 fi
3480 fi
3481
3482 # Make sure dlfiles contains only unique files that won't be dlpreopened
3483 old_dlfiles="$dlfiles"
3484 dlfiles=
3485 for lib in $old_dlfiles; do
3486 case " $dlprefiles $dlfiles " in
3487 *" $lib "*) ;;
3488 *) dlfiles="$dlfiles $lib" ;;
3489 esac
3490 done
3491
3492 # Make sure dlprefiles contains only unique files
3493 old_dlprefiles="$dlprefiles"
3494 dlprefiles=
3495 for lib in $old_dlprefiles; do
3496 case "$dlprefiles " in
3497 *" $lib "*) ;;
3498 *) dlprefiles="$dlprefiles $lib" ;;
3499 esac
3500 done
3501
3502 if test "$build_libtool_libs" = yes; then
3503 if test -n "$rpath"; then
3504 case $host in
3505 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3506 # these systems don't actually have a c library (as such)!
3507 ;;
3508 *-*-rhapsody* | *-*-darwin1.[012])
3509 # Rhapsody C library is in the System framework
3510 deplibs="$deplibs -framework System"
3511 ;;
3512 *-*-netbsd*)
3513 # Don't link with libc until the a.out ld.so is fixed.
3514 ;;
3515 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3516 # Do not include libc due to us having libc/libc_r.
3517 ;;
3518 *-*-sco3.2v5* | *-*-sco5v6*)
3519 # Causes problems with __ctype
3520 ;;
3521 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3522 # Compiler inserts libc in the correct place for threads to work
3523 ;;
3524 *)
3525 # Add libc to deplibs on all other systems if necessary.
3526 if test "$build_libtool_need_lc" = "yes"; then
3527 deplibs="$deplibs -lc"
3528 fi
3529 ;;
3530 esac
3531 fi
3532
3533 # Transform deplibs into only deplibs that can be linked in shared.
3534 name_save=$name
3535 libname_save=$libname
3536 release_save=$release
3537 versuffix_save=$versuffix
3538 major_save=$major
3539 # I'm not sure if I'm treating the release correctly. I think
3540 # release should show up in the -l (ie -lgmp5) so we don't want to
3541 # add it in twice. Is that correct?
3542 release=""
3543 versuffix=""
3544 major=""
3545 newdeplibs=
3546 droppeddeps=no
3547 case $deplibs_check_method in
3548 pass_all)
3549 # Don't check for shared/static. Everything works.
3550 # This might be a little naive. We might want to check
3551 # whether the library exists or not. But this is on
3552 # osf3 & osf4 and I'm not really sure... Just
3553 # implementing what was already the behavior.
3554 newdeplibs=$deplibs
3555 ;;
3556 test_compile)
3557 # This code stresses the "libraries are programs" paradigm to its
3558 # limits. Maybe even breaks it. We compile a program, linking it
3559 # against the deplibs as a proxy for the library. Then we can check
3560 # whether they linked in statically or dynamically with ldd.
3561 $rm conftest.c
3562 cat > conftest.c <<EOF
3563 int main() { return 0; }
3564 EOF
3565 $rm conftest
3566 $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
3567 if test "$?" -eq 0 ; then
3568 ldd_output=`ldd conftest`
3569 for i in $deplibs; do
3570 name=`expr $i : '-l\(.*\)'`
3571 # If $name is empty we are operating on a -L argument.
3572 if test "$name" != "" && test "$name" -ne "0"; then
3573 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3574 case " $predeps $postdeps " in
3575 *" $i "*)
3576 newdeplibs="$newdeplibs $i"
3577 i=""
3578 ;;
3579 esac
3580 fi
3581 if test -n "$i" ; then
3582 libname=`eval \\$echo \"$libname_spec\"`
3583 deplib_matches=`eval \\$echo \"$library_names_spec\"`
3584 set dummy $deplib_matches
3585 deplib_match=$2
3586 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3587 newdeplibs="$newdeplibs $i"
3588 else
3589 droppeddeps=yes
3590 $echo
3591 $echo "*** Warning: dynamic linker does not accept needed library $i."
3592 $echo "*** I have the capability to make that library automatically link in when"
3593 $echo "*** you link to this library. But I can only do this if you have a"
3594 $echo "*** shared version of the library, which I believe you do not have"
3595 $echo "*** because a test_compile did reveal that the linker did not use it for"
3596 $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3597 fi
3598 fi
3599 else
3600 newdeplibs="$newdeplibs $i"
3601 fi
3602 done
3603 else
3604 # Error occurred in the first compile. Let's try to salvage
3605 # the situation: Compile a separate program for each library.
3606 for i in $deplibs; do
3607 name=`expr $i : '-l\(.*\)'`
3608 # If $name is empty we are operating on a -L argument.
3609 if test "$name" != "" && test "$name" != "0"; then
3610 $rm conftest
3611 $LTCC $LTCFLAGS -o conftest conftest.c $i
3612 # Did it work?
3613 if test "$?" -eq 0 ; then
3614 ldd_output=`ldd conftest`
3615 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3616 case " $predeps $postdeps " in
3617 *" $i "*)
3618 newdeplibs="$newdeplibs $i"
3619 i=""
3620 ;;
3621 esac
3622 fi
3623 if test -n "$i" ; then
3624 libname=`eval \\$echo \"$libname_spec\"`
3625 deplib_matches=`eval \\$echo \"$library_names_spec\"`
3626 set dummy $deplib_matches
3627 deplib_match=$2
3628 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3629 newdeplibs="$newdeplibs $i"
3630 else
3631 droppeddeps=yes
3632 $echo
3633 $echo "*** Warning: dynamic linker does not accept needed library $i."
3634 $echo "*** I have the capability to make that library automatically link in when"
3635 $echo "*** you link to this library. But I can only do this if you have a"
3636 $echo "*** shared version of the library, which you do not appear to have"
3637 $echo "*** because a test_compile did reveal that the linker did not use this one"
3638 $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3639 fi
3640 fi
3641 else
3642 droppeddeps=yes
3643 $echo
3644 $echo "*** Warning! Library $i is needed by this library but I was not able to"
3645 $echo "*** make it link in! You will probably need to install it or some"
3646 $echo "*** library that it depends on before this library will be fully"
3647 $echo "*** functional. Installing it before continuing would be even better."
3648 fi
3649 else
3650 newdeplibs="$newdeplibs $i"
3651 fi
3652 done
3653 fi
3654 ;;
3655 file_magic*)
3656 set dummy $deplibs_check_method
3657 file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3658 for a_deplib in $deplibs; do
3659 name=`expr $a_deplib : '-l\(.*\)'`
3660 # If $name is empty we are operating on a -L argument.
3661 if test "$name" != "" && test "$name" != "0"; then
3662 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3663 case " $predeps $postdeps " in
3664 *" $a_deplib "*)
3665 newdeplibs="$newdeplibs $a_deplib"
3666 a_deplib=""
3667 ;;
3668 esac
3669 fi
3670 if test -n "$a_deplib" ; then
3671 libname=`eval \\$echo \"$libname_spec\"`
3672 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3673 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3674 for potent_lib in $potential_libs; do
3675 # Follow soft links.
3676 if ls -lLd "$potent_lib" 2>/dev/null \
3677 | grep " -> " >/dev/null; then
3678 continue
3679 fi
3680 # The statement above tries to avoid entering an
3681 # endless loop below, in case of cyclic links.
3682 # We might still enter an endless loop, since a link
3683 # loop can be closed while we follow links,
3684 # but so what?
3685 potlib="$potent_lib"
3686 while test -h "$potlib" 2>/dev/null; do
3687 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3688 case $potliblink in
3689 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3690 *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3691 esac
3692 done
3693 # It is ok to link against an archive when
3694 # building a shared library.
3695 if $AR -t $potlib > /dev/null 2>&1; then
3696 newdeplibs="$newdeplibs $a_deplib"
3697 a_deplib=""
3698 break 2
3699 fi
3700 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3701 | ${SED} 10q \
3702 | $EGREP "$file_magic_regex" > /dev/null; then
3703 newdeplibs="$newdeplibs $a_deplib"
3704 a_deplib=""
3705 break 2
3706 fi
3707 done
3708 done
3709 fi
3710 if test -n "$a_deplib" ; then
3711 droppeddeps=yes
3712 $echo
3713 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3714 $echo "*** I have the capability to make that library automatically link in when"
3715 $echo "*** you link to this library. But I can only do this if you have a"
3716 $echo "*** shared version of the library, which you do not appear to have"
3717 $echo "*** because I did check the linker path looking for a file starting"
3718 if test -z "$potlib" ; then
3719 $echo "*** with $libname but no candidates were found. (...for file magic test)"
3720 else
3721 $echo "*** with $libname and none of the candidates passed a file format test"
3722 $echo "*** using a file magic. Last file checked: $potlib"
3723 fi
3724 fi
3725 else
3726 # Add a -L argument.
3727 newdeplibs="$newdeplibs $a_deplib"
3728 fi
3729 done # Gone through all deplibs.
3730 ;;
3731 match_pattern*)
3732 set dummy $deplibs_check_method
3733 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3734 for a_deplib in $deplibs; do
3735 name=`expr $a_deplib : '-l\(.*\)'`
3736 # If $name is empty we are operating on a -L argument.
3737 if test -n "$name" && test "$name" != "0"; then
3738 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3739 case " $predeps $postdeps " in
3740 *" $a_deplib "*)
3741 newdeplibs="$newdeplibs $a_deplib"
3742 a_deplib=""
3743 ;;
3744 esac
3745 fi
3746 if test -n "$a_deplib" ; then
3747 libname=`eval \\$echo \"$libname_spec\"`
3748 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3749 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3750 for potent_lib in $potential_libs; do
3751 potlib="$potent_lib" # see symlink-check above in file_magic test
3752 if eval $echo \"$potent_lib\" 2>/dev/null \
3753 | ${SED} 10q \
3754 | $EGREP "$match_pattern_regex" > /dev/null; then
3755 newdeplibs="$newdeplibs $a_deplib"
3756 a_deplib=""
3757 break 2
3758 fi
3759 done
3760 done
3761 fi
3762 if test -n "$a_deplib" ; then
3763 droppeddeps=yes
3764 $echo
3765 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3766 $echo "*** I have the capability to make that library automatically link in when"
3767 $echo "*** you link to this library. But I can only do this if you have a"
3768 $echo "*** shared version of the library, which you do not appear to have"
3769 $echo "*** because I did check the linker path looking for a file starting"
3770 if test -z "$potlib" ; then
3771 $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3772 else
3773 $echo "*** with $libname and none of the candidates passed a file format test"
3774 $echo "*** using a regex pattern. Last file checked: $potlib"
3775 fi
3776 fi
3777 else
3778 # Add a -L argument.
3779 newdeplibs="$newdeplibs $a_deplib"
3780 fi
3781 done # Gone through all deplibs.
3782 ;;
3783 none | unknown | *)
3784 newdeplibs=""
3785 tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3786 -e 's/ -[LR][^ ]*//g'`
3787 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3788 for i in $predeps $postdeps ; do
3789 # can't use Xsed below, because $i might contain '/'
3790 tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3791 done
3792 fi
3793 if $echo "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' \
3794 | grep . >/dev/null; then
3795 $echo
3796 if test "X$deplibs_check_method" = "Xnone"; then
3797 $echo "*** Warning: inter-library dependencies are not supported in this platform."
3798 else
3799 $echo "*** Warning: inter-library dependencies are not known to be supported."
3800 fi
3801 $echo "*** All declared inter-library dependencies are being dropped."
3802 droppeddeps=yes
3803 fi
3804 ;;
3805 esac
3806 versuffix=$versuffix_save
3807 major=$major_save
3808 release=$release_save
3809 libname=$libname_save
3810 name=$name_save
3811
3812 case $host in
3813 *-*-rhapsody* | *-*-darwin1.[012])
3814 # On Rhapsody replace the C library is the System framework
3815 newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3816 ;;
3817 esac
3818
3819 if test "$droppeddeps" = yes; then
3820 if test "$module" = yes; then
3821 $echo
3822 $echo "*** Warning: libtool could not satisfy all declared inter-library"
3823 $echo "*** dependencies of module $libname. Therefore, libtool will create"
3824 $echo "*** a static module, that should work as long as the dlopening"
3825 $echo "*** application is linked with the -dlopen flag."
3826 if test -z "$global_symbol_pipe"; then
3827 $echo
3828 $echo "*** However, this would only work if libtool was able to extract symbol"
3829 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3830 $echo "*** not find such a program. So, this module is probably useless."
3831 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3832 fi
3833 if test "$build_old_libs" = no; then
3834 oldlibs="$output_objdir/$libname.$libext"
3835 build_libtool_libs=module
3836 build_old_libs=yes
3837 else
3838 build_libtool_libs=no
3839 fi
3840 else
3841 $echo "*** The inter-library dependencies that have been dropped here will be"
3842 $echo "*** automatically added whenever a program is linked with this library"
3843 $echo "*** or is declared to -dlopen it."
3844
3845 if test "$allow_undefined" = no; then
3846 $echo
3847 $echo "*** Since this library must not contain undefined symbols,"
3848 $echo "*** because either the platform does not support them or"
3849 $echo "*** it was explicitly requested with -no-undefined,"
3850 $echo "*** libtool will only create a static version of it."
3851 if test "$build_old_libs" = no; then
3852 oldlibs="$output_objdir/$libname.$libext"
3853 build_libtool_libs=module
3854 build_old_libs=yes
3855 else
3856 build_libtool_libs=no
3857 fi
3858 fi
3859 fi
3860 fi
3861 # Done checking deplibs!
3862 deplibs=$newdeplibs
3863 fi
3864
3865
3866 # move library search paths that coincide with paths to not yet
3867 # installed libraries to the beginning of the library search list
3868 new_libs=
3869 for path in $notinst_path; do
3870 case " $new_libs " in
3871 *" -L$path/$objdir "*) ;;
3872 *)
3873 case " $deplibs " in
3874 *" -L$path/$objdir "*)
3875 new_libs="$new_libs -L$path/$objdir" ;;
3876 esac
3877 ;;
3878 esac
3879 done
3880 for deplib in $deplibs; do
3881 case $deplib in
3882 -L*)
3883 case " $new_libs " in
3884 *" $deplib "*) ;;
3885 *) new_libs="$new_libs $deplib" ;;
3886 esac
3887 ;;
3888 *) new_libs="$new_libs $deplib" ;;
3889 esac
3890 done
3891 deplibs="$new_libs"
3892
3893
3894 # All the library-specific variables (install_libdir is set above).
3895 library_names=
3896 old_library=
3897 dlname=
3898
3899 # Test again, we may have decided not to build it any more
3900 if test "$build_libtool_libs" = yes; then
3901 if test "$hardcode_into_libs" = yes; then
3902 # Hardcode the library paths
3903 hardcode_libdirs=
3904 dep_rpath=
3905 rpath="$finalize_rpath"
3906 test "$mode" != relink && rpath="$compile_rpath$rpath"
3907 for libdir in $rpath; do
3908 if test -n "$hardcode_libdir_flag_spec"; then
3909 if test -n "$hardcode_libdir_separator"; then
3910 if test -z "$hardcode_libdirs"; then
3911 hardcode_libdirs="$libdir"
3912 else
3913 # Just accumulate the unique libdirs.
3914 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3915 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3916 ;;
3917 *)
3918 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3919 ;;
3920 esac
3921 fi
3922 else
3923 eval flag=\"$hardcode_libdir_flag_spec\"
3924 dep_rpath="$dep_rpath $flag"
3925 fi
3926 elif test -n "$runpath_var"; then
3927 case "$perm_rpath " in
3928 *" $libdir "*) ;;
3929 *) perm_rpath="$perm_rpath $libdir" ;;
3930 esac
3931 fi
3932 done
3933 # Substitute the hardcoded libdirs into the rpath.
3934 if test -n "$hardcode_libdir_separator" &&
3935 test -n "$hardcode_libdirs"; then
3936 libdir="$hardcode_libdirs"
3937 if test -n "$hardcode_libdir_flag_spec_ld"; then
3938 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3939 else
3940 eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3941 fi
3942 fi
3943 if test -n "$runpath_var" && test -n "$perm_rpath"; then
3944 # We should set the runpath_var.
3945 rpath=
3946 for dir in $perm_rpath; do
3947 rpath="$rpath$dir:"
3948 done
3949 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3950 fi
3951 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3952 fi
3953
3954 shlibpath="$finalize_shlibpath"
3955 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3956 if test -n "$shlibpath"; then
3957 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3958 fi
3959
3960 # Get the real and link names of the library.
3961 eval shared_ext=\"$shrext_cmds\"
3962 eval library_names=\"$library_names_spec\"
3963 set dummy $library_names
3964 realname="$2"
3965 shift; shift
3966
3967 if test -n "$soname_spec"; then
3968 eval soname=\"$soname_spec\"
3969 else
3970 soname="$realname"
3971 fi
3972 if test -z "$dlname"; then
3973 dlname=$soname
3974 fi
3975
3976 lib="$output_objdir/$realname"
3977 linknames=
3978 for link
3979 do
3980 linknames="$linknames $link"
3981 done
3982
3983 # Use standard objects if they are pic
3984 test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3985
3986 # Prepare the list of exported symbols
3987 if test -z "$export_symbols"; then
3988 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3989 $show "generating symbol list for \`$libname.la'"
3990 export_symbols="$output_objdir/$libname.exp"
3991 $run $rm $export_symbols
3992 cmds=$export_symbols_cmds
3993 save_ifs="$IFS"; IFS='~'
3994 for cmd in $cmds; do
3995 IFS="$save_ifs"
3996 eval cmd=\"$cmd\"
3997 if len=`expr "X$cmd" : ".*"` &&
3998 test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3999 $show "$cmd"
4000 $run eval "$cmd" || exit $?
4001 skipped_export=false
4002 else
4003 # The command line is too long to execute in one step.
4004 $show "using reloadable object file for export list..."
4005 skipped_export=:
4006 # Break out early, otherwise skipped_export may be
4007 # set to false by a later but shorter cmd.
4008 break
4009 fi
4010 done
4011 IFS="$save_ifs"
4012 if test -n "$export_symbols_regex"; then
4013 $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
4014 $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
4015 $show "$mv \"${export_symbols}T\" \"$export_symbols\""
4016 $run eval '$mv "${export_symbols}T" "$export_symbols"'
4017 fi
4018 fi
4019 fi
4020
4021 if test -n "$export_symbols" && test -n "$include_expsyms"; then
4022 $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
4023 fi
4024
4025 tmp_deplibs=
4026 for test_deplib in $deplibs; do
4027 case " $convenience " in
4028 *" $test_deplib "*) ;;
4029 *)
4030 tmp_deplibs="$tmp_deplibs $test_deplib"
4031 ;;
4032 esac
4033 done
4034 deplibs="$tmp_deplibs"
4035
4036 if test -n "$convenience"; then
4037 if test -n "$whole_archive_flag_spec"; then
4038 save_libobjs=$libobjs
4039 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4040 else
4041 gentop="$output_objdir/${outputname}x"
4042 generated="$generated $gentop"
4043
4044 func_extract_archives $gentop $convenience
4045 libobjs="$libobjs $func_extract_archives_result"
4046 fi
4047 fi
4048
4049 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
4050 eval flag=\"$thread_safe_flag_spec\"
4051 linker_flags="$linker_flags $flag"
4052 fi
4053
4054 # Make a backup of the uninstalled library when relinking
4055 if test "$mode" = relink; then
4056 $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
4057 fi
4058
4059 # Do each of the archive commands.
4060 if test "$module" = yes && test -n "$module_cmds" ; then
4061 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4062 eval test_cmds=\"$module_expsym_cmds\"
4063 cmds=$module_expsym_cmds
4064 else
4065 eval test_cmds=\"$module_cmds\"
4066 cmds=$module_cmds
4067 fi
4068 else
4069 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4070 eval test_cmds=\"$archive_expsym_cmds\"
4071 cmds=$archive_expsym_cmds
4072 else
4073 eval test_cmds=\"$archive_cmds\"
4074 cmds=$archive_cmds
4075 fi
4076 fi
4077
4078 if test "X$skipped_export" != "X:" &&
4079 len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4080 test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4081 :
4082 else
4083 # The command line is too long to link in one step, link piecewise.
4084 $echo "creating reloadable object files..."
4085
4086 # Save the value of $output and $libobjs because we want to
4087 # use them later. If we have whole_archive_flag_spec, we
4088 # want to use save_libobjs as it was before
4089 # whole_archive_flag_spec was expanded, because we can't
4090 # assume the linker understands whole_archive_flag_spec.
4091 # This may have to be revisited, in case too many
4092 # convenience libraries get linked in and end up exceeding
4093 # the spec.
4094 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
4095 save_libobjs=$libobjs
4096 fi
4097 save_output=$output
4098 output_la=`$echo "X$output" | $Xsed -e "$basename"`
4099
4100 # Clear the reloadable object creation command queue and
4101 # initialize k to one.
4102 test_cmds=
4103 concat_cmds=
4104 objlist=
4105 delfiles=
4106 last_robj=
4107 k=1
4108 output=$output_objdir/$output_la-${k}.$objext
4109 # Loop over the list of objects to be linked.
4110 for obj in $save_libobjs
4111 do
4112 eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4113 if test "X$objlist" = X ||
4114 { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4115 test "$len" -le "$max_cmd_len"; }; then
4116 objlist="$objlist $obj"
4117 else
4118 # The command $test_cmds is almost too long, add a
4119 # command to the queue.
4120 if test "$k" -eq 1 ; then
4121 # The first file doesn't have a previous command to add.
4122 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4123 else
4124 # All subsequent reloadable object files will link in
4125 # the last one created.
4126 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4127 fi
4128 last_robj=$output_objdir/$output_la-${k}.$objext
4129 k=`expr $k + 1`
4130 output=$output_objdir/$output_la-${k}.$objext
4131 objlist=$obj
4132 len=1
4133 fi
4134 done
4135 # Handle the remaining objects by creating one last
4136 # reloadable object file. All subsequent reloadable object
4137 # files will link in the last one created.
4138 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4139 eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4140
4141 if ${skipped_export-false}; then
4142 $show "generating symbol list for \`$libname.la'"
4143 export_symbols="$output_objdir/$libname.exp"
4144 $run $rm $export_symbols
4145 libobjs=$output
4146 # Append the command to create the export file.
4147 eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4148 fi
4149
4150 # Set up a command to remove the reloadable object files
4151 # after they are used.
4152 i=0
4153 while test "$i" -lt "$k"
4154 do
4155 i=`expr $i + 1`
4156 delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4157 done
4158
4159 $echo "creating a temporary reloadable object file: $output"
4160
4161 # Loop through the commands generated above and execute them.
4162 save_ifs="$IFS"; IFS='~'
4163 for cmd in $concat_cmds; do
4164 IFS="$save_ifs"
4165 $show "$cmd"
4166 $run eval "$cmd" || exit $?
4167 done
4168 IFS="$save_ifs"
4169
4170 libobjs=$output
4171 # Restore the value of output.
4172 output=$save_output
4173
4174 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4175 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4176 fi
4177 # Expand the library linking commands again to reset the
4178 # value of $libobjs for piecewise linking.
4179
4180 # Do each of the archive commands.
4181 if test "$module" = yes && test -n "$module_cmds" ; then
4182 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4183 cmds=$module_expsym_cmds
4184 else
4185 cmds=$module_cmds
4186 fi
4187 else
4188 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4189 cmds=$archive_expsym_cmds
4190 else
4191 cmds=$archive_cmds
4192 fi
4193 fi
4194
4195 # Append the command to remove the reloadable object files
4196 # to the just-reset $cmds.
4197 eval cmds=\"\$cmds~\$rm $delfiles\"
4198 fi
4199 save_ifs="$IFS"; IFS='~'
4200 for cmd in $cmds; do
4201 IFS="$save_ifs"
4202 eval cmd=\"$cmd\"
4203 $show "$cmd"
4204 $run eval "$cmd" || {
4205 lt_exit=$?
4206
4207 # Restore the uninstalled library and exit
4208 if test "$mode" = relink; then
4209 $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
4210 fi
4211
4212 exit $lt_exit
4213 }
4214 done
4215 IFS="$save_ifs"
4216
4217 # Restore the uninstalled library and exit
4218 if test "$mode" = relink; then
4219 $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
4220
4221 if test -n "$convenience"; then
4222 if test -z "$whole_archive_flag_spec"; then
4223 $show "${rm}r $gentop"
4224 $run ${rm}r "$gentop"
4225 fi
4226 fi
4227
4228 exit $EXIT_SUCCESS
4229 fi
4230
4231 # Create links to the real library.
4232 for linkname in $linknames; do
4233 if test "$realname" != "$linkname"; then
4234 $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4235 $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
4236 fi
4237 done
4238
4239 # If -module or -export-dynamic was specified, set the dlname.
4240 if test "$module" = yes || test "$export_dynamic" = yes; then
4241 # On all known operating systems, these are identical.
4242 dlname="$soname"
4243 fi
4244 fi
4245 ;;
4246
4247 obj)
4248 if test -n "$deplibs"; then
4249 $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4250 fi
4251
4252 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4253 $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4254 fi
4255
4256 if test -n "$rpath"; then
4257 $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4258 fi
4259
4260 if test -n "$xrpath"; then
4261 $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4262 fi
4263
4264 if test -n "$vinfo"; then
4265 $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4266 fi
4267
4268 if test -n "$release"; then
4269 $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4270 fi
4271
4272 case $output in
4273 *.lo)
4274 if test -n "$objs$old_deplibs"; then
4275 $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4276 exit $EXIT_FAILURE
4277 fi
4278 libobj="$output"
4279 obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4280 ;;
4281 *)
4282 libobj=
4283 obj="$output"
4284 ;;
4285 esac
4286
4287 # Delete the old objects.
4288 $run $rm $obj $libobj
4289
4290 # Objects from convenience libraries. This assumes
4291 # single-version convenience libraries. Whenever we create
4292 # different ones for PIC/non-PIC, this we'll have to duplicate
4293 # the extraction.
4294 reload_conv_objs=
4295 gentop=
4296 # reload_cmds runs $LD directly, so let us get rid of
4297 # -Wl from whole_archive_flag_spec
4298 wl=
4299
4300 if test -n "$convenience"; then
4301 if test -n "$whole_archive_flag_spec"; then
4302 eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
4303 else
4304 gentop="$output_objdir/${obj}x"
4305 generated="$generated $gentop"
4306
4307 func_extract_archives $gentop $convenience
4308 reload_conv_objs="$reload_objs $func_extract_archives_result"
4309 fi
4310 fi
4311
4312 # Create the old-style object.
4313 reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4314
4315 output="$obj"
4316 cmds=$reload_cmds
4317 save_ifs="$IFS"; IFS='~'
4318 for cmd in $cmds; do
4319 IFS="$save_ifs"
4320 eval cmd=\"$cmd\"
4321 $show "$cmd"
4322 $run eval "$cmd" || exit $?
4323 done
4324 IFS="$save_ifs"
4325
4326 # Exit if we aren't doing a library object file.
4327 if test -z "$libobj"; then
4328 if test -n "$gentop"; then
4329 $show "${rm}r $gentop"
4330 $run ${rm}r $gentop
4331 fi
4332
4333 exit $EXIT_SUCCESS
4334 fi
4335
4336 if test "$build_libtool_libs" != yes; then
4337 if test -n "$gentop"; then
4338 $show "${rm}r $gentop"
4339 $run ${rm}r $gentop
4340 fi
4341
4342 # Create an invalid libtool object if no PIC, so that we don't
4343 # accidentally link it into a program.
4344 # $show "echo timestamp > $libobj"
4345 # $run eval "echo timestamp > $libobj" || exit $?
4346 exit $EXIT_SUCCESS
4347 fi
4348
4349 if test -n "$pic_flag" || test "$pic_mode" != default; then
4350 # Only do commands if we really have different PIC objects.
4351 reload_objs="$libobjs $reload_conv_objs"
4352 output="$libobj"
4353 cmds=$reload_cmds
4354 save_ifs="$IFS"; IFS='~'
4355 for cmd in $cmds; do
4356 IFS="$save_ifs"
4357 eval cmd=\"$cmd\"
4358 $show "$cmd"
4359 $run eval "$cmd" || exit $?
4360 done
4361 IFS="$save_ifs"
4362 fi
4363
4364 if test -n "$gentop"; then
4365 $show "${rm}r $gentop"
4366 $run ${rm}r $gentop
4367 fi
4368
4369 exit $EXIT_SUCCESS
4370 ;;
4371
4372 prog)
4373 case $host in
4374 *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4375 esac
4376 if test -n "$vinfo"; then
4377 $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4378 fi
4379
4380 if test -n "$release"; then
4381 $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4382 fi
4383
4384 if test "$preload" = yes; then
4385 if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4386 test "$dlopen_self_static" = unknown; then
4387 $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4388 fi
4389 fi
4390
4391 case $host in
4392 *-*-rhapsody* | *-*-darwin1.[012])
4393 # On Rhapsody replace the C library is the System framework
4394 compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4395 finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4396 ;;
4397 esac
4398
4399 case $host in
4400 *darwin*)
4401 # Don't allow lazy linking, it breaks C++ global constructors
4402 if test "$tagname" = CXX ; then
4403 compile_command="$compile_command ${wl}-bind_at_load"
4404 finalize_command="$finalize_command ${wl}-bind_at_load"
4405 fi
4406 ;;
4407 esac
4408
4409
4410 # move library search paths that coincide with paths to not yet
4411 # installed libraries to the beginning of the library search list
4412 new_libs=
4413 for path in $notinst_path; do
4414 case " $new_libs " in
4415 *" -L$path/$objdir "*) ;;
4416 *)
4417 case " $compile_deplibs " in
4418 *" -L$path/$objdir "*)
4419 new_libs="$new_libs -L$path/$objdir" ;;
4420 esac
4421 ;;
4422 esac
4423 done
4424 for deplib in $compile_deplibs; do
4425 case $deplib in
4426 -L*)
4427 case " $new_libs " in
4428 *" $deplib "*) ;;
4429 *) new_libs="$new_libs $deplib" ;;
4430 esac
4431 ;;
4432 *) new_libs="$new_libs $deplib" ;;
4433 esac
4434 done
4435 compile_deplibs="$new_libs"
4436
4437
4438 compile_command="$compile_command $compile_deplibs"
4439 finalize_command="$finalize_command $finalize_deplibs"
4440
4441 if test -n "$rpath$xrpath"; then
4442 # If the user specified any rpath flags, then add them.
4443 for libdir in $rpath $xrpath; do
4444 # This is the magic to use -rpath.
4445 case "$finalize_rpath " in
4446 *" $libdir "*) ;;
4447 *) finalize_rpath="$finalize_rpath $libdir" ;;
4448 esac
4449 done
4450 fi
4451
4452 # Now hardcode the library paths
4453 rpath=
4454 hardcode_libdirs=
4455 for libdir in $compile_rpath $finalize_rpath; do
4456 if test -n "$hardcode_libdir_flag_spec"; then
4457 if test -n "$hardcode_libdir_separator"; then
4458 if test -z "$hardcode_libdirs"; then
4459 hardcode_libdirs="$libdir"
4460 else
4461 # Just accumulate the unique libdirs.
4462 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4463 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4464 ;;
4465 *)
4466 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4467 ;;
4468 esac
4469 fi
4470 else
4471 eval flag=\"$hardcode_libdir_flag_spec\"
4472 rpath="$rpath $flag"
4473 fi
4474 elif test -n "$runpath_var"; then
4475 case "$perm_rpath " in
4476 *" $libdir "*) ;;
4477 *) perm_rpath="$perm_rpath $libdir" ;;
4478 esac
4479 fi
4480 case $host in
4481 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4482 testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
4483 case :$dllsearchpath: in
4484 *":$libdir:"*) ;;
4485 *) dllsearchpath="$dllsearchpath:$libdir";;
4486 esac
4487 case :$dllsearchpath: in
4488 *":$testbindir:"*) ;;
4489 *) dllsearchpath="$dllsearchpath:$testbindir";;
4490 esac
4491 ;;
4492 esac
4493 done
4494 # Substitute the hardcoded libdirs into the rpath.
4495 if test -n "$hardcode_libdir_separator" &&
4496 test -n "$hardcode_libdirs"; then
4497 libdir="$hardcode_libdirs"
4498 eval rpath=\" $hardcode_libdir_flag_spec\"
4499 fi
4500 compile_rpath="$rpath"
4501
4502 rpath=
4503 hardcode_libdirs=
4504 for libdir in $finalize_rpath; do
4505 if test -n "$hardcode_libdir_flag_spec"; then
4506 if test -n "$hardcode_libdir_separator"; then
4507 if test -z "$hardcode_libdirs"; then
4508 hardcode_libdirs="$libdir"
4509 else
4510 # Just accumulate the unique libdirs.
4511 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4512 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4513 ;;
4514 *)
4515 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4516 ;;
4517 esac
4518 fi
4519 else
4520 eval flag=\"$hardcode_libdir_flag_spec\"
4521 rpath="$rpath $flag"
4522 fi
4523 elif test -n "$runpath_var"; then
4524 case "$finalize_perm_rpath " in
4525 *" $libdir "*) ;;
4526 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4527 esac
4528 fi
4529 done
4530 # Substitute the hardcoded libdirs into the rpath.
4531 if test -n "$hardcode_libdir_separator" &&
4532 test -n "$hardcode_libdirs"; then
4533 libdir="$hardcode_libdirs"
4534 eval rpath=\" $hardcode_libdir_flag_spec\"
4535 fi
4536 finalize_rpath="$rpath"
4537
4538 if test -n "$libobjs" && test "$build_old_libs" = yes; then
4539 # Transform all the library objects into standard objects.
4540 compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4541 finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4542 fi
4543
4544 dlsyms=
4545 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4546 if test -n "$NM" && test -n "$global_symbol_pipe"; then
4547 dlsyms="${outputname}S.c"
4548 else
4549 $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4550 fi
4551 fi
4552
4553 if test -n "$dlsyms"; then
4554 case $dlsyms in
4555 "") ;;
4556 *.c)
4557 # Discover the nlist of each of the dlfiles.
4558 nlist="$output_objdir/${outputname}.nm"
4559
4560 $show "$rm $nlist ${nlist}S ${nlist}T"
4561 $run $rm "$nlist" "${nlist}S" "${nlist}T"
4562
4563 # Parse the name list into a source file.
4564 $show "creating $output_objdir/$dlsyms"
4565
4566 test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4567 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4568 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4569
4570 #ifdef __cplusplus
4571 extern \"C\" {
4572 #endif
4573
4574 /* Prevent the only kind of declaration conflicts we can make. */
4575 #define lt_preloaded_symbols some_other_symbol
4576
4577 /* External symbol declarations for the compiler. */\
4578 "
4579
4580 if test "$dlself" = yes; then
4581 $show "generating symbol list for \`$output'"
4582
4583 test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4584
4585 # Add our own program objects to the symbol list.
4586 progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4587 for arg in $progfiles; do
4588 $show "extracting global C symbols from \`$arg'"
4589 $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4590 done
4591
4592 if test -n "$exclude_expsyms"; then
4593 $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4594 $run eval '$mv "$nlist"T "$nlist"'
4595 fi
4596
4597 if test -n "$export_symbols_regex"; then
4598 $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4599 $run eval '$mv "$nlist"T "$nlist"'
4600 fi
4601
4602 # Prepare the list of exported symbols
4603 if test -z "$export_symbols"; then
4604 export_symbols="$output_objdir/$outputname.exp"
4605 $run $rm $export_symbols
4606 $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4607 case $host in
4608 *cygwin* | *mingw* )
4609 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4610 $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4611 ;;
4612 esac
4613 else
4614 $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4615 $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4616 $run eval 'mv "$nlist"T "$nlist"'
4617 case $host in
4618 *cygwin* | *mingw* )
4619 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4620 $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4621 ;;
4622 esac
4623 fi
4624 fi
4625
4626 for arg in $dlprefiles; do
4627 $show "extracting global C symbols from \`$arg'"
4628 name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4629 $run eval '$echo ": $name " >> "$nlist"'
4630 $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4631 done
4632
4633 if test -z "$run"; then
4634 # Make sure we have at least an empty file.
4635 test -f "$nlist" || : > "$nlist"
4636
4637 if test -n "$exclude_expsyms"; then
4638 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4639 $mv "$nlist"T "$nlist"
4640 fi
4641
4642 # Try sorting and uniquifying the output.
4643 if grep -v "^: " < "$nlist" |
4644 if sort -k 3 </dev/null >/dev/null 2>&1; then
4645 sort -k 3
4646 else
4647 sort +2
4648 fi |
4649 uniq > "$nlist"S; then
4650 :
4651 else
4652 grep -v "^: " < "$nlist" > "$nlist"S
4653 fi
4654
4655 if test -f "$nlist"S; then
4656 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4657 else
4658 $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4659 fi
4660
4661 $echo >> "$output_objdir/$dlsyms" "\
4662
4663 #undef lt_preloaded_symbols
4664
4665 #if defined (__STDC__) && __STDC__
4666 # define lt_ptr void *
4667 #else
4668 # define lt_ptr char *
4669 # define const
4670 #endif
4671
4672 /* The mapping between symbol names and symbols. */
4673 "
4674
4675 case $host in
4676 *cygwin* | *mingw* )
4677 $echo >> "$output_objdir/$dlsyms" "\
4678 /* DATA imports from DLLs on WIN32 can't be const, because
4679 runtime relocations are performed -- see ld's documentation
4680 on pseudo-relocs */
4681 struct {
4682 "
4683 ;;
4684 * )
4685 $echo >> "$output_objdir/$dlsyms" "\
4686 const struct {
4687 "
4688 ;;
4689 esac
4690
4691
4692 $echo >> "$output_objdir/$dlsyms" "\
4693 const char *name;
4694 lt_ptr address;
4695 }
4696 lt_preloaded_symbols[] =
4697 {\
4698 "
4699
4700 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4701
4702 $echo >> "$output_objdir/$dlsyms" "\
4703 {0, (lt_ptr) 0}
4704 };
4705
4706 /* This works around a problem in FreeBSD linker */
4707 #ifdef FREEBSD_WORKAROUND
4708 static const void *lt_preloaded_setup() {
4709 return lt_preloaded_symbols;
4710 }
4711 #endif
4712
4713 #ifdef __cplusplus
4714 }
4715 #endif\
4716 "
4717 fi
4718
4719 pic_flag_for_symtable=
4720 case $host in
4721 # compiling the symbol table file with pic_flag works around
4722 # a FreeBSD bug that causes programs to crash when -lm is
4723 # linked before any other PIC object. But we must not use
4724 # pic_flag when linking with -static. The problem exists in
4725 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4726 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4727 case "$compile_command " in
4728 *" -static "*) ;;
4729 *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4730 esac;;
4731 *-*-hpux*)
4732 case "$compile_command " in
4733 *" -static "*) ;;
4734 *) pic_flag_for_symtable=" $pic_flag";;
4735 esac
4736 esac
4737
4738 # Now compile the dynamic symbol file.
4739 $show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4740 $run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4741
4742 # Clean up the generated files.
4743 $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4744 $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4745
4746 # Transform the symbol file into the correct name.
4747 case $host in
4748 *cygwin* | *mingw* )
4749 if test -f "$output_objdir/${outputname}.def" ; then
4750 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4751 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4752 else
4753 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4754 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4755 fi
4756 ;;
4757 * )
4758 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4759 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4760 ;;
4761 esac
4762 ;;
4763 *)
4764 $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4765 exit $EXIT_FAILURE
4766 ;;
4767 esac
4768 else
4769 # We keep going just in case the user didn't refer to
4770 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
4771 # really was required.
4772
4773 # Nullify the symbol file.
4774 compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4775 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4776 fi
4777
4778 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4779 # Replace the output file specification.
4780 compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4781 link_command="$compile_command$compile_rpath"
4782
4783 # We have no uninstalled library dependencies, so finalize right now.
4784 $show "$link_command"
4785 $run eval "$link_command"
4786 exit_status=$?
4787
4788 # Delete the generated files.
4789 if test -n "$dlsyms"; then
4790 $show "$rm $output_objdir/${outputname}S.${objext}"
4791 $run $rm "$output_objdir/${outputname}S.${objext}"
4792 fi
4793
4794 exit $exit_status
4795 fi
4796
4797 if test -n "$shlibpath_var"; then
4798 # We should set the shlibpath_var
4799 rpath=
4800 for dir in $temp_rpath; do
4801 case $dir in
4802 [\\/]* | [A-Za-z]:[\\/]*)
4803 # Absolute path.
4804 rpath="$rpath$dir:"
4805 ;;
4806 *)
4807 # Relative path: add a thisdir entry.
4808 rpath="$rpath\$thisdir/$dir:"
4809 ;;
4810 esac
4811 done
4812 temp_rpath="$rpath"
4813 fi
4814
4815 if test -n "$compile_shlibpath$finalize_shlibpath"; then
4816 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4817 fi
4818 if test -n "$finalize_shlibpath"; then
4819 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4820 fi
4821
4822 compile_var=
4823 finalize_var=
4824 if test -n "$runpath_var"; then
4825 if test -n "$perm_rpath"; then
4826 # We should set the runpath_var.
4827 rpath=
4828 for dir in $perm_rpath; do
4829 rpath="$rpath$dir:"
4830 done
4831 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4832 fi
4833 if test -n "$finalize_perm_rpath"; then
4834 # We should set the runpath_var.
4835 rpath=
4836 for dir in $finalize_perm_rpath; do
4837 rpath="$rpath$dir:"
4838 done
4839 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4840 fi
4841 fi
4842
4843 if test "$no_install" = yes; then
4844 # We don't need to create a wrapper script.
4845 link_command="$compile_var$compile_command$compile_rpath"
4846 # Replace the output file specification.
4847 link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4848 # Delete the old output file.
4849 $run $rm $output
4850 # Link the executable and exit
4851 $show "$link_command"
4852 $run eval "$link_command" || exit $?
4853 exit $EXIT_SUCCESS
4854 fi
4855
4856 if test "$hardcode_action" = relink; then
4857 # Fast installation is not supported
4858 link_command="$compile_var$compile_command$compile_rpath"
4859 relink_command="$finalize_var$finalize_command$finalize_rpath"
4860
4861 $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4862 $echo "$modename: \`$output' will be relinked during installation" 1>&2
4863 else
4864 if test "$fast_install" != no; then
4865 link_command="$finalize_var$compile_command$finalize_rpath"
4866 if test "$fast_install" = yes; then
4867 relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4868 else
4869 # fast_install is set to needless
4870 relink_command=
4871 fi
4872 else
4873 link_command="$compile_var$compile_command$compile_rpath"
4874 relink_command="$finalize_var$finalize_command$finalize_rpath"
4875 fi
4876 fi
4877
4878 # Replace the output file specification.
4879 link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4880
4881 # Delete the old output files.
4882 $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4883
4884 $show "$link_command"
4885 $run eval "$link_command" || exit $?
4886
4887 # Now create the wrapper script.
4888 $show "creating $output"
4889
4890 # Quote the relink command for shipping.
4891 if test -n "$relink_command"; then
4892 # Preserve any variables that may affect compiler behavior
4893 for var in $variables_saved_for_relink; do
4894 if eval test -z \"\${$var+set}\"; then
4895 relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4896 elif eval var_value=\$$var; test -z "$var_value"; then
4897 relink_command="$var=; export $var; $relink_command"
4898 else
4899 var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4900 relink_command="$var=\"$var_value\"; export $var; $relink_command"
4901 fi
4902 done
4903 relink_command="(cd `pwd`; $relink_command)"
4904 relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4905 fi
4906
4907 # Quote $echo for shipping.
4908 if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4909 case $progpath in
4910 [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4911 *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4912 esac
4913 qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4914 else
4915 qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4916 fi
4917
4918 # Only actually do things if our run command is non-null.
4919 if test -z "$run"; then
4920 # win32 will think the script is a binary if it has
4921 # a .exe suffix, so we strip it off here.
4922 case $output in
4923 *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4924 esac
4925 # test for cygwin because mv fails w/o .exe extensions
4926 case $host in
4927 *cygwin*)
4928 exeext=.exe
4929 outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4930 *) exeext= ;;
4931 esac
4932 case $host in
4933 *cygwin* | *mingw* )
4934 output_name=`basename $output`
4935 output_path=`dirname $output`
4936 cwrappersource="$output_path/$objdir/lt-$output_name.c"
4937 cwrapper="$output_path/$output_name.exe"
4938 $rm $cwrappersource $cwrapper
4939 trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4940
4941 cat > $cwrappersource <<EOF
4942
4943 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4944 Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4945
4946 The $output program cannot be directly executed until all the libtool
4947 libraries that it depends on are installed.
4948
4949 This wrapper executable should never be moved out of the build directory.
4950 If it is, it will not operate correctly.
4951
4952 Currently, it simply execs the wrapper *script* "/bin/sh $output",
4953 but could eventually absorb all of the scripts functionality and
4954 exec $objdir/$outputname directly.
4955 */
4956 EOF
4957 cat >> $cwrappersource<<"EOF"
4958 #include <stdio.h>
4959 #include <stdlib.h>
4960 #include <unistd.h>
4961 #include <malloc.h>
4962 #include <stdarg.h>
4963 #include <assert.h>
4964 #include <string.h>
4965 #include <ctype.h>
4966 #include <sys/stat.h>
4967
4968 #if defined(PATH_MAX)
4969 # define LT_PATHMAX PATH_MAX
4970 #elif defined(MAXPATHLEN)
4971 # define LT_PATHMAX MAXPATHLEN
4972 #else
4973 # define LT_PATHMAX 1024
4974 #endif
4975
4976 #ifndef DIR_SEPARATOR
4977 # define DIR_SEPARATOR '/'
4978 # define PATH_SEPARATOR ':'
4979 #endif
4980
4981 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4982 defined (__OS2__)
4983 # define HAVE_DOS_BASED_FILE_SYSTEM
4984 # ifndef DIR_SEPARATOR_2
4985 # define DIR_SEPARATOR_2 '\\'
4986 # endif
4987 # ifndef PATH_SEPARATOR_2
4988 # define PATH_SEPARATOR_2 ';'
4989 # endif
4990 #endif
4991
4992 #ifndef DIR_SEPARATOR_2
4993 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4994 #else /* DIR_SEPARATOR_2 */
4995 # define IS_DIR_SEPARATOR(ch) \
4996 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4997 #endif /* DIR_SEPARATOR_2 */
4998
4999 #ifndef PATH_SEPARATOR_2
5000 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5001 #else /* PATH_SEPARATOR_2 */
5002 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5003 #endif /* PATH_SEPARATOR_2 */
5004
5005 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5006 #define XFREE(stale) do { \
5007 if (stale) { free ((void *) stale); stale = 0; } \
5008 } while (0)
5009
5010 /* -DDEBUG is fairly common in CFLAGS. */
5011 #undef DEBUG
5012 #if defined DEBUGWRAPPER
5013 # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5014 #else
5015 # define DEBUG(format, ...)
5016 #endif
5017
5018 const char *program_name = NULL;
5019
5020 void * xmalloc (size_t num);
5021 char * xstrdup (const char *string);
5022 const char * base_name (const char *name);
5023 char * find_executable(const char *wrapper);
5024 int check_executable(const char *path);
5025 char * strendzap(char *str, const char *pat);
5026 void lt_fatal (const char *message, ...);
5027
5028 int
5029 main (int argc, char *argv[])
5030 {
5031 char **newargz;
5032 int i;
5033
5034 program_name = (char *) xstrdup (base_name (argv[0]));
5035 DEBUG("(main) argv[0] : %s\n",argv[0]);
5036 DEBUG("(main) program_name : %s\n",program_name);
5037 newargz = XMALLOC(char *, argc+2);
5038 EOF
5039
5040 cat >> $cwrappersource <<EOF
5041 newargz[0] = (char *) xstrdup("$SHELL");
5042 EOF
5043
5044 cat >> $cwrappersource <<"EOF"
5045 newargz[1] = find_executable(argv[0]);
5046 if (newargz[1] == NULL)
5047 lt_fatal("Couldn't find %s", argv[0]);
5048 DEBUG("(main) found exe at : %s\n",newargz[1]);
5049 /* we know the script has the same name, without the .exe */
5050 /* so make sure newargz[1] doesn't end in .exe */
5051 strendzap(newargz[1],".exe");
5052 for (i = 1; i < argc; i++)
5053 newargz[i+1] = xstrdup(argv[i]);
5054 newargz[argc+1] = NULL;
5055
5056 for (i=0; i<argc+1; i++)
5057 {
5058 DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
5059 ;
5060 }
5061
5062 EOF
5063
5064 case $host_os in
5065 mingw*)
5066 cat >> $cwrappersource <<EOF
5067 execv("$SHELL",(char const **)newargz);
5068 EOF
5069 ;;
5070 *)
5071 cat >> $cwrappersource <<EOF
5072 execv("$SHELL",newargz);
5073 EOF
5074 ;;
5075 esac
5076
5077 cat >> $cwrappersource <<"EOF"
5078 return 127;
5079 }
5080
5081 void *
5082 xmalloc (size_t num)
5083 {
5084 void * p = (void *) malloc (num);
5085 if (!p)
5086 lt_fatal ("Memory exhausted");
5087
5088 return p;
5089 }
5090
5091 char *
5092 xstrdup (const char *string)
5093 {
5094 return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5095 ;
5096 }
5097
5098 const char *
5099 base_name (const char *name)
5100 {
5101 const char *base;
5102
5103 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5104 /* Skip over the disk name in MSDOS pathnames. */
5105 if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5106 name += 2;
5107 #endif
5108
5109 for (base = name; *name; name++)
5110 if (IS_DIR_SEPARATOR (*name))
5111 base = name + 1;
5112 return base;
5113 }
5114
5115 int
5116 check_executable(const char * path)
5117 {
5118 struct stat st;
5119
5120 DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5121 if ((!path) || (!*path))
5122 return 0;
5123
5124 if ((stat (path, &st) >= 0) &&
5125 (
5126 /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5127 #if defined (S_IXOTH)
5128 ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5129 #endif
5130 #if defined (S_IXGRP)
5131 ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5132 #endif
5133 ((st.st_mode & S_IXUSR) == S_IXUSR))
5134 )
5135 return 1;
5136 else
5137 return 0;
5138 }
5139
5140 /* Searches for the full path of the wrapper. Returns
5141 newly allocated full path name if found, NULL otherwise */
5142 char *
5143 find_executable (const char* wrapper)
5144 {
5145 int has_slash = 0;
5146 const char* p;
5147 const char* p_next;
5148 /* static buffer for getcwd */
5149 char tmp[LT_PATHMAX + 1];
5150 int tmp_len;
5151 char* concat_name;
5152
5153 DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5154
5155 if ((wrapper == NULL) || (*wrapper == '\0'))
5156 return NULL;
5157
5158 /* Absolute path? */
5159 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5160 if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5161 {
5162 concat_name = xstrdup (wrapper);
5163 if (check_executable(concat_name))
5164 return concat_name;
5165 XFREE(concat_name);
5166 }
5167 else
5168 {
5169 #endif
5170 if (IS_DIR_SEPARATOR (wrapper[0]))
5171 {
5172 concat_name = xstrdup (wrapper);
5173 if (check_executable(concat_name))
5174 return concat_name;
5175 XFREE(concat_name);
5176 }
5177 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5178 }
5179 #endif
5180
5181 for (p = wrapper; *p; p++)
5182 if (*p == '/')
5183 {
5184 has_slash = 1;
5185 break;
5186 }
5187 if (!has_slash)
5188 {
5189 /* no slashes; search PATH */
5190 const char* path = getenv ("PATH");
5191 if (path != NULL)
5192 {
5193 for (p = path; *p; p = p_next)
5194 {
5195 const char* q;
5196 size_t p_len;
5197 for (q = p; *q; q++)
5198 if (IS_PATH_SEPARATOR(*q))
5199 break;
5200 p_len = q - p;
5201 p_next = (*q == '\0' ? q : q + 1);
5202 if (p_len == 0)
5203 {
5204 /* empty path: current directory */
5205 if (getcwd (tmp, LT_PATHMAX) == NULL)
5206 lt_fatal ("getcwd failed");
5207 tmp_len = strlen(tmp);
5208 concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5209 memcpy (concat_name, tmp, tmp_len);
5210 concat_name[tmp_len] = '/';
5211 strcpy (concat_name + tmp_len + 1, wrapper);
5212 }
5213 else
5214 {
5215 concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5216 memcpy (concat_name, p, p_len);
5217 concat_name[p_len] = '/';
5218 strcpy (concat_name + p_len + 1, wrapper);
5219 }
5220 if (check_executable(concat_name))
5221 return concat_name;
5222 XFREE(concat_name);
5223 }
5224 }
5225 /* not found in PATH; assume curdir */
5226 }
5227 /* Relative path | not found in path: prepend cwd */
5228 if (getcwd (tmp, LT_PATHMAX) == NULL)
5229 lt_fatal ("getcwd failed");
5230 tmp_len = strlen(tmp);
5231 concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5232 memcpy (concat_name, tmp, tmp_len);
5233 concat_name[tmp_len] = '/';
5234 strcpy (concat_name + tmp_len + 1, wrapper);
5235
5236 if (check_executable(concat_name))
5237 return concat_name;
5238 XFREE(concat_name);
5239 return NULL;
5240 }
5241
5242 char *
5243 strendzap(char *str, const char *pat)
5244 {
5245 size_t len, patlen;
5246
5247 assert(str != NULL);
5248 assert(pat != NULL);
5249
5250 len = strlen(str);
5251 patlen = strlen(pat);
5252
5253 if (patlen <= len)
5254 {
5255 str += len - patlen;
5256 if (strcmp(str, pat) == 0)
5257 *str = '\0';
5258 }
5259 return str;
5260 }
5261
5262 static void
5263 lt_error_core (int exit_status, const char * mode,
5264 const char * message, va_list ap)
5265 {
5266 fprintf (stderr, "%s: %s: ", program_name, mode);
5267 vfprintf (stderr, message, ap);
5268 fprintf (stderr, ".\n");
5269
5270 if (exit_status >= 0)
5271 exit (exit_status);
5272 }
5273
5274 void
5275 lt_fatal (const char *message, ...)
5276 {
5277 va_list ap;
5278 va_start (ap, message);
5279 lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5280 va_end (ap);
5281 }
5282 EOF
5283 # we should really use a build-platform specific compiler
5284 # here, but OTOH, the wrappers (shell script and this C one)
5285 # are only useful if you want to execute the "real" binary.
5286 # Since the "real" binary is built for $host, then this
5287 # wrapper might as well be built for $host, too.
5288 $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5289 ;;
5290 esac
5291 $rm $output
5292 trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5293
5294 $echo > $output "\
5295 #! $SHELL
5296
5297 # $output - temporary wrapper script for $objdir/$outputname
5298 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5299 #
5300 # The $output program cannot be directly executed until all the libtool
5301 # libraries that it depends on are installed.
5302 #
5303 # This wrapper script should never be moved out of the build directory.
5304 # If it is, it will not operate correctly.
5305
5306 # Sed substitution that helps us do robust quoting. It backslashifies
5307 # metacharacters that are still active within double-quoted strings.
5308 Xsed='${SED} -e 1s/^X//'
5309 sed_quote_subst='$sed_quote_subst'
5310
5311 # The HP-UX ksh and POSIX shell print the target directory to stdout
5312 # if CDPATH is set.
5313 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5314
5315 relink_command=\"$relink_command\"
5316
5317 # This environment variable determines our operation mode.
5318 if test \"\$libtool_install_magic\" = \"$magic\"; then
5319 # install mode needs the following variable:
5320 notinst_deplibs='$notinst_deplibs'
5321 else
5322 # When we are sourced in execute mode, \$file and \$echo are already set.
5323 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5324 echo=\"$qecho\"
5325 file=\"\$0\"
5326 # Make sure echo works.
5327 if test \"X\$1\" = X--no-reexec; then
5328 # Discard the --no-reexec flag, and continue.
5329 shift
5330 elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5331 # Yippee, \$echo works!
5332 :
5333 else
5334 # Restart under the correct shell, and then maybe \$echo will work.
5335 exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5336 fi
5337 fi\
5338 "
5339 $echo >> $output "\
5340
5341 # Find the directory that this script lives in.
5342 thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5343 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5344
5345 # Follow symbolic links until we get to the real thisdir.
5346 file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5347 while test -n \"\$file\"; do
5348 destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5349
5350 # If there was a directory component, then change thisdir.
5351 if test \"x\$destdir\" != \"x\$file\"; then
5352 case \"\$destdir\" in
5353 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5354 *) thisdir=\"\$thisdir/\$destdir\" ;;
5355 esac
5356 fi
5357
5358 file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5359 file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5360 done
5361
5362 # Try to get the absolute directory name.
5363 absdir=\`cd \"\$thisdir\" && pwd\`
5364 test -n \"\$absdir\" && thisdir=\"\$absdir\"
5365 "
5366
5367 if test "$fast_install" = yes; then
5368 $echo >> $output "\
5369 program=lt-'$outputname'$exeext
5370 progdir=\"\$thisdir/$objdir\"
5371
5372 if test ! -f \"\$progdir/\$program\" || \\
5373 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5374 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5375
5376 file=\"\$\$-\$program\"
5377
5378 if test ! -d \"\$progdir\"; then
5379 $mkdir \"\$progdir\"
5380 else
5381 $rm \"\$progdir/\$file\"
5382 fi"
5383
5384 $echo >> $output "\
5385
5386 # relink executable if necessary
5387 if test -n \"\$relink_command\"; then
5388 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5389 else
5390 $echo \"\$relink_command_output\" >&2
5391 $rm \"\$progdir/\$file\"
5392 exit $EXIT_FAILURE
5393 fi
5394 fi
5395
5396 $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5397 { $rm \"\$progdir/\$program\";
5398 $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5399 $rm \"\$progdir/\$file\"
5400 fi"
5401 else
5402 $echo >> $output "\
5403 program='$outputname'
5404 progdir=\"\$thisdir/$objdir\"
5405 "
5406 fi
5407
5408 $echo >> $output "\
5409
5410 if test -f \"\$progdir/\$program\"; then"
5411
5412 # Export our shlibpath_var if we have one.
5413 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5414 $echo >> $output "\
5415 # Add our own library path to $shlibpath_var
5416 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5417
5418 # Some systems cannot cope with colon-terminated $shlibpath_var
5419 # The second colon is a workaround for a bug in BeOS R4 sed
5420 $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5421
5422 export $shlibpath_var
5423 "
5424 fi
5425
5426 # fixup the dll searchpath if we need to.
5427 if test -n "$dllsearchpath"; then
5428 $echo >> $output "\
5429 # Add the dll search path components to the executable PATH
5430 PATH=$dllsearchpath:\$PATH
5431 "
5432 fi
5433
5434 $echo >> $output "\
5435 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5436 # Run the actual program with our arguments.
5437
5438 # Make sure env LD_LIBRARY_PATH does not mess us up
5439 if test -n \"\${LD_LIBRARY_PATH+set}\"; then
5440 export LD_LIBRARY_PATH=\$progdir:\$LD_LIBRARY_PATH
5441 fi
5442 "
5443 case $host in
5444 # Backslashes separate directories on plain windows
5445 *-*-mingw | *-*-os2*)
5446 $echo >> $output "\
5447 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5448 "
5449 ;;
5450
5451 *)
5452 $echo >> $output "\
5453 exec \"\$progdir/\$program\" \${1+\"\$@\"}
5454 "
5455 ;;
5456 esac
5457 $echo >> $output "\
5458 \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
5459 exit $EXIT_FAILURE
5460 fi
5461 else
5462 # The program doesn't exist.
5463 \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5464 \$echo \"This script is just a wrapper for \$program.\" 1>&2
5465 $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5466 exit $EXIT_FAILURE
5467 fi
5468 fi\
5469 "
5470 chmod +x $output
5471 fi
5472 exit $EXIT_SUCCESS
5473 ;;
5474 esac
5475
5476 # See if we need to build an old-fashioned archive.
5477 for oldlib in $oldlibs; do
5478
5479 if test "$build_libtool_libs" = convenience; then
5480 oldobjs="$libobjs_save"
5481 addlibs="$convenience"
5482 build_libtool_libs=no
5483 else
5484 if test "$build_libtool_libs" = module; then
5485 oldobjs="$libobjs_save"
5486 build_libtool_libs=no
5487 else
5488 oldobjs="$old_deplibs $non_pic_objects"
5489 fi
5490 addlibs="$old_convenience"
5491 fi
5492
5493 if test -n "$addlibs"; then
5494 gentop="$output_objdir/${outputname}x"
5495 generated="$generated $gentop"
5496
5497 func_extract_archives $gentop $addlibs
5498 oldobjs="$oldobjs $func_extract_archives_result"
5499 fi
5500
5501 # Do each command in the archive commands.
5502 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5503 cmds=$old_archive_from_new_cmds
5504 else
5505 # POSIX demands no paths to be encoded in archives. We have
5506 # to avoid creating archives with duplicate basenames if we
5507 # might have to extract them afterwards, e.g., when creating a
5508 # static archive out of a convenience library, or when linking
5509 # the entirety of a libtool archive into another (currently
5510 # not supported by libtool).
5511 if (for obj in $oldobjs
5512 do
5513 $echo "X$obj" | $Xsed -e 's%^.*/%%'
5514 done | sort | sort -uc >/dev/null 2>&1); then
5515 :
5516 else
5517 $echo "copying selected object files to avoid basename conflicts..."
5518
5519 if test -z "$gentop"; then
5520 gentop="$output_objdir/${outputname}x"
5521 generated="$generated $gentop"
5522
5523 $show "${rm}r $gentop"
5524 $run ${rm}r "$gentop"
5525 $show "$mkdir $gentop"
5526 $run $mkdir "$gentop"
5527 exit_status=$?
5528 if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5529 exit $exit_status
5530 fi
5531 fi
5532
5533 save_oldobjs=$oldobjs
5534 oldobjs=
5535 counter=1
5536 for obj in $save_oldobjs
5537 do
5538 objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
5539 case " $oldobjs " in
5540 " ") oldobjs=$obj ;;
5541 *[\ /]"$objbase "*)
5542 while :; do
5543 # Make sure we don't pick an alternate name that also
5544 # overlaps.
5545 newobj=lt$counter-$objbase
5546 counter=`expr $counter + 1`
5547 case " $oldobjs " in
5548 *[\ /]"$newobj "*) ;;
5549 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5550 esac
5551 done
5552 $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5553 $run ln "$obj" "$gentop/$newobj" ||
5554 $run cp "$obj" "$gentop/$newobj"
5555 oldobjs="$oldobjs $gentop/$newobj"
5556 ;;
5557 *) oldobjs="$oldobjs $obj" ;;
5558 esac
5559 done
5560 fi
5561
5562 eval cmds=\"$old_archive_cmds\"
5563
5564 if len=`expr "X$cmds" : ".*"` &&
5565 test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5566 cmds=$old_archive_cmds
5567 else
5568 # the command line is too long to link in one step, link in parts
5569 $echo "using piecewise archive linking..."
5570 save_RANLIB=$RANLIB
5571 RANLIB=:
5572 objlist=
5573 concat_cmds=
5574 save_oldobjs=$oldobjs
5575
5576 # Is there a better way of finding the last object in the list?
5577 for obj in $save_oldobjs
5578 do
5579 last_oldobj=$obj
5580 done
5581 for obj in $save_oldobjs
5582 do
5583 oldobjs="$objlist $obj"
5584 objlist="$objlist $obj"
5585 eval test_cmds=\"$old_archive_cmds\"
5586 if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5587 test "$len" -le "$max_cmd_len"; then
5588 :
5589 else
5590 # the above command should be used before it gets too long
5591 oldobjs=$objlist
5592 if test "$obj" = "$last_oldobj" ; then
5593 RANLIB=$save_RANLIB
5594 fi
5595 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5596 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5597 objlist=
5598 fi
5599 done
5600 RANLIB=$save_RANLIB
5601 oldobjs=$objlist
5602 if test "X$oldobjs" = "X" ; then
5603 eval cmds=\"\$concat_cmds\"
5604 else
5605 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5606 fi
5607 fi
5608 fi
5609 save_ifs="$IFS"; IFS='~'
5610 for cmd in $cmds; do
5611 eval cmd=\"$cmd\"
5612 IFS="$save_ifs"
5613 $show "$cmd"
5614 $run eval "$cmd" || exit $?
5615 done
5616 IFS="$save_ifs"
5617 done
5618
5619 if test -n "$generated"; then
5620 $show "${rm}r$generated"
5621 $run ${rm}r$generated
5622 fi
5623
5624 # Now create the libtool archive.
5625 case $output in
5626 *.la)
5627 old_library=
5628 test "$build_old_libs" = yes && old_library="$libname.$libext"
5629 $show "creating $output"
5630
5631 # Preserve any variables that may affect compiler behavior
5632 for var in $variables_saved_for_relink; do
5633 if eval test -z \"\${$var+set}\"; then
5634 relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5635 elif eval var_value=\$$var; test -z "$var_value"; then
5636 relink_command="$var=; export $var; $relink_command"
5637 else
5638 var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5639 relink_command="$var=\"$var_value\"; export $var; $relink_command"
5640 fi
5641 done
5642 # Quote the link command for shipping.
5643 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5644 relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5645 if test "$hardcode_automatic" = yes ; then
5646 relink_command=
5647 fi
5648
5649
5650 # Only create the output if not a dry run.
5651 if test -z "$run"; then
5652 for installed in no yes; do
5653 if test "$installed" = yes; then
5654 if test -z "$install_libdir"; then
5655 break
5656 fi
5657 output="$output_objdir/$outputname"i
5658 # Replace all uninstalled libtool libraries with the installed ones
5659 newdependency_libs=
5660 for deplib in $dependency_libs; do
5661 case $deplib in
5662 *.la)
5663 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5664 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5665 if test -z "$libdir"; then
5666 $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5667 exit $EXIT_FAILURE
5668 fi
5669 if test "X$EGREP" = X ; then
5670 EGREP=egrep
5671 fi
5672 # We do not want portage's install root ($D) present. Check only for
5673 # this if the .la is being installed.
5674 if test "$installed" = yes && test "$D"; then
5675 eval mynewdependency_lib=`echo "$libdir/$name" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
5676 else
5677 mynewdependency_lib="$libdir/$name"
5678 fi
5679 # Do not add duplicates
5680 if test "$mynewdependency_lib"; then
5681 my_little_ninja_foo_1=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
5682 if test -z "$my_little_ninja_foo_1"; then
5683 newdependency_libs="$newdependency_libs $mynewdependency_lib"
5684 fi
5685 fi
5686 ;;
5687 *)
5688 if test "$installed" = yes; then
5689 # Rather use S=WORKDIR if our version of portage supports it.
5690 # This is because some ebuild (gcc) do not use $S as buildroot.
5691 if test "$PWORKDIR"; then
5692 S="$PWORKDIR"
5693 fi
5694 # We do not want portage's build root ($S) present.
5695 my_little_ninja_foo_2=`echo $deplib |$EGREP -e "$S"`
5696 # We do not want portage's install root ($D) present.
5697 my_little_ninja_foo_3=`echo $deplib |$EGREP -e "$D"`
5698 if test -n "$my_little_ninja_foo_2" && test "$S"; then
5699 mynewdependency_lib=""
5700 elif test -n "$my_little_ninja_foo_3" && test "$D"; then
5701 eval mynewdependency_lib=`echo "$deplib" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
5702 else
5703 mynewdependency_lib="$deplib"
5704 fi
5705 else
5706 mynewdependency_lib="$deplib"
5707 fi
5708 # Do not add duplicates
5709 if test "$mynewdependency_lib"; then
5710 my_little_ninja_foo_4=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
5711 if test -z "$my_little_ninja_foo_4"; then
5712 newdependency_libs="$newdependency_libs $mynewdependency_lib"
5713 fi
5714 fi
5715 ;;
5716 esac
5717 done
5718 dependency_libs="$newdependency_libs"
5719 newdlfiles=
5720 for lib in $dlfiles; do
5721 name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5722 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5723 if test -z "$libdir"; then
5724 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5725 exit $EXIT_FAILURE
5726 fi
5727 newdlfiles="$newdlfiles $libdir/$name"
5728 done
5729 dlfiles="$newdlfiles"
5730 newdlprefiles=
5731 for lib in $dlprefiles; do
5732 name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5733 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5734 if test -z "$libdir"; then
5735 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5736 exit $EXIT_FAILURE
5737 fi
5738 newdlprefiles="$newdlprefiles $libdir/$name"
5739 done
5740 dlprefiles="$newdlprefiles"
5741 else
5742 newdlfiles=
5743 for lib in $dlfiles; do
5744 case $lib in
5745 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5746 *) abs=`pwd`"/$lib" ;;
5747 esac
5748 newdlfiles="$newdlfiles $abs"
5749 done
5750 dlfiles="$newdlfiles"
5751 newdlprefiles=
5752 for lib in $dlprefiles; do
5753 case $lib in
5754 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5755 *) abs=`pwd`"/$lib" ;;
5756 esac
5757 newdlprefiles="$newdlprefiles $abs"
5758 done
5759 dlprefiles="$newdlprefiles"
5760 fi
5761 $rm $output
5762 # place dlname in correct position for cygwin
5763 tdlname=$dlname
5764 case $host,$output,$installed,$module,$dlname in
5765 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5766 esac
5767 # Do not add duplicates
5768 if test "$installed" = yes && test "$D"; then
5769 install_libdir=`echo "$install_libdir" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
5770 fi
5771 $echo > $output "\
5772 # $outputname - a libtool library file
5773 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5774 #
5775 # Please DO NOT delete this file!
5776 # It is necessary for linking the library.
5777
5778 # The name that we can dlopen(3).
5779 dlname='$tdlname'
5780
5781 # Names of this library.
5782 library_names='$library_names'
5783
5784 # The name of the static archive.
5785 old_library='$old_library'
5786
5787 # Libraries that this one depends upon.
5788 dependency_libs='$dependency_libs'
5789
5790 # Version information for $libname.
5791 current=$current
5792 age=$age
5793 revision=$revision
5794
5795 # Is this an already installed library?
5796 installed=$installed
5797
5798 # Should we warn about portability when linking against -modules?
5799 shouldnotlink=$module
5800
5801 # Files to dlopen/dlpreopen
5802 dlopen='$dlfiles'
5803 dlpreopen='$dlprefiles'
5804
5805 # Directory that this library needs to be installed in:
5806 libdir='$install_libdir'"
5807 if test "$installed" = no && test "$need_relink" = yes; then
5808 $echo >> $output "\
5809 relink_command=\"$relink_command\""
5810 fi
5811 done
5812 fi
5813
5814 # Do a symbolic link so that the libtool archive can be found in
5815 # LD_LIBRARY_PATH before the program is installed.
5816 $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5817 $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5818 ;;
5819 esac
5820 exit $EXIT_SUCCESS
5821 ;;
5822
5823 # libtool install mode
5824 install)
5825 modename="$modename: install"
5826
5827 # There may be an optional sh(1) argument at the beginning of
5828 # install_prog (especially on Windows NT).
5829 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5830 # Allow the use of GNU shtool's install command.
5831 $echo "X$nonopt" | grep shtool > /dev/null; then
5832 # Aesthetically quote it.
5833 arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5834 case $arg in
5835 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5836 arg="\"$arg\""
5837 ;;
5838 esac
5839 install_prog="$arg "
5840 arg="$1"
5841 shift
5842 else
5843 install_prog=
5844 arg=$nonopt
5845 fi
5846
5847 # The real first argument should be the name of the installation program.
5848 # Aesthetically quote it.
5849 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5850 case $arg in
5851 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5852 arg="\"$arg\""
5853 ;;
5854 esac
5855 install_prog="$install_prog$arg"
5856
5857 # We need to accept at least all the BSD install flags.
5858 dest=
5859 files=
5860 opts=
5861 prev=
5862 install_type=
5863 isdir=no
5864 stripme=
5865 for arg
5866 do
5867 if test -n "$dest"; then
5868 files="$files $dest"
5869 dest=$arg
5870 continue
5871 fi
5872
5873 case $arg in
5874 -d) isdir=yes ;;
5875 -f)
5876 case " $install_prog " in
5877 *[\\\ /]cp\ *) ;;
5878 *) prev=$arg ;;
5879 esac
5880 ;;
5881 -g | -m | -o) prev=$arg ;;
5882 -s)
5883 stripme=" -s"
5884 continue
5885 ;;
5886 -*)
5887 ;;
5888 *)
5889 # If the previous option needed an argument, then skip it.
5890 if test -n "$prev"; then
5891 prev=
5892 else
5893 dest=$arg
5894 continue
5895 fi
5896 ;;
5897 esac
5898
5899 # Aesthetically quote the argument.
5900 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5901 case $arg in
5902 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5903 arg="\"$arg\""
5904 ;;
5905 esac
5906 install_prog="$install_prog $arg"
5907 done
5908
5909 if test -z "$install_prog"; then
5910 $echo "$modename: you must specify an install program" 1>&2
5911 $echo "$help" 1>&2
5912 exit $EXIT_FAILURE
5913 fi
5914
5915 if test -n "$prev"; then
5916 $echo "$modename: the \`$prev' option requires an argument" 1>&2
5917 $echo "$help" 1>&2
5918 exit $EXIT_FAILURE
5919 fi
5920
5921 if test -z "$files"; then
5922 if test -z "$dest"; then
5923 $echo "$modename: no file or destination specified" 1>&2
5924 else
5925 $echo "$modename: you must specify a destination" 1>&2
5926 fi
5927 $echo "$help" 1>&2
5928 exit $EXIT_FAILURE
5929 fi
5930
5931 # Strip any trailing slash from the destination.
5932 dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5933
5934 # Check to see that the destination is a directory.
5935 test -d "$dest" && isdir=yes
5936 if test "$isdir" = yes; then
5937 destdir="$dest"
5938 destname=
5939 else
5940 destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5941 test "X$destdir" = "X$dest" && destdir=.
5942 destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5943
5944 # Not a directory, so check to see that there is only one file specified.
5945 set dummy $files
5946 if test "$#" -gt 2; then
5947 $echo "$modename: \`$dest' is not a directory" 1>&2
5948 $echo "$help" 1>&2
5949 exit $EXIT_FAILURE
5950 fi
5951 fi
5952 case $destdir in
5953 [\\/]* | [A-Za-z]:[\\/]*) ;;
5954 *)
5955 for file in $files; do
5956 case $file in
5957 *.lo) ;;
5958 *)
5959 $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5960 $echo "$help" 1>&2
5961 exit $EXIT_FAILURE
5962 ;;
5963 esac
5964 done
5965 ;;
5966 esac
5967
5968 # This variable tells wrapper scripts just to set variables rather
5969 # than running their programs.
5970 libtool_install_magic="$magic"
5971
5972 staticlibs=
5973 future_libdirs=
5974 current_libdirs=
5975 for file in $files; do
5976
5977 # Do each installation.
5978 case $file in
5979 *.$libext)
5980 # Do the static libraries later.
5981 staticlibs="$staticlibs $file"
5982 ;;
5983
5984 *.la)
5985 # Check to see that this really is a libtool archive.
5986 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5987 else
5988 $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5989 $echo "$help" 1>&2
5990 exit $EXIT_FAILURE
5991 fi
5992
5993 library_names=
5994 old_library=
5995 relink_command=
5996 # If there is no directory component, then add one.
5997 case $file in
5998 */* | *\\*) . $file ;;
5999 *) . ./$file ;;
6000 esac
6001
6002 # Add the libdir to current_libdirs if it is the destination.
6003 if test "X$destdir" = "X$libdir"; then
6004 case "$current_libdirs " in
6005 *" $libdir "*) ;;
6006 *) current_libdirs="$current_libdirs $libdir" ;;
6007 esac
6008 else
6009 # Note the libdir as a future libdir.
6010 case "$future_libdirs " in
6011 *" $libdir "*) ;;
6012 *) future_libdirs="$future_libdirs $libdir" ;;
6013 esac
6014 fi
6015
6016 dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
6017 test "X$dir" = "X$file/" && dir=
6018 dir="$dir$objdir"
6019
6020 if test -n "$relink_command"; then
6021 # Determine the prefix the user has applied to our future dir.
6022 inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
6023
6024 # Don't allow the user to place us outside of our expected
6025 # location b/c this prevents finding dependent libraries that
6026 # are installed to the same prefix.
6027 # At present, this check doesn't affect windows .dll's that
6028 # are installed into $libdir/../bin (currently, that works fine)
6029 # but it's something to keep an eye on.
6030 if test "$inst_prefix_dir" = "$destdir"; then
6031 $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
6032 exit $EXIT_FAILURE
6033 fi
6034
6035 if test -n "$inst_prefix_dir"; then
6036 # Stick the inst_prefix_dir data into the link command.
6037 relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
6038 else
6039 relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
6040 fi
6041
6042 $echo "$modename: warning: relinking \`$file'" 1>&2
6043 $show "$relink_command"
6044 if $run eval "$relink_command"; then :
6045 else
6046 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6047 exit $EXIT_FAILURE
6048 fi
6049 fi
6050
6051 # See the names of the shared library.
6052 set dummy $library_names
6053 if test -n "$2"; then
6054 realname="$2"
6055 shift
6056 shift
6057
6058 srcname="$realname"
6059 test -n "$relink_command" && srcname="$realname"T
6060
6061 # Install the shared library and build the symlinks.
6062 $show "$install_prog $dir/$srcname $destdir/$realname"
6063 $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
6064 if test -n "$stripme" && test -n "$striplib"; then
6065 $show "$striplib $destdir/$realname"
6066 $run eval "$striplib $destdir/$realname" || exit $?
6067 fi
6068
6069 if test "$#" -gt 0; then
6070 # Delete the old symlinks, and create new ones.
6071 # Try `ln -sf' first, because the `ln' binary might depend on
6072 # the symlink we replace! Solaris /bin/ln does not understand -f,
6073 # so we also need to try rm && ln -s.
6074 for linkname
6075 do
6076 if test "$linkname" != "$realname"; then
6077 $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6078 $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6079 fi
6080 done
6081 fi
6082
6083 # Do each command in the postinstall commands.
6084 lib="$destdir/$realname"
6085 cmds=$postinstall_cmds
6086 save_ifs="$IFS"; IFS='~'
6087 for cmd in $cmds; do
6088 IFS="$save_ifs"
6089 eval cmd=\"$cmd\"
6090 $show "$cmd"
6091 $run eval "$cmd" || {
6092 lt_exit=$?
6093
6094 # Restore the uninstalled library and exit
6095 if test "$mode" = relink; then
6096 $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
6097 fi
6098
6099 exit $lt_exit
6100 }
6101 done
6102 IFS="$save_ifs"
6103 fi
6104
6105 # Install the pseudo-library for information purposes.
6106 name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6107 instname="$dir/$name"i
6108 $show "$install_prog $instname $destdir/$name"
6109 $run eval "$install_prog $instname $destdir/$name" || exit $?
6110
6111 # Maybe install the static library, too.
6112 test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6113 ;;
6114
6115 *.lo)
6116 # Install (i.e. copy) a libtool object.
6117
6118 # Figure out destination file name, if it wasn't already specified.
6119 if test -n "$destname"; then
6120 destfile="$destdir/$destname"
6121 else
6122 destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6123 destfile="$destdir/$destfile"
6124 fi
6125
6126 # Deduce the name of the destination old-style object file.
6127 case $destfile in
6128 *.lo)
6129 staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6130 ;;
6131 *.$objext)
6132 staticdest="$destfile"
6133 destfile=
6134 ;;
6135 *)
6136 $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6137 $echo "$help" 1>&2
6138 exit $EXIT_FAILURE
6139 ;;
6140 esac
6141
6142 # Install the libtool object if requested.
6143 if test -n "$destfile"; then
6144 $show "$install_prog $file $destfile"
6145 $run eval "$install_prog $file $destfile" || exit $?
6146 fi
6147
6148 # Install the old object if enabled.
6149 if test "$build_old_libs" = yes; then
6150 # Deduce the name of the old-style object file.
6151 staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6152
6153 $show "$install_prog $staticobj $staticdest"
6154 $run eval "$install_prog \$staticobj \$staticdest" || exit $?
6155 fi
6156 exit $EXIT_SUCCESS
6157 ;;
6158
6159 *)
6160 # Figure out destination file name, if it wasn't already specified.
6161 if test -n "$destname"; then
6162 destfile="$destdir/$destname"
6163 else
6164 destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6165 destfile="$destdir/$destfile"
6166 fi
6167
6168 # If the file is missing, and there is a .exe on the end, strip it
6169 # because it is most likely a libtool script we actually want to
6170 # install
6171 stripped_ext=""
6172 case $file in
6173 *.exe)
6174 if test ! -f "$file"; then
6175 file=`$echo $file|${SED} 's,.exe$,,'`
6176 stripped_ext=".exe"
6177 fi
6178 ;;
6179 esac
6180
6181 # Do a test to see if this is really a libtool program.
6182 case $host in
6183 *cygwin*|*mingw*)
6184 wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6185 ;;
6186 *)
6187 wrapper=$file
6188 ;;
6189 esac
6190 if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6191 notinst_deplibs=
6192 relink_command=
6193
6194 # Note that it is not necessary on cygwin/mingw to append a dot to
6195 # foo even if both foo and FILE.exe exist: automatic-append-.exe
6196 # behavior happens only for exec(3), not for open(2)! Also, sourcing
6197 # `FILE.' does not work on cygwin managed mounts.
6198 #
6199 # If there is no directory component, then add one.
6200 case $wrapper in
6201 */* | *\\*) . ${wrapper} ;;
6202 *) . ./${wrapper} ;;
6203 esac
6204
6205 # Check the variables that should have been set.
6206 if test -z "$notinst_deplibs"; then
6207 $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6208 exit $EXIT_FAILURE
6209 fi
6210
6211 finalize=yes
6212 for lib in $notinst_deplibs; do
6213 # Check to see that each library is installed.
6214 libdir=
6215 if test -f "$lib"; then
6216 # If there is no directory component, then add one.
6217 case $lib in
6218 */* | *\\*) . $lib ;;
6219 *) . ./$lib ;;
6220 esac
6221 fi
6222 libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6223 if test -n "$libdir" && test ! -f "$libfile"; then
6224 $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6225 finalize=no
6226 fi
6227 done
6228
6229 relink_command=
6230 # Note that it is not necessary on cygwin/mingw to append a dot to
6231 # foo even if both foo and FILE.exe exist: automatic-append-.exe
6232 # behavior happens only for exec(3), not for open(2)! Also, sourcing
6233 # `FILE.' does not work on cygwin managed mounts.
6234 #
6235 # If there is no directory component, then add one.
6236 case $wrapper in
6237 */* | *\\*) . ${wrapper} ;;
6238 *) . ./${wrapper} ;;
6239 esac
6240
6241 outputname=
6242 if test "$fast_install" = no && test -n "$relink_command"; then
6243 if test "$finalize" = yes && test -z "$run"; then
6244 tmpdir=`func_mktempdir`
6245 file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6246 outputname="$tmpdir/$file"
6247 # Replace the output file specification.
6248 relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
6249
6250 $show "$relink_command"
6251 if $run eval "$relink_command"; then :
6252 else
6253 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6254 ${rm}r "$tmpdir"
6255 continue
6256 fi
6257 file="$outputname"
6258 else
6259 $echo "$modename: warning: cannot relink \`$file'" 1>&2
6260 fi
6261 else
6262 # Install the binary that we compiled earlier.
6263 file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6264 fi
6265 fi
6266
6267 # remove .exe since cygwin /usr/bin/install will append another
6268 # one anyway
6269 case $install_prog,$host in
6270 */usr/bin/install*,*cygwin*)
6271 case $file:$destfile in
6272 *.exe:*.exe)
6273 # this is ok
6274 ;;
6275 *.exe:*)
6276 destfile=$destfile.exe
6277 ;;
6278 *:*.exe)
6279 destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6280 ;;
6281 esac
6282 ;;
6283 esac
6284 $show "$install_prog$stripme $file $destfile"
6285 $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6286 test -n "$outputname" && ${rm}r "$tmpdir"
6287 ;;
6288 esac
6289 done
6290
6291 for file in $staticlibs; do
6292 name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6293
6294 # Set up the ranlib parameters.
6295 oldlib="$destdir/$name"
6296
6297 $show "$install_prog $file $oldlib"
6298 $run eval "$install_prog \$file \$oldlib" || exit $?
6299
6300 if test -n "$stripme" && test -n "$old_striplib"; then
6301 $show "$old_striplib $oldlib"
6302 $run eval "$old_striplib $oldlib" || exit $?
6303 fi
6304
6305 # Do each command in the postinstall commands.
6306 cmds=$old_postinstall_cmds
6307 save_ifs="$IFS"; IFS='~'
6308 for cmd in $cmds; do
6309 IFS="$save_ifs"
6310 eval cmd=\"$cmd\"
6311 $show "$cmd"
6312 $run eval "$cmd" || exit $?
6313 done
6314 IFS="$save_ifs"
6315 done
6316
6317 if test -n "$future_libdirs"; then
6318 $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6319 fi
6320
6321 if test -n "$current_libdirs"; then
6322 # Maybe just do a dry run.
6323 test -n "$run" && current_libdirs=" -n$current_libdirs"
6324 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6325 else
6326 exit $EXIT_SUCCESS
6327 fi
6328 ;;
6329
6330 # libtool finish mode
6331 finish)
6332 modename="$modename: finish"
6333 libdirs="$nonopt"
6334 admincmds=
6335
6336 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6337 for dir
6338 do
6339 libdirs="$libdirs $dir"
6340 done
6341
6342 for libdir in $libdirs; do
6343 if test -n "$finish_cmds"; then
6344 # Do each command in the finish commands.
6345 cmds=$finish_cmds
6346 save_ifs="$IFS"; IFS='~'
6347 for cmd in $cmds; do
6348 IFS="$save_ifs"
6349 eval cmd=\"$cmd\"
6350 $show "$cmd"
6351 $run eval "$cmd" || admincmds="$admincmds
6352 $cmd"
6353 done
6354 IFS="$save_ifs"
6355 fi
6356 if test -n "$finish_eval"; then
6357 # Do the single finish_eval.
6358 eval cmds=\"$finish_eval\"
6359 $run eval "$cmds" || admincmds="$admincmds
6360 $cmds"
6361 fi
6362 done
6363 fi
6364
6365 # Exit here if they wanted silent mode.
6366 test "$show" = : && exit $EXIT_SUCCESS
6367
6368 $echo "X----------------------------------------------------------------------" | $Xsed
6369 $echo "Libraries have been installed in:"
6370 for libdir in $libdirs; do
6371 $echo " $libdir"
6372 done
6373 $echo
6374 $echo "If you ever happen to want to link against installed libraries"
6375 $echo "in a given directory, LIBDIR, you must either use libtool, and"
6376 $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6377 $echo "flag during linking and do at least one of the following:"
6378 if test -n "$shlibpath_var"; then
6379 $echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
6380 $echo " during execution"
6381 fi
6382 if test -n "$runpath_var"; then
6383 $echo " - add LIBDIR to the \`$runpath_var' environment variable"
6384 $echo " during linking"
6385 fi
6386 if test -n "$hardcode_libdir_flag_spec"; then
6387 libdir=LIBDIR
6388 eval flag=\"$hardcode_libdir_flag_spec\"
6389
6390 $echo " - use the \`$flag' linker flag"
6391 fi
6392 if test -n "$admincmds"; then
6393 $echo " - have your system administrator run these commands:$admincmds"
6394 fi
6395 if test -f /etc/ld.so.conf; then
6396 $echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6397 fi
6398 $echo
6399 $echo "See any operating system documentation about shared libraries for"
6400 $echo "more information, such as the ld(1) and ld.so(8) manual pages."
6401 $echo "X----------------------------------------------------------------------" | $Xsed
6402 exit $EXIT_SUCCESS
6403 ;;
6404
6405 # libtool execute mode
6406 execute)
6407 modename="$modename: execute"
6408
6409 # The first argument is the command name.
6410 cmd="$nonopt"
6411 if test -z "$cmd"; then
6412 $echo "$modename: you must specify a COMMAND" 1>&2
6413 $echo "$help"
6414 exit $EXIT_FAILURE
6415 fi
6416
6417 # Handle -dlopen flags immediately.
6418 for file in $execute_dlfiles; do
6419 if test ! -f "$file"; then
6420 $echo "$modename: \`$file' is not a file" 1>&2
6421 $echo "$help" 1>&2
6422 exit $EXIT_FAILURE
6423 fi
6424
6425 dir=
6426 case $file in
6427 *.la)
6428 # Check to see that this really is a libtool archive.
6429 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6430 else
6431 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6432 $echo "$help" 1>&2
6433 exit $EXIT_FAILURE
6434 fi
6435
6436 # Read the libtool library.
6437 dlname=
6438 library_names=
6439
6440 # If there is no directory component, then add one.
6441 case $file in
6442 */* | *\\*) . $file ;;
6443 *) . ./$file ;;
6444 esac
6445
6446 # Skip this library if it cannot be dlopened.
6447 if test -z "$dlname"; then
6448 # Warn if it was a shared library.
6449 test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6450 continue
6451 fi
6452
6453 dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6454