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

Contents of /code/trunk/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log

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