comparison ltmain.sh @ 1:45c8592d5d13

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