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