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

Contents of /code/trunk/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log


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