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