Author: Gianluca Guida <glguida@tlbflush.org>
Date: Sun Feb 26 22:22:35 UTC 2017
Parent: 294bc789a5d4019cf0a37fbcafdd4dc1433413ce
Log message:
Add util m4 require_liblac and fixes.
- require_liblac.m4 can be used by external projects to check
the presence of lac in the system through autotools.
- Add missing M4 script needed by aclocal.
- Add missing libtool script
1: diff --git a/Makefile.in b/Makefile.in
2: index cc1b059..e241962 100644
3: --- a/Makefile.in
4: +++ b/Makefile.in
5: @@ -94,7 +94,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
6: $(top_srcdir)/m4/libsigsegv.m4 $(top_srcdir)/m4/libtool.m4 \
7: $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
8: $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
9: - $(top_srcdir)/m4/readline.m4 $(top_srcdir)/configure.ac
10: + $(top_srcdir)/m4/readline.m4 $(top_srcdir)/m4/std-gnu11.m4 \
11: + $(top_srcdir)/configure.ac
12: am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
13: $(ACLOCAL_M4)
14: DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
15: @@ -163,9 +164,8 @@ CTAGS = ctags
16: CSCOPE = cscope
17: DIST_SUBDIRS = $(SUBDIRS)
18: am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in AUTHORS \
19: - COPYING ChangeLog INSTALL NEWS README TODO compile \
20: - config.guess config.rpath config.sub install-sh ltmain.sh \
21: - missing ylwrap
22: + COPYING ChangeLog INSTALL NEWS README TODO config.guess \
23: + config.rpath config.sub install-sh ltmain.sh missing ylwrap
24: DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
25: distdir = $(PACKAGE)-$(VERSION)
26: top_distdir = $(distdir)
27: diff --git a/aclocal.m4 b/aclocal.m4
28: index e70ea93..d8c5be4 100644
29: --- a/aclocal.m4
30: +++ b/aclocal.m4
31: @@ -1306,70 +1306,6 @@ AC_DEFUN([_AM_SET_OPTIONS],
32: AC_DEFUN([_AM_IF_OPTION],
33: [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
34:
35: -# Copyright (C) 1999-2014 Free Software Foundation, Inc.
36: -#
37: -# This file is free software; the Free Software Foundation
38: -# gives unlimited permission to copy and/or distribute it,
39: -# with or without modifications, as long as this notice is preserved.
40: -
41: -# _AM_PROG_CC_C_O
42: -# ---------------
43: -# Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC
44: -# to automatically call this.
45: -AC_DEFUN([_AM_PROG_CC_C_O],
46: -[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
47: -AC_REQUIRE_AUX_FILE([compile])dnl
48: -AC_LANG_PUSH([C])dnl
49: -AC_CACHE_CHECK(
50: - [whether $CC understands -c and -o together],
51: - [am_cv_prog_cc_c_o],
52: - [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
53: - # Make sure it works both with $CC and with simple cc.
54: - # Following AC_PROG_CC_C_O, we do the test twice because some
55: - # compilers refuse to overwrite an existing .o file with -o,
56: - # though they will create one.
57: - am_cv_prog_cc_c_o=yes
58: - for am_i in 1 2; do
59: - if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
60: - && test -f conftest2.$ac_objext; then
61: - : OK
62: - else
63: - am_cv_prog_cc_c_o=no
64: - break
65: - fi
66: - done
67: - rm -f core conftest*
68: - unset am_i])
69: -if test "$am_cv_prog_cc_c_o" != yes; then
70: - # Losing compiler, so override with the script.
71: - # FIXME: It is wrong to rewrite CC.
72: - # But if we don't then we get into trouble of one sort or another.
73: - # A longer-term fix would be to have automake use am__CC in this case,
74: - # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
75: - CC="$am_aux_dir/compile $CC"
76: -fi
77: -AC_LANG_POP([C])])
78: -
79: -# For backward compatibility.
80: -AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
81: -
82: -# Copyright (C) 2001-2014 Free Software Foundation, Inc.
83: -#
84: -# This file is free software; the Free Software Foundation
85: -# gives unlimited permission to copy and/or distribute it,
86: -# with or without modifications, as long as this notice is preserved.
87: -
88: -# AM_RUN_LOG(COMMAND)
89: -# -------------------
90: -# Run COMMAND, save the exit status in ac_status, and log it.
91: -# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
92: -AC_DEFUN([AM_RUN_LOG],
93: -[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
94: - ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
95: - ac_status=$?
96: - echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
97: - (exit $ac_status); }])
98: -
99: # Check to make sure that the build environment is sane. -*- Autoconf -*-
100:
101: # Copyright (C) 1996-2014 Free Software Foundation, Inc.
102: @@ -1701,3 +1637,4 @@ m4_include([m4/ltsugar.m4])
103: m4_include([m4/ltversion.m4])
104: m4_include([m4/lt~obsolete.m4])
105: m4_include([m4/readline.m4])
106: +m4_include([m4/std-gnu11.m4])
107: diff --git a/compile b/compile
108: deleted file mode 100755
109: index a85b723..0000000
110: --- a/compile
111: +++ /dev/null
112: @@ -1,347 +0,0 @@
113: -#! /bin/sh
114: -# Wrapper for compilers which do not understand '-c -o'.
115: -
116: -scriptversion=2012-10-14.11; # UTC
117: -
118: -# Copyright (C) 1999-2014 Free Software Foundation, Inc.
119: -# Written by Tom Tromey <tromey@cygnus.com>.
120: -#
121: -# This program is free software; you can redistribute it and/or modify
122: -# it under the terms of the GNU General Public License as published by
123: -# the Free Software Foundation; either version 2, or (at your option)
124: -# any later version.
125: -#
126: -# This program is distributed in the hope that it will be useful,
127: -# but WITHOUT ANY WARRANTY; without even the implied warranty of
128: -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
129: -# GNU General Public License for more details.
130: -#
131: -# You should have received a copy of the GNU General Public License
132: -# along with this program. If not, see <http://www.gnu.org/licenses/>.
133: -
134: -# As a special exception to the GNU General Public License, if you
135: -# distribute this file as part of a program that contains a
136: -# configuration script generated by Autoconf, you may include it under
137: -# the same distribution terms that you use for the rest of that program.
138: -
139: -# This file is maintained in Automake, please report
140: -# bugs to <bug-automake@gnu.org> or send patches to
141: -# <automake-patches@gnu.org>.
142: -
143: -nl='
144: -'
145: -
146: -# We need space, tab and new line, in precisely that order. Quoting is
147: -# there to prevent tools from complaining about whitespace usage.
148: -IFS=" "" $nl"
149: -
150: -file_conv=
151: -
152: -# func_file_conv build_file lazy
153: -# Convert a $build file to $host form and store it in $file
154: -# Currently only supports Windows hosts. If the determined conversion
155: -# type is listed in (the comma separated) LAZY, no conversion will
156: -# take place.
157: -func_file_conv ()
158: -{
159: - file=$1
160: - case $file in
161: - / | /[!/]*) # absolute file, and not a UNC file
162: - if test -z "$file_conv"; then
163: - # lazily determine how to convert abs files
164: - case `uname -s` in
165: - MINGW*)
166: - file_conv=mingw
167: - ;;
168: - CYGWIN*)
169: - file_conv=cygwin
170: - ;;
171: - *)
172: - file_conv=wine
173: - ;;
174: - esac
175: - fi
176: - case $file_conv/,$2, in
177: - *,$file_conv,*)
178: - ;;
179: - mingw/*)
180: - file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
181: - ;;
182: - cygwin/*)
183: - file=`cygpath -m "$file" || echo "$file"`
184: - ;;
185: - wine/*)
186: - file=`winepath -w "$file" || echo "$file"`
187: - ;;
188: - esac
189: - ;;
190: - esac
191: -}
192: -
193: -# func_cl_dashL linkdir
194: -# Make cl look for libraries in LINKDIR
195: -func_cl_dashL ()
196: -{
197: - func_file_conv "$1"
198: - if test -z "$lib_path"; then
199: - lib_path=$file
200: - else
201: - lib_path="$lib_path;$file"
202: - fi
203: - linker_opts="$linker_opts -LIBPATH:$file"
204: -}
205: -
206: -# func_cl_dashl library
207: -# Do a library search-path lookup for cl
208: -func_cl_dashl ()
209: -{
210: - lib=$1
211: - found=no
212: - save_IFS=$IFS
213: - IFS=';'
214: - for dir in $lib_path $LIB
215: - do
216: - IFS=$save_IFS
217: - if $shared && test -f "$dir/$lib.dll.lib"; then
218: - found=yes
219: - lib=$dir/$lib.dll.lib
220: - break
221: - fi
222: - if test -f "$dir/$lib.lib"; then
223: - found=yes
224: - lib=$dir/$lib.lib
225: - break
226: - fi
227: - if test -f "$dir/lib$lib.a"; then
228: - found=yes
229: - lib=$dir/lib$lib.a
230: - break
231: - fi
232: - done
233: - IFS=$save_IFS
234: -
235: - if test "$found" != yes; then
236: - lib=$lib.lib
237: - fi
238: -}
239: -
240: -# func_cl_wrapper cl arg...
241: -# Adjust compile command to suit cl
242: -func_cl_wrapper ()
243: -{
244: - # Assume a capable shell
245: - lib_path=
246: - shared=:
247: - linker_opts=
248: - for arg
249: - do
250: - if test -n "$eat"; then
251: - eat=
252: - else
253: - case $1 in
254: - -o)
255: - # configure might choose to run compile as 'compile cc -o foo foo.c'.
256: - eat=1
257: - case $2 in
258: - *.o | *.[oO][bB][jJ])
259: - func_file_conv "$2"
260: - set x "$@" -Fo"$file"
261: - shift
262: - ;;
263: - *)
264: - func_file_conv "$2"
265: - set x "$@" -Fe"$file"
266: - shift
267: - ;;
268: - esac
269: - ;;
270: - -I)
271: - eat=1
272: - func_file_conv "$2" mingw
273: - set x "$@" -I"$file"
274: - shift
275: - ;;
276: - -I*)
277: - func_file_conv "${1#-I}" mingw
278: - set x "$@" -I"$file"
279: - shift
280: - ;;
281: - -l)
282: - eat=1
283: - func_cl_dashl "$2"
284: - set x "$@" "$lib"
285: - shift
286: - ;;
287: - -l*)
288: - func_cl_dashl "${1#-l}"
289: - set x "$@" "$lib"
290: - shift
291: - ;;
292: - -L)
293: - eat=1
294: - func_cl_dashL "$2"
295: - ;;
296: - -L*)
297: - func_cl_dashL "${1#-L}"
298: - ;;
299: - -static)
300: - shared=false
301: - ;;
302: - -Wl,*)
303: - arg=${1#-Wl,}
304: - save_ifs="$IFS"; IFS=','
305: - for flag in $arg; do
306: - IFS="$save_ifs"
307: - linker_opts="$linker_opts $flag"
308: - done
309: - IFS="$save_ifs"
310: - ;;
311: - -Xlinker)
312: - eat=1
313: - linker_opts="$linker_opts $2"
314: - ;;
315: - -*)
316: - set x "$@" "$1"
317: - shift
318: - ;;
319: - *.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
320: - func_file_conv "$1"
321: - set x "$@" -Tp"$file"
322: - shift
323: - ;;
324: - *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
325: - func_file_conv "$1" mingw
326: - set x "$@" "$file"
327: - shift
328: - ;;
329: - *)
330: - set x "$@" "$1"
331: - shift
332: - ;;
333: - esac
334: - fi
335: - shift
336: - done
337: - if test -n "$linker_opts"; then
338: - linker_opts="-link$linker_opts"
339: - fi
340: - exec "$@" $linker_opts
341: - exit 1
342: -}
343: -
344: -eat=
345: -
346: -case $1 in
347: - '')
348: - echo "$0: No command. Try '$0 --help' for more information." 1>&2
349: - exit 1;
350: - ;;
351: - -h | --h*)
352: - cat <<\EOF
353: -Usage: compile [--help] [--version] PROGRAM [ARGS]
354: -
355: -Wrapper for compilers which do not understand '-c -o'.
356: -Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
357: -arguments, and rename the output as expected.
358: -
359: -If you are trying to build a whole package this is not the
360: -right script to run: please start by reading the file 'INSTALL'.
361: -
362: -Report bugs to <bug-automake@gnu.org>.
363: -EOF
364: - exit $?
365: - ;;
366: - -v | --v*)
367: - echo "compile $scriptversion"
368: - exit $?
369: - ;;
370: - cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
371: - func_cl_wrapper "$@" # Doesn't return...
372: - ;;
373: -esac
374: -
375: -ofile=
376: -cfile=
377: -
378: -for arg
379: -do
380: - if test -n "$eat"; then
381: - eat=
382: - else
383: - case $1 in
384: - -o)
385: - # configure might choose to run compile as 'compile cc -o foo foo.c'.
386: - # So we strip '-o arg' only if arg is an object.
387: - eat=1
388: - case $2 in
389: - *.o | *.obj)
390: - ofile=$2
391: - ;;
392: - *)
393: - set x "$@" -o "$2"
394: - shift
395: - ;;
396: - esac
397: - ;;
398: - *.c)
399: - cfile=$1
400: - set x "$@" "$1"
401: - shift
402: - ;;
403: - *)
404: - set x "$@" "$1"
405: - shift
406: - ;;
407: - esac
408: - fi
409: - shift
410: -done
411: -
412: -if test -z "$ofile" || test -z "$cfile"; then
413: - # If no '-o' option was seen then we might have been invoked from a
414: - # pattern rule where we don't need one. That is ok -- this is a
415: - # normal compilation that the losing compiler can handle. If no
416: - # '.c' file was seen then we are probably linking. That is also
417: - # ok.
418: - exec "$@"
419: -fi
420: -
421: -# Name of file we expect compiler to create.
422: -cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
423: -
424: -# Create the lock directory.
425: -# Note: use '[/\\:.-]' here to ensure that we don't use the same name
426: -# that we are using for the .o file. Also, base the name on the expected
427: -# object file name, since that is what matters with a parallel build.
428: -lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
429: -while true; do
430: - if mkdir "$lockdir" >/dev/null 2>&1; then
431: - break
432: - fi
433: - sleep 1
434: -done
435: -# FIXME: race condition here if user kills between mkdir and trap.
436: -trap "rmdir '$lockdir'; exit 1" 1 2 15
437: -
438: -# Run the compile.
439: -"$@"
440: -ret=$?
441: -
442: -if test -f "$cofile"; then
443: - test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
444: -elif test -f "${cofile}bj"; then
445: - test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
446: -fi
447: -
448: -rmdir "$lockdir"
449: -exit $ret
450: -
451: -# Local Variables:
452: -# mode: shell-script
453: -# sh-indentation: 2
454: -# eval: (add-hook 'write-file-hooks 'time-stamp)
455: -# time-stamp-start: "scriptversion="
456: -# time-stamp-format: "%:y-%02m-%02d.%02H"
457: -# time-stamp-time-zone: "UTC"
458: -# time-stamp-end: "; # UTC"
459: -# End:
460: diff --git a/configure b/configure
461: index f16c84a..514000d 100755
462: --- a/configure
463: +++ b/configure
464: @@ -3221,6 +3221,100 @@ esac
465: fi
466:
467: fi
468: +if test -z "$CC"; then
469: + if test -n "$ac_tool_prefix"; then
470: + # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
471: +set dummy ${ac_tool_prefix}clang; ac_word=$2
472: +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
473: +$as_echo_n "checking for $ac_word... " >&6; }
474: +if ${ac_cv_prog_CC+:} false; then :
475: + $as_echo_n "(cached) " >&6
476: +else
477: + if test -n "$CC"; then
478: + ac_cv_prog_CC="$CC" # Let the user override the test.
479: +else
480: +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
481: +for as_dir in $PATH
482: +do
483: + IFS=$as_save_IFS
484: + test -z "$as_dir" && as_dir=.
485: + for ac_exec_ext in '' $ac_executable_extensions; do
486: + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
487: + ac_cv_prog_CC="${ac_tool_prefix}clang"
488: + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
489: + break 2
490: + fi
491: +done
492: + done
493: +IFS=$as_save_IFS
494: +
495: +fi
496: +fi
497: +CC=$ac_cv_prog_CC
498: +if test -n "$CC"; then
499: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
500: +$as_echo "$CC" >&6; }
501: +else
502: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
503: +$as_echo "no" >&6; }
504: +fi
505: +
506: +
507: +fi
508: +if test -z "$ac_cv_prog_CC"; then
509: + ac_ct_CC=$CC
510: + # Extract the first word of "clang", so it can be a program name with args.
511: +set dummy clang; ac_word=$2
512: +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
513: +$as_echo_n "checking for $ac_word... " >&6; }
514: +if ${ac_cv_prog_ac_ct_CC+:} false; then :
515: + $as_echo_n "(cached) " >&6
516: +else
517: + if test -n "$ac_ct_CC"; then
518: + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
519: +else
520: +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
521: +for as_dir in $PATH
522: +do
523: + IFS=$as_save_IFS
524: + test -z "$as_dir" && as_dir=.
525: + for ac_exec_ext in '' $ac_executable_extensions; do
526: + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
527: + ac_cv_prog_ac_ct_CC="clang"
528: + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
529: + break 2
530: + fi
531: +done
532: + done
533: +IFS=$as_save_IFS
534: +
535: +fi
536: +fi
537: +ac_ct_CC=$ac_cv_prog_ac_ct_CC
538: +if test -n "$ac_ct_CC"; then
539: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
540: +$as_echo "$ac_ct_CC" >&6; }
541: +else
542: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
543: +$as_echo "no" >&6; }
544: +fi
545: +
546: + if test "x$ac_ct_CC" = x; then
547: + CC=""
548: + else
549: + case $cross_compiling:$ac_tool_warned in
550: +yes:)
551: +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
552: +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
553: +ac_tool_warned=yes ;;
554: +esac
555: + CC=$ac_ct_CC
556: + fi
557: +else
558: + CC="$ac_cv_prog_CC"
559: +fi
560: +
561: +fi
562:
563:
564: test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
565: @@ -3232,7 +3326,7 @@ See \`config.log' for more details" "$LINENO" 5; }
566: $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
567: set X $ac_compile
568: ac_compiler=$2
569: -for ac_option in --version -v -V -qversion; do
570: +for ac_option in --version -v -V -qversion -version; do
571: { { ac_try="$ac_compiler $ac_option >&5"
572: case "(($ac_try" in
573: *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
574: @@ -3618,8 +3712,420 @@ else
575: CFLAGS=
576: fi
577: fi
578: -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
579: -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
580: +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
581: +$as_echo_n "checking for $CC option to enable C11 features... " >&6; }
582: +if ${ac_cv_prog_cc_c11+:} false; then :
583: + $as_echo_n "(cached) " >&6
584: +else
585: + ac_cv_prog_cc_c11=no
586: +ac_save_CC=$CC
587: +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
588: +/* end confdefs.h. */
589: +#include <stdarg.h>
590: +#include <stdbool.h>
591: +#include <stddef.h>
592: +#include <stdlib.h>
593: +#include <wchar.h>
594: +#include <stdio.h>
595: +
596: +// Check varargs macros. These examples are taken from C99 6.10.3.5.
597: +#define debug(...) fprintf (stderr, __VA_ARGS__)
598: +#define showlist(...) puts (#__VA_ARGS__)
599: +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
600: +static void
601: +test_varargs_macros (void)
602: +{
603: + int x = 1234;
604: + int y = 5678;
605: + debug ("Flag");
606: + debug ("X = %d\n", x);
607: + showlist (The first, second, and third items.);
608: + report (x>y, "x is %d but y is %d", x, y);
609: +}
610: +
611: +// Check long long types.
612: +#define BIG64 18446744073709551615ull
613: +#define BIG32 4294967295ul
614: +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
615: +#if !BIG_OK
616: + your preprocessor is broken;
617: +#endif
618: +#if BIG_OK
619: +#else
620: + your preprocessor is broken;
621: +#endif
622: +static long long int bignum = -9223372036854775807LL;
623: +static unsigned long long int ubignum = BIG64;
624: +
625: +struct incomplete_array
626: +{
627: + int datasize;
628: + double data[];
629: +};
630: +
631: +struct named_init {
632: + int number;
633: + const wchar_t *name;
634: + double average;
635: +};
636: +
637: +typedef const char *ccp;
638: +
639: +static inline int
640: +test_restrict (ccp restrict text)
641: +{
642: + // See if C++-style comments work.
643: + // Iterate through items via the restricted pointer.
644: + // Also check for declarations in for loops.
645: + for (unsigned int i = 0; *(text+i) != '\0'; ++i)
646: + continue;
647: + return 0;
648: +}
649: +
650: +// Check varargs and va_copy.
651: +static bool
652: +test_varargs (const char *format, ...)
653: +{
654: + va_list args;
655: + va_start (args, format);
656: + va_list args_copy;
657: + va_copy (args_copy, args);
658: +
659: + const char *str = "";
660: + int number = 0;
661: + float fnumber = 0;
662: +
663: + while (*format)
664: + {
665: + switch (*format++)
666: + {
667: + case 's': // string
668: + str = va_arg (args_copy, const char *);
669: + break;
670: + case 'd': // int
671: + number = va_arg (args_copy, int);
672: + break;
673: + case 'f': // float
674: + fnumber = va_arg (args_copy, double);
675: + break;
676: + default:
677: + break;
678: + }
679: + }
680: + va_end (args_copy);
681: + va_end (args);
682: +
683: + return *str && number && fnumber;
684: +}
685: +// Check _Alignas.
686: +char _Alignas (double) aligned_as_double;
687: +char _Alignas (0) no_special_alignment;
688: +extern char aligned_as_int;
689: +char _Alignas (0) _Alignas (int) aligned_as_int;
690: +
691: +// Check _Alignof.
692: +enum
693: +{
694: + int_alignment = _Alignof (int),
695: + int_array_alignment = _Alignof (int[100]),
696: + char_alignment = _Alignof (char)
697: +};
698: +_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
699: +
700: +// Check _Noreturn.
701: +int _Noreturn does_not_return (void) { for (;;) continue; }
702: +
703: +// Check _Static_assert.
704: +struct test_static_assert
705: +{
706: + int x;
707: + _Static_assert (sizeof (int) <= sizeof (long int),
708: + "_Static_assert does not work in struct");
709: + long int y;
710: +};
711: +
712: +// Check UTF-8 literals.
713: +#define u8 syntax error!
714: +char const utf8_literal[] = u8"happens to be ASCII" "another string";
715: +
716: +// Check duplicate typedefs.
717: +typedef long *long_ptr;
718: +typedef long int *long_ptr;
719: +typedef long_ptr long_ptr;
720: +
721: +// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
722: +struct anonymous
723: +{
724: + union {
725: + struct { int i; int j; };
726: + struct { int k; long int l; } w;
727: + };
728: + int m;
729: +} v1;
730: +
731: +int
732: +main ()
733: +{
734: +
735: + // Check bool.
736: + _Bool success = false;
737: +
738: + // Check restrict.
739: + if (test_restrict ("String literal") == 0)
740: + success = true;
741: + char *restrict newvar = "Another string";
742: +
743: + // Check varargs.
744: + success &= test_varargs ("s, d' f .", "string", 65, 34.234);
745: + test_varargs_macros ();
746: +
747: + // Check flexible array members.
748: + struct incomplete_array *ia =
749: + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
750: + ia->datasize = 10;
751: + for (int i = 0; i < ia->datasize; ++i)
752: + ia->data[i] = i * 1.234;
753: +
754: + // Check named initializers.
755: + struct named_init ni = {
756: + .number = 34,
757: + .name = L"Test wide string",
758: + .average = 543.34343,
759: + };
760: +
761: + ni.number = 58;
762: +
763: + int dynamic_array[ni.number];
764: + dynamic_array[ni.number - 1] = 543;
765: +
766: + // work around unused variable warnings
767: + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
768: + || dynamic_array[ni.number - 1] != 543);
769: +
770: + v1.i = 2;
771: + v1.w.k = 5;
772: + _Static_assert ((offsetof (struct anonymous, i)
773: + == offsetof (struct anonymous, w.k)),
774: + "Anonymous union alignment botch");
775: +
776: + ;
777: + return 0;
778: +}
779: +_ACEOF
780: +for ac_arg in '' -std=gnu11
781: +do
782: + CC="$ac_save_CC $ac_arg"
783: + if ac_fn_c_try_compile "$LINENO"; then :
784: + ac_cv_prog_cc_c11=$ac_arg
785: +fi
786: +rm -f core conftest.err conftest.$ac_objext
787: + test "x$ac_cv_prog_cc_c11" != "xno" && break
788: +done
789: +rm -f conftest.$ac_ext
790: +CC=$ac_save_CC
791: +
792: +fi
793: +# AC_CACHE_VAL
794: +ac_prog_cc_stdc_options=
795: +case "x$ac_cv_prog_cc_c11" in
796: + x)
797: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
798: +$as_echo "none needed" >&6; } ;;
799: + xno)
800: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
801: +$as_echo "unsupported" >&6; } ;;
802: + *)
803: + ac_prog_cc_stdc_options=" $ac_cv_prog_cc_c11"
804: + CC=$CC$ac_prog_cc_stdc_options
805: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
806: +$as_echo "$ac_cv_prog_cc_c11" >&6; } ;;
807: +esac
808: +if test "x$ac_cv_prog_cc_c11" != xno; then :
809: + ac_prog_cc_stdc=c11
810: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
811: +else
812: + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
813: +$as_echo_n "checking for $CC option to enable C99 features... " >&6; }
814: +if ${ac_cv_prog_cc_c99+:} false; then :
815: + $as_echo_n "(cached) " >&6
816: +else
817: + ac_cv_prog_cc_c99=no
818: +ac_save_CC=$CC
819: +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
820: +/* end confdefs.h. */
821: +#include <stdarg.h>
822: +#include <stdbool.h>
823: +#include <stddef.h>
824: +#include <stdlib.h>
825: +#include <wchar.h>
826: +#include <stdio.h>
827: +
828: +// Check varargs macros. These examples are taken from C99 6.10.3.5.
829: +#define debug(...) fprintf (stderr, __VA_ARGS__)
830: +#define showlist(...) puts (#__VA_ARGS__)
831: +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
832: +static void
833: +test_varargs_macros (void)
834: +{
835: + int x = 1234;
836: + int y = 5678;
837: + debug ("Flag");
838: + debug ("X = %d\n", x);
839: + showlist (The first, second, and third items.);
840: + report (x>y, "x is %d but y is %d", x, y);
841: +}
842: +
843: +// Check long long types.
844: +#define BIG64 18446744073709551615ull
845: +#define BIG32 4294967295ul
846: +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
847: +#if !BIG_OK
848: + your preprocessor is broken;
849: +#endif
850: +#if BIG_OK
851: +#else
852: + your preprocessor is broken;
853: +#endif
854: +static long long int bignum = -9223372036854775807LL;
855: +static unsigned long long int ubignum = BIG64;
856: +
857: +struct incomplete_array
858: +{
859: + int datasize;
860: + double data[];
861: +};
862: +
863: +struct named_init {
864: + int number;
865: + const wchar_t *name;
866: + double average;
867: +};
868: +
869: +typedef const char *ccp;
870: +
871: +static inline int
872: +test_restrict (ccp restrict text)
873: +{
874: + // See if C++-style comments work.
875: + // Iterate through items via the restricted pointer.
876: + // Also check for declarations in for loops.
877: + for (unsigned int i = 0; *(text+i) != '\0'; ++i)
878: + continue;
879: + return 0;
880: +}
881: +
882: +// Check varargs and va_copy.
883: +static bool
884: +test_varargs (const char *format, ...)
885: +{
886: + va_list args;
887: + va_start (args, format);
888: + va_list args_copy;
889: + va_copy (args_copy, args);
890: +
891: + const char *str = "";
892: + int number = 0;
893: + float fnumber = 0;
894: +
895: + while (*format)
896: + {
897: + switch (*format++)
898: + {
899: + case 's': // string
900: + str = va_arg (args_copy, const char *);
901: + break;
902: + case 'd': // int
903: + number = va_arg (args_copy, int);
904: + break;
905: + case 'f': // float
906: + fnumber = va_arg (args_copy, double);
907: + break;
908: + default:
909: + break;
910: + }
911: + }
912: + va_end (args_copy);
913: + va_end (args);
914: +
915: + return *str && number && fnumber;
916: +}
917: +int
918: +main ()
919: +{
920: +
921: + // Check bool.
922: + _Bool success = false;
923: +
924: + // Check restrict.
925: + if (test_restrict ("String literal") == 0)
926: + success = true;
927: + char *restrict newvar = "Another string";
928: +
929: + // Check varargs.
930: + success &= test_varargs ("s, d' f .", "string", 65, 34.234);
931: + test_varargs_macros ();
932: +
933: + // Check flexible array members.
934: + struct incomplete_array *ia =
935: + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
936: + ia->datasize = 10;
937: + for (int i = 0; i < ia->datasize; ++i)
938: + ia->data[i] = i * 1.234;
939: +
940: + // Check named initializers.
941: + struct named_init ni = {
942: + .number = 34,
943: + .name = L"Test wide string",
944: + .average = 543.34343,
945: + };
946: +
947: + ni.number = 58;
948: +
949: + int dynamic_array[ni.number];
950: + dynamic_array[ni.number - 1] = 543;
951: +
952: + // work around unused variable warnings
953: + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
954: + || dynamic_array[ni.number - 1] != 543);
955: +
956: + ;
957: + return 0;
958: +}
959: +_ACEOF
960: +for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99
961: +do
962: + CC="$ac_save_CC $ac_arg"
963: + if ac_fn_c_try_compile "$LINENO"; then :
964: + ac_cv_prog_cc_c99=$ac_arg
965: +fi
966: +rm -f core conftest.err conftest.$ac_objext
967: + test "x$ac_cv_prog_cc_c99" != "xno" && break
968: +done
969: +rm -f conftest.$ac_ext
970: +CC=$ac_save_CC
971: +
972: +fi
973: +# AC_CACHE_VAL
974: +ac_prog_cc_stdc_options=
975: +case "x$ac_cv_prog_cc_c99" in
976: + x)
977: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
978: +$as_echo "none needed" >&6; } ;;
979: + xno)
980: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
981: +$as_echo "unsupported" >&6; } ;;
982: + *)
983: + ac_prog_cc_stdc_options=" $ac_cv_prog_cc_c99"
984: + CC=$CC$ac_prog_cc_stdc_options
985: + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
986: +$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
987: +esac
988: +if test "x$ac_cv_prog_cc_c99" != xno; then :
989: + ac_prog_cc_stdc=c99
990: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
991: +else
992: + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
993: +$as_echo_n "checking for $CC option to enable C89 features... " >&6; }
994: if ${ac_cv_prog_cc_c89+:} false; then :
995: $as_echo_n "(cached) " >&6
996: else
997: @@ -3692,6 +4198,7 @@ CC=$ac_save_CC
998:
999: fi
1000: # AC_CACHE_VAL
1001: +ac_prog_cc_stdc_options=
1002: case "x$ac_cv_prog_cc_c89" in
1003: x)
1004: { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
1005: @@ -3700,78 +4207,28 @@ $as_echo "none needed" >&6; } ;;
1006: { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
1007: $as_echo "unsupported" >&6; } ;;
1008: *)
1009: - CC="$CC $ac_cv_prog_cc_c89"
1010: + ac_prog_cc_stdc_options=" $ac_cv_prog_cc_c89"
1011: + CC=$CC$ac_prog_cc_stdc_options
1012: { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
1013: $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
1014: esac
1015: if test "x$ac_cv_prog_cc_c89" != xno; then :
1016: -
1017: -fi
1018: -
1019: -ac_ext=c
1020: -ac_cpp='$CPP $CPPFLAGS'
1021: -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1022: -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1023: -ac_compiler_gnu=$ac_cv_c_compiler_gnu
1024: -
1025: -ac_ext=c
1026: -ac_cpp='$CPP $CPPFLAGS'
1027: -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1028: -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1029: -ac_compiler_gnu=$ac_cv_c_compiler_gnu
1030: -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
1031: -$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
1032: -if ${am_cv_prog_cc_c_o+:} false; then :
1033: - $as_echo_n "(cached) " >&6
1034: + ac_prog_cc_stdc=c89
1035: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
1036: else
1037: - cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1038: -/* end confdefs.h. */
1039: + ac_prog_cc_stdc=no
1040: + ac_cv_prog_cc_stdc=no
1041: +fi
1042:
1043: -int
1044: -main ()
1045: -{
1046: +fi
1047:
1048: - ;
1049: - return 0;
1050: -}
1051: -_ACEOF
1052: - # Make sure it works both with $CC and with simple cc.
1053: - # Following AC_PROG_CC_C_O, we do the test twice because some
1054: - # compilers refuse to overwrite an existing .o file with -o,
1055: - # though they will create one.
1056: - am_cv_prog_cc_c_o=yes
1057: - for am_i in 1 2; do
1058: - if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
1059: - ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
1060: - ac_status=$?
1061: - echo "$as_me:$LINENO: \$? = $ac_status" >&5
1062: - (exit $ac_status); } \
1063: - && test -f conftest2.$ac_objext; then
1064: - : OK
1065: - else
1066: - am_cv_prog_cc_c_o=no
1067: - break
1068: - fi
1069: - done
1070: - rm -f core conftest*
1071: - unset am_i
1072: -fi
1073: -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
1074: -$as_echo "$am_cv_prog_cc_c_o" >&6; }
1075: -if test "$am_cv_prog_cc_c_o" != yes; then
1076: - # Losing compiler, so override with the script.
1077: - # FIXME: It is wrong to rewrite CC.
1078: - # But if we don't then we get into trouble of one sort or another.
1079: - # A longer-term fix would be to have automake use am__CC in this case,
1080: - # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
1081: - CC="$am_aux_dir/compile $CC"
1082: fi
1083: +
1084: ac_ext=c
1085: ac_cpp='$CPP $CPPFLAGS'
1086: ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1087: ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1088: ac_compiler_gnu=$ac_cv_c_compiler_gnu
1089: -
1090: DEPDIR="${am__leading_dot}deps"
1091:
1092: ac_config_commands="$ac_config_commands depfiles"
1093: diff --git a/examples/Makefile.in b/examples/Makefile.in
1094: index ee959d3..4f76f1f 100644
1095: --- a/examples/Makefile.in
1096: +++ b/examples/Makefile.in
1097: @@ -95,7 +95,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
1098: $(top_srcdir)/m4/libsigsegv.m4 $(top_srcdir)/m4/libtool.m4 \
1099: $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
1100: $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
1101: - $(top_srcdir)/m4/readline.m4 $(top_srcdir)/configure.ac
1102: + $(top_srcdir)/m4/readline.m4 $(top_srcdir)/m4/std-gnu11.m4 \
1103: + $(top_srcdir)/configure.ac
1104: am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
1105: $(ACLOCAL_M4)
1106: DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
1107: diff --git a/libtool b/libtool
1108: new file mode 100755
1109: index 0000000..cf3cc51
1110: --- /dev/null
1111: +++ b/libtool
1112: @@ -0,0 +1,11645 @@
1113: +#! /bin/sh
1114: +# Generated automatically by config.status (lac) 0.1.0
1115: +# Libtool was configured on host work:
1116: +# NOTE: Changes made to this file will be lost: look at ltmain.sh.
1117: +
1118: +# Provide generalized library-building support services.
1119: +# Written by Gordon Matzigkeit, 1996
1120: +
1121: +# Copyright (C) 2014 Free Software Foundation, Inc.
1122: +# This is free software; see the source for copying conditions. There is NO
1123: +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
1124: +
1125: +# GNU Libtool is free software; you can redistribute it and/or modify
1126: +# it under the terms of the GNU General Public License as published by
1127: +# the Free Software Foundation; either version 2 of of the License, or
1128: +# (at your option) any later version.
1129: +#
1130: +# As a special exception to the GNU General Public License, if you
1131: +# distribute this file as part of a program or library that is built
1132: +# using GNU Libtool, you may include this file under the same
1133: +# distribution terms that you use for the rest of that program.
1134: +#
1135: +# GNU Libtool is distributed in the hope that it will be useful, but
1136: +# WITHOUT ANY WARRANTY; without even the implied warranty of
1137: +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1138: +# GNU General Public License for more details.
1139: +#
1140: +# You should have received a copy of the GNU General Public License
1141: +# along with this program. If not, see <http://www.gnu.org/licenses/>.
1142: +
1143: +
1144: +# The names of the tagged configurations supported by this script.
1145: +available_tags=''
1146: +
1147: +# Configured defaults for sys_lib_dlsearch_path munging.
1148: +: ${LT_SYS_LIBRARY_PATH=""}
1149: +
1150: +# ### BEGIN LIBTOOL CONFIG
1151: +
1152: +# Which release of libtool.m4 was used?
1153: +macro_version=2.4.6
1154: +macro_revision=2.4.6
1155: +
1156: +# Whether or not to build shared libraries.
1157: +build_libtool_libs=yes
1158: +
1159: +# Whether or not to build static libraries.
1160: +build_old_libs=yes
1161: +
1162: +# What type of objects to build.
1163: +pic_mode=default
1164: +
1165: +# Whether or not to optimize for fast installation.
1166: +fast_install=yes
1167: +
1168: +# Shared archive member basename,for filename based shared library versioning on AIX.
1169: +shared_archive_member_spec=
1170: +
1171: +# Shell to use when invoking shell scripts.
1172: +SHELL="/bin/sh"
1173: +
1174: +# An echo program that protects backslashes.
1175: +ECHO="printf %s\\n"
1176: +
1177: +# The PATH separator for the build system.
1178: +PATH_SEPARATOR=":"
1179: +
1180: +# The host system.
1181: +host_alias=
1182: +host=x86_64-unknown-linux-gnu
1183: +host_os=linux-gnu
1184: +
1185: +# The build system.
1186: +build_alias=
1187: +build=x86_64-unknown-linux-gnu
1188: +build_os=linux-gnu
1189: +
1190: +# A sed program that does not truncate output.
1191: +SED="/usr/bin/sed"
1192: +
1193: +# Sed that helps us avoid accidentally triggering echo(1) options like -n.
1194: +Xsed="$SED -e 1s/^X//"
1195: +
1196: +# A grep program that handles long lines.
1197: +GREP="/usr/bin/grep"
1198: +
1199: +# An ERE matcher.
1200: +EGREP="/usr/bin/grep -E"
1201: +
1202: +# A literal string matcher.
1203: +FGREP="/usr/bin/grep -F"
1204: +
1205: +# A BSD- or MS-compatible name lister.
1206: +NM="/usr/bin/nm -B"
1207: +
1208: +# Whether we need soft or hard links.
1209: +LN_S="ln -s"
1210: +
1211: +# What is the maximum length of a command?
1212: +max_cmd_len=1572864
1213: +
1214: +# Object file suffix (normally "o").
1215: +objext=o
1216: +
1217: +# Executable file suffix (normally "").
1218: +exeext=
1219: +
1220: +# whether the shell understands "unset".
1221: +lt_unset=unset
1222: +
1223: +# turn spaces into newlines.
1224: +SP2NL="tr \\040 \\012"
1225: +
1226: +# turn newlines into spaces.
1227: +NL2SP="tr \\015\\012 \\040\\040"
1228: +
1229: +# convert $build file names to $host format.
1230: +to_host_file_cmd=func_convert_file_noop
1231: +
1232: +# convert $build files to toolchain format.
1233: +to_tool_file_cmd=func_convert_file_noop
1234: +
1235: +# An object symbol dumper.
1236: +OBJDUMP="objdump"
1237: +
1238: +# Method to check whether dependent libraries are shared objects.
1239: +deplibs_check_method="pass_all"
1240: +
1241: +# Command to use when deplibs_check_method = "file_magic".
1242: +file_magic_cmd="\$MAGIC_CMD"
1243: +
1244: +# How to find potential files when deplibs_check_method = "file_magic".
1245: +file_magic_glob=""
1246: +
1247: +# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
1248: +want_nocaseglob="no"
1249: +
1250: +# DLL creation program.
1251: +DLLTOOL="false"
1252: +
1253: +# Command to associate shared and link libraries.
1254: +sharedlib_from_linklib_cmd="printf %s\\n"
1255: +
1256: +# The archiver.
1257: +AR="ar"
1258: +
1259: +# Flags to create an archive.
1260: +AR_FLAGS="cru"
1261: +
1262: +# How to feed a file listing to the archiver.
1263: +archiver_list_spec="@"
1264: +
1265: +# A symbol stripping program.
1266: +STRIP="strip"
1267: +
1268: +# Commands used to install an old-style archive.
1269: +RANLIB="ranlib"
1270: +old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$tool_oldlib"
1271: +old_postuninstall_cmds=""
1272: +
1273: +# Whether to use a lock for old archive extraction.
1274: +lock_old_archive_extraction=no
1275: +
1276: +# A C compiler.
1277: +LTCC="gcc"
1278: +
1279: +# LTCC compiler flags.
1280: +LTCFLAGS="-g -O2"
1281: +
1282: +# Take the output of nm and produce a listing of raw symbols and C names.
1283: +global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p' | sed '/ __gnu_lto/d'"
1284: +
1285: +# Transform the output of nm in a proper C declaration.
1286: +global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW][ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
1287: +
1288: +# Transform the output of nm into a list of symbols to manually relocate.
1289: +global_symbol_to_import=""
1290: +
1291: +# Transform the output of nm in a C name address pair.
1292: +global_symbol_to_c_name_address="sed -n -e 's/^: \\(.*\\) .*\$/ {\"\\1\", (void *) 0},/p' -e 's/^[ABCDGIRSTW][ABCDGIRSTW]* .* \\(.*\\)\$/ {\"\\1\", (void *) \\&\\1},/p'"
1293: +
1294: +# Transform the output of nm in a C name address pair when lib prefix is needed.
1295: +global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\(.*\\) .*\$/ {\"\\1\", (void *) 0},/p' -e 's/^[ABCDGIRSTW][ABCDGIRSTW]* .* \\(lib.*\\)\$/ {\"\\1\", (void *) \\&\\1},/p' -e 's/^[ABCDGIRSTW][ABCDGIRSTW]* .* \\(.*\\)\$/ {\"lib\\1\", (void *) \\&\\1},/p'"
1296: +
1297: +# The name lister interface.
1298: +nm_interface="BSD nm"
1299: +
1300: +# Specify filename containing input files for $NM.
1301: +nm_file_list_spec="@"
1302: +
1303: +# The root where to search for dependent libraries,and where our libraries should be installed.
1304: +lt_sysroot=
1305: +
1306: +# Command to truncate a binary pipe.
1307: +lt_truncate_bin="/usr/bin/dd bs=4096 count=1"
1308: +
1309: +# The name of the directory that contains temporary libtool files.
1310: +objdir=.libs
1311: +
1312: +# Used to examine libraries when file_magic_cmd begins with "file".
1313: +MAGIC_CMD=file
1314: +
1315: +# Must we lock files when doing compilation?
1316: +need_locks="no"
1317: +
1318: +# Manifest tool.
1319: +MANIFEST_TOOL=":"
1320: +
1321: +# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
1322: +DSYMUTIL=""
1323: +
1324: +# Tool to change global to local symbols on Mac OS X.
1325: +NMEDIT=""
1326: +
1327: +# Tool to manipulate fat objects and archives on Mac OS X.
1328: +LIPO=""
1329: +
1330: +# ldd/readelf like tool for Mach-O binaries on Mac OS X.
1331: +OTOOL=""
1332: +
1333: +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
1334: +OTOOL64=""
1335: +
1336: +# Old archive suffix (normally "a").
1337: +libext=a
1338: +
1339: +# Shared library suffix (normally ".so").
1340: +shrext_cmds=".so"
1341: +
1342: +# The commands to extract the exported symbol list from a shared archive.
1343: +extract_expsyms_cmds=""
1344: +
1345: +# Variables whose values should be saved in libtool wrapper scripts and
1346: +# restored at link time.
1347: +variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
1348: +
1349: +# Do we need the "lib" prefix for modules?
1350: +need_lib_prefix=no
1351: +
1352: +# Do we need a version for libraries?
1353: +need_version=no
1354: +
1355: +# Library versioning type.
1356: +version_type=linux
1357: +
1358: +# Shared library runtime path variable.
1359: +runpath_var=LD_RUN_PATH
1360: +
1361: +# Shared library path variable.
1362: +shlibpath_var=LD_LIBRARY_PATH
1363: +
1364: +# Is shlibpath searched before the hard-coded library search path?
1365: +shlibpath_overrides_runpath=no
1366: +
1367: +# Format of library name prefix.
1368: +libname_spec="lib\$name"
1369: +
1370: +# List of archive names. First name is the real one, the rest are links.
1371: +# The last name is the one that the linker finds with -lNAME
1372: +library_names_spec="\$libname\$release\$shared_ext\$versuffix \$libname\$release\$shared_ext\$major \$libname\$shared_ext"
1373: +
1374: +# The coded name of the library, if different from the real name.
1375: +soname_spec="\$libname\$release\$shared_ext\$major"
1376: +
1377: +# Permission mode override for installation of shared libraries.
1378: +install_override_mode=""
1379: +
1380: +# Command to use after installation of a shared archive.
1381: +postinstall_cmds=""
1382: +
1383: +# Command to use after uninstallation of a shared archive.
1384: +postuninstall_cmds=""
1385: +
1386: +# Commands used to finish a libtool library installation in a directory.
1387: +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
1388: +
1389: +# As "finish_cmds", except a single script fragment to be evaled but
1390: +# not shown.
1391: +finish_eval=""
1392: +
1393: +# Whether we should hardcode library paths into libraries.
1394: +hardcode_into_libs=yes
1395: +
1396: +# Compile-time system search path for libraries.
1397: +sys_lib_search_path_spec="/usr/lib/gcc/x86_64-redhat-linux/5.3.1 /usr/lib64 /lib64 /usr/lib /lib "
1398: +
1399: +# Detected run-time system search path for libraries.
1400: +sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib /usr/lib64/bind99 /usr/lib64/llvm "
1401: +
1402: +# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
1403: +configure_time_lt_sys_library_path=""
1404: +
1405: +# Whether dlopen is supported.
1406: +dlopen_support=unknown
1407: +
1408: +# Whether dlopen of programs is supported.
1409: +dlopen_self=unknown
1410: +
1411: +# Whether dlopen of statically linked programs is supported.
1412: +dlopen_self_static=unknown
1413: +
1414: +# Commands to strip libraries.
1415: +old_striplib="strip --strip-debug"
1416: +striplib="strip --strip-unneeded"
1417: +
1418: +
1419: +# The linker used to build libraries.
1420: +LD="/usr/bin/ld -m elf_x86_64"
1421: +
1422: +# How to create reloadable object files.
1423: +reload_flag=" -r"
1424: +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
1425: +
1426: +# Commands used to build an old-style archive.
1427: +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$tool_oldlib"
1428: +
1429: +# A language specific compiler.
1430: +CC="gcc"
1431: +
1432: +# Is the compiler the GNU compiler?
1433: +with_gcc=yes
1434: +
1435: +# Compiler flag to turn off builtin functions.
1436: +no_builtin_flag=" -fno-builtin"
1437: +
1438: +# Additional compiler flags for building library objects.
1439: +pic_flag=" -fPIC -DPIC"
1440: +
1441: +# How to pass a linker flag through the compiler.
1442: +wl="-Wl,"
1443: +
1444: +# Compiler flag to prevent dynamic linking.
1445: +link_static_flag=""
1446: +
1447: +# Does compiler simultaneously support -c and -o options?
1448: +compiler_c_o="yes"
1449: +
1450: +# Whether or not to add -lc for building shared libraries.
1451: +build_libtool_need_lc=no
1452: +
1453: +# Whether or not to disallow shared libs when runtime libs are static.
1454: +allow_libtool_libs_with_static_runtimes=no
1455: +
1456: +# Compiler flag to allow reflexive dlopens.
1457: +export_dynamic_flag_spec="\$wl--export-dynamic"
1458: +
1459: +# Compiler flag to generate shared objects directly from archives.
1460: +whole_archive_flag_spec="\$wl--whole-archive\$convenience \$wl--no-whole-archive"
1461: +
1462: +# Whether the compiler copes with passing no objects directly.
1463: +compiler_needs_object="no"
1464: +
1465: +# Create an old-style archive from a shared archive.
1466: +old_archive_from_new_cmds=""
1467: +
1468: +# Create a temporary old-style archive to link instead of a shared archive.
1469: +old_archive_from_expsyms_cmds=""
1470: +
1471: +# Commands used to build a shared archive.
1472: +archive_cmds="\$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \$wl-soname \$wl\$soname -o \$lib"
1473: +archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
1474: + cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
1475: + echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
1476: + \$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \$wl-soname \$wl\$soname \$wl-version-script \$wl\$output_objdir/\$libname.ver -o \$lib"
1477: +
1478: +# Commands used to build a loadable module if different from building
1479: +# a shared archive.
1480: +module_cmds=""
1481: +module_expsym_cmds=""
1482: +
1483: +# Whether we are building with GNU ld or not.
1484: +with_gnu_ld="yes"
1485: +
1486: +# Flag that allows shared libraries with undefined symbols to be built.
1487: +allow_undefined_flag=""
1488: +
1489: +# Flag that enforces no undefined symbols.
1490: +no_undefined_flag=""
1491: +
1492: +# Flag to hardcode $libdir into a binary during linking.
1493: +# This must work even if $libdir does not exist
1494: +hardcode_libdir_flag_spec="\$wl-rpath \$wl\$libdir"
1495: +
1496: +# Whether we need a single "-rpath" flag with a separated argument.
1497: +hardcode_libdir_separator=""
1498: +
1499: +# Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
1500: +# DIR into the resulting binary.
1501: +hardcode_direct=no
1502: +
1503: +# Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
1504: +# DIR into the resulting binary and the resulting library dependency is
1505: +# "absolute",i.e impossible to change by setting $shlibpath_var if the
1506: +# library is relocated.
1507: +hardcode_direct_absolute=no
1508: +
1509: +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
1510: +# into the resulting binary.
1511: +hardcode_minus_L=no
1512: +
1513: +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
1514: +# into the resulting binary.
1515: +hardcode_shlibpath_var=unsupported
1516: +
1517: +# Set to "yes" if building a shared library automatically hardcodes DIR
1518: +# into the library and all subsequent libraries and executables linked
1519: +# against it.
1520: +hardcode_automatic=no
1521: +
1522: +# Set to yes if linker adds runtime paths of dependent libraries
1523: +# to runtime path list.
1524: +inherit_rpath=no
1525: +
1526: +# Whether libtool must link a program against all its dependency libraries.
1527: +link_all_deplibs=unknown
1528: +
1529: +# Set to "yes" if exported symbols are required.
1530: +always_export_symbols=no
1531: +
1532: +# The commands to list exported symbols.
1533: +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
1534: +
1535: +# Symbols that should not be listed in the preloaded symbols.
1536: +exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
1537: +
1538: +# Symbols that must always be exported.
1539: +include_expsyms=""
1540: +
1541: +# Commands necessary for linking programs (against libraries) with templates.
1542: +prelink_cmds=""
1543: +
1544: +# Commands necessary for finishing linking programs.
1545: +postlink_cmds=""
1546: +
1547: +# Specify filename containing input files.
1548: +file_list_spec=""
1549: +
1550: +# How to hardcode a shared library path into an executable.
1551: +hardcode_action=immediate
1552: +
1553: +# ### END LIBTOOL CONFIG
1554: +
1555: +
1556: +# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
1557: +
1558: +# func_munge_path_list VARIABLE PATH
1559: +# -----------------------------------
1560: +# VARIABLE is name of variable containing _space_ separated list of
1561: +# directories to be munged by the contents of PATH, which is string
1562: +# having a format:
1563: +# "DIR[:DIR]:"
1564: +# string "DIR[ DIR]" will be prepended to VARIABLE
1565: +# ":DIR[:DIR]"
1566: +# string "DIR[ DIR]" will be appended to VARIABLE
1567: +# "DIRP[:DIRP]::[DIRA:]DIRA"
1568: +# string "DIRP[ DIRP]" will be prepended to VARIABLE and string
1569: +# "DIRA[ DIRA]" will be appended to VARIABLE
1570: +# "DIR[:DIR]"
1571: +# VARIABLE will be replaced by "DIR[ DIR]"
1572: +func_munge_path_list ()
1573: +{
1574: + case x$2 in
1575: + x)
1576: + ;;
1577: + *:)
1578: + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
1579: + ;;
1580: + x:*)
1581: + eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
1582: + ;;
1583: + *::*)
1584: + eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
1585: + eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
1586: + ;;
1587: + *)
1588: + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
1589: + ;;
1590: + esac
1591: +}
1592: +
1593: +
1594: +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix.
1595: +func_cc_basename ()
1596: +{
1597: + for cc_temp in $*""; do
1598: + case $cc_temp in
1599: + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
1600: + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
1601: + \-*) ;;
1602: + *) break;;
1603: + esac
1604: + done
1605: + func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
1606: +}
1607: +
1608: +
1609: +# ### END FUNCTIONS SHARED WITH CONFIGURE
1610: +
1611: +#! /bin/sh
1612: +## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
1613: +## by inline-source v2014-01-03.01
1614: +
1615: +# libtool (GNU libtool) 2.4.6
1616: +# Provide generalized library-building support services.
1617: +# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
1618: +
1619: +# Copyright (C) 1996-2015 Free Software Foundation, Inc.
1620: +# This is free software; see the source for copying conditions. There is NO
1621: +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
1622: +
1623: +# GNU Libtool is free software; you can redistribute it and/or modify
1624: +# it under the terms of the GNU General Public License as published by
1625: +# the Free Software Foundation; either version 2 of the License, or
1626: +# (at your option) any later version.
1627: +#
1628: +# As a special exception to the GNU General Public License,
1629: +# if you distribute this file as part of a program or library that
1630: +# is built using GNU Libtool, you may include this file under the
1631: +# same distribution terms that you use for the rest of that program.
1632: +#
1633: +# GNU Libtool is distributed in the hope that it will be useful, but
1634: +# WITHOUT ANY WARRANTY; without even the implied warranty of
1635: +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1636: +# General Public License for more details.
1637: +#
1638: +# You should have received a copy of the GNU General Public License
1639: +# along with this program. If not, see <http://www.gnu.org/licenses/>.
1640: +
1641: +
1642: +PROGRAM=libtool
1643: +PACKAGE=libtool
1644: +VERSION=2.4.6
1645: +package_revision=2.4.6
1646: +
1647: +
1648: +## ------ ##
1649: +## Usage. ##
1650: +## ------ ##
1651: +
1652: +# Run './libtool --help' for help with using this script from the
1653: +# command line.
1654: +
1655: +
1656: +## ------------------------------- ##
1657: +## User overridable command paths. ##
1658: +## ------------------------------- ##
1659: +
1660: +# After configure completes, it has a better idea of some of the
1661: +# shell tools we need than the defaults used by the functions shared
1662: +# with bootstrap, so set those here where they can still be over-
1663: +# ridden by the user, but otherwise take precedence.
1664: +
1665: +: ${AUTOCONF="autoconf"}
1666: +: ${AUTOMAKE="automake"}
1667: +
1668: +
1669: +## -------------------------- ##
1670: +## Source external libraries. ##
1671: +## -------------------------- ##
1672: +
1673: +# Much of our low-level functionality needs to be sourced from external
1674: +# libraries, which are installed to $pkgauxdir.
1675: +
1676: +# Set a version string for this script.
1677: +scriptversion=2015-01-20.17; # UTC
1678: +
1679: +# General shell script boiler plate, and helper functions.
1680: +# Written by Gary V. Vaughan, 2004
1681: +
1682: +# Copyright (C) 2004-2015 Free Software Foundation, Inc.
1683: +# This is free software; see the source for copying conditions. There is NO
1684: +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
1685: +
1686: +# This program is free software; you can redistribute it and/or modify
1687: +# it under the terms of the GNU General Public License as published by
1688: +# the Free Software Foundation; either version 3 of the License, or
1689: +# (at your option) any later version.
1690: +
1691: +# As a special exception to the GNU General Public License, if you distribute
1692: +# this file as part of a program or library that is built using GNU Libtool,
1693: +# you may include this file under the same distribution terms that you use
1694: +# for the rest of that program.
1695: +
1696: +# This program is distributed in the hope that it will be useful,
1697: +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1698: +# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
1699: +# General Public License for more details.
1700: +
1701: +# You should have received a copy of the GNU General Public License
1702: +# along with this program. If not, see <http://www.gnu.org/licenses/>.
1703: +
1704: +# Please report bugs or propose patches to gary@gnu.org.
1705: +
1706: +
1707: +## ------ ##
1708: +## Usage. ##
1709: +## ------ ##
1710: +
1711: +# Evaluate this file near the top of your script to gain access to
1712: +# the functions and variables defined here:
1713: +#
1714: +# . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
1715: +#
1716: +# If you need to override any of the default environment variable
1717: +# settings, do that before evaluating this file.
1718: +
1719: +
1720: +## -------------------- ##
1721: +## Shell normalisation. ##
1722: +## -------------------- ##
1723: +
1724: +# Some shells need a little help to be as Bourne compatible as possible.
1725: +# Before doing anything else, make sure all that help has been provided!
1726: +
1727: +DUALCASE=1; export DUALCASE # for MKS sh
1728: +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
1729: + emulate sh
1730: + NULLCMD=:
1731: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
1732: + # is contrary to our usage. Disable this feature.
1733: + alias -g '${1+"$@"}'='"$@"'
1734: + setopt NO_GLOB_SUBST
1735: +else
1736: + case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
1737: +fi
1738: +
1739: +# NLS nuisances: We save the old values in case they are required later.
1740: +_G_user_locale=
1741: +_G_safe_locale=
1742: +for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1743: +do
1744: + eval "if test set = \"\${$_G_var+set}\"; then
1745: + save_$_G_var=\$$_G_var
1746: + $_G_var=C
1747: + export $_G_var
1748: + _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
1749: + _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
1750: + fi"
1751: +done
1752: +
1753: +# CDPATH.
1754: +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
1755: +
1756: +# Make sure IFS has a sensible default
1757: +sp=' '
1758: +nl='
1759: +'
1760: +IFS="$sp $nl"
1761: +
1762: +# There are apparently some retarded systems that use ';' as a PATH separator!
1763: +if test "${PATH_SEPARATOR+set}" != set; then
1764: + PATH_SEPARATOR=:
1765: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
1766: + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
1767: + PATH_SEPARATOR=';'
1768: + }
1769: +fi
1770: +
1771: +
1772: +
1773: +## ------------------------- ##
1774: +## Locate command utilities. ##
1775: +## ------------------------- ##
1776: +
1777: +
1778: +# func_executable_p FILE
1779: +# ----------------------
1780: +# Check that FILE is an executable regular file.
1781: +func_executable_p ()
1782: +{
1783: + test -f "$1" && test -x "$1"
1784: +}
1785: +
1786: +
1787: +# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
1788: +# --------------------------------------------
1789: +# Search for either a program that responds to --version with output
1790: +# containing "GNU", or else returned by CHECK_FUNC otherwise, by
1791: +# trying all the directories in PATH with each of the elements of
1792: +# PROGS_LIST.
1793: +#
1794: +# CHECK_FUNC should accept the path to a candidate program, and
1795: +# set $func_check_prog_result if it truncates its output less than
1796: +# $_G_path_prog_max characters.
1797: +func_path_progs ()
1798: +{
1799: + _G_progs_list=$1
1800: + _G_check_func=$2
1801: + _G_PATH=${3-"$PATH"}
1802: +
1803: + _G_path_prog_max=0
1804: + _G_path_prog_found=false
1805: + _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
1806: + for _G_dir in $_G_PATH; do
1807: + IFS=$_G_save_IFS
1808: + test -z "$_G_dir" && _G_dir=.
1809: + for _G_prog_name in $_G_progs_list; do
1810: + for _exeext in '' .EXE; do
1811: + _G_path_prog=$_G_dir/$_G_prog_name$_exeext
1812: + func_executable_p "$_G_path_prog" || continue
1813: + case `"$_G_path_prog" --version 2>&1` in
1814: + *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
1815: + *) $_G_check_func $_G_path_prog
1816: + func_path_progs_result=$func_check_prog_result
1817: + ;;
1818: + esac
1819: + $_G_path_prog_found && break 3
1820: + done
1821: + done
1822: + done
1823: + IFS=$_G_save_IFS
1824: + test -z "$func_path_progs_result" && {
1825: + echo "no acceptable sed could be found in \$PATH" >&2
1826: + exit 1
1827: + }
1828: +}
1829: +
1830: +
1831: +# We want to be able to use the functions in this file before configure
1832: +# has figured out where the best binaries are kept, which means we have
1833: +# to search for them ourselves - except when the results are already set
1834: +# where we skip the searches.
1835: +
1836: +# Unless the user overrides by setting SED, search the path for either GNU
1837: +# sed, or the sed that truncates its output the least.
1838: +test -z "$SED" && {
1839: + _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
1840: + for _G_i in 1 2 3 4 5 6 7; do
1841: + _G_sed_script=$_G_sed_script$nl$_G_sed_script
1842: + done
1843: + echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
1844: + _G_sed_script=
1845: +
1846: + func_check_prog_sed ()
1847: + {
1848: + _G_path_prog=$1
1849: +
1850: + _G_count=0
1851: + printf 0123456789 >conftest.in
1852: + while :
1853: + do
1854: + cat conftest.in conftest.in >conftest.tmp
1855: + mv conftest.tmp conftest.in
1856: + cp conftest.in conftest.nl
1857: + echo '' >> conftest.nl
1858: + "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
1859: + diff conftest.out conftest.nl >/dev/null 2>&1 || break
1860: + _G_count=`expr $_G_count + 1`
1861: + if test "$_G_count" -gt "$_G_path_prog_max"; then
1862: + # Best one so far, save it but keep looking for a better one
1863: + func_check_prog_result=$_G_path_prog
1864: + _G_path_prog_max=$_G_count
1865: + fi
1866: + # 10*(2^10) chars as input seems more than enough
1867: + test 10 -lt "$_G_count" && break
1868: + done
1869: + rm -f conftest.in conftest.tmp conftest.nl conftest.out
1870: + }
1871: +
1872: + func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
1873: + rm -f conftest.sed
1874: + SED=$func_path_progs_result
1875: +}
1876: +
1877: +
1878: +# Unless the user overrides by setting GREP, search the path for either GNU
1879: +# grep, or the grep that truncates its output the least.
1880: +test -z "$GREP" && {
1881: + func_check_prog_grep ()
1882: + {
1883: + _G_path_prog=$1
1884: +
1885: + _G_count=0
1886: + _G_path_prog_max=0
1887: + printf 0123456789 >conftest.in
1888: + while :
1889: + do
1890: + cat conftest.in conftest.in >conftest.tmp
1891: + mv conftest.tmp conftest.in
1892: + cp conftest.in conftest.nl
1893: + echo 'GREP' >> conftest.nl
1894: + "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
1895: + diff conftest.out conftest.nl >/dev/null 2>&1 || break
1896: + _G_count=`expr $_G_count + 1`
1897: + if test "$_G_count" -gt "$_G_path_prog_max"; then
1898: + # Best one so far, save it but keep looking for a better one
1899: + func_check_prog_result=$_G_path_prog
1900: + _G_path_prog_max=$_G_count
1901: + fi
1902: + # 10*(2^10) chars as input seems more than enough
1903: + test 10 -lt "$_G_count" && break
1904: + done
1905: + rm -f conftest.in conftest.tmp conftest.nl conftest.out
1906: + }
1907: +
1908: + func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
1909: + GREP=$func_path_progs_result
1910: +}
1911: +
1912: +
1913: +## ------------------------------- ##
1914: +## User overridable command paths. ##
1915: +## ------------------------------- ##
1916: +
1917: +# All uppercase variable names are used for environment variables. These
1918: +# variables can be overridden by the user before calling a script that
1919: +# uses them if a suitable command of that name is not already available
1920: +# in the command search PATH.
1921: +
1922: +: ${CP="cp -f"}
1923: +: ${ECHO="printf %s\n"}
1924: +: ${EGREP="$GREP -E"}
1925: +: ${FGREP="$GREP -F"}
1926: +: ${LN_S="ln -s"}
1927: +: ${MAKE="make"}
1928: +: ${MKDIR="mkdir"}
1929: +: ${MV="mv -f"}
1930: +: ${RM="rm -f"}
1931: +: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
1932: +
1933: +
1934: +## -------------------- ##
1935: +## Useful sed snippets. ##
1936: +## -------------------- ##
1937: +
1938: +sed_dirname='s|/[^/]*$||'
1939: +sed_basename='s|^.*/||'
1940: +
1941: +# Sed substitution that helps us do robust quoting. It backslashifies
1942: +# metacharacters that are still active within double-quoted strings.
1943: +sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
1944: +
1945: +# Same as above, but do not quote variable references.
1946: +sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
1947: +
1948: +# Sed substitution that turns a string into a regex matching for the
1949: +# string literally.
1950: +sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
1951: +
1952: +# Sed substitution that converts a w32 file name or path
1953: +# that contains forward slashes, into one that contains
1954: +# (escaped) backslashes. A very naive implementation.
1955: +sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
1956: +
1957: +# Re-'\' parameter expansions in output of sed_double_quote_subst that
1958: +# were '\'-ed in input to the same. If an odd number of '\' preceded a
1959: +# '$' in input to sed_double_quote_subst, that '$' was protected from
1960: +# expansion. Since each input '\' is now two '\'s, look for any number
1961: +# of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'.
1962: +_G_bs='\\'
1963: +_G_bs2='\\\\'
1964: +_G_bs4='\\\\\\\\'
1965: +_G_dollar='\$'
1966: +sed_double_backslash="\
1967: + s/$_G_bs4/&\\
1968: +/g
1969: + s/^$_G_bs2$_G_dollar/$_G_bs&/
1970: + s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
1971: + s/\n//g"
1972: +
1973: +
1974: +## ----------------- ##
1975: +## Global variables. ##
1976: +## ----------------- ##
1977: +
1978: +# Except for the global variables explicitly listed below, the following
1979: +# functions in the '^func_' namespace, and the '^require_' namespace
1980: +# variables initialised in the 'Resource management' section, sourcing
1981: +# this file will not pollute your global namespace with anything
1982: +# else. There's no portable way to scope variables in Bourne shell
1983: +# though, so actually running these functions will sometimes place
1984: +# results into a variable named after the function, and often use
1985: +# temporary variables in the '^_G_' namespace. If you are careful to
1986: +# avoid using those namespaces casually in your sourcing script, things
1987: +# should continue to work as you expect. And, of course, you can freely
1988: +# overwrite any of the functions or variables defined here before
1989: +# calling anything to customize them.
1990: +
1991: +EXIT_SUCCESS=0
1992: +EXIT_FAILURE=1
1993: +EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
1994: +EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
1995: +
1996: +# Allow overriding, eg assuming that you follow the convention of
1997: +# putting '$debug_cmd' at the start of all your functions, you can get
1998: +# bash to show function call trace with:
1999: +#
2000: +# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
2001: +debug_cmd=${debug_cmd-":"}
2002: +exit_cmd=:
2003: +
2004: +# By convention, finish your script with:
2005: +#
2006: +# exit $exit_status
2007: +#
2008: +# so that you can set exit_status to non-zero if you want to indicate
2009: +# something went wrong during execution without actually bailing out at
2010: +# the point of failure.
2011: +exit_status=$EXIT_SUCCESS
2012: +
2013: +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
2014: +# is ksh but when the shell is invoked as "sh" and the current value of
2015: +# the _XPG environment variable is not equal to 1 (one), the special
2016: +# positional parameter $0, within a function call, is the name of the
2017: +# function.
2018: +progpath=$0
2019: +
2020: +# The name of this program.
2021: +progname=`$ECHO "$progpath" |$SED "$sed_basename"`
2022: +
2023: +# Make sure we have an absolute progpath for reexecution:
2024: +case $progpath in
2025: + [\\/]*|[A-Za-z]:\\*) ;;
2026: + *[\\/]*)
2027: + progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
2028: + progdir=`cd "$progdir" && pwd`
2029: + progpath=$progdir/$progname
2030: + ;;
2031: + *)
2032: + _G_IFS=$IFS
2033: + IFS=${PATH_SEPARATOR-:}
2034: + for progdir in $PATH; do
2035: + IFS=$_G_IFS
2036: + test -x "$progdir/$progname" && break
2037: + done
2038: + IFS=$_G_IFS
2039: + test -n "$progdir" || progdir=`pwd`
2040: + progpath=$progdir/$progname
2041: + ;;
2042: +esac
2043: +
2044: +
2045: +## ----------------- ##
2046: +## Standard options. ##
2047: +## ----------------- ##
2048: +
2049: +# The following options affect the operation of the functions defined
2050: +# below, and should be set appropriately depending on run-time para-
2051: +# meters passed on the command line.
2052: +
2053: +opt_dry_run=false
2054: +opt_quiet=false
2055: +opt_verbose=false
2056: +
2057: +# Categories 'all' and 'none' are always available. Append any others
2058: +# you will pass as the first argument to func_warning from your own
2059: +# code.
2060: +warning_categories=
2061: +
2062: +# By default, display warnings according to 'opt_warning_types'. Set
2063: +# 'warning_func' to ':' to elide all warnings, or func_fatal_error to
2064: +# treat the next displayed warning as a fatal error.
2065: +warning_func=func_warn_and_continue
2066: +
2067: +# Set to 'all' to display all warnings, 'none' to suppress all
2068: +# warnings, or a space delimited list of some subset of
2069: +# 'warning_categories' to display only the listed warnings.
2070: +opt_warning_types=all
2071: +
2072: +
2073: +## -------------------- ##
2074: +## Resource management. ##
2075: +## -------------------- ##
2076: +
2077: +# This section contains definitions for functions that each ensure a
2078: +# particular resource (a file, or a non-empty configuration variable for
2079: +# example) is available, and if appropriate to extract default values
2080: +# from pertinent package files. Call them using their associated
2081: +# 'require_*' variable to ensure that they are executed, at most, once.
2082: +#
2083: +# It's entirely deliberate that calling these functions can set
2084: +# variables that don't obey the namespace limitations obeyed by the rest
2085: +# of this file, in order that that they be as useful as possible to
2086: +# callers.
2087: +
2088: +
2089: +# require_term_colors
2090: +# -------------------
2091: +# Allow display of bold text on terminals that support it.
2092: +require_term_colors=func_require_term_colors
2093: +func_require_term_colors ()
2094: +{
2095: + $debug_cmd
2096: +
2097: + test -t 1 && {
2098: + # COLORTERM and USE_ANSI_COLORS environment variables take
2099: + # precedence, because most terminfo databases neglect to describe
2100: + # whether color sequences are supported.
2101: + test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
2102: +
2103: + if test 1 = "$USE_ANSI_COLORS"; then
2104: + # Standard ANSI escape sequences
2105: + tc_reset='[0m'
2106: + tc_bold='[1m'; tc_standout='[7m'
2107: + tc_red='[31m'; tc_green='[32m'
2108: + tc_blue='[34m'; tc_cyan='[36m'
2109: + else
2110: + # Otherwise trust the terminfo database after all.
2111: + test -n "`tput sgr0 2>/dev/null`" && {
2112: + tc_reset=`tput sgr0`
2113: + test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
2114: + tc_standout=$tc_bold
2115: + test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
2116: + test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
2117: + test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
2118: + test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
2119: + test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
2120: + }
2121: + fi
2122: + }
2123: +
2124: + require_term_colors=:
2125: +}
2126: +
2127: +
2128: +## ----------------- ##
2129: +## Function library. ##
2130: +## ----------------- ##
2131: +
2132: +# This section contains a variety of useful functions to call in your
2133: +# scripts. Take note of the portable wrappers for features provided by
2134: +# some modern shells, which will fall back to slower equivalents on
2135: +# less featureful shells.
2136: +
2137: +
2138: +# func_append VAR VALUE
2139: +# ---------------------
2140: +# Append VALUE onto the existing contents of VAR.
2141: +
2142: + # We should try to minimise forks, especially on Windows where they are
2143: + # unreasonably slow, so skip the feature probes when bash or zsh are
2144: + # being used:
2145: + if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
2146: + : ${_G_HAVE_ARITH_OP="yes"}
2147: + : ${_G_HAVE_XSI_OPS="yes"}
2148: + # The += operator was introduced in bash 3.1
2149: + case $BASH_VERSION in
2150: + [12].* | 3.0 | 3.0*) ;;
2151: + *)
2152: + : ${_G_HAVE_PLUSEQ_OP="yes"}
2153: + ;;
2154: + esac
2155: + fi
2156: +
2157: + # _G_HAVE_PLUSEQ_OP
2158: + # Can be empty, in which case the shell is probed, "yes" if += is
2159: + # useable or anything else if it does not work.
2160: + test -z "$_G_HAVE_PLUSEQ_OP" \
2161: + && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
2162: + && _G_HAVE_PLUSEQ_OP=yes
2163: +
2164: +if test yes = "$_G_HAVE_PLUSEQ_OP"
2165: +then
2166: + # This is an XSI compatible shell, allowing a faster implementation...
2167: + eval 'func_append ()
2168: + {
2169: + $debug_cmd
2170: +
2171: + eval "$1+=\$2"
2172: + }'
2173: +else
2174: + # ...otherwise fall back to using expr, which is often a shell builtin.
2175: + func_append ()
2176: + {
2177: + $debug_cmd
2178: +
2179: + eval "$1=\$$1\$2"
2180: + }
2181: +fi
2182: +
2183: +
2184: +# func_append_quoted VAR VALUE
2185: +# ----------------------------
2186: +# Quote VALUE and append to the end of shell variable VAR, separated
2187: +# by a space.
2188: +if test yes = "$_G_HAVE_PLUSEQ_OP"; then
2189: + eval 'func_append_quoted ()
2190: + {
2191: + $debug_cmd
2192: +
2193: + func_quote_for_eval "$2"
2194: + eval "$1+=\\ \$func_quote_for_eval_result"
2195: + }'
2196: +else
2197: + func_append_quoted ()
2198: + {
2199: + $debug_cmd
2200: +
2201: + func_quote_for_eval "$2"
2202: + eval "$1=\$$1\\ \$func_quote_for_eval_result"
2203: + }
2204: +fi
2205: +
2206: +
2207: +# func_append_uniq VAR VALUE
2208: +# --------------------------
2209: +# Append unique VALUE onto the existing contents of VAR, assuming
2210: +# entries are delimited by the first character of VALUE. For example:
2211: +#
2212: +# func_append_uniq options " --another-option option-argument"
2213: +#
2214: +# will only append to $options if " --another-option option-argument "
2215: +# is not already present somewhere in $options already (note spaces at
2216: +# each end implied by leading space in second argument).
2217: +func_append_uniq ()
2218: +{
2219: + $debug_cmd
2220: +
2221: + eval _G_current_value='`$ECHO $'$1'`'
2222: + _G_delim=`expr "$2" : '\(.\)'`
2223: +
2224: + case $_G_delim$_G_current_value$_G_delim in
2225: + *"$2$_G_delim"*) ;;
2226: + *) func_append "$@" ;;
2227: + esac
2228: +}
2229: +
2230: +
2231: +# func_arith TERM...
2232: +# ------------------
2233: +# Set func_arith_result to the result of evaluating TERMs.
2234: + test -z "$_G_HAVE_ARITH_OP" \
2235: + && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
2236: + && _G_HAVE_ARITH_OP=yes
2237: +
2238: +if test yes = "$_G_HAVE_ARITH_OP"; then
2239: + eval 'func_arith ()
2240: + {
2241: + $debug_cmd
2242: +
2243: + func_arith_result=$(( $* ))
2244: + }'
2245: +else
2246: + func_arith ()
2247: + {
2248: + $debug_cmd
2249: +
2250: + func_arith_result=`expr "$@"`
2251: + }
2252: +fi
2253: +
2254: +
2255: +# func_basename FILE
2256: +# ------------------
2257: +# Set func_basename_result to FILE with everything up to and including
2258: +# the last / stripped.
2259: +if test yes = "$_G_HAVE_XSI_OPS"; then
2260: + # If this shell supports suffix pattern removal, then use it to avoid
2261: + # forking. Hide the definitions single quotes in case the shell chokes
2262: + # on unsupported syntax...
2263: + _b='func_basename_result=${1##*/}'
2264: + _d='case $1 in
2265: + */*) func_dirname_result=${1%/*}$2 ;;
2266: + * ) func_dirname_result=$3 ;;
2267: + esac'
2268: +
2269: +else
2270: + # ...otherwise fall back to using sed.
2271: + _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
2272: + _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"`
2273: + if test "X$func_dirname_result" = "X$1"; then
2274: + func_dirname_result=$3
2275: + else
2276: + func_append func_dirname_result "$2"
2277: + fi'
2278: +fi
2279: +
2280: +eval 'func_basename ()
2281: +{
2282: + $debug_cmd
2283: +
2284: + '"$_b"'
2285: +}'
2286: +
2287: +
2288: +# func_dirname FILE APPEND NONDIR_REPLACEMENT
2289: +# -------------------------------------------
2290: +# Compute the dirname of FILE. If nonempty, add APPEND to the result,
2291: +# otherwise set result to NONDIR_REPLACEMENT.
2292: +eval 'func_dirname ()
2293: +{
2294: + $debug_cmd
2295: +
2296: + '"$_d"'
2297: +}'
2298: +
2299: +
2300: +# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
2301: +# --------------------------------------------------------
2302: +# Perform func_basename and func_dirname in a single function
2303: +# call:
2304: +# dirname: Compute the dirname of FILE. If nonempty,
2305: +# add APPEND to the result, otherwise set result
2306: +# to NONDIR_REPLACEMENT.
2307: +# value returned in "$func_dirname_result"
2308: +# basename: Compute filename of FILE.
2309: +# value retuned in "$func_basename_result"
2310: +# For efficiency, we do not delegate to the functions above but instead
2311: +# duplicate the functionality here.
2312: +eval 'func_dirname_and_basename ()
2313: +{
2314: + $debug_cmd
2315: +
2316: + '"$_b"'
2317: + '"$_d"'
2318: +}'
2319: +
2320: +
2321: +# func_echo ARG...
2322: +# ----------------
2323: +# Echo program name prefixed message.
2324: +func_echo ()
2325: +{
2326: + $debug_cmd
2327: +
2328: + _G_message=$*
2329: +
2330: + func_echo_IFS=$IFS
2331: + IFS=$nl
2332: + for _G_line in $_G_message; do
2333: + IFS=$func_echo_IFS
2334: + $ECHO "$progname: $_G_line"
2335: + done
2336: + IFS=$func_echo_IFS
2337: +}
2338: +
2339: +
2340: +# func_echo_all ARG...
2341: +# --------------------
2342: +# Invoke $ECHO with all args, space-separated.
2343: +func_echo_all ()
2344: +{
2345: + $ECHO "$*"
2346: +}
2347: +
2348: +
2349: +# func_echo_infix_1 INFIX ARG...
2350: +# ------------------------------
2351: +# Echo program name, followed by INFIX on the first line, with any
2352: +# additional lines not showing INFIX.
2353: +func_echo_infix_1 ()
2354: +{
2355: + $debug_cmd
2356: +
2357: + $require_term_colors
2358: +
2359: + _G_infix=$1; shift
2360: + _G_indent=$_G_infix
2361: + _G_prefix="$progname: $_G_infix: "
2362: + _G_message=$*
2363: +
2364: + # Strip color escape sequences before counting printable length
2365: + for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
2366: + do
2367: + test -n "$_G_tc" && {
2368: + _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
2369: + _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
2370: + }
2371: + done
2372: + _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes
2373: +
2374: + func_echo_infix_1_IFS=$IFS
2375: + IFS=$nl
2376: + for _G_line in $_G_message; do
2377: + IFS=$func_echo_infix_1_IFS
2378: + $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
2379: + _G_prefix=$_G_indent
2380: + done
2381: + IFS=$func_echo_infix_1_IFS
2382: +}
2383: +
2384: +
2385: +# func_error ARG...
2386: +# -----------------
2387: +# Echo program name prefixed message to standard error.
2388: +func_error ()
2389: +{
2390: + $debug_cmd
2391: +
2392: + $require_term_colors
2393: +
2394: + func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2
2395: +}
2396: +
2397: +
2398: +# func_fatal_error ARG...
2399: +# -----------------------
2400: +# Echo program name prefixed message to standard error, and exit.
2401: +func_fatal_error ()
2402: +{
2403: + $debug_cmd
2404: +
2405: + func_error "$*"
2406: + exit $EXIT_FAILURE
2407: +}
2408: +
2409: +
2410: +# func_grep EXPRESSION FILENAME
2411: +# -----------------------------
2412: +# Check whether EXPRESSION matches any line of FILENAME, without output.
2413: +func_grep ()
2414: +{
2415: + $debug_cmd
2416: +
2417: + $GREP "$1" "$2" >/dev/null 2>&1
2418: +}
2419: +
2420: +
2421: +# func_len STRING
2422: +# ---------------
2423: +# Set func_len_result to the length of STRING. STRING may not
2424: +# start with a hyphen.
2425: + test -z "$_G_HAVE_XSI_OPS" \
2426: + && (eval 'x=a/b/c;
2427: + test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
2428: + && _G_HAVE_XSI_OPS=yes
2429: +
2430: +if test yes = "$_G_HAVE_XSI_OPS"; then
2431: + eval 'func_len ()
2432: + {
2433: + $debug_cmd
2434: +
2435: + func_len_result=${#1}
2436: + }'
2437: +else
2438: + func_len ()
2439: + {
2440: + $debug_cmd
2441: +
2442: + func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
2443: + }
2444: +fi
2445: +
2446: +
2447: +# func_mkdir_p DIRECTORY-PATH
2448: +# ---------------------------
2449: +# Make sure the entire path to DIRECTORY-PATH is available.
2450: +func_mkdir_p ()
2451: +{
2452: + $debug_cmd
2453: +
2454: + _G_directory_path=$1
2455: + _G_dir_list=
2456: +
2457: + if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
2458: +
2459: + # Protect directory names starting with '-'
2460: + case $_G_directory_path in
2461: + -*) _G_directory_path=./$_G_directory_path ;;
2462: + esac
2463: +
2464: + # While some portion of DIR does not yet exist...
2465: + while test ! -d "$_G_directory_path"; do
2466: + # ...make a list in topmost first order. Use a colon delimited
2467: + # list incase some portion of path contains whitespace.
2468: + _G_dir_list=$_G_directory_path:$_G_dir_list
2469: +
2470: + # If the last portion added has no slash in it, the list is done
2471: + case $_G_directory_path in */*) ;; *) break ;; esac
2472: +
2473: + # ...otherwise throw away the child directory and loop
2474: + _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
2475: + done
2476: + _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
2477: +
2478: + func_mkdir_p_IFS=$IFS; IFS=:
2479: + for _G_dir in $_G_dir_list; do
2480: + IFS=$func_mkdir_p_IFS
2481: + # mkdir can fail with a 'File exist' error if two processes
2482: + # try to create one of the directories concurrently. Don't
2483: + # stop in that case!
2484: + $MKDIR "$_G_dir" 2>/dev/null || :
2485: + done
2486: + IFS=$func_mkdir_p_IFS
2487: +
2488: + # Bail out if we (or some other process) failed to create a directory.
2489: + test -d "$_G_directory_path" || \
2490: + func_fatal_error "Failed to create '$1'"
2491: + fi
2492: +}
2493: +
2494: +
2495: +# func_mktempdir [BASENAME]
2496: +# -------------------------
2497: +# Make a temporary directory that won't clash with other running
2498: +# libtool processes, and avoids race conditions if possible. If
2499: +# given, BASENAME is the basename for that directory.
2500: +func_mktempdir ()
2501: +{
2502: + $debug_cmd
2503: +
2504: + _G_template=${TMPDIR-/tmp}/${1-$progname}
2505: +
2506: + if test : = "$opt_dry_run"; then
2507: + # Return a directory name, but don't create it in dry-run mode
2508: + _G_tmpdir=$_G_template-$$
2509: + else
2510: +
2511: + # If mktemp works, use that first and foremost
2512: + _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
2513: +
2514: + if test ! -d "$_G_tmpdir"; then
2515: + # Failing that, at least try and use $RANDOM to avoid a race
2516: + _G_tmpdir=$_G_template-${RANDOM-0}$$
2517: +
2518: + func_mktempdir_umask=`umask`
2519: + umask 0077
2520: + $MKDIR "$_G_tmpdir"
2521: + umask $func_mktempdir_umask
2522: + fi
2523: +
2524: + # If we're not in dry-run mode, bomb out on failure
2525: + test -d "$_G_tmpdir" || \
2526: + func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
2527: + fi
2528: +
2529: + $ECHO "$_G_tmpdir"
2530: +}
2531: +
2532: +
2533: +# func_normal_abspath PATH
2534: +# ------------------------
2535: +# Remove doubled-up and trailing slashes, "." path components,
2536: +# and cancel out any ".." path components in PATH after making
2537: +# it an absolute path.
2538: +func_normal_abspath ()
2539: +{
2540: + $debug_cmd
2541: +
2542: + # These SED scripts presuppose an absolute path with a trailing slash.
2543: + _G_pathcar='s|^/\([^/]*\).*$|\1|'
2544: + _G_pathcdr='s|^/[^/]*||'
2545: + _G_removedotparts=':dotsl
2546: + s|/\./|/|g
2547: + t dotsl
2548: + s|/\.$|/|'
2549: + _G_collapseslashes='s|/\{1,\}|/|g'
2550: + _G_finalslash='s|/*$|/|'
2551: +
2552: + # Start from root dir and reassemble the path.
2553: + func_normal_abspath_result=
2554: + func_normal_abspath_tpath=$1
2555: + func_normal_abspath_altnamespace=
2556: + case $func_normal_abspath_tpath in
2557: + "")
2558: + # Empty path, that just means $cwd.
2559: + func_stripname '' '/' "`pwd`"
2560: + func_normal_abspath_result=$func_stripname_result
2561: + return
2562: + ;;
2563: + # The next three entries are used to spot a run of precisely
2564: + # two leading slashes without using negated character classes;
2565: + # we take advantage of case's first-match behaviour.
2566: + ///*)
2567: + # Unusual form of absolute path, do nothing.
2568: + ;;
2569: + //*)
2570: + # Not necessarily an ordinary path; POSIX reserves leading '//'
2571: + # and for example Cygwin uses it to access remote file shares
2572: + # over CIFS/SMB, so we conserve a leading double slash if found.
2573: + func_normal_abspath_altnamespace=/
2574: + ;;
2575: + /*)
2576: + # Absolute path, do nothing.
2577: + ;;
2578: + *)
2579: + # Relative path, prepend $cwd.
2580: + func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
2581: + ;;
2582: + esac
2583: +
2584: + # Cancel out all the simple stuff to save iterations. We also want
2585: + # the path to end with a slash for ease of parsing, so make sure
2586: + # there is one (and only one) here.
2587: + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
2588: + -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
2589: + while :; do
2590: + # Processed it all yet?
2591: + if test / = "$func_normal_abspath_tpath"; then
2592: + # If we ascended to the root using ".." the result may be empty now.
2593: + if test -z "$func_normal_abspath_result"; then
2594: + func_normal_abspath_result=/
2595: + fi
2596: + break
2597: + fi
2598: + func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
2599: + -e "$_G_pathcar"`
2600: + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
2601: + -e "$_G_pathcdr"`
2602: + # Figure out what to do with it
2603: + case $func_normal_abspath_tcomponent in
2604: + "")
2605: + # Trailing empty path component, ignore it.
2606: + ;;
2607: + ..)
2608: + # Parent dir; strip last assembled component from result.
2609: + func_dirname "$func_normal_abspath_result"
2610: + func_normal_abspath_result=$func_dirname_result
2611: + ;;
2612: + *)
2613: + # Actual path component, append it.
2614: + func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
2615: + ;;
2616: + esac
2617: + done
2618: + # Restore leading double-slash if one was found on entry.
2619: + func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
2620: +}
2621: +
2622: +
2623: +# func_notquiet ARG...
2624: +# --------------------
2625: +# Echo program name prefixed message only when not in quiet mode.
2626: +func_notquiet ()
2627: +{
2628: + $debug_cmd
2629: +
2630: + $opt_quiet || func_echo ${1+"$@"}
2631: +
2632: + # A bug in bash halts the script if the last line of a function
2633: + # fails when set -e is in force, so we need another command to
2634: + # work around that:
2635: + :
2636: +}
2637: +
2638: +
2639: +# func_relative_path SRCDIR DSTDIR
2640: +# --------------------------------
2641: +# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
2642: +func_relative_path ()
2643: +{
2644: + $debug_cmd
2645: +
2646: + func_relative_path_result=
2647: + func_normal_abspath "$1"
2648: + func_relative_path_tlibdir=$func_normal_abspath_result
2649: + func_normal_abspath "$2"
2650: + func_relative_path_tbindir=$func_normal_abspath_result
2651: +
2652: + # Ascend the tree starting from libdir
2653: + while :; do
2654: + # check if we have found a prefix of bindir
2655: + case $func_relative_path_tbindir in
2656: + $func_relative_path_tlibdir)
2657: + # found an exact match
2658: + func_relative_path_tcancelled=
2659: + break
2660: + ;;
2661: + $func_relative_path_tlibdir*)
2662: + # found a matching prefix
2663: + func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
2664: + func_relative_path_tcancelled=$func_stripname_result
2665: + if test -z "$func_relative_path_result"; then
2666: + func_relative_path_result=.
2667: + fi
2668: + break
2669: + ;;
2670: + *)
2671: + func_dirname $func_relative_path_tlibdir
2672: + func_relative_path_tlibdir=$func_dirname_result
2673: + if test -z "$func_relative_path_tlibdir"; then
2674: + # Have to descend all the way to the root!
2675: + func_relative_path_result=../$func_relative_path_result
2676: + func_relative_path_tcancelled=$func_relative_path_tbindir
2677: + break
2678: + fi
2679: + func_relative_path_result=../$func_relative_path_result
2680: + ;;
2681: + esac
2682: + done
2683: +
2684: + # Now calculate path; take care to avoid doubling-up slashes.
2685: + func_stripname '' '/' "$func_relative_path_result"
2686: + func_relative_path_result=$func_stripname_result
2687: + func_stripname '/' '/' "$func_relative_path_tcancelled"
2688: + if test -n "$func_stripname_result"; then
2689: + func_append func_relative_path_result "/$func_stripname_result"
2690: + fi
2691: +
2692: + # Normalisation. If bindir is libdir, return '.' else relative path.
2693: + if test -n "$func_relative_path_result"; then
2694: + func_stripname './' '' "$func_relative_path_result"
2695: + func_relative_path_result=$func_stripname_result
2696: + fi
2697: +
2698: + test -n "$func_relative_path_result" || func_relative_path_result=.
2699: +
2700: + :
2701: +}
2702: +
2703: +
2704: +# func_quote_for_eval ARG...
2705: +# --------------------------
2706: +# Aesthetically quote ARGs to be evaled later.
2707: +# This function returns two values:
2708: +# i) func_quote_for_eval_result
2709: +# double-quoted, suitable for a subsequent eval
2710: +# ii) func_quote_for_eval_unquoted_result
2711: +# has all characters that are still active within double
2712: +# quotes backslashified.
2713: +func_quote_for_eval ()
2714: +{
2715: + $debug_cmd
2716: +
2717: + func_quote_for_eval_unquoted_result=
2718: + func_quote_for_eval_result=
2719: + while test 0 -lt $#; do
2720: + case $1 in
2721: + *[\\\`\"\$]*)
2722: + _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
2723: + *)
2724: + _G_unquoted_arg=$1 ;;
2725: + esac
2726: + if test -n "$func_quote_for_eval_unquoted_result"; then
2727: + func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
2728: + else
2729: + func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
2730: + fi
2731: +
2732: + case $_G_unquoted_arg in
2733: + # Double-quote args containing shell metacharacters to delay
2734: + # word splitting, command substitution and variable expansion
2735: + # for a subsequent eval.
2736: + # Many Bourne shells cannot handle close brackets correctly
2737: + # in scan sets, so we specify it separately.
2738: + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
2739: + _G_quoted_arg=\"$_G_unquoted_arg\"
2740: + ;;
2741: + *)
2742: + _G_quoted_arg=$_G_unquoted_arg
2743: + ;;
2744: + esac
2745: +
2746: + if test -n "$func_quote_for_eval_result"; then
2747: + func_append func_quote_for_eval_result " $_G_quoted_arg"
2748: + else
2749: + func_append func_quote_for_eval_result "$_G_quoted_arg"
2750: + fi
2751: + shift
2752: + done
2753: +}
2754: +
2755: +
2756: +# func_quote_for_expand ARG
2757: +# -------------------------
2758: +# Aesthetically quote ARG to be evaled later; same as above,
2759: +# but do not quote variable references.
2760: +func_quote_for_expand ()
2761: +{
2762: + $debug_cmd
2763: +
2764: + case $1 in
2765: + *[\\\`\"]*)
2766: + _G_arg=`$ECHO "$1" | $SED \
2767: + -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
2768: + *)
2769: + _G_arg=$1 ;;
2770: + esac
2771: +
2772: + case $_G_arg in
2773: + # Double-quote args containing shell metacharacters to delay
2774: + # word splitting and command substitution for a subsequent eval.
2775: + # Many Bourne shells cannot handle close brackets correctly
2776: + # in scan sets, so we specify it separately.
2777: + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
2778: + _G_arg=\"$_G_arg\"
2779: + ;;
2780: + esac
2781: +
2782: + func_quote_for_expand_result=$_G_arg
2783: +}
2784: +
2785: +
2786: +# func_stripname PREFIX SUFFIX NAME
2787: +# ---------------------------------
2788: +# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
2789: +# PREFIX and SUFFIX must not contain globbing or regex special
2790: +# characters, hashes, percent signs, but SUFFIX may contain a leading
2791: +# dot (in which case that matches only a dot).
2792: +if test yes = "$_G_HAVE_XSI_OPS"; then
2793: + eval 'func_stripname ()
2794: + {
2795: + $debug_cmd
2796: +
2797: + # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
2798: + # positional parameters, so assign one to ordinary variable first.
2799: + func_stripname_result=$3
2800: + func_stripname_result=${func_stripname_result#"$1"}
2801: + func_stripname_result=${func_stripname_result%"$2"}
2802: + }'
2803: +else
2804: + func_stripname ()
2805: + {
2806: + $debug_cmd
2807: +
2808: + case $2 in
2809: + .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
2810: + *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
2811: + esac
2812: + }
2813: +fi
2814: +
2815: +
2816: +# func_show_eval CMD [FAIL_EXP]
2817: +# -----------------------------
2818: +# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
2819: +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
2820: +# is given, then evaluate it.
2821: +func_show_eval ()
2822: +{
2823: + $debug_cmd
2824: +
2825: + _G_cmd=$1
2826: + _G_fail_exp=${2-':'}
2827: +
2828: + func_quote_for_expand "$_G_cmd"
2829: + eval "func_notquiet $func_quote_for_expand_result"
2830: +
2831: + $opt_dry_run || {
2832: + eval "$_G_cmd"
2833: + _G_status=$?
2834: + if test 0 -ne "$_G_status"; then
2835: + eval "(exit $_G_status); $_G_fail_exp"
2836: + fi
2837: + }
2838: +}
2839: +
2840: +
2841: +# func_show_eval_locale CMD [FAIL_EXP]
2842: +# ------------------------------------
2843: +# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
2844: +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
2845: +# is given, then evaluate it. Use the saved locale for evaluation.
2846: +func_show_eval_locale ()
2847: +{
2848: + $debug_cmd
2849: +
2850: + _G_cmd=$1
2851: + _G_fail_exp=${2-':'}
2852: +
2853: + $opt_quiet || {
2854: + func_quote_for_expand "$_G_cmd"
2855: + eval "func_echo $func_quote_for_expand_result"
2856: + }
2857: +
2858: + $opt_dry_run || {
2859: + eval "$_G_user_locale
2860: + $_G_cmd"
2861: + _G_status=$?
2862: + eval "$_G_safe_locale"
2863: + if test 0 -ne "$_G_status"; then
2864: + eval "(exit $_G_status); $_G_fail_exp"
2865: + fi
2866: + }
2867: +}
2868: +
2869: +
2870: +# func_tr_sh
2871: +# ----------
2872: +# Turn $1 into a string suitable for a shell variable name.
2873: +# Result is stored in $func_tr_sh_result. All characters
2874: +# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
2875: +# if $1 begins with a digit, a '_' is prepended as well.
2876: +func_tr_sh ()
2877: +{
2878: + $debug_cmd
2879: +
2880: + case $1 in
2881: + [0-9]* | *[!a-zA-Z0-9_]*)
2882: + func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
2883: + ;;
2884: + * )
2885: + func_tr_sh_result=$1
2886: + ;;
2887: + esac
2888: +}
2889: +
2890: +
2891: +# func_verbose ARG...
2892: +# -------------------
2893: +# Echo program name prefixed message in verbose mode only.
2894: +func_verbose ()
2895: +{
2896: + $debug_cmd
2897: +
2898: + $opt_verbose && func_echo "$*"
2899: +
2900: + :
2901: +}
2902: +
2903: +
2904: +# func_warn_and_continue ARG...
2905: +# -----------------------------
2906: +# Echo program name prefixed warning message to standard error.
2907: +func_warn_and_continue ()
2908: +{
2909: + $debug_cmd
2910: +
2911: + $require_term_colors
2912: +
2913: + func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
2914: +}
2915: +
2916: +
2917: +# func_warning CATEGORY ARG...
2918: +# ----------------------------
2919: +# Echo program name prefixed warning message to standard error. Warning
2920: +# messages can be filtered according to CATEGORY, where this function
2921: +# elides messages where CATEGORY is not listed in the global variable
2922: +# 'opt_warning_types'.
2923: +func_warning ()
2924: +{
2925: + $debug_cmd
2926: +
2927: + # CATEGORY must be in the warning_categories list!
2928: + case " $warning_categories " in
2929: + *" $1 "*) ;;
2930: + *) func_internal_error "invalid warning category '$1'" ;;
2931: + esac
2932: +
2933: + _G_category=$1
2934: + shift
2935: +
2936: + case " $opt_warning_types " in
2937: + *" $_G_category "*) $warning_func ${1+"$@"} ;;
2938: + esac
2939: +}
2940: +
2941: +
2942: +# func_sort_ver VER1 VER2
2943: +# -----------------------
2944: +# 'sort -V' is not generally available.
2945: +# Note this deviates from the version comparison in automake
2946: +# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
2947: +# but this should suffice as we won't be specifying old
2948: +# version formats or redundant trailing .0 in bootstrap.conf.
2949: +# If we did want full compatibility then we should probably
2950: +# use m4_version_compare from autoconf.
2951: +func_sort_ver ()
2952: +{
2953: + $debug_cmd
2954: +
2955: + printf '%s\n%s\n' "$1" "$2" \
2956: + | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
2957: +}
2958: +
2959: +# func_lt_ver PREV CURR
2960: +# ---------------------
2961: +# Return true if PREV and CURR are in the correct order according to
2962: +# func_sort_ver, otherwise false. Use it like this:
2963: +#
2964: +# func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
2965: +func_lt_ver ()
2966: +{
2967: + $debug_cmd
2968: +
2969: + test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
2970: +}
2971: +
2972: +
2973: +# Local variables:
2974: +# mode: shell-script
2975: +# sh-indentation: 2
2976: +# eval: (add-hook 'before-save-hook 'time-stamp)
2977: +# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
2978: +# time-stamp-time-zone: "UTC"
2979: +# End:
2980: +#! /bin/sh
2981: +
2982: +# Set a version string for this script.
2983: +scriptversion=2014-01-07.03; # UTC
2984: +
2985: +# A portable, pluggable option parser for Bourne shell.
2986: +# Written by Gary V. Vaughan, 2010
2987: +
2988: +# Copyright (C) 2010-2015 Free Software Foundation, Inc.
2989: +# This is free software; see the source for copying conditions. There is NO
2990: +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
2991: +
2992: +# This program is free software: you can redistribute it and/or modify
2993: +# it under the terms of the GNU General Public License as published by
2994: +# the Free Software Foundation, either version 3 of the License, or
2995: +# (at your option) any later version.
2996: +
2997: +# This program is distributed in the hope that it will be useful,
2998: +# but WITHOUT ANY WARRANTY; without even the implied warranty of
2999: +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3000: +# GNU General Public License for more details.
3001: +
3002: +# You should have received a copy of the GNU General Public License
3003: +# along with this program. If not, see <http://www.gnu.org/licenses/>.
3004: +
3005: +# Please report bugs or propose patches to gary@gnu.org.
3006: +
3007: +
3008: +## ------ ##
3009: +## Usage. ##
3010: +## ------ ##
3011: +
3012: +# This file is a library for parsing options in your shell scripts along
3013: +# with assorted other useful supporting features that you can make use
3014: +# of too.
3015: +#
3016: +# For the simplest scripts you might need only:
3017: +#
3018: +# #!/bin/sh
3019: +# . relative/path/to/funclib.sh
3020: +# . relative/path/to/options-parser
3021: +# scriptversion=1.0
3022: +# func_options ${1+"$@"}
3023: +# eval set dummy "$func_options_result"; shift
3024: +# ...rest of your script...
3025: +#
3026: +# In order for the '--version' option to work, you will need to have a
3027: +# suitably formatted comment like the one at the top of this file
3028: +# starting with '# Written by ' and ending with '# warranty; '.
3029: +#
3030: +# For '-h' and '--help' to work, you will also need a one line
3031: +# description of your script's purpose in a comment directly above the
3032: +# '# Written by ' line, like the one at the top of this file.
3033: +#
3034: +# The default options also support '--debug', which will turn on shell
3035: +# execution tracing (see the comment above debug_cmd below for another
3036: +# use), and '--verbose' and the func_verbose function to allow your script
3037: +# to display verbose messages only when your user has specified
3038: +# '--verbose'.
3039: +#
3040: +# After sourcing this file, you can plug processing for additional
3041: +# options by amending the variables from the 'Configuration' section
3042: +# below, and following the instructions in the 'Option parsing'
3043: +# section further down.
3044: +
3045: +## -------------- ##
3046: +## Configuration. ##
3047: +## -------------- ##
3048: +
3049: +# You should override these variables in your script after sourcing this
3050: +# file so that they reflect the customisations you have added to the
3051: +# option parser.
3052: +
3053: +# The usage line for option parsing errors and the start of '-h' and
3054: +# '--help' output messages. You can embed shell variables for delayed
3055: +# expansion at the time the message is displayed, but you will need to
3056: +# quote other shell meta-characters carefully to prevent them being
3057: +# expanded when the contents are evaled.
3058: +usage='$progpath [OPTION]...'
3059: +
3060: +# Short help message in response to '-h' and '--help'. Add to this or
3061: +# override it after sourcing this library to reflect the full set of
3062: +# options your script accepts.
3063: +usage_message="\
3064: + --debug enable verbose shell tracing
3065: + -W, --warnings=CATEGORY
3066: + report the warnings falling in CATEGORY [all]
3067: + -v, --verbose verbosely report processing
3068: + --version print version information and exit
3069: + -h, --help print short or long help message and exit
3070: +"
3071: +
3072: +# Additional text appended to 'usage_message' in response to '--help'.
3073: +long_help_message="
3074: +Warning categories include:
3075: + 'all' show all warnings
3076: + 'none' turn off all the warnings
3077: + 'error' warnings are treated as fatal errors"
3078: +
3079: +# Help message printed before fatal option parsing errors.
3080: +fatal_help="Try '\$progname --help' for more information."
3081: +
3082: +
3083: +
3084: +## ------------------------- ##
3085: +## Hook function management. ##
3086: +## ------------------------- ##
3087: +
3088: +# This section contains functions for adding, removing, and running hooks
3089: +# to the main code. A hook is just a named list of of function, that can
3090: +# be run in order later on.
3091: +
3092: +# func_hookable FUNC_NAME
3093: +# -----------------------
3094: +# Declare that FUNC_NAME will run hooks added with
3095: +# 'func_add_hook FUNC_NAME ...'.
3096: +func_hookable ()
3097: +{
3098: + $debug_cmd
3099: +
3100: + func_append hookable_fns " $1"
3101: +}
3102: +
3103: +
3104: +# func_add_hook FUNC_NAME HOOK_FUNC
3105: +# ---------------------------------
3106: +# Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must
3107: +# first have been declared "hookable" by a call to 'func_hookable'.
3108: +func_add_hook ()
3109: +{
3110: + $debug_cmd
3111: +
3112: + case " $hookable_fns " in
3113: + *" $1 "*) ;;
3114: + *) func_fatal_error "'$1' does not accept hook functions." ;;
3115: + esac
3116: +
3117: + eval func_append ${1}_hooks '" $2"'
3118: +}
3119: +
3120: +
3121: +# func_remove_hook FUNC_NAME HOOK_FUNC
3122: +# ------------------------------------
3123: +# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
3124: +func_remove_hook ()
3125: +{
3126: + $debug_cmd
3127: +
3128: + eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
3129: +}
3130: +
3131: +
3132: +# func_run_hooks FUNC_NAME [ARG]...
3133: +# ---------------------------------
3134: +# Run all hook functions registered to FUNC_NAME.
3135: +# It is assumed that the list of hook functions contains nothing more
3136: +# than a whitespace-delimited list of legal shell function names, and
3137: +# no effort is wasted trying to catch shell meta-characters or preserve
3138: +# whitespace.
3139: +func_run_hooks ()
3140: +{
3141: + $debug_cmd
3142: +
3143: + case " $hookable_fns " in
3144: + *" $1 "*) ;;
3145: + *) func_fatal_error "'$1' does not support hook funcions.n" ;;
3146: + esac
3147: +
3148: + eval _G_hook_fns=\$$1_hooks; shift
3149: +
3150: + for _G_hook in $_G_hook_fns; do
3151: + eval $_G_hook '"$@"'
3152: +
3153: + # store returned options list back into positional
3154: + # parameters for next 'cmd' execution.
3155: + eval _G_hook_result=\$${_G_hook}_result
3156: + eval set dummy "$_G_hook_result"; shift
3157: + done
3158: +
3159: + func_quote_for_eval ${1+"$@"}
3160: + func_run_hooks_result=$func_quote_for_eval_result
3161: +}
3162: +
3163: +
3164: +
3165: +## --------------- ##
3166: +## Option parsing. ##
3167: +## --------------- ##
3168: +
3169: +# In order to add your own option parsing hooks, you must accept the
3170: +# full positional parameter list in your hook function, remove any
3171: +# options that you action, and then pass back the remaining unprocessed
3172: +# options in '<hooked_function_name>_result', escaped suitably for
3173: +# 'eval'. Like this:
3174: +#
3175: +# my_options_prep ()
3176: +# {
3177: +# $debug_cmd
3178: +#
3179: +# # Extend the existing usage message.
3180: +# usage_message=$usage_message'
3181: +# -s, --silent don'\''t print informational messages
3182: +# '
3183: +#
3184: +# func_quote_for_eval ${1+"$@"}
3185: +# my_options_prep_result=$func_quote_for_eval_result
3186: +# }
3187: +# func_add_hook func_options_prep my_options_prep
3188: +#
3189: +#
3190: +# my_silent_option ()
3191: +# {
3192: +# $debug_cmd
3193: +#
3194: +# # Note that for efficiency, we parse as many options as we can
3195: +# # recognise in a loop before passing the remainder back to the
3196: +# # caller on the first unrecognised argument we encounter.
3197: +# while test $# -gt 0; do
3198: +# opt=$1; shift
3199: +# case $opt in
3200: +# --silent|-s) opt_silent=: ;;
3201: +# # Separate non-argument short options:
3202: +# -s*) func_split_short_opt "$_G_opt"
3203: +# set dummy "$func_split_short_opt_name" \
3204: +# "-$func_split_short_opt_arg" ${1+"$@"}
3205: +# shift
3206: +# ;;
3207: +# *) set dummy "$_G_opt" "$*"; shift; break ;;
3208: +# esac
3209: +# done
3210: +#
3211: +# func_quote_for_eval ${1+"$@"}
3212: +# my_silent_option_result=$func_quote_for_eval_result
3213: +# }
3214: +# func_add_hook func_parse_options my_silent_option
3215: +#
3216: +#
3217: +# my_option_validation ()
3218: +# {
3219: +# $debug_cmd
3220: +#
3221: +# $opt_silent && $opt_verbose && func_fatal_help "\
3222: +# '--silent' and '--verbose' options are mutually exclusive."
3223: +#
3224: +# func_quote_for_eval ${1+"$@"}
3225: +# my_option_validation_result=$func_quote_for_eval_result
3226: +# }
3227: +# func_add_hook func_validate_options my_option_validation
3228: +#
3229: +# You'll alse need to manually amend $usage_message to reflect the extra
3230: +# options you parse. It's preferable to append if you can, so that
3231: +# multiple option parsing hooks can be added safely.
3232: +
3233: +
3234: +# func_options [ARG]...
3235: +# ---------------------
3236: +# All the functions called inside func_options are hookable. See the
3237: +# individual implementations for details.
3238: +func_hookable func_options
3239: +func_options ()
3240: +{
3241: + $debug_cmd
3242: +
3243: + func_options_prep ${1+"$@"}
3244: + eval func_parse_options \
3245: + ${func_options_prep_result+"$func_options_prep_result"}
3246: + eval func_validate_options \
3247: + ${func_parse_options_result+"$func_parse_options_result"}
3248: +
3249: + eval func_run_hooks func_options \
3250: + ${func_validate_options_result+"$func_validate_options_result"}
3251: +
3252: + # save modified positional parameters for caller
3253: + func_options_result=$func_run_hooks_result
3254: +}
3255: +
3256: +
3257: +# func_options_prep [ARG]...
3258: +# --------------------------
3259: +# All initialisations required before starting the option parse loop.
3260: +# Note that when calling hook functions, we pass through the list of
3261: +# positional parameters. If a hook function modifies that list, and
3262: +# needs to propogate that back to rest of this script, then the complete
3263: +# modified list must be put in 'func_run_hooks_result' before
3264: +# returning.
3265: +func_hookable func_options_prep
3266: +func_options_prep ()
3267: +{
3268: + $debug_cmd
3269: +
3270: + # Option defaults:
3271: + opt_verbose=false
3272: + opt_warning_types=
3273: +
3274: + func_run_hooks func_options_prep ${1+"$@"}
3275: +
3276: + # save modified positional parameters for caller
3277: + func_options_prep_result=$func_run_hooks_result
3278: +}
3279: +
3280: +
3281: +# func_parse_options [ARG]...
3282: +# ---------------------------
3283: +# The main option parsing loop.
3284: +func_hookable func_parse_options
3285: +func_parse_options ()
3286: +{
3287: + $debug_cmd
3288: +
3289: + func_parse_options_result=
3290: +
3291: + # this just eases exit handling
3292: + while test $# -gt 0; do
3293: + # Defer to hook functions for initial option parsing, so they
3294: + # get priority in the event of reusing an option name.
3295: + func_run_hooks func_parse_options ${1+"$@"}
3296: +
3297: + # Adjust func_parse_options positional parameters to match
3298: + eval set dummy "$func_run_hooks_result"; shift
3299: +
3300: + # Break out of the loop if we already parsed every option.
3301: + test $# -gt 0 || break
3302: +
3303: + _G_opt=$1
3304: + shift
3305: + case $_G_opt in
3306: + --debug|-x) debug_cmd='set -x'
3307: + func_echo "enabling shell trace mode"
3308: + $debug_cmd
3309: + ;;
3310: +
3311: + --no-warnings|--no-warning|--no-warn)
3312: + set dummy --warnings none ${1+"$@"}
3313: + shift
3314: + ;;
3315: +
3316: + --warnings|--warning|-W)
3317: + test $# = 0 && func_missing_arg $_G_opt && break
3318: + case " $warning_categories $1" in
3319: + *" $1 "*)
3320: + # trailing space prevents matching last $1 above
3321: + func_append_uniq opt_warning_types " $1"
3322: + ;;
3323: + *all)
3324: + opt_warning_types=$warning_categories
3325: + ;;
3326: + *none)
3327: + opt_warning_types=none
3328: + warning_func=:
3329: + ;;
3330: + *error)
3331: + opt_warning_types=$warning_categories
3332: + warning_func=func_fatal_error
3333: + ;;
3334: + *)
3335: + func_fatal_error \
3336: + "unsupported warning category: '$1'"
3337: + ;;
3338: + esac
3339: + shift
3340: + ;;
3341: +
3342: + --verbose|-v) opt_verbose=: ;;
3343: + --version) func_version ;;
3344: + -\?|-h) func_usage ;;
3345: + --help) func_help ;;
3346: +
3347: + # Separate optargs to long options (plugins may need this):
3348: + --*=*) func_split_equals "$_G_opt"
3349: + set dummy "$func_split_equals_lhs" \
3350: + "$func_split_equals_rhs" ${1+"$@"}
3351: + shift
3352: + ;;
3353: +
3354: + # Separate optargs to short options:
3355: + -W*)
3356: + func_split_short_opt "$_G_opt"
3357: + set dummy "$func_split_short_opt_name" \
3358: + "$func_split_short_opt_arg" ${1+"$@"}
3359: + shift
3360: + ;;
3361: +
3362: + # Separate non-argument short options:
3363: + -\?*|-h*|-v*|-x*)
3364: + func_split_short_opt "$_G_opt"
3365: + set dummy "$func_split_short_opt_name" \
3366: + "-$func_split_short_opt_arg" ${1+"$@"}
3367: + shift
3368: + ;;
3369: +
3370: + --) break ;;
3371: + -*) func_fatal_help "unrecognised option: '$_G_opt'" ;;
3372: + *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
3373: + esac
3374: + done
3375: +
3376: + # save modified positional parameters for caller
3377: + func_quote_for_eval ${1+"$@"}
3378: + func_parse_options_result=$func_quote_for_eval_result
3379: +}
3380: +
3381: +
3382: +# func_validate_options [ARG]...
3383: +# ------------------------------
3384: +# Perform any sanity checks on option settings and/or unconsumed
3385: +# arguments.
3386: +func_hookable func_validate_options
3387: +func_validate_options ()
3388: +{
3389: + $debug_cmd
3390: +
3391: + # Display all warnings if -W was not given.
3392: + test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
3393: +
3394: + func_run_hooks func_validate_options ${1+"$@"}
3395: +
3396: + # Bail if the options were screwed!
3397: + $exit_cmd $EXIT_FAILURE
3398: +
3399: + # save modified positional parameters for caller
3400: + func_validate_options_result=$func_run_hooks_result
3401: +}
3402: +
3403: +
3404: +
3405: +## ----------------- ##
3406: +## Helper functions. ##
3407: +## ----------------- ##
3408: +
3409: +# This section contains the helper functions used by the rest of the
3410: +# hookable option parser framework in ascii-betical order.
3411: +
3412: +
3413: +# func_fatal_help ARG...
3414: +# ----------------------
3415: +# Echo program name prefixed message to standard error, followed by
3416: +# a help hint, and exit.
3417: +func_fatal_help ()
3418: +{
3419: + $debug_cmd
3420: +
3421: + eval \$ECHO \""Usage: $usage"\"
3422: + eval \$ECHO \""$fatal_help"\"
3423: + func_error ${1+"$@"}
3424: + exit $EXIT_FAILURE
3425: +}
3426: +
3427: +
3428: +# func_help
3429: +# ---------
3430: +# Echo long help message to standard output and exit.
3431: +func_help ()
3432: +{
3433: + $debug_cmd
3434: +
3435: + func_usage_message
3436: + $ECHO "$long_help_message"
3437: + exit 0
3438: +}
3439: +
3440: +
3441: +# func_missing_arg ARGNAME
3442: +# ------------------------
3443: +# Echo program name prefixed message to standard error and set global
3444: +# exit_cmd.
3445: +func_missing_arg ()
3446: +{
3447: + $debug_cmd
3448: +
3449: + func_error "Missing argument for '$1'."
3450: + exit_cmd=exit
3451: +}
3452: +
3453: +
3454: +# func_split_equals STRING
3455: +# ------------------------
3456: +# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
3457: +# splitting STRING at the '=' sign.
3458: +test -z "$_G_HAVE_XSI_OPS" \
3459: + && (eval 'x=a/b/c;
3460: + test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
3461: + && _G_HAVE_XSI_OPS=yes
3462: +
3463: +if test yes = "$_G_HAVE_XSI_OPS"
3464: +then
3465: + # This is an XSI compatible shell, allowing a faster implementation...
3466: + eval 'func_split_equals ()
3467: + {
3468: + $debug_cmd
3469: +
3470: + func_split_equals_lhs=${1%%=*}
3471: + func_split_equals_rhs=${1#*=}
3472: + test "x$func_split_equals_lhs" = "x$1" \
3473: + && func_split_equals_rhs=
3474: + }'
3475: +else
3476: + # ...otherwise fall back to using expr, which is often a shell builtin.
3477: + func_split_equals ()
3478: + {
3479: + $debug_cmd
3480: +
3481: + func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
3482: + func_split_equals_rhs=
3483: + test "x$func_split_equals_lhs" = "x$1" \
3484: + || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
3485: + }
3486: +fi #func_split_equals
3487: +
3488: +
3489: +# func_split_short_opt SHORTOPT
3490: +# -----------------------------
3491: +# Set func_split_short_opt_name and func_split_short_opt_arg shell
3492: +# variables after splitting SHORTOPT after the 2nd character.
3493: +if test yes = "$_G_HAVE_XSI_OPS"
3494: +then
3495: + # This is an XSI compatible shell, allowing a faster implementation...
3496: + eval 'func_split_short_opt ()
3497: + {
3498: + $debug_cmd
3499: +
3500: + func_split_short_opt_arg=${1#??}
3501: + func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
3502: + }'
3503: +else
3504: + # ...otherwise fall back to using expr, which is often a shell builtin.
3505: + func_split_short_opt ()
3506: + {
3507: + $debug_cmd
3508: +
3509: + func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
3510: + func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
3511: + }
3512: +fi #func_split_short_opt
3513: +
3514: +
3515: +# func_usage
3516: +# ----------
3517: +# Echo short help message to standard output and exit.
3518: +func_usage ()
3519: +{
3520: + $debug_cmd
3521: +
3522: + func_usage_message
3523: + $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
3524: + exit 0
3525: +}
3526: +
3527: +
3528: +# func_usage_message
3529: +# ------------------
3530: +# Echo short help message to standard output.
3531: +func_usage_message ()
3532: +{
3533: + $debug_cmd
3534: +
3535: + eval \$ECHO \""Usage: $usage"\"
3536: + echo
3537: + $SED -n 's|^# ||
3538: + /^Written by/{
3539: + x;p;x
3540: + }
3541: + h
3542: + /^Written by/q' < "$progpath"
3543: + echo
3544: + eval \$ECHO \""$usage_message"\"
3545: +}
3546: +
3547: +
3548: +# func_version
3549: +# ------------
3550: +# Echo version message to standard output and exit.
3551: +func_version ()
3552: +{
3553: + $debug_cmd
3554: +
3555: + printf '%s\n' "$progname $scriptversion"
3556: + $SED -n '
3557: + /(C)/!b go
3558: + :more
3559: + /\./!{
3560: + N
3561: + s|\n# | |
3562: + b more
3563: + }
3564: + :go
3565: + /^# Written by /,/# warranty; / {
3566: + s|^# ||
3567: + s|^# *$||
3568: + s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
3569: + p
3570: + }
3571: + /^# Written by / {
3572: + s|^# ||
3573: + p
3574: + }
3575: + /^warranty; /q' < "$progpath"
3576: +
3577: + exit $?
3578: +}
3579: +
3580: +
3581: +# Local variables:
3582: +# mode: shell-script
3583: +# sh-indentation: 2
3584: +# eval: (add-hook 'before-save-hook 'time-stamp)
3585: +# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
3586: +# time-stamp-time-zone: "UTC"
3587: +# End:
3588: +
3589: +# Set a version string.
3590: +scriptversion='(GNU libtool) 2.4.6'
3591: +
3592: +
3593: +# func_echo ARG...
3594: +# ----------------
3595: +# Libtool also displays the current mode in messages, so override
3596: +# funclib.sh func_echo with this custom definition.
3597: +func_echo ()
3598: +{
3599: + $debug_cmd
3600: +
3601: + _G_message=$*
3602: +
3603: + func_echo_IFS=$IFS
3604: + IFS=$nl
3605: + for _G_line in $_G_message; do
3606: + IFS=$func_echo_IFS
3607: + $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
3608: + done
3609: + IFS=$func_echo_IFS
3610: +}
3611: +
3612: +
3613: +# func_warning ARG...
3614: +# -------------------
3615: +# Libtool warnings are not categorized, so override funclib.sh
3616: +# func_warning with this simpler definition.
3617: +func_warning ()
3618: +{
3619: + $debug_cmd
3620: +
3621: + $warning_func ${1+"$@"}
3622: +}
3623: +
3624: +
3625: +## ---------------- ##
3626: +## Options parsing. ##
3627: +## ---------------- ##
3628: +
3629: +# Hook in the functions to make sure our own options are parsed during
3630: +# the option parsing loop.
3631: +
3632: +usage='$progpath [OPTION]... [MODE-ARG]...'
3633: +
3634: +# Short help message in response to '-h'.
3635: +usage_message="Options:
3636: + --config show all configuration variables
3637: + --debug enable verbose shell tracing
3638: + -n, --dry-run display commands without modifying any files
3639: + --features display basic configuration information and exit
3640: + --mode=MODE use operation mode MODE
3641: + --no-warnings equivalent to '-Wnone'
3642: + --preserve-dup-deps don't remove duplicate dependency libraries
3643: + --quiet, --silent don't print informational messages
3644: + --tag=TAG use configuration variables from tag TAG
3645: + -v, --verbose print more informational messages than default
3646: + --version print version information
3647: + -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all]
3648: + -h, --help, --help-all print short, long, or detailed help message
3649: +"
3650: +
3651: +# Additional text appended to 'usage_message' in response to '--help'.
3652: +func_help ()
3653: +{
3654: + $debug_cmd
3655: +
3656: + func_usage_message
3657: + $ECHO "$long_help_message
3658: +
3659: +MODE must be one of the following:
3660: +
3661: + clean remove files from the build directory
3662: + compile compile a source file into a libtool object
3663: + execute automatically set library path, then run a program
3664: + finish complete the installation of libtool libraries
3665: + install install libraries or executables
3666: + link create a library or an executable
3667: + uninstall remove libraries from an installed directory
3668: +
3669: +MODE-ARGS vary depending on the MODE. When passed as first option,
3670: +'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
3671: +Try '$progname --help --mode=MODE' for a more detailed description of MODE.
3672: +
3673: +When reporting a bug, please describe a test case to reproduce it and
3674: +include the following information:
3675: +
3676: + host-triplet: $host
3677: + shell: $SHELL
3678: + compiler: $LTCC
3679: + compiler flags: $LTCFLAGS
3680: + linker: $LD (gnu? $with_gnu_ld)
3681: + version: $progname (GNU libtool) 2.4.6
3682: + automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
3683: + autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q`
3684: +
3685: +Report bugs to <bug-libtool@gnu.org>.
3686: +GNU libtool home page: <http://www.gnu.org/software/libtool/>.
3687: +General help using GNU software: <http://www.gnu.org/gethelp/>."
3688: + exit 0
3689: +}
3690: +
3691: +
3692: +# func_lo2o OBJECT-NAME
3693: +# ---------------------
3694: +# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
3695: +# object suffix.
3696: +
3697: +lo2o=s/\\.lo\$/.$objext/
3698: +o2lo=s/\\.$objext\$/.lo/
3699: +
3700: +if test yes = "$_G_HAVE_XSI_OPS"; then
3701: + eval 'func_lo2o ()
3702: + {
3703: + case $1 in
3704: + *.lo) func_lo2o_result=${1%.lo}.$objext ;;
3705: + * ) func_lo2o_result=$1 ;;
3706: + esac
3707: + }'
3708: +
3709: + # func_xform LIBOBJ-OR-SOURCE
3710: + # ---------------------------
3711: + # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
3712: + # suffix to a '.lo' libtool-object suffix.
3713: + eval 'func_xform ()
3714: + {
3715: + func_xform_result=${1%.*}.lo
3716: + }'
3717: +else
3718: + # ...otherwise fall back to using sed.
3719: + func_lo2o ()
3720: + {
3721: + func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
3722: + }
3723: +
3724: + func_xform ()
3725: + {
3726: + func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
3727: + }
3728: +fi
3729: +
3730: +
3731: +# func_fatal_configuration ARG...
3732: +# -------------------------------
3733: +# Echo program name prefixed message to standard error, followed by
3734: +# a configuration failure hint, and exit.
3735: +func_fatal_configuration ()
3736: +{
3737: + func__fatal_error ${1+"$@"} \
3738: + "See the $PACKAGE documentation for more information." \
3739: + "Fatal configuration error."
3740: +}
3741: +
3742: +
3743: +# func_config
3744: +# -----------
3745: +# Display the configuration for all the tags in this script.
3746: +func_config ()
3747: +{
3748: + re_begincf='^# ### BEGIN LIBTOOL'
3749: + re_endcf='^# ### END LIBTOOL'
3750: +
3751: + # Default configuration.
3752: + $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
3753: +
3754: + # Now print the configurations for the tags.
3755: + for tagname in $taglist; do
3756: + $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
3757: + done
3758: +
3759: + exit $?
3760: +}
3761: +
3762: +
3763: +# func_features
3764: +# -------------
3765: +# Display the features supported by this script.
3766: +func_features ()
3767: +{
3768: + echo "host: $host"
3769: + if test yes = "$build_libtool_libs"; then
3770: + echo "enable shared libraries"
3771: + else
3772: + echo "disable shared libraries"
3773: + fi
3774: + if test yes = "$build_old_libs"; then
3775: + echo "enable static libraries"
3776: + else
3777: + echo "disable static libraries"
3778: + fi
3779: +
3780: + exit $?
3781: +}
3782: +
3783: +
3784: +# func_enable_tag TAGNAME
3785: +# -----------------------
3786: +# Verify that TAGNAME is valid, and either flag an error and exit, or
3787: +# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
3788: +# variable here.
3789: +func_enable_tag ()
3790: +{
3791: + # Global variable:
3792: + tagname=$1
3793: +
3794: + re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
3795: + re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
3796: + sed_extractcf=/$re_begincf/,/$re_endcf/p
3797: +
3798: + # Validate tagname.
3799: + case $tagname in
3800: + *[!-_A-Za-z0-9,/]*)
3801: + func_fatal_error "invalid tag name: $tagname"
3802: + ;;
3803: + esac
3804: +
3805: + # Don't test for the "default" C tag, as we know it's
3806: + # there but not specially marked.
3807: + case $tagname in
3808: + CC) ;;
3809: + *)
3810: + if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
3811: + taglist="$taglist $tagname"
3812: +
3813: + # Evaluate the configuration. Be careful to quote the path
3814: + # and the sed script, to avoid splitting on whitespace, but
3815: + # also don't use non-portable quotes within backquotes within
3816: + # quotes we have to do it in 2 steps:
3817: + extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
3818: + eval "$extractedcf"
3819: + else
3820: + func_error "ignoring unknown tag $tagname"
3821: + fi
3822: + ;;
3823: + esac
3824: +}
3825: +
3826: +
3827: +# func_check_version_match
3828: +# ------------------------
3829: +# Ensure that we are using m4 macros, and libtool script from the same
3830: +# release of libtool.
3831: +func_check_version_match ()
3832: +{
3833: + if test "$package_revision" != "$macro_revision"; then
3834: + if test "$VERSION" != "$macro_version"; then
3835: + if test -z "$macro_version"; then
3836: + cat >&2 <<_LT_EOF
3837: +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
3838: +$progname: definition of this LT_INIT comes from an older release.
3839: +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
3840: +$progname: and run autoconf again.
3841: +_LT_EOF
3842: + else
3843: + cat >&2 <<_LT_EOF
3844: +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
3845: +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
3846: +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
3847: +$progname: and run autoconf again.
3848: +_LT_EOF
3849: + fi
3850: + else
3851: + cat >&2 <<_LT_EOF
3852: +$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
3853: +$progname: but the definition of this LT_INIT comes from revision $macro_revision.
3854: +$progname: You should recreate aclocal.m4 with macros from revision $package_revision
3855: +$progname: of $PACKAGE $VERSION and run autoconf again.
3856: +_LT_EOF
3857: + fi
3858: +
3859: + exit $EXIT_MISMATCH
3860: + fi
3861: +}
3862: +
3863: +
3864: +# libtool_options_prep [ARG]...
3865: +# -----------------------------
3866: +# Preparation for options parsed by libtool.
3867: +libtool_options_prep ()
3868: +{
3869: + $debug_mode
3870: +
3871: + # Option defaults:
3872: + opt_config=false
3873: + opt_dlopen=
3874: + opt_dry_run=false
3875: + opt_help=false
3876: + opt_mode=
3877: + opt_preserve_dup_deps=false
3878: + opt_quiet=false
3879: +
3880: + nonopt=
3881: + preserve_args=
3882: +
3883: + # Shorthand for --mode=foo, only valid as the first argument
3884: + case $1 in
3885: + clean|clea|cle|cl)
3886: + shift; set dummy --mode clean ${1+"$@"}; shift
3887: + ;;
3888: + compile|compil|compi|comp|com|co|c)
3889: + shift; set dummy --mode compile ${1+"$@"}; shift
3890: + ;;
3891: + execute|execut|execu|exec|exe|ex|e)
3892: + shift; set dummy --mode execute ${1+"$@"}; shift
3893: + ;;
3894: + finish|finis|fini|fin|fi|f)
3895: + shift; set dummy --mode finish ${1+"$@"}; shift
3896: + ;;
3897: + install|instal|insta|inst|ins|in|i)
3898: + shift; set dummy --mode install ${1+"$@"}; shift
3899: + ;;
3900: + link|lin|li|l)
3901: + shift; set dummy --mode link ${1+"$@"}; shift
3902: + ;;
3903: + uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
3904: + shift; set dummy --mode uninstall ${1+"$@"}; shift
3905: + ;;
3906: + esac
3907: +
3908: + # Pass back the list of options.
3909: + func_quote_for_eval ${1+"$@"}
3910: + libtool_options_prep_result=$func_quote_for_eval_result
3911: +}
3912: +func_add_hook func_options_prep libtool_options_prep
3913: +
3914: +
3915: +# libtool_parse_options [ARG]...
3916: +# ---------------------------------
3917: +# Provide handling for libtool specific options.
3918: +libtool_parse_options ()
3919: +{
3920: + $debug_cmd
3921: +
3922: + # Perform our own loop to consume as many options as possible in
3923: + # each iteration.
3924: + while test $# -gt 0; do
3925: + _G_opt=$1
3926: + shift
3927: + case $_G_opt in
3928: + --dry-run|--dryrun|-n)
3929: + opt_dry_run=:
3930: + ;;
3931: +
3932: + --config) func_config ;;
3933: +
3934: + --dlopen|-dlopen)
3935: + opt_dlopen="${opt_dlopen+$opt_dlopen
3936: +}$1"
3937: + shift
3938: + ;;
3939: +
3940: + --preserve-dup-deps)
3941: + opt_preserve_dup_deps=: ;;
3942: +
3943: + --features) func_features ;;
3944: +
3945: + --finish) set dummy --mode finish ${1+"$@"}; shift ;;
3946: +
3947: + --help) opt_help=: ;;
3948: +
3949: + --help-all) opt_help=': help-all' ;;
3950: +
3951: + --mode) test $# = 0 && func_missing_arg $_G_opt && break
3952: + opt_mode=$1
3953: + case $1 in
3954: + # Valid mode arguments:
3955: + clean|compile|execute|finish|install|link|relink|uninstall) ;;
3956: +
3957: + # Catch anything else as an error
3958: + *) func_error "invalid argument for $_G_opt"
3959: + exit_cmd=exit
3960: + break
3961: + ;;
3962: + esac
3963: + shift
3964: + ;;
3965: +
3966: + --no-silent|--no-quiet)
3967: + opt_quiet=false
3968: + func_append preserve_args " $_G_opt"
3969: + ;;
3970: +
3971: + --no-warnings|--no-warning|--no-warn)
3972: + opt_warning=false
3973: + func_append preserve_args " $_G_opt"
3974: + ;;
3975: +
3976: + --no-verbose)
3977: + opt_verbose=false
3978: + func_append preserve_args " $_G_opt"
3979: + ;;
3980: +
3981: + --silent|--quiet)
3982: + opt_quiet=:
3983: + opt_verbose=false
3984: + func_append preserve_args " $_G_opt"
3985: + ;;
3986: +
3987: + --tag) test $# = 0 && func_missing_arg $_G_opt && break
3988: + opt_tag=$1
3989: + func_append preserve_args " $_G_opt $1"
3990: + func_enable_tag "$1"
3991: + shift
3992: + ;;
3993: +
3994: + --verbose|-v) opt_quiet=false
3995: + opt_verbose=:
3996: + func_append preserve_args " $_G_opt"
3997: + ;;
3998: +
3999: + # An option not handled by this hook function:
4000: + *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
4001: + esac
4002: + done
4003: +
4004: +
4005: + # save modified positional parameters for caller
4006: + func_quote_for_eval ${1+"$@"}
4007: + libtool_parse_options_result=$func_quote_for_eval_result
4008: +}
4009: +func_add_hook func_parse_options libtool_parse_options
4010: +
4011: +
4012: +
4013: +# libtool_validate_options [ARG]...
4014: +# ---------------------------------
4015: +# Perform any sanity checks on option settings and/or unconsumed
4016: +# arguments.
4017: +libtool_validate_options ()
4018: +{
4019: + # save first non-option argument
4020: + if test 0 -lt $#; then
4021: + nonopt=$1
4022: + shift
4023: + fi
4024: +
4025: + # preserve --debug
4026: + test : = "$debug_cmd" || func_append preserve_args " --debug"
4027: +
4028: + case $host in
4029: + # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
4030: + # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
4031: + *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
4032: + # don't eliminate duplications in $postdeps and $predeps
4033: + opt_duplicate_compiler_generated_deps=:
4034: + ;;
4035: + *)
4036: + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
4037: + ;;
4038: + esac
4039: +
4040: + $opt_help || {
4041: + # Sanity checks first:
4042: + func_check_version_match
4043: +
4044: + test yes != "$build_libtool_libs" \
4045: + && test yes != "$build_old_libs" \
4046: + && func_fatal_configuration "not configured to build any kind of library"
4047: +
4048: + # Darwin sucks
4049: + eval std_shrext=\"$shrext_cmds\"
4050: +
4051: + # Only execute mode is allowed to have -dlopen flags.
4052: + if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
4053: + func_error "unrecognized option '-dlopen'"
4054: + $ECHO "$help" 1>&2
4055: + exit $EXIT_FAILURE
4056: + fi
4057: +
4058: + # Change the help message to a mode-specific one.
4059: + generic_help=$help
4060: + help="Try '$progname --help --mode=$opt_mode' for more information."
4061: + }
4062: +
4063: + # Pass back the unparsed argument list
4064: + func_quote_for_eval ${1+"$@"}
4065: + libtool_validate_options_result=$func_quote_for_eval_result
4066: +}
4067: +func_add_hook func_validate_options libtool_validate_options
4068: +
4069: +
4070: +# Process options as early as possible so that --help and --version
4071: +# can return quickly.
4072: +func_options ${1+"$@"}
4073: +eval set dummy "$func_options_result"; shift
4074: +
4075: +
4076: +
4077: +## ----------- ##
4078: +## Main. ##
4079: +## ----------- ##
4080: +
4081: +magic='%%%MAGIC variable%%%'
4082: +magic_exe='%%%MAGIC EXE variable%%%'
4083: +
4084: +# Global variables.
4085: +extracted_archives=
4086: +extracted_serial=0
4087: +
4088: +# If this variable is set in any of the actions, the command in it
4089: +# will be execed at the end. This prevents here-documents from being
4090: +# left over by shells.
4091: +exec_cmd=
4092: +
4093: +
4094: +# A function that is used when there is no print builtin or printf.
4095: +func_fallback_echo ()
4096: +{
4097: + eval 'cat <<_LTECHO_EOF
4098: +$1
4099: +_LTECHO_EOF'
4100: +}
4101: +
4102: +# func_generated_by_libtool
4103: +# True iff stdin has been generated by Libtool. This function is only
4104: +# a basic sanity check; it will hardly flush out determined imposters.
4105: +func_generated_by_libtool_p ()
4106: +{
4107: + $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
4108: +}
4109: +
4110: +# func_lalib_p file
4111: +# True iff FILE is a libtool '.la' library or '.lo' object file.
4112: +# This function is only a basic sanity check; it will hardly flush out
4113: +# determined imposters.
4114: +func_lalib_p ()
4115: +{
4116: + test -f "$1" &&
4117: + $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
4118: +}
4119: +
4120: +# func_lalib_unsafe_p file
4121: +# True iff FILE is a libtool '.la' library or '.lo' object file.
4122: +# This function implements the same check as func_lalib_p without
4123: +# resorting to external programs. To this end, it redirects stdin and
4124: +# closes it afterwards, without saving the original file descriptor.
4125: +# As a safety measure, use it only where a negative result would be
4126: +# fatal anyway. Works if 'file' does not exist.
4127: +func_lalib_unsafe_p ()
4128: +{
4129: + lalib_p=no
4130: + if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
4131: + for lalib_p_l in 1 2 3 4
4132: + do
4133: + read lalib_p_line
4134: + case $lalib_p_line in
4135: + \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
4136: + esac
4137: + done
4138: + exec 0<&5 5<&-
4139: + fi
4140: + test yes = "$lalib_p"
4141: +}
4142: +
4143: +# func_ltwrapper_script_p file
4144: +# True iff FILE is a libtool wrapper script
4145: +# This function is only a basic sanity check; it will hardly flush out
4146: +# determined imposters.
4147: +func_ltwrapper_script_p ()
4148: +{
4149: + test -f "$1" &&
4150: + $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
4151: +}
4152: +
4153: +# func_ltwrapper_executable_p file
4154: +# True iff FILE is a libtool wrapper executable
4155: +# This function is only a basic sanity check; it will hardly flush out
4156: +# determined imposters.
4157: +func_ltwrapper_executable_p ()
4158: +{
4159: + func_ltwrapper_exec_suffix=
4160: + case $1 in
4161: + *.exe) ;;
4162: + *) func_ltwrapper_exec_suffix=.exe ;;
4163: + esac
4164: + $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
4165: +}
4166: +
4167: +# func_ltwrapper_scriptname file
4168: +# Assumes file is an ltwrapper_executable
4169: +# uses $file to determine the appropriate filename for a
4170: +# temporary ltwrapper_script.
4171: +func_ltwrapper_scriptname ()
4172: +{
4173: + func_dirname_and_basename "$1" "" "."
4174: + func_stripname '' '.exe' "$func_basename_result"
4175: + func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
4176: +}
4177: +
4178: +# func_ltwrapper_p file
4179: +# True iff FILE is a libtool wrapper script or wrapper executable
4180: +# This function is only a basic sanity check; it will hardly flush out
4181: +# determined imposters.
4182: +func_ltwrapper_p ()
4183: +{
4184: + func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
4185: +}
4186: +
4187: +
4188: +# func_execute_cmds commands fail_cmd
4189: +# Execute tilde-delimited COMMANDS.
4190: +# If FAIL_CMD is given, eval that upon failure.
4191: +# FAIL_CMD may read-access the current command in variable CMD!
4192: +func_execute_cmds ()
4193: +{
4194: + $debug_cmd
4195: +
4196: + save_ifs=$IFS; IFS='~'
4197: + for cmd in $1; do
4198: + IFS=$sp$nl
4199: + eval cmd=\"$cmd\"
4200: + IFS=$save_ifs
4201: + func_show_eval "$cmd" "${2-:}"
4202: + done
4203: + IFS=$save_ifs
4204: +}
4205: +
4206: +
4207: +# func_source file
4208: +# Source FILE, adding directory component if necessary.
4209: +# Note that it is not necessary on cygwin/mingw to append a dot to
4210: +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
4211: +# behavior happens only for exec(3), not for open(2)! Also, sourcing
4212: +# 'FILE.' does not work on cygwin managed mounts.
4213: +func_source ()
4214: +{
4215: + $debug_cmd
4216: +
4217: + case $1 in
4218: + */* | *\\*) . "$1" ;;
4219: + *) . "./$1" ;;
4220: + esac
4221: +}
4222: +
4223: +
4224: +# func_resolve_sysroot PATH
4225: +# Replace a leading = in PATH with a sysroot. Store the result into
4226: +# func_resolve_sysroot_result
4227: +func_resolve_sysroot ()
4228: +{
4229: + func_resolve_sysroot_result=$1
4230: + case $func_resolve_sysroot_result in
4231: + =*)
4232: + func_stripname '=' '' "$func_resolve_sysroot_result"
4233: + func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
4234: + ;;
4235: + esac
4236: +}
4237: +
4238: +# func_replace_sysroot PATH
4239: +# If PATH begins with the sysroot, replace it with = and
4240: +# store the result into func_replace_sysroot_result.
4241: +func_replace_sysroot ()
4242: +{
4243: + case $lt_sysroot:$1 in
4244: + ?*:"$lt_sysroot"*)
4245: + func_stripname "$lt_sysroot" '' "$1"
4246: + func_replace_sysroot_result='='$func_stripname_result
4247: + ;;
4248: + *)
4249: + # Including no sysroot.
4250: + func_replace_sysroot_result=$1
4251: + ;;
4252: + esac
4253: +}
4254: +
4255: +# func_infer_tag arg
4256: +# Infer tagged configuration to use if any are available and
4257: +# if one wasn't chosen via the "--tag" command line option.
4258: +# Only attempt this if the compiler in the base compile
4259: +# command doesn't match the default compiler.
4260: +# arg is usually of the form 'gcc ...'
4261: +func_infer_tag ()
4262: +{
4263: + $debug_cmd
4264: +
4265: + if test -n "$available_tags" && test -z "$tagname"; then
4266: + CC_quoted=
4267: + for arg in $CC; do
4268: + func_append_quoted CC_quoted "$arg"
4269: + done
4270: + CC_expanded=`func_echo_all $CC`
4271: + CC_quoted_expanded=`func_echo_all $CC_quoted`
4272: + case $@ in
4273: + # Blanks in the command may have been stripped by the calling shell,
4274: + # but not from the CC environment variable when configure was run.
4275: + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
4276: + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
4277: + # Blanks at the start of $base_compile will cause this to fail
4278: + # if we don't check for them as well.
4279: + *)
4280: + for z in $available_tags; do
4281: + if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
4282: + # Evaluate the configuration.
4283: + eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
4284: + CC_quoted=
4285: + for arg in $CC; do
4286: + # Double-quote args containing other shell metacharacters.
4287: + func_append_quoted CC_quoted "$arg"
4288: + done
4289: + CC_expanded=`func_echo_all $CC`
4290: + CC_quoted_expanded=`func_echo_all $CC_quoted`
4291: + case "$@ " in
4292: + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
4293: + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
4294: + # The compiler in the base compile command matches
4295: + # the one in the tagged configuration.
4296: + # Assume this is the tagged configuration we want.
4297: + tagname=$z
4298: + break
4299: + ;;
4300: + esac
4301: + fi
4302: + done
4303: + # If $tagname still isn't set, then no tagged configuration
4304: + # was found and let the user know that the "--tag" command
4305: + # line option must be used.
4306: + if test -z "$tagname"; then
4307: + func_echo "unable to infer tagged configuration"
4308: + func_fatal_error "specify a tag with '--tag'"
4309: +# else
4310: +# func_verbose "using $tagname tagged configuration"
4311: + fi
4312: + ;;
4313: + esac
4314: + fi
4315: +}
4316: +
4317: +
4318: +
4319: +# func_write_libtool_object output_name pic_name nonpic_name
4320: +# Create a libtool object file (analogous to a ".la" file),
4321: +# but don't create it if we're doing a dry run.
4322: +func_write_libtool_object ()
4323: +{
4324: + write_libobj=$1
4325: + if test yes = "$build_libtool_libs"; then
4326: + write_lobj=\'$2\'
4327: + else
4328: + write_lobj=none
4329: + fi
4330: +
4331: + if test yes = "$build_old_libs"; then
4332: + write_oldobj=\'$3\'
4333: + else
4334: + write_oldobj=none
4335: + fi
4336: +
4337: + $opt_dry_run || {
4338: + cat >${write_libobj}T <<EOF
4339: +# $write_libobj - a libtool object file
4340: +# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
4341: +#
4342: +# Please DO NOT delete this file!
4343: +# It is necessary for linking the library.
4344: +
4345: +# Name of the PIC object.
4346: +pic_object=$write_lobj
4347: +
4348: +# Name of the non-PIC object
4349: +non_pic_object=$write_oldobj
4350: +
4351: +EOF
4352: + $MV "${write_libobj}T" "$write_libobj"
4353: + }
4354: +}
4355: +
4356: +
4357: +##################################################
4358: +# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
4359: +##################################################
4360: +
4361: +# func_convert_core_file_wine_to_w32 ARG
4362: +# Helper function used by file name conversion functions when $build is *nix,
4363: +# and $host is mingw, cygwin, or some other w32 environment. Relies on a
4364: +# correctly configured wine environment available, with the winepath program
4365: +# in $build's $PATH.
4366: +#
4367: +# ARG is the $build file name to be converted to w32 format.
4368: +# Result is available in $func_convert_core_file_wine_to_w32_result, and will
4369: +# be empty on error (or when ARG is empty)
4370: +func_convert_core_file_wine_to_w32 ()
4371: +{
4372: + $debug_cmd
4373: +
4374: + func_convert_core_file_wine_to_w32_result=$1
4375: + if test -n "$1"; then
4376: + # Unfortunately, winepath does not exit with a non-zero error code, so we
4377: + # are forced to check the contents of stdout. On the other hand, if the
4378: + # command is not found, the shell will set an exit code of 127 and print
4379: + # *an error message* to stdout. So we must check for both error code of
4380: + # zero AND non-empty stdout, which explains the odd construction:
4381: + func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
4382: + if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
4383: + func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
4384: + $SED -e "$sed_naive_backslashify"`
4385: + else
4386: + func_convert_core_file_wine_to_w32_result=
4387: + fi
4388: + fi
4389: +}
4390: +# end: func_convert_core_file_wine_to_w32
4391: +
4392: +
4393: +# func_convert_core_path_wine_to_w32 ARG
4394: +# Helper function used by path conversion functions when $build is *nix, and
4395: +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
4396: +# configured wine environment available, with the winepath program in $build's
4397: +# $PATH. Assumes ARG has no leading or trailing path separator characters.
4398: +#
4399: +# ARG is path to be converted from $build format to win32.
4400: +# Result is available in $func_convert_core_path_wine_to_w32_result.
4401: +# Unconvertible file (directory) names in ARG are skipped; if no directory names
4402: +# are convertible, then the result may be empty.
4403: +func_convert_core_path_wine_to_w32 ()
4404: +{
4405: + $debug_cmd
4406: +
4407: + # unfortunately, winepath doesn't convert paths, only file names
4408: + func_convert_core_path_wine_to_w32_result=
4409: + if test -n "$1"; then
4410: + oldIFS=$IFS
4411: + IFS=:
4412: + for func_convert_core_path_wine_to_w32_f in $1; do
4413: + IFS=$oldIFS
4414: + func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
4415: + if test -n "$func_convert_core_file_wine_to_w32_result"; then
4416: + if test -z "$func_convert_core_path_wine_to_w32_result"; then
4417: + func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
4418: + else
4419: + func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
4420: + fi
4421: + fi
4422: + done
4423: + IFS=$oldIFS
4424: + fi
4425: +}
4426: +# end: func_convert_core_path_wine_to_w32
4427: +
4428: +
4429: +# func_cygpath ARGS...
4430: +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
4431: +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
4432: +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
4433: +# (2), returns the Cygwin file name or path in func_cygpath_result (input
4434: +# file name or path is assumed to be in w32 format, as previously converted
4435: +# from $build's *nix or MSYS format). In case (3), returns the w32 file name
4436: +# or path in func_cygpath_result (input file name or path is assumed to be in
4437: +# Cygwin format). Returns an empty string on error.
4438: +#
4439: +# ARGS are passed to cygpath, with the last one being the file name or path to
4440: +# be converted.
4441: +#
4442: +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
4443: +# environment variable; do not put it in $PATH.
4444: +func_cygpath ()
4445: +{
4446: + $debug_cmd
4447: +
4448: + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
4449: + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
4450: + if test "$?" -ne 0; then
4451: + # on failure, ensure result is empty
4452: + func_cygpath_result=
4453: + fi
4454: + else
4455: + func_cygpath_result=
4456: + func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
4457: + fi
4458: +}
4459: +#end: func_cygpath
4460: +
4461: +
4462: +# func_convert_core_msys_to_w32 ARG
4463: +# Convert file name or path ARG from MSYS format to w32 format. Return
4464: +# result in func_convert_core_msys_to_w32_result.
4465: +func_convert_core_msys_to_w32 ()
4466: +{
4467: + $debug_cmd
4468: +
4469: + # awkward: cmd appends spaces to result
4470: + func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
4471: + $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
4472: +}
4473: +#end: func_convert_core_msys_to_w32
4474: +
4475: +
4476: +# func_convert_file_check ARG1 ARG2
4477: +# Verify that ARG1 (a file name in $build format) was converted to $host
4478: +# format in ARG2. Otherwise, emit an error message, but continue (resetting
4479: +# func_to_host_file_result to ARG1).
4480: +func_convert_file_check ()
4481: +{
4482: + $debug_cmd
4483: +
4484: + if test -z "$2" && test -n "$1"; then
4485: + func_error "Could not determine host file name corresponding to"
4486: + func_error " '$1'"
4487: + func_error "Continuing, but uninstalled executables may not work."
4488: + # Fallback:
4489: + func_to_host_file_result=$1
4490: + fi
4491: +}
4492: +# end func_convert_file_check
4493: +
4494: +
4495: +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
4496: +# Verify that FROM_PATH (a path in $build format) was converted to $host
4497: +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
4498: +# func_to_host_file_result to a simplistic fallback value (see below).
4499: +func_convert_path_check ()
4500: +{
4501: + $debug_cmd
4502: +
4503: + if test -z "$4" && test -n "$3"; then
4504: + func_error "Could not determine the host path corresponding to"
4505: + func_error " '$3'"
4506: + func_error "Continuing, but uninstalled executables may not work."
4507: + # Fallback. This is a deliberately simplistic "conversion" and
4508: + # should not be "improved". See libtool.info.
4509: + if test "x$1" != "x$2"; then
4510: + lt_replace_pathsep_chars="s|$1|$2|g"
4511: + func_to_host_path_result=`echo "$3" |
4512: + $SED -e "$lt_replace_pathsep_chars"`
4513: + else
4514: + func_to_host_path_result=$3
4515: + fi
4516: + fi
4517: +}
4518: +# end func_convert_path_check
4519: +
4520: +
4521: +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
4522: +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
4523: +# and appending REPL if ORIG matches BACKPAT.
4524: +func_convert_path_front_back_pathsep ()
4525: +{
4526: + $debug_cmd
4527: +
4528: + case $4 in
4529: + $1 ) func_to_host_path_result=$3$func_to_host_path_result
4530: + ;;
4531: + esac
4532: + case $4 in
4533: + $2 ) func_append func_to_host_path_result "$3"
4534: + ;;
4535: + esac
4536: +}
4537: +# end func_convert_path_front_back_pathsep
4538: +
4539: +
4540: +##################################################
4541: +# $build to $host FILE NAME CONVERSION FUNCTIONS #
4542: +##################################################
4543: +# invoked via '$to_host_file_cmd ARG'
4544: +#
4545: +# In each case, ARG is the path to be converted from $build to $host format.
4546: +# Result will be available in $func_to_host_file_result.
4547: +
4548: +
4549: +# func_to_host_file ARG
4550: +# Converts the file name ARG from $build format to $host format. Return result
4551: +# in func_to_host_file_result.
4552: +func_to_host_file ()
4553: +{
4554: + $debug_cmd
4555: +
4556: + $to_host_file_cmd "$1"
4557: +}
4558: +# end func_to_host_file
4559: +
4560: +
4561: +# func_to_tool_file ARG LAZY
4562: +# converts the file name ARG from $build format to toolchain format. Return
4563: +# result in func_to_tool_file_result. If the conversion in use is listed
4564: +# in (the comma separated) LAZY, no conversion takes place.
4565: +func_to_tool_file ()
4566: +{
4567: + $debug_cmd
4568: +
4569: + case ,$2, in
4570: + *,"$to_tool_file_cmd",*)
4571: + func_to_tool_file_result=$1
4572: + ;;
4573: + *)
4574: + $to_tool_file_cmd "$1"
4575: + func_to_tool_file_result=$func_to_host_file_result
4576: + ;;
4577: + esac
4578: +}
4579: +# end func_to_tool_file
4580: +
4581: +
4582: +# func_convert_file_noop ARG
4583: +# Copy ARG to func_to_host_file_result.
4584: +func_convert_file_noop ()
4585: +{
4586: + func_to_host_file_result=$1
4587: +}
4588: +# end func_convert_file_noop
4589: +
4590: +
4591: +# func_convert_file_msys_to_w32 ARG
4592: +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
4593: +# conversion to w32 is not available inside the cwrapper. Returns result in
4594: +# func_to_host_file_result.
4595: +func_convert_file_msys_to_w32 ()
4596: +{
4597: + $debug_cmd
4598: +
4599: + func_to_host_file_result=$1
4600: + if test -n "$1"; then
4601: + func_convert_core_msys_to_w32 "$1"
4602: + func_to_host_file_result=$func_convert_core_msys_to_w32_result
4603: + fi
4604: + func_convert_file_check "$1" "$func_to_host_file_result"
4605: +}
4606: +# end func_convert_file_msys_to_w32
4607: +
4608: +
4609: +# func_convert_file_cygwin_to_w32 ARG
4610: +# Convert file name ARG from Cygwin to w32 format. Returns result in
4611: +# func_to_host_file_result.
4612: +func_convert_file_cygwin_to_w32 ()
4613: +{
4614: + $debug_cmd
4615: +
4616: + func_to_host_file_result=$1
4617: + if test -n "$1"; then
4618: + # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
4619: + # LT_CYGPATH in this case.
4620: + func_to_host_file_result=`cygpath -m "$1"`
4621: + fi
4622: + func_convert_file_check "$1" "$func_to_host_file_result"
4623: +}
4624: +# end func_convert_file_cygwin_to_w32
4625: +
4626: +
4627: +# func_convert_file_nix_to_w32 ARG
4628: +# Convert file name ARG from *nix to w32 format. Requires a wine environment
4629: +# and a working winepath. Returns result in func_to_host_file_result.
4630: +func_convert_file_nix_to_w32 ()
4631: +{
4632: + $debug_cmd
4633: +
4634: + func_to_host_file_result=$1
4635: + if test -n "$1"; then
4636: + func_convert_core_file_wine_to_w32 "$1"
4637: + func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
4638: + fi
4639: + func_convert_file_check "$1" "$func_to_host_file_result"
4640: +}
4641: +# end func_convert_file_nix_to_w32
4642: +
4643: +
4644: +# func_convert_file_msys_to_cygwin ARG
4645: +# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
4646: +# Returns result in func_to_host_file_result.
4647: +func_convert_file_msys_to_cygwin ()
4648: +{
4649: + $debug_cmd
4650: +
4651: + func_to_host_file_result=$1
4652: + if test -n "$1"; then
4653: + func_convert_core_msys_to_w32 "$1"
4654: + func_cygpath -u "$func_convert_core_msys_to_w32_result"
4655: + func_to_host_file_result=$func_cygpath_result
4656: + fi
4657: + func_convert_file_check "$1" "$func_to_host_file_result"
4658: +}
4659: +# end func_convert_file_msys_to_cygwin
4660: +
4661: +
4662: +# func_convert_file_nix_to_cygwin ARG
4663: +# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
4664: +# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
4665: +# in func_to_host_file_result.
4666: +func_convert_file_nix_to_cygwin ()
4667: +{
4668: + $debug_cmd
4669: +
4670: + func_to_host_file_result=$1
4671: + if test -n "$1"; then
4672: + # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
4673: + func_convert_core_file_wine_to_w32 "$1"
4674: + func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
4675: + func_to_host_file_result=$func_cygpath_result
4676: + fi
4677: + func_convert_file_check "$1" "$func_to_host_file_result"
4678: +}
4679: +# end func_convert_file_nix_to_cygwin
4680: +
4681: +
4682: +#############################################
4683: +# $build to $host PATH CONVERSION FUNCTIONS #
4684: +#############################################
4685: +# invoked via '$to_host_path_cmd ARG'
4686: +#
4687: +# In each case, ARG is the path to be converted from $build to $host format.
4688: +# The result will be available in $func_to_host_path_result.
4689: +#
4690: +# Path separators are also converted from $build format to $host format. If
4691: +# ARG begins or ends with a path separator character, it is preserved (but
4692: +# converted to $host format) on output.
4693: +#
4694: +# All path conversion functions are named using the following convention:
4695: +# file name conversion function : func_convert_file_X_to_Y ()
4696: +# path conversion function : func_convert_path_X_to_Y ()
4697: +# where, for any given $build/$host combination the 'X_to_Y' value is the
4698: +# same. If conversion functions are added for new $build/$host combinations,
4699: +# the two new functions must follow this pattern, or func_init_to_host_path_cmd
4700: +# will break.
4701: +
4702: +
4703: +# func_init_to_host_path_cmd
4704: +# Ensures that function "pointer" variable $to_host_path_cmd is set to the
4705: +# appropriate value, based on the value of $to_host_file_cmd.
4706: +to_host_path_cmd=
4707: +func_init_to_host_path_cmd ()
4708: +{
4709: + $debug_cmd
4710: +
4711: + if test -z "$to_host_path_cmd"; then
4712: + func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
4713: + to_host_path_cmd=func_convert_path_$func_stripname_result
4714: + fi
4715: +}
4716: +
4717: +
4718: +# func_to_host_path ARG
4719: +# Converts the path ARG from $build format to $host format. Return result
4720: +# in func_to_host_path_result.
4721: +func_to_host_path ()
4722: +{
4723: + $debug_cmd
4724: +
4725: + func_init_to_host_path_cmd
4726: + $to_host_path_cmd "$1"
4727: +}
4728: +# end func_to_host_path
4729: +
4730: +
4731: +# func_convert_path_noop ARG
4732: +# Copy ARG to func_to_host_path_result.
4733: +func_convert_path_noop ()
4734: +{
4735: + func_to_host_path_result=$1
4736: +}
4737: +# end func_convert_path_noop
4738: +
4739: +
4740: +# func_convert_path_msys_to_w32 ARG
4741: +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
4742: +# conversion to w32 is not available inside the cwrapper. Returns result in
4743: +# func_to_host_path_result.
4744: +func_convert_path_msys_to_w32 ()
4745: +{
4746: + $debug_cmd
4747: +
4748: + func_to_host_path_result=$1
4749: + if test -n "$1"; then
4750: + # Remove leading and trailing path separator characters from ARG. MSYS
4751: + # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
4752: + # and winepath ignores them completely.
4753: + func_stripname : : "$1"
4754: + func_to_host_path_tmp1=$func_stripname_result
4755: + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
4756: + func_to_host_path_result=$func_convert_core_msys_to_w32_result
4757: + func_convert_path_check : ";" \
4758: + "$func_to_host_path_tmp1" "$func_to_host_path_result"
4759: + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
4760: + fi
4761: +}
4762: +# end func_convert_path_msys_to_w32
4763: +
4764: +
4765: +# func_convert_path_cygwin_to_w32 ARG
4766: +# Convert path ARG from Cygwin to w32 format. Returns result in
4767: +# func_to_host_file_result.
4768: +func_convert_path_cygwin_to_w32 ()
4769: +{
4770: + $debug_cmd
4771: +
4772: + func_to_host_path_result=$1
4773: + if test -n "$1"; then
4774: + # See func_convert_path_msys_to_w32:
4775: + func_stripname : : "$1"
4776: + func_to_host_path_tmp1=$func_stripname_result
4777: + func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
4778: + func_convert_path_check : ";" \
4779: + "$func_to_host_path_tmp1" "$func_to_host_path_result"
4780: + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
4781: + fi
4782: +}
4783: +# end func_convert_path_cygwin_to_w32
4784: +
4785: +
4786: +# func_convert_path_nix_to_w32 ARG
4787: +# Convert path ARG from *nix to w32 format. Requires a wine environment and
4788: +# a working winepath. Returns result in func_to_host_file_result.
4789: +func_convert_path_nix_to_w32 ()
4790: +{
4791: + $debug_cmd
4792: +
4793: + func_to_host_path_result=$1
4794: + if test -n "$1"; then
4795: + # See func_convert_path_msys_to_w32:
4796: + func_stripname : : "$1"
4797: + func_to_host_path_tmp1=$func_stripname_result
4798: + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
4799: + func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
4800: + func_convert_path_check : ";" \
4801: + "$func_to_host_path_tmp1" "$func_to_host_path_result"
4802: + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
4803: + fi
4804: +}
4805: +# end func_convert_path_nix_to_w32
4806: +
4807: +
4808: +# func_convert_path_msys_to_cygwin ARG
4809: +# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
4810: +# Returns result in func_to_host_file_result.
4811: +func_convert_path_msys_to_cygwin ()
4812: +{
4813: + $debug_cmd
4814: +
4815: + func_to_host_path_result=$1
4816: + if test -n "$1"; then
4817: + # See func_convert_path_msys_to_w32:
4818: + func_stripname : : "$1"
4819: + func_to_host_path_tmp1=$func_stripname_result
4820: + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
4821: + func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
4822: + func_to_host_path_result=$func_cygpath_result
4823: + func_convert_path_check : : \
4824: + "$func_to_host_path_tmp1" "$func_to_host_path_result"
4825: + func_convert_path_front_back_pathsep ":*" "*:" : "$1"
4826: + fi
4827: +}
4828: +# end func_convert_path_msys_to_cygwin
4829: +
4830: +
4831: +# func_convert_path_nix_to_cygwin ARG
4832: +# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
4833: +# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
4834: +# func_to_host_file_result.
4835: +func_convert_path_nix_to_cygwin ()
4836: +{
4837: + $debug_cmd
4838: +
4839: + func_to_host_path_result=$1
4840: + if test -n "$1"; then
4841: + # Remove leading and trailing path separator characters from
4842: + # ARG. msys behavior is inconsistent here, cygpath turns them
4843: + # into '.;' and ';.', and winepath ignores them completely.
4844: + func_stripname : : "$1"
4845: + func_to_host_path_tmp1=$func_stripname_result
4846: + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
4847: + func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
4848: + func_to_host_path_result=$func_cygpath_result
4849: + func_convert_path_check : : \
4850: + "$func_to_host_path_tmp1" "$func_to_host_path_result"
4851: + func_convert_path_front_back_pathsep ":*" "*:" : "$1"
4852: + fi
4853: +}
4854: +# end func_convert_path_nix_to_cygwin
4855: +
4856: +
4857: +# func_dll_def_p FILE
4858: +# True iff FILE is a Windows DLL '.def' file.
4859: +# Keep in sync with _LT_DLL_DEF_P in libtool.m4
4860: +func_dll_def_p ()
4861: +{
4862: + $debug_cmd
4863: +
4864: + func_dll_def_p_tmp=`$SED -n \
4865: + -e 's/^[ ]*//' \
4866: + -e '/^\(;.*\)*$/d' \
4867: + -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \
4868: + -e q \
4869: + "$1"`
4870: + test DEF = "$func_dll_def_p_tmp"
4871: +}
4872: +
4873: +
4874: +# func_mode_compile arg...
4875: +func_mode_compile ()
4876: +{
4877: + $debug_cmd
4878: +
4879: + # Get the compilation command and the source file.
4880: + base_compile=
4881: + srcfile=$nonopt # always keep a non-empty value in "srcfile"
4882: + suppress_opt=yes
4883: + suppress_output=
4884: + arg_mode=normal
4885: + libobj=
4886: + later=
4887: + pie_flag=
4888: +
4889: + for arg
4890: + do
4891: + case $arg_mode in
4892: + arg )
4893: + # do not "continue". Instead, add this to base_compile
4894: + lastarg=$arg
4895: + arg_mode=normal
4896: + ;;
4897: +
4898: + target )
4899: + libobj=$arg
4900: + arg_mode=normal
4901: + continue
4902: + ;;
4903: +
4904: + normal )
4905: + # Accept any command-line options.
4906: + case $arg in
4907: + -o)
4908: + test -n "$libobj" && \
4909: + func_fatal_error "you cannot specify '-o' more than once"
4910: + arg_mode=target
4911: + continue
4912: + ;;
4913: +
4914: + -pie | -fpie | -fPIE)
4915: + func_append pie_flag " $arg"
4916: + continue
4917: + ;;
4918: +
4919: + -shared | -static | -prefer-pic | -prefer-non-pic)
4920: + func_append later " $arg"
4921: + continue
4922: + ;;
4923: +
4924: + -no-suppress)
4925: + suppress_opt=no
4926: + continue
4927: + ;;
4928: +
4929: + -Xcompiler)
4930: + arg_mode=arg # the next one goes into the "base_compile" arg list
4931: + continue # The current "srcfile" will either be retained or
4932: + ;; # replaced later. I would guess that would be a bug.
4933: +
4934: + -Wc,*)
4935: + func_stripname '-Wc,' '' "$arg"
4936: + args=$func_stripname_result
4937: + lastarg=
4938: + save_ifs=$IFS; IFS=,
4939: + for arg in $args; do
4940: + IFS=$save_ifs
4941: + func_append_quoted lastarg "$arg"
4942: + done
4943: + IFS=$save_ifs
4944: + func_stripname ' ' '' "$lastarg"
4945: + lastarg=$func_stripname_result
4946: +
4947: + # Add the arguments to base_compile.
4948: + func_append base_compile " $lastarg"
4949: + continue
4950: + ;;
4951: +
4952: + *)
4953: + # Accept the current argument as the source file.
4954: + # The previous "srcfile" becomes the current argument.
4955: + #
4956: + lastarg=$srcfile
4957: + srcfile=$arg
4958: + ;;
4959: + esac # case $arg
4960: + ;;
4961: + esac # case $arg_mode
4962: +
4963: + # Aesthetically quote the previous argument.
4964: + func_append_quoted base_compile "$lastarg"
4965: + done # for arg
4966: +
4967: + case $arg_mode in
4968: + arg)
4969: + func_fatal_error "you must specify an argument for -Xcompile"
4970: + ;;
4971: + target)
4972: + func_fatal_error "you must specify a target with '-o'"
4973: + ;;
4974: + *)
4975: + # Get the name of the library object.
4976: + test -z "$libobj" && {
4977: + func_basename "$srcfile"
4978: + libobj=$func_basename_result
4979: + }
4980: + ;;
4981: + esac
4982: +
4983: + # Recognize several different file suffixes.
4984: + # If the user specifies -o file.o, it is replaced with file.lo
4985: + case $libobj in
4986: + *.[cCFSifmso] | \
4987: + *.ada | *.adb | *.ads | *.asm | \
4988: + *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
4989: + *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
4990: + func_xform "$libobj"
4991: + libobj=$func_xform_result
4992: + ;;
4993: + esac
4994: +
4995: + case $libobj in
4996: + *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
4997: + *)
4998: + func_fatal_error "cannot determine name of library object from '$libobj'"
4999: + ;;
5000: + esac
5001: +
5002: + func_infer_tag $base_compile
5003: +
5004: + for arg in $later; do
5005: + case $arg in
5006: + -shared)
5007: + test yes = "$build_libtool_libs" \
5008: + || func_fatal_configuration "cannot build a shared library"
5009: + build_old_libs=no
5010: + continue
5011: + ;;
5012: +
5013: + -static)
5014: + build_libtool_libs=no
5015: + build_old_libs=yes
5016: + continue
5017: + ;;
5018: +
5019: + -prefer-pic)
5020: + pic_mode=yes
5021: + continue
5022: + ;;
5023: +
5024: + -prefer-non-pic)
5025: + pic_mode=no
5026: + continue
5027: + ;;
5028: + esac
5029: + done
5030: +
5031: + func_quote_for_eval "$libobj"
5032: + test "X$libobj" != "X$func_quote_for_eval_result" \
5033: + && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
5034: + && func_warning "libobj name '$libobj' may not contain shell special characters."
5035: + func_dirname_and_basename "$obj" "/" ""
5036: + objname=$func_basename_result
5037: + xdir=$func_dirname_result
5038: + lobj=$xdir$objdir/$objname
5039: +
5040: + test -z "$base_compile" && \
5041: + func_fatal_help "you must specify a compilation command"
5042: +
5043: + # Delete any leftover library objects.
5044: + if test yes = "$build_old_libs"; then
5045: + removelist="$obj $lobj $libobj ${libobj}T"
5046: + else
5047: + removelist="$lobj $libobj ${libobj}T"
5048: + fi
5049: +
5050: + # On Cygwin there's no "real" PIC flag so we must build both object types
5051: + case $host_os in
5052: + cygwin* | mingw* | pw32* | os2* | cegcc*)
5053: + pic_mode=default
5054: + ;;
5055: + esac
5056: + if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
5057: + # non-PIC code in shared libraries is not supported
5058: + pic_mode=default
5059: + fi
5060: +
5061: + # Calculate the filename of the output object if compiler does
5062: + # not support -o with -c
5063: + if test no = "$compiler_c_o"; then
5064: + output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
5065: + lockfile=$output_obj.lock
5066: + else
5067: + output_obj=
5068: + need_locks=no
5069: + lockfile=
5070: + fi
5071: +
5072: + # Lock this critical section if it is needed
5073: + # We use this script file to make the link, it avoids creating a new file
5074: + if test yes = "$need_locks"; then
5075: + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
5076: + func_echo "Waiting for $lockfile to be removed"
5077: + sleep 2
5078: + done
5079: + elif test warn = "$need_locks"; then
5080: + if test -f "$lockfile"; then
5081: + $ECHO "\
5082: +*** ERROR, $lockfile exists and contains:
5083: +`cat $lockfile 2>/dev/null`
5084: +
5085: +This indicates that another process is trying to use the same
5086: +temporary object file, and libtool could not work around it because
5087: +your compiler does not support '-c' and '-o' together. If you
5088: +repeat this compilation, it may succeed, by chance, but you had better
5089: +avoid parallel builds (make -j) in this platform, or get a better
5090: +compiler."
5091: +
5092: + $opt_dry_run || $RM $removelist
5093: + exit $EXIT_FAILURE
5094: + fi
5095: + func_append removelist " $output_obj"
5096: + $ECHO "$srcfile" > "$lockfile"
5097: + fi
5098: +
5099: + $opt_dry_run || $RM $removelist
5100: + func_append removelist " $lockfile"
5101: + trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
5102: +
5103: + func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
5104: + srcfile=$func_to_tool_file_result
5105: + func_quote_for_eval "$srcfile"
5106: + qsrcfile=$func_quote_for_eval_result
5107: +
5108: + # Only build a PIC object if we are building libtool libraries.
5109: + if test yes = "$build_libtool_libs"; then
5110: + # Without this assignment, base_compile gets emptied.
5111: + fbsd_hideous_sh_bug=$base_compile
5112: +
5113: + if test no != "$pic_mode"; then
5114: + command="$base_compile $qsrcfile $pic_flag"
5115: + else
5116: + # Don't build PIC code
5117: + command="$base_compile $qsrcfile"
5118: + fi
5119: +
5120: + func_mkdir_p "$xdir$objdir"
5121: +
5122: + if test -z "$output_obj"; then
5123: + # Place PIC objects in $objdir
5124: + func_append command " -o $lobj"
5125: + fi
5126: +
5127: + func_show_eval_locale "$command" \
5128: + 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
5129: +
5130: + if test warn = "$need_locks" &&
5131: + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
5132: + $ECHO "\
5133: +*** ERROR, $lockfile contains:
5134: +`cat $lockfile 2>/dev/null`
5135: +
5136: +but it should contain:
5137: +$srcfile
5138: +
5139: +This indicates that another process is trying to use the same
5140: +temporary object file, and libtool could not work around it because
5141: +your compiler does not support '-c' and '-o' together. If you
5142: +repeat this compilation, it may succeed, by chance, but you had better
5143: +avoid parallel builds (make -j) in this platform, or get a better
5144: +compiler."
5145: +
5146: + $opt_dry_run || $RM $removelist
5147: + exit $EXIT_FAILURE
5148: + fi
5149: +
5150: + # Just move the object if needed, then go on to compile the next one
5151: + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
5152: + func_show_eval '$MV "$output_obj" "$lobj"' \
5153: + 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
5154: + fi
5155: +
5156: + # Allow error messages only from the first compilation.
5157: + if test yes = "$suppress_opt"; then
5158: + suppress_output=' >/dev/null 2>&1'
5159: + fi
5160: + fi
5161: +
5162: + # Only build a position-dependent object if we build old libraries.
5163: + if test yes = "$build_old_libs"; then
5164: + if test yes != "$pic_mode"; then
5165: + # Don't build PIC code
5166: + command="$base_compile $qsrcfile$pie_flag"
5167: + else
5168: + command="$base_compile $qsrcfile $pic_flag"
5169: + fi
5170: + if test yes = "$compiler_c_o"; then
5171: + func_append command " -o $obj"
5172: + fi
5173: +
5174: + # Suppress compiler output if we already did a PIC compilation.
5175: + func_append command "$suppress_output"
5176: + func_show_eval_locale "$command" \
5177: + '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
5178: +
5179: + if test warn = "$need_locks" &&
5180: + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
5181: + $ECHO "\
5182: +*** ERROR, $lockfile contains:
5183: +`cat $lockfile 2>/dev/null`
5184: +
5185: +but it should contain:
5186: +$srcfile
5187: +
5188: +This indicates that another process is trying to use the same
5189: +temporary object file, and libtool could not work around it because
5190: +your compiler does not support '-c' and '-o' together. If you
5191: +repeat this compilation, it may succeed, by chance, but you had better
5192: +avoid parallel builds (make -j) in this platform, or get a better
5193: +compiler."
5194: +
5195: + $opt_dry_run || $RM $removelist
5196: + exit $EXIT_FAILURE
5197: + fi
5198: +
5199: + # Just move the object if needed
5200: + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
5201: + func_show_eval '$MV "$output_obj" "$obj"' \
5202: + 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
5203: + fi
5204: + fi
5205: +
5206: + $opt_dry_run || {
5207: + func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
5208: +
5209: + # Unlock the critical section if it was locked
5210: + if test no != "$need_locks"; then
5211: + removelist=$lockfile
5212: + $RM "$lockfile"
5213: + fi
5214: + }
5215: +
5216: + exit $EXIT_SUCCESS
5217: +}
5218: +
5219: +$opt_help || {
5220: + test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
5221: +}
5222: +
5223: +func_mode_help ()
5224: +{
5225: + # We need to display help for each of the modes.
5226: + case $opt_mode in
5227: + "")
5228: + # Generic help is extracted from the usage comments
5229: + # at the start of this file.
5230: + func_help
5231: + ;;
5232: +
5233: + clean)
5234: + $ECHO \
5235: +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
5236: +
5237: +Remove files from the build directory.
5238: +
5239: +RM is the name of the program to use to delete files associated with each FILE
5240: +(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
5241: +to RM.
5242: +
5243: +If FILE is a libtool library, object or program, all the files associated
5244: +with it are deleted. Otherwise, only FILE itself is deleted using RM."
5245: + ;;
5246: +
5247: + compile)
5248: + $ECHO \
5249: +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
5250: +
5251: +Compile a source file into a libtool library object.
5252: +
5253: +This mode accepts the following additional options:
5254: +
5255: + -o OUTPUT-FILE set the output file name to OUTPUT-FILE
5256: + -no-suppress do not suppress compiler output for multiple passes
5257: + -prefer-pic try to build PIC objects only
5258: + -prefer-non-pic try to build non-PIC objects only
5259: + -shared do not build a '.o' file suitable for static linking
5260: + -static only build a '.o' file suitable for static linking
5261: + -Wc,FLAG pass FLAG directly to the compiler
5262: +
5263: +COMPILE-COMMAND is a command to be used in creating a 'standard' object file
5264: +from the given SOURCEFILE.
5265: +
5266: +The output file name is determined by removing the directory component from
5267: +SOURCEFILE, then substituting the C source code suffix '.c' with the
5268: +library object suffix, '.lo'."
5269: + ;;
5270: +
5271: + execute)
5272: + $ECHO \
5273: +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
5274: +
5275: +Automatically set library path, then run a program.
5276: +
5277: +This mode accepts the following additional options:
5278: +
5279: + -dlopen FILE add the directory containing FILE to the library path
5280: +
5281: +This mode sets the library path environment variable according to '-dlopen'
5282: +flags.
5283: +
5284: +If any of the ARGS are libtool executable wrappers, then they are translated
5285: +into their corresponding uninstalled binary, and any of their required library
5286: +directories are added to the library path.
5287: +
5288: +Then, COMMAND is executed, with ARGS as arguments."
5289: + ;;
5290: +
5291: + finish)
5292: + $ECHO \
5293: +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
5294: +
5295: +Complete the installation of libtool libraries.
5296: +
5297: +Each LIBDIR is a directory that contains libtool libraries.
5298: +
5299: +The commands that this mode executes may require superuser privileges. Use
5300: +the '--dry-run' option if you just want to see what would be executed."
5301: + ;;
5302: +
5303: + install)
5304: + $ECHO \
5305: +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
5306: +
5307: +Install executables or libraries.
5308: +
5309: +INSTALL-COMMAND is the installation command. The first component should be
5310: +either the 'install' or 'cp' program.
5311: +
5312: +The following components of INSTALL-COMMAND are treated specially:
5313: +
5314: + -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
5315: +
5316: +The rest of the components are interpreted as arguments to that command (only
5317: +BSD-compatible install options are recognized)."
5318: + ;;
5319: +
5320: + link)
5321: + $ECHO \
5322: +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
5323: +
5324: +Link object files or libraries together to form another library, or to
5325: +create an executable program.
5326: +
5327: +LINK-COMMAND is a command using the C compiler that you would use to create
5328: +a program from several object files.
5329: +
5330: +The following components of LINK-COMMAND are treated specially:
5331: +
5332: + -all-static do not do any dynamic linking at all
5333: + -avoid-version do not add a version suffix if possible
5334: + -bindir BINDIR specify path to binaries directory (for systems where
5335: + libraries must be found in the PATH setting at runtime)
5336: + -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime
5337: + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
5338: + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
5339: + -export-symbols SYMFILE
5340: + try to export only the symbols listed in SYMFILE
5341: + -export-symbols-regex REGEX
5342: + try to export only the symbols matching REGEX
5343: + -LLIBDIR search LIBDIR for required installed libraries
5344: + -lNAME OUTPUT-FILE requires the installed library libNAME
5345: + -module build a library that can dlopened
5346: + -no-fast-install disable the fast-install mode
5347: + -no-install link a not-installable executable
5348: + -no-undefined declare that a library does not refer to external symbols
5349: + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
5350: + -objectlist FILE use a list of object files found in FILE to specify objects
5351: + -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes)
5352: + -precious-files-regex REGEX
5353: + don't remove output files matching REGEX
5354: + -release RELEASE specify package release information
5355: + -rpath LIBDIR the created library will eventually be installed in LIBDIR
5356: + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
5357: + -shared only do dynamic linking of libtool libraries
5358: + -shrext SUFFIX override the standard shared library file extension
5359: + -static do not do any dynamic linking of uninstalled libtool libraries
5360: + -static-libtool-libs
5361: + do not do any dynamic linking of libtool libraries
5362: + -version-info CURRENT[:REVISION[:AGE]]
5363: + specify library version info [each variable defaults to 0]
5364: + -weak LIBNAME declare that the target provides the LIBNAME interface
5365: + -Wc,FLAG
5366: + -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
5367: + -Wl,FLAG
5368: + -Xlinker FLAG pass linker-specific FLAG directly to the linker
5369: + -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
5370: +
5371: +All other options (arguments beginning with '-') are ignored.
5372: +
5373: +Every other argument is treated as a filename. Files ending in '.la' are
5374: +treated as uninstalled libtool libraries, other files are standard or library
5375: +object files.
5376: +
5377: +If the OUTPUT-FILE ends in '.la', then a libtool library is created,
5378: +only library objects ('.lo' files) may be specified, and '-rpath' is
5379: +required, except when creating a convenience library.
5380: +
5381: +If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
5382: +using 'ar' and 'ranlib', or on Windows using 'lib'.
5383: +
5384: +If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
5385: +is created, otherwise an executable program is created."
5386: + ;;
5387: +
5388: + uninstall)
5389: + $ECHO \
5390: +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
5391: +
5392: +Remove libraries from an installation directory.
5393: +
5394: +RM is the name of the program to use to delete files associated with each FILE
5395: +(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
5396: +to RM.
5397: +
5398: +If FILE is a libtool library, all the files associated with it are deleted.
5399: +Otherwise, only FILE itself is deleted using RM."
5400: + ;;
5401: +
5402: + *)
5403: + func_fatal_help "invalid operation mode '$opt_mode'"
5404: + ;;
5405: + esac
5406: +
5407: + echo
5408: + $ECHO "Try '$progname --help' for more information about other modes."
5409: +}
5410: +
5411: +# Now that we've collected a possible --mode arg, show help if necessary
5412: +if $opt_help; then
5413: + if test : = "$opt_help"; then
5414: + func_mode_help
5415: + else
5416: + {
5417: + func_help noexit
5418: + for opt_mode in compile link execute install finish uninstall clean; do
5419: + func_mode_help
5420: + done
5421: + } | $SED -n '1p; 2,$s/^Usage:/ or: /p'
5422: + {
5423: + func_help noexit
5424: + for opt_mode in compile link execute install finish uninstall clean; do
5425: + echo
5426: + func_mode_help
5427: + done
5428: + } |
5429: + $SED '1d
5430: + /^When reporting/,/^Report/{
5431: + H
5432: + d
5433: + }
5434: + $x
5435: + /information about other modes/d
5436: + /more detailed .*MODE/d
5437: + s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
5438: + fi
5439: + exit $?
5440: +fi
5441: +
5442: +
5443: +# func_mode_execute arg...
5444: +func_mode_execute ()
5445: +{
5446: + $debug_cmd
5447: +
5448: + # The first argument is the command name.
5449: + cmd=$nonopt
5450: + test -z "$cmd" && \
5451: + func_fatal_help "you must specify a COMMAND"
5452: +
5453: + # Handle -dlopen flags immediately.
5454: + for file in $opt_dlopen; do
5455: + test -f "$file" \
5456: + || func_fatal_help "'$file' is not a file"
5457: +
5458: + dir=
5459: + case $file in
5460: + *.la)
5461: + func_resolve_sysroot "$file"
5462: + file=$func_resolve_sysroot_result
5463: +
5464: + # Check to see that this really is a libtool archive.
5465: + func_lalib_unsafe_p "$file" \
5466: + || func_fatal_help "'$lib' is not a valid libtool archive"
5467: +
5468: + # Read the libtool library.
5469: + dlname=
5470: + library_names=
5471: + func_source "$file"
5472: +
5473: + # Skip this library if it cannot be dlopened.
5474: + if test -z "$dlname"; then
5475: + # Warn if it was a shared library.
5476: + test -n "$library_names" && \
5477: + func_warning "'$file' was not linked with '-export-dynamic'"
5478: + continue
5479: + fi
5480: +
5481: + func_dirname "$file" "" "."
5482: + dir=$func_dirname_result
5483: +
5484: + if test -f "$dir/$objdir/$dlname"; then
5485: + func_append dir "/$objdir"
5486: + else
5487: + if test ! -f "$dir/$dlname"; then
5488: + func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
5489: + fi
5490: + fi
5491: + ;;
5492: +
5493: + *.lo)
5494: + # Just add the directory containing the .lo file.
5495: + func_dirname "$file" "" "."
5496: + dir=$func_dirname_result
5497: + ;;
5498: +
5499: + *)
5500: + func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
5501: + continue
5502: + ;;
5503: + esac
5504: +
5505: + # Get the absolute pathname.
5506: + absdir=`cd "$dir" && pwd`
5507: + test -n "$absdir" && dir=$absdir
5508: +
5509: + # Now add the directory to shlibpath_var.
5510: + if eval "test -z \"\$$shlibpath_var\""; then
5511: + eval "$shlibpath_var=\"\$dir\""
5512: + else
5513: + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5514: + fi
5515: + done
5516: +
5517: + # This variable tells wrapper scripts just to set shlibpath_var
5518: + # rather than running their programs.
5519: + libtool_execute_magic=$magic
5520: +
5521: + # Check if any of the arguments is a wrapper script.
5522: + args=
5523: + for file
5524: + do
5525: + case $file in
5526: + -* | *.la | *.lo ) ;;
5527: + *)
5528: + # Do a test to see if this is really a libtool program.
5529: + if func_ltwrapper_script_p "$file"; then
5530: + func_source "$file"
5531: + # Transform arg to wrapped name.
5532: + file=$progdir/$program
5533: + elif func_ltwrapper_executable_p "$file"; then
5534: + func_ltwrapper_scriptname "$file"
5535: + func_source "$func_ltwrapper_scriptname_result"
5536: + # Transform arg to wrapped name.
5537: + file=$progdir/$program
5538: + fi
5539: + ;;
5540: + esac
5541: + # Quote arguments (to preserve shell metacharacters).
5542: + func_append_quoted args "$file"
5543: + done
5544: +
5545: + if $opt_dry_run; then
5546: + # Display what would be done.
5547: + if test -n "$shlibpath_var"; then
5548: + eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
5549: + echo "export $shlibpath_var"
5550: + fi
5551: + $ECHO "$cmd$args"
5552: + exit $EXIT_SUCCESS
5553: + else
5554: + if test -n "$shlibpath_var"; then
5555: + # Export the shlibpath_var.
5556: + eval "export $shlibpath_var"
5557: + fi
5558: +
5559: + # Restore saved environment variables
5560: + for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
5561: + do
5562: + eval "if test \"\${save_$lt_var+set}\" = set; then
5563: + $lt_var=\$save_$lt_var; export $lt_var
5564: + else
5565: + $lt_unset $lt_var
5566: + fi"
5567: + done
5568: +
5569: + # Now prepare to actually exec the command.
5570: + exec_cmd=\$cmd$args
5571: + fi
5572: +}
5573: +
5574: +test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
5575: +
5576: +
5577: +# func_mode_finish arg...
5578: +func_mode_finish ()
5579: +{
5580: + $debug_cmd
5581: +
5582: + libs=
5583: + libdirs=
5584: + admincmds=
5585: +
5586: + for opt in "$nonopt" ${1+"$@"}
5587: + do
5588: + if test -d "$opt"; then
5589: + func_append libdirs " $opt"
5590: +
5591: + elif test -f "$opt"; then
5592: + if func_lalib_unsafe_p "$opt"; then
5593: + func_append libs " $opt"
5594: + else
5595: + func_warning "'$opt' is not a valid libtool archive"
5596: + fi
5597: +
5598: + else
5599: + func_fatal_error "invalid argument '$opt'"
5600: + fi
5601: + done
5602: +
5603: + if test -n "$libs"; then
5604: + if test -n "$lt_sysroot"; then
5605: + sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
5606: + sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
5607: + else
5608: + sysroot_cmd=
5609: + fi
5610: +
5611: + # Remove sysroot references
5612: + if $opt_dry_run; then
5613: + for lib in $libs; do
5614: + echo "removing references to $lt_sysroot and '=' prefixes from $lib"
5615: + done
5616: + else
5617: + tmpdir=`func_mktempdir`
5618: + for lib in $libs; do
5619: + $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
5620: + > $tmpdir/tmp-la
5621: + mv -f $tmpdir/tmp-la $lib
5622: + done
5623: + ${RM}r "$tmpdir"
5624: + fi
5625: + fi
5626: +
5627: + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5628: + for libdir in $libdirs; do
5629: + if test -n "$finish_cmds"; then
5630: + # Do each command in the finish commands.
5631: + func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
5632: +'"$cmd"'"'
5633: + fi
5634: + if test -n "$finish_eval"; then
5635: + # Do the single finish_eval.
5636: + eval cmds=\"$finish_eval\"
5637: + $opt_dry_run || eval "$cmds" || func_append admincmds "
5638: + $cmds"
5639: + fi
5640: + done
5641: + fi
5642: +
5643: + # Exit here if they wanted silent mode.
5644: + $opt_quiet && exit $EXIT_SUCCESS
5645: +
5646: + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5647: + echo "----------------------------------------------------------------------"
5648: + echo "Libraries have been installed in:"
5649: + for libdir in $libdirs; do
5650: + $ECHO " $libdir"
5651: + done
5652: + echo
5653: + echo "If you ever happen to want to link against installed libraries"
5654: + echo "in a given directory, LIBDIR, you must either use libtool, and"
5655: + echo "specify the full pathname of the library, or use the '-LLIBDIR'"
5656: + echo "flag during linking and do at least one of the following:"
5657: + if test -n "$shlibpath_var"; then
5658: + echo " - add LIBDIR to the '$shlibpath_var' environment variable"
5659: + echo " during execution"
5660: + fi
5661: + if test -n "$runpath_var"; then
5662: + echo " - add LIBDIR to the '$runpath_var' environment variable"
5663: + echo " during linking"
5664: + fi
5665: + if test -n "$hardcode_libdir_flag_spec"; then
5666: + libdir=LIBDIR
5667: + eval flag=\"$hardcode_libdir_flag_spec\"
5668: +
5669: + $ECHO " - use the '$flag' linker flag"
5670: + fi
5671: + if test -n "$admincmds"; then
5672: + $ECHO " - have your system administrator run these commands:$admincmds"
5673: + fi
5674: + if test -f /etc/ld.so.conf; then
5675: + echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
5676: + fi
5677: + echo
5678: +
5679: + echo "See any operating system documentation about shared libraries for"
5680: + case $host in
5681: + solaris2.[6789]|solaris2.1[0-9])
5682: + echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
5683: + echo "pages."
5684: + ;;
5685: + *)
5686: + echo "more information, such as the ld(1) and ld.so(8) manual pages."
5687: + ;;
5688: + esac
5689: + echo "----------------------------------------------------------------------"
5690: + fi
5691: + exit $EXIT_SUCCESS
5692: +}
5693: +
5694: +test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
5695: +
5696: +
5697: +# func_mode_install arg...
5698: +func_mode_install ()
5699: +{
5700: + $debug_cmd
5701: +
5702: + # There may be an optional sh(1) argument at the beginning of
5703: + # install_prog (especially on Windows NT).
5704: + if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
5705: + # Allow the use of GNU shtool's install command.
5706: + case $nonopt in *shtool*) :;; *) false;; esac
5707: + then
5708: + # Aesthetically quote it.
5709: + func_quote_for_eval "$nonopt"
5710: + install_prog="$func_quote_for_eval_result "
5711: + arg=$1
5712: + shift
5713: + else
5714: + install_prog=
5715: + arg=$nonopt
5716: + fi
5717: +
5718: + # The real first argument should be the name of the installation program.
5719: + # Aesthetically quote it.
5720: + func_quote_for_eval "$arg"
5721: + func_append install_prog "$func_quote_for_eval_result"
5722: + install_shared_prog=$install_prog
5723: + case " $install_prog " in
5724: + *[\\\ /]cp\ *) install_cp=: ;;
5725: + *) install_cp=false ;;
5726: + esac
5727: +
5728: + # We need to accept at least all the BSD install flags.
5729: + dest=
5730: + files=
5731: + opts=
5732: + prev=
5733: + install_type=
5734: + isdir=false
5735: + stripme=
5736: + no_mode=:
5737: + for arg
5738: + do
5739: + arg2=
5740: + if test -n "$dest"; then
5741: + func_append files " $dest"
5742: + dest=$arg
5743: + continue
5744: + fi
5745: +
5746: + case $arg in
5747: + -d) isdir=: ;;
5748: + -f)
5749: + if $install_cp; then :; else
5750: + prev=$arg
5751: + fi
5752: + ;;
5753: + -g | -m | -o)
5754: + prev=$arg
5755: + ;;
5756: + -s)
5757: + stripme=" -s"
5758: + continue
5759: + ;;
5760: + -*)
5761: + ;;
5762: + *)
5763: + # If the previous option needed an argument, then skip it.
5764: + if test -n "$prev"; then
5765: + if test X-m = "X$prev" && test -n "$install_override_mode"; then
5766: + arg2=$install_override_mode
5767: + no_mode=false
5768: + fi
5769: + prev=
5770: + else
5771: + dest=$arg
5772: + continue
5773: + fi
5774: + ;;
5775: + esac
5776: +
5777: + # Aesthetically quote the argument.
5778: + func_quote_for_eval "$arg"
5779: + func_append install_prog " $func_quote_for_eval_result"
5780: + if test -n "$arg2"; then
5781: + func_quote_for_eval "$arg2"
5782: + fi
5783: + func_append install_shared_prog " $func_quote_for_eval_result"
5784: + done
5785: +
5786: + test -z "$install_prog" && \
5787: + func_fatal_help "you must specify an install program"
5788: +
5789: + test -n "$prev" && \
5790: + func_fatal_help "the '$prev' option requires an argument"
5791: +
5792: + if test -n "$install_override_mode" && $no_mode; then
5793: + if $install_cp; then :; else
5794: + func_quote_for_eval "$install_override_mode"
5795: + func_append install_shared_prog " -m $func_quote_for_eval_result"
5796: + fi
5797: + fi
5798: +
5799: + if test -z "$files"; then
5800: + if test -z "$dest"; then
5801: + func_fatal_help "no file or destination specified"
5802: + else
5803: + func_fatal_help "you must specify a destination"
5804: + fi
5805: + fi
5806: +
5807: + # Strip any trailing slash from the destination.
5808: + func_stripname '' '/' "$dest"
5809: + dest=$func_stripname_result
5810: +
5811: + # Check to see that the destination is a directory.
5812: + test -d "$dest" && isdir=:
5813: + if $isdir; then
5814: + destdir=$dest
5815: + destname=
5816: + else
5817: + func_dirname_and_basename "$dest" "" "."
5818: + destdir=$func_dirname_result
5819: + destname=$func_basename_result
5820: +
5821: + # Not a directory, so check to see that there is only one file specified.
5822: + set dummy $files; shift
5823: + test "$#" -gt 1 && \
5824: + func_fatal_help "'$dest' is not a directory"
5825: + fi
5826: + case $destdir in
5827: + [\\/]* | [A-Za-z]:[\\/]*) ;;
5828: + *)
5829: + for file in $files; do
5830: + case $file in
5831: + *.lo) ;;
5832: + *)
5833: + func_fatal_help "'$destdir' must be an absolute directory name"
5834: + ;;
5835: + esac
5836: + done
5837: + ;;
5838: + esac
5839: +
5840: + # This variable tells wrapper scripts just to set variables rather
5841: + # than running their programs.
5842: + libtool_install_magic=$magic
5843: +
5844: + staticlibs=
5845: + future_libdirs=
5846: + current_libdirs=
5847: + for file in $files; do
5848: +
5849: + # Do each installation.
5850: + case $file in
5851: + *.$libext)
5852: + # Do the static libraries later.
5853: + func_append staticlibs " $file"
5854: + ;;
5855: +
5856: + *.la)
5857: + func_resolve_sysroot "$file"
5858: + file=$func_resolve_sysroot_result
5859: +
5860: + # Check to see that this really is a libtool archive.
5861: + func_lalib_unsafe_p "$file" \
5862: + || func_fatal_help "'$file' is not a valid libtool archive"
5863: +
5864: + library_names=
5865: + old_library=
5866: + relink_command=
5867: + func_source "$file"
5868: +
5869: + # Add the libdir to current_libdirs if it is the destination.
5870: + if test "X$destdir" = "X$libdir"; then
5871: + case "$current_libdirs " in
5872: + *" $libdir "*) ;;
5873: + *) func_append current_libdirs " $libdir" ;;
5874: + esac
5875: + else
5876: + # Note the libdir as a future libdir.
5877: + case "$future_libdirs " in
5878: + *" $libdir "*) ;;
5879: + *) func_append future_libdirs " $libdir" ;;
5880: + esac
5881: + fi
5882: +
5883: + func_dirname "$file" "/" ""
5884: + dir=$func_dirname_result
5885: + func_append dir "$objdir"
5886: +
5887: + if test -n "$relink_command"; then
5888: + # Determine the prefix the user has applied to our future dir.
5889: + inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
5890: +
5891: + # Don't allow the user to place us outside of our expected
5892: + # location b/c this prevents finding dependent libraries that
5893: + # are installed to the same prefix.
5894: + # At present, this check doesn't affect windows .dll's that
5895: + # are installed into $libdir/../bin (currently, that works fine)
5896: + # but it's something to keep an eye on.
5897: + test "$inst_prefix_dir" = "$destdir" && \
5898: + func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
5899: +
5900: + if test -n "$inst_prefix_dir"; then
5901: + # Stick the inst_prefix_dir data into the link command.
5902: + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5903: + else
5904: + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5905: + fi
5906: +
5907: + func_warning "relinking '$file'"
5908: + func_show_eval "$relink_command" \
5909: + 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
5910: + fi
5911: +
5912: + # See the names of the shared library.
5913: + set dummy $library_names; shift
5914: + if test -n "$1"; then
5915: + realname=$1
5916: + shift
5917: +
5918: + srcname=$realname
5919: + test -n "$relink_command" && srcname=${realname}T
5920: +
5921: + # Install the shared library and build the symlinks.
5922: + func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
5923: + 'exit $?'
5924: + tstripme=$stripme
5925: + case $host_os in
5926: + cygwin* | mingw* | pw32* | cegcc*)
5927: + case $realname in
5928: + *.dll.a)
5929: + tstripme=
5930: + ;;
5931: + esac
5932: + ;;
5933: + os2*)
5934: + case $realname in
5935: + *_dll.a)
5936: + tstripme=
5937: + ;;
5938: + esac
5939: + ;;
5940: + esac
5941: + if test -n "$tstripme" && test -n "$striplib"; then
5942: + func_show_eval "$striplib $destdir/$realname" 'exit $?'
5943: + fi
5944: +
5945: + if test "$#" -gt 0; then
5946: + # Delete the old symlinks, and create new ones.
5947: + # Try 'ln -sf' first, because the 'ln' binary might depend on
5948: + # the symlink we replace! Solaris /bin/ln does not understand -f,
5949: + # so we also need to try rm && ln -s.
5950: + for linkname
5951: + do
5952: + test "$linkname" != "$realname" \
5953: + && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
5954: + done
5955: + fi
5956: +
5957: + # Do each command in the postinstall commands.
5958: + lib=$destdir/$realname
5959: + func_execute_cmds "$postinstall_cmds" 'exit $?'
5960: + fi
5961: +
5962: + # Install the pseudo-library for information purposes.
5963: + func_basename "$file"
5964: + name=$func_basename_result
5965: + instname=$dir/${name}i
5966: + func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
5967: +
5968: + # Maybe install the static library, too.
5969: + test -n "$old_library" && func_append staticlibs " $dir/$old_library"
5970: + ;;
5971: +
5972: + *.lo)
5973: + # Install (i.e. copy) a libtool object.
5974: +
5975: + # Figure out destination file name, if it wasn't already specified.
5976: + if test -n "$destname"; then
5977: + destfile=$destdir/$destname
5978: + else
5979: + func_basename "$file"
5980: + destfile=$func_basename_result
5981: + destfile=$destdir/$destfile
5982: + fi
5983: +
5984: + # Deduce the name of the destination old-style object file.
5985: + case $destfile in
5986: + *.lo)
5987: + func_lo2o "$destfile"
5988: + staticdest=$func_lo2o_result
5989: + ;;
5990: + *.$objext)
5991: + staticdest=$destfile
5992: + destfile=
5993: + ;;
5994: + *)
5995: + func_fatal_help "cannot copy a libtool object to '$destfile'"
5996: + ;;
5997: + esac
5998: +
5999: + # Install the libtool object if requested.
6000: + test -n "$destfile" && \
6001: + func_show_eval "$install_prog $file $destfile" 'exit $?'
6002: +
6003: + # Install the old object if enabled.
6004: + if test yes = "$build_old_libs"; then
6005: + # Deduce the name of the old-style object file.
6006: + func_lo2o "$file"
6007: + staticobj=$func_lo2o_result
6008: + func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
6009: + fi
6010: + exit $EXIT_SUCCESS
6011: + ;;
6012: +
6013: + *)
6014: + # Figure out destination file name, if it wasn't already specified.
6015: + if test -n "$destname"; then
6016: + destfile=$destdir/$destname
6017: + else
6018: + func_basename "$file"
6019: + destfile=$func_basename_result
6020: + destfile=$destdir/$destfile
6021: + fi
6022: +
6023: + # If the file is missing, and there is a .exe on the end, strip it
6024: + # because it is most likely a libtool script we actually want to
6025: + # install
6026: + stripped_ext=
6027: + case $file in
6028: + *.exe)
6029: + if test ! -f "$file"; then
6030: + func_stripname '' '.exe' "$file"
6031: + file=$func_stripname_result
6032: + stripped_ext=.exe
6033: + fi
6034: + ;;
6035: + esac
6036: +
6037: + # Do a test to see if this is really a libtool program.
6038: + case $host in
6039: + *cygwin* | *mingw*)
6040: + if func_ltwrapper_executable_p "$file"; then
6041: + func_ltwrapper_scriptname "$file"
6042: + wrapper=$func_ltwrapper_scriptname_result
6043: + else
6044: + func_stripname '' '.exe' "$file"
6045: + wrapper=$func_stripname_result
6046: + fi
6047: + ;;
6048: + *)
6049: + wrapper=$file
6050: + ;;
6051: + esac
6052: + if func_ltwrapper_script_p "$wrapper"; then
6053: + notinst_deplibs=
6054: + relink_command=
6055: +
6056: + func_source "$wrapper"
6057: +
6058: + # Check the variables that should have been set.
6059: + test -z "$generated_by_libtool_version" && \
6060: + func_fatal_error "invalid libtool wrapper script '$wrapper'"
6061: +
6062: + finalize=:
6063: + for lib in $notinst_deplibs; do
6064: + # Check to see that each library is installed.
6065: + libdir=
6066: + if test -f "$lib"; then
6067: + func_source "$lib"
6068: + fi
6069: + libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
6070: + if test -n "$libdir" && test ! -f "$libfile"; then
6071: + func_warning "'$lib' has not been installed in '$libdir'"
6072: + finalize=false
6073: + fi
6074: + done
6075: +
6076: + relink_command=
6077: + func_source "$wrapper"
6078: +
6079: + outputname=
6080: + if test no = "$fast_install" && test -n "$relink_command"; then
6081: + $opt_dry_run || {
6082: + if $finalize; then
6083: + tmpdir=`func_mktempdir`
6084: + func_basename "$file$stripped_ext"
6085: + file=$func_basename_result
6086: + outputname=$tmpdir/$file
6087: + # Replace the output file specification.
6088: + relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
6089: +
6090: + $opt_quiet || {
6091: + func_quote_for_expand "$relink_command"
6092: + eval "func_echo $func_quote_for_expand_result"
6093: + }
6094: + if eval "$relink_command"; then :
6095: + else
6096: + func_error "error: relink '$file' with the above command before installing it"
6097: + $opt_dry_run || ${RM}r "$tmpdir"
6098: + continue
6099: + fi
6100: + file=$outputname
6101: + else
6102: + func_warning "cannot relink '$file'"
6103: + fi
6104: + }
6105: + else
6106: + # Install the binary that we compiled earlier.
6107: + file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
6108: + fi
6109: + fi
6110: +
6111: + # remove .exe since cygwin /usr/bin/install will append another
6112: + # one anyway
6113: + case $install_prog,$host in
6114: + */usr/bin/install*,*cygwin*)
6115: + case $file:$destfile in
6116: + *.exe:*.exe)
6117: + # this is ok
6118: + ;;
6119: + *.exe:*)
6120: + destfile=$destfile.exe
6121: + ;;
6122: + *:*.exe)
6123: + func_stripname '' '.exe' "$destfile"
6124: + destfile=$func_stripname_result
6125: + ;;
6126: + esac
6127: + ;;
6128: + esac
6129: + func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
6130: + $opt_dry_run || if test -n "$outputname"; then
6131: + ${RM}r "$tmpdir"
6132: + fi
6133: + ;;
6134: + esac
6135: + done
6136: +
6137: + for file in $staticlibs; do
6138: + func_basename "$file"
6139: + name=$func_basename_result
6140: +
6141: + # Set up the ranlib parameters.
6142: + oldlib=$destdir/$name
6143: + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
6144: + tool_oldlib=$func_to_tool_file_result
6145: +
6146: + func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
6147: +
6148: + if test -n "$stripme" && test -n "$old_striplib"; then
6149: + func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
6150: + fi
6151: +
6152: + # Do each command in the postinstall commands.
6153: + func_execute_cmds "$old_postinstall_cmds" 'exit $?'
6154: + done
6155: +
6156: + test -n "$future_libdirs" && \
6157: + func_warning "remember to run '$progname --finish$future_libdirs'"
6158: +
6159: + if test -n "$current_libdirs"; then
6160: + # Maybe just do a dry run.
6161: + $opt_dry_run && current_libdirs=" -n$current_libdirs"
6162: + exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
6163: + else
6164: + exit $EXIT_SUCCESS
6165: + fi
6166: +}
6167: +
6168: +test install = "$opt_mode" && func_mode_install ${1+"$@"}
6169: +
6170: +
6171: +# func_generate_dlsyms outputname originator pic_p
6172: +# Extract symbols from dlprefiles and create ${outputname}S.o with
6173: +# a dlpreopen symbol table.
6174: +func_generate_dlsyms ()
6175: +{
6176: + $debug_cmd
6177: +
6178: + my_outputname=$1
6179: + my_originator=$2
6180: + my_pic_p=${3-false}
6181: + my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
6182: + my_dlsyms=
6183: +
6184: + if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
6185: + if test -n "$NM" && test -n "$global_symbol_pipe"; then
6186: + my_dlsyms=${my_outputname}S.c
6187: + else
6188: + func_error "not configured to extract global symbols from dlpreopened files"
6189: + fi
6190: + fi
6191: +
6192: + if test -n "$my_dlsyms"; then
6193: + case $my_dlsyms in
6194: + "") ;;
6195: + *.c)
6196: + # Discover the nlist of each of the dlfiles.
6197: + nlist=$output_objdir/$my_outputname.nm
6198: +
6199: + func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
6200: +
6201: + # Parse the name list into a source file.
6202: + func_verbose "creating $output_objdir/$my_dlsyms"
6203: +
6204: + $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
6205: +/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
6206: +/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
6207: +
6208: +#ifdef __cplusplus
6209: +extern \"C\" {
6210: +#endif
6211: +
6212: +#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
6213: +#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
6214: +#endif
6215: +
6216: +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
6217: +#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
6218: +/* DATA imports from DLLs on WIN32 can't be const, because runtime
6219: + relocations are performed -- see ld's documentation on pseudo-relocs. */
6220: +# define LT_DLSYM_CONST
6221: +#elif defined __osf__
6222: +/* This system does not cope well with relocations in const data. */
6223: +# define LT_DLSYM_CONST
6224: +#else
6225: +# define LT_DLSYM_CONST const
6226: +#endif
6227: +
6228: +#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
6229: +
6230: +/* External symbol declarations for the compiler. */\
6231: +"
6232: +
6233: + if test yes = "$dlself"; then
6234: + func_verbose "generating symbol list for '$output'"
6235: +
6236: + $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
6237: +
6238: + # Add our own program objects to the symbol list.
6239: + progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
6240: + for progfile in $progfiles; do
6241: + func_to_tool_file "$progfile" func_convert_file_msys_to_w32
6242: + func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
6243: + $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
6244: + done
6245: +
6246: + if test -n "$exclude_expsyms"; then
6247: + $opt_dry_run || {
6248: + eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
6249: + eval '$MV "$nlist"T "$nlist"'
6250: + }
6251: + fi
6252: +
6253: + if test -n "$export_symbols_regex"; then
6254: + $opt_dry_run || {
6255: + eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
6256: + eval '$MV "$nlist"T "$nlist"'
6257: + }
6258: + fi
6259: +
6260: + # Prepare the list of exported symbols
6261: + if test -z "$export_symbols"; then
6262: + export_symbols=$output_objdir/$outputname.exp
6263: + $opt_dry_run || {
6264: + $RM $export_symbols
6265: + eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
6266: + case $host in
6267: + *cygwin* | *mingw* | *cegcc* )
6268: + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
6269: + eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
6270: + ;;
6271: + esac
6272: + }
6273: + else
6274: + $opt_dry_run || {
6275: + eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
6276: + eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
6277: + eval '$MV "$nlist"T "$nlist"'
6278: + case $host in
6279: + *cygwin* | *mingw* | *cegcc* )
6280: + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
6281: + eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
6282: + ;;
6283: + esac
6284: + }
6285: + fi
6286: + fi
6287: +
6288: + for dlprefile in $dlprefiles; do
6289: + func_verbose "extracting global C symbols from '$dlprefile'"
6290: + func_basename "$dlprefile"
6291: + name=$func_basename_result
6292: + case $host in
6293: + *cygwin* | *mingw* | *cegcc* )
6294: + # if an import library, we need to obtain dlname
6295: + if func_win32_import_lib_p "$dlprefile"; then
6296: + func_tr_sh "$dlprefile"
6297: + eval "curr_lafile=\$libfile_$func_tr_sh_result"
6298: + dlprefile_dlbasename=
6299: + if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
6300: + # Use subshell, to avoid clobbering current variable values
6301: + dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
6302: + if test -n "$dlprefile_dlname"; then
6303: + func_basename "$dlprefile_dlname"
6304: + dlprefile_dlbasename=$func_basename_result
6305: + else
6306: + # no lafile. user explicitly requested -dlpreopen <import library>.
6307: + $sharedlib_from_linklib_cmd "$dlprefile"
6308: + dlprefile_dlbasename=$sharedlib_from_linklib_result
6309: + fi
6310: + fi
6311: + $opt_dry_run || {
6312: + if test -n "$dlprefile_dlbasename"; then
6313: + eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
6314: + else
6315: + func_warning "Could not compute DLL name from $name"
6316: + eval '$ECHO ": $name " >> "$nlist"'
6317: + fi
6318: + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
6319: + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
6320: + $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
6321: + }
6322: + else # not an import lib
6323: + $opt_dry_run || {
6324: + eval '$ECHO ": $name " >> "$nlist"'
6325: + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
6326: + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
6327: + }
6328: + fi
6329: + ;;
6330: + *)
6331: + $opt_dry_run || {
6332: + eval '$ECHO ": $name " >> "$nlist"'
6333: + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
6334: + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
6335: + }
6336: + ;;
6337: + esac
6338: + done
6339: +
6340: + $opt_dry_run || {
6341: + # Make sure we have at least an empty file.
6342: + test -f "$nlist" || : > "$nlist"
6343: +
6344: + if test -n "$exclude_expsyms"; then
6345: + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
6346: + $MV "$nlist"T "$nlist"
6347: + fi
6348: +
6349: + # Try sorting and uniquifying the output.
6350: + if $GREP -v "^: " < "$nlist" |
6351: + if sort -k 3 </dev/null >/dev/null 2>&1; then
6352: + sort -k 3
6353: + else
6354: + sort +2
6355: + fi |
6356: + uniq > "$nlist"S; then
6357: + :
6358: + else
6359: + $GREP -v "^: " < "$nlist" > "$nlist"S
6360: + fi
6361: +
6362: + if test -f "$nlist"S; then
6363: + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
6364: + else
6365: + echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
6366: + fi
6367: +
6368: + func_show_eval '$RM "${nlist}I"'
6369: + if test -n "$global_symbol_to_import"; then
6370: + eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
6371: + fi
6372: +
6373: + echo >> "$output_objdir/$my_dlsyms" "\
6374: +
6375: +/* The mapping between symbol names and symbols. */
6376: +typedef struct {
6377: + const char *name;
6378: + void *address;
6379: +} lt_dlsymlist;
6380: +extern LT_DLSYM_CONST lt_dlsymlist
6381: +lt_${my_prefix}_LTX_preloaded_symbols[];\
6382: +"
6383: +
6384: + if test -s "$nlist"I; then
6385: + echo >> "$output_objdir/$my_dlsyms" "\
6386: +static void lt_syminit(void)
6387: +{
6388: + LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
6389: + for (; symbol->name; ++symbol)
6390: + {"
6391: + $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
6392: + echo >> "$output_objdir/$my_dlsyms" "\
6393: + }
6394: +}"
6395: + fi
6396: + echo >> "$output_objdir/$my_dlsyms" "\
6397: +LT_DLSYM_CONST lt_dlsymlist
6398: +lt_${my_prefix}_LTX_preloaded_symbols[] =
6399: +{ {\"$my_originator\", (void *) 0},"
6400: +
6401: + if test -s "$nlist"I; then
6402: + echo >> "$output_objdir/$my_dlsyms" "\
6403: + {\"@INIT@\", (void *) <_syminit},"
6404: + fi
6405: +
6406: + case $need_lib_prefix in
6407: + no)
6408: + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
6409: + ;;
6410: + *)
6411: + eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
6412: + ;;
6413: + esac
6414: + echo >> "$output_objdir/$my_dlsyms" "\
6415: + {0, (void *) 0}
6416: +};
6417: +
6418: +/* This works around a problem in FreeBSD linker */
6419: +#ifdef FREEBSD_WORKAROUND
6420: +static const void *lt_preloaded_setup() {
6421: + return lt_${my_prefix}_LTX_preloaded_symbols;
6422: +}
6423: +#endif
6424: +
6425: +#ifdef __cplusplus
6426: +}
6427: +#endif\
6428: +"
6429: + } # !$opt_dry_run
6430: +
6431: + pic_flag_for_symtable=
6432: + case "$compile_command " in
6433: + *" -static "*) ;;
6434: + *)
6435: + case $host in
6436: + # compiling the symbol table file with pic_flag works around
6437: + # a FreeBSD bug that causes programs to crash when -lm is
6438: + # linked before any other PIC object. But we must not use
6439: + # pic_flag when linking with -static. The problem exists in
6440: + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
6441: + *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
6442: + pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
6443: + *-*-hpux*)
6444: + pic_flag_for_symtable=" $pic_flag" ;;
6445: + *)
6446: + $my_pic_p && pic_flag_for_symtable=" $pic_flag"
6447: + ;;
6448: + esac
6449: + ;;
6450: + esac
6451: + symtab_cflags=
6452: + for arg in $LTCFLAGS; do
6453: + case $arg in
6454: + -pie | -fpie | -fPIE) ;;
6455: + *) func_append symtab_cflags " $arg" ;;
6456: + esac
6457: + done
6458: +
6459: + # Now compile the dynamic symbol file.
6460: + func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
6461: +
6462: + # Clean up the generated files.
6463: + func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
6464: +
6465: + # Transform the symbol file into the correct name.
6466: + symfileobj=$output_objdir/${my_outputname}S.$objext
6467: + case $host in
6468: + *cygwin* | *mingw* | *cegcc* )
6469: + if test -f "$output_objdir/$my_outputname.def"; then
6470: + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
6471: + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
6472: + else
6473: + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
6474: + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
6475: + fi
6476: + ;;
6477: + *)
6478: + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
6479: + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
6480: + ;;
6481: + esac
6482: + ;;
6483: + *)
6484: + func_fatal_error "unknown suffix for '$my_dlsyms'"
6485: + ;;
6486: + esac
6487: + else
6488: + # We keep going just in case the user didn't refer to
6489: + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
6490: + # really was required.
6491: +
6492: + # Nullify the symbol file.
6493: + compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
6494: + finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
6495: + fi
6496: +}
6497: +
6498: +# func_cygming_gnu_implib_p ARG
6499: +# This predicate returns with zero status (TRUE) if
6500: +# ARG is a GNU/binutils-style import library. Returns
6501: +# with nonzero status (FALSE) otherwise.
6502: +func_cygming_gnu_implib_p ()
6503: +{
6504: + $debug_cmd
6505: +
6506: + func_to_tool_file "$1" func_convert_file_msys_to_w32
6507: + func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
6508: + test -n "$func_cygming_gnu_implib_tmp"
6509: +}
6510: +
6511: +# func_cygming_ms_implib_p ARG
6512: +# This predicate returns with zero status (TRUE) if
6513: +# ARG is an MS-style import library. Returns
6514: +# with nonzero status (FALSE) otherwise.
6515: +func_cygming_ms_implib_p ()
6516: +{
6517: + $debug_cmd
6518: +
6519: + func_to_tool_file "$1" func_convert_file_msys_to_w32
6520: + func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
6521: + test -n "$func_cygming_ms_implib_tmp"
6522: +}
6523: +
6524: +# func_win32_libid arg
6525: +# return the library type of file 'arg'
6526: +#
6527: +# Need a lot of goo to handle *both* DLLs and import libs
6528: +# Has to be a shell function in order to 'eat' the argument
6529: +# that is supplied when $file_magic_command is called.
6530: +# Despite the name, also deal with 64 bit binaries.
6531: +func_win32_libid ()
6532: +{
6533: + $debug_cmd
6534: +
6535: + win32_libid_type=unknown
6536: + win32_fileres=`file -L $1 2>/dev/null`
6537: + case $win32_fileres in
6538: + *ar\ archive\ import\ library*) # definitely import
6539: + win32_libid_type="x86 archive import"
6540: + ;;
6541: + *ar\ archive*) # could be an import, or static
6542: + # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
6543: + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
6544: + $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
6545: + case $nm_interface in
6546: + "MS dumpbin")
6547: + if func_cygming_ms_implib_p "$1" ||
6548: + func_cygming_gnu_implib_p "$1"
6549: + then
6550: + win32_nmres=import
6551: + else
6552: + win32_nmres=
6553: + fi
6554: + ;;
6555: + *)
6556: + func_to_tool_file "$1" func_convert_file_msys_to_w32
6557: + win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
6558: + $SED -n -e '
6559: + 1,100{
6560: + / I /{
6561: + s|.*|import|
6562: + p
6563: + q
6564: + }
6565: + }'`
6566: + ;;
6567: + esac
6568: + case $win32_nmres in
6569: + import*) win32_libid_type="x86 archive import";;
6570: + *) win32_libid_type="x86 archive static";;
6571: + esac
6572: + fi
6573: + ;;
6574: + *DLL*)
6575: + win32_libid_type="x86 DLL"
6576: + ;;
6577: + *executable*) # but shell scripts are "executable" too...
6578: + case $win32_fileres in
6579: + *MS\ Windows\ PE\ Intel*)
6580: + win32_libid_type="x86 DLL"
6581: + ;;
6582: + esac
6583: + ;;
6584: + esac
6585: + $ECHO "$win32_libid_type"
6586: +}
6587: +
6588: +# func_cygming_dll_for_implib ARG
6589: +#
6590: +# Platform-specific function to extract the
6591: +# name of the DLL associated with the specified
6592: +# import library ARG.
6593: +# Invoked by eval'ing the libtool variable
6594: +# $sharedlib_from_linklib_cmd
6595: +# Result is available in the variable
6596: +# $sharedlib_from_linklib_result
6597: +func_cygming_dll_for_implib ()
6598: +{
6599: + $debug_cmd
6600: +
6601: + sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
6602: +}
6603: +
6604: +# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
6605: +#
6606: +# The is the core of a fallback implementation of a
6607: +# platform-specific function to extract the name of the
6608: +# DLL associated with the specified import library LIBNAME.
6609: +#
6610: +# SECTION_NAME is either .idata$6 or .idata$7, depending
6611: +# on the platform and compiler that created the implib.
6612: +#
6613: +# Echos the name of the DLL associated with the
6614: +# specified import library.
6615: +func_cygming_dll_for_implib_fallback_core ()
6616: +{
6617: + $debug_cmd
6618: +
6619: + match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
6620: + $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
6621: + $SED '/^Contents of section '"$match_literal"':/{
6622: + # Place marker at beginning of archive member dllname section
6623: + s/.*/====MARK====/
6624: + p
6625: + d
6626: + }
6627: + # These lines can sometimes be longer than 43 characters, but
6628: + # are always uninteresting
6629: + /:[ ]*file format pe[i]\{,1\}-/d
6630: + /^In archive [^:]*:/d
6631: + # Ensure marker is printed
6632: + /^====MARK====/p
6633: + # Remove all lines with less than 43 characters
6634: + /^.\{43\}/!d
6635: + # From remaining lines, remove first 43 characters
6636: + s/^.\{43\}//' |
6637: + $SED -n '
6638: + # Join marker and all lines until next marker into a single line
6639: + /^====MARK====/ b para
6640: + H
6641: + $ b para
6642: + b
6643: + :para
6644: + x
6645: + s/\n//g
6646: + # Remove the marker
6647: + s/^====MARK====//
6648: + # Remove trailing dots and whitespace
6649: + s/[\. \t]*$//
6650: + # Print
6651: + /./p' |
6652: + # we now have a list, one entry per line, of the stringified
6653: + # contents of the appropriate section of all members of the
6654: + # archive that possess that section. Heuristic: eliminate
6655: + # all those that have a first or second character that is
6656: + # a '.' (that is, objdump's representation of an unprintable
6657: + # character.) This should work for all archives with less than
6658: + # 0x302f exports -- but will fail for DLLs whose name actually
6659: + # begins with a literal '.' or a single character followed by
6660: + # a '.'.
6661: + #
6662: + # Of those that remain, print the first one.
6663: + $SED -e '/^\./d;/^.\./d;q'
6664: +}
6665: +
6666: +# func_cygming_dll_for_implib_fallback ARG
6667: +# Platform-specific function to extract the
6668: +# name of the DLL associated with the specified
6669: +# import library ARG.
6670: +#
6671: +# This fallback implementation is for use when $DLLTOOL
6672: +# does not support the --identify-strict option.
6673: +# Invoked by eval'ing the libtool variable
6674: +# $sharedlib_from_linklib_cmd
6675: +# Result is available in the variable
6676: +# $sharedlib_from_linklib_result
6677: +func_cygming_dll_for_implib_fallback ()
6678: +{
6679: + $debug_cmd
6680: +
6681: + if func_cygming_gnu_implib_p "$1"; then
6682: + # binutils import library
6683: + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
6684: + elif func_cygming_ms_implib_p "$1"; then
6685: + # ms-generated import library
6686: + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
6687: + else
6688: + # unknown
6689: + sharedlib_from_linklib_result=
6690: + fi
6691: +}
6692: +
6693: +
6694: +# func_extract_an_archive dir oldlib
6695: +func_extract_an_archive ()
6696: +{
6697: + $debug_cmd
6698: +
6699: + f_ex_an_ar_dir=$1; shift
6700: + f_ex_an_ar_oldlib=$1
6701: + if test yes = "$lock_old_archive_extraction"; then
6702: + lockfile=$f_ex_an_ar_oldlib.lock
6703: + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
6704: + func_echo "Waiting for $lockfile to be removed"
6705: + sleep 2
6706: + done
6707: + fi
6708: + func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
6709: + 'stat=$?; rm -f "$lockfile"; exit $stat'
6710: + if test yes = "$lock_old_archive_extraction"; then
6711: + $opt_dry_run || rm -f "$lockfile"
6712: + fi
6713: + if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
6714: + :
6715: + else
6716: + func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
6717: + fi
6718: +}
6719: +
6720: +
6721: +# func_extract_archives gentop oldlib ...
6722: +func_extract_archives ()
6723: +{
6724: + $debug_cmd
6725: +
6726: + my_gentop=$1; shift
6727: + my_oldlibs=${1+"$@"}
6728: + my_oldobjs=
6729: + my_xlib=
6730: + my_xabs=
6731: + my_xdir=
6732: +
6733: + for my_xlib in $my_oldlibs; do
6734: + # Extract the objects.
6735: + case $my_xlib in
6736: + [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
6737: + *) my_xabs=`pwd`"/$my_xlib" ;;
6738: + esac
6739: + func_basename "$my_xlib"
6740: + my_xlib=$func_basename_result
6741: + my_xlib_u=$my_xlib
6742: + while :; do
6743: + case " $extracted_archives " in
6744: + *" $my_xlib_u "*)
6745: + func_arith $extracted_serial + 1
6746: + extracted_serial=$func_arith_result
6747: + my_xlib_u=lt$extracted_serial-$my_xlib ;;
6748: + *) break ;;
6749: + esac
6750: + done
6751: + extracted_archives="$extracted_archives $my_xlib_u"
6752: + my_xdir=$my_gentop/$my_xlib_u
6753: +
6754: + func_mkdir_p "$my_xdir"
6755: +
6756: + case $host in
6757: + *-darwin*)
6758: + func_verbose "Extracting $my_xabs"
6759: + # Do not bother doing anything if just a dry run
6760: + $opt_dry_run || {
6761: + darwin_orig_dir=`pwd`
6762: + cd $my_xdir || exit $?
6763: + darwin_archive=$my_xabs
6764: + darwin_curdir=`pwd`
6765: + func_basename "$darwin_archive"
6766: + darwin_base_archive=$func_basename_result
6767: + darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
6768: + if test -n "$darwin_arches"; then
6769: + darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
6770: + darwin_arch=
6771: + func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
6772: + for darwin_arch in $darwin_arches; do
6773: + func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
6774: + $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
6775: + cd "unfat-$$/$darwin_base_archive-$darwin_arch"
6776: + func_extract_an_archive "`pwd`" "$darwin_base_archive"
6777: + cd "$darwin_curdir"
6778: + $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
6779: + done # $darwin_arches
6780: + ## Okay now we've a bunch of thin objects, gotta fatten them up :)
6781: + darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
6782: + darwin_file=
6783: + darwin_files=
6784: + for darwin_file in $darwin_filelist; do
6785: + darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
6786: + $LIPO -create -output "$darwin_file" $darwin_files
6787: + done # $darwin_filelist
6788: + $RM -rf unfat-$$
6789: + cd "$darwin_orig_dir"
6790: + else
6791: + cd $darwin_orig_dir
6792: + func_extract_an_archive "$my_xdir" "$my_xabs"
6793: + fi # $darwin_arches
6794: + } # !$opt_dry_run
6795: + ;;
6796: + *)
6797: + func_extract_an_archive "$my_xdir" "$my_xabs"
6798: + ;;
6799: + esac
6800: + my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
6801: + done
6802: +
6803: + func_extract_archives_result=$my_oldobjs
6804: +}
6805: +
6806: +
6807: +# func_emit_wrapper [arg=no]
6808: +#
6809: +# Emit a libtool wrapper script on stdout.
6810: +# Don't directly open a file because we may want to
6811: +# incorporate the script contents within a cygwin/mingw
6812: +# wrapper executable. Must ONLY be called from within
6813: +# func_mode_link because it depends on a number of variables
6814: +# set therein.
6815: +#
6816: +# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
6817: +# variable will take. If 'yes', then the emitted script
6818: +# will assume that the directory where it is stored is
6819: +# the $objdir directory. This is a cygwin/mingw-specific
6820: +# behavior.
6821: +func_emit_wrapper ()
6822: +{
6823: + func_emit_wrapper_arg1=${1-no}
6824: +
6825: + $ECHO "\
6826: +#! $SHELL
6827: +
6828: +# $output - temporary wrapper script for $objdir/$outputname
6829: +# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
6830: +#
6831: +# The $output program cannot be directly executed until all the libtool
6832: +# libraries that it depends on are installed.
6833: +#
6834: +# This wrapper script should never be moved out of the build directory.
6835: +# If it is, it will not operate correctly.
6836: +
6837: +# Sed substitution that helps us do robust quoting. It backslashifies
6838: +# metacharacters that are still active within double-quoted strings.
6839: +sed_quote_subst='$sed_quote_subst'
6840: +
6841: +# Be Bourne compatible
6842: +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
6843: + emulate sh
6844: + NULLCMD=:
6845: + # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
6846: + # is contrary to our usage. Disable this feature.
6847: + alias -g '\${1+\"\$@\"}'='\"\$@\"'
6848: + setopt NO_GLOB_SUBST
6849: +else
6850: + case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
6851: +fi
6852: +BIN_SH=xpg4; export BIN_SH # for Tru64
6853: +DUALCASE=1; export DUALCASE # for MKS sh
6854: +
6855: +# The HP-UX ksh and POSIX shell print the target directory to stdout
6856: +# if CDPATH is set.
6857: +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
6858: +
6859: +relink_command=\"$relink_command\"
6860: +
6861: +# This environment variable determines our operation mode.
6862: +if test \"\$libtool_install_magic\" = \"$magic\"; then
6863: + # install mode needs the following variables:
6864: + generated_by_libtool_version='$macro_version'
6865: + notinst_deplibs='$notinst_deplibs'
6866: +else
6867: + # When we are sourced in execute mode, \$file and \$ECHO are already set.
6868: + if test \"\$libtool_execute_magic\" != \"$magic\"; then
6869: + file=\"\$0\""
6870: +
6871: + qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
6872: + $ECHO "\
6873: +
6874: +# A function that is used when there is no print builtin or printf.
6875: +func_fallback_echo ()
6876: +{
6877: + eval 'cat <<_LTECHO_EOF
6878: +\$1
6879: +_LTECHO_EOF'
6880: +}
6881: + ECHO=\"$qECHO\"
6882: + fi
6883: +
6884: +# Very basic option parsing. These options are (a) specific to
6885: +# the libtool wrapper, (b) are identical between the wrapper
6886: +# /script/ and the wrapper /executable/ that is used only on
6887: +# windows platforms, and (c) all begin with the string "--lt-"
6888: +# (application programs are unlikely to have options that match
6889: +# this pattern).
6890: +#
6891: +# There are only two supported options: --lt-debug and
6892: +# --lt-dump-script. There is, deliberately, no --lt-help.
6893: +#
6894: +# The first argument to this parsing function should be the
6895: +# script's $0 value, followed by "$@".
6896: +lt_option_debug=
6897: +func_parse_lt_options ()
6898: +{
6899: + lt_script_arg0=\$0
6900: + shift
6901: + for lt_opt
6902: + do
6903: + case \"\$lt_opt\" in
6904: + --lt-debug) lt_option_debug=1 ;;
6905: + --lt-dump-script)
6906: + lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
6907: + test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
6908: + lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
6909: + cat \"\$lt_dump_D/\$lt_dump_F\"
6910: + exit 0
6911: + ;;
6912: + --lt-*)
6913: + \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
6914: + exit 1
6915: + ;;
6916: + esac
6917: + done
6918: +
6919: + # Print the debug banner immediately:
6920: + if test -n \"\$lt_option_debug\"; then
6921: + echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
6922: + fi
6923: +}
6924: +
6925: +# Used when --lt-debug. Prints its arguments to stdout
6926: +# (redirection is the responsibility of the caller)
6927: +func_lt_dump_args ()
6928: +{
6929: + lt_dump_args_N=1;
6930: + for lt_arg
6931: + do
6932: + \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
6933: + lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
6934: + done
6935: +}
6936: +
6937: +# Core function for launching the target application
6938: +func_exec_program_core ()
6939: +{
6940: +"
6941: + case $host in
6942: + # Backslashes separate directories on plain windows
6943: + *-*-mingw | *-*-os2* | *-cegcc*)
6944: + $ECHO "\
6945: + if test -n \"\$lt_option_debug\"; then
6946: + \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
6947: + func_lt_dump_args \${1+\"\$@\"} 1>&2
6948: + fi
6949: + exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
6950: +"
6951: + ;;
6952: +
6953: + *)
6954: + $ECHO "\
6955: + if test -n \"\$lt_option_debug\"; then
6956: + \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
6957: + func_lt_dump_args \${1+\"\$@\"} 1>&2
6958: + fi
6959: + exec \"\$progdir/\$program\" \${1+\"\$@\"}
6960: +"
6961: + ;;
6962: + esac
6963: + $ECHO "\
6964: + \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
6965: + exit 1
6966: +}
6967: +
6968: +# A function to encapsulate launching the target application
6969: +# Strips options in the --lt-* namespace from \$@ and
6970: +# launches target application with the remaining arguments.
6971: +func_exec_program ()
6972: +{
6973: + case \" \$* \" in
6974: + *\\ --lt-*)
6975: + for lt_wr_arg
6976: + do
6977: + case \$lt_wr_arg in
6978: + --lt-*) ;;
6979: + *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
6980: + esac
6981: + shift
6982: + done ;;
6983: + esac
6984: + func_exec_program_core \${1+\"\$@\"}
6985: +}
6986: +
6987: + # Parse options
6988: + func_parse_lt_options \"\$0\" \${1+\"\$@\"}
6989: +
6990: + # Find the directory that this script lives in.
6991: + thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
6992: + test \"x\$thisdir\" = \"x\$file\" && thisdir=.
6993: +
6994: + # Follow symbolic links until we get to the real thisdir.
6995: + file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
6996: + while test -n \"\$file\"; do
6997: + destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
6998: +
6999: + # If there was a directory component, then change thisdir.
7000: + if test \"x\$destdir\" != \"x\$file\"; then
7001: + case \"\$destdir\" in
7002: + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
7003: + *) thisdir=\"\$thisdir/\$destdir\" ;;
7004: + esac
7005: + fi
7006: +
7007: + file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
7008: + file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
7009: + done
7010: +
7011: + # Usually 'no', except on cygwin/mingw when embedded into
7012: + # the cwrapper.
7013: + WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
7014: + if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
7015: + # special case for '.'
7016: + if test \"\$thisdir\" = \".\"; then
7017: + thisdir=\`pwd\`
7018: + fi
7019: + # remove .libs from thisdir
7020: + case \"\$thisdir\" in
7021: + *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
7022: + $objdir ) thisdir=. ;;
7023: + esac
7024: + fi
7025: +
7026: + # Try to get the absolute directory name.
7027: + absdir=\`cd \"\$thisdir\" && pwd\`
7028: + test -n \"\$absdir\" && thisdir=\"\$absdir\"
7029: +"
7030: +
7031: + if test yes = "$fast_install"; then
7032: + $ECHO "\
7033: + program=lt-'$outputname'$exeext
7034: + progdir=\"\$thisdir/$objdir\"
7035: +
7036: + if test ! -f \"\$progdir/\$program\" ||
7037: + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
7038: + test \"X\$file\" != \"X\$progdir/\$program\"; }; then
7039: +
7040: + file=\"\$\$-\$program\"
7041: +
7042: + if test ! -d \"\$progdir\"; then
7043: + $MKDIR \"\$progdir\"
7044: + else
7045: + $RM \"\$progdir/\$file\"
7046: + fi"
7047: +
7048: + $ECHO "\
7049: +
7050: + # relink executable if necessary
7051: + if test -n \"\$relink_command\"; then
7052: + if relink_command_output=\`eval \$relink_command 2>&1\`; then :
7053: + else
7054: + \$ECHO \"\$relink_command_output\" >&2
7055: + $RM \"\$progdir/\$file\"
7056: + exit 1
7057: + fi
7058: + fi
7059: +
7060: + $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
7061: + { $RM \"\$progdir/\$program\";
7062: + $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
7063: + $RM \"\$progdir/\$file\"
7064: + fi"
7065: + else
7066: + $ECHO "\
7067: + program='$outputname'
7068: + progdir=\"\$thisdir/$objdir\"
7069: +"
7070: + fi
7071: +
7072: + $ECHO "\
7073: +
7074: + if test -f \"\$progdir/\$program\"; then"
7075: +
7076: + # fixup the dll searchpath if we need to.
7077: + #
7078: + # Fix the DLL searchpath if we need to. Do this before prepending
7079: + # to shlibpath, because on Windows, both are PATH and uninstalled
7080: + # libraries must come first.
7081: + if test -n "$dllsearchpath"; then
7082: + $ECHO "\
7083: + # Add the dll search path components to the executable PATH
7084: + PATH=$dllsearchpath:\$PATH
7085: +"
7086: + fi
7087: +
7088: + # Export our shlibpath_var if we have one.
7089: + if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
7090: + $ECHO "\
7091: + # Add our own library path to $shlibpath_var
7092: + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
7093: +
7094: + # Some systems cannot cope with colon-terminated $shlibpath_var
7095: + # The second colon is a workaround for a bug in BeOS R4 sed
7096: + $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
7097: +
7098: + export $shlibpath_var
7099: +"
7100: + fi
7101: +
7102: + $ECHO "\
7103: + if test \"\$libtool_execute_magic\" != \"$magic\"; then
7104: + # Run the actual program with our arguments.
7105: + func_exec_program \${1+\"\$@\"}
7106: + fi
7107: + else
7108: + # The program doesn't exist.
7109: + \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
7110: + \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
7111: + \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
7112: + exit 1
7113: + fi
7114: +fi\
7115: +"
7116: +}
7117: +
7118: +
7119: +# func_emit_cwrapperexe_src
7120: +# emit the source code for a wrapper executable on stdout
7121: +# Must ONLY be called from within func_mode_link because
7122: +# it depends on a number of variable set therein.
7123: +func_emit_cwrapperexe_src ()
7124: +{
7125: + cat <<EOF
7126: +
7127: +/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
7128: + Generated by $PROGRAM (GNU $PACKAGE) $VERSION
7129: +
7130: + The $output program cannot be directly executed until all the libtool
7131: + libraries that it depends on are installed.
7132: +
7133: + This wrapper executable should never be moved out of the build directory.
7134: + If it is, it will not operate correctly.
7135: +*/
7136: +EOF
7137: + cat <<"EOF"
7138: +#ifdef _MSC_VER
7139: +# define _CRT_SECURE_NO_DEPRECATE 1
7140: +#endif
7141: +#include <stdio.h>
7142: +#include <stdlib.h>
7143: +#ifdef _MSC_VER
7144: +# include <direct.h>
7145: +# include <process.h>
7146: +# include <io.h>
7147: +#else
7148: +# include <unistd.h>
7149: +# include <stdint.h>
7150: +# ifdef __CYGWIN__
7151: +# include <io.h>
7152: +# endif
7153: +#endif
7154: +#include <malloc.h>
7155: +#include <stdarg.h>
7156: +#include <assert.h>
7157: +#include <string.h>
7158: +#include <ctype.h>
7159: +#include <errno.h>
7160: +#include <fcntl.h>
7161: +#include <sys/stat.h>
7162: +
7163: +#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
7164: +
7165: +/* declarations of non-ANSI functions */
7166: +#if defined __MINGW32__
7167: +# ifdef __STRICT_ANSI__
7168: +int _putenv (const char *);
7169: +# endif
7170: +#elif defined __CYGWIN__
7171: +# ifdef __STRICT_ANSI__
7172: +char *realpath (const char *, char *);
7173: +int putenv (char *);
7174: +int setenv (const char *, const char *, int);
7175: +# endif
7176: +/* #elif defined other_platform || defined ... */
7177: +#endif
7178: +
7179: +/* portability defines, excluding path handling macros */
7180: +#if defined _MSC_VER
7181: +# define setmode _setmode
7182: +# define stat _stat
7183: +# define chmod _chmod
7184: +# define getcwd _getcwd
7185: +# define putenv _putenv
7186: +# define S_IXUSR _S_IEXEC
7187: +#elif defined __MINGW32__
7188: +# define setmode _setmode
7189: +# define stat _stat
7190: +# define chmod _chmod
7191: +# define getcwd _getcwd
7192: +# define putenv _putenv
7193: +#elif defined __CYGWIN__
7194: +# define HAVE_SETENV
7195: +# define FOPEN_WB "wb"
7196: +/* #elif defined other platforms ... */
7197: +#endif
7198: +
7199: +#if defined PATH_MAX
7200: +# define LT_PATHMAX PATH_MAX
7201: +#elif defined MAXPATHLEN
7202: +# define LT_PATHMAX MAXPATHLEN
7203: +#else
7204: +# define LT_PATHMAX 1024
7205: +#endif
7206: +
7207: +#ifndef S_IXOTH
7208: +# define S_IXOTH 0
7209: +#endif
7210: +#ifndef S_IXGRP
7211: +# define S_IXGRP 0
7212: +#endif
7213: +
7214: +/* path handling portability macros */
7215: +#ifndef DIR_SEPARATOR
7216: +# define DIR_SEPARATOR '/'
7217: +# define PATH_SEPARATOR ':'
7218: +#endif
7219: +
7220: +#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
7221: + defined __OS2__
7222: +# define HAVE_DOS_BASED_FILE_SYSTEM
7223: +# define FOPEN_WB "wb"
7224: +# ifndef DIR_SEPARATOR_2
7225: +# define DIR_SEPARATOR_2 '\\'
7226: +# endif
7227: +# ifndef PATH_SEPARATOR_2
7228: +# define PATH_SEPARATOR_2 ';'
7229: +# endif
7230: +#endif
7231: +
7232: +#ifndef DIR_SEPARATOR_2
7233: +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
7234: +#else /* DIR_SEPARATOR_2 */
7235: +# define IS_DIR_SEPARATOR(ch) \
7236: + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
7237: +#endif /* DIR_SEPARATOR_2 */
7238: +
7239: +#ifndef PATH_SEPARATOR_2
7240: +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
7241: +#else /* PATH_SEPARATOR_2 */
7242: +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
7243: +#endif /* PATH_SEPARATOR_2 */
7244: +
7245: +#ifndef FOPEN_WB
7246: +# define FOPEN_WB "w"
7247: +#endif
7248: +#ifndef _O_BINARY
7249: +# define _O_BINARY 0
7250: +#endif
7251: +
7252: +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
7253: +#define XFREE(stale) do { \
7254: + if (stale) { free (stale); stale = 0; } \
7255: +} while (0)
7256: +
7257: +#if defined LT_DEBUGWRAPPER
7258: +static int lt_debug = 1;
7259: +#else
7260: +static int lt_debug = 0;
7261: +#endif
7262: +
7263: +const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
7264: +
7265: +void *xmalloc (size_t num);
7266: +char *xstrdup (const char *string);
7267: +const char *base_name (const char *name);
7268: +char *find_executable (const char *wrapper);
7269: +char *chase_symlinks (const char *pathspec);
7270: +int make_executable (const char *path);
7271: +int check_executable (const char *path);
7272: +char *strendzap (char *str, const char *pat);
7273: +void lt_debugprintf (const char *file, int line, const char *fmt, ...);
7274: +void lt_fatal (const char *file, int line, const char *message, ...);
7275: +static const char *nonnull (const char *s);
7276: +static const char *nonempty (const char *s);
7277: +void lt_setenv (const char *name, const char *value);
7278: +char *lt_extend_str (const char *orig_value, const char *add, int to_end);
7279: +void lt_update_exe_path (const char *name, const char *value);
7280: +void lt_update_lib_path (const char *name, const char *value);
7281: +char **prepare_spawn (char **argv);
7282: +void lt_dump_script (FILE *f);
7283: +EOF
7284: +
7285: + cat <<EOF
7286: +#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
7287: +# define externally_visible volatile
7288: +#else
7289: +# define externally_visible __attribute__((externally_visible)) volatile
7290: +#endif
7291: +externally_visible const char * MAGIC_EXE = "$magic_exe";
7292: +const char * LIB_PATH_VARNAME = "$shlibpath_var";
7293: +EOF
7294: +
7295: + if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
7296: + func_to_host_path "$temp_rpath"
7297: + cat <<EOF
7298: +const char * LIB_PATH_VALUE = "$func_to_host_path_result";
7299: +EOF
7300: + else
7301: + cat <<"EOF"
7302: +const char * LIB_PATH_VALUE = "";
7303: +EOF
7304: + fi
7305: +
7306: + if test -n "$dllsearchpath"; then
7307: + func_to_host_path "$dllsearchpath:"
7308: + cat <<EOF
7309: +const char * EXE_PATH_VARNAME = "PATH";
7310: +const char * EXE_PATH_VALUE = "$func_to_host_path_result";
7311: +EOF
7312: + else
7313: + cat <<"EOF"
7314: +const char * EXE_PATH_VARNAME = "";
7315: +const char * EXE_PATH_VALUE = "";
7316: +EOF
7317: + fi
7318: +
7319: + if test yes = "$fast_install"; then
7320: + cat <<EOF
7321: +const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
7322: +EOF
7323: + else
7324: + cat <<EOF
7325: +const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
7326: +EOF
7327: + fi
7328: +
7329: +
7330: + cat <<"EOF"
7331: +
7332: +#define LTWRAPPER_OPTION_PREFIX "--lt-"
7333: +
7334: +static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
7335: +static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
7336: +static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
7337: +
7338: +int
7339: +main (int argc, char *argv[])
7340: +{
7341: + char **newargz;
7342: + int newargc;
7343: + char *tmp_pathspec;
7344: + char *actual_cwrapper_path;
7345: + char *actual_cwrapper_name;
7346: + char *target_name;
7347: + char *lt_argv_zero;
7348: + int rval = 127;
7349: +
7350: + int i;
7351: +
7352: + program_name = (char *) xstrdup (base_name (argv[0]));
7353: + newargz = XMALLOC (char *, (size_t) argc + 1);
7354: +
7355: + /* very simple arg parsing; don't want to rely on getopt
7356: + * also, copy all non cwrapper options to newargz, except
7357: + * argz[0], which is handled differently
7358: + */
7359: + newargc=0;
7360: + for (i = 1; i < argc; i++)
7361: + {
7362: + if (STREQ (argv[i], dumpscript_opt))
7363: + {
7364: +EOF
7365: + case $host in
7366: + *mingw* | *cygwin* )
7367: + # make stdout use "unix" line endings
7368: + echo " setmode(1,_O_BINARY);"
7369: + ;;
7370: + esac
7371: +
7372: + cat <<"EOF"
7373: + lt_dump_script (stdout);
7374: + return 0;
7375: + }
7376: + if (STREQ (argv[i], debug_opt))
7377: + {
7378: + lt_debug = 1;
7379: + continue;
7380: + }
7381: + if (STREQ (argv[i], ltwrapper_option_prefix))
7382: + {
7383: + /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
7384: + namespace, but it is not one of the ones we know about and
7385: + have already dealt with, above (inluding dump-script), then
7386: + report an error. Otherwise, targets might begin to believe
7387: + they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
7388: + namespace. The first time any user complains about this, we'll
7389: + need to make LTWRAPPER_OPTION_PREFIX a configure-time option
7390: + or a configure.ac-settable value.
7391: + */
7392: + lt_fatal (__FILE__, __LINE__,
7393: + "unrecognized %s option: '%s'",
7394: + ltwrapper_option_prefix, argv[i]);
7395: + }
7396: + /* otherwise ... */
7397: + newargz[++newargc] = xstrdup (argv[i]);
7398: + }
7399: + newargz[++newargc] = NULL;
7400: +
7401: +EOF
7402: + cat <<EOF
7403: + /* The GNU banner must be the first non-error debug message */
7404: + lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
7405: +EOF
7406: + cat <<"EOF"
7407: + lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
7408: + lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
7409: +
7410: + tmp_pathspec = find_executable (argv[0]);
7411: + if (tmp_pathspec == NULL)
7412: + lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
7413: + lt_debugprintf (__FILE__, __LINE__,
7414: + "(main) found exe (before symlink chase) at: %s\n",
7415: + tmp_pathspec);
7416: +
7417: + actual_cwrapper_path = chase_symlinks (tmp_pathspec);
7418: + lt_debugprintf (__FILE__, __LINE__,
7419: + "(main) found exe (after symlink chase) at: %s\n",
7420: + actual_cwrapper_path);
7421: + XFREE (tmp_pathspec);
7422: +
7423: + actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
7424: + strendzap (actual_cwrapper_path, actual_cwrapper_name);
7425: +
7426: + /* wrapper name transforms */
7427: + strendzap (actual_cwrapper_name, ".exe");
7428: + tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
7429: + XFREE (actual_cwrapper_name);
7430: + actual_cwrapper_name = tmp_pathspec;
7431: + tmp_pathspec = 0;
7432: +
7433: + /* target_name transforms -- use actual target program name; might have lt- prefix */
7434: + target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
7435: + strendzap (target_name, ".exe");
7436: + tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
7437: + XFREE (target_name);
7438: + target_name = tmp_pathspec;
7439: + tmp_pathspec = 0;
7440: +
7441: + lt_debugprintf (__FILE__, __LINE__,
7442: + "(main) libtool target name: %s\n",
7443: + target_name);
7444: +EOF
7445: +
7446: + cat <<EOF
7447: + newargz[0] =
7448: + XMALLOC (char, (strlen (actual_cwrapper_path) +
7449: + strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
7450: + strcpy (newargz[0], actual_cwrapper_path);
7451: + strcat (newargz[0], "$objdir");
7452: + strcat (newargz[0], "/");
7453: +EOF
7454: +
7455: + cat <<"EOF"
7456: + /* stop here, and copy so we don't have to do this twice */
7457: + tmp_pathspec = xstrdup (newargz[0]);
7458: +
7459: + /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
7460: + strcat (newargz[0], actual_cwrapper_name);
7461: +
7462: + /* DO want the lt- prefix here if it exists, so use target_name */
7463: + lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
7464: + XFREE (tmp_pathspec);
7465: + tmp_pathspec = NULL;
7466: +EOF
7467: +
7468: + case $host_os in
7469: + mingw*)
7470: + cat <<"EOF"
7471: + {
7472: + char* p;
7473: + while ((p = strchr (newargz[0], '\\')) != NULL)
7474: + {
7475: + *p = '/';
7476: + }
7477: + while ((p = strchr (lt_argv_zero, '\\')) != NULL)
7478: + {
7479: + *p = '/';
7480: + }
7481: + }
7482: +EOF
7483: + ;;
7484: + esac
7485: +
7486: + cat <<"EOF"
7487: + XFREE (target_name);
7488: + XFREE (actual_cwrapper_path);
7489: + XFREE (actual_cwrapper_name);
7490: +
7491: + lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
7492: + lt_setenv ("DUALCASE", "1"); /* for MSK sh */
7493: + /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
7494: + be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
7495: + because on Windows, both *_VARNAMEs are PATH but uninstalled
7496: + libraries must come first. */
7497: + lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
7498: + lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
7499: +
7500: + lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
7501: + nonnull (lt_argv_zero));
7502: + for (i = 0; i < newargc; i++)
7503: + {
7504: + lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
7505: + i, nonnull (newargz[i]));
7506: + }
7507: +
7508: +EOF
7509: +
7510: + case $host_os in
7511: + mingw*)
7512: + cat <<"EOF"
7513: + /* execv doesn't actually work on mingw as expected on unix */
7514: + newargz = prepare_spawn (newargz);
7515: + rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
7516: + if (rval == -1)
7517: + {
7518: + /* failed to start process */
7519: + lt_debugprintf (__FILE__, __LINE__,
7520: + "(main) failed to launch target \"%s\": %s\n",
7521: + lt_argv_zero, nonnull (strerror (errno)));
7522: + return 127;
7523: + }
7524: + return rval;
7525: +EOF
7526: + ;;
7527: + *)
7528: + cat <<"EOF"
7529: + execv (lt_argv_zero, newargz);
7530: + return rval; /* =127, but avoids unused variable warning */
7531: +EOF
7532: + ;;
7533: + esac
7534: +
7535: + cat <<"EOF"
7536: +}
7537: +
7538: +void *
7539: +xmalloc (size_t num)
7540: +{
7541: + void *p = (void *) malloc (num);
7542: + if (!p)
7543: + lt_fatal (__FILE__, __LINE__, "memory exhausted");
7544: +
7545: + return p;
7546: +}
7547: +
7548: +char *
7549: +xstrdup (const char *string)
7550: +{
7551: + return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
7552: + string) : NULL;
7553: +}
7554: +
7555: +const char *
7556: +base_name (const char *name)
7557: +{
7558: + const char *base;
7559: +
7560: +#if defined HAVE_DOS_BASED_FILE_SYSTEM
7561: + /* Skip over the disk name in MSDOS pathnames. */
7562: + if (isalpha ((unsigned char) name[0]) && name[1] == ':')
7563: + name += 2;
7564: +#endif
7565: +
7566: + for (base = name; *name; name++)
7567: + if (IS_DIR_SEPARATOR (*name))
7568: + base = name + 1;
7569: + return base;
7570: +}
7571: +
7572: +int
7573: +check_executable (const char *path)
7574: +{
7575: + struct stat st;
7576: +
7577: + lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
7578: + nonempty (path));
7579: + if ((!path) || (!*path))
7580: + return 0;
7581: +
7582: + if ((stat (path, &st) >= 0)
7583: + && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
7584: + return 1;
7585: + else
7586: + return 0;
7587: +}
7588: +
7589: +int
7590: +make_executable (const char *path)
7591: +{
7592: + int rval = 0;
7593: + struct stat st;
7594: +
7595: + lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
7596: + nonempty (path));
7597: + if ((!path) || (!*path))
7598: + return 0;
7599: +
7600: + if (stat (path, &st) >= 0)
7601: + {
7602: + rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
7603: + }
7604: + return rval;
7605: +}
7606: +
7607: +/* Searches for the full path of the wrapper. Returns
7608: + newly allocated full path name if found, NULL otherwise
7609: + Does not chase symlinks, even on platforms that support them.
7610: +*/
7611: +char *
7612: +find_executable (const char *wrapper)
7613: +{
7614: + int has_slash = 0;
7615: + const char *p;
7616: + const char *p_next;
7617: + /* static buffer for getcwd */
7618: + char tmp[LT_PATHMAX + 1];
7619: + size_t tmp_len;
7620: + char *concat_name;
7621: +
7622: + lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
7623: + nonempty (wrapper));
7624: +
7625: + if ((wrapper == NULL) || (*wrapper == '\0'))
7626: + return NULL;
7627: +
7628: + /* Absolute path? */
7629: +#if defined HAVE_DOS_BASED_FILE_SYSTEM
7630: + if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
7631: + {
7632: + concat_name = xstrdup (wrapper);
7633: + if (check_executable (concat_name))
7634: + return concat_name;
7635: + XFREE (concat_name);
7636: + }
7637: + else
7638: + {
7639: +#endif
7640: + if (IS_DIR_SEPARATOR (wrapper[0]))
7641: + {
7642: + concat_name = xstrdup (wrapper);
7643: + if (check_executable (concat_name))
7644: + return concat_name;
7645: + XFREE (concat_name);
7646: + }
7647: +#if defined HAVE_DOS_BASED_FILE_SYSTEM
7648: + }
7649: +#endif
7650: +
7651: + for (p = wrapper; *p; p++)
7652: + if (*p == '/')
7653: + {
7654: + has_slash = 1;
7655: + break;
7656: + }
7657: + if (!has_slash)
7658: + {
7659: + /* no slashes; search PATH */
7660: + const char *path = getenv ("PATH");
7661: + if (path != NULL)
7662: + {
7663: + for (p = path; *p; p = p_next)
7664: + {
7665: + const char *q;
7666: + size_t p_len;
7667: + for (q = p; *q; q++)
7668: + if (IS_PATH_SEPARATOR (*q))
7669: + break;
7670: + p_len = (size_t) (q - p);
7671: + p_next = (*q == '\0' ? q : q + 1);
7672: + if (p_len == 0)
7673: + {
7674: + /* empty path: current directory */
7675: + if (getcwd (tmp, LT_PATHMAX) == NULL)
7676: + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
7677: + nonnull (strerror (errno)));
7678: + tmp_len = strlen (tmp);
7679: + concat_name =
7680: + XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
7681: + memcpy (concat_name, tmp, tmp_len);
7682: + concat_name[tmp_len] = '/';
7683: + strcpy (concat_name + tmp_len + 1, wrapper);
7684: + }
7685: + else
7686: + {
7687: + concat_name =
7688: + XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
7689: + memcpy (concat_name, p, p_len);
7690: + concat_name[p_len] = '/';
7691: + strcpy (concat_name + p_len + 1, wrapper);
7692: + }
7693: + if (check_executable (concat_name))
7694: + return concat_name;
7695: + XFREE (concat_name);
7696: + }
7697: + }
7698: + /* not found in PATH; assume curdir */
7699: + }
7700: + /* Relative path | not found in path: prepend cwd */
7701: + if (getcwd (tmp, LT_PATHMAX) == NULL)
7702: + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
7703: + nonnull (strerror (errno)));
7704: + tmp_len = strlen (tmp);
7705: + concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
7706: + memcpy (concat_name, tmp, tmp_len);
7707: + concat_name[tmp_len] = '/';
7708: + strcpy (concat_name + tmp_len + 1, wrapper);
7709: +
7710: + if (check_executable (concat_name))
7711: + return concat_name;
7712: + XFREE (concat_name);
7713: + return NULL;
7714: +}
7715: +
7716: +char *
7717: +chase_symlinks (const char *pathspec)
7718: +{
7719: +#ifndef S_ISLNK
7720: + return xstrdup (pathspec);
7721: +#else
7722: + char buf[LT_PATHMAX];
7723: + struct stat s;
7724: + char *tmp_pathspec = xstrdup (pathspec);
7725: + char *p;
7726: + int has_symlinks = 0;
7727: + while (strlen (tmp_pathspec) && !has_symlinks)
7728: + {
7729: + lt_debugprintf (__FILE__, __LINE__,
7730: + "checking path component for symlinks: %s\n",
7731: + tmp_pathspec);
7732: + if (lstat (tmp_pathspec, &s) == 0)
7733: + {
7734: + if (S_ISLNK (s.st_mode) != 0)
7735: + {
7736: + has_symlinks = 1;
7737: + break;
7738: + }
7739: +
7740: + /* search backwards for last DIR_SEPARATOR */
7741: + p = tmp_pathspec + strlen (tmp_pathspec) - 1;
7742: + while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
7743: + p--;
7744: + if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
7745: + {
7746: + /* no more DIR_SEPARATORS left */
7747: + break;
7748: + }
7749: + *p = '\0';
7750: + }
7751: + else
7752: + {
7753: + lt_fatal (__FILE__, __LINE__,
7754: + "error accessing file \"%s\": %s",
7755: + tmp_pathspec, nonnull (strerror (errno)));
7756: + }
7757: + }
7758: + XFREE (tmp_pathspec);
7759: +
7760: + if (!has_symlinks)
7761: + {
7762: + return xstrdup (pathspec);
7763: + }
7764: +
7765: + tmp_pathspec = realpath (pathspec, buf);
7766: + if (tmp_pathspec == 0)
7767: + {
7768: + lt_fatal (__FILE__, __LINE__,
7769: + "could not follow symlinks for %s", pathspec);
7770: + }
7771: + return xstrdup (tmp_pathspec);
7772: +#endif
7773: +}
7774: +
7775: +char *
7776: +strendzap (char *str, const char *pat)
7777: +{
7778: + size_t len, patlen;
7779: +
7780: + assert (str != NULL);
7781: + assert (pat != NULL);
7782: +
7783: + len = strlen (str);
7784: + patlen = strlen (pat);
7785: +
7786: + if (patlen <= len)
7787: + {
7788: + str += len - patlen;
7789: + if (STREQ (str, pat))
7790: + *str = '\0';
7791: + }
7792: + return str;
7793: +}
7794: +
7795: +void
7796: +lt_debugprintf (const char *file, int line, const char *fmt, ...)
7797: +{
7798: + va_list args;
7799: + if (lt_debug)
7800: + {
7801: + (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
7802: + va_start (args, fmt);
7803: + (void) vfprintf (stderr, fmt, args);
7804: + va_end (args);
7805: + }
7806: +}
7807: +
7808: +static void
7809: +lt_error_core (int exit_status, const char *file,
7810: + int line, const char *mode,
7811: + const char *message, va_list ap)
7812: +{
7813: + fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
7814: + vfprintf (stderr, message, ap);
7815: + fprintf (stderr, ".\n");
7816: +
7817: + if (exit_status >= 0)
7818: + exit (exit_status);
7819: +}
7820: +
7821: +void
7822: +lt_fatal (const char *file, int line, const char *message, ...)
7823: +{
7824: + va_list ap;
7825: + va_start (ap, message);
7826: + lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
7827: + va_end (ap);
7828: +}
7829: +
7830: +static const char *
7831: +nonnull (const char *s)
7832: +{
7833: + return s ? s : "(null)";
7834: +}
7835: +
7836: +static const char *
7837: +nonempty (const char *s)
7838: +{
7839: + return (s && !*s) ? "(empty)" : nonnull (s);
7840: +}
7841: +
7842: +void
7843: +lt_setenv (const char *name, const char *value)
7844: +{
7845: + lt_debugprintf (__FILE__, __LINE__,
7846: + "(lt_setenv) setting '%s' to '%s'\n",
7847: + nonnull (name), nonnull (value));
7848: + {
7849: +#ifdef HAVE_SETENV
7850: + /* always make a copy, for consistency with !HAVE_SETENV */
7851: + char *str = xstrdup (value);
7852: + setenv (name, str, 1);
7853: +#else
7854: + size_t len = strlen (name) + 1 + strlen (value) + 1;
7855: + char *str = XMALLOC (char, len);
7856: + sprintf (str, "%s=%s", name, value);
7857: + if (putenv (str) != EXIT_SUCCESS)
7858: + {
7859: + XFREE (str);
7860: + }
7861: +#endif
7862: + }
7863: +}
7864: +
7865: +char *
7866: +lt_extend_str (const char *orig_value, const char *add, int to_end)
7867: +{
7868: + char *new_value;
7869: + if (orig_value && *orig_value)
7870: + {
7871: + size_t orig_value_len = strlen (orig_value);
7872: + size_t add_len = strlen (add);
7873: + new_value = XMALLOC (char, add_len + orig_value_len + 1);
7874: + if (to_end)
7875: + {
7876: + strcpy (new_value, orig_value);
7877: + strcpy (new_value + orig_value_len, add);
7878: + }
7879: + else
7880: + {
7881: + strcpy (new_value, add);
7882: + strcpy (new_value + add_len, orig_value);
7883: + }
7884: + }
7885: + else
7886: + {
7887: + new_value = xstrdup (add);
7888: + }
7889: + return new_value;
7890: +}
7891: +
7892: +void
7893: +lt_update_exe_path (const char *name, const char *value)
7894: +{
7895: + lt_debugprintf (__FILE__, __LINE__,
7896: + "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
7897: + nonnull (name), nonnull (value));
7898: +
7899: + if (name && *name && value && *value)
7900: + {
7901: + char *new_value = lt_extend_str (getenv (name), value, 0);
7902: + /* some systems can't cope with a ':'-terminated path #' */
7903: + size_t len = strlen (new_value);
7904: + while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
7905: + {
7906: + new_value[--len] = '\0';
7907: + }
7908: + lt_setenv (name, new_value);
7909: + XFREE (new_value);
7910: + }
7911: +}
7912: +
7913: +void
7914: +lt_update_lib_path (const char *name, const char *value)
7915: +{
7916: + lt_debugprintf (__FILE__, __LINE__,
7917: + "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
7918: + nonnull (name), nonnull (value));
7919: +
7920: + if (name && *name && value && *value)
7921: + {
7922: + char *new_value = lt_extend_str (getenv (name), value, 0);
7923: + lt_setenv (name, new_value);
7924: + XFREE (new_value);
7925: + }
7926: +}
7927: +
7928: +EOF
7929: + case $host_os in
7930: + mingw*)
7931: + cat <<"EOF"
7932: +
7933: +/* Prepares an argument vector before calling spawn().
7934: + Note that spawn() does not by itself call the command interpreter
7935: + (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
7936: + ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
7937: + GetVersionEx(&v);
7938: + v.dwPlatformId == VER_PLATFORM_WIN32_NT;
7939: + }) ? "cmd.exe" : "command.com").
7940: + Instead it simply concatenates the arguments, separated by ' ', and calls
7941: + CreateProcess(). We must quote the arguments since Win32 CreateProcess()
7942: + interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
7943: + special way:
7944: + - Space and tab are interpreted as delimiters. They are not treated as
7945: + delimiters if they are surrounded by double quotes: "...".
7946: + - Unescaped double quotes are removed from the input. Their only effect is
7947: + that within double quotes, space and tab are treated like normal
7948: + characters.
7949: + - Backslashes not followed by double quotes are not special.
7950: + - But 2*n+1 backslashes followed by a double quote become
7951: + n backslashes followed by a double quote (n >= 0):
7952: + \" -> "
7953: + \\\" -> \"
7954: + \\\\\" -> \\"
7955: + */
7956: +#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
7957: +#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
7958: +char **
7959: +prepare_spawn (char **argv)
7960: +{
7961: + size_t argc;
7962: + char **new_argv;
7963: + size_t i;
7964: +
7965: + /* Count number of arguments. */
7966: + for (argc = 0; argv[argc] != NULL; argc++)
7967: + ;
7968: +
7969: + /* Allocate new argument vector. */
7970: + new_argv = XMALLOC (char *, argc + 1);
7971: +
7972: + /* Put quoted arguments into the new argument vector. */
7973: + for (i = 0; i < argc; i++)
7974: + {
7975: + const char *string = argv[i];
7976: +
7977: + if (string[0] == '\0')
7978: + new_argv[i] = xstrdup ("\"\"");
7979: + else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
7980: + {
7981: + int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
7982: + size_t length;
7983: + unsigned int backslashes;
7984: + const char *s;
7985: + char *quoted_string;
7986: + char *p;
7987: +
7988: + length = 0;
7989: + backslashes = 0;
7990: + if (quote_around)
7991: + length++;
7992: + for (s = string; *s != '\0'; s++)
7993: + {
7994: + char c = *s;
7995: + if (c == '"')
7996: + length += backslashes + 1;
7997: + length++;
7998: + if (c == '\\')
7999: + backslashes++;
8000: + else
8001: + backslashes = 0;
8002: + }
8003: + if (quote_around)
8004: + length += backslashes + 1;
8005: +
8006: + quoted_string = XMALLOC (char, length + 1);
8007: +
8008: + p = quoted_string;
8009: + backslashes = 0;
8010: + if (quote_around)
8011: + *p++ = '"';
8012: + for (s = string; *s != '\0'; s++)
8013: + {
8014: + char c = *s;
8015: + if (c == '"')
8016: + {
8017: + unsigned int j;
8018: + for (j = backslashes + 1; j > 0; j--)
8019: + *p++ = '\\';
8020: + }
8021: + *p++ = c;
8022: + if (c == '\\')
8023: + backslashes++;
8024: + else
8025: + backslashes = 0;
8026: + }
8027: + if (quote_around)
8028: + {
8029: + unsigned int j;
8030: + for (j = backslashes; j > 0; j--)
8031: + *p++ = '\\';
8032: + *p++ = '"';
8033: + }
8034: + *p = '\0';
8035: +
8036: + new_argv[i] = quoted_string;
8037: + }
8038: + else
8039: + new_argv[i] = (char *) string;
8040: + }
8041: + new_argv[argc] = NULL;
8042: +
8043: + return new_argv;
8044: +}
8045: +EOF
8046: + ;;
8047: + esac
8048: +
8049: + cat <<"EOF"
8050: +void lt_dump_script (FILE* f)
8051: +{
8052: +EOF
8053: + func_emit_wrapper yes |
8054: + $SED -n -e '
8055: +s/^\(.\{79\}\)\(..*\)/\1\
8056: +\2/
8057: +h
8058: +s/\([\\"]\)/\\\1/g
8059: +s/$/\\n/
8060: +s/\([^\n]*\).*/ fputs ("\1", f);/p
8061: +g
8062: +D'
8063: + cat <<"EOF"
8064: +}
8065: +EOF
8066: +}
8067: +# end: func_emit_cwrapperexe_src
8068: +
8069: +# func_win32_import_lib_p ARG
8070: +# True if ARG is an import lib, as indicated by $file_magic_cmd
8071: +func_win32_import_lib_p ()
8072: +{
8073: + $debug_cmd
8074: +
8075: + case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
8076: + *import*) : ;;
8077: + *) false ;;
8078: + esac
8079: +}
8080: +
8081: +# func_suncc_cstd_abi
8082: +# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
8083: +# Several compiler flags select an ABI that is incompatible with the
8084: +# Cstd library. Avoid specifying it if any are in CXXFLAGS.
8085: +func_suncc_cstd_abi ()
8086: +{
8087: + $debug_cmd
8088: +
8089: + case " $compile_command " in
8090: + *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
8091: + suncc_use_cstd_abi=no
8092: + ;;
8093: + *)
8094: + suncc_use_cstd_abi=yes
8095: + ;;
8096: + esac
8097: +}
8098: +
8099: +# func_mode_link arg...
8100: +func_mode_link ()
8101: +{
8102: + $debug_cmd
8103: +
8104: + case $host in
8105: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8106: + # It is impossible to link a dll without this setting, and
8107: + # we shouldn't force the makefile maintainer to figure out
8108: + # what system we are compiling for in order to pass an extra
8109: + # flag for every libtool invocation.
8110: + # allow_undefined=no
8111: +
8112: + # FIXME: Unfortunately, there are problems with the above when trying
8113: + # to make a dll that has undefined symbols, in which case not
8114: + # even a static library is built. For now, we need to specify
8115: + # -no-undefined on the libtool link line when we can be certain
8116: + # that all symbols are satisfied, otherwise we get a static library.
8117: + allow_undefined=yes
8118: + ;;
8119: + *)
8120: + allow_undefined=yes
8121: + ;;
8122: + esac
8123: + libtool_args=$nonopt
8124: + base_compile="$nonopt $@"
8125: + compile_command=$nonopt
8126: + finalize_command=$nonopt
8127: +
8128: + compile_rpath=
8129: + finalize_rpath=
8130: + compile_shlibpath=
8131: + finalize_shlibpath=
8132: + convenience=
8133: + old_convenience=
8134: + deplibs=
8135: + old_deplibs=
8136: + compiler_flags=
8137: + linker_flags=
8138: + dllsearchpath=
8139: + lib_search_path=`pwd`
8140: + inst_prefix_dir=
8141: + new_inherited_linker_flags=
8142: +
8143: + avoid_version=no
8144: + bindir=
8145: + dlfiles=
8146: + dlprefiles=
8147: + dlself=no
8148: + export_dynamic=no
8149: + export_symbols=
8150: + export_symbols_regex=
8151: + generated=
8152: + libobjs=
8153: + ltlibs=
8154: + module=no
8155: + no_install=no
8156: + objs=
8157: + os2dllname=
8158: + non_pic_objects=
8159: + precious_files_regex=
8160: + prefer_static_libs=no
8161: + preload=false
8162: + prev=
8163: + prevarg=
8164: + release=
8165: + rpath=
8166: + xrpath=
8167: + perm_rpath=
8168: + temp_rpath=
8169: + thread_safe=no
8170: + vinfo=
8171: + vinfo_number=no
8172: + weak_libs=
8173: + single_module=$wl-single_module
8174: + func_infer_tag $base_compile
8175: +
8176: + # We need to know -static, to get the right output filenames.
8177: + for arg
8178: + do
8179: + case $arg in
8180: + -shared)
8181: + test yes != "$build_libtool_libs" \
8182: + && func_fatal_configuration "cannot build a shared library"
8183: + build_old_libs=no
8184: + break
8185: + ;;
8186: + -all-static | -static | -static-libtool-libs)
8187: + case $arg in
8188: + -all-static)
8189: + if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
8190: + func_warning "complete static linking is impossible in this configuration"
8191: + fi
8192: + if test -n "$link_static_flag"; then
8193: + dlopen_self=$dlopen_self_static
8194: + fi
8195: + prefer_static_libs=yes
8196: + ;;
8197: + -static)
8198: + if test -z "$pic_flag" && test -n "$link_static_flag"; then
8199: + dlopen_self=$dlopen_self_static
8200: + fi
8201: + prefer_static_libs=built
8202: + ;;
8203: + -static-libtool-libs)
8204: + if test -z "$pic_flag" && test -n "$link_static_flag"; then
8205: + dlopen_self=$dlopen_self_static
8206: + fi
8207: + prefer_static_libs=yes
8208: + ;;
8209: + esac
8210: + build_libtool_libs=no
8211: + build_old_libs=yes
8212: + break
8213: + ;;
8214: + esac
8215: + done
8216: +
8217: + # See if our shared archives depend on static archives.
8218: + test -n "$old_archive_from_new_cmds" && build_old_libs=yes
8219: +
8220: + # Go through the arguments, transforming them on the way.
8221: + while test "$#" -gt 0; do
8222: + arg=$1
8223: + shift
8224: + func_quote_for_eval "$arg"
8225: + qarg=$func_quote_for_eval_unquoted_result
8226: + func_append libtool_args " $func_quote_for_eval_result"
8227: +
8228: + # If the previous option needs an argument, assign it.
8229: + if test -n "$prev"; then
8230: + case $prev in
8231: + output)
8232: + func_append compile_command " @OUTPUT@"
8233: + func_append finalize_command " @OUTPUT@"
8234: + ;;
8235: + esac
8236: +
8237: + case $prev in
8238: + bindir)
8239: + bindir=$arg
8240: + prev=
8241: + continue
8242: + ;;
8243: + dlfiles|dlprefiles)
8244: + $preload || {
8245: + # Add the symbol object into the linking commands.
8246: + func_append compile_command " @SYMFILE@"
8247: + func_append finalize_command " @SYMFILE@"
8248: + preload=:
8249: + }
8250: + case $arg in
8251: + *.la | *.lo) ;; # We handle these cases below.
8252: + force)
8253: + if test no = "$dlself"; then
8254: + dlself=needless
8255: + export_dynamic=yes
8256: + fi
8257: + prev=
8258: + continue
8259: + ;;
8260: + self)
8261: + if test dlprefiles = "$prev"; then
8262: + dlself=yes
8263: + elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
8264: + dlself=yes
8265: + else
8266: + dlself=needless
8267: + export_dynamic=yes
8268: + fi
8269: + prev=
8270: + continue
8271: + ;;
8272: + *)
8273: + if test dlfiles = "$prev"; then
8274: + func_append dlfiles " $arg"
8275: + else
8276: + func_append dlprefiles " $arg"
8277: + fi
8278: + prev=
8279: + continue
8280: + ;;
8281: + esac
8282: + ;;
8283: + expsyms)
8284: + export_symbols=$arg
8285: + test -f "$arg" \
8286: + || func_fatal_error "symbol file '$arg' does not exist"
8287: + prev=
8288: + continue
8289: + ;;
8290: + expsyms_regex)
8291: + export_symbols_regex=$arg
8292: + prev=
8293: + continue
8294: + ;;
8295: + framework)
8296: + case $host in
8297: + *-*-darwin*)
8298: + case "$deplibs " in
8299: + *" $qarg.ltframework "*) ;;
8300: + *) func_append deplibs " $qarg.ltframework" # this is fixed later
8301: + ;;
8302: + esac
8303: + ;;
8304: + esac
8305: + prev=
8306: + continue
8307: + ;;
8308: + inst_prefix)
8309: + inst_prefix_dir=$arg
8310: + prev=
8311: + continue
8312: + ;;
8313: + mllvm)
8314: + # Clang does not use LLVM to link, so we can simply discard any
8315: + # '-mllvm $arg' options when doing the link step.
8316: + prev=
8317: + continue
8318: + ;;
8319: + objectlist)
8320: + if test -f "$arg"; then
8321: + save_arg=$arg
8322: + moreargs=
8323: + for fil in `cat "$save_arg"`
8324: + do
8325: +# func_append moreargs " $fil"
8326: + arg=$fil
8327: + # A libtool-controlled object.
8328: +
8329: + # Check to see that this really is a libtool object.
8330: + if func_lalib_unsafe_p "$arg"; then
8331: + pic_object=
8332: + non_pic_object=
8333: +
8334: + # Read the .lo file
8335: + func_source "$arg"
8336: +
8337: + if test -z "$pic_object" ||
8338: + test -z "$non_pic_object" ||
8339: + test none = "$pic_object" &&
8340: + test none = "$non_pic_object"; then
8341: + func_fatal_error "cannot find name of object for '$arg'"
8342: + fi
8343: +
8344: + # Extract subdirectory from the argument.
8345: + func_dirname "$arg" "/" ""
8346: + xdir=$func_dirname_result
8347: +
8348: + if test none != "$pic_object"; then
8349: + # Prepend the subdirectory the object is found in.
8350: + pic_object=$xdir$pic_object
8351: +
8352: + if test dlfiles = "$prev"; then
8353: + if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
8354: + func_append dlfiles " $pic_object"
8355: + prev=
8356: + continue
8357: + else
8358: + # If libtool objects are unsupported, then we need to preload.
8359: + prev=dlprefiles
8360: + fi
8361: + fi
8362: +
8363: + # CHECK ME: I think I busted this. -Ossama
8364: + if test dlprefiles = "$prev"; then
8365: + # Preload the old-style object.
8366: + func_append dlprefiles " $pic_object"
8367: + prev=
8368: + fi
8369: +
8370: + # A PIC object.
8371: + func_append libobjs " $pic_object"
8372: + arg=$pic_object
8373: + fi
8374: +
8375: + # Non-PIC object.
8376: + if test none != "$non_pic_object"; then
8377: + # Prepend the subdirectory the object is found in.
8378: + non_pic_object=$xdir$non_pic_object
8379: +
8380: + # A standard non-PIC object
8381: + func_append non_pic_objects " $non_pic_object"
8382: + if test -z "$pic_object" || test none = "$pic_object"; then
8383: + arg=$non_pic_object
8384: + fi
8385: + else
8386: + # If the PIC object exists, use it instead.
8387: + # $xdir was prepended to $pic_object above.
8388: + non_pic_object=$pic_object
8389: + func_append non_pic_objects " $non_pic_object"
8390: + fi
8391: + else
8392: + # Only an error if not doing a dry-run.
8393: + if $opt_dry_run; then
8394: + # Extract subdirectory from the argument.
8395: + func_dirname "$arg" "/" ""
8396: + xdir=$func_dirname_result
8397: +
8398: + func_lo2o "$arg"
8399: + pic_object=$xdir$objdir/$func_lo2o_result
8400: + non_pic_object=$xdir$func_lo2o_result
8401: + func_append libobjs " $pic_object"
8402: + func_append non_pic_objects " $non_pic_object"
8403: + else
8404: + func_fatal_error "'$arg' is not a valid libtool object"
8405: + fi
8406: + fi
8407: + done
8408: + else
8409: + func_fatal_error "link input file '$arg' does not exist"
8410: + fi
8411: + arg=$save_arg
8412: + prev=
8413: + continue
8414: + ;;
8415: + os2dllname)
8416: + os2dllname=$arg
8417: + prev=
8418: + continue
8419: + ;;
8420: + precious_regex)
8421: + precious_files_regex=$arg
8422: + prev=
8423: + continue
8424: + ;;
8425: + release)
8426: + release=-$arg
8427: + prev=
8428: + continue
8429: + ;;
8430: + rpath | xrpath)
8431: + # We need an absolute path.
8432: + case $arg in
8433: + [\\/]* | [A-Za-z]:[\\/]*) ;;
8434: + *)
8435: + func_fatal_error "only absolute run-paths are allowed"
8436: + ;;
8437: + esac
8438: + if test rpath = "$prev"; then
8439: + case "$rpath " in
8440: + *" $arg "*) ;;
8441: + *) func_append rpath " $arg" ;;
8442: + esac
8443: + else
8444: + case "$xrpath " in
8445: + *" $arg "*) ;;
8446: + *) func_append xrpath " $arg" ;;
8447: + esac
8448: + fi
8449: + prev=
8450: + continue
8451: + ;;
8452: + shrext)
8453: + shrext_cmds=$arg
8454: + prev=
8455: + continue
8456: + ;;
8457: + weak)
8458: + func_append weak_libs " $arg"
8459: + prev=
8460: + continue
8461: + ;;
8462: + xcclinker)
8463: + func_append linker_flags " $qarg"
8464: + func_append compiler_flags " $qarg"
8465: + prev=
8466: + func_append compile_command " $qarg"
8467: + func_append finalize_command " $qarg"
8468: + continue
8469: + ;;
8470: + xcompiler)
8471: + func_append compiler_flags " $qarg"
8472: + prev=
8473: + func_append compile_command " $qarg"
8474: + func_append finalize_command " $qarg"
8475: + continue
8476: + ;;
8477: + xlinker)
8478: + func_append linker_flags " $qarg"
8479: + func_append compiler_flags " $wl$qarg"
8480: + prev=
8481: + func_append compile_command " $wl$qarg"
8482: + func_append finalize_command " $wl$qarg"
8483: + continue
8484: + ;;
8485: + *)
8486: + eval "$prev=\"\$arg\""
8487: + prev=
8488: + continue
8489: + ;;
8490: + esac
8491: + fi # test -n "$prev"
8492: +
8493: + prevarg=$arg
8494: +
8495: + case $arg in
8496: + -all-static)
8497: + if test -n "$link_static_flag"; then
8498: + # See comment for -static flag below, for more details.
8499: + func_append compile_command " $link_static_flag"
8500: + func_append finalize_command " $link_static_flag"
8501: + fi
8502: + continue
8503: + ;;
8504: +
8505: + -allow-undefined)
8506: + # FIXME: remove this flag sometime in the future.
8507: + func_fatal_error "'-allow-undefined' must not be used because it is the default"
8508: + ;;
8509: +
8510: + -avoid-version)
8511: + avoid_version=yes
8512: + continue
8513: + ;;
8514: +
8515: + -bindir)
8516: + prev=bindir
8517: + continue
8518: + ;;
8519: +
8520: + -dlopen)
8521: + prev=dlfiles
8522: + continue
8523: + ;;
8524: +
8525: + -dlpreopen)
8526: + prev=dlprefiles
8527: + continue
8528: + ;;
8529: +
8530: + -export-dynamic)
8531: + export_dynamic=yes
8532: + continue
8533: + ;;
8534: +
8535: + -export-symbols | -export-symbols-regex)
8536: + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
8537: + func_fatal_error "more than one -exported-symbols argument is not allowed"
8538: + fi
8539: + if test X-export-symbols = "X$arg"; then
8540: + prev=expsyms
8541: + else
8542: + prev=expsyms_regex
8543: + fi
8544: + continue
8545: + ;;
8546: +
8547: + -framework)
8548: + prev=framework
8549: + continue
8550: + ;;
8551: +
8552: + -inst-prefix-dir)
8553: + prev=inst_prefix
8554: + continue
8555: + ;;
8556: +
8557: + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
8558: + # so, if we see these flags be careful not to treat them like -L
8559: + -L[A-Z][A-Z]*:*)
8560: + case $with_gcc/$host in
8561: + no/*-*-irix* | /*-*-irix*)
8562: + func_append compile_command " $arg"
8563: + func_append finalize_command " $arg"
8564: + ;;
8565: + esac
8566: + continue
8567: + ;;
8568: +
8569: + -L*)
8570: + func_stripname "-L" '' "$arg"
8571: + if test -z "$func_stripname_result"; then
8572: + if test "$#" -gt 0; then
8573: + func_fatal_error "require no space between '-L' and '$1'"
8574: + else
8575: + func_fatal_error "need path for '-L' option"
8576: + fi
8577: + fi
8578: + func_resolve_sysroot "$func_stripname_result"
8579: + dir=$func_resolve_sysroot_result
8580: + # We need an absolute path.
8581: + case $dir in
8582: + [\\/]* | [A-Za-z]:[\\/]*) ;;
8583: + *)
8584: + absdir=`cd "$dir" && pwd`
8585: + test -z "$absdir" && \
8586: + func_fatal_error "cannot determine absolute directory name of '$dir'"
8587: + dir=$absdir
8588: + ;;
8589: + esac
8590: + case "$deplibs " in
8591: + *" -L$dir "* | *" $arg "*)
8592: + # Will only happen for absolute or sysroot arguments
8593: + ;;
8594: + *)
8595: + # Preserve sysroot, but never include relative directories
8596: + case $dir in
8597: + [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
8598: + *) func_append deplibs " -L$dir" ;;
8599: + esac
8600: + func_append lib_search_path " $dir"
8601: + ;;
8602: + esac
8603: + case $host in
8604: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8605: + testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
8606: + case :$dllsearchpath: in
8607: + *":$dir:"*) ;;
8608: + ::) dllsearchpath=$dir;;
8609: + *) func_append dllsearchpath ":$dir";;
8610: + esac
8611: + case :$dllsearchpath: in
8612: + *":$testbindir:"*) ;;
8613: + ::) dllsearchpath=$testbindir;;
8614: + *) func_append dllsearchpath ":$testbindir";;
8615: + esac
8616: + ;;
8617: + esac
8618: + continue
8619: + ;;
8620: +
8621: + -l*)
8622: + if test X-lc = "X$arg" || test X-lm = "X$arg"; then
8623: + case $host in
8624: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
8625: + # These systems don't actually have a C or math library (as such)
8626: + continue
8627: + ;;
8628: + *-*-os2*)
8629: + # These systems don't actually have a C library (as such)
8630: + test X-lc = "X$arg" && continue
8631: + ;;
8632: + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
8633: + # Do not include libc due to us having libc/libc_r.
8634: + test X-lc = "X$arg" && continue
8635: + ;;
8636: + *-*-rhapsody* | *-*-darwin1.[012])
8637: + # Rhapsody C and math libraries are in the System framework
8638: + func_append deplibs " System.ltframework"
8639: + continue
8640: + ;;
8641: + *-*-sco3.2v5* | *-*-sco5v6*)
8642: + # Causes problems with __ctype
8643: + test X-lc = "X$arg" && continue
8644: + ;;
8645: + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
8646: + # Compiler inserts libc in the correct place for threads to work
8647: + test X-lc = "X$arg" && continue
8648: + ;;
8649: + esac
8650: + elif test X-lc_r = "X$arg"; then
8651: + case $host in
8652: + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
8653: + # Do not include libc_r directly, use -pthread flag.
8654: + continue
8655: + ;;
8656: + esac
8657: + fi
8658: + func_append deplibs " $arg"
8659: + continue
8660: + ;;
8661: +
8662: + -mllvm)
8663: + prev=mllvm
8664: + continue
8665: + ;;
8666: +
8667: + -module)
8668: + module=yes
8669: + continue
8670: + ;;
8671: +
8672: + # Tru64 UNIX uses -model [arg] to determine the layout of C++
8673: + # classes, name mangling, and exception handling.
8674: + # Darwin uses the -arch flag to determine output architecture.
8675: + -model|-arch|-isysroot|--sysroot)
8676: + func_append compiler_flags " $arg"
8677: + func_append compile_command " $arg"
8678: + func_append finalize_command " $arg"
8679: + prev=xcompiler
8680: + continue
8681: + ;;
8682: +
8683: + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
8684: + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
8685: + func_append compiler_flags " $arg"
8686: + func_append compile_command " $arg"
8687: + func_append finalize_command " $arg"
8688: + case "$new_inherited_linker_flags " in
8689: + *" $arg "*) ;;
8690: + * ) func_append new_inherited_linker_flags " $arg" ;;
8691: + esac
8692: + continue
8693: + ;;
8694: +
8695: + -multi_module)
8696: + single_module=$wl-multi_module
8697: + continue
8698: + ;;
8699: +
8700: + -no-fast-install)
8701: + fast_install=no
8702: + continue
8703: + ;;
8704: +
8705: + -no-install)
8706: + case $host in
8707: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
8708: + # The PATH hackery in wrapper scripts is required on Windows
8709: + # and Darwin in order for the loader to find any dlls it needs.
8710: + func_warning "'-no-install' is ignored for $host"
8711: + func_warning "assuming '-no-fast-install' instead"
8712: + fast_install=no
8713: + ;;
8714: + *) no_install=yes ;;
8715: + esac
8716: + continue
8717: + ;;
8718: +
8719: + -no-undefined)
8720: + allow_undefined=no
8721: + continue
8722: + ;;
8723: +
8724: + -objectlist)
8725: + prev=objectlist
8726: + continue
8727: + ;;
8728: +
8729: + -os2dllname)
8730: + prev=os2dllname
8731: + continue
8732: + ;;
8733: +
8734: + -o) prev=output ;;
8735: +
8736: + -precious-files-regex)
8737: + prev=precious_regex
8738: + continue
8739: + ;;
8740: +
8741: + -release)
8742: + prev=release
8743: + continue
8744: + ;;
8745: +
8746: + -rpath)
8747: + prev=rpath
8748: + continue
8749: + ;;
8750: +
8751: + -R)
8752: + prev=xrpath
8753: + continue
8754: + ;;
8755: +
8756: + -R*)
8757: + func_stripname '-R' '' "$arg"
8758: + dir=$func_stripname_result
8759: + # We need an absolute path.
8760: + case $dir in
8761: + [\\/]* | [A-Za-z]:[\\/]*) ;;
8762: + =*)
8763: + func_stripname '=' '' "$dir"
8764: + dir=$lt_sysroot$func_stripname_result
8765: + ;;
8766: + *)
8767: + func_fatal_error "only absolute run-paths are allowed"
8768: + ;;
8769: + esac
8770: + case "$xrpath " in
8771: + *" $dir "*) ;;
8772: + *) func_append xrpath " $dir" ;;
8773: + esac
8774: + continue
8775: + ;;
8776: +
8777: + -shared)
8778: + # The effects of -shared are defined in a previous loop.
8779: + continue
8780: + ;;
8781: +
8782: + -shrext)
8783: + prev=shrext
8784: + continue
8785: + ;;
8786: +
8787: + -static | -static-libtool-libs)
8788: + # The effects of -static are defined in a previous loop.
8789: + # We used to do the same as -all-static on platforms that
8790: + # didn't have a PIC flag, but the assumption that the effects
8791: + # would be equivalent was wrong. It would break on at least
8792: + # Digital Unix and AIX.
8793: + continue
8794: + ;;
8795: +
8796: + -thread-safe)
8797: + thread_safe=yes
8798: + continue
8799: + ;;
8800: +
8801: + -version-info)
8802: + prev=vinfo
8803: + continue
8804: + ;;
8805: +
8806: + -version-number)
8807: + prev=vinfo
8808: + vinfo_number=yes
8809: + continue
8810: + ;;
8811: +
8812: + -weak)
8813: + prev=weak
8814: + continue
8815: + ;;
8816: +
8817: + -Wc,*)
8818: + func_stripname '-Wc,' '' "$arg"
8819: + args=$func_stripname_result
8820: + arg=
8821: + save_ifs=$IFS; IFS=,
8822: + for flag in $args; do
8823: + IFS=$save_ifs
8824: + func_quote_for_eval "$flag"
8825: + func_append arg " $func_quote_for_eval_result"
8826: + func_append compiler_flags " $func_quote_for_eval_result"
8827: + done
8828: + IFS=$save_ifs
8829: + func_stripname ' ' '' "$arg"
8830: + arg=$func_stripname_result
8831: + ;;
8832: +
8833: + -Wl,*)
8834: + func_stripname '-Wl,' '' "$arg"
8835: + args=$func_stripname_result
8836: + arg=
8837: + save_ifs=$IFS; IFS=,
8838: + for flag in $args; do
8839: + IFS=$save_ifs
8840: + func_quote_for_eval "$flag"
8841: + func_append arg " $wl$func_quote_for_eval_result"
8842: + func_append compiler_flags " $wl$func_quote_for_eval_result"
8843: + func_append linker_flags " $func_quote_for_eval_result"
8844: + done
8845: + IFS=$save_ifs
8846: + func_stripname ' ' '' "$arg"
8847: + arg=$func_stripname_result
8848: + ;;
8849: +
8850: + -Xcompiler)
8851: + prev=xcompiler
8852: + continue
8853: + ;;
8854: +
8855: + -Xlinker)
8856: + prev=xlinker
8857: + continue
8858: + ;;
8859: +
8860: + -XCClinker)
8861: + prev=xcclinker
8862: + continue
8863: + ;;
8864: +
8865: + # -msg_* for osf cc
8866: + -msg_*)
8867: + func_quote_for_eval "$arg"
8868: + arg=$func_quote_for_eval_result
8869: + ;;
8870: +
8871: + # Flags to be passed through unchanged, with rationale:
8872: + # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
8873: + # -r[0-9][0-9]* specify processor for the SGI compiler
8874: + # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
8875: + # +DA*, +DD* enable 64-bit mode for the HP compiler
8876: + # -q* compiler args for the IBM compiler
8877: + # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
8878: + # -F/path path to uninstalled frameworks, gcc on darwin
8879: + # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
8880: + # -fstack-protector* stack protector flags for GCC
8881: + # @file GCC response files
8882: + # -tp=* Portland pgcc target processor selection
8883: + # --sysroot=* for sysroot support
8884: + # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
8885: + # -stdlib=* select c++ std lib with clang
8886: + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
8887: + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
8888: + -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*)
8889: + func_quote_for_eval "$arg"
8890: + arg=$func_quote_for_eval_result
8891: + func_append compile_command " $arg"
8892: + func_append finalize_command " $arg"
8893: + func_append compiler_flags " $arg"
8894: + continue
8895: + ;;
8896: +
8897: + -Z*)
8898: + if test os2 = "`expr $host : '.*\(os2\)'`"; then
8899: + # OS/2 uses -Zxxx to specify OS/2-specific options
8900: + compiler_flags="$compiler_flags $arg"
8901: + func_append compile_command " $arg"
8902: + func_append finalize_command " $arg"
8903: + case $arg in
8904: + -Zlinker | -Zstack)
8905: + prev=xcompiler
8906: + ;;
8907: + esac
8908: + continue
8909: + else
8910: + # Otherwise treat like 'Some other compiler flag' below
8911: + func_quote_for_eval "$arg"
8912: + arg=$func_quote_for_eval_result
8913: + fi
8914: + ;;
8915: +
8916: + # Some other compiler flag.
8917: + -* | +*)
8918: + func_quote_for_eval "$arg"
8919: + arg=$func_quote_for_eval_result
8920: + ;;
8921: +
8922: + *.$objext)
8923: + # A standard object.
8924: + func_append objs " $arg"
8925: + ;;
8926: +
8927: + *.lo)
8928: + # A libtool-controlled object.
8929: +
8930: + # Check to see that this really is a libtool object.
8931: + if func_lalib_unsafe_p "$arg"; then
8932: + pic_object=
8933: + non_pic_object=
8934: +
8935: + # Read the .lo file
8936: + func_source "$arg"
8937: +
8938: + if test -z "$pic_object" ||
8939: + test -z "$non_pic_object" ||
8940: + test none = "$pic_object" &&
8941: + test none = "$non_pic_object"; then
8942: + func_fatal_error "cannot find name of object for '$arg'"
8943: + fi
8944: +
8945: + # Extract subdirectory from the argument.
8946: + func_dirname "$arg" "/" ""
8947: + xdir=$func_dirname_result
8948: +
8949: + test none = "$pic_object" || {
8950: + # Prepend the subdirectory the object is found in.
8951: + pic_object=$xdir$pic_object
8952: +
8953: + if test dlfiles = "$prev"; then
8954: + if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
8955: + func_append dlfiles " $pic_object"
8956: + prev=
8957: + continue
8958: + else
8959: + # If libtool objects are unsupported, then we need to preload.
8960: + prev=dlprefiles
8961: + fi
8962: + fi
8963: +
8964: + # CHECK ME: I think I busted this. -Ossama
8965: + if test dlprefiles = "$prev"; then
8966: + # Preload the old-style object.
8967: + func_append dlprefiles " $pic_object"
8968: + prev=
8969: + fi
8970: +
8971: + # A PIC object.
8972: + func_append libobjs " $pic_object"
8973: + arg=$pic_object
8974: + }
8975: +
8976: + # Non-PIC object.
8977: + if test none != "$non_pic_object"; then
8978: + # Prepend the subdirectory the object is found in.
8979: + non_pic_object=$xdir$non_pic_object
8980: +
8981: + # A standard non-PIC object
8982: + func_append non_pic_objects " $non_pic_object"
8983: + if test -z "$pic_object" || test none = "$pic_object"; then
8984: + arg=$non_pic_object
8985: + fi
8986: + else
8987: + # If the PIC object exists, use it instead.
8988: + # $xdir was prepended to $pic_object above.
8989: + non_pic_object=$pic_object
8990: + func_append non_pic_objects " $non_pic_object"
8991: + fi
8992: + else
8993: + # Only an error if not doing a dry-run.
8994: + if $opt_dry_run; then
8995: + # Extract subdirectory from the argument.
8996: + func_dirname "$arg" "/" ""
8997: + xdir=$func_dirname_result
8998: +
8999: + func_lo2o "$arg"
9000: + pic_object=$xdir$objdir/$func_lo2o_result
9001: + non_pic_object=$xdir$func_lo2o_result
9002: + func_append libobjs " $pic_object"
9003: + func_append non_pic_objects " $non_pic_object"
9004: + else
9005: + func_fatal_error "'$arg' is not a valid libtool object"
9006: + fi
9007: + fi
9008: + ;;
9009: +
9010: + *.$libext)
9011: + # An archive.
9012: + func_append deplibs " $arg"
9013: + func_append old_deplibs " $arg"
9014: + continue
9015: + ;;
9016: +
9017: + *.la)
9018: + # A libtool-controlled library.
9019: +
9020: + func_resolve_sysroot "$arg"
9021: + if test dlfiles = "$prev"; then
9022: + # This library was specified with -dlopen.
9023: + func_append dlfiles " $func_resolve_sysroot_result"
9024: + prev=
9025: + elif test dlprefiles = "$prev"; then
9026: + # The library was specified with -dlpreopen.
9027: + func_append dlprefiles " $func_resolve_sysroot_result"
9028: + prev=
9029: + else
9030: + func_append deplibs " $func_resolve_sysroot_result"
9031: + fi
9032: + continue
9033: + ;;
9034: +
9035: + # Some other compiler argument.
9036: + *)
9037: + # Unknown arguments in both finalize_command and compile_command need
9038: + # to be aesthetically quoted because they are evaled later.
9039: + func_quote_for_eval "$arg"
9040: + arg=$func_quote_for_eval_result
9041: + ;;
9042: + esac # arg
9043: +
9044: + # Now actually substitute the argument into the commands.
9045: + if test -n "$arg"; then
9046: + func_append compile_command " $arg"
9047: + func_append finalize_command " $arg"
9048: + fi
9049: + done # argument parsing loop
9050: +
9051: + test -n "$prev" && \
9052: + func_fatal_help "the '$prevarg' option requires an argument"
9053: +
9054: + if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
9055: + eval arg=\"$export_dynamic_flag_spec\"
9056: + func_append compile_command " $arg"
9057: + func_append finalize_command " $arg"
9058: + fi
9059: +
9060: + oldlibs=
9061: + # calculate the name of the file, without its directory
9062: + func_basename "$output"
9063: + outputname=$func_basename_result
9064: + libobjs_save=$libobjs
9065: +
9066: + if test -n "$shlibpath_var"; then
9067: + # get the directories listed in $shlibpath_var
9068: + eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
9069: + else
9070: + shlib_search_path=
9071: + fi
9072: + eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
9073: + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
9074: +
9075: + # Definition is injected by LT_CONFIG during libtool generation.
9076: + func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
9077: +
9078: + func_dirname "$output" "/" ""
9079: + output_objdir=$func_dirname_result$objdir
9080: + func_to_tool_file "$output_objdir/"
9081: + tool_output_objdir=$func_to_tool_file_result
9082: + # Create the object directory.
9083: + func_mkdir_p "$output_objdir"
9084: +
9085: + # Determine the type of output
9086: + case $output in
9087: + "")
9088: + func_fatal_help "you must specify an output file"
9089: + ;;
9090: + *.$libext) linkmode=oldlib ;;
9091: + *.lo | *.$objext) linkmode=obj ;;
9092: + *.la) linkmode=lib ;;
9093: + *) linkmode=prog ;; # Anything else should be a program.
9094: + esac
9095: +
9096: + specialdeplibs=
9097: +
9098: + libs=
9099: + # Find all interdependent deplibs by searching for libraries
9100: + # that are linked more than once (e.g. -la -lb -la)
9101: + for deplib in $deplibs; do
9102: + if $opt_preserve_dup_deps; then
9103: + case "$libs " in
9104: + *" $deplib "*) func_append specialdeplibs " $deplib" ;;
9105: + esac
9106: + fi
9107: + func_append libs " $deplib"
9108: + done
9109: +
9110: + if test lib = "$linkmode"; then
9111: + libs="$predeps $libs $compiler_lib_search_path $postdeps"
9112: +
9113: + # Compute libraries that are listed more than once in $predeps
9114: + # $postdeps and mark them as special (i.e., whose duplicates are
9115: + # not to be eliminated).
9116: + pre_post_deps=
9117: + if $opt_duplicate_compiler_generated_deps; then
9118: + for pre_post_dep in $predeps $postdeps; do
9119: + case "$pre_post_deps " in
9120: + *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
9121: + esac
9122: + func_append pre_post_deps " $pre_post_dep"
9123: + done
9124: + fi
9125: + pre_post_deps=
9126: + fi
9127: +
9128: + deplibs=
9129: + newdependency_libs=
9130: + newlib_search_path=
9131: + need_relink=no # whether we're linking any uninstalled libtool libraries
9132: + notinst_deplibs= # not-installed libtool libraries
9133: + notinst_path= # paths that contain not-installed libtool libraries
9134: +
9135: + case $linkmode in
9136: + lib)
9137: + passes="conv dlpreopen link"
9138: + for file in $dlfiles $dlprefiles; do
9139: + case $file in
9140: + *.la) ;;
9141: + *)
9142: + func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
9143: + ;;
9144: + esac
9145: + done
9146: + ;;
9147: + prog)
9148: + compile_deplibs=
9149: + finalize_deplibs=
9150: + alldeplibs=false
9151: + newdlfiles=
9152: + newdlprefiles=
9153: + passes="conv scan dlopen dlpreopen link"
9154: + ;;
9155: + *) passes="conv"
9156: + ;;
9157: + esac
9158: +
9159: + for pass in $passes; do
9160: + # The preopen pass in lib mode reverses $deplibs; put it back here
9161: + # so that -L comes before libs that need it for instance...
9162: + if test lib,link = "$linkmode,$pass"; then
9163: + ## FIXME: Find the place where the list is rebuilt in the wrong
9164: + ## order, and fix it there properly
9165: + tmp_deplibs=
9166: + for deplib in $deplibs; do
9167: + tmp_deplibs="$deplib $tmp_deplibs"
9168: + done
9169: + deplibs=$tmp_deplibs
9170: + fi
9171: +
9172: + if test lib,link = "$linkmode,$pass" ||
9173: + test prog,scan = "$linkmode,$pass"; then
9174: + libs=$deplibs
9175: + deplibs=
9176: + fi
9177: + if test prog = "$linkmode"; then
9178: + case $pass in
9179: + dlopen) libs=$dlfiles ;;
9180: + dlpreopen) libs=$dlprefiles ;;
9181: + link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
9182: + esac
9183: + fi
9184: + if test lib,dlpreopen = "$linkmode,$pass"; then
9185: + # Collect and forward deplibs of preopened libtool libs
9186: + for lib in $dlprefiles; do
9187: + # Ignore non-libtool-libs
9188: + dependency_libs=
9189: + func_resolve_sysroot "$lib"
9190: + case $lib in
9191: + *.la) func_source "$func_resolve_sysroot_result" ;;
9192: + esac
9193: +
9194: + # Collect preopened libtool deplibs, except any this library
9195: + # has declared as weak libs
9196: + for deplib in $dependency_libs; do
9197: + func_basename "$deplib"
9198: + deplib_base=$func_basename_result
9199: + case " $weak_libs " in
9200: + *" $deplib_base "*) ;;
9201: + *) func_append deplibs " $deplib" ;;
9202: + esac
9203: + done
9204: + done
9205: + libs=$dlprefiles
9206: + fi
9207: + if test dlopen = "$pass"; then
9208: + # Collect dlpreopened libraries
9209: + save_deplibs=$deplibs
9210: + deplibs=
9211: + fi
9212: +
9213: + for deplib in $libs; do
9214: + lib=
9215: + found=false
9216: + case $deplib in
9217: + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
9218: + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
9219: + if test prog,link = "$linkmode,$pass"; then
9220: + compile_deplibs="$deplib $compile_deplibs"
9221: + finalize_deplibs="$deplib $finalize_deplibs"
9222: + else
9223: + func_append compiler_flags " $deplib"
9224: + if test lib = "$linkmode"; then
9225: + case "$new_inherited_linker_flags " in
9226: + *" $deplib "*) ;;
9227: + * ) func_append new_inherited_linker_flags " $deplib" ;;
9228: + esac
9229: + fi
9230: + fi
9231: + continue
9232: + ;;
9233: + -l*)
9234: + if test lib != "$linkmode" && test prog != "$linkmode"; then
9235: + func_warning "'-l' is ignored for archives/objects"
9236: + continue
9237: + fi
9238: + func_stripname '-l' '' "$deplib"
9239: + name=$func_stripname_result
9240: + if test lib = "$linkmode"; then
9241: + searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
9242: + else
9243: + searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
9244: + fi
9245: + for searchdir in $searchdirs; do
9246: + for search_ext in .la $std_shrext .so .a; do
9247: + # Search the libtool library
9248: + lib=$searchdir/lib$name$search_ext
9249: + if test -f "$lib"; then
9250: + if test .la = "$search_ext"; then
9251: + found=:
9252: + else
9253: + found=false
9254: + fi
9255: + break 2
9256: + fi
9257: + done
9258: + done
9259: + if $found; then
9260: + # deplib is a libtool library
9261: + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
9262: + # We need to do some special things here, and not later.
9263: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9264: + case " $predeps $postdeps " in
9265: + *" $deplib "*)
9266: + if func_lalib_p "$lib"; then
9267: + library_names=
9268: + old_library=
9269: + func_source "$lib"
9270: + for l in $old_library $library_names; do
9271: + ll=$l
9272: + done
9273: + if test "X$ll" = "X$old_library"; then # only static version available
9274: + found=false
9275: + func_dirname "$lib" "" "."
9276: + ladir=$func_dirname_result
9277: + lib=$ladir/$old_library
9278: + if test prog,link = "$linkmode,$pass"; then
9279: + compile_deplibs="$deplib $compile_deplibs"
9280: + finalize_deplibs="$deplib $finalize_deplibs"
9281: + else
9282: + deplibs="$deplib $deplibs"
9283: + test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
9284: + fi
9285: + continue
9286: + fi
9287: + fi
9288: + ;;
9289: + *) ;;
9290: + esac
9291: + fi
9292: + else
9293: + # deplib doesn't seem to be a libtool library
9294: + if test prog,link = "$linkmode,$pass"; then
9295: + compile_deplibs="$deplib $compile_deplibs"
9296: + finalize_deplibs="$deplib $finalize_deplibs"
9297: + else
9298: + deplibs="$deplib $deplibs"
9299: + test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
9300: + fi
9301: + continue
9302: + fi
9303: + ;; # -l
9304: + *.ltframework)
9305: + if test prog,link = "$linkmode,$pass"; then
9306: + compile_deplibs="$deplib $compile_deplibs"
9307: + finalize_deplibs="$deplib $finalize_deplibs"
9308: + else
9309: + deplibs="$deplib $deplibs"
9310: + if test lib = "$linkmode"; then
9311: + case "$new_inherited_linker_flags " in
9312: + *" $deplib "*) ;;
9313: + * ) func_append new_inherited_linker_flags " $deplib" ;;
9314: + esac
9315: + fi
9316: + fi
9317: + continue
9318: + ;;
9319: + -L*)
9320: + case $linkmode in
9321: + lib)
9322: + deplibs="$deplib $deplibs"
9323: + test conv = "$pass" && continue
9324: + newdependency_libs="$deplib $newdependency_libs"
9325: + func_stripname '-L' '' "$deplib"
9326: + func_resolve_sysroot "$func_stripname_result"
9327: + func_append newlib_search_path " $func_resolve_sysroot_result"
9328: + ;;
9329: + prog)
9330: + if test conv = "$pass"; then
9331: + deplibs="$deplib $deplibs"
9332: + continue
9333: + fi
9334: + if test scan = "$pass"; then
9335: + deplibs="$deplib $deplibs"
9336: + else
9337: + compile_deplibs="$deplib $compile_deplibs"
9338: + finalize_deplibs="$deplib $finalize_deplibs"
9339: + fi
9340: + func_stripname '-L' '' "$deplib"
9341: + func_resolve_sysroot "$func_stripname_result"
9342: + func_append newlib_search_path " $func_resolve_sysroot_result"
9343: + ;;
9344: + *)
9345: + func_warning "'-L' is ignored for archives/objects"
9346: + ;;
9347: + esac # linkmode
9348: + continue
9349: + ;; # -L
9350: + -R*)
9351: + if test link = "$pass"; then
9352: + func_stripname '-R' '' "$deplib"
9353: + func_resolve_sysroot "$func_stripname_result"
9354: + dir=$func_resolve_sysroot_result
9355: + # Make sure the xrpath contains only unique directories.
9356: + case "$xrpath " in
9357: + *" $dir "*) ;;
9358: + *) func_append xrpath " $dir" ;;
9359: + esac
9360: + fi
9361: + deplibs="$deplib $deplibs"
9362: + continue
9363: + ;;
9364: + *.la)
9365: + func_resolve_sysroot "$deplib"
9366: + lib=$func_resolve_sysroot_result
9367: + ;;
9368: + *.$libext)
9369: + if test conv = "$pass"; then
9370: + deplibs="$deplib $deplibs"
9371: + continue
9372: + fi
9373: + case $linkmode in
9374: + lib)
9375: + # Linking convenience modules into shared libraries is allowed,
9376: + # but linking other static libraries is non-portable.
9377: + case " $dlpreconveniencelibs " in
9378: + *" $deplib "*) ;;
9379: + *)
9380: + valid_a_lib=false
9381: + case $deplibs_check_method in
9382: + match_pattern*)
9383: + set dummy $deplibs_check_method; shift
9384: + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
9385: + if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
9386: + | $EGREP "$match_pattern_regex" > /dev/null; then
9387: + valid_a_lib=:
9388: + fi
9389: + ;;
9390: + pass_all)
9391: + valid_a_lib=:
9392: + ;;
9393: + esac
9394: + if $valid_a_lib; then
9395: + echo
9396: + $ECHO "*** Warning: Linking the shared library $output against the"
9397: + $ECHO "*** static library $deplib is not portable!"
9398: + deplibs="$deplib $deplibs"
9399: + else
9400: + echo
9401: + $ECHO "*** Warning: Trying to link with static lib archive $deplib."
9402: + echo "*** I have the capability to make that library automatically link in when"
9403: + echo "*** you link to this library. But I can only do this if you have a"
9404: + echo "*** shared version of the library, which you do not appear to have"
9405: + echo "*** because the file extensions .$libext of this argument makes me believe"
9406: + echo "*** that it is just a static archive that I should not use here."
9407: + fi
9408: + ;;
9409: + esac
9410: + continue
9411: + ;;
9412: + prog)
9413: + if test link != "$pass"; then
9414: + deplibs="$deplib $deplibs"
9415: + else
9416: + compile_deplibs="$deplib $compile_deplibs"
9417: + finalize_deplibs="$deplib $finalize_deplibs"
9418: + fi
9419: + continue
9420: + ;;
9421: + esac # linkmode
9422: + ;; # *.$libext
9423: + *.lo | *.$objext)
9424: + if test conv = "$pass"; then
9425: + deplibs="$deplib $deplibs"
9426: + elif test prog = "$linkmode"; then
9427: + if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
9428: + # If there is no dlopen support or we're linking statically,
9429: + # we need to preload.
9430: + func_append newdlprefiles " $deplib"
9431: + compile_deplibs="$deplib $compile_deplibs"
9432: + finalize_deplibs="$deplib $finalize_deplibs"
9433: + else
9434: + func_append newdlfiles " $deplib"
9435: + fi
9436: + fi
9437: + continue
9438: + ;;
9439: + %DEPLIBS%)
9440: + alldeplibs=:
9441: + continue
9442: + ;;
9443: + esac # case $deplib
9444: +
9445: + $found || test -f "$lib" \
9446: + || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
9447: +
9448: + # Check to see that this really is a libtool archive.
9449: + func_lalib_unsafe_p "$lib" \
9450: + || func_fatal_error "'$lib' is not a valid libtool archive"
9451: +
9452: + func_dirname "$lib" "" "."
9453: + ladir=$func_dirname_result
9454: +
9455: + dlname=
9456: + dlopen=
9457: + dlpreopen=
9458: + libdir=
9459: + library_names=
9460: + old_library=
9461: + inherited_linker_flags=
9462: + # If the library was installed with an old release of libtool,
9463: + # it will not redefine variables installed, or shouldnotlink
9464: + installed=yes
9465: + shouldnotlink=no
9466: + avoidtemprpath=
9467: +
9468: +
9469: + # Read the .la file
9470: + func_source "$lib"
9471: +
9472: + # Convert "-framework foo" to "foo.ltframework"
9473: + if test -n "$inherited_linker_flags"; then
9474: + tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
9475: + for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
9476: + case " $new_inherited_linker_flags " in
9477: + *" $tmp_inherited_linker_flag "*) ;;
9478: + *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
9479: + esac
9480: + done
9481: + fi
9482: + dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9483: + if test lib,link = "$linkmode,$pass" ||
9484: + test prog,scan = "$linkmode,$pass" ||
9485: + { test prog != "$linkmode" && test lib != "$linkmode"; }; then
9486: + test -n "$dlopen" && func_append dlfiles " $dlopen"
9487: + test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
9488: + fi
9489: +
9490: + if test conv = "$pass"; then
9491: + # Only check for convenience libraries
9492: + deplibs="$lib $deplibs"
9493: + if test -z "$libdir"; then
9494: + if test -z "$old_library"; then
9495: + func_fatal_error "cannot find name of link library for '$lib'"
9496: + fi
9497: + # It is a libtool convenience library, so add in its objects.
9498: + func_append convenience " $ladir/$objdir/$old_library"
9499: + func_append old_convenience " $ladir/$objdir/$old_library"
9500: + elif test prog != "$linkmode" && test lib != "$linkmode"; then
9501: + func_fatal_error "'$lib' is not a convenience library"
9502: + fi
9503: + tmp_libs=
9504: + for deplib in $dependency_libs; do
9505: + deplibs="$deplib $deplibs"
9506: + if $opt_preserve_dup_deps; then
9507: + case "$tmp_libs " in
9508: + *" $deplib "*) func_append specialdeplibs " $deplib" ;;
9509: + esac
9510: + fi
9511: + func_append tmp_libs " $deplib"
9512: + done
9513: + continue
9514: + fi # $pass = conv
9515: +
9516: +
9517: + # Get the name of the library we link against.
9518: + linklib=
9519: + if test -n "$old_library" &&
9520: + { test yes = "$prefer_static_libs" ||
9521: + test built,no = "$prefer_static_libs,$installed"; }; then
9522: + linklib=$old_library
9523: + else
9524: + for l in $old_library $library_names; do
9525: + linklib=$l
9526: + done
9527: + fi
9528: + if test -z "$linklib"; then
9529: + func_fatal_error "cannot find name of link library for '$lib'"
9530: + fi
9531: +
9532: + # This library was specified with -dlopen.
9533: + if test dlopen = "$pass"; then
9534: + test -z "$libdir" \
9535: + && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
9536: + if test -z "$dlname" ||
9537: + test yes != "$dlopen_support" ||
9538: + test no = "$build_libtool_libs"
9539: + then
9540: + # If there is no dlname, no dlopen support or we're linking
9541: + # statically, we need to preload. We also need to preload any
9542: + # dependent libraries so libltdl's deplib preloader doesn't
9543: + # bomb out in the load deplibs phase.
9544: + func_append dlprefiles " $lib $dependency_libs"
9545: + else
9546: + func_append newdlfiles " $lib"
9547: + fi
9548: + continue
9549: + fi # $pass = dlopen
9550: +
9551: + # We need an absolute path.
9552: + case $ladir in
9553: + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
9554: + *)
9555: + abs_ladir=`cd "$ladir" && pwd`
9556: + if test -z "$abs_ladir"; then
9557: + func_warning "cannot determine absolute directory name of '$ladir'"
9558: + func_warning "passing it literally to the linker, although it might fail"
9559: + abs_ladir=$ladir
9560: + fi
9561: + ;;
9562: + esac
9563: + func_basename "$lib"
9564: + laname=$func_basename_result
9565: +
9566: + # Find the relevant object directory and library name.
9567: + if test yes = "$installed"; then
9568: + if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
9569: + func_warning "library '$lib' was moved."
9570: + dir=$ladir
9571: + absdir=$abs_ladir
9572: + libdir=$abs_ladir
9573: + else
9574: + dir=$lt_sysroot$libdir
9575: + absdir=$lt_sysroot$libdir
9576: + fi
9577: + test yes = "$hardcode_automatic" && avoidtemprpath=yes
9578: + else
9579: + if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
9580: + dir=$ladir
9581: + absdir=$abs_ladir
9582: + # Remove this search path later
9583: + func_append notinst_path " $abs_ladir"
9584: + else
9585: + dir=$ladir/$objdir
9586: + absdir=$abs_ladir/$objdir
9587: + # Remove this search path later
9588: + func_append notinst_path " $abs_ladir"
9589: + fi
9590: + fi # $installed = yes
9591: + func_stripname 'lib' '.la' "$laname"
9592: + name=$func_stripname_result
9593: +
9594: + # This library was specified with -dlpreopen.
9595: + if test dlpreopen = "$pass"; then
9596: + if test -z "$libdir" && test prog = "$linkmode"; then
9597: + func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
9598: + fi
9599: + case $host in
9600: + # special handling for platforms with PE-DLLs.
9601: + *cygwin* | *mingw* | *cegcc* )
9602: + # Linker will automatically link against shared library if both
9603: + # static and shared are present. Therefore, ensure we extract
9604: + # symbols from the import library if a shared library is present
9605: + # (otherwise, the dlopen module name will be incorrect). We do
9606: + # this by putting the import library name into $newdlprefiles.
9607: + # We recover the dlopen module name by 'saving' the la file
9608: + # name in a special purpose variable, and (later) extracting the
9609: + # dlname from the la file.
9610: + if test -n "$dlname"; then
9611: + func_tr_sh "$dir/$linklib"
9612: + eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
9613: + func_append newdlprefiles " $dir/$linklib"
9614: + else
9615: + func_append newdlprefiles " $dir/$old_library"
9616: + # Keep a list of preopened convenience libraries to check
9617: + # that they are being used correctly in the link pass.
9618: + test -z "$libdir" && \
9619: + func_append dlpreconveniencelibs " $dir/$old_library"
9620: + fi
9621: + ;;
9622: + * )
9623: + # Prefer using a static library (so that no silly _DYNAMIC symbols
9624: + # are required to link).
9625: + if test -n "$old_library"; then
9626: + func_append newdlprefiles " $dir/$old_library"
9627: + # Keep a list of preopened convenience libraries to check
9628: + # that they are being used correctly in the link pass.
9629: + test -z "$libdir" && \
9630: + func_append dlpreconveniencelibs " $dir/$old_library"
9631: + # Otherwise, use the dlname, so that lt_dlopen finds it.
9632: + elif test -n "$dlname"; then
9633: + func_append newdlprefiles " $dir/$dlname"
9634: + else
9635: + func_append newdlprefiles " $dir/$linklib"
9636: + fi
9637: + ;;
9638: + esac
9639: + fi # $pass = dlpreopen
9640: +
9641: + if test -z "$libdir"; then
9642: + # Link the convenience library
9643: + if test lib = "$linkmode"; then
9644: + deplibs="$dir/$old_library $deplibs"
9645: + elif test prog,link = "$linkmode,$pass"; then
9646: + compile_deplibs="$dir/$old_library $compile_deplibs"
9647: + finalize_deplibs="$dir/$old_library $finalize_deplibs"
9648: + else
9649: + deplibs="$lib $deplibs" # used for prog,scan pass
9650: + fi
9651: + continue
9652: + fi
9653: +
9654: +
9655: + if test prog = "$linkmode" && test link != "$pass"; then
9656: + func_append newlib_search_path " $ladir"
9657: + deplibs="$lib $deplibs"
9658: +
9659: + linkalldeplibs=false
9660: + if test no != "$link_all_deplibs" || test -z "$library_names" ||
9661: + test no = "$build_libtool_libs"; then
9662: + linkalldeplibs=:
9663: + fi
9664: +
9665: + tmp_libs=
9666: + for deplib in $dependency_libs; do
9667: + case $deplib in
9668: + -L*) func_stripname '-L' '' "$deplib"
9669: + func_resolve_sysroot "$func_stripname_result"
9670: + func_append newlib_search_path " $func_resolve_sysroot_result"
9671: + ;;
9672: + esac
9673: + # Need to link against all dependency_libs?
9674: + if $linkalldeplibs; then
9675: + deplibs="$deplib $deplibs"
9676: + else
9677: + # Need to hardcode shared library paths
9678: + # or/and link against static libraries
9679: + newdependency_libs="$deplib $newdependency_libs"
9680: + fi
9681: + if $opt_preserve_dup_deps; then
9682: + case "$tmp_libs " in
9683: + *" $deplib "*) func_append specialdeplibs " $deplib" ;;
9684: + esac
9685: + fi
9686: + func_append tmp_libs " $deplib"
9687: + done # for deplib
9688: + continue
9689: + fi # $linkmode = prog...
9690: +
9691: + if test prog,link = "$linkmode,$pass"; then
9692: + if test -n "$library_names" &&
9693: + { { test no = "$prefer_static_libs" ||
9694: + test built,yes = "$prefer_static_libs,$installed"; } ||
9695: + test -z "$old_library"; }; then
9696: + # We need to hardcode the library path
9697: + if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
9698: + # Make sure the rpath contains only unique directories.
9699: + case $temp_rpath: in
9700: + *"$absdir:"*) ;;
9701: + *) func_append temp_rpath "$absdir:" ;;
9702: + esac
9703: + fi
9704: +
9705: + # Hardcode the library path.
9706: + # Skip directories that are in the system default run-time
9707: + # search path.
9708: + case " $sys_lib_dlsearch_path " in
9709: + *" $absdir "*) ;;
9710: + *)
9711: + case "$compile_rpath " in
9712: + *" $absdir "*) ;;
9713: + *) func_append compile_rpath " $absdir" ;;
9714: + esac
9715: + ;;
9716: + esac
9717: + case " $sys_lib_dlsearch_path " in
9718: + *" $libdir "*) ;;
9719: + *)
9720: + case "$finalize_rpath " in
9721: + *" $libdir "*) ;;
9722: + *) func_append finalize_rpath " $libdir" ;;
9723: + esac
9724: + ;;
9725: + esac
9726: + fi # $linkmode,$pass = prog,link...
9727: +
9728: + if $alldeplibs &&
9729: + { test pass_all = "$deplibs_check_method" ||
9730: + { test yes = "$build_libtool_libs" &&
9731: + test -n "$library_names"; }; }; then
9732: + # We only need to search for static libraries
9733: + continue
9734: + fi
9735: + fi
9736: +
9737: + link_static=no # Whether the deplib will be linked statically
9738: + use_static_libs=$prefer_static_libs
9739: + if test built = "$use_static_libs" && test yes = "$installed"; then
9740: + use_static_libs=no
9741: + fi
9742: + if test -n "$library_names" &&
9743: + { test no = "$use_static_libs" || test -z "$old_library"; }; then
9744: + case $host in
9745: + *cygwin* | *mingw* | *cegcc* | *os2*)
9746: + # No point in relinking DLLs because paths are not encoded
9747: + func_append notinst_deplibs " $lib"
9748: + need_relink=no
9749: + ;;
9750: + *)
9751: + if test no = "$installed"; then
9752: + func_append notinst_deplibs " $lib"
9753: + need_relink=yes
9754: + fi
9755: + ;;
9756: + esac
9757: + # This is a shared library
9758: +
9759: + # Warn about portability, can't link against -module's on some
9760: + # systems (darwin). Don't bleat about dlopened modules though!
9761: + dlopenmodule=
9762: + for dlpremoduletest in $dlprefiles; do
9763: + if test "X$dlpremoduletest" = "X$lib"; then
9764: + dlopenmodule=$dlpremoduletest
9765: + break
9766: + fi
9767: + done
9768: + if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
9769: + echo
9770: + if test prog = "$linkmode"; then
9771: + $ECHO "*** Warning: Linking the executable $output against the loadable module"
9772: + else
9773: + $ECHO "*** Warning: Linking the shared library $output against the loadable module"
9774: + fi
9775: + $ECHO "*** $linklib is not portable!"
9776: + fi
9777: + if test lib = "$linkmode" &&
9778: + test yes = "$hardcode_into_libs"; then
9779: + # Hardcode the library path.
9780: + # Skip directories that are in the system default run-time
9781: + # search path.
9782: + case " $sys_lib_dlsearch_path " in
9783: + *" $absdir "*) ;;
9784: + *)
9785: + case "$compile_rpath " in
9786: + *" $absdir "*) ;;
9787: + *) func_append compile_rpath " $absdir" ;;
9788: + esac
9789: + ;;
9790: + esac
9791: + case " $sys_lib_dlsearch_path " in
9792: + *" $libdir "*) ;;
9793: + *)
9794: + case "$finalize_rpath " in
9795: + *" $libdir "*) ;;
9796: + *) func_append finalize_rpath " $libdir" ;;
9797: + esac
9798: + ;;
9799: + esac
9800: + fi
9801: +
9802: + if test -n "$old_archive_from_expsyms_cmds"; then
9803: + # figure out the soname
9804: + set dummy $library_names
9805: + shift
9806: + realname=$1
9807: + shift
9808: + libname=`eval "\\$ECHO \"$libname_spec\""`
9809: + # use dlname if we got it. it's perfectly good, no?
9810: + if test -n "$dlname"; then
9811: + soname=$dlname
9812: + elif test -n "$soname_spec"; then
9813: + # bleh windows
9814: + case $host in
9815: + *cygwin* | mingw* | *cegcc* | *os2*)
9816: + func_arith $current - $age
9817: + major=$func_arith_result
9818: + versuffix=-$major
9819: + ;;
9820: + esac
9821: + eval soname=\"$soname_spec\"
9822: + else
9823: + soname=$realname
9824: + fi
9825: +
9826: + # Make a new name for the extract_expsyms_cmds to use
9827: + soroot=$soname
9828: + func_basename "$soroot"
9829: + soname=$func_basename_result
9830: + func_stripname 'lib' '.dll' "$soname"
9831: + newlib=libimp-$func_stripname_result.a
9832: +
9833: + # If the library has no export list, then create one now
9834: + if test -f "$output_objdir/$soname-def"; then :
9835: + else
9836: + func_verbose "extracting exported symbol list from '$soname'"
9837: + func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
9838: + fi
9839: +
9840: + # Create $newlib
9841: + if test -f "$output_objdir/$newlib"; then :; else
9842: + func_verbose "generating import library for '$soname'"
9843: + func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
9844: + fi
9845: + # make sure the library variables are pointing to the new library
9846: + dir=$output_objdir
9847: + linklib=$newlib
9848: + fi # test -n "$old_archive_from_expsyms_cmds"
9849: +
9850: + if test prog = "$linkmode" || test relink != "$opt_mode"; then
9851: + add_shlibpath=
9852: + add_dir=
9853: + add=
9854: + lib_linked=yes
9855: + case $hardcode_action in
9856: + immediate | unsupported)
9857: + if test no = "$hardcode_direct"; then
9858: + add=$dir/$linklib
9859: + case $host in
9860: + *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
9861: + *-*-sysv4*uw2*) add_dir=-L$dir ;;
9862: + *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
9863: + *-*-unixware7*) add_dir=-L$dir ;;
9864: + *-*-darwin* )
9865: + # if the lib is a (non-dlopened) module then we cannot
9866: + # link against it, someone is ignoring the earlier warnings
9867: + if /usr/bin/file -L $add 2> /dev/null |
9868: + $GREP ": [^:]* bundle" >/dev/null; then
9869: + if test "X$dlopenmodule" != "X$lib"; then
9870: + $ECHO "*** Warning: lib $linklib is a module, not a shared library"
9871: + if test -z "$old_library"; then
9872: + echo
9873: + echo "*** And there doesn't seem to be a static archive available"
9874: + echo "*** The link will probably fail, sorry"
9875: + else
9876: + add=$dir/$old_library
9877: + fi
9878: + elif test -n "$old_library"; then
9879: + add=$dir/$old_library
9880: + fi
9881: + fi
9882: + esac
9883: + elif test no = "$hardcode_minus_L"; then
9884: + case $host in
9885: + *-*-sunos*) add_shlibpath=$dir ;;
9886: + esac
9887: + add_dir=-L$dir
9888: + add=-l$name
9889: + elif test no = "$hardcode_shlibpath_var"; then
9890: + add_shlibpath=$dir
9891: + add=-l$name
9892: + else
9893: + lib_linked=no
9894: + fi
9895: + ;;
9896: + relink)
9897: + if test yes = "$hardcode_direct" &&
9898: + test no = "$hardcode_direct_absolute"; then
9899: + add=$dir/$linklib
9900: + elif test yes = "$hardcode_minus_L"; then
9901: + add_dir=-L$absdir
9902: + # Try looking first in the location we're being installed to.
9903: + if test -n "$inst_prefix_dir"; then
9904: + case $libdir in
9905: + [\\/]*)
9906: + func_append add_dir " -L$inst_prefix_dir$libdir"
9907: + ;;
9908: + esac
9909: + fi
9910: + add=-l$name
9911: + elif test yes = "$hardcode_shlibpath_var"; then
9912: + add_shlibpath=$dir
9913: + add=-l$name
9914: + else
9915: + lib_linked=no
9916: + fi
9917: + ;;
9918: + *) lib_linked=no ;;
9919: + esac
9920: +
9921: + if test yes != "$lib_linked"; then
9922: + func_fatal_configuration "unsupported hardcode properties"
9923: + fi
9924: +
9925: + if test -n "$add_shlibpath"; then
9926: + case :$compile_shlibpath: in
9927: + *":$add_shlibpath:"*) ;;
9928: + *) func_append compile_shlibpath "$add_shlibpath:" ;;
9929: + esac
9930: + fi
9931: + if test prog = "$linkmode"; then
9932: + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
9933: + test -n "$add" && compile_deplibs="$add $compile_deplibs"
9934: + else
9935: + test -n "$add_dir" && deplibs="$add_dir $deplibs"
9936: + test -n "$add" && deplibs="$add $deplibs"
9937: + if test yes != "$hardcode_direct" &&
9938: + test yes != "$hardcode_minus_L" &&
9939: + test yes = "$hardcode_shlibpath_var"; then
9940: + case :$finalize_shlibpath: in
9941: + *":$libdir:"*) ;;
9942: + *) func_append finalize_shlibpath "$libdir:" ;;
9943: + esac
9944: + fi
9945: + fi
9946: + fi
9947: +
9948: + if test prog = "$linkmode" || test relink = "$opt_mode"; then
9949: + add_shlibpath=
9950: + add_dir=
9951: + add=
9952: + # Finalize command for both is simple: just hardcode it.
9953: + if test yes = "$hardcode_direct" &&
9954: + test no = "$hardcode_direct_absolute"; then
9955: + add=$libdir/$linklib
9956: + elif test yes = "$hardcode_minus_L"; then
9957: + add_dir=-L$libdir
9958: + add=-l$name
9959: + elif test yes = "$hardcode_shlibpath_var"; then
9960: + case :$finalize_shlibpath: in
9961: + *":$libdir:"*) ;;
9962: + *) func_append finalize_shlibpath "$libdir:" ;;
9963: + esac
9964: + add=-l$name
9965: + elif test yes = "$hardcode_automatic"; then
9966: + if test -n "$inst_prefix_dir" &&
9967: + test -f "$inst_prefix_dir$libdir/$linklib"; then
9968: + add=$inst_prefix_dir$libdir/$linklib
9969: + else
9970: + add=$libdir/$linklib
9971: + fi
9972: + else
9973: + # We cannot seem to hardcode it, guess we'll fake it.
9974: + add_dir=-L$libdir
9975: + # Try looking first in the location we're being installed to.
9976: + if test -n "$inst_prefix_dir"; then
9977: + case $libdir in
9978: + [\\/]*)
9979: + func_append add_dir " -L$inst_prefix_dir$libdir"
9980: + ;;
9981: + esac
9982: + fi
9983: + add=-l$name
9984: + fi
9985: +
9986: + if test prog = "$linkmode"; then
9987: + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
9988: + test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
9989: + else
9990: + test -n "$add_dir" && deplibs="$add_dir $deplibs"
9991: + test -n "$add" && deplibs="$add $deplibs"
9992: + fi
9993: + fi
9994: + elif test prog = "$linkmode"; then
9995: + # Here we assume that one of hardcode_direct or hardcode_minus_L
9996: + # is not unsupported. This is valid on all known static and
9997: + # shared platforms.
9998: + if test unsupported != "$hardcode_direct"; then
9999: + test -n "$old_library" && linklib=$old_library
10000: + compile_deplibs="$dir/$linklib $compile_deplibs"
10001: + finalize_deplibs="$dir/$linklib $finalize_deplibs"
10002: + else
10003: + compile_deplibs="-l$name -L$dir $compile_deplibs"
10004: + finalize_deplibs="-l$name -L$dir $finalize_deplibs"
10005: + fi
10006: + elif test yes = "$build_libtool_libs"; then
10007: + # Not a shared library
10008: + if test pass_all != "$deplibs_check_method"; then
10009: + # We're trying link a shared library against a static one
10010: + # but the system doesn't support it.
10011: +
10012: + # Just print a warning and add the library to dependency_libs so
10013: + # that the program can be linked against the static library.
10014: + echo
10015: + $ECHO "*** Warning: This system cannot link to static lib archive $lib."
10016: + echo "*** I have the capability to make that library automatically link in when"
10017: + echo "*** you link to this library. But I can only do this if you have a"
10018: + echo "*** shared version of the library, which you do not appear to have."
10019: + if test yes = "$module"; then
10020: + echo "*** But as you try to build a module library, libtool will still create "
10021: + echo "*** a static module, that should work as long as the dlopening application"
10022: + echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
10023: + if test -z "$global_symbol_pipe"; then
10024: + echo
10025: + echo "*** However, this would only work if libtool was able to extract symbol"
10026: + echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
10027: + echo "*** not find such a program. So, this module is probably useless."
10028: + echo "*** 'nm' from GNU binutils and a full rebuild may help."
10029: + fi
10030: + if test no = "$build_old_libs"; then
10031: + build_libtool_libs=module
10032: + build_old_libs=yes
10033: + else
10034: + build_libtool_libs=no
10035: + fi
10036: + fi
10037: + else
10038: + deplibs="$dir/$old_library $deplibs"
10039: + link_static=yes
10040: + fi
10041: + fi # link shared/static library?
10042: +
10043: + if test lib = "$linkmode"; then
10044: + if test -n "$dependency_libs" &&
10045: + { test yes != "$hardcode_into_libs" ||
10046: + test yes = "$build_old_libs" ||
10047: + test yes = "$link_static"; }; then
10048: + # Extract -R from dependency_libs
10049: + temp_deplibs=
10050: + for libdir in $dependency_libs; do
10051: + case $libdir in
10052: + -R*) func_stripname '-R' '' "$libdir"
10053: + temp_xrpath=$func_stripname_result
10054: + case " $xrpath " in
10055: + *" $temp_xrpath "*) ;;
10056: + *) func_append xrpath " $temp_xrpath";;
10057: + esac;;
10058: + *) func_append temp_deplibs " $libdir";;
10059: + esac
10060: + done
10061: + dependency_libs=$temp_deplibs
10062: + fi
10063: +
10064: + func_append newlib_search_path " $absdir"
10065: + # Link against this library
10066: + test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
10067: + # ... and its dependency_libs
10068: + tmp_libs=
10069: + for deplib in $dependency_libs; do
10070: + newdependency_libs="$deplib $newdependency_libs"
10071: + case $deplib in
10072: + -L*) func_stripname '-L' '' "$deplib"
10073: + func_resolve_sysroot "$func_stripname_result";;
10074: + *) func_resolve_sysroot "$deplib" ;;
10075: + esac
10076: + if $opt_preserve_dup_deps; then
10077: + case "$tmp_libs " in
10078: + *" $func_resolve_sysroot_result "*)
10079: + func_append specialdeplibs " $func_resolve_sysroot_result" ;;
10080: + esac
10081: + fi
10082: + func_append tmp_libs " $func_resolve_sysroot_result"
10083: + done
10084: +
10085: + if test no != "$link_all_deplibs"; then
10086: + # Add the search paths of all dependency libraries
10087: + for deplib in $dependency_libs; do
10088: + path=
10089: + case $deplib in
10090: + -L*) path=$deplib ;;
10091: + *.la)
10092: + func_resolve_sysroot "$deplib"
10093: + deplib=$func_resolve_sysroot_result
10094: + func_dirname "$deplib" "" "."
10095: + dir=$func_dirname_result
10096: + # We need an absolute path.
10097: + case $dir in
10098: + [\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
10099: + *)
10100: + absdir=`cd "$dir" && pwd`
10101: + if test -z "$absdir"; then
10102: + func_warning "cannot determine absolute directory name of '$dir'"
10103: + absdir=$dir
10104: + fi
10105: + ;;
10106: + esac
10107: + if $GREP "^installed=no" $deplib > /dev/null; then
10108: + case $host in
10109: + *-*-darwin*)
10110: + depdepl=
10111: + eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
10112: + if test -n "$deplibrary_names"; then
10113: + for tmp in $deplibrary_names; do
10114: + depdepl=$tmp
10115: + done
10116: + if test -f "$absdir/$objdir/$depdepl"; then
10117: + depdepl=$absdir/$objdir/$depdepl
10118: + darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
10119: + if test -z "$darwin_install_name"; then
10120: + darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
10121: + fi
10122: + func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
10123: + func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
10124: + path=
10125: + fi
10126: + fi
10127: + ;;
10128: + *)
10129: + path=-L$absdir/$objdir
10130: + ;;
10131: + esac
10132: + else
10133: + eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
10134: + test -z "$libdir" && \
10135: + func_fatal_error "'$deplib' is not a valid libtool archive"
10136: + test "$absdir" != "$libdir" && \
10137: + func_warning "'$deplib' seems to be moved"
10138: +
10139: + path=-L$absdir
10140: + fi
10141: + ;;
10142: + esac
10143: + case " $deplibs " in
10144: + *" $path "*) ;;
10145: + *) deplibs="$path $deplibs" ;;
10146: + esac
10147: + done
10148: + fi # link_all_deplibs != no
10149: + fi # linkmode = lib
10150: + done # for deplib in $libs
10151: + if test link = "$pass"; then
10152: + if test prog = "$linkmode"; then
10153: + compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
10154: + finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
10155: + else
10156: + compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
10157: + fi
10158: + fi
10159: + dependency_libs=$newdependency_libs
10160: + if test dlpreopen = "$pass"; then
10161: + # Link the dlpreopened libraries before other libraries
10162: + for deplib in $save_deplibs; do
10163: + deplibs="$deplib $deplibs"
10164: + done
10165: + fi
10166: + if test dlopen != "$pass"; then
10167: + test conv = "$pass" || {
10168: + # Make sure lib_search_path contains only unique directories.
10169: + lib_search_path=
10170: + for dir in $newlib_search_path; do
10171: + case "$lib_search_path " in
10172: + *" $dir "*) ;;
10173: + *) func_append lib_search_path " $dir" ;;
10174: + esac
10175: + done
10176: + newlib_search_path=
10177: + }
10178: +
10179: + if test prog,link = "$linkmode,$pass"; then
10180: + vars="compile_deplibs finalize_deplibs"
10181: + else
10182: + vars=deplibs
10183: + fi
10184: + for var in $vars dependency_libs; do
10185: + # Add libraries to $var in reverse order
10186: + eval tmp_libs=\"\$$var\"
10187: + new_libs=
10188: + for deplib in $tmp_libs; do
10189: + # FIXME: Pedantically, this is the right thing to do, so
10190: + # that some nasty dependency loop isn't accidentally
10191: + # broken:
10192: + #new_libs="$deplib $new_libs"
10193: + # Pragmatically, this seems to cause very few problems in
10194: + # practice:
10195: + case $deplib in
10196: + -L*) new_libs="$deplib $new_libs" ;;
10197: + -R*) ;;
10198: + *)
10199: + # And here is the reason: when a library appears more
10200: + # than once as an explicit dependence of a library, or
10201: + # is implicitly linked in more than once by the
10202: + # compiler, it is considered special, and multiple
10203: + # occurrences thereof are not removed. Compare this
10204: + # with having the same library being listed as a
10205: + # dependency of multiple other libraries: in this case,
10206: + # we know (pedantically, we assume) the library does not
10207: + # need to be listed more than once, so we keep only the
10208: + # last copy. This is not always right, but it is rare
10209: + # enough that we require users that really mean to play
10210: + # such unportable linking tricks to link the library
10211: + # using -Wl,-lname, so that libtool does not consider it
10212: + # for duplicate removal.
10213: + case " $specialdeplibs " in
10214: + *" $deplib "*) new_libs="$deplib $new_libs" ;;
10215: + *)
10216: + case " $new_libs " in
10217: + *" $deplib "*) ;;
10218: + *) new_libs="$deplib $new_libs" ;;
10219: + esac
10220: + ;;
10221: + esac
10222: + ;;
10223: + esac
10224: + done
10225: + tmp_libs=
10226: + for deplib in $new_libs; do
10227: + case $deplib in
10228: + -L*)
10229: + case " $tmp_libs " in
10230: + *" $deplib "*) ;;
10231: + *) func_append tmp_libs " $deplib" ;;
10232: + esac
10233: + ;;
10234: + *) func_append tmp_libs " $deplib" ;;
10235: + esac
10236: + done
10237: + eval $var=\"$tmp_libs\"
10238: + done # for var
10239: + fi
10240: +
10241: + # Add Sun CC postdeps if required:
10242: + test CXX = "$tagname" && {
10243: + case $host_os in
10244: + linux*)
10245: + case `$CC -V 2>&1 | sed 5q` in
10246: + *Sun\ C*) # Sun C++ 5.9
10247: + func_suncc_cstd_abi
10248: +
10249: + if test no != "$suncc_use_cstd_abi"; then
10250: + func_append postdeps ' -library=Cstd -library=Crun'
10251: + fi
10252: + ;;
10253: + esac
10254: + ;;
10255: +
10256: + solaris*)
10257: + func_cc_basename "$CC"
10258: + case $func_cc_basename_result in
10259: + CC* | sunCC*)
10260: + func_suncc_cstd_abi
10261: +
10262: + if test no != "$suncc_use_cstd_abi"; then
10263: + func_append postdeps ' -library=Cstd -library=Crun'
10264: + fi
10265: + ;;
10266: + esac
10267: + ;;
10268: + esac
10269: + }
10270: +
10271: + # Last step: remove runtime libs from dependency_libs
10272: + # (they stay in deplibs)
10273: + tmp_libs=
10274: + for i in $dependency_libs; do
10275: + case " $predeps $postdeps $compiler_lib_search_path " in
10276: + *" $i "*)
10277: + i=
10278: + ;;
10279: + esac
10280: + if test -n "$i"; then
10281: + func_append tmp_libs " $i"
10282: + fi
10283: + done
10284: + dependency_libs=$tmp_libs
10285: + done # for pass
10286: + if test prog = "$linkmode"; then
10287: + dlfiles=$newdlfiles
10288: + fi
10289: + if test prog = "$linkmode" || test lib = "$linkmode"; then
10290: + dlprefiles=$newdlprefiles
10291: + fi
10292: +
10293: + case $linkmode in
10294: + oldlib)
10295: + if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
10296: + func_warning "'-dlopen' is ignored for archives"
10297: + fi
10298: +
10299: + case " $deplibs" in
10300: + *\ -l* | *\ -L*)
10301: + func_warning "'-l' and '-L' are ignored for archives" ;;
10302: + esac
10303: +
10304: + test -n "$rpath" && \
10305: + func_warning "'-rpath' is ignored for archives"
10306: +
10307: + test -n "$xrpath" && \
10308: + func_warning "'-R' is ignored for archives"
10309: +
10310: + test -n "$vinfo" && \
10311: + func_warning "'-version-info/-version-number' is ignored for archives"
10312: +
10313: + test -n "$release" && \
10314: + func_warning "'-release' is ignored for archives"
10315: +
10316: + test -n "$export_symbols$export_symbols_regex" && \
10317: + func_warning "'-export-symbols' is ignored for archives"
10318: +
10319: + # Now set the variables for building old libraries.
10320: + build_libtool_libs=no
10321: + oldlibs=$output
10322: + func_append objs "$old_deplibs"
10323: + ;;
10324: +
10325: + lib)
10326: + # Make sure we only generate libraries of the form 'libNAME.la'.
10327: + case $outputname in
10328: + lib*)
10329: + func_stripname 'lib' '.la' "$outputname"
10330: + name=$func_stripname_result
10331: + eval shared_ext=\"$shrext_cmds\"
10332: + eval libname=\"$libname_spec\"
10333: + ;;
10334: + *)
10335: + test no = "$module" \
10336: + && func_fatal_help "libtool library '$output' must begin with 'lib'"
10337: +
10338: + if test no != "$need_lib_prefix"; then
10339: + # Add the "lib" prefix for modules if required
10340: + func_stripname '' '.la' "$outputname"
10341: + name=$func_stripname_result
10342: + eval shared_ext=\"$shrext_cmds\"
10343: + eval libname=\"$libname_spec\"
10344: + else
10345: + func_stripname '' '.la' "$outputname"
10346: + libname=$func_stripname_result
10347: + fi
10348: + ;;
10349: + esac
10350: +
10351: + if test -n "$objs"; then
10352: + if test pass_all != "$deplibs_check_method"; then
10353: + func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
10354: + else
10355: + echo
10356: + $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
10357: + $ECHO "*** objects $objs is not portable!"
10358: + func_append libobjs " $objs"
10359: + fi
10360: + fi
10361: +
10362: + test no = "$dlself" \
10363: + || func_warning "'-dlopen self' is ignored for libtool libraries"
10364: +
10365: + set dummy $rpath
10366: + shift
10367: + test 1 -lt "$#" \
10368: + && func_warning "ignoring multiple '-rpath's for a libtool library"
10369: +
10370: + install_libdir=$1
10371: +
10372: + oldlibs=
10373: + if test -z "$rpath"; then
10374: + if test yes = "$build_libtool_libs"; then
10375: + # Building a libtool convenience library.
10376: + # Some compilers have problems with a '.al' extension so
10377: + # convenience libraries should have the same extension an
10378: + # archive normally would.
10379: + oldlibs="$output_objdir/$libname.$libext $oldlibs"
10380: + build_libtool_libs=convenience
10381: + build_old_libs=yes
10382: + fi
10383: +
10384: + test -n "$vinfo" && \
10385: + func_warning "'-version-info/-version-number' is ignored for convenience libraries"
10386: +
10387: + test -n "$release" && \
10388: + func_warning "'-release' is ignored for convenience libraries"
10389: + else
10390: +
10391: + # Parse the version information argument.
10392: + save_ifs=$IFS; IFS=:
10393: + set dummy $vinfo 0 0 0
10394: + shift
10395: + IFS=$save_ifs
10396: +
10397: + test -n "$7" && \
10398: + func_fatal_help "too many parameters to '-version-info'"
10399: +
10400: + # convert absolute version numbers to libtool ages
10401: + # this retains compatibility with .la files and attempts
10402: + # to make the code below a bit more comprehensible
10403: +
10404: + case $vinfo_number in
10405: + yes)
10406: + number_major=$1
10407: + number_minor=$2
10408: + number_revision=$3
10409: + #
10410: + # There are really only two kinds -- those that
10411: + # use the current revision as the major version
10412: + # and those that subtract age and use age as
10413: + # a minor version. But, then there is irix
10414: + # that has an extra 1 added just for fun
10415: + #
10416: + case $version_type in
10417: + # correct linux to gnu/linux during the next big refactor
10418: + darwin|freebsd-elf|linux|osf|windows|none)
10419: + func_arith $number_major + $number_minor
10420: + current=$func_arith_result
10421: + age=$number_minor
10422: + revision=$number_revision
10423: + ;;
10424: + freebsd-aout|qnx|sunos)
10425: + current=$number_major
10426: + revision=$number_minor
10427: + age=0
10428: + ;;
10429: + irix|nonstopux)
10430: + func_arith $number_major + $number_minor
10431: + current=$func_arith_result
10432: + age=$number_minor
10433: + revision=$number_minor
10434: + lt_irix_increment=no
10435: + ;;
10436: + esac
10437: + ;;
10438: + no)
10439: + current=$1
10440: + revision=$2
10441: + age=$3
10442: + ;;
10443: + esac
10444: +
10445: + # Check that each of the things are valid numbers.
10446: + case $current in
10447: + 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]) ;;
10448: + *)
10449: + func_error "CURRENT '$current' must be a nonnegative integer"
10450: + func_fatal_error "'$vinfo' is not valid version information"
10451: + ;;
10452: + esac
10453: +
10454: + case $revision in
10455: + 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]) ;;
10456: + *)
10457: + func_error "REVISION '$revision' must be a nonnegative integer"
10458: + func_fatal_error "'$vinfo' is not valid version information"
10459: + ;;
10460: + esac
10461: +
10462: + case $age in
10463: + 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]) ;;
10464: + *)
10465: + func_error "AGE '$age' must be a nonnegative integer"
10466: + func_fatal_error "'$vinfo' is not valid version information"
10467: + ;;
10468: + esac
10469: +
10470: + if test "$age" -gt "$current"; then
10471: + func_error "AGE '$age' is greater than the current interface number '$current'"
10472: + func_fatal_error "'$vinfo' is not valid version information"
10473: + fi
10474: +
10475: + # Calculate the version variables.
10476: + major=
10477: + versuffix=
10478: + verstring=
10479: + case $version_type in
10480: + none) ;;
10481: +
10482: + darwin)
10483: + # Like Linux, but with the current version available in
10484: + # verstring for coding it into the library header
10485: + func_arith $current - $age
10486: + major=.$func_arith_result
10487: + versuffix=$major.$age.$revision
10488: + # Darwin ld doesn't like 0 for these options...
10489: + func_arith $current + 1
10490: + minor_current=$func_arith_result
10491: + xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
10492: + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
10493: + # On Darwin other compilers
10494: + case $CC in
10495: + nagfor*)
10496: + verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
10497: + ;;
10498: + *)
10499: + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
10500: + ;;
10501: + esac
10502: + ;;
10503: +
10504: + freebsd-aout)
10505: + major=.$current
10506: + versuffix=.$current.$revision
10507: + ;;
10508: +
10509: + freebsd-elf)
10510: + func_arith $current - $age
10511: + major=.$func_arith_result
10512: + versuffix=$major.$age.$revision
10513: + ;;
10514: +
10515: + irix | nonstopux)
10516: + if test no = "$lt_irix_increment"; then
10517: + func_arith $current - $age
10518: + else
10519: + func_arith $current - $age + 1
10520: + fi
10521: + major=$func_arith_result
10522: +
10523: + case $version_type in
10524: + nonstopux) verstring_prefix=nonstopux ;;
10525: + *) verstring_prefix=sgi ;;
10526: + esac
10527: + verstring=$verstring_prefix$major.$revision
10528: +
10529: + # Add in all the interfaces that we are compatible with.
10530: + loop=$revision
10531: + while test 0 -ne "$loop"; do
10532: + func_arith $revision - $loop
10533: + iface=$func_arith_result
10534: + func_arith $loop - 1
10535: + loop=$func_arith_result
10536: + verstring=$verstring_prefix$major.$iface:$verstring
10537: + done
10538: +
10539: + # Before this point, $major must not contain '.'.
10540: + major=.$major
10541: + versuffix=$major.$revision
10542: + ;;
10543: +
10544: + linux) # correct to gnu/linux during the next big refactor
10545: + func_arith $current - $age
10546: + major=.$func_arith_result
10547: + versuffix=$major.$age.$revision
10548: + ;;
10549: +
10550: + osf)
10551: + func_arith $current - $age
10552: + major=.$func_arith_result
10553: + versuffix=.$current.$age.$revision
10554: + verstring=$current.$age.$revision
10555: +
10556: + # Add in all the interfaces that we are compatible with.
10557: + loop=$age
10558: + while test 0 -ne "$loop"; do
10559: + func_arith $current - $loop
10560: + iface=$func_arith_result
10561: + func_arith $loop - 1
10562: + loop=$func_arith_result
10563: + verstring=$verstring:$iface.0
10564: + done
10565: +
10566: + # Make executables depend on our current version.
10567: + func_append verstring ":$current.0"
10568: + ;;
10569: +
10570: + qnx)
10571: + major=.$current
10572: + versuffix=.$current
10573: + ;;
10574: +
10575: + sco)
10576: + major=.$current
10577: + versuffix=.$current
10578: + ;;
10579: +
10580: + sunos)
10581: + major=.$current
10582: + versuffix=.$current.$revision
10583: + ;;
10584: +
10585: + windows)
10586: + # Use '-' rather than '.', since we only want one
10587: + # extension on DOS 8.3 file systems.
10588: + func_arith $current - $age
10589: + major=$func_arith_result
10590: + versuffix=-$major
10591: + ;;
10592: +
10593: + *)
10594: + func_fatal_configuration "unknown library version type '$version_type'"
10595: + ;;
10596: + esac
10597: +
10598: + # Clear the version info if we defaulted, and they specified a release.
10599: + if test -z "$vinfo" && test -n "$release"; then
10600: + major=
10601: + case $version_type in
10602: + darwin)
10603: + # we can't check for "0.0" in archive_cmds due to quoting
10604: + # problems, so we reset it completely
10605: + verstring=
10606: + ;;
10607: + *)
10608: + verstring=0.0
10609: + ;;
10610: + esac
10611: + if test no = "$need_version"; then
10612: + versuffix=
10613: + else
10614: + versuffix=.0.0
10615: + fi
10616: + fi
10617: +
10618: + # Remove version info from name if versioning should be avoided
10619: + if test yes,no = "$avoid_version,$need_version"; then
10620: + major=
10621: + versuffix=
10622: + verstring=
10623: + fi
10624: +
10625: + # Check to see if the archive will have undefined symbols.
10626: + if test yes = "$allow_undefined"; then
10627: + if test unsupported = "$allow_undefined_flag"; then
10628: + if test yes = "$build_old_libs"; then
10629: + func_warning "undefined symbols not allowed in $host shared libraries; building static only"
10630: + build_libtool_libs=no
10631: + else
10632: + func_fatal_error "can't build $host shared library unless -no-undefined is specified"
10633: + fi
10634: + fi
10635: + else
10636: + # Don't allow undefined symbols.
10637: + allow_undefined_flag=$no_undefined_flag
10638: + fi
10639: +
10640: + fi
10641: +
10642: + func_generate_dlsyms "$libname" "$libname" :
10643: + func_append libobjs " $symfileobj"
10644: + test " " = "$libobjs" && libobjs=
10645: +
10646: + if test relink != "$opt_mode"; then
10647: + # Remove our outputs, but don't remove object files since they
10648: + # may have been created when compiling PIC objects.
10649: + removelist=
10650: + tempremovelist=`$ECHO "$output_objdir/*"`
10651: + for p in $tempremovelist; do
10652: + case $p in
10653: + *.$objext | *.gcno)
10654: + ;;
10655: + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
10656: + if test -n "$precious_files_regex"; then
10657: + if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
10658: + then
10659: + continue
10660: + fi
10661: + fi
10662: + func_append removelist " $p"
10663: + ;;
10664: + *) ;;
10665: + esac
10666: + done
10667: + test -n "$removelist" && \
10668: + func_show_eval "${RM}r \$removelist"
10669: + fi
10670: +
10671: + # Now set the variables for building old libraries.
10672: + if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
10673: + func_append oldlibs " $output_objdir/$libname.$libext"
10674: +
10675: + # Transform .lo files to .o files.
10676: + oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
10677: + fi
10678: +
10679: + # Eliminate all temporary directories.
10680: + #for path in $notinst_path; do
10681: + # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
10682: + # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
10683: + # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
10684: + #done
10685: +
10686: + if test -n "$xrpath"; then
10687: + # If the user specified any rpath flags, then add them.
10688: + temp_xrpath=
10689: + for libdir in $xrpath; do
10690: + func_replace_sysroot "$libdir"
10691: + func_append temp_xrpath " -R$func_replace_sysroot_result"
10692: + case "$finalize_rpath " in
10693: + *" $libdir "*) ;;
10694: + *) func_append finalize_rpath " $libdir" ;;
10695: + esac
10696: + done
10697: + if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
10698: + dependency_libs="$temp_xrpath $dependency_libs"
10699: + fi
10700: + fi
10701: +
10702: + # Make sure dlfiles contains only unique files that won't be dlpreopened
10703: + old_dlfiles=$dlfiles
10704: + dlfiles=
10705: + for lib in $old_dlfiles; do
10706: + case " $dlprefiles $dlfiles " in
10707: + *" $lib "*) ;;
10708: + *) func_append dlfiles " $lib" ;;
10709: + esac
10710: + done
10711: +
10712: + # Make sure dlprefiles contains only unique files
10713: + old_dlprefiles=$dlprefiles
10714: + dlprefiles=
10715: + for lib in $old_dlprefiles; do
10716: + case "$dlprefiles " in
10717: + *" $lib "*) ;;
10718: + *) func_append dlprefiles " $lib" ;;
10719: + esac
10720: + done
10721: +
10722: + if test yes = "$build_libtool_libs"; then
10723: + if test -n "$rpath"; then
10724: + case $host in
10725: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
10726: + # these systems don't actually have a c library (as such)!
10727: + ;;
10728: + *-*-rhapsody* | *-*-darwin1.[012])
10729: + # Rhapsody C library is in the System framework
10730: + func_append deplibs " System.ltframework"
10731: + ;;
10732: + *-*-netbsd*)
10733: + # Don't link with libc until the a.out ld.so is fixed.
10734: + ;;
10735: + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
10736: + # Do not include libc due to us having libc/libc_r.
10737: + ;;
10738: + *-*-sco3.2v5* | *-*-sco5v6*)
10739: + # Causes problems with __ctype
10740: + ;;
10741: + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
10742: + # Compiler inserts libc in the correct place for threads to work
10743: + ;;
10744: + *)
10745: + # Add libc to deplibs on all other systems if necessary.
10746: + if test yes = "$build_libtool_need_lc"; then
10747: + func_append deplibs " -lc"
10748: + fi
10749: + ;;
10750: + esac
10751: + fi
10752: +
10753: + # Transform deplibs into only deplibs that can be linked in shared.
10754: + name_save=$name
10755: + libname_save=$libname
10756: + release_save=$release
10757: + versuffix_save=$versuffix
10758: + major_save=$major
10759: + # I'm not sure if I'm treating the release correctly. I think
10760: + # release should show up in the -l (ie -lgmp5) so we don't want to
10761: + # add it in twice. Is that correct?
10762: + release=
10763: + versuffix=
10764: + major=
10765: + newdeplibs=
10766: + droppeddeps=no
10767: + case $deplibs_check_method in
10768: + pass_all)
10769: + # Don't check for shared/static. Everything works.
10770: + # This might be a little naive. We might want to check
10771: + # whether the library exists or not. But this is on
10772: + # osf3 & osf4 and I'm not really sure... Just
10773: + # implementing what was already the behavior.
10774: + newdeplibs=$deplibs
10775: + ;;
10776: + test_compile)
10777: + # This code stresses the "libraries are programs" paradigm to its
10778: + # limits. Maybe even breaks it. We compile a program, linking it
10779: + # against the deplibs as a proxy for the library. Then we can check
10780: + # whether they linked in statically or dynamically with ldd.
10781: + $opt_dry_run || $RM conftest.c
10782: + cat > conftest.c <<EOF
10783: + int main() { return 0; }
10784: +EOF
10785: + $opt_dry_run || $RM conftest
10786: + if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
10787: + ldd_output=`ldd conftest`
10788: + for i in $deplibs; do
10789: + case $i in
10790: + -l*)
10791: + func_stripname -l '' "$i"
10792: + name=$func_stripname_result
10793: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
10794: + case " $predeps $postdeps " in
10795: + *" $i "*)
10796: + func_append newdeplibs " $i"
10797: + i=
10798: + ;;
10799: + esac
10800: + fi
10801: + if test -n "$i"; then
10802: + libname=`eval "\\$ECHO \"$libname_spec\""`
10803: + deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
10804: + set dummy $deplib_matches; shift
10805: + deplib_match=$1
10806: + if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
10807: + func_append newdeplibs " $i"
10808: + else
10809: + droppeddeps=yes
10810: + echo
10811: + $ECHO "*** Warning: dynamic linker does not accept needed library $i."
10812: + echo "*** I have the capability to make that library automatically link in when"
10813: + echo "*** you link to this library. But I can only do this if you have a"
10814: + echo "*** shared version of the library, which I believe you do not have"
10815: + echo "*** because a test_compile did reveal that the linker did not use it for"
10816: + echo "*** its dynamic dependency list that programs get resolved with at runtime."
10817: + fi
10818: + fi
10819: + ;;
10820: + *)
10821: + func_append newdeplibs " $i"
10822: + ;;
10823: + esac
10824: + done
10825: + else
10826: + # Error occurred in the first compile. Let's try to salvage
10827: + # the situation: Compile a separate program for each library.
10828: + for i in $deplibs; do
10829: + case $i in
10830: + -l*)
10831: + func_stripname -l '' "$i"
10832: + name=$func_stripname_result
10833: + $opt_dry_run || $RM conftest
10834: + if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
10835: + ldd_output=`ldd conftest`
10836: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
10837: + case " $predeps $postdeps " in
10838: + *" $i "*)
10839: + func_append newdeplibs " $i"
10840: + i=
10841: + ;;
10842: + esac
10843: + fi
10844: + if test -n "$i"; then
10845: + libname=`eval "\\$ECHO \"$libname_spec\""`
10846: + deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
10847: + set dummy $deplib_matches; shift
10848: + deplib_match=$1
10849: + if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
10850: + func_append newdeplibs " $i"
10851: + else
10852: + droppeddeps=yes
10853: + echo
10854: + $ECHO "*** Warning: dynamic linker does not accept needed library $i."
10855: + echo "*** I have the capability to make that library automatically link in when"
10856: + echo "*** you link to this library. But I can only do this if you have a"
10857: + echo "*** shared version of the library, which you do not appear to have"
10858: + echo "*** because a test_compile did reveal that the linker did not use this one"
10859: + echo "*** as a dynamic dependency that programs can get resolved with at runtime."
10860: + fi
10861: + fi
10862: + else
10863: + droppeddeps=yes
10864: + echo
10865: + $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
10866: + echo "*** make it link in! You will probably need to install it or some"
10867: + echo "*** library that it depends on before this library will be fully"
10868: + echo "*** functional. Installing it before continuing would be even better."
10869: + fi
10870: + ;;
10871: + *)
10872: + func_append newdeplibs " $i"
10873: + ;;
10874: + esac
10875: + done
10876: + fi
10877: + ;;
10878: + file_magic*)
10879: + set dummy $deplibs_check_method; shift
10880: + file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
10881: + for a_deplib in $deplibs; do
10882: + case $a_deplib in
10883: + -l*)
10884: + func_stripname -l '' "$a_deplib"
10885: + name=$func_stripname_result
10886: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
10887: + case " $predeps $postdeps " in
10888: + *" $a_deplib "*)
10889: + func_append newdeplibs " $a_deplib"
10890: + a_deplib=
10891: + ;;
10892: + esac
10893: + fi
10894: + if test -n "$a_deplib"; then
10895: + libname=`eval "\\$ECHO \"$libname_spec\""`
10896: + if test -n "$file_magic_glob"; then
10897: + libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
10898: + else
10899: + libnameglob=$libname
10900: + fi
10901: + test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
10902: + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
10903: + if test yes = "$want_nocaseglob"; then
10904: + shopt -s nocaseglob
10905: + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
10906: + $nocaseglob
10907: + else
10908: + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
10909: + fi
10910: + for potent_lib in $potential_libs; do
10911: + # Follow soft links.
10912: + if ls -lLd "$potent_lib" 2>/dev/null |
10913: + $GREP " -> " >/dev/null; then
10914: + continue
10915: + fi
10916: + # The statement above tries to avoid entering an
10917: + # endless loop below, in case of cyclic links.
10918: + # We might still enter an endless loop, since a link
10919: + # loop can be closed while we follow links,
10920: + # but so what?
10921: + potlib=$potent_lib
10922: + while test -h "$potlib" 2>/dev/null; do
10923: + potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
10924: + case $potliblink in
10925: + [\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
10926: + *) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
10927: + esac
10928: + done
10929: + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
10930: + $SED -e 10q |
10931: + $EGREP "$file_magic_regex" > /dev/null; then
10932: + func_append newdeplibs " $a_deplib"
10933: + a_deplib=
10934: + break 2
10935: + fi
10936: + done
10937: + done
10938: + fi
10939: + if test -n "$a_deplib"; then
10940: + droppeddeps=yes
10941: + echo
10942: + $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
10943: + echo "*** I have the capability to make that library automatically link in when"
10944: + echo "*** you link to this library. But I can only do this if you have a"
10945: + echo "*** shared version of the library, which you do not appear to have"
10946: + echo "*** because I did check the linker path looking for a file starting"
10947: + if test -z "$potlib"; then
10948: + $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
10949: + else
10950: + $ECHO "*** with $libname and none of the candidates passed a file format test"
10951: + $ECHO "*** using a file magic. Last file checked: $potlib"
10952: + fi
10953: + fi
10954: + ;;
10955: + *)
10956: + # Add a -L argument.
10957: + func_append newdeplibs " $a_deplib"
10958: + ;;
10959: + esac
10960: + done # Gone through all deplibs.
10961: + ;;
10962: + match_pattern*)
10963: + set dummy $deplibs_check_method; shift
10964: + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
10965: + for a_deplib in $deplibs; do
10966: + case $a_deplib in
10967: + -l*)
10968: + func_stripname -l '' "$a_deplib"
10969: + name=$func_stripname_result
10970: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
10971: + case " $predeps $postdeps " in
10972: + *" $a_deplib "*)
10973: + func_append newdeplibs " $a_deplib"
10974: + a_deplib=
10975: + ;;
10976: + esac
10977: + fi
10978: + if test -n "$a_deplib"; then
10979: + libname=`eval "\\$ECHO \"$libname_spec\""`
10980: + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
10981: + potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
10982: + for potent_lib in $potential_libs; do
10983: + potlib=$potent_lib # see symlink-check above in file_magic test
10984: + if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
10985: + $EGREP "$match_pattern_regex" > /dev/null; then
10986: + func_append newdeplibs " $a_deplib"
10987: + a_deplib=
10988: + break 2
10989: + fi
10990: + done
10991: + done
10992: + fi
10993: + if test -n "$a_deplib"; then
10994: + droppeddeps=yes
10995: + echo
10996: + $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
10997: + echo "*** I have the capability to make that library automatically link in when"
10998: + echo "*** you link to this library. But I can only do this if you have a"
10999: + echo "*** shared version of the library, which you do not appear to have"
11000: + echo "*** because I did check the linker path looking for a file starting"
11001: + if test -z "$potlib"; then
11002: + $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
11003: + else
11004: + $ECHO "*** with $libname and none of the candidates passed a file format test"
11005: + $ECHO "*** using a regex pattern. Last file checked: $potlib"
11006: + fi
11007: + fi
11008: + ;;
11009: + *)
11010: + # Add a -L argument.
11011: + func_append newdeplibs " $a_deplib"
11012: + ;;
11013: + esac
11014: + done # Gone through all deplibs.
11015: + ;;
11016: + none | unknown | *)
11017: + newdeplibs=
11018: + tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
11019: + if test yes = "$allow_libtool_libs_with_static_runtimes"; then
11020: + for i in $predeps $postdeps; do
11021: + # can't use Xsed below, because $i might contain '/'
11022: + tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
11023: + done
11024: + fi
11025: + case $tmp_deplibs in
11026: + *[!\ \ ]*)
11027: + echo
11028: + if test none = "$deplibs_check_method"; then
11029: + echo "*** Warning: inter-library dependencies are not supported in this platform."
11030: + else
11031: + echo "*** Warning: inter-library dependencies are not known to be supported."
11032: + fi
11033: + echo "*** All declared inter-library dependencies are being dropped."
11034: + droppeddeps=yes
11035: + ;;
11036: + esac
11037: + ;;
11038: + esac
11039: + versuffix=$versuffix_save
11040: + major=$major_save
11041: + release=$release_save
11042: + libname=$libname_save
11043: + name=$name_save
11044: +
11045: + case $host in
11046: + *-*-rhapsody* | *-*-darwin1.[012])
11047: + # On Rhapsody replace the C library with the System framework
11048: + newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
11049: + ;;
11050: + esac
11051: +
11052: + if test yes = "$droppeddeps"; then
11053: + if test yes = "$module"; then
11054: + echo
11055: + echo "*** Warning: libtool could not satisfy all declared inter-library"
11056: + $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
11057: + echo "*** a static module, that should work as long as the dlopening"
11058: + echo "*** application is linked with the -dlopen flag."
11059: + if test -z "$global_symbol_pipe"; then
11060: + echo
11061: + echo "*** However, this would only work if libtool was able to extract symbol"
11062: + echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
11063: + echo "*** not find such a program. So, this module is probably useless."
11064: + echo "*** 'nm' from GNU binutils and a full rebuild may help."
11065: + fi
11066: + if test no = "$build_old_libs"; then
11067: + oldlibs=$output_objdir/$libname.$libext
11068: + build_libtool_libs=module
11069: + build_old_libs=yes
11070: + else
11071: + build_libtool_libs=no
11072: + fi
11073: + else
11074: + echo "*** The inter-library dependencies that have been dropped here will be"
11075: + echo "*** automatically added whenever a program is linked with this library"
11076: + echo "*** or is declared to -dlopen it."
11077: +
11078: + if test no = "$allow_undefined"; then
11079: + echo
11080: + echo "*** Since this library must not contain undefined symbols,"
11081: + echo "*** because either the platform does not support them or"
11082: + echo "*** it was explicitly requested with -no-undefined,"
11083: + echo "*** libtool will only create a static version of it."
11084: + if test no = "$build_old_libs"; then
11085: + oldlibs=$output_objdir/$libname.$libext
11086: + build_libtool_libs=module
11087: + build_old_libs=yes
11088: + else
11089: + build_libtool_libs=no
11090: + fi
11091: + fi
11092: + fi
11093: + fi
11094: + # Done checking deplibs!
11095: + deplibs=$newdeplibs
11096: + fi
11097: + # Time to change all our "foo.ltframework" stuff back to "-framework foo"
11098: + case $host in
11099: + *-*-darwin*)
11100: + newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
11101: + new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
11102: + deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
11103: + ;;
11104: + esac
11105: +
11106: + # move library search paths that coincide with paths to not yet
11107: + # installed libraries to the beginning of the library search list
11108: + new_libs=
11109: + for path in $notinst_path; do
11110: + case " $new_libs " in
11111: + *" -L$path/$objdir "*) ;;
11112: + *)
11113: + case " $deplibs " in
11114: + *" -L$path/$objdir "*)
11115: + func_append new_libs " -L$path/$objdir" ;;
11116: + esac
11117: + ;;
11118: + esac
11119: + done
11120: + for deplib in $deplibs; do
11121: + case $deplib in
11122: + -L*)
11123: + case " $new_libs " in
11124: + *" $deplib "*) ;;
11125: + *) func_append new_libs " $deplib" ;;
11126: + esac
11127: + ;;
11128: + *) func_append new_libs " $deplib" ;;
11129: + esac
11130: + done
11131: + deplibs=$new_libs
11132: +
11133: + # All the library-specific variables (install_libdir is set above).
11134: + library_names=
11135: + old_library=
11136: + dlname=
11137: +
11138: + # Test again, we may have decided not to build it any more
11139: + if test yes = "$build_libtool_libs"; then
11140: + # Remove $wl instances when linking with ld.
11141: + # FIXME: should test the right _cmds variable.
11142: + case $archive_cmds in
11143: + *\$LD\ *) wl= ;;
11144: + esac
11145: + if test yes = "$hardcode_into_libs"; then
11146: + # Hardcode the library paths
11147: + hardcode_libdirs=
11148: + dep_rpath=
11149: + rpath=$finalize_rpath
11150: + test relink = "$opt_mode" || rpath=$compile_rpath$rpath
11151: + for libdir in $rpath; do
11152: + if test -n "$hardcode_libdir_flag_spec"; then
11153: + if test -n "$hardcode_libdir_separator"; then
11154: + func_replace_sysroot "$libdir"
11155: + libdir=$func_replace_sysroot_result
11156: + if test -z "$hardcode_libdirs"; then
11157: + hardcode_libdirs=$libdir
11158: + else
11159: + # Just accumulate the unique libdirs.
11160: + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
11161: + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
11162: + ;;
11163: + *)
11164: + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
11165: + ;;
11166: + esac
11167: + fi
11168: + else
11169: + eval flag=\"$hardcode_libdir_flag_spec\"
11170: + func_append dep_rpath " $flag"
11171: + fi
11172: + elif test -n "$runpath_var"; then
11173: + case "$perm_rpath " in
11174: + *" $libdir "*) ;;
11175: + *) func_append perm_rpath " $libdir" ;;
11176: + esac
11177: + fi
11178: + done
11179: + # Substitute the hardcoded libdirs into the rpath.
11180: + if test -n "$hardcode_libdir_separator" &&
11181: + test -n "$hardcode_libdirs"; then
11182: + libdir=$hardcode_libdirs
11183: + eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
11184: + fi
11185: + if test -n "$runpath_var" && test -n "$perm_rpath"; then
11186: + # We should set the runpath_var.
11187: + rpath=
11188: + for dir in $perm_rpath; do
11189: + func_append rpath "$dir:"
11190: + done
11191: + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
11192: + fi
11193: + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
11194: + fi
11195: +
11196: + shlibpath=$finalize_shlibpath
11197: + test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
11198: + if test -n "$shlibpath"; then
11199: + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
11200: + fi
11201: +
11202: + # Get the real and link names of the library.
11203: + eval shared_ext=\"$shrext_cmds\"
11204: + eval library_names=\"$library_names_spec\"
11205: + set dummy $library_names
11206: + shift
11207: + realname=$1
11208: + shift
11209: +
11210: + if test -n "$soname_spec"; then
11211: + eval soname=\"$soname_spec\"
11212: + else
11213: + soname=$realname
11214: + fi
11215: + if test -z "$dlname"; then
11216: + dlname=$soname
11217: + fi
11218: +
11219: + lib=$output_objdir/$realname
11220: + linknames=
11221: + for link
11222: + do
11223: + func_append linknames " $link"
11224: + done
11225: +
11226: + # Use standard objects if they are pic
11227: + test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
11228: + test "X$libobjs" = "X " && libobjs=
11229: +
11230: + delfiles=
11231: + if test -n "$export_symbols" && test -n "$include_expsyms"; then
11232: + $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
11233: + export_symbols=$output_objdir/$libname.uexp
11234: + func_append delfiles " $export_symbols"
11235: + fi
11236: +
11237: + orig_export_symbols=
11238: + case $host_os in
11239: + cygwin* | mingw* | cegcc*)
11240: + if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
11241: + # exporting using user supplied symfile
11242: + func_dll_def_p "$export_symbols" || {
11243: + # and it's NOT already a .def file. Must figure out
11244: + # which of the given symbols are data symbols and tag
11245: + # them as such. So, trigger use of export_symbols_cmds.
11246: + # export_symbols gets reassigned inside the "prepare
11247: + # the list of exported symbols" if statement, so the
11248: + # include_expsyms logic still works.
11249: + orig_export_symbols=$export_symbols
11250: + export_symbols=
11251: + always_export_symbols=yes
11252: + }
11253: + fi
11254: + ;;
11255: + esac
11256: +
11257: + # Prepare the list of exported symbols
11258: + if test -z "$export_symbols"; then
11259: + if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
11260: + func_verbose "generating symbol list for '$libname.la'"
11261: + export_symbols=$output_objdir/$libname.exp
11262: + $opt_dry_run || $RM $export_symbols
11263: + cmds=$export_symbols_cmds
11264: + save_ifs=$IFS; IFS='~'
11265: + for cmd1 in $cmds; do
11266: + IFS=$save_ifs
11267: + # Take the normal branch if the nm_file_list_spec branch
11268: + # doesn't work or if tool conversion is not needed.
11269: + case $nm_file_list_spec~$to_tool_file_cmd in
11270: + *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
11271: + try_normal_branch=yes
11272: + eval cmd=\"$cmd1\"
11273: + func_len " $cmd"
11274: + len=$func_len_result
11275: + ;;
11276: + *)
11277: + try_normal_branch=no
11278: + ;;
11279: + esac
11280: + if test yes = "$try_normal_branch" \
11281: + && { test "$len" -lt "$max_cmd_len" \
11282: + || test "$max_cmd_len" -le -1; }
11283: + then
11284: + func_show_eval "$cmd" 'exit $?'
11285: + skipped_export=false
11286: + elif test -n "$nm_file_list_spec"; then
11287: + func_basename "$output"
11288: + output_la=$func_basename_result
11289: + save_libobjs=$libobjs
11290: + save_output=$output
11291: + output=$output_objdir/$output_la.nm
11292: + func_to_tool_file "$output"
11293: + libobjs=$nm_file_list_spec$func_to_tool_file_result
11294: + func_append delfiles " $output"
11295: + func_verbose "creating $NM input file list: $output"
11296: + for obj in $save_libobjs; do
11297: + func_to_tool_file "$obj"
11298: + $ECHO "$func_to_tool_file_result"
11299: + done > "$output"
11300: + eval cmd=\"$cmd1\"
11301: + func_show_eval "$cmd" 'exit $?'
11302: + output=$save_output
11303: + libobjs=$save_libobjs
11304: + skipped_export=false
11305: + else
11306: + # The command line is too long to execute in one step.
11307: + func_verbose "using reloadable object file for export list..."
11308: + skipped_export=:
11309: + # Break out early, otherwise skipped_export may be
11310: + # set to false by a later but shorter cmd.
11311: + break
11312: + fi
11313: + done
11314: + IFS=$save_ifs
11315: + if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
11316: + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
11317: + func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
11318: + fi
11319: + fi
11320: + fi
11321: +
11322: + if test -n "$export_symbols" && test -n "$include_expsyms"; then
11323: + tmp_export_symbols=$export_symbols
11324: + test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
11325: + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
11326: + fi
11327: +
11328: + if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
11329: + # The given exports_symbols file has to be filtered, so filter it.
11330: + func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
11331: + # FIXME: $output_objdir/$libname.filter potentially contains lots of
11332: + # 's' commands, which not all seds can handle. GNU sed should be fine
11333: + # though. Also, the filter scales superlinearly with the number of
11334: + # global variables. join(1) would be nice here, but unfortunately
11335: + # isn't a blessed tool.
11336: + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
11337: + func_append delfiles " $export_symbols $output_objdir/$libname.filter"
11338: + export_symbols=$output_objdir/$libname.def
11339: + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
11340: + fi
11341: +
11342: + tmp_deplibs=
11343: + for test_deplib in $deplibs; do
11344: + case " $convenience " in
11345: + *" $test_deplib "*) ;;
11346: + *)
11347: + func_append tmp_deplibs " $test_deplib"
11348: + ;;
11349: + esac
11350: + done
11351: + deplibs=$tmp_deplibs
11352: +
11353: + if test -n "$convenience"; then
11354: + if test -n "$whole_archive_flag_spec" &&
11355: + test yes = "$compiler_needs_object" &&
11356: + test -z "$libobjs"; then
11357: + # extract the archives, so we have objects to list.
11358: + # TODO: could optimize this to just extract one archive.
11359: + whole_archive_flag_spec=
11360: + fi
11361: + if test -n "$whole_archive_flag_spec"; then
11362: + save_libobjs=$libobjs
11363: + eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
11364: + test "X$libobjs" = "X " && libobjs=
11365: + else
11366: + gentop=$output_objdir/${outputname}x
11367: + func_append generated " $gentop"
11368: +
11369: + func_extract_archives $gentop $convenience
11370: + func_append libobjs " $func_extract_archives_result"
11371: + test "X$libobjs" = "X " && libobjs=
11372: + fi
11373: + fi
11374: +
11375: + if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
11376: + eval flag=\"$thread_safe_flag_spec\"
11377: + func_append linker_flags " $flag"
11378: + fi
11379: +
11380: + # Make a backup of the uninstalled library when relinking
11381: + if test relink = "$opt_mode"; then
11382: + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
11383: + fi
11384: +
11385: + # Do each of the archive commands.
11386: + if test yes = "$module" && test -n "$module_cmds"; then
11387: + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
11388: + eval test_cmds=\"$module_expsym_cmds\"
11389: + cmds=$module_expsym_cmds
11390: + else
11391: + eval test_cmds=\"$module_cmds\"
11392: + cmds=$module_cmds
11393: + fi
11394: + else
11395: + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
11396: + eval test_cmds=\"$archive_expsym_cmds\"
11397: + cmds=$archive_expsym_cmds
11398: + else
11399: + eval test_cmds=\"$archive_cmds\"
11400: + cmds=$archive_cmds
11401: + fi
11402: + fi
11403: +
11404: + if test : != "$skipped_export" &&
11405: + func_len " $test_cmds" &&
11406: + len=$func_len_result &&
11407: + test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
11408: + :
11409: + else
11410: + # The command line is too long to link in one step, link piecewise
11411: + # or, if using GNU ld and skipped_export is not :, use a linker
11412: + # script.
11413: +
11414: + # Save the value of $output and $libobjs because we want to
11415: + # use them later. If we have whole_archive_flag_spec, we
11416: + # want to use save_libobjs as it was before
11417: + # whole_archive_flag_spec was expanded, because we can't
11418: + # assume the linker understands whole_archive_flag_spec.
11419: + # This may have to be revisited, in case too many
11420: + # convenience libraries get linked in and end up exceeding
11421: + # the spec.
11422: + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
11423: + save_libobjs=$libobjs
11424: + fi
11425: + save_output=$output
11426: + func_basename "$output"
11427: + output_la=$func_basename_result
11428: +
11429: + # Clear the reloadable object creation command queue and
11430: + # initialize k to one.
11431: + test_cmds=
11432: + concat_cmds=
11433: + objlist=
11434: + last_robj=
11435: + k=1
11436: +
11437: + if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
11438: + output=$output_objdir/$output_la.lnkscript
11439: + func_verbose "creating GNU ld script: $output"
11440: + echo 'INPUT (' > $output
11441: + for obj in $save_libobjs
11442: + do
11443: + func_to_tool_file "$obj"
11444: + $ECHO "$func_to_tool_file_result" >> $output
11445: + done
11446: + echo ')' >> $output
11447: + func_append delfiles " $output"
11448: + func_to_tool_file "$output"
11449: + output=$func_to_tool_file_result
11450: + elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
11451: + output=$output_objdir/$output_la.lnk
11452: + func_verbose "creating linker input file list: $output"
11453: + : > $output
11454: + set x $save_libobjs
11455: + shift
11456: + firstobj=
11457: + if test yes = "$compiler_needs_object"; then
11458: + firstobj="$1 "
11459: + shift
11460: + fi
11461: + for obj
11462: + do
11463: + func_to_tool_file "$obj"
11464: + $ECHO "$func_to_tool_file_result" >> $output
11465: + done
11466: + func_append delfiles " $output"
11467: + func_to_tool_file "$output"
11468: + output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
11469: + else
11470: + if test -n "$save_libobjs"; then
11471: + func_verbose "creating reloadable object files..."
11472: + output=$output_objdir/$output_la-$k.$objext
11473: + eval test_cmds=\"$reload_cmds\"
11474: + func_len " $test_cmds"
11475: + len0=$func_len_result
11476: + len=$len0
11477: +
11478: + # Loop over the list of objects to be linked.
11479: + for obj in $save_libobjs
11480: + do
11481: + func_len " $obj"
11482: + func_arith $len + $func_len_result
11483: + len=$func_arith_result
11484: + if test -z "$objlist" ||
11485: + test "$len" -lt "$max_cmd_len"; then
11486: + func_append objlist " $obj"
11487: + else
11488: + # The command $test_cmds is almost too long, add a
11489: + # command to the queue.
11490: + if test 1 -eq "$k"; then
11491: + # The first file doesn't have a previous command to add.
11492: + reload_objs=$objlist
11493: + eval concat_cmds=\"$reload_cmds\"
11494: + else
11495: + # All subsequent reloadable object files will link in
11496: + # the last one created.
11497: + reload_objs="$objlist $last_robj"
11498: + eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
11499: + fi
11500: + last_robj=$output_objdir/$output_la-$k.$objext
11501: + func_arith $k + 1
11502: + k=$func_arith_result
11503: + output=$output_objdir/$output_la-$k.$objext
11504: + objlist=" $obj"
11505: + func_len " $last_robj"
11506: + func_arith $len0 + $func_len_result
11507: + len=$func_arith_result
11508: + fi
11509: + done
11510: + # Handle the remaining objects by creating one last
11511: + # reloadable object file. All subsequent reloadable object
11512: + # files will link in the last one created.
11513: + test -z "$concat_cmds" || concat_cmds=$concat_cmds~
11514: + reload_objs="$objlist $last_robj"
11515: + eval concat_cmds=\"\$concat_cmds$reload_cmds\"
11516: + if test -n "$last_robj"; then
11517: + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
11518: + fi
11519: + func_append delfiles " $output"
11520: +
11521: + else
11522: + output=
11523: + fi
11524: +
11525: + ${skipped_export-false} && {
11526: + func_verbose "generating symbol list for '$libname.la'"
11527: + export_symbols=$output_objdir/$libname.exp
11528: + $opt_dry_run || $RM $export_symbols
11529: + libobjs=$output
11530: + # Append the command to create the export file.
11531: + test -z "$concat_cmds" || concat_cmds=$concat_cmds~
11532: + eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
11533: + if test -n "$last_robj"; then
11534: + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
11535: + fi
11536: + }
11537: +
11538: + test -n "$save_libobjs" &&
11539: + func_verbose "creating a temporary reloadable object file: $output"
11540: +
11541: + # Loop through the commands generated above and execute them.
11542: + save_ifs=$IFS; IFS='~'
11543: + for cmd in $concat_cmds; do
11544: + IFS=$save_ifs
11545: + $opt_quiet || {
11546: + func_quote_for_expand "$cmd"
11547: + eval "func_echo $func_quote_for_expand_result"
11548: + }
11549: + $opt_dry_run || eval "$cmd" || {
11550: + lt_exit=$?
11551: +
11552: + # Restore the uninstalled library and exit
11553: + if test relink = "$opt_mode"; then
11554: + ( cd "$output_objdir" && \
11555: + $RM "${realname}T" && \
11556: + $MV "${realname}U" "$realname" )
11557: + fi
11558: +
11559: + exit $lt_exit
11560: + }
11561: + done
11562: + IFS=$save_ifs
11563: +
11564: + if test -n "$export_symbols_regex" && ${skipped_export-false}; then
11565: + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
11566: + func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
11567: + fi
11568: + fi
11569: +
11570: + ${skipped_export-false} && {
11571: + if test -n "$export_symbols" && test -n "$include_expsyms"; then
11572: + tmp_export_symbols=$export_symbols
11573: + test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
11574: + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
11575: + fi
11576: +
11577: + if test -n "$orig_export_symbols"; then
11578: + # The given exports_symbols file has to be filtered, so filter it.
11579: + func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
11580: + # FIXME: $output_objdir/$libname.filter potentially contains lots of
11581: + # 's' commands, which not all seds can handle. GNU sed should be fine
11582: + # though. Also, the filter scales superlinearly with the number of
11583: + # global variables. join(1) would be nice here, but unfortunately
11584: + # isn't a blessed tool.
11585: + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
11586: + func_append delfiles " $export_symbols $output_objdir/$libname.filter"
11587: + export_symbols=$output_objdir/$libname.def
11588: + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
11589: + fi
11590: + }
11591: +
11592: + libobjs=$output
11593: + # Restore the value of output.
11594: + output=$save_output
11595: +
11596: + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
11597: + eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
11598: + test "X$libobjs" = "X " && libobjs=
11599: + fi
11600: + # Expand the library linking commands again to reset the
11601: + # value of $libobjs for piecewise linking.
11602: +
11603: + # Do each of the archive commands.
11604: + if test yes = "$module" && test -n "$module_cmds"; then
11605: + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
11606: + cmds=$module_expsym_cmds
11607: + else
11608: + cmds=$module_cmds
11609: + fi
11610: + else
11611: + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
11612: + cmds=$archive_expsym_cmds
11613: + else
11614: + cmds=$archive_cmds
11615: + fi
11616: + fi
11617: + fi
11618: +
11619: + if test -n "$delfiles"; then
11620: + # Append the command to remove temporary files to $cmds.
11621: + eval cmds=\"\$cmds~\$RM $delfiles\"
11622: + fi
11623: +
11624: + # Add any objects from preloaded convenience libraries
11625: + if test -n "$dlprefiles"; then
11626: + gentop=$output_objdir/${outputname}x
11627: + func_append generated " $gentop"
11628: +
11629: + func_extract_archives $gentop $dlprefiles
11630: + func_append libobjs " $func_extract_archives_result"
11631: + test "X$libobjs" = "X " && libobjs=
11632: + fi
11633: +
11634: + save_ifs=$IFS; IFS='~'
11635: + for cmd in $cmds; do
11636: + IFS=$sp$nl
11637: + eval cmd=\"$cmd\"
11638: + IFS=$save_ifs
11639: + $opt_quiet || {
11640: + func_quote_for_expand "$cmd"
11641: + eval "func_echo $func_quote_for_expand_result"
11642: + }
11643: + $opt_dry_run || eval "$cmd" || {
11644: + lt_exit=$?
11645: +
11646: + # Restore the uninstalled library and exit
11647: + if test relink = "$opt_mode"; then
11648: + ( cd "$output_objdir" && \
11649: + $RM "${realname}T" && \
11650: + $MV "${realname}U" "$realname" )
11651: + fi
11652: +
11653: + exit $lt_exit
11654: + }
11655: + done
11656: + IFS=$save_ifs
11657: +
11658: + # Restore the uninstalled library and exit
11659: + if test relink = "$opt_mode"; then
11660: + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
11661: +
11662: + if test -n "$convenience"; then
11663: + if test -z "$whole_archive_flag_spec"; then
11664: + func_show_eval '${RM}r "$gentop"'
11665: + fi
11666: + fi
11667: +
11668: + exit $EXIT_SUCCESS
11669: + fi
11670: +
11671: + # Create links to the real library.
11672: + for linkname in $linknames; do
11673: + if test "$realname" != "$linkname"; then
11674: + func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
11675: + fi
11676: + done
11677: +
11678: + # If -module or -export-dynamic was specified, set the dlname.
11679: + if test yes = "$module" || test yes = "$export_dynamic"; then
11680: + # On all known operating systems, these are identical.
11681: + dlname=$soname
11682: + fi
11683: + fi
11684: + ;;
11685: +
11686: + obj)
11687: + if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
11688: + func_warning "'-dlopen' is ignored for objects"
11689: + fi
11690: +
11691: + case " $deplibs" in
11692: + *\ -l* | *\ -L*)
11693: + func_warning "'-l' and '-L' are ignored for objects" ;;
11694: + esac
11695: +
11696: + test -n "$rpath" && \
11697: + func_warning "'-rpath' is ignored for objects"
11698: +
11699: + test -n "$xrpath" && \
11700: + func_warning "'-R' is ignored for objects"
11701: +
11702: + test -n "$vinfo" && \
11703: + func_warning "'-version-info' is ignored for objects"
11704: +
11705: + test -n "$release" && \
11706: + func_warning "'-release' is ignored for objects"
11707: +
11708: + case $output in
11709: + *.lo)
11710: + test -n "$objs$old_deplibs" && \
11711: + func_fatal_error "cannot build library object '$output' from non-libtool objects"
11712: +
11713: + libobj=$output
11714: + func_lo2o "$libobj"
11715: + obj=$func_lo2o_result
11716: + ;;
11717: + *)
11718: + libobj=
11719: + obj=$output
11720: + ;;
11721: + esac
11722: +
11723: + # Delete the old objects.
11724: + $opt_dry_run || $RM $obj $libobj
11725: +
11726: + # Objects from convenience libraries. This assumes
11727: + # single-version convenience libraries. Whenever we create
11728: + # different ones for PIC/non-PIC, this we'll have to duplicate
11729: + # the extraction.
11730: + reload_conv_objs=
11731: + gentop=
11732: + # if reload_cmds runs $LD directly, get rid of -Wl from
11733: + # whole_archive_flag_spec and hope we can get by with turning comma
11734: + # into space.
11735: + case $reload_cmds in
11736: + *\$LD[\ \$]*) wl= ;;
11737: + esac
11738: + if test -n "$convenience"; then
11739: + if test -n "$whole_archive_flag_spec"; then
11740: + eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
11741: + test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
11742: + reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
11743: + else
11744: + gentop=$output_objdir/${obj}x
11745: + func_append generated " $gentop"
11746: +
11747: + func_extract_archives $gentop $convenience
11748: + reload_conv_objs="$reload_objs $func_extract_archives_result"
11749: + fi
11750: + fi
11751: +
11752: + # If we're not building shared, we need to use non_pic_objs
11753: + test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
11754: +
11755: + # Create the old-style object.
11756: + reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
11757: +
11758: + output=$obj
11759: + func_execute_cmds "$reload_cmds" 'exit $?'
11760: +
11761: + # Exit if we aren't doing a library object file.
11762: + if test -z "$libobj"; then
11763: + if test -n "$gentop"; then
11764: + func_show_eval '${RM}r "$gentop"'
11765: + fi
11766: +
11767: + exit $EXIT_SUCCESS
11768: + fi
11769: +
11770: + test yes = "$build_libtool_libs" || {
11771: + if test -n "$gentop"; then
11772: + func_show_eval '${RM}r "$gentop"'
11773: + fi
11774: +
11775: + # Create an invalid libtool object if no PIC, so that we don't
11776: + # accidentally link it into a program.
11777: + # $show "echo timestamp > $libobj"
11778: + # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
11779: + exit $EXIT_SUCCESS
11780: + }
11781: +
11782: + if test -n "$pic_flag" || test default != "$pic_mode"; then
11783: + # Only do commands if we really have different PIC objects.
11784: + reload_objs="$libobjs $reload_conv_objs"
11785: + output=$libobj
11786: + func_execute_cmds "$reload_cmds" 'exit $?'
11787: + fi
11788: +
11789: + if test -n "$gentop"; then
11790: + func_show_eval '${RM}r "$gentop"'
11791: + fi
11792: +
11793: + exit $EXIT_SUCCESS
11794: + ;;
11795: +
11796: + prog)
11797: + case $host in
11798: + *cygwin*) func_stripname '' '.exe' "$output"
11799: + output=$func_stripname_result.exe;;
11800: + esac
11801: + test -n "$vinfo" && \
11802: + func_warning "'-version-info' is ignored for programs"
11803: +
11804: + test -n "$release" && \
11805: + func_warning "'-release' is ignored for programs"
11806: +
11807: + $preload \
11808: + && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
11809: + && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
11810: +
11811: + case $host in
11812: + *-*-rhapsody* | *-*-darwin1.[012])
11813: + # On Rhapsody replace the C library is the System framework
11814: + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
11815: + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
11816: + ;;
11817: + esac
11818: +
11819: + case $host in
11820: + *-*-darwin*)
11821: + # Don't allow lazy linking, it breaks C++ global constructors
11822: + # But is supposedly fixed on 10.4 or later (yay!).
11823: + if test CXX = "$tagname"; then
11824: + case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
11825: + 10.[0123])
11826: + func_append compile_command " $wl-bind_at_load"
11827: + func_append finalize_command " $wl-bind_at_load"
11828: + ;;
11829: + esac
11830: + fi
11831: + # Time to change all our "foo.ltframework" stuff back to "-framework foo"
11832: + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
11833: + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
11834: + ;;
11835: + esac
11836: +
11837: +
11838: + # move library search paths that coincide with paths to not yet
11839: + # installed libraries to the beginning of the library search list
11840: + new_libs=
11841: + for path in $notinst_path; do
11842: + case " $new_libs " in
11843: + *" -L$path/$objdir "*) ;;
11844: + *)
11845: + case " $compile_deplibs " in
11846: + *" -L$path/$objdir "*)
11847: + func_append new_libs " -L$path/$objdir" ;;
11848: + esac
11849: + ;;
11850: + esac
11851: + done
11852: + for deplib in $compile_deplibs; do
11853: + case $deplib in
11854: + -L*)
11855: + case " $new_libs " in
11856: + *" $deplib "*) ;;
11857: + *) func_append new_libs " $deplib" ;;
11858: + esac
11859: + ;;
11860: + *) func_append new_libs " $deplib" ;;
11861: + esac
11862: + done
11863: + compile_deplibs=$new_libs
11864: +
11865: +
11866: + func_append compile_command " $compile_deplibs"
11867: + func_append finalize_command " $finalize_deplibs"
11868: +
11869: + if test -n "$rpath$xrpath"; then
11870: + # If the user specified any rpath flags, then add them.
11871: + for libdir in $rpath $xrpath; do
11872: + # This is the magic to use -rpath.
11873: + case "$finalize_rpath " in
11874: + *" $libdir "*) ;;
11875: + *) func_append finalize_rpath " $libdir" ;;
11876: + esac
11877: + done
11878: + fi
11879: +
11880: + # Now hardcode the library paths
11881: + rpath=
11882: + hardcode_libdirs=
11883: + for libdir in $compile_rpath $finalize_rpath; do
11884: + if test -n "$hardcode_libdir_flag_spec"; then
11885: + if test -n "$hardcode_libdir_separator"; then
11886: + if test -z "$hardcode_libdirs"; then
11887: + hardcode_libdirs=$libdir
11888: + else
11889: + # Just accumulate the unique libdirs.
11890: + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
11891: + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
11892: + ;;
11893: + *)
11894: + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
11895: + ;;
11896: + esac
11897: + fi
11898: + else
11899: + eval flag=\"$hardcode_libdir_flag_spec\"
11900: + func_append rpath " $flag"
11901: + fi
11902: + elif test -n "$runpath_var"; then
11903: + case "$perm_rpath " in
11904: + *" $libdir "*) ;;
11905: + *) func_append perm_rpath " $libdir" ;;
11906: + esac
11907: + fi
11908: + case $host in
11909: + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
11910: + testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
11911: + case :$dllsearchpath: in
11912: + *":$libdir:"*) ;;
11913: + ::) dllsearchpath=$libdir;;
11914: + *) func_append dllsearchpath ":$libdir";;
11915: + esac
11916: + case :$dllsearchpath: in
11917: + *":$testbindir:"*) ;;
11918: + ::) dllsearchpath=$testbindir;;
11919: + *) func_append dllsearchpath ":$testbindir";;
11920: + esac
11921: + ;;
11922: + esac
11923: + done
11924: + # Substitute the hardcoded libdirs into the rpath.
11925: + if test -n "$hardcode_libdir_separator" &&
11926: + test -n "$hardcode_libdirs"; then
11927: + libdir=$hardcode_libdirs
11928: + eval rpath=\" $hardcode_libdir_flag_spec\"
11929: + fi
11930: + compile_rpath=$rpath
11931: +
11932: + rpath=
11933: + hardcode_libdirs=
11934: + for libdir in $finalize_rpath; do
11935: + if test -n "$hardcode_libdir_flag_spec"; then
11936: + if test -n "$hardcode_libdir_separator"; then
11937: + if test -z "$hardcode_libdirs"; then
11938: + hardcode_libdirs=$libdir
11939: + else
11940: + # Just accumulate the unique libdirs.
11941: + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
11942: + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
11943: + ;;
11944: + *)
11945: + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
11946: + ;;
11947: + esac
11948: + fi
11949: + else
11950: + eval flag=\"$hardcode_libdir_flag_spec\"
11951: + func_append rpath " $flag"
11952: + fi
11953: + elif test -n "$runpath_var"; then
11954: + case "$finalize_perm_rpath " in
11955: + *" $libdir "*) ;;
11956: + *) func_append finalize_perm_rpath " $libdir" ;;
11957: + esac
11958: + fi
11959: + done
11960: + # Substitute the hardcoded libdirs into the rpath.
11961: + if test -n "$hardcode_libdir_separator" &&
11962: + test -n "$hardcode_libdirs"; then
11963: + libdir=$hardcode_libdirs
11964: + eval rpath=\" $hardcode_libdir_flag_spec\"
11965: + fi
11966: + finalize_rpath=$rpath
11967: +
11968: + if test -n "$libobjs" && test yes = "$build_old_libs"; then
11969: + # Transform all the library objects into standard objects.
11970: + compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
11971: + finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
11972: + fi
11973: +
11974: + func_generate_dlsyms "$outputname" "@PROGRAM@" false
11975: +
11976: + # template prelinking step
11977: + if test -n "$prelink_cmds"; then
11978: + func_execute_cmds "$prelink_cmds" 'exit $?'
11979: + fi
11980: +
11981: + wrappers_required=:
11982: + case $host in
11983: + *cegcc* | *mingw32ce*)
11984: + # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
11985: + wrappers_required=false
11986: + ;;
11987: + *cygwin* | *mingw* )
11988: + test yes = "$build_libtool_libs" || wrappers_required=false
11989: + ;;
11990: + *)
11991: + if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
11992: + wrappers_required=false
11993: + fi
11994: + ;;
11995: + esac
11996: + $wrappers_required || {
11997: + # Replace the output file specification.
11998: + compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
11999: + link_command=$compile_command$compile_rpath
12000: +
12001: + # We have no uninstalled library dependencies, so finalize right now.
12002: + exit_status=0
12003: + func_show_eval "$link_command" 'exit_status=$?'
12004: +
12005: + if test -n "$postlink_cmds"; then
12006: + func_to_tool_file "$output"
12007: + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
12008: + func_execute_cmds "$postlink_cmds" 'exit $?'
12009: + fi
12010: +
12011: + # Delete the generated files.
12012: + if test -f "$output_objdir/${outputname}S.$objext"; then
12013: + func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
12014: + fi
12015: +
12016: + exit $exit_status
12017: + }
12018: +
12019: + if test -n "$compile_shlibpath$finalize_shlibpath"; then
12020: + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
12021: + fi
12022: + if test -n "$finalize_shlibpath"; then
12023: + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
12024: + fi
12025: +
12026: + compile_var=
12027: + finalize_var=
12028: + if test -n "$runpath_var"; then
12029: + if test -n "$perm_rpath"; then
12030: + # We should set the runpath_var.
12031: + rpath=
12032: + for dir in $perm_rpath; do
12033: + func_append rpath "$dir:"
12034: + done
12035: + compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
12036: + fi
12037: + if test -n "$finalize_perm_rpath"; then
12038: + # We should set the runpath_var.
12039: + rpath=
12040: + for dir in $finalize_perm_rpath; do
12041: + func_append rpath "$dir:"
12042: + done
12043: + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
12044: + fi
12045: + fi
12046: +
12047: + if test yes = "$no_install"; then
12048: + # We don't need to create a wrapper script.
12049: + link_command=$compile_var$compile_command$compile_rpath
12050: + # Replace the output file specification.
12051: + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
12052: + # Delete the old output file.
12053: + $opt_dry_run || $RM $output
12054: + # Link the executable and exit
12055: + func_show_eval "$link_command" 'exit $?'
12056: +
12057: + if test -n "$postlink_cmds"; then
12058: + func_to_tool_file "$output"
12059: + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
12060: + func_execute_cmds "$postlink_cmds" 'exit $?'
12061: + fi
12062: +
12063: + exit $EXIT_SUCCESS
12064: + fi
12065: +
12066: + case $hardcode_action,$fast_install in
12067: + relink,*)
12068: + # Fast installation is not supported
12069: + link_command=$compile_var$compile_command$compile_rpath
12070: + relink_command=$finalize_var$finalize_command$finalize_rpath
12071: +
12072: + func_warning "this platform does not like uninstalled shared libraries"
12073: + func_warning "'$output' will be relinked during installation"
12074: + ;;
12075: + *,yes)
12076: + link_command=$finalize_var$compile_command$finalize_rpath
12077: + relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
12078: + ;;
12079: + *,no)
12080: + link_command=$compile_var$compile_command$compile_rpath
12081: + relink_command=$finalize_var$finalize_command$finalize_rpath
12082: + ;;
12083: + *,needless)
12084: + link_command=$finalize_var$compile_command$finalize_rpath
12085: + relink_command=
12086: + ;;
12087: + esac
12088: +
12089: + # Replace the output file specification.
12090: + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
12091: +
12092: + # Delete the old output files.
12093: + $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
12094: +
12095: + func_show_eval "$link_command" 'exit $?'
12096: +
12097: + if test -n "$postlink_cmds"; then
12098: + func_to_tool_file "$output_objdir/$outputname"
12099: + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
12100: + func_execute_cmds "$postlink_cmds" 'exit $?'
12101: + fi
12102: +
12103: + # Now create the wrapper script.
12104: + func_verbose "creating $output"
12105: +
12106: + # Quote the relink command for shipping.
12107: + if test -n "$relink_command"; then
12108: + # Preserve any variables that may affect compiler behavior
12109: + for var in $variables_saved_for_relink; do
12110: + if eval test -z \"\${$var+set}\"; then
12111: + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
12112: + elif eval var_value=\$$var; test -z "$var_value"; then
12113: + relink_command="$var=; export $var; $relink_command"
12114: + else
12115: + func_quote_for_eval "$var_value"
12116: + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
12117: + fi
12118: + done
12119: + relink_command="(cd `pwd`; $relink_command)"
12120: + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
12121: + fi
12122: +
12123: + # Only actually do things if not in dry run mode.
12124: + $opt_dry_run || {
12125: + # win32 will think the script is a binary if it has
12126: + # a .exe suffix, so we strip it off here.
12127: + case $output in
12128: + *.exe) func_stripname '' '.exe' "$output"
12129: + output=$func_stripname_result ;;
12130: + esac
12131: + # test for cygwin because mv fails w/o .exe extensions
12132: + case $host in
12133: + *cygwin*)
12134: + exeext=.exe
12135: + func_stripname '' '.exe' "$outputname"
12136: + outputname=$func_stripname_result ;;
12137: + *) exeext= ;;
12138: + esac
12139: + case $host in
12140: + *cygwin* | *mingw* )
12141: + func_dirname_and_basename "$output" "" "."
12142: + output_name=$func_basename_result
12143: + output_path=$func_dirname_result
12144: + cwrappersource=$output_path/$objdir/lt-$output_name.c
12145: + cwrapper=$output_path/$output_name.exe
12146: + $RM $cwrappersource $cwrapper
12147: + trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
12148: +
12149: + func_emit_cwrapperexe_src > $cwrappersource
12150: +
12151: + # The wrapper executable is built using the $host compiler,
12152: + # because it contains $host paths and files. If cross-
12153: + # compiling, it, like the target executable, must be
12154: + # executed on the $host or under an emulation environment.
12155: + $opt_dry_run || {
12156: + $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
12157: + $STRIP $cwrapper
12158: + }
12159: +
12160: + # Now, create the wrapper script for func_source use:
12161: + func_ltwrapper_scriptname $cwrapper
12162: + $RM $func_ltwrapper_scriptname_result
12163: + trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
12164: + $opt_dry_run || {
12165: + # note: this script will not be executed, so do not chmod.
12166: + if test "x$build" = "x$host"; then
12167: + $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
12168: + else
12169: + func_emit_wrapper no > $func_ltwrapper_scriptname_result
12170: + fi
12171: + }
12172: + ;;
12173: + * )
12174: + $RM $output
12175: + trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
12176: +
12177: + func_emit_wrapper no > $output
12178: + chmod +x $output
12179: + ;;
12180: + esac
12181: + }
12182: + exit $EXIT_SUCCESS
12183: + ;;
12184: + esac
12185: +
12186: + # See if we need to build an old-fashioned archive.
12187: + for oldlib in $oldlibs; do
12188: +
12189: + case $build_libtool_libs in
12190: + convenience)
12191: + oldobjs="$libobjs_save $symfileobj"
12192: + addlibs=$convenience
12193: + build_libtool_libs=no
12194: + ;;
12195: + module)
12196: + oldobjs=$libobjs_save
12197: + addlibs=$old_convenience
12198: + build_libtool_libs=no
12199: + ;;
12200: + *)
12201: + oldobjs="$old_deplibs $non_pic_objects"
12202: + $preload && test -f "$symfileobj" \
12203: + && func_append oldobjs " $symfileobj"
12204: + addlibs=$old_convenience
12205: + ;;
12206: + esac
12207: +
12208: + if test -n "$addlibs"; then
12209: + gentop=$output_objdir/${outputname}x
12210: + func_append generated " $gentop"
12211: +
12212: + func_extract_archives $gentop $addlibs
12213: + func_append oldobjs " $func_extract_archives_result"
12214: + fi
12215: +
12216: + # Do each command in the archive commands.
12217: + if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
12218: + cmds=$old_archive_from_new_cmds
12219: + else
12220: +
12221: + # Add any objects from preloaded convenience libraries
12222: + if test -n "$dlprefiles"; then
12223: + gentop=$output_objdir/${outputname}x
12224: + func_append generated " $gentop"
12225: +
12226: + func_extract_archives $gentop $dlprefiles
12227: + func_append oldobjs " $func_extract_archives_result"
12228: + fi
12229: +
12230: + # POSIX demands no paths to be encoded in archives. We have
12231: + # to avoid creating archives with duplicate basenames if we
12232: + # might have to extract them afterwards, e.g., when creating a
12233: + # static archive out of a convenience library, or when linking
12234: + # the entirety of a libtool archive into another (currently
12235: + # not supported by libtool).
12236: + if (for obj in $oldobjs
12237: + do
12238: + func_basename "$obj"
12239: + $ECHO "$func_basename_result"
12240: + done | sort | sort -uc >/dev/null 2>&1); then
12241: + :
12242: + else
12243: + echo "copying selected object files to avoid basename conflicts..."
12244: + gentop=$output_objdir/${outputname}x
12245: + func_append generated " $gentop"
12246: + func_mkdir_p "$gentop"
12247: + save_oldobjs=$oldobjs
12248: + oldobjs=
12249: + counter=1
12250: + for obj in $save_oldobjs
12251: + do
12252: + func_basename "$obj"
12253: + objbase=$func_basename_result
12254: + case " $oldobjs " in
12255: + " ") oldobjs=$obj ;;
12256: + *[\ /]"$objbase "*)
12257: + while :; do
12258: + # Make sure we don't pick an alternate name that also
12259: + # overlaps.
12260: + newobj=lt$counter-$objbase
12261: + func_arith $counter + 1
12262: + counter=$func_arith_result
12263: + case " $oldobjs " in
12264: + *[\ /]"$newobj "*) ;;
12265: + *) if test ! -f "$gentop/$newobj"; then break; fi ;;
12266: + esac
12267: + done
12268: + func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
12269: + func_append oldobjs " $gentop/$newobj"
12270: + ;;
12271: + *) func_append oldobjs " $obj" ;;
12272: + esac
12273: + done
12274: + fi
12275: + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
12276: + tool_oldlib=$func_to_tool_file_result
12277: + eval cmds=\"$old_archive_cmds\"
12278: +
12279: + func_len " $cmds"
12280: + len=$func_len_result
12281: + if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
12282: + cmds=$old_archive_cmds
12283: + elif test -n "$archiver_list_spec"; then
12284: + func_verbose "using command file archive linking..."
12285: + for obj in $oldobjs
12286: + do
12287: + func_to_tool_file "$obj"
12288: + $ECHO "$func_to_tool_file_result"
12289: + done > $output_objdir/$libname.libcmd
12290: + func_to_tool_file "$output_objdir/$libname.libcmd"
12291: + oldobjs=" $archiver_list_spec$func_to_tool_file_result"
12292: + cmds=$old_archive_cmds
12293: + else
12294: + # the command line is too long to link in one step, link in parts
12295: + func_verbose "using piecewise archive linking..."
12296: + save_RANLIB=$RANLIB
12297: + RANLIB=:
12298: + objlist=
12299: + concat_cmds=
12300: + save_oldobjs=$oldobjs
12301: + oldobjs=
12302: + # Is there a better way of finding the last object in the list?
12303: + for obj in $save_oldobjs
12304: + do
12305: + last_oldobj=$obj
12306: + done
12307: + eval test_cmds=\"$old_archive_cmds\"
12308: + func_len " $test_cmds"
12309: + len0=$func_len_result
12310: + len=$len0
12311: + for obj in $save_oldobjs
12312: + do
12313: + func_len " $obj"
12314: + func_arith $len + $func_len_result
12315: + len=$func_arith_result
12316: + func_append objlist " $obj"
12317: + if test "$len" -lt "$max_cmd_len"; then
12318: + :
12319: + else
12320: + # the above command should be used before it gets too long
12321: + oldobjs=$objlist
12322: + if test "$obj" = "$last_oldobj"; then
12323: + RANLIB=$save_RANLIB
12324: + fi
12325: + test -z "$concat_cmds" || concat_cmds=$concat_cmds~
12326: + eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
12327: + objlist=
12328: + len=$len0
12329: + fi
12330: + done
12331: + RANLIB=$save_RANLIB
12332: + oldobjs=$objlist
12333: + if test -z "$oldobjs"; then
12334: + eval cmds=\"\$concat_cmds\"
12335: + else
12336: + eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
12337: + fi
12338: + fi
12339: + fi
12340: + func_execute_cmds "$cmds" 'exit $?'
12341: + done
12342: +
12343: + test -n "$generated" && \
12344: + func_show_eval "${RM}r$generated"
12345: +
12346: + # Now create the libtool archive.
12347: + case $output in
12348: + *.la)
12349: + old_library=
12350: + test yes = "$build_old_libs" && old_library=$libname.$libext
12351: + func_verbose "creating $output"
12352: +
12353: + # Preserve any variables that may affect compiler behavior
12354: + for var in $variables_saved_for_relink; do
12355: + if eval test -z \"\${$var+set}\"; then
12356: + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
12357: + elif eval var_value=\$$var; test -z "$var_value"; then
12358: + relink_command="$var=; export $var; $relink_command"
12359: + else
12360: + func_quote_for_eval "$var_value"
12361: + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
12362: + fi
12363: + done
12364: + # Quote the link command for shipping.
12365: + relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
12366: + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
12367: + if test yes = "$hardcode_automatic"; then
12368: + relink_command=
12369: + fi
12370: +
12371: + # Only create the output if not a dry run.
12372: + $opt_dry_run || {
12373: + for installed in no yes; do
12374: + if test yes = "$installed"; then
12375: + if test -z "$install_libdir"; then
12376: + break
12377: + fi
12378: + output=$output_objdir/${outputname}i
12379: + # Replace all uninstalled libtool libraries with the installed ones
12380: + newdependency_libs=
12381: + for deplib in $dependency_libs; do
12382: + case $deplib in
12383: + *.la)
12384: + func_basename "$deplib"
12385: + name=$func_basename_result
12386: + func_resolve_sysroot "$deplib"
12387: + eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
12388: + test -z "$libdir" && \
12389: + func_fatal_error "'$deplib' is not a valid libtool archive"
12390: + func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
12391: + ;;
12392: + -L*)
12393: + func_stripname -L '' "$deplib"
12394: + func_replace_sysroot "$func_stripname_result"
12395: + func_append newdependency_libs " -L$func_replace_sysroot_result"
12396: + ;;
12397: + -R*)
12398: + func_stripname -R '' "$deplib"
12399: + func_replace_sysroot "$func_stripname_result"
12400: + func_append newdependency_libs " -R$func_replace_sysroot_result"
12401: + ;;
12402: + *) func_append newdependency_libs " $deplib" ;;
12403: + esac
12404: + done
12405: + dependency_libs=$newdependency_libs
12406: + newdlfiles=
12407: +
12408: + for lib in $dlfiles; do
12409: + case $lib in
12410: + *.la)
12411: + func_basename "$lib"
12412: + name=$func_basename_result
12413: + eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
12414: + test -z "$libdir" && \
12415: + func_fatal_error "'$lib' is not a valid libtool archive"
12416: + func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
12417: + ;;
12418: + *) func_append newdlfiles " $lib" ;;
12419: + esac
12420: + done
12421: + dlfiles=$newdlfiles
12422: + newdlprefiles=
12423: + for lib in $dlprefiles; do
12424: + case $lib in
12425: + *.la)
12426: + # Only pass preopened files to the pseudo-archive (for
12427: + # eventual linking with the app. that links it) if we
12428: + # didn't already link the preopened objects directly into
12429: + # the library:
12430: + func_basename "$lib"
12431: + name=$func_basename_result
12432: + eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
12433: + test -z "$libdir" && \
12434: + func_fatal_error "'$lib' is not a valid libtool archive"
12435: + func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
12436: + ;;
12437: + esac
12438: + done
12439: + dlprefiles=$newdlprefiles
12440: + else
12441: + newdlfiles=
12442: + for lib in $dlfiles; do
12443: + case $lib in
12444: + [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
12445: + *) abs=`pwd`"/$lib" ;;
12446: + esac
12447: + func_append newdlfiles " $abs"
12448: + done
12449: + dlfiles=$newdlfiles
12450: + newdlprefiles=
12451: + for lib in $dlprefiles; do
12452: + case $lib in
12453: + [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
12454: + *) abs=`pwd`"/$lib" ;;
12455: + esac
12456: + func_append newdlprefiles " $abs"
12457: + done
12458: + dlprefiles=$newdlprefiles
12459: + fi
12460: + $RM $output
12461: + # place dlname in correct position for cygwin
12462: + # In fact, it would be nice if we could use this code for all target
12463: + # systems that can't hard-code library paths into their executables
12464: + # and that have no shared library path variable independent of PATH,
12465: + # but it turns out we can't easily determine that from inspecting
12466: + # libtool variables, so we have to hard-code the OSs to which it
12467: + # applies here; at the moment, that means platforms that use the PE
12468: + # object format with DLL files. See the long comment at the top of
12469: + # tests/bindir.at for full details.
12470: + tdlname=$dlname
12471: + case $host,$output,$installed,$module,$dlname in
12472: + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
12473: + # If a -bindir argument was supplied, place the dll there.
12474: + if test -n "$bindir"; then
12475: + func_relative_path "$install_libdir" "$bindir"
12476: + tdlname=$func_relative_path_result/$dlname
12477: + else
12478: + # Otherwise fall back on heuristic.
12479: + tdlname=../bin/$dlname
12480: + fi
12481: + ;;
12482: + esac
12483: + $ECHO > $output "\
12484: +# $outputname - a libtool library file
12485: +# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
12486: +#
12487: +# Please DO NOT delete this file!
12488: +# It is necessary for linking the library.
12489: +
12490: +# The name that we can dlopen(3).
12491: +dlname='$tdlname'
12492: +
12493: +# Names of this library.
12494: +library_names='$library_names'
12495: +
12496: +# The name of the static archive.
12497: +old_library='$old_library'
12498: +
12499: +# Linker flags that cannot go in dependency_libs.
12500: +inherited_linker_flags='$new_inherited_linker_flags'
12501: +
12502: +# Libraries that this one depends upon.
12503: +dependency_libs='$dependency_libs'
12504: +
12505: +# Names of additional weak libraries provided by this library
12506: +weak_library_names='$weak_libs'
12507: +
12508: +# Version information for $libname.
12509: +current=$current
12510: +age=$age
12511: +revision=$revision
12512: +
12513: +# Is this an already installed library?
12514: +installed=$installed
12515: +
12516: +# Should we warn about portability when linking against -modules?
12517: +shouldnotlink=$module
12518: +
12519: +# Files to dlopen/dlpreopen
12520: +dlopen='$dlfiles'
12521: +dlpreopen='$dlprefiles'
12522: +
12523: +# Directory that this library needs to be installed in:
12524: +libdir='$install_libdir'"
12525: + if test no,yes = "$installed,$need_relink"; then
12526: + $ECHO >> $output "\
12527: +relink_command=\"$relink_command\""
12528: + fi
12529: + done
12530: + }
12531: +
12532: + # Do a symbolic link so that the libtool archive can be found in
12533: + # LD_LIBRARY_PATH before the program is installed.
12534: + func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
12535: + ;;
12536: + esac
12537: + exit $EXIT_SUCCESS
12538: +}
12539: +
12540: +if test link = "$opt_mode" || test relink = "$opt_mode"; then
12541: + func_mode_link ${1+"$@"}
12542: +fi
12543: +
12544: +
12545: +# func_mode_uninstall arg...
12546: +func_mode_uninstall ()
12547: +{
12548: + $debug_cmd
12549: +
12550: + RM=$nonopt
12551: + files=
12552: + rmforce=false
12553: + exit_status=0
12554: +
12555: + # This variable tells wrapper scripts just to set variables rather
12556: + # than running their programs.
12557: + libtool_install_magic=$magic
12558: +
12559: + for arg
12560: + do
12561: + case $arg in
12562: + -f) func_append RM " $arg"; rmforce=: ;;
12563: + -*) func_append RM " $arg" ;;
12564: + *) func_append files " $arg" ;;
12565: + esac
12566: + done
12567: +
12568: + test -z "$RM" && \
12569: + func_fatal_help "you must specify an RM program"
12570: +
12571: + rmdirs=
12572: +
12573: + for file in $files; do
12574: + func_dirname "$file" "" "."
12575: + dir=$func_dirname_result
12576: + if test . = "$dir"; then
12577: + odir=$objdir
12578: + else
12579: + odir=$dir/$objdir
12580: + fi
12581: + func_basename "$file"
12582: + name=$func_basename_result
12583: + test uninstall = "$opt_mode" && odir=$dir
12584: +
12585: + # Remember odir for removal later, being careful to avoid duplicates
12586: + if test clean = "$opt_mode"; then
12587: + case " $rmdirs " in
12588: + *" $odir "*) ;;
12589: + *) func_append rmdirs " $odir" ;;
12590: + esac
12591: + fi
12592: +
12593: + # Don't error if the file doesn't exist and rm -f was used.
12594: + if { test -L "$file"; } >/dev/null 2>&1 ||
12595: + { test -h "$file"; } >/dev/null 2>&1 ||
12596: + test -f "$file"; then
12597: + :
12598: + elif test -d "$file"; then
12599: + exit_status=1
12600: + continue
12601: + elif $rmforce; then
12602: + continue
12603: + fi
12604: +
12605: + rmfiles=$file
12606: +
12607: + case $name in
12608: + *.la)
12609: + # Possibly a libtool archive, so verify it.
12610: + if func_lalib_p "$file"; then
12611: + func_source $dir/$name
12612: +
12613: + # Delete the libtool libraries and symlinks.
12614: + for n in $library_names; do
12615: + func_append rmfiles " $odir/$n"
12616: + done
12617: + test -n "$old_library" && func_append rmfiles " $odir/$old_library"
12618: +
12619: + case $opt_mode in
12620: + clean)
12621: + case " $library_names " in
12622: + *" $dlname "*) ;;
12623: + *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
12624: + esac
12625: + test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
12626: + ;;
12627: + uninstall)
12628: + if test -n "$library_names"; then
12629: + # Do each command in the postuninstall commands.
12630: + func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
12631: + fi
12632: +
12633: + if test -n "$old_library"; then
12634: + # Do each command in the old_postuninstall commands.
12635: + func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
12636: + fi
12637: + # FIXME: should reinstall the best remaining shared library.
12638: + ;;
12639: + esac
12640: + fi
12641: + ;;
12642: +
12643: + *.lo)
12644: + # Possibly a libtool object, so verify it.
12645: + if func_lalib_p "$file"; then
12646: +
12647: + # Read the .lo file
12648: + func_source $dir/$name
12649: +
12650: + # Add PIC object to the list of files to remove.
12651: + if test -n "$pic_object" && test none != "$pic_object"; then
12652: + func_append rmfiles " $dir/$pic_object"
12653: + fi
12654: +
12655: + # Add non-PIC object to the list of files to remove.
12656: + if test -n "$non_pic_object" && test none != "$non_pic_object"; then
12657: + func_append rmfiles " $dir/$non_pic_object"
12658: + fi
12659: + fi
12660: + ;;
12661: +
12662: + *)
12663: + if test clean = "$opt_mode"; then
12664: + noexename=$name
12665: + case $file in
12666: + *.exe)
12667: + func_stripname '' '.exe' "$file"
12668: + file=$func_stripname_result
12669: + func_stripname '' '.exe' "$name"
12670: + noexename=$func_stripname_result
12671: + # $file with .exe has already been added to rmfiles,
12672: + # add $file without .exe
12673: + func_append rmfiles " $file"
12674: + ;;
12675: + esac
12676: + # Do a test to see if this is a libtool program.
12677: + if func_ltwrapper_p "$file"; then
12678: + if func_ltwrapper_executable_p "$file"; then
12679: + func_ltwrapper_scriptname "$file"
12680: + relink_command=
12681: + func_source $func_ltwrapper_scriptname_result
12682: + func_append rmfiles " $func_ltwrapper_scriptname_result"
12683: + else
12684: + relink_command=
12685: + func_source $dir/$noexename
12686: + fi
12687: +
12688: + # note $name still contains .exe if it was in $file originally
12689: + # as does the version of $file that was added into $rmfiles
12690: + func_append rmfiles " $odir/$name $odir/${name}S.$objext"
12691: + if test yes = "$fast_install" && test -n "$relink_command"; then
12692: + func_append rmfiles " $odir/lt-$name"
12693: + fi
12694: + if test "X$noexename" != "X$name"; then
12695: + func_append rmfiles " $odir/lt-$noexename.c"
12696: + fi
12697: + fi
12698: + fi
12699: + ;;
12700: + esac
12701: + func_show_eval "$RM $rmfiles" 'exit_status=1'
12702: + done
12703: +
12704: + # Try to remove the $objdir's in the directories where we deleted files
12705: + for dir in $rmdirs; do
12706: + if test -d "$dir"; then
12707: + func_show_eval "rmdir $dir >/dev/null 2>&1"
12708: + fi
12709: + done
12710: +
12711: + exit $exit_status
12712: +}
12713: +
12714: +if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
12715: + func_mode_uninstall ${1+"$@"}
12716: +fi
12717: +
12718: +test -z "$opt_mode" && {
12719: + help=$generic_help
12720: + func_fatal_help "you must specify a MODE"
12721: +}
12722: +
12723: +test -z "$exec_cmd" && \
12724: + func_fatal_help "invalid operation mode '$opt_mode'"
12725: +
12726: +if test -n "$exec_cmd"; then
12727: + eval exec "$exec_cmd"
12728: + exit $EXIT_FAILURE
12729: +fi
12730: +
12731: +exit $exit_status
12732: +
12733: +
12734: +# The TAGs below are defined such that we never get into a situation
12735: +# where we disable both kinds of libraries. Given conflicting
12736: +# choices, we go for a static library, that is the most portable,
12737: +# since we can't tell whether shared libraries were disabled because
12738: +# the user asked for that or because the platform doesn't support
12739: +# them. This is particularly important on AIX, because we don't
12740: +# support having both static and shared libraries enabled at the same
12741: +# time on that platform, so we default to a shared-only configuration.
12742: +# If a disable-shared tag is given, we'll fallback to a static-only
12743: +# configuration. But we'll never go from static-only to shared-only.
12744: +
12745: +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
12746: +build_libtool_libs=no
12747: +build_old_libs=yes
12748: +# ### END LIBTOOL TAG CONFIG: disable-shared
12749: +
12750: +# ### BEGIN LIBTOOL TAG CONFIG: disable-static
12751: +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
12752: +# ### END LIBTOOL TAG CONFIG: disable-static
12753: +
12754: +# Local Variables:
12755: +# mode:shell-script
12756: +# sh-indentation:2
12757: +# End:
12758: diff --git a/m4/require_liblac.m4 b/m4/require_liblac.m4
12759: new file mode 100644
12760: index 0000000..252cd37
12761: --- /dev/null
12762: +++ b/m4/require_liblac.m4
12763: @@ -0,0 +1,12 @@
12764: +# liblac.m4 serial 1
12765: +dnl Copyright (C) 2017 Gianluca Guida.
12766: +dnl This file is free software; the author gives unlimited
12767: +dnl permission to copy and/or distribute it, with or without
12768: +dnl modifications, as long as this notice is preserved.
12769: +
12770: +AC_DEFUN([REQUIRE_LIBLAC],
12771: +[
12772: + AC_LIB_HAVE_LINKFLAGS([lac], [],
12773: + [#include <lac.h>], [lac_init();],
12774: + AC_MSG_ERROR([requires liblac]))
12775: +])
12776: diff --git a/m4/std-gnu11.m4 b/m4/std-gnu11.m4
12777: new file mode 100644
12778: index 0000000..9dae9b1
12779: --- /dev/null
12780: +++ b/m4/std-gnu11.m4
12781: @@ -0,0 +1,824 @@
12782: +# Prefer GNU C11 and C++11 to earlier versions. -*- coding: utf-8 -*-
12783: +
12784: +# This implementation is taken from GNU Autoconf lib/autoconf/c.m4
12785: +# commit 017d5ddd82854911f0119691d91ea8a1438824d6
12786: +# dated Sun Apr 3 13:57:17 2016 -0700
12787: +# This implementation will be obsolete once we can assume Autoconf 2.70
12788: +# or later is installed everywhere a Gnulib program might be developed.
12789: +
12790: +
12791: +# Copyright (C) 2001-2017 Free Software Foundation, Inc.
12792: +
12793: +# This program is free software; you can redistribute it and/or modify
12794: +# it under the terms of the GNU General Public License as published by
12795: +# the Free Software Foundation, either version 3 of the License, or
12796: +# (at your option) any later version.
12797: +#
12798: +# This program is distributed in the hope that it will be useful,
12799: +# but WITHOUT ANY WARRANTY; without even the implied warranty of
12800: +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12801: +# GNU General Public License for more details.
12802: +#
12803: +# You should have received a copy of the GNU General Public License
12804: +# along with this program. If not, see <http://www.gnu.org/licenses/>.
12805: +
12806: +# Written by David MacKenzie, with help from
12807: +# Akim Demaille, Paul Eggert,
12808: +# François Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
12809: +# Roland McGrath, Noah Friedman, david d zuhn, and many others.
12810: +
12811: +
12812: +# AC_PROG_CC([COMPILER ...])
12813: +# --------------------------
12814: +# COMPILER ... is a space separated list of C compilers to search for.
12815: +# This just gives the user an opportunity to specify an alternative
12816: +# search list for the C compiler.
12817: +AC_DEFUN_ONCE([AC_PROG_CC],
12818: +[AC_LANG_PUSH(C)dnl
12819: +AC_ARG_VAR([CC], [C compiler command])dnl
12820: +AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
12821: +_AC_ARG_VAR_LDFLAGS()dnl
12822: +_AC_ARG_VAR_LIBS()dnl
12823: +_AC_ARG_VAR_CPPFLAGS()dnl
12824: +m4_ifval([$1],
12825: + [AC_CHECK_TOOLS(CC, [$1])],
12826: +[AC_CHECK_TOOL(CC, gcc)
12827: +if test -z "$CC"; then
12828: + dnl Here we want:
12829: + dnl AC_CHECK_TOOL(CC, cc)
12830: + dnl but without the check for a tool without the prefix.
12831: + dnl Until the check is removed from there, copy the code:
12832: + if test -n "$ac_tool_prefix"; then
12833: + AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
12834: + fi
12835: +fi
12836: +if test -z "$CC"; then
12837: + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
12838: +fi
12839: +if test -z "$CC"; then
12840: + AC_CHECK_TOOLS(CC, cl.exe)
12841: +fi
12842: +if test -z "$CC"; then
12843: + AC_CHECK_TOOL(CC, clang)
12844: +fi
12845: +])
12846: +
12847: +test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
12848: +
12849: +# Provide some information about the compiler.
12850: +_AS_ECHO_LOG([checking for _AC_LANG compiler version])
12851: +set X $ac_compile
12852: +ac_compiler=$[2]
12853: +for ac_option in --version -v -V -qversion -version; do
12854: + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
12855: +done
12856: +
12857: +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
12858: +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
12859: +_AC_LANG_COMPILER_GNU
12860: +if test $ac_compiler_gnu = yes; then
12861: + GCC=yes
12862: +else
12863: + GCC=
12864: +fi
12865: +_AC_PROG_CC_G
12866: +dnl
12867: +dnl Set ac_prog_cc_stdc to the supported C version.
12868: +dnl Also set the documented variable ac_cv_prog_cc_stdc;
12869: +dnl its name was chosen when it was cached, but it is no longer cached.
12870: +_AC_PROG_CC_C11([ac_prog_cc_stdc=c11
12871: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11],
12872: + [_AC_PROG_CC_C99([ac_prog_cc_stdc=c99
12873: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
12874: + [_AC_PROG_CC_C89([ac_prog_cc_stdc=c89
12875: + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
12876: + [ac_prog_cc_stdc=no
12877: + ac_cv_prog_cc_stdc=no])])])
12878: +dnl
12879: +AC_LANG_POP(C)dnl
12880: +])# AC_PROG_CC
12881: +
12882: +
12883: +
12884: +# AC_PROG_CXX([LIST-OF-COMPILERS])
12885: +# --------------------------------
12886: +# LIST-OF-COMPILERS is a space separated list of C++ compilers to search
12887: +# for (if not specified, a default list is used). This just gives the
12888: +# user an opportunity to specify an alternative search list for the C++
12889: +# compiler.
12890: +# aCC HP-UX C++ compiler much better than `CC', so test before.
12891: +# FCC Fujitsu C++ compiler
12892: +# KCC KAI C++ compiler
12893: +# RCC Rational C++
12894: +# xlC_r AIX C Set++ (with support for reentrant code)
12895: +# xlC AIX C Set++
12896: +AC_DEFUN([AC_PROG_CXX],
12897: +[AC_LANG_PUSH(C++)dnl
12898: +AC_ARG_VAR([CXX], [C++ compiler command])dnl
12899: +AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
12900: +_AC_ARG_VAR_LDFLAGS()dnl
12901: +_AC_ARG_VAR_LIBS()dnl
12902: +_AC_ARG_VAR_CPPFLAGS()dnl
12903: +_AC_ARG_VAR_PRECIOUS([CCC])dnl
12904: +if test -z "$CXX"; then
12905: + if test -n "$CCC"; then
12906: + CXX=$CCC
12907: + else
12908: + AC_CHECK_TOOLS(CXX,
12909: + [m4_default([$1],
12910: + [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++])],
12911: + g++)
12912: + fi
12913: +fi
12914: +# Provide some information about the compiler.
12915: +_AS_ECHO_LOG([checking for _AC_LANG compiler version])
12916: +set X $ac_compile
12917: +ac_compiler=$[2]
12918: +for ac_option in --version -v -V -qversion; do
12919: + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
12920: +done
12921: +
12922: +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
12923: +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
12924: +_AC_LANG_COMPILER_GNU
12925: +if test $ac_compiler_gnu = yes; then
12926: + GXX=yes
12927: +else
12928: + GXX=
12929: +fi
12930: +_AC_PROG_CXX_G
12931: +_AC_PROG_CXX_CXX11([ac_prog_cxx_stdcxx=cxx11
12932: + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
12933: + ac_cv_prog_cxx_cxx98=$ac_cv_prog_cxx_cxx11],
12934: + [_AC_PROG_CXX_CXX98([ac_prog_cxx_stdcxx=cxx98
12935: + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98],
12936: + [ac_prog_cxx_stdcxx=no
12937: + ac_cv_prog_cxx_stdcxx=no])])
12938: +AC_LANG_POP(C++)dnl
12939: +])# AC_PROG_CXX
12940: +
12941: +
12942: +# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
12943: +# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
12944: +# --------------------------------------------------------------
12945: +# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
12946: +# by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails,
12947: +# try again with each compiler option in the space-separated OPTION-LIST; if one
12948: +# helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE,
12949: +# else ACTION-IF-UNAVAILABLE.
12950: +AC_DEFUN([_AC_C_STD_TRY],
12951: +[AC_MSG_CHECKING([for $CC option to enable ]m4_translit($1, [c], [C])[ features])
12952: +AC_CACHE_VAL(ac_cv_prog_cc_$1,
12953: +[ac_cv_prog_cc_$1=no
12954: +ac_save_CC=$CC
12955: +AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
12956: +for ac_arg in '' $4
12957: +do
12958: + CC="$ac_save_CC $ac_arg"
12959: + _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
12960: + test "x$ac_cv_prog_cc_$1" != "xno" && break
12961: +done
12962: +rm -f conftest.$ac_ext
12963: +CC=$ac_save_CC
12964: +])# AC_CACHE_VAL
12965: +ac_prog_cc_stdc_options=
12966: +case "x$ac_cv_prog_cc_$1" in
12967: + x)
12968: + AC_MSG_RESULT([none needed]) ;;
12969: + xno)
12970: + AC_MSG_RESULT([unsupported]) ;;
12971: + *)
12972: + ac_prog_cc_stdc_options=" $ac_cv_prog_cc_$1"
12973: + CC=$CC$ac_prog_cc_stdc_options
12974: + AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
12975: +esac
12976: +AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
12977: +])# _AC_C_STD_TRY
12978: +
12979: +# _AC_C_C99_TEST_HEADER
12980: +# ---------------------
12981: +# A C header suitable for testing for C99.
12982: +AC_DEFUN([_AC_C_C99_TEST_HEADER],
12983: +[[#include <stdarg.h>
12984: +#include <stdbool.h>
12985: +#include <stddef.h>
12986: +#include <stdlib.h>
12987: +#include <wchar.h>
12988: +#include <stdio.h>
12989: +
12990: +// Check varargs macros. These examples are taken from C99 6.10.3.5.
12991: +#define debug(...) fprintf (stderr, __VA_ARGS__)
12992: +#define showlist(...) puts (#__VA_ARGS__)
12993: +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
12994: +static void
12995: +test_varargs_macros (void)
12996: +{
12997: + int x = 1234;
12998: + int y = 5678;
12999: + debug ("Flag");
13000: + debug ("X = %d\n", x);
13001: + showlist (The first, second, and third items.);
13002: + report (x>y, "x is %d but y is %d", x, y);
13003: +}
13004: +
13005: +// Check long long types.
13006: +#define BIG64 18446744073709551615ull
13007: +#define BIG32 4294967295ul
13008: +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
13009: +#if !BIG_OK
13010: + your preprocessor is broken;
13011: +#endif
13012: +#if BIG_OK
13013: +#else
13014: + your preprocessor is broken;
13015: +#endif
13016: +static long long int bignum = -9223372036854775807LL;
13017: +static unsigned long long int ubignum = BIG64;
13018: +
13019: +struct incomplete_array
13020: +{
13021: + int datasize;
13022: + double data[];
13023: +};
13024: +
13025: +struct named_init {
13026: + int number;
13027: + const wchar_t *name;
13028: + double average;
13029: +};
13030: +
13031: +typedef const char *ccp;
13032: +
13033: +static inline int
13034: +test_restrict (ccp restrict text)
13035: +{
13036: + // See if C++-style comments work.
13037: + // Iterate through items via the restricted pointer.
13038: + // Also check for declarations in for loops.
13039: + for (unsigned int i = 0; *(text+i) != '\0'; ++i)
13040: + continue;
13041: + return 0;
13042: +}
13043: +
13044: +// Check varargs and va_copy.
13045: +static bool
13046: +test_varargs (const char *format, ...)
13047: +{
13048: + va_list args;
13049: + va_start (args, format);
13050: + va_list args_copy;
13051: + va_copy (args_copy, args);
13052: +
13053: + const char *str = "";
13054: + int number = 0;
13055: + float fnumber = 0;
13056: +
13057: + while (*format)
13058: + {
13059: + switch (*format++)
13060: + {
13061: + case 's': // string
13062: + str = va_arg (args_copy, const char *);
13063: + break;
13064: + case 'd': // int
13065: + number = va_arg (args_copy, int);
13066: + break;
13067: + case 'f': // float
13068: + fnumber = va_arg (args_copy, double);
13069: + break;
13070: + default:
13071: + break;
13072: + }
13073: + }
13074: + va_end (args_copy);
13075: + va_end (args);
13076: +
13077: + return *str && number && fnumber;
13078: +}]])# _AC_C_C99_TEST_HEADER
13079: +
13080: +# _AC_C_C99_TEST_BODY
13081: +# -------------------
13082: +# A C body suitable for testing for C99, assuming the corresponding header.
13083: +AC_DEFUN([_AC_C_C99_TEST_BODY],
13084: +[[
13085: + // Check bool.
13086: + _Bool success = false;
13087: +
13088: + // Check restrict.
13089: + if (test_restrict ("String literal") == 0)
13090: + success = true;
13091: + char *restrict newvar = "Another string";
13092: +
13093: + // Check varargs.
13094: + success &= test_varargs ("s, d' f .", "string", 65, 34.234);
13095: + test_varargs_macros ();
13096: +
13097: + // Check flexible array members.
13098: + struct incomplete_array *ia =
13099: + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
13100: + ia->datasize = 10;
13101: + for (int i = 0; i < ia->datasize; ++i)
13102: + ia->data[i] = i * 1.234;
13103: +
13104: + // Check named initializers.
13105: + struct named_init ni = {
13106: + .number = 34,
13107: + .name = L"Test wide string",
13108: + .average = 543.34343,
13109: + };
13110: +
13111: + ni.number = 58;
13112: +
13113: + int dynamic_array[ni.number];
13114: + dynamic_array[ni.number - 1] = 543;
13115: +
13116: + // work around unused variable warnings
13117: + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
13118: + || dynamic_array[ni.number - 1] != 543);
13119: +]])
13120: +
13121: +# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
13122: +# ----------------------------------------------------------------
13123: +# If the C compiler is not in ISO C99 mode by default, try to add an
13124: +# option to output variable CC to make it so. This macro tries
13125: +# various options that select ISO C99 on some system or another. It
13126: +# considers the compiler to be in ISO C99 mode if it handles _Bool,
13127: +# // comments, flexible array members, inline, long long int, mixed
13128: +# code and declarations, named initialization of structs, restrict,
13129: +# va_copy, varargs macros, variable declarations in for loops and
13130: +# variable length arrays.
13131: +AC_DEFUN([_AC_PROG_CC_C99],
13132: +[_AC_C_STD_TRY([c99],
13133: +[_AC_C_C99_TEST_HEADER],
13134: +[_AC_C_C99_TEST_BODY],
13135: +dnl Try
13136: +dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
13137: +dnl IBM XL C -qlanglvl=extc1x (V12.1; does not pass C11 test)
13138: +dnl IBM XL C -qlanglvl=extc99
13139: +dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdc99)
13140: +dnl HP cc -AC99
13141: +dnl Intel ICC -std=c99, -c99 (deprecated)
13142: +dnl IRIX -c99
13143: +dnl Solaris -D_STDC_C99=
13144: +dnl cc's -xc99 option uses linker magic to define the external
13145: +dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99
13146: +dnl behavior for C library functions. This is not wanted here,
13147: +dnl because it means that a single module compiled with -xc99
13148: +dnl alters C runtime behavior for the entire program, not for
13149: +dnl just the module. Instead, define the (private) symbol
13150: +dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>.
13151: +dnl The resulting compiler passes the test case here, and that's
13152: +dnl good enough. For more, please see the thread starting at:
13153: +dnl http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
13154: +dnl Tru64 -c99
13155: +dnl with extended modes being tried first.
13156: +[[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99]], [$1], [$2])[]dnl
13157: +])# _AC_PROG_CC_C99
13158: +
13159: +
13160: +# _AC_PROG_CC_C11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
13161: +# ----------------------------------------------------------------
13162: +# If the C compiler is not in ISO C11 mode by default, try to add an
13163: +# option to output variable CC to make it so. This macro tries
13164: +# various options that select ISO C11 on some system or another. It
13165: +# considers the compiler to be in ISO C11 mode if it handles _Alignas,
13166: +# _Alignof, _Noreturn, _Static_assert, UTF-8 string literals,
13167: +# duplicate typedefs, and anonymous structures and unions.
13168: +AC_DEFUN([_AC_PROG_CC_C11],
13169: +[_AC_C_STD_TRY([c11],
13170: +[_AC_C_C99_TEST_HEADER[
13171: +// Check _Alignas.
13172: +char _Alignas (double) aligned_as_double;
13173: +char _Alignas (0) no_special_alignment;
13174: +extern char aligned_as_int;
13175: +char _Alignas (0) _Alignas (int) aligned_as_int;
13176: +
13177: +// Check _Alignof.
13178: +enum
13179: +{
13180: + int_alignment = _Alignof (int),
13181: + int_array_alignment = _Alignof (int[100]),
13182: + char_alignment = _Alignof (char)
13183: +};
13184: +_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
13185: +
13186: +// Check _Noreturn.
13187: +int _Noreturn does_not_return (void) { for (;;) continue; }
13188: +
13189: +// Check _Static_assert.
13190: +struct test_static_assert
13191: +{
13192: + int x;
13193: + _Static_assert (sizeof (int) <= sizeof (long int),
13194: + "_Static_assert does not work in struct");
13195: + long int y;
13196: +};
13197: +
13198: +// Check UTF-8 literals.
13199: +#define u8 syntax error!
13200: +char const utf8_literal[] = u8"happens to be ASCII" "another string";
13201: +
13202: +// Check duplicate typedefs.
13203: +typedef long *long_ptr;
13204: +typedef long int *long_ptr;
13205: +typedef long_ptr long_ptr;
13206: +
13207: +// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
13208: +struct anonymous
13209: +{
13210: + union {
13211: + struct { int i; int j; };
13212: + struct { int k; long int l; } w;
13213: + };
13214: + int m;
13215: +} v1;
13216: +]],
13217: +[_AC_C_C99_TEST_BODY[
13218: + v1.i = 2;
13219: + v1.w.k = 5;
13220: + _Static_assert ((offsetof (struct anonymous, i)
13221: + == offsetof (struct anonymous, w.k)),
13222: + "Anonymous union alignment botch");
13223: +]],
13224: +dnl Try
13225: +dnl GCC -std=gnu11 (unused restrictive mode: -std=c11)
13226: +dnl with extended modes being tried first.
13227: +dnl
13228: +dnl Do not try -qlanglvl=extc1x, because IBM XL C V12.1 (the latest version as
13229: +dnl of September 2012) does not pass the C11 test. For now, try extc1x when
13230: +dnl compiling the C99 test instead, since it enables _Static_assert and
13231: +dnl _Noreturn, which is a win. If -qlanglvl=extc11 or -qlanglvl=extc1x passes
13232: +dnl the C11 test in some future version of IBM XL C, we'll add it here,
13233: +dnl preferably extc11.
13234: +[[-std=gnu11]], [$1], [$2])[]dnl
13235: +])# _AC_PROG_CC_C11
13236: +
13237: +
13238: +# AC_PROG_CC_C89
13239: +# --------------
13240: +# Do not use AU_ALIAS here and in AC_PROG_CC_C99 and AC_PROG_CC_STDC,
13241: +# as that'd be incompatible with how Automake redefines AC_PROG_CC. See
13242: +# <http://lists.gnu.org/archive/html/autoconf/2012-10/msg00048.html>.
13243: +AU_DEFUN([AC_PROG_CC_C89],
13244: + [AC_REQUIRE([AC_PROG_CC])],
13245: + [$0 is obsolete; use AC_PROG_CC]
13246: +)
13247: +
13248: +# AC_PROG_CC_C99
13249: +# --------------
13250: +AU_DEFUN([AC_PROG_CC_C99],
13251: + [AC_REQUIRE([AC_PROG_CC])],
13252: + [$0 is obsolete; use AC_PROG_CC]
13253: +)
13254: +
13255: +# AC_PROG_CC_STDC
13256: +# ---------------
13257: +AU_DEFUN([AC_PROG_CC_STDC],
13258: + [AC_REQUIRE([AC_PROG_CC])],
13259: + [$0 is obsolete; use AC_PROG_CC]
13260: +)
13261: +
13262: +
13263: +# AC_C_PROTOTYPES
13264: +# ---------------
13265: +# Check if the C compiler supports prototypes, included if it needs
13266: +# options.
13267: +AC_DEFUN([AC_C_PROTOTYPES],
13268: +[AC_REQUIRE([AC_PROG_CC])dnl
13269: +if test "$ac_prog_cc_stdc" != no; then
13270: + AC_DEFINE(PROTOTYPES, 1,
13271: + [Define to 1 if the C compiler supports function prototypes.])
13272: + AC_DEFINE(__PROTOTYPES, 1,
13273: + [Define like PROTOTYPES; this can be used by system headers.])
13274: +fi
13275: +])# AC_C_PROTOTYPES
13276: +
13277: +
13278: +# _AC_CXX_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
13279: +# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
13280: +# ----------------------------------------------------------------
13281: +# Check whether the C++ compiler accepts features of STANDARD (e.g
13282: +# `cxx98', `cxx11') by trying to compile a program of TEST-PROLOGUE
13283: +# and TEST-BODY. If this fails, try again with each compiler option
13284: +# in the space-separated OPTION-LIST; if one helps, append it to CXX.
13285: +# If eventually successful, run ACTION-IF-AVAILABLE, else
13286: +# ACTION-IF-UNAVAILABLE.
13287: +AC_DEFUN([_AC_CXX_STD_TRY],
13288: +[AC_MSG_CHECKING([for $CXX option to enable ]m4_translit(m4_translit($1, [x], [+]), [a-z], [A-Z])[ features])
13289: +AC_LANG_PUSH(C++)dnl
13290: +AC_CACHE_VAL(ac_cv_prog_cxx_$1,
13291: +[ac_cv_prog_cxx_$1=no
13292: +ac_save_CXX=$CXX
13293: +AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
13294: +for ac_arg in '' $4
13295: +do
13296: + CXX="$ac_save_CXX $ac_arg"
13297: + _AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_$1=$ac_arg])
13298: + test "x$ac_cv_prog_cxx_$1" != "xno" && break
13299: +done
13300: +rm -f conftest.$ac_ext
13301: +CXX=$ac_save_CXX
13302: +])# AC_CACHE_VAL
13303: +ac_prog_cxx_stdcxx_options=
13304: +case "x$ac_cv_prog_cxx_$1" in
13305: + x)
13306: + AC_MSG_RESULT([none needed]) ;;
13307: + xno)
13308: + AC_MSG_RESULT([unsupported]) ;;
13309: + *)
13310: + ac_prog_cxx_stdcxx_options=" $ac_cv_prog_cxx_$1"
13311: + CXX=$CXX$ac_prog_cxx_stdcxx_options
13312: + AC_MSG_RESULT([$ac_cv_prog_cxx_$1]) ;;
13313: +esac
13314: +AC_LANG_POP(C++)dnl
13315: +AS_IF([test "x$ac_cv_prog_cxx_$1" != xno], [$5], [$6])
13316: +])# _AC_CXX_STD_TRY
13317: +
13318: +# _AC_CXX_CXX98_TEST_HEADER
13319: +# -------------------------
13320: +# A C++ header suitable for testing for CXX98.
13321: +AC_DEFUN([_AC_CXX_CXX98_TEST_HEADER],
13322: +[[
13323: +#include <algorithm>
13324: +#include <cstdlib>
13325: +#include <fstream>
13326: +#include <iomanip>
13327: +#include <iostream>
13328: +#include <list>
13329: +#include <map>
13330: +#include <set>
13331: +#include <sstream>
13332: +#include <stdexcept>
13333: +#include <string>
13334: +#include <utility>
13335: +#include <vector>
13336: +
13337: +namespace test {
13338: + typedef std::vector<std::string> string_vec;
13339: + typedef std::pair<int,bool> map_value;
13340: + typedef std::map<std::string,map_value> map_type;
13341: + typedef std::set<int> set_type;
13342: +
13343: + template<typename T>
13344: + class printer {
13345: + public:
13346: + printer(std::ostringstream& os): os(os) {}
13347: + void operator() (T elem) { os << elem << std::endl; }
13348: + private:
13349: + std::ostringstream& os;
13350: + };
13351: +}
13352: +]])# _AC_CXX_CXX98_TEST_HEADER
13353: +
13354: +# _AC_CXX_CXX98_TEST_BODY
13355: +# -----------------------
13356: +# A C++ body suitable for testing for CXX98, assuming the corresponding header.
13357: +AC_DEFUN([_AC_CXX_CXX98_TEST_BODY],
13358: +[[
13359: +
13360: +try {
13361: + // Basic string.
13362: + std::string teststr("ASCII text");
13363: + teststr += " string";
13364: +
13365: + // Simple vector.
13366: + test::string_vec testvec;
13367: + testvec.push_back(teststr);
13368: + testvec.push_back("foo");
13369: + testvec.push_back("bar");
13370: + if (testvec.size() != 3) {
13371: + throw std::runtime_error("vector size is not 1");
13372: + }
13373: +
13374: + // Dump vector into stringstream and obtain string.
13375: + std::ostringstream os;
13376: + for (test::string_vec::const_iterator i = testvec.begin();
13377: + i != testvec.end(); ++i) {
13378: + if (i + 1 != testvec.end()) {
13379: + os << teststr << '\n';
13380: + }
13381: + }
13382: + // Check algorithms work.
13383: + std::for_each(testvec.begin(), testvec.end(), test::printer<std::string>(os));
13384: + std::string os_out = os.str();
13385: +
13386: + // Test pair and map.
13387: + test::map_type testmap;
13388: + testmap.insert(std::make_pair(std::string("key"),
13389: + std::make_pair(53,false)));
13390: +
13391: + // Test set.
13392: + int values[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
13393: + test::set_type testset(values, values + sizeof(values)/sizeof(values[0]));
13394: + std::list<int> testlist(testset.begin(), testset.end());
13395: + std::copy(testset.begin(), testset.end(), std::back_inserter(testlist));
13396: +} catch (const std::exception& e) {
13397: + std::cerr << "Caught exception: " << e.what() << std::endl;
13398: +
13399: + // Test fstream
13400: + std::ofstream of("test.txt");
13401: + of << "Test ASCII text\n" << std::flush;
13402: + of << "N= " << std::hex << std::setw(8) << std::left << 534 << std::endl;
13403: + of.close();
13404: +}
13405: +std::exit(0);
13406: +]])
13407: +
13408: +# _AC_CXX_CXX11_TEST_HEADER
13409: +# -------------------------
13410: +# A C++ header suitable for testing for CXX11.
13411: +AC_DEFUN([_AC_CXX_CXX11_TEST_HEADER],
13412: +[[
13413: +#include <deque>
13414: +#include <functional>
13415: +#include <memory>
13416: +#include <tuple>
13417: +#include <array>
13418: +#include <regex>
13419: +#include <iostream>
13420: +
13421: +namespace cxx11test
13422: +{
13423: + typedef std::shared_ptr<std::string> sptr;
13424: + typedef std::weak_ptr<std::string> wptr;
13425: +
13426: + typedef std::tuple<std::string,int,double> tp;
13427: + typedef std::array<int, 20> int_array;
13428: +
13429: + constexpr int get_val() { return 20; }
13430: +
13431: + struct testinit
13432: + {
13433: + int i;
13434: + double d;
13435: + };
13436: +
13437: + class delegate {
13438: + public:
13439: + delegate(int n) : n(n) {}
13440: + delegate(): delegate(2354) {}
13441: +
13442: + virtual int getval() { return this->n; };
13443: + protected:
13444: + int n;
13445: + };
13446: +
13447: + class overridden : public delegate {
13448: + public:
13449: + overridden(int n): delegate(n) {}
13450: + virtual int getval() override final { return this->n * 2; }
13451: + };
13452: +
13453: + class nocopy {
13454: + public:
13455: + nocopy(int i): i(i) {}
13456: + nocopy() = default;
13457: + nocopy(const nocopy&) = delete;
13458: + nocopy & operator=(const nocopy&) = delete;
13459: + private:
13460: + int i;
13461: + };
13462: +}
13463: +]])# _AC_CXX_CXX11_TEST_HEADER
13464: +
13465: +# _AC_CXX_CXX11_TEST_BODY
13466: +# -----------------------
13467: +# A C++ body suitable for testing for CXX11, assuming the corresponding header.
13468: +AC_DEFUN([_AC_CXX_CXX11_TEST_BODY],
13469: +[[
13470: +{
13471: + // Test auto and decltype
13472: + std::deque<int> d;
13473: + d.push_front(43);
13474: + d.push_front(484);
13475: + d.push_front(3);
13476: + d.push_front(844);
13477: + int total = 0;
13478: + for (auto i = d.begin(); i != d.end(); ++i) { total += *i; }
13479: +
13480: + auto a1 = 6538;
13481: + auto a2 = 48573953.4;
13482: + auto a3 = "String literal";
13483: +
13484: + decltype(a2) a4 = 34895.034;
13485: +}
13486: +{
13487: + // Test constexpr
13488: + short sa[cxx11test::get_val()] = { 0 };
13489: +}
13490: +{
13491: + // Test initializer lists
13492: + cxx11test::testinit il = { 4323, 435234.23544 };
13493: +}
13494: +{
13495: + // Test range-based for and lambda
13496: + cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
13497: + for (int &x : array) { x += 23; }
13498: + std::for_each(array.begin(), array.end(), [](int v1){ std::cout << v1; });
13499: +}
13500: +{
13501: + using cxx11test::sptr;
13502: + using cxx11test::wptr;
13503: +
13504: + sptr sp(new std::string("ASCII string"));
13505: + wptr wp(sp);
13506: + sptr sp2(wp);
13507: +}
13508: +{
13509: + cxx11test::tp tuple("test", 54, 45.53434);
13510: + double d = std::get<2>(tuple);
13511: + std::string s;
13512: + int i;
13513: + std::tie(s,i,d) = tuple;
13514: +}
13515: +{
13516: + static std::regex filename_regex("^_?([a-z0-9_.]+-)+[a-z0-9]+$");
13517: + std::string testmatch("Test if this string matches");
13518: + bool match = std::regex_search(testmatch, filename_regex);
13519: +}
13520: +{
13521: + cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
13522: + cxx11test::int_array::size_type size = array.size();
13523: +}
13524: +{
13525: + // Test constructor delegation
13526: + cxx11test::delegate d1;
13527: + cxx11test::delegate d2();
13528: + cxx11test::delegate d3(45);
13529: +}
13530: +{
13531: + // Test override and final
13532: + cxx11test::overridden o1(55464);
13533: +}
13534: +{
13535: + // Test nullptr
13536: + char *c = nullptr;
13537: +}
13538: +{
13539: + // Test template brackets
13540: + std::vector<std::pair<int,char*>> v1;
13541: +}
13542: +{
13543: + // Unicode literals
13544: + char const *utf8 = u8"UTF-8 string \u2500";
13545: + char16_t const *utf16 = u"UTF-8 string \u2500";
13546: + char32_t const *utf32 = U"UTF-32 string \u2500";
13547: +}
13548: +]])
13549: +
13550: +# _AC_PROG_CXX_CXX98 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
13551: +# -------------------------------------------------------------------
13552: +
13553: +# If the C++ compiler is not in ISO C++98 mode by default, try to add
13554: +# an option to output variable CXX to make it so. This macro tries
13555: +# various options that select ISO C++98 on some system or another. It
13556: +# considers the compiler to be in ISO C++98 mode if it handles basic
13557: +# features of the std namespace including: string, containers (list,
13558: +# map, set, vector), streams (fstreams, iostreams, stringstreams,
13559: +# iomanip), pair, exceptions and algorithms.
13560: +
13561: +
13562: +AC_DEFUN([_AC_PROG_CXX_CXX98],
13563: +[_AC_CXX_STD_TRY([cxx98],
13564: +[_AC_CXX_CXX98_TEST_HEADER],
13565: +[_AC_CXX_CXX98_TEST_BODY],
13566: +dnl Try
13567: +dnl GCC -std=gnu++98 (unused restrictive mode: -std=c++98)
13568: +dnl IBM XL C -qlanglvl=extended
13569: +dnl HP aC++ -AA
13570: +dnl Intel ICC -std=gnu++98
13571: +dnl Solaris N/A (default)
13572: +dnl Tru64 N/A (default, but -std gnu could be used)
13573: +dnl with extended modes being tried first.
13574: +[[-std=gnu++98 -std=c++98 -qlanglvl=extended -AA]], [$1], [$2])[]dnl
13575: +])# _AC_PROG_CXX_CXX98
13576: +
13577: +# _AC_PROG_CXX_CXX11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
13578: +# -------------------------------------------------------------------
13579: +# If the C++ compiler is not in ISO CXX11 mode by default, try to add
13580: +# an option to output variable CXX to make it so. This macro tries
13581: +# various options that select ISO C++11 on some system or another. It
13582: +# considers the compiler to be in ISO C++11 mode if it handles all the
13583: +# tests from the C++98 checks, plus the following: Language features
13584: +# (auto, constexpr, decltype, default/deleted constructors, delegate
13585: +# constructors, final, initializer lists, lambda functions, nullptr,
13586: +# override, range-based for loops, template brackets without spaces,
13587: +# unicode literals) and library features (array, memory (shared_ptr,
13588: +# weak_ptr), regex and tuple types).
13589: +AC_DEFUN([_AC_PROG_CXX_CXX11],
13590: +[_AC_CXX_STD_TRY([cxx11],
13591: +[_AC_CXX_CXX11_TEST_HEADER
13592: +_AC_CXX_CXX98_TEST_HEADER],
13593: +[_AC_CXX_CXX11_TEST_BODY
13594: +_AC_CXX_CXX98_TEST_BODY],
13595: +dnl Try
13596: +dnl GCC -std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants]
13597: +dnl IBM XL C -qlanglvl=extended0x
13598: +dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11)
13599: +dnl HP aC++ -AA
13600: +dnl Intel ICC -std=c++11 -std=c++0x
13601: +dnl Solaris N/A (no support)
13602: +dnl Tru64 N/A (no support)
13603: +dnl with extended modes being tried first.
13604: +[[-std=gnu++11 -std=c++11 -std=gnu++0x -std=c++0x -qlanglvl=extended0x -AA]], [$1], [$2])[]dnl
13605: +])# _AC_PROG_CXX_CXX11
13606: diff --git a/src/Makefile.in b/src/Makefile.in
13607: index cc0e485..a2c2849 100644
13608: --- a/src/Makefile.in
13609: +++ b/src/Makefile.in
13610: @@ -94,7 +94,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
13611: $(top_srcdir)/m4/libsigsegv.m4 $(top_srcdir)/m4/libtool.m4 \
13612: $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
13613: $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
13614: - $(top_srcdir)/m4/readline.m4 $(top_srcdir)/configure.ac
13615: + $(top_srcdir)/m4/readline.m4 $(top_srcdir)/m4/std-gnu11.m4 \
13616: + $(top_srcdir)/configure.ac
13617: am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
13618: $(ACLOCAL_M4)
13619: DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
13620: diff --git a/src/lib/Makefile.in b/src/lib/Makefile.in
13621: index 9987700..c90b6eb 100644
13622: --- a/src/lib/Makefile.in
13623: +++ b/src/lib/Makefile.in
13624: @@ -97,7 +97,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
13625: $(top_srcdir)/m4/libsigsegv.m4 $(top_srcdir)/m4/libtool.m4 \
13626: $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
13627: $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
13628: - $(top_srcdir)/m4/readline.m4 $(top_srcdir)/configure.ac
13629: + $(top_srcdir)/m4/readline.m4 $(top_srcdir)/m4/std-gnu11.m4 \
13630: + $(top_srcdir)/configure.ac
13631: am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
13632: $(ACLOCAL_M4)
13633: DIST_COMMON = $(srcdir)/Makefile.am $(dist_lac_DATA) \
13634: diff --git a/src/repl/Makefile.in b/src/repl/Makefile.in
13635: index c33668a..d858641 100644
13636: --- a/src/repl/Makefile.in
13637: +++ b/src/repl/Makefile.in
13638: @@ -96,7 +96,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
13639: $(top_srcdir)/m4/libsigsegv.m4 $(top_srcdir)/m4/libtool.m4 \
13640: $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
13641: $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
13642: - $(top_srcdir)/m4/readline.m4 $(top_srcdir)/configure.ac
13643: + $(top_srcdir)/m4/readline.m4 $(top_srcdir)/m4/std-gnu11.m4 \
13644: + $(top_srcdir)/configure.ac
13645: am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
13646: $(ACLOCAL_M4)
13647: DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)