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