Commit upstream/2.5.8+ds2 - teckit

New upstream version 2.5.8+ds2 Daniel Glassey 4 years ago

63 changed file(s) with 13471 addition(s) and 5766 deletion(s). Raw diff Collapse all Expand all

-2

INSTALL less more

0	0	INSTALL
1	1
2		Note: If you checked out teckit from svn, or for any other reason don't have
	2	Note: If you checked out teckit from a VCS, or for any other reason don't have
3	3	a file called "configure", you will need to initialize the directory using
4	4	GNU autotools. Instructions for this are given further down.
5	5

62	62
63	63	The results will be in the teckit-linux subdirectory.
64	64
	65	To build just a source package that can be passed to an external package builder
	66	(such as `pbuilder`) add `-S` to the command line. Other `debuild` options can
	67	be given as well.
	68
65	69	BUILDING a MAC PACKAGE
66	70
67	71	Run the following script:

91	95	./autogen.sh
92	96
93	97	in the teckit source directory. This normally needs to be done only once, but
94		if you update the directory from svn you may need to run it again.
	98	if you update your directory from the VCS you may need to run it again.

+32

-18

Makefile.in less more

0		# Makefile.in generated by automake 1.14.1 from Makefile.am.
	0	# Makefile.in generated by automake 1.15 from Makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	3	# Copyright (C) 1994-2014 Free Software Foundation, Inc.
4	4
5	5	# This Makefile.in is free software; the Free Software Foundation
6	6	# gives unlimited permission to copy and/or distribute it,

14	14	@SET_MAKE@
15	15
16	16	VPATH = @srcdir@
17		am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__is_gnu_make = { \
	18	if test -z '$(MAKELEVEL)'; then \
	19	false; \
	20	elif test -n '$(MAKE_HOST)'; then \
	21	true; \
	22	elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
	23	true; \
	24	else \
	25	false; \
	26	fi; \
	27	}
18	28	am__make_running_with_option = \
19	29	case $${target_option-} in \
20	30	?) ;; \

79	89	host_triplet = @host@
80	90	target_triplet = @target@
81	91	subdir = .
82		DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
83		$(top_srcdir)/configure $(am__configure_deps) \
84		$(srcdir)/config.h.in $(srcdir)/installed-top.pc.in \
85		$(srcdir)/teckit.pc.in $(srcdir)/uninstalled-top.pc.in AUTHORS \
86		COPYING ChangeLog INSTALL NEWS README compile config.guess \
87		config.sub depcomp install-sh missing ltmain.sh
88	92	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
89	93	am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
90	94	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \

93	97	$(top_srcdir)/zlib-1.2.3/zlib.ac $(top_srcdir)/configure.ac
94	98	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
95	99	$(ACLOCAL_M4)
	100	DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
	101	$(am__configure_deps) $(am__DIST_COMMON)
96	102	am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
97	103	configure.lineno config.status.lineno
98	104	mkinstalldirs = $(install_sh) -d

185	191	CTAGS = ctags
186	192	CSCOPE = cscope
187	193	DIST_SUBDIRS = $(SUBDIRS)
	194	am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in \
	195	$(srcdir)/installed-top.pc.in $(srcdir)/teckit.pc.in \
	196	$(srcdir)/uninstalled-top.pc.in AUTHORS COPYING ChangeLog \
	197	INSTALL NEWS README compile config.guess config.sub install-sh \
	198	ltmain.sh missing
188	199	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
189	200	distdir = $(PACKAGE)-$(VERSION)
190	201	top_distdir = $(distdir)

271	282	LIPO = @LIPO@
272	283	LN_S = @LN_S@
273	284	LTLIBOBJS = @LTLIBOBJS@
	285	LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
274	286	MAINT = @MAINT@
275	287	MAKEINFO = @MAKEINFO@
276	288	MANIFEST_TOOL = @MANIFEST_TOOL@

346	358	prefix = @prefix@
347	359	program_transform_name = @program_transform_name@
348	360	psdir = @psdir@
	361	runstatedir = @runstatedir@
349	362	sbindir = @sbindir@
350	363	sharedstatedir = @sharedstatedir@
351	364	srcdir = @srcdir@

383	396	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
384	397	$(am__cd) $(top_srcdir) && \
385	398	$(AUTOMAKE) --foreign Makefile
386		.PRECIOUS: Makefile
387	399	Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
388	400	@case '$?' in \
389	401	config.status) \

639	651	$(am__post_remove_distdir)
640	652
641	653	dist-tarZ: distdir
642		@echo WARNING: "Support for shar distribution archives is" \
643		"deprecated." >&2
	654	@echo WARNING: "Support for distribution archives compressed with" \
	655	"legacy program 'compress' is deprecated." >&2
644	656	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
645	657	tardir=$(distdir) && $(am__tar) \| compress -c >$(distdir).tar.Z
646	658	$(am__post_remove_distdir)
647	659
648	660	dist-shar: distdir
649		@echo WARNING: "Support for distribution archives compressed with" \
650		"legacy program 'compress' is deprecated." >&2
	661	@echo WARNING: "Support for shar distribution archives is" \
	662	"deprecated." >&2
651	663	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
652	664	shar $(distdir) \| GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
653	665	$(am__post_remove_distdir)

683	695	esac
684	696	chmod -R a-w $(distdir)
685	697	chmod u+w $(distdir)
686		mkdir $(distdir)/_build $(distdir)/_inst
	698	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
687	699	chmod a-w $(distdir)
688	700	test -d $(distdir)/_build \|\| exit 0; \
689	701	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd \| sed -e 's,^[^:\\/]:[\\/],/,'` \
690	702	&& dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
691	703	&& am__cwd=`pwd` \
692		&& $(am__cd) $(distdir)/_build \
693		&& ../configure \
	704	&& $(am__cd) $(distdir)/_build/sub \
	705	&& ../../configure \
694	706	$(AM_DISTCHECK_CONFIGURE_FLAGS) \
695	707	$(DISTCHECK_CONFIGURE_FLAGS) \
696		--srcdir=.. --prefix="$$dc_install_base" \
	708	--srcdir=../.. --prefix="$$dc_install_base" \
697	709	&& $(MAKE) $(AM_MAKEFLAGS) \
698	710	&& $(MAKE) $(AM_MAKEFLAGS) dvi \
699	711	&& $(MAKE) $(AM_MAKEFLAGS) check \

873	885	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
874	886	uninstall-am uninstall-pkgconfigDATA
875	887
	888	.PRECIOUS: Makefile
	889
876	890
877	891	# Tell versions [3.59,3.63) of GNU make to not export all variables.
878	892	# Otherwise a system limit (for SysV at least) may be exceeded.

+26

-1

NEWS less more

	0	2018-06-18
	1	Version 2.5.8
	2	Updated Unicode character names and normalization data to 11.0.0
	3
	4	2017-06-22
	5	Version 2.5.7
	6	Updated Unicode character names and normalization data to 10.0.0
	7	Added a 64-bit Windows build
	8	Updated documentation
	9
	10	2016-04-19
	11	Version 2.5.6
	12	Added a diversion of /usr/bin/teckit_compile to avoid a conflict with the
	13	texlive-binaries package on Linux
	14
	15	2016-04-11
	16	Version 2.5.5
	17	Split shared libraries into a separate Linux package
	18	Made Linux packages multiarch-compatible
	19	Fixed compiler warnings
	20
	21	2014-07-09
	22	Version 2.5.4
	23	Improved building and testing scripts
	24	Enabled tests to be run on Windows without bash
	25
0	26	2014-06-30
1		Version 2.5.4
2	27	Updated Unicode character names and normalization data to 7.0.0
3	28	Fixed data normalization bug
4	29	Updated tests

+11

-9

README less more

0	0	README
	1	======
1	2
2	3	This is TECkit, a library for encoding conversion, usable through standalone
3	4	tools or by linking with other software packages.
4	5
	6	See the Documentation folder for information on the TECkit mapping language
	7	and conversion tool usage notes.
5	8
6		See the docs folder for TECkit mapping language and conversion tool usage notes.
	9	The TECkit libraries have been updated to support the Unicode 11.0.0 character
	10	repertoire.
7	11
8
9		The teckit_compile tool now supports a new option, not described in the PDF
10		documentation:
11
12		-x generate XML representation rather than compiled table
13
14		This is primarily intended for use by the Reprise utility, and the XML format
15		produced is subject to change according to the needs of that tool.
	12	Starting with TECkit version 2.5.7 there are several changes with the Windows
	13	builds. First, a 64-bit build has been added to the already existing 32-bit
	14	build. Second, the runtime files have changed. The file libwinpthread-1.dll
	15	is no longer needed. The file libstdc++-6.dll needs to match the build
	16	(32 or 64 bit) of the rest of the code. The 32-bit build needs
	17	libgcc_s_sjlj-1.dll, while the 64-bit build needs libgcc_s_seh-1.dll.

-539

~~SFconv/ConvertUTF.c~~ less more

0		/*
1		* Copyright 2001-2004 Unicode, Inc.
2		*
3		* Disclaimer
4		*
5		* This source code is provided as is by Unicode, Inc. No claims are
6		* made as to fitness for any particular purpose. No warranties of any
7		* kind are expressed or implied. The recipient agrees to determine
8		* applicability of information provided. If this file has been
9		* purchased on magnetic or optical media from Unicode, Inc., the
10		* sole remedy for any claim will be exchange of defective media
11		* within 90 days of receipt.
12		*
13		* Limitations on Rights to Redistribute This Code
14		*
15		* Unicode, Inc. hereby grants the right to freely use the information
16		* supplied in this file in the creation of products supporting the
17		* Unicode Standard, and to make copies of this file in any form
18		* for internal or external distribution as long as this notice
19		* remains attached.
20		*/
21
22		/* ---------------------------------------------------------------------
23
24		Conversions between UTF32, UTF-16, and UTF-8. Source code file.
25		Author: Mark E. Davis, 1994.
26		Rev History: Rick McGowan, fixes & updates May 2001.
27		Sept 2001: fixed const & error conditions per
28		mods suggested by S. Parent & A. Lillich.
29		June 2002: Tim Dodd added detection and handling of incomplete
30		source sequences, enhanced error detection, added casts
31		to eliminate compiler warnings.
32		July 2003: slight mods to back out aggressive FFFE detection.
33		Jan 2004: updated switches in from-UTF8 conversions.
34		Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
35
36		See the header file "ConvertUTF.h" for complete documentation.
37
38		------------------------------------------------------------------------ */
39
40
41		#include "ConvertUTF.h"
42		#ifdef CVTUTF_DEBUG
43		#include <stdio.h>
44		#endif
45
46		static const int halfShift = 10; /* used for shifting by 10 bits */
47
48		static const UTF32 halfBase = 0x0010000UL;
49		static const UTF32 halfMask = 0x3FFUL;
50
51		#define UNI_SUR_HIGH_START (UTF32)0xD800
52		#define UNI_SUR_HIGH_END (UTF32)0xDBFF
53		#define UNI_SUR_LOW_START (UTF32)0xDC00
54		#define UNI_SUR_LOW_END (UTF32)0xDFFF
55		#define false 0
56		#define true 1
57
58		/* --------------------------------------------------------------------- */
59
60		ConversionResult ConvertUTF32toUTF16 (
61		const UTF32** sourceStart, const UTF32* sourceEnd,
62		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
63		ConversionResult result = conversionOK;
64		const UTF32* source = *sourceStart;
65		UTF16* target = *targetStart;
66		while (source < sourceEnd) {
67		UTF32 ch;
68		if (target >= targetEnd) {
69		result = targetExhausted; break;
70		}
71		ch = *source++;
72		if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
73		/* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
74		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
75		if (flags == strictConversion) {
76		--source; /* return to the illegal value itself */
77		result = sourceIllegal;
78		break;
79		} else {
80		*target++ = UNI_REPLACEMENT_CHAR;
81		}
82		} else {
83		target++ = (UTF16)ch; / normal case */
84		}
85		} else if (ch > UNI_MAX_LEGAL_UTF32) {
86		if (flags == strictConversion) {
87		result = sourceIllegal;
88		} else {
89		*target++ = UNI_REPLACEMENT_CHAR;
90		}
91		} else {
92		/* target is a character in range 0xFFFF - 0x10FFFF. */
93		if (target + 1 >= targetEnd) {
94		--source; /* Back up source pointer! */
95		result = targetExhausted; break;
96		}
97		ch -= halfBase;
98		*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
99		*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
100		}
101		}
102		*sourceStart = source;
103		*targetStart = target;
104		return result;
105		}
106
107		/* --------------------------------------------------------------------- */
108
109		ConversionResult ConvertUTF16toUTF32 (
110		const UTF16** sourceStart, const UTF16* sourceEnd,
111		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
112		ConversionResult result = conversionOK;
113		const UTF16* source = *sourceStart;
114		UTF32* target = *targetStart;
115		UTF32 ch, ch2;
116		while (source < sourceEnd) {
117		const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
118		ch = *source++;
119		/* If we have a surrogate pair, convert to UTF32 first. */
120		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
121		/* If the 16 bits following the high surrogate are in the source buffer... */
122		if (source < sourceEnd) {
123		ch2 = *source;
124		/* If it's a low surrogate, convert to UTF32. */
125		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
126		ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
127		+ (ch2 - UNI_SUR_LOW_START) + halfBase;
128		++source;
129		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
130		--source; /* return to the illegal value itself */
131		result = sourceIllegal;
132		break;
133		}
134		} else { /* We don't have the 16 bits following the high surrogate. */
135		--source; /* return to the high surrogate */
136		result = sourceExhausted;
137		break;
138		}
139		} else if (flags == strictConversion) {
140		/* UTF-16 surrogate values are illegal in UTF-32 */
141		if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
142		--source; /* return to the illegal value itself */
143		result = sourceIllegal;
144		break;
145		}
146		}
147		if (target >= targetEnd) {
148		source = oldSource; /* Back up source pointer! */
149		result = targetExhausted; break;
150		}
151		*target++ = ch;
152		}
153		*sourceStart = source;
154		*targetStart = target;
155		#ifdef CVTUTF_DEBUG
156		if (result == sourceIllegal) {
157		fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
158		fflush(stderr);
159		}
160		#endif
161		return result;
162		}
163
164		/* --------------------------------------------------------------------- */
165
166		/*
167		* Index into the table below with the first byte of a UTF-8 sequence to
168		* get the number of trailing bytes that are supposed to follow it.
169		* Note that legal UTF-8 values can't have 4 or 5-bytes. The table is
170		* left as-is for anyone who may want to do such conversion, which was
171		* allowed in earlier algorithms.
172		*/
173		static const char trailingBytesForUTF8[256] = {
174		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
175		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
176		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
177		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
178		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
179		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
180		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
181		2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
182		};
183
184		/*
185		* Magic values subtracted from a buffer value during UTF8 conversion.
186		* This table contains as many values as there might be trailing bytes
187		* in a UTF-8 sequence.
188		*/
189		static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
190		0x03C82080UL, 0xFA082080UL, 0x82082080UL };
191
192		/*
193		* Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
194		* into the first byte, depending on how many bytes follow. There are
195		* as many entries in this table as there are UTF-8 sequence types.
196		* (I.e., one byte sequence, two byte... etc.). Remember that sequencs
197		* for legal UTF-8 will be 4 or fewer bytes total.
198		*/
199		static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
200
201		/* --------------------------------------------------------------------- */
202
203		/* The interface converts a whole buffer to avoid function-call overhead.
204		* Constants have been gathered. Loops & conditionals have been removed as
205		* much as possible for efficiency, in favor of drop-through switches.
206		* (See "Note A" at the bottom of the file for equivalent code.)
207		* If your compiler supports it, the "isLegalUTF8" call can be turned
208		* into an inline function.
209		*/
210
211		/* --------------------------------------------------------------------- */
212
213		ConversionResult ConvertUTF16toUTF8 (
214		const UTF16** sourceStart, const UTF16* sourceEnd,
215		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
216		ConversionResult result = conversionOK;
217		const UTF16* source = *sourceStart;
218		UTF8* target = *targetStart;
219		while (source < sourceEnd) {
220		UTF32 ch;
221		unsigned short bytesToWrite = 0;
222		const UTF32 byteMask = 0xBF;
223		const UTF32 byteMark = 0x80;
224		const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
225		ch = *source++;
226		/* If we have a surrogate pair, convert to UTF32 first. */
227		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
228		/* If the 16 bits following the high surrogate are in the source buffer... */
229		if (source < sourceEnd) {
230		UTF32 ch2 = *source;
231		/* If it's a low surrogate, convert to UTF32. */
232		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
233		ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
234		+ (ch2 - UNI_SUR_LOW_START) + halfBase;
235		++source;
236		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
237		--source; /* return to the illegal value itself */
238		result = sourceIllegal;
239		break;
240		}
241		} else { /* We don't have the 16 bits following the high surrogate. */
242		--source; /* return to the high surrogate */
243		result = sourceExhausted;
244		break;
245		}
246		} else if (flags == strictConversion) {
247		/* UTF-16 surrogate values are illegal in UTF-32 */
248		if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
249		--source; /* return to the illegal value itself */
250		result = sourceIllegal;
251		break;
252		}
253		}
254		/* Figure out how many bytes the result will require */
255		if (ch < (UTF32)0x80) { bytesToWrite = 1;
256		} else if (ch < (UTF32)0x800) { bytesToWrite = 2;
257		} else if (ch < (UTF32)0x10000) { bytesToWrite = 3;
258		} else if (ch < (UTF32)0x110000) { bytesToWrite = 4;
259		} else { bytesToWrite = 3;
260		ch = UNI_REPLACEMENT_CHAR;
261		}
262
263		target += bytesToWrite;
264		if (target > targetEnd) {
265		source = oldSource; /* Back up source pointer! */
266		target -= bytesToWrite; result = targetExhausted; break;
267		}
268		switch (bytesToWrite) { /* note: everything falls through. */
269		case 4: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
270		case 3: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
271		case 2: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
272		case 1: *--target = (UTF8)(ch \| firstByteMark[bytesToWrite]);
273		}
274		target += bytesToWrite;
275		}
276		*sourceStart = source;
277		*targetStart = target;
278		return result;
279		}
280
281		/* --------------------------------------------------------------------- */
282
283		/*
284		* Utility routine to tell whether a sequence of bytes is legal UTF-8.
285		* This must be called with the length pre-determined by the first byte.
286		* If not calling this from ConvertUTF8to*, then the length can be set by:
287		* length = trailingBytesForUTF8[*source]+1;
288		* and the sequence is illegal right away if there aren't that many bytes
289		* available.
290		* If presented with a length > 4, this returns false. The Unicode
291		* definition of UTF-8 goes up to 4-byte sequences.
292		*/
293
294		static Boolean isLegalUTF8(const UTF8 *source, int length) {
295		UTF8 a;
296		const UTF8 *srcptr = source+length;
297		switch (length) {
298		default: return false;
299		/* Everything else falls through when "true"... */
300		case 4: if ((a = (*--srcptr)) < 0x80 \|\| a > 0xBF) return false;
301		case 3: if ((a = (*--srcptr)) < 0x80 \|\| a > 0xBF) return false;
302		case 2: if ((a = (*--srcptr)) > 0xBF) return false;
303
304		switch (*source) {
305		/* no fall-through in this inner switch */
306		case 0xE0: if (a < 0xA0) return false; break;
307		case 0xED: if (a > 0x9F) return false; break;
308		case 0xF0: if (a < 0x90) return false; break;
309		case 0xF4: if (a > 0x8F) return false; break;
310		default: if (a < 0x80) return false;
311		}
312
313		case 1: if (source >= 0x80 && source < 0xC2) return false;
314		}
315		if (*source > 0xF4) return false;
316		return true;
317		}
318
319		/* --------------------------------------------------------------------- */
320
321		/*
322		* Exported function to return whether a UTF-8 sequence is legal or not.
323		* This is not used here; it's just exported.
324		*/
325		Boolean isLegalUTF8Sequence(const UTF8 source, const UTF8 sourceEnd) {
326		int length = trailingBytesForUTF8[*source]+1;
327		if (source+length > sourceEnd) {
328		return false;
329		}
330		return isLegalUTF8(source, length);
331		}
332
333		/* --------------------------------------------------------------------- */
334
335		ConversionResult ConvertUTF8toUTF16 (
336		const UTF8** sourceStart, const UTF8* sourceEnd,
337		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
338		ConversionResult result = conversionOK;
339		const UTF8* source = *sourceStart;
340		UTF16* target = *targetStart;
341		while (source < sourceEnd) {
342		UTF32 ch = 0;
343		unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
344		if (source + extraBytesToRead >= sourceEnd) {
345		result = sourceExhausted; break;
346		}
347		/* Do this check whether lenient or strict */
348		if (! isLegalUTF8(source, extraBytesToRead+1)) {
349		result = sourceIllegal;
350		break;
351		}
352		/*
353		* The cases all fall through. See "Note A" below.
354		*/
355		switch (extraBytesToRead) {
356		case 5: ch += source++; ch <<= 6; / remember, illegal UTF-8 */
357		case 4: ch += source++; ch <<= 6; / remember, illegal UTF-8 */
358		case 3: ch += *source++; ch <<= 6;
359		case 2: ch += *source++; ch <<= 6;
360		case 1: ch += *source++; ch <<= 6;
361		case 0: ch += *source++;
362		}
363		ch -= offsetsFromUTF8[extraBytesToRead];
364
365		if (target >= targetEnd) {
366		source -= (extraBytesToRead+1); /* Back up source pointer! */
367		result = targetExhausted; break;
368		}
369		if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
370		/* UTF-16 surrogate values are illegal in UTF-32 */
371		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
372		if (flags == strictConversion) {
373		source -= (extraBytesToRead+1); /* return to the illegal value itself */
374		result = sourceIllegal;
375		break;
376		} else {
377		*target++ = UNI_REPLACEMENT_CHAR;
378		}
379		} else {
380		target++ = (UTF16)ch; / normal case */
381		}
382		} else if (ch > UNI_MAX_UTF16) {
383		if (flags == strictConversion) {
384		result = sourceIllegal;
385		source -= (extraBytesToRead+1); /* return to the start */
386		break; /* Bail out; shouldn't continue */
387		} else {
388		*target++ = UNI_REPLACEMENT_CHAR;
389		}
390		} else {
391		/* target is a character in range 0xFFFF - 0x10FFFF. */
392		if (target + 1 >= targetEnd) {
393		source -= (extraBytesToRead+1); /* Back up source pointer! */
394		result = targetExhausted; break;
395		}
396		ch -= halfBase;
397		*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
398		*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
399		}
400		}
401		*sourceStart = source;
402		*targetStart = target;
403		return result;
404		}
405
406		/* --------------------------------------------------------------------- */
407
408		ConversionResult ConvertUTF32toUTF8 (
409		const UTF32** sourceStart, const UTF32* sourceEnd,
410		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
411		ConversionResult result = conversionOK;
412		const UTF32* source = *sourceStart;
413		UTF8* target = *targetStart;
414		while (source < sourceEnd) {
415		UTF32 ch;
416		unsigned short bytesToWrite = 0;
417		const UTF32 byteMask = 0xBF;
418		const UTF32 byteMark = 0x80;
419		ch = *source++;
420		if (flags == strictConversion ) {
421		/* UTF-16 surrogate values are illegal in UTF-32 */
422		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
423		--source; /* return to the illegal value itself */
424		result = sourceIllegal;
425		break;
426		}
427		}
428		/*
429		* Figure out how many bytes the result will require. Turn any
430		* illegally large UTF32 things (> Plane 17) into replacement chars.
431		*/
432		if (ch < (UTF32)0x80) { bytesToWrite = 1;
433		} else if (ch < (UTF32)0x800) { bytesToWrite = 2;
434		} else if (ch < (UTF32)0x10000) { bytesToWrite = 3;
435		} else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4;
436		} else { bytesToWrite = 3;
437		ch = UNI_REPLACEMENT_CHAR;
438		result = sourceIllegal;
439		}
440
441		target += bytesToWrite;
442		if (target > targetEnd) {
443		--source; /* Back up source pointer! */
444		target -= bytesToWrite; result = targetExhausted; break;
445		}
446		switch (bytesToWrite) { /* note: everything falls through. */
447		case 4: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
448		case 3: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
449		case 2: *--target = (UTF8)((ch \| byteMark) & byteMask); ch >>= 6;
450		case 1: *--target = (UTF8) (ch \| firstByteMark[bytesToWrite]);
451		}
452		target += bytesToWrite;
453		}
454		*sourceStart = source;
455		*targetStart = target;
456		return result;
457		}
458
459		/* --------------------------------------------------------------------- */
460
461		ConversionResult ConvertUTF8toUTF32 (
462		const UTF8** sourceStart, const UTF8* sourceEnd,
463		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
464		ConversionResult result = conversionOK;
465		const UTF8* source = *sourceStart;
466		UTF32* target = *targetStart;
467		while (source < sourceEnd) {
468		UTF32 ch = 0;
469		unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
470		if (source + extraBytesToRead >= sourceEnd) {
471		result = sourceExhausted; break;
472		}
473		/* Do this check whether lenient or strict */
474		if (! isLegalUTF8(source, extraBytesToRead+1)) {
475		result = sourceIllegal;
476		break;
477		}
478		/*
479		* The cases all fall through. See "Note A" below.
480		*/
481		switch (extraBytesToRead) {
482		case 5: ch += *source++; ch <<= 6;
483		case 4: ch += *source++; ch <<= 6;
484		case 3: ch += *source++; ch <<= 6;
485		case 2: ch += *source++; ch <<= 6;
486		case 1: ch += *source++; ch <<= 6;
487		case 0: ch += *source++;
488		}
489		ch -= offsetsFromUTF8[extraBytesToRead];
490
491		if (target >= targetEnd) {
492		source -= (extraBytesToRead+1); /* Back up the source pointer! */
493		result = targetExhausted; break;
494		}
495		if (ch <= UNI_MAX_LEGAL_UTF32) {
496		/*
497		* UTF-16 surrogate values are illegal in UTF-32, and anything
498		* over Plane 17 (> 0x10FFFF) is illegal.
499		*/
500		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
501		if (flags == strictConversion) {
502		source -= (extraBytesToRead+1); /* return to the illegal value itself */
503		result = sourceIllegal;
504		break;
505		} else {
506		*target++ = UNI_REPLACEMENT_CHAR;
507		}
508		} else {
509		*target++ = ch;
510		}
511		} else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
512		result = sourceIllegal;
513		*target++ = UNI_REPLACEMENT_CHAR;
514		}
515		}
516		*sourceStart = source;
517		*targetStart = target;
518		return result;
519		}
520
521		/* ---------------------------------------------------------------------
522
523		Note A.
524		The fall-through switches in UTF-8 reading code save a
525		temp variable, some decrements & conditionals. The switches
526		are equivalent to the following loop:
527		{
528		int tmpBytesToRead = extraBytesToRead+1;
529		do {
530		ch += *source++;
531		--tmpBytesToRead;
532		if (tmpBytesToRead) ch <<= 6;
533		} while (tmpBytesToRead > 0);
534		}
535		In UTF-8 writing code, the switches on "bytesToWrite" are
536		similarly unrolled loops.
537
538		--------------------------------------------------------------------- */

-149

~~SFconv/ConvertUTF.h~~ less more

0		/*
1		* Copyright 2001-2004 Unicode, Inc.
2		*
3		* Disclaimer
4		*
5		* This source code is provided as is by Unicode, Inc. No claims are
6		* made as to fitness for any particular purpose. No warranties of any
7		* kind are expressed or implied. The recipient agrees to determine
8		* applicability of information provided. If this file has been
9		* purchased on magnetic or optical media from Unicode, Inc., the
10		* sole remedy for any claim will be exchange of defective media
11		* within 90 days of receipt.
12		*
13		* Limitations on Rights to Redistribute This Code
14		*
15		* Unicode, Inc. hereby grants the right to freely use the information
16		* supplied in this file in the creation of products supporting the
17		* Unicode Standard, and to make copies of this file in any form
18		* for internal or external distribution as long as this notice
19		* remains attached.
20		*/
21
22		/* ---------------------------------------------------------------------
23
24		Conversions between UTF32, UTF-16, and UTF-8. Header file.
25
26		Several funtions are included here, forming a complete set of
27		conversions between the three formats. UTF-7 is not included
28		here, but is handled in a separate source file.
29
30		Each of these routines takes pointers to input buffers and output
31		buffers. The input buffers are const.
32
33		Each routine converts the text between *sourceStart and sourceEnd,
34		putting the result into the buffer between *targetStart and
35		targetEnd. Note: the end pointers are after the last item: e.g.
36		*(sourceEnd - 1) is the last item.
37
38		The return result indicates whether the conversion was successful,
39		and if not, whether the problem was in the source or target buffers.
40		(Only the first encountered problem is indicated.)
41
42		After the conversion, sourceStart and targetStart are both
43		updated to point to the end of last text successfully converted in
44		the respective buffers.
45
46		Input parameters:
47		sourceStart - pointer to a pointer to the source buffer.
48		The contents of this are modified on return so that
49		it points at the next thing to be converted.
50		targetStart - similarly, pointer to pointer to the target buffer.
51		sourceEnd, targetEnd - respectively pointers to the ends of the
52		two buffers, for overflow checking only.
53
54		These conversion functions take a ConversionFlags argument. When this
55		flag is set to strict, both irregular sequences and isolated surrogates
56		will cause an error. When the flag is set to lenient, both irregular
57		sequences and isolated surrogates are converted.
58
59		Whether the flag is strict or lenient, all illegal sequences will cause
60		an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
61		or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
62		must check for illegal sequences.
63
64		When the flag is set to lenient, characters over 0x10FFFF are converted
65		to the replacement character; otherwise (when the flag is set to strict)
66		they constitute an error.
67
68		Output parameters:
69		The value "sourceIllegal" is returned from some routines if the input
70		sequence is malformed. When "sourceIllegal" is returned, the source
71		value will point to the illegal value that caused the problem. E.g.,
72		in UTF-8 when a sequence is malformed, it points to the start of the
73		malformed sequence.
74
75		Author: Mark E. Davis, 1994.
76		Rev History: Rick McGowan, fixes & updates May 2001.
77		Fixes & updates, Sept 2001.
78
79		------------------------------------------------------------------------ */
80
81		/* ---------------------------------------------------------------------
82		The following 4 definitions are compiler-specific.
83		The C standard does not guarantee that wchar_t has at least
84		16 bits, so wchar_t is no less portable than unsigned short!
85		All should be unsigned values to avoid sign extension during
86		bit mask & shift operations.
87		------------------------------------------------------------------------ */
88
89		typedef unsigned long UTF32; /* at least 32 bits */
90		typedef unsigned short UTF16; /* at least 16 bits */
91		typedef unsigned char UTF8; /* typically 8 bits */
92		typedef unsigned char Boolean; /* 0 or 1 */
93
94		/* Some fundamental constants */
95		#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
96		#define UNI_MAX_BMP (UTF32)0x0000FFFF
97		#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
98		#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
99		#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
100
101		typedef enum {
102		conversionOK, /* conversion successful */
103		sourceExhausted, /* partial character in source, but hit end */
104		targetExhausted, /* insuff. room in target for conversion */
105		sourceIllegal /* source sequence is illegal/malformed */
106		} ConversionResult;
107
108		typedef enum {
109		strictConversion = 0,
110		lenientConversion
111		} ConversionFlags;
112
113		/* This is for C++ and does no harm in C */
114		#ifdef __cplusplus
115		extern "C" {
116		#endif
117
118		ConversionResult ConvertUTF8toUTF16 (
119		const UTF8** sourceStart, const UTF8* sourceEnd,
120		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
121
122		ConversionResult ConvertUTF16toUTF8 (
123		const UTF16** sourceStart, const UTF16* sourceEnd,
124		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
125
126		ConversionResult ConvertUTF8toUTF32 (
127		const UTF8** sourceStart, const UTF8* sourceEnd,
128		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
129
130		ConversionResult ConvertUTF32toUTF8 (
131		const UTF32** sourceStart, const UTF32* sourceEnd,
132		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
133
134		ConversionResult ConvertUTF16toUTF32 (
135		const UTF16** sourceStart, const UTF16* sourceEnd,
136		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
137
138		ConversionResult ConvertUTF32toUTF16 (
139		const UTF32** sourceStart, const UTF32* sourceEnd,
140		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
141
142		Boolean isLegalUTF8Sequence(const UTF8 source, const UTF8 sourceEnd);
143
144		#ifdef __cplusplus
145		}
146		#endif
147
148		/* --------------------------------------------------------------------- */

+18

-13

SFconv/SFconv.cpp less more

9	9	using namespace std;
10	10
11	11	#include "TECkit_Engine.h"
12		#include "ConvertUTF.h"
	12	#include "UtfCodec.h"
13	13	#include "sfReader.h"
14	14
15	15	#ifndef platformUTF16

94	94	static ustring
95	95	Utf8ToString(const char* s)
96	96	{
97		int len = strlen(s);
98		UniChar* buf = new UniChar[len];
99		const Byte* sourceStart = (Byte*)s;
100		UniChar* targetStart = buf;
101		int status = ConvertUTF8toUTF16(&sourceStart, sourceStart + len, &targetStart, targetStart + len, lenientConversion);
102		if (status != conversionOK) {
103		fprintf(stderr, "error %d converting UTF-8 to UTF-16\n", status);
104		exit(1);
105		}
106		ustring ustr(buf, targetStart - buf);
	97	int len = strlen(s);
	98	utf16::codeunit_t * const buf = new utf16::codeunit_t[len];
	99
	100	utf16::iterator out = buf;
	101	utf8::const_iterator in = s,
	102	end = s + len;
	103	while (in != end && !(in.error() \|\| out.error()))
	104	out++ = in++;
	105
	106	if (in.error() \|\| out.error()) {
	107	fprintf(stderr, "error %d converting UTF-8 to UTF-16\n", 4);
	108	exit(1);
	109	}
	110
	111	ustring ustr(buf, out - buf);
107	112	delete[] buf;
108	113	return ustr;
109	114	}

312	317	fprintf(stderr, "unable to read mapping file for %s (file %s)\n", mappingName.c_str(), mapFileName.c_str());
313	318	exit(1);
314	319	}
315		fread(buf, 1, fileSize, mapFile);
	320	fileSize = fread(buf, 1, fileSize, mapFile);
316	321	fclose(mapFile);
317	322
318	323	TECkit_Converter converter;

628	633	// *** Unicode to Byte conversion
629	634	Byte bom[3];
630	635	long pos = ftell(inFile);
631		if (fread(bom, 3, 1, inFile)) {
	636	if (fread(bom, 3, 1, inFile) > 0) {
632	637	if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf) {
633	638	inForm = kForm_UTF8;
634	639	}

+38

-0

SFconv/UtfCodec.cpp less more

	0	/* GRAPHITE2 LICENSING
	1
	2	Copyright 2010, SIL International
	3	All rights reserved.
	4
	5	This library is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU Lesser General Public License as published
	7	by the Free Software Foundation; either version 2.1 of License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should also have received a copy of the GNU Lesser General Public
	16	License along with this library in the file named "LICENSE".
	17	If not, write to the Free Software Foundation, 51 Franklin Street,
	18	Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
	19	internet at http://www.fsf.org/licenses/lgpl.html.
	20
	21	Alternatively, the contents of this file may be used under the terms of the
	22	Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
	23	License, as published by the Free Software Foundation, either version 2
	24	of the License or (at your option) any later version.
	25	*/
	26	#include "UtfCodec.h"
	27
	28	const int8_t _utf_codec<8>::sz_lut[16] =
	29	{
	30	1,1,1,1,1,1,1,1, // 1 byte
	31	0,0,0,0, // trailing byte
	32	2,2, // 2 bytes
	33	3, // 3 bytes
	34	4 // 4 bytes
	35	};
	36
	37	const uint8_t _utf_codec<8>::mask_lut[5] = {0x7f, 0xff, 0x3f, 0x1f, 0x0f};

+252

-0

SFconv/UtfCodec.h less more

	0	/* GRAPHITE2 LICENSING
	1
	2	Copyright 2011, SIL International
	3	All rights reserved.
	4
	5	This library is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU Lesser General Public License as published
	7	by the Free Software Foundation; either version 2.1 of License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should also have received a copy of the GNU Lesser General Public
	16	License along with this library in the file named "LICENSE".
	17	If not, write to the Free Software Foundation, 51 Franklin Street,
	18	Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
	19	internet at http://www.fsf.org/licenses/lgpl.html.
	20
	21	Alternatively, the contents of this file may be used under the terms of the
	22	Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
	23	License, as published by the Free Software Foundation, either version 2
	24	of the License or (at your option) any later version.
	25	*/
	26	#pragma once
	27
	28	#include <cstddef>
	29	#include <cstdlib>
	30	#include <cstdint>
	31
	32	using std::int8_t;
	33	using std::uint8_t;
	34	using std::ptrdiff_t;
	35
	36	typedef uint32_t uchar_t;
	37
	38	template <int N>
	39	struct _utf_codec
	40	{
	41	typedef uchar_t codeunit_t;
	42
	43	static void put(codeunit_t * cp, const uchar_t , int8_t & len) throw();
	44	static uchar_t get(const codeunit_t * cp, int8_t & len) throw();
	45	static bool validate(const codeunit_t * s, const codeunit_t * e) throw();
	46	};
	47
	48
	49	template <>
	50	struct _utf_codec<32>
	51	{
	52	private:
	53	static const uchar_t limit = 0x110000;
	54	public:
	55	typedef uint32_t codeunit_t;
	56
	57	inline
	58	static void put(codeunit_t * cp, const uchar_t usv, int8_t & l) throw()
	59	{
	60	*cp = usv; l = 1;
	61	}
	62
	63	inline
	64	static uchar_t get(const codeunit_t * cp, int8_t & l) throw()
	65	{
	66	if (cp[0] < limit) { l = 1; return cp[0]; }
	67	else { l = -1; return 0xFFFD; }
	68	}
	69
	70	inline
	71	static bool validate(codeunit_t * s, codeunit_t * e) throw()
	72	{
	73	return e > s;
	74	}
	75	};
	76
	77
	78	template <>
	79	struct _utf_codec<16>
	80	{
	81	private:
	82	static const int32_t lead_offset = 0xD800 - (0x10000 >> 10);
	83	static const int32_t surrogate_offset = 0x10000 - (0xD800 << 10) - 0xDC00;
	84	public:
	85	typedef uint16_t codeunit_t;
	86
	87	inline
	88	static void put(codeunit_t * cp, const uchar_t usv, int8_t & l) throw()
	89	{
	90	if (usv < 0x10000) { l = 1; cp[0] = codeunit_t(usv); }
	91	else
	92	{
	93	cp[0] = codeunit_t(lead_offset + (usv >> 10));
	94	cp[1] = codeunit_t(0xDC00 + (usv & 0x3FF));
	95	l = 2;
	96	}
	97	}
	98
	99	inline
	100	static uchar_t get(const codeunit_t * cp, int8_t & l) throw()
	101	{
	102	const uint32_t uh = cp[0];
	103	l = 1;
	104
	105	if (uh < 0xD800\|\| uh > 0xDFFF) { return uh; }
	106	const uint32_t ul = cp[1];
	107	if (uh > 0xDBFF \|\| ul < 0xDC00 \|\| ul > 0xDFFF) { l = -1; return 0xFFFD; }
	108	++l;
	109	return (uh<<10) + ul + surrogate_offset;
	110	}
	111
	112	inline
	113	static bool validate(codeunit_t * s, codeunit_t * e) throw()
	114	{
	115	const ptrdiff_t n = e-s;
	116	if (n <= 0) return n == 0;
	117	const uint32_t u = *(s+(n-1)); // Get the last codepoint
	118	return (u < 0xD800 \|\| u > 0xDBFF);
	119	}
	120	};
	121
	122
	123	template <>
	124	struct _utf_codec<8>
	125	{
	126	private:
	127	static const uchar_t limit = 0x110000;
	128	static const int8_t sz_lut[16];
	129	static const uint8_t mask_lut[5];
	130
	131
	132	public:
	133	typedef uint8_t codeunit_t;
	134
	135	inline
	136	static void put(codeunit_t * cp, const uchar_t usv, int8_t & l) throw()
	137	{
	138	if (usv < 0x80) {l = 1; cp[0] = usv; return; }
	139	if (usv < 0x0800) {l = 2; cp[0] = 0xC0 + (usv >> 6); cp[1] = 0x80 + (usv & 0x3F); return; }
	140	if (usv < 0x10000) {l = 3; cp[0] = 0xE0 + (usv >> 12); cp[1] = 0x80 + ((usv >> 6) & 0x3F); cp[2] = 0x80 + (usv & 0x3F); return; }
	141	else {l = 4; cp[0] = 0xF0 + (usv >> 18); cp[1] = 0x80 + ((usv >> 12) & 0x3F); cp[2] = 0x80 + ((usv >> 6) & 0x3F); cp[3] = 0x80 + (usv & 0x3F); return; }
	142	}
	143
	144	inline
	145	static uchar_t get(const codeunit_t * cp, int8_t & l) throw()
	146	{
	147	const int8_t seq_sz = sz_lut[*cp >> 4];
	148	uchar_t u = *cp & mask_lut[seq_sz];
	149	l = 1;
	150	bool toolong = false;
	151
	152	switch(seq_sz) {
	153	case 4: u <<= 6; u \|= ++cp & 0x3F; if (cp >> 6 != 2) break; ++l; toolong = (u < 0x10);
	154	// no break
	155	case 3: u <<= 6; u \|= ++cp & 0x3F; if (cp >> 6 != 2) break; ++l; toolong \|= (u < 0x20);
	156	// no break
	157	case 2: u <<= 6; u \|= ++cp & 0x3F; if (cp >> 6 != 2) break; ++l; toolong \|= (u < 0x80);
	158	// no break
	159	case 1: break;
	160	case 0: l = -1; return 0xFFFD;
	161	}
	162
	163	if (l != seq_sz \|\| toolong \|\| u >= limit)
	164	{
	165	l = -l;
	166	return 0xFFFD;
	167	}
	168	return u;
	169	}
	170
	171	inline
	172	static bool validate(codeunit_t * s, codeunit_t * e) throw()
	173	{
	174	const ptrdiff_t n = e-s;
	175	if (n <= 0) return n == 0;
	176	s += (n-1);
	177	if (*s < 0x80) return true;
	178	if (*s >= 0xC0) return false;
	179	if (n == 1) return true;
	180	if (*--s < 0x80) return true;
	181	if (*s >= 0xe0) return false;
	182	if (n == 2 \|\| *s >= 0xC0) return true;
	183	if (*--s < 0x80) return true;
	184	if (*s >= 0xF0) return false;
	185	return true;
	186	}
	187
	188	};
	189
	190
	191	template <typename C>
	192	class _utf_iterator
	193	{
	194	typedef _utf_codec<sizeof(C)*8> codec;
	195
	196	C * cp;
	197	mutable int8_t sl;
	198
	199	public:
	200	typedef C codeunit_type;
	201	typedef uchar_t value_type;
	202	typedef uchar_t * pointer;
	203
	204	class reference
	205	{
	206	const _utf_iterator & _i;
	207
	208	reference(const _utf_iterator & i): _i(i) {}
	209	public:
	210	operator value_type () const throw () { return codec::get(_i.cp, _i.sl); }
	211	reference & operator = (const value_type usv) throw() { codec::put(_i.cp, usv, _i.sl); return *this; }
	212
	213	friend class _utf_iterator;
	214	};
	215
	216
	217	_utf_iterator(const void * us=0) : cp(reinterpret_cast<C >(const_cast<void >(us))), sl(1) { }
	218
	219	_utf_iterator & operator ++ () { cp += abs(sl); return *this; }
	220	_utf_iterator operator ++ (int) { _utf_iterator tmp(*this); operator++(); return tmp; }
	221
	222	bool operator == (const _utf_iterator & rhs) const throw() { return cp >= rhs.cp; }
	223	bool operator != (const _utf_iterator & rhs) const throw() { return !operator==(rhs); }
	224
	225	reference operator * () const throw() { return *this; }
	226	pointer operator ->() const throw() { return &operator *(); }
	227
	228	operator codeunit_type * () const throw() { return cp; }
	229
	230	bool error() const throw() { return sl < 1; }
	231	};
	232
	233	template <typename C>
	234	struct utf
	235	{
	236	typedef typename _utf_codec<sizeof(C)*8>::codeunit_t codeunit_t;
	237
	238	typedef _utf_iterator<C> iterator;
	239	typedef _utf_iterator<const C> const_iterator;
	240
	241	inline
	242	static bool validate(codeunit_t * s, codeunit_t * e) throw() {
	243	return _utf_codec<sizeof(C)*8>::validate(s,e);
	244	}
	245	};
	246
	247
	248	typedef utf<uint32_t> utf32;
	249	typedef utf<uint16_t> utf16;
	250	typedef utf<uint8_t> utf8;
	251

-0

SFconv/sfReader.h less more

8	8	#define INLINE_START 2
9	9	#define INLINE_END 3
10	10	#define INLINE_MARKER 4
	11	#define UNI_REPLACEMENT_CHAR (uint32_t)0x0000FFFD
	12	#define UNI_MAX_BMP (uint32_t)0x0000FFFF
	13	#define UNI_MAX_UTF16 (uint32_t)0x0010FFFF
11	14
12	15	template<class C>
13	16	class sfReader

+32

-29

aclocal.m4 less more

0		# generated automatically by aclocal 1.14.1 -- Autoconf --
1
2		# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	0	# generated automatically by aclocal 1.15 -- Autoconf --
	1
	2	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
3	3
4	4	# This file is free software; the Free Software Foundation
5	5	# gives unlimited permission to copy and/or distribute it,

19	19	If you have problems, you may need to regenerate the build system entirely.
20	20	To do so, use the procedure documented by the package, typically 'autoreconf'.])])
21	21
22		# Copyright (C) 2002-2013 Free Software Foundation, Inc.
	22	# Copyright (C) 2002-2014 Free Software Foundation, Inc.
23	23	#
24	24	# This file is free software; the Free Software Foundation
25	25	# gives unlimited permission to copy and/or distribute it,

31	31	# generated from the m4 files accompanying Automake X.Y.
32	32	# (This private macro should not be called outside this file.)
33	33	AC_DEFUN([AM_AUTOMAKE_VERSION],
34		[am__api_version='1.14'
	34	[am__api_version='1.15'
35	35	dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
36	36	dnl require some minimum version. Point them to the right macro.
37		m4_if([$1], [1.14.1], [],
	37	m4_if([$1], [1.15], [],
38	38	[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
39	39	])
40	40

50	50	# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
51	51	# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
52	52	AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
53		[AM_AUTOMAKE_VERSION([1.14.1])dnl
	53	[AM_AUTOMAKE_VERSION([1.15])dnl
54	54	m4_ifndef([AC_AUTOCONF_VERSION],
55	55	[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
56	56	_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
57	57
58	58	# AM_AUX_DIR_EXPAND -- Autoconf --
59	59
60		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	60	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
61	61	#
62	62	# This file is free software; the Free Software Foundation
63	63	# gives unlimited permission to copy and/or distribute it,

109	109
110	110	# AM_CONDITIONAL -- Autoconf --
111	111
112		# Copyright (C) 1997-2013 Free Software Foundation, Inc.
	112	# Copyright (C) 1997-2014 Free Software Foundation, Inc.
113	113	#
114	114	# This file is free software; the Free Software Foundation
115	115	# gives unlimited permission to copy and/or distribute it,

140	140	Usually this means the macro was only invoked conditionally.]])
141	141	fi])])
142	142
143		# Copyright (C) 1999-2013 Free Software Foundation, Inc.
	143	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
144	144	#
145	145	# This file is free software; the Free Software Foundation
146	146	# gives unlimited permission to copy and/or distribute it,

331	331
332	332	# Generate code to set up dependency tracking. -- Autoconf --
333	333
334		# Copyright (C) 1999-2013 Free Software Foundation, Inc.
	334	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
335	335	#
336	336	# This file is free software; the Free Software Foundation
337	337	# gives unlimited permission to copy and/or distribute it,

407	407
408	408	# Do all the work for Automake. -- Autoconf --
409	409
410		# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	410	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
411	411	#
412	412	# This file is free software; the Free Software Foundation
413	413	# gives unlimited permission to copy and/or distribute it,

497	497	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
498	498	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
499	499	AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
500		# We need awk for the "check" target. The system "awk" is bad on
501		# some platforms.
	500	# We need awk for the "check" target (and possibly the TAP driver). The
	501	# system "awk" is bad on some platforms.
502	502	AC_REQUIRE([AC_PROG_AWK])dnl
503	503	AC_REQUIRE([AC_PROG_MAKE_SET])dnl
504	504	AC_REQUIRE([AM_SET_LEADING_DOT])dnl

572	572	AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
573	573	fi
574	574	fi
	575	dnl The trailing newline in this macro's definition is deliberate, for
	576	dnl backward compatibility and to allow trailing 'dnl'-style comments
	577	dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
575	578	])
576	579
577	580	dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not

601	604	done
602	605	echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
603	606
604		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	607	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
605	608	#
606	609	# This file is free software; the Free Software Foundation
607	610	# gives unlimited permission to copy and/or distribute it,

612	615	# Define $install_sh.
613	616	AC_DEFUN([AM_PROG_INSTALL_SH],
614	617	[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
615		if test x"${install_sh}" != xset; then
	618	if test x"${install_sh+set}" != xset; then
616	619	case $am_aux_dir in
617	620	\ \| \ )
618	621	install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;

622	625	fi
623	626	AC_SUBST([install_sh])])
624	627
625		# Copyright (C) 2003-2013 Free Software Foundation, Inc.
	628	# Copyright (C) 2003-2014 Free Software Foundation, Inc.
626	629	#
627	630	# This file is free software; the Free Software Foundation
628	631	# gives unlimited permission to copy and/or distribute it,

644	647	# Add --enable-maintainer-mode option to configure. -- Autoconf --
645	648	# From Jim Meyering
646	649
647		# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	650	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
648	651	#
649	652	# This file is free software; the Free Software Foundation
650	653	# gives unlimited permission to copy and/or distribute it,

679	682
680	683	# Check to see how 'make' treats includes. -- Autoconf --
681	684
682		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	685	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
683	686	#
684	687	# This file is free software; the Free Software Foundation
685	688	# gives unlimited permission to copy and/or distribute it,

729	732
730	733	# Fake the existence of programs that GNU maintainers use. -- Autoconf --
731	734
732		# Copyright (C) 1997-2013 Free Software Foundation, Inc.
	735	# Copyright (C) 1997-2014 Free Software Foundation, Inc.
733	736	#
734	737	# This file is free software; the Free Software Foundation
735	738	# gives unlimited permission to copy and/or distribute it,

770	773	# Obsolete and "removed" macros, that must however still report explicit
771	774	# error messages when used, to smooth transition.
772	775	#
773		# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	776	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
774	777	#
775	778	# This file is free software; the Free Software Foundation
776	779	# gives unlimited permission to copy and/or distribute it,

797	800
798	801	# Helper functions for option handling. -- Autoconf --
799	802
800		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	803	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
801	804	#
802	805	# This file is free software; the Free Software Foundation
803	806	# gives unlimited permission to copy and/or distribute it,

826	829	AC_DEFUN([_AM_IF_OPTION],
827	830	[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
828	831
829		# Copyright (C) 1999-2013 Free Software Foundation, Inc.
	832	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
830	833	#
831	834	# This file is free software; the Free Software Foundation
832	835	# gives unlimited permission to copy and/or distribute it,

873	876	# For backward compatibility.
874	877	AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
875	878
876		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	879	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
877	880	#
878	881	# This file is free software; the Free Software Foundation
879	882	# gives unlimited permission to copy and/or distribute it,

892	895
893	896	# Check to make sure that the build environment is sane. -- Autoconf --
894	897
895		# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	898	# Copyright (C) 1996-2014 Free Software Foundation, Inc.
896	899	#
897	900	# This file is free software; the Free Software Foundation
898	901	# gives unlimited permission to copy and/or distribute it,

973	976	rm -f conftest.file
974	977	])
975	978
976		# Copyright (C) 2009-2013 Free Software Foundation, Inc.
	979	# Copyright (C) 2009-2014 Free Software Foundation, Inc.
977	980	#
978	981	# This file is free software; the Free Software Foundation
979	982	# gives unlimited permission to copy and/or distribute it,

1033	1036	_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
1034	1037	])
1035	1038
1036		# Copyright (C) 2001-2013 Free Software Foundation, Inc.
	1039	# Copyright (C) 2001-2014 Free Software Foundation, Inc.
1037	1040	#
1038	1041	# This file is free software; the Free Software Foundation
1039	1042	# gives unlimited permission to copy and/or distribute it,

1061	1064	INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
1062	1065	AC_SUBST([INSTALL_STRIP_PROGRAM])])
1063	1066
1064		# Copyright (C) 2006-2013 Free Software Foundation, Inc.
	1067	# Copyright (C) 2006-2014 Free Software Foundation, Inc.
1065	1068	#
1066	1069	# This file is free software; the Free Software Foundation
1067	1070	# gives unlimited permission to copy and/or distribute it,

1080	1083
1081	1084	# Check how to create a tarball. -- Autoconf --
1082	1085
1083		# Copyright (C) 2004-2013 Free Software Foundation, Inc.
	1086	# Copyright (C) 2004-2014 Free Software Foundation, Inc.
1084	1087	#
1085	1088	# This file is free software; the Free Software Foundation
1086	1089	# gives unlimited permission to copy and/or distribute it,

-2

bin/Makefile.am less more

27	27	txtconv_SOURCES = @top_builddir@/source/Sample-tools/TxtConv.cpp
28	28
29	29	sfconv_SOURCES = @top_builddir@/SFconv/SFconv.cpp
30		sfconv_SOURCES += @top_builddir@/SFconv/ConvertUTF.c
	30	sfconv_SOURCES += @top_builddir@/SFconv/UtfCodec.cpp
31	31	sfconv_CPPFLAGS = $(AM_CPPFLAGS) $(EXPAT_CFLAGS)
	32	sfconv_CXXFLAGS = -std=c++11
32	33	sfconv_CFLAGS = $(AM_CPPFLAGS) $(EXPAT_CFLAGS)
33	34	sfconv_SOURCES += @top_builddir@/SFconv/sfReader.h
34		sfconv_SOURCES += @top_builddir@/SFconv/ConvertUTF.h
	35	sfconv_SOURCES += @top_builddir@/SFconv/UtfCodec.h
35	36	sfconv_SOURCES += @top_builddir@/SFconv/Debug_Prefix.h
36	37	sfconv_SOURCES += @top_builddir@/SFconv/Final_Prefix.h
37	38	sfconv_SOURCES += @top_builddir@/SFconv/ushort_chartraits.h

+44

-30

bin/Makefile.in less more

0		# Makefile.in generated by automake 1.14.1 from Makefile.am.
	0	# Makefile.in generated by automake 1.15 from Makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	3	# Copyright (C) 1994-2014 Free Software Foundation, Inc.
4	4
5	5	# This Makefile.in is free software; the Free Software Foundation
6	6	# gives unlimited permission to copy and/or distribute it,

15	15
16	16
17	17	VPATH = @srcdir@
18		am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__is_gnu_make = { \
	19	if test -z '$(MAKELEVEL)'; then \
	20	false; \
	21	elif test -n '$(MAKE_HOST)'; then \
	22	true; \
	23	elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
	24	true; \
	25	else \
	26	false; \
	27	fi; \
	28	}
19	29	am__make_running_with_option = \
20	30	case $${target_option-} in \
21	31	?) ;; \

88	98	@OLD_LIB_NAMES_FALSE@ $(top_builddir)/lib/libTECkit.la \
89	99	@OLD_LIB_NAMES_FALSE@ $(noinst_LIBRARIES)
90	100	subdir = bin
91		DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
92		$(top_srcdir)/depcomp
93	101	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
94	102	am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
95	103	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \

98	106	$(top_srcdir)/zlib-1.2.3/zlib.ac $(top_srcdir)/configure.ac
99	107	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
100	108	$(ACLOCAL_M4)
	109	DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
101	110	mkinstalldirs = $(install_sh) -d
102	111	CONFIG_HEADER = $(top_builddir)/config.h
103	112	CONFIG_CLEAN_FILES =

124	133	am__installdirs = "$(DESTDIR)$(bindir)"
125	134	PROGRAMS = $(bin_PROGRAMS)
126	135	am_sfconv_OBJECTS = @top_builddir@/SFconv/sfconv-SFconv.$(OBJEXT) \
127		@top_builddir@/SFconv/sfconv-ConvertUTF.$(OBJEXT)
	136	@top_builddir@/SFconv/sfconv-UtfCodec.$(OBJEXT)
128	137	sfconv_OBJECTS = $(am_sfconv_OBJECTS)
129	138	AM_V_lt = $(am__v_lt_@AM_V@)
130	139	am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
131	140	am__v_lt_0 = --silent
132	141	am__v_lt_1 =
133	142	sfconv_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
134		$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	143	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(sfconv_CXXFLAGS) \
135	144	$(CXXFLAGS) $(sfconv_LDFLAGS) $(LDFLAGS) -o $@
136	145	am_teckit_compile_OBJECTS = \
137	146	@top_builddir@/source/Sample-tools/TECkit_Compile.$(OBJEXT)

226	235	done \| $(am__uniquify_input)`
227	236	ETAGS = etags
228	237	CTAGS = ctags
	238	am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp
229	239	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
230	240	ACLOCAL = @ACLOCAL@
231	241	AMTAR = @AMTAR@

271	281	LIPO = @LIPO@
272	282	LN_S = @LN_S@
273	283	LTLIBOBJS = @LTLIBOBJS@
	284	LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
274	285	MAINT = @MAINT@
275	286	MAKEINFO = @MAKEINFO@
276	287	MANIFEST_TOOL = @MANIFEST_TOOL@

346	357	prefix = @prefix@
347	358	program_transform_name = @program_transform_name@
348	359	psdir = @psdir@
	360	runstatedir = @runstatedir@
349	361	sbindir = @sbindir@
350	362	sharedstatedir = @sharedstatedir@
351	363	srcdir = @srcdir@

376	388	teckit_compile_SOURCES = @top_builddir@/source/Sample-tools/TECkit_Compile.cpp
377	389	txtconv_SOURCES = @top_builddir@/source/Sample-tools/TxtConv.cpp
378	390	sfconv_SOURCES = @top_builddir@/SFconv/SFconv.cpp \
379		@top_builddir@/SFconv/ConvertUTF.c \
	391	@top_builddir@/SFconv/UtfCodec.cpp \
380	392	@top_builddir@/SFconv/sfReader.h \
381		@top_builddir@/SFconv/ConvertUTF.h \
	393	@top_builddir@/SFconv/UtfCodec.h \
382	394	@top_builddir@/SFconv/Debug_Prefix.h \
383	395	@top_builddir@/SFconv/Final_Prefix.h \
384	396	@top_builddir@/SFconv/ushort_chartraits.h
385	397	sfconv_CPPFLAGS = $(AM_CPPFLAGS) $(EXPAT_CFLAGS)
	398	sfconv_CXXFLAGS = -std=c++11
386	399	sfconv_CFLAGS = $(AM_CPPFLAGS) $(EXPAT_CFLAGS)
387	400	@OLD_LIB_NAMES_FALSE@teckit_compile_LDADD = $(top_builddir)/lib/libTECkit_Compiler.la
388	401	@OLD_LIB_NAMES_TRUE@teckit_compile_LDADD = $(top_builddir)/lib/TECkit_Compiler_x86.la

416	429	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign bin/Makefile'; \
417	430	$(am__cd) $(top_srcdir) && \
418	431	$(AUTOMAKE) --foreign bin/Makefile
419		.PRECIOUS: Makefile
420	432	Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
421	433	@case '$?' in \
422	434	config.status) \

524	536	@top_builddir@/SFconv/sfconv-SFconv.$(OBJEXT): \
525	537	@top_builddir@/SFconv/$(am__dirstamp) \
526	538	@top_builddir@/SFconv/$(DEPDIR)/$(am__dirstamp)
527		@top_builddir@/SFconv/sfconv-ConvertUTF.$(OBJEXT): \
	539	@top_builddir@/SFconv/sfconv-UtfCodec.$(OBJEXT): \
528	540	@top_builddir@/SFconv/$(am__dirstamp) \
529	541	@top_builddir@/SFconv/$(DEPDIR)/$(am__dirstamp)
530	542

562	574	distclean-compile:
563	575	-rm -f *.tab.c
564	576
565		@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Po@am__quote@
566	577	@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Po@am__quote@
	578	@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Po@am__quote@
567	579	@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/expat/xmlparse/$(DEPDIR)/libexpat_a-hashtable.Po@am__quote@
568	580	@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/expat/xmlparse/$(DEPDIR)/libexpat_a-xmlparse.Po@am__quote@
569	581	@AMDEP_TRUE@@am__include@ @am__quote@@top_builddir@/SFconv/expat/xmltok/$(DEPDIR)/libexpat_a-xmlrole.Po@am__quote@

650	662	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='@top_builddir@/SFconv/expat/xmltok/xmltok.c' object='@top_builddir@/SFconv/expat/xmltok/libexpat_a-xmltok.obj' libtool=no @AMDEPBACKSLASH@
651	663	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
652	664	@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libexpat_a_CFLAGS) $(CFLAGS) -c -o @top_builddir@/SFconv/expat/xmltok/libexpat_a-xmltok.obj `if test -f '@top_builddir@/SFconv/expat/xmltok/xmltok.c'; then $(CYGPATH_W) '@top_builddir@/SFconv/expat/xmltok/xmltok.c'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/expat/xmltok/xmltok.c'; fi`
653
654		@top_builddir@/SFconv/sfconv-ConvertUTF.o: @top_builddir@/SFconv/ConvertUTF.c
655		@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CFLAGS) $(CFLAGS) -MT @top_builddir@/SFconv/sfconv-ConvertUTF.o -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Tpo -c -o @top_builddir@/SFconv/sfconv-ConvertUTF.o `test -f '@top_builddir@/SFconv/ConvertUTF.c' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/ConvertUTF.c
656		@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Po
657		@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='@top_builddir@/SFconv/ConvertUTF.c' object='@top_builddir@/SFconv/sfconv-ConvertUTF.o' libtool=no @AMDEPBACKSLASH@
658		@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
659		@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CFLAGS) $(CFLAGS) -c -o @top_builddir@/SFconv/sfconv-ConvertUTF.o `test -f '@top_builddir@/SFconv/ConvertUTF.c' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/ConvertUTF.c
660
661		@top_builddir@/SFconv/sfconv-ConvertUTF.obj: @top_builddir@/SFconv/ConvertUTF.c
662		@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CFLAGS) $(CFLAGS) -MT @top_builddir@/SFconv/sfconv-ConvertUTF.obj -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Tpo -c -o @top_builddir@/SFconv/sfconv-ConvertUTF.obj `if test -f '@top_builddir@/SFconv/ConvertUTF.c'; then $(CYGPATH_W) '@top_builddir@/SFconv/ConvertUTF.c'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/ConvertUTF.c'; fi`
663		@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-ConvertUTF.Po
664		@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='@top_builddir@/SFconv/ConvertUTF.c' object='@top_builddir@/SFconv/sfconv-ConvertUTF.obj' libtool=no @AMDEPBACKSLASH@
665		@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
666		@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CFLAGS) $(CFLAGS) -c -o @top_builddir@/SFconv/sfconv-ConvertUTF.obj `if test -f '@top_builddir@/SFconv/ConvertUTF.c'; then $(CYGPATH_W) '@top_builddir@/SFconv/ConvertUTF.c'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/ConvertUTF.c'; fi`
667	665
668	666	.cpp.o:
669	667	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\

690	688	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
691	689
692	690	@top_builddir@/SFconv/sfconv-SFconv.o: @top_builddir@/SFconv/SFconv.cpp
693		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-SFconv.o -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo -c -o @top_builddir@/SFconv/sfconv-SFconv.o `test -f '@top_builddir@/SFconv/SFconv.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/SFconv.cpp
	691	@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-SFconv.o -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo -c -o @top_builddir@/SFconv/sfconv-SFconv.o `test -f '@top_builddir@/SFconv/SFconv.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/SFconv.cpp
694	692	@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Po
695	693	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='@top_builddir@/SFconv/SFconv.cpp' object='@top_builddir@/SFconv/sfconv-SFconv.o' libtool=no @AMDEPBACKSLASH@
696	694	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
697		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-SFconv.o `test -f '@top_builddir@/SFconv/SFconv.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/SFconv.cpp
	695	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-SFconv.o `test -f '@top_builddir@/SFconv/SFconv.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/SFconv.cpp
698	696
699	697	@top_builddir@/SFconv/sfconv-SFconv.obj: @top_builddir@/SFconv/SFconv.cpp
700		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-SFconv.obj -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo -c -o @top_builddir@/SFconv/sfconv-SFconv.obj `if test -f '@top_builddir@/SFconv/SFconv.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/SFconv.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/SFconv.cpp'; fi`
	698	@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-SFconv.obj -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo -c -o @top_builddir@/SFconv/sfconv-SFconv.obj `if test -f '@top_builddir@/SFconv/SFconv.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/SFconv.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/SFconv.cpp'; fi`
701	699	@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-SFconv.Po
702	700	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='@top_builddir@/SFconv/SFconv.cpp' object='@top_builddir@/SFconv/sfconv-SFconv.obj' libtool=no @AMDEPBACKSLASH@
703	701	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
704		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-SFconv.obj `if test -f '@top_builddir@/SFconv/SFconv.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/SFconv.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/SFconv.cpp'; fi`
	702	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-SFconv.obj `if test -f '@top_builddir@/SFconv/SFconv.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/SFconv.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/SFconv.cpp'; fi`
	703
	704	@top_builddir@/SFconv/sfconv-UtfCodec.o: @top_builddir@/SFconv/UtfCodec.cpp
	705	@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-UtfCodec.o -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Tpo -c -o @top_builddir@/SFconv/sfconv-UtfCodec.o `test -f '@top_builddir@/SFconv/UtfCodec.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/UtfCodec.cpp
	706	@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Po
	707	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='@top_builddir@/SFconv/UtfCodec.cpp' object='@top_builddir@/SFconv/sfconv-UtfCodec.o' libtool=no @AMDEPBACKSLASH@
	708	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
	709	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-UtfCodec.o `test -f '@top_builddir@/SFconv/UtfCodec.cpp' \|\| echo '$(srcdir)/'`@top_builddir@/SFconv/UtfCodec.cpp
	710
	711	@top_builddir@/SFconv/sfconv-UtfCodec.obj: @top_builddir@/SFconv/UtfCodec.cpp
	712	@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -MT @top_builddir@/SFconv/sfconv-UtfCodec.obj -MD -MP -MF @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Tpo -c -o @top_builddir@/SFconv/sfconv-UtfCodec.obj `if test -f '@top_builddir@/SFconv/UtfCodec.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/UtfCodec.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/UtfCodec.cpp'; fi`
	713	@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Tpo @top_builddir@/SFconv/$(DEPDIR)/sfconv-UtfCodec.Po
	714	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='@top_builddir@/SFconv/UtfCodec.cpp' object='@top_builddir@/SFconv/sfconv-UtfCodec.obj' libtool=no @AMDEPBACKSLASH@
	715	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
	716	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(sfconv_CPPFLAGS) $(CPPFLAGS) $(sfconv_CXXFLAGS) $(CXXFLAGS) -c -o @top_builddir@/SFconv/sfconv-UtfCodec.obj `if test -f '@top_builddir@/SFconv/UtfCodec.cpp'; then $(CYGPATH_W) '@top_builddir@/SFconv/UtfCodec.cpp'; else $(CYGPATH_W) '$(srcdir)/@top_builddir@/SFconv/UtfCodec.cpp'; fi`
705	717
706	718	mostlyclean-libtool:
707	719	-rm -f *.lo

924	936	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
925	937	tags tags-am uninstall uninstall-am uninstall-binPROGRAMS
926	938
	939	.PRECIOUS: Makefile
	940
927	941	@SYSTEM_EXPAT_FALSE@$(am_libexpat_a_OBJECTS): CFLAGS := $(filter-out -Wextra, $(CFLAGS))
928	942	@OLD_LIB_NAMES_TRUE@TECkit_Compile_ver.o: $(tool_src)/TECkit_Compile_ver.rc
929	943	@OLD_LIB_NAMES_TRUE@ $(RC) $(AM_RCFLAGS) $(RCFLAGS) -o $@ $<

-1

compile less more

2	2
3	3	scriptversion=2012-10-14.11; # UTC
4	4
5		# Copyright (C) 1999-2013 Free Software Foundation, Inc.
	5	# Copyright (C) 1999-2014 Free Software Foundation, Inc.
6	6	# Written by Tom Tromey <tromey@cygnus.com>.
7	7	#
8	8	# This program is free software; you can redistribute it and/or modify

+35

-14

config.guess less more

0	0	#! /bin/sh
1	1	# Attempt to guess a canonical system name.
2		# Copyright 1992-2014 Free Software Foundation, Inc.
3
4		timestamp='2014-03-23'
	2	# Copyright 1992-2015 Free Software Foundation, Inc.
	3
	4	timestamp='2015-08-20'
5	5
6	6	# This file is free software; you can redistribute it and/or modify it
7	7	# under the terms of the GNU General Public License as published by

23	23	# program. This Exception is an additional permission under section 7
24	24	# of the GNU General Public License, version 3 ("GPLv3").
25	25	#
26		# Originally written by Per Bothner.
	26	# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
27	27	#
28	28	# You can get the latest version of this script from:
29	29	# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
30	30	#
31		# Please send patches with a ChangeLog entry to config-patches@gnu.org.
	31	# Please send patches to <config-patches@gnu.org>.
32	32
33	33
34	34	me=`echo "$0" \| sed -e 's,.*/,,'`

49	49	GNU config.guess ($timestamp)
50	50
51	51	Originally written by Per Bothner.
52		Copyright 1992-2014 Free Software Foundation, Inc.
	52	Copyright 1992-2015 Free Software Foundation, Inc.
53	53
54	54	This is free software; see the source for copying conditions. There is NO
55	55	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

167	167	# Note: NetBSD doesn't particularly care about the vendor
168	168	# portion of the name. We always set it to "unknown".
169	169	sysctl="sysctl -n hw.machine_arch"
170		UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null \|\| \
171		/usr/sbin/$sysctl 2>/dev/null \|\| echo unknown)`
	170	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null \|\| \
	171	/sbin/$sysctl 2>/dev/null \|\| \
	172	/usr/sbin/$sysctl 2>/dev/null \|\| \
	173	echo unknown)`
172	174	case "${UNAME_MACHINE_ARCH}" in
173	175	armeb) machine=armeb-unknown ;;
174	176	arm*) machine=arm-unknown ;;
175	177	sh3el) machine=shl-unknown ;;
176	178	sh3eb) machine=sh-unknown ;;
177	179	sh5el) machine=sh5le-unknown ;;
	180	earmv*)
	181	arch=`echo ${UNAME_MACHINE_ARCH} \| sed -e 's,^e$armv[0-9]$.*$,\1,'`
	182	endian=`echo ${UNAME_MACHINE_ARCH} \| sed -ne 's,^.*$eb$$,\1,p'`
	183	machine=${arch}${endian}-unknown
	184	;;
178	185	*) machine=${UNAME_MACHINE_ARCH}-unknown ;;
179	186	esac
180	187	# The Operating System including object format, if it has switched
181	188	# to ELF recently, or will in the future.
182	189	case "${UNAME_MACHINE_ARCH}" in
183		arm\|i386\|m68k\|ns32k\|sh3\|sparc\|vax)
	190	arm\|earm\|i386\|m68k\|ns32k\|sh3*\|sparc\|vax)
184	191	eval $set_cc_for_build
185	192	if echo __ELF__ \| $CC_FOR_BUILD -E - 2>/dev/null \
186	193	\| grep -q __ELF__

196	203	os=netbsd
197	204	;;
198	205	esac
	206	# Determine ABI tags.
	207	case "${UNAME_MACHINE_ARCH}" in
	208	earm*)
	209	expr='s/^earmv[0-9]/-eabi/;s/eb$//'
	210	abi=`echo ${UNAME_MACHINE_ARCH} \| sed -e "$expr"`
	211	;;
	212	esac
199	213	# The OS release
200	214	# Debian GNU/NetBSD machines have a different userland, and
201	215	# thus, need a distinct triplet. However, they do not need

206	220	release='-gnu'
207	221	;;
208	222	*)
209		release=`echo ${UNAME_RELEASE}\|sed -e 's/[-_].*/\./'`
	223	release=`echo ${UNAME_RELEASE} \| sed -e 's/[-_].*//' \| cut -d. -f1,2`
210	224	;;
211	225	esac
212	226	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
213	227	# contains redundant information, the shorter form:
214	228	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
215		echo "${machine}-${os}${release}"
	229	echo "${machine}-${os}${release}${abi}"
216	230	exit ;;
217	231	:Bitrig::*)
218	232	UNAME_MACHINE_ARCH=`arch \| sed 's/Bitrig.//'`

233	247	exit ;;
234	248	:MirBSD::*)
235	249	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
	250	exit ;;
	251	:Sortix::*)
	252	echo ${UNAME_MACHINE}-unknown-sortix
236	253	exit ;;
237	254	alpha:OSF1::)
238	255	case $UNAME_RELEASE in

578	595	else
579	596	IBM_ARCH=powerpc
580	597	fi
581		if [ -x /usr/bin/oslevel ] ; then
582		IBM_REV=`/usr/bin/oslevel`
	598	if [ -x /usr/bin/lslpp ] ; then
	599	IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc \|
	600	awk -F: '{ print $3 }' \| sed s/[0-9]*$/0/`
583	601	else
584	602	IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
585	603	fi

931	949	crisv32:Linux::)
932	950	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
933	951	exit ;;
	952	e2k:Linux::)
	953	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	954	exit ;;
934	955	frv:Linux::)
935	956	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
936	957	exit ;;

1019	1040	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
1020	1041	exit ;;
1021	1042	x86_64:Linux::)
1022		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1043	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
1023	1044	exit ;;
1024	1045	xtensa:Linux::*)
1025	1046	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}

-2

config.h.in less more

41	41	/* Define to 1 if you have the <zlib.h> header file. */
42	42	#undef HAVE_ZLIB_H
43	43
44		/* Define to the sub-directory in which libtool stores uninstalled libraries.
45		*/
	44	/* Define to the sub-directory where libtool stores uninstalled libraries. */
46	45	#undef LT_OBJDIR
47	46
48	47	/* Name of package */

+26

-12

config.sub less more

0	0	#! /bin/sh
1	1	# Configuration validation subroutine script.
2		# Copyright 1992-2014 Free Software Foundation, Inc.
3
4		timestamp='2014-09-11'
	2	# Copyright 1992-2015 Free Software Foundation, Inc.
	3
	4	timestamp='2015-08-20'
5	5
6	6	# This file is free software; you can redistribute it and/or modify it
7	7	# under the terms of the GNU General Public License as published by

24	24	# of the GNU General Public License, version 3 ("GPLv3").
25	25
26	26
27		# Please send patches with a ChangeLog entry to config-patches@gnu.org.
	27	# Please send patches to <config-patches@gnu.org>.
28	28	#
29	29	# Configuration subroutine to validate and canonicalize a configuration type.
30	30	# Supply the specified configuration type as an argument.

67	67	version="\
68	68	GNU config.sub ($timestamp)
69	69
70		Copyright 1992-2014 Free Software Foundation, Inc.
	70	Copyright 1992-2015 Free Software Foundation, Inc.
71	71
72	72	This is free software; see the source for copying conditions. There is NO
73	73	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

116	116	case $maybe_os in
117	117	nto-qnx* \| linux-gnu* \| linux-android* \| linux-dietlibc \| linux-newlib* \| \
118	118	linux-musl* \| linux-uclibc* \| uclinux-uclibc* \| uclinux-gnu* \| kfreebsd-gnu \| \
119		knetbsd-gnu \| netbsd-gnu \| \
	119	knetbsd-gnu \| netbsd-gnu \| netbsd-eabi \| \
120	120	kopensolaris-gnu \| \
121	121	storm-chaos* \| os2-emx* \| rtmk-nova*)
122	122	os=-$maybe_os

254	254	\| arc \| arceb \
255	255	\| arm \| arm[bl]e \| arme[lb] \| armv[2-8] \| armv[3-8][lb] \| armv7[arm] \
256	256	\| avr \| avr32 \
	257	\| ba \
257	258	\| be32 \| be64 \
258	259	\| bfin \
259	260	\| c4x \| c8051 \| clipper \
260	261	\| d10v \| d30v \| dlx \| dsp16xx \
261		\| epiphany \
262		\| fido \| fr30 \| frv \
	262	\| e2k \| epiphany \
	263	\| fido \| fr30 \| frv \| ft32 \
263	264	\| h8300 \| h8500 \| hppa \| hppa1.[01] \| hppa2.0 \| hppa2.0[nw] \| hppa64 \
264	265	\| hexagon \
265	266	\| i370 \| i860 \| i960 \| ia64 \

304	305	\| riscv32 \| riscv64 \
305	306	\| rl78 \| rx \
306	307	\| score \
307		\| sh \| sh[1234] \| sh[24]a \| sh[24]aeb \| sh[23]e \| sh[34]eb \| sheb \| shbe \| shle \| sh[1234]le \| sh3ele \
	308	\| sh \| sh[1234] \| sh[24]a \| sh[24]aeb \| sh[23]e \| sh[234]eb \| sheb \| shbe \| shle \| sh[1234]le \| sh3ele \
308	309	\| sh64 \| sh64le \
309	310	\| sparc \| sparc64 \| sparc64b \| sparc64v \| sparc86x \| sparclet \| sparclite \
310	311	\| sparcv8 \| sparcv9 \| sparcv9b \| sparcv9v \

312	313	\| tahoe \| tic4x \| tic54x \| tic55x \| tic6x \| tic80 \| tron \
313	314	\| ubicom32 \
314	315	\| v850 \| v850e \| v850e1 \| v850e2 \| v850es \| v850e2v3 \
	316	\| visium \
315	317	\| we32k \
316	318	\| x86 \| xc16x \| xstormy16 \| xtensa \
317	319	\| z8k \| z80)

325	327	;;
326	328	c6x)
327	329	basic_machine=tic6x-unknown
	330	;;
	331	leon\|leon[3-9])
	332	basic_machine=sparc-$basic_machine
328	333	;;
329	334	m6811 \| m68hc11 \| m6812 \| m68hc12 \| m68hcs12x \| nvptx \| picochip)
330	335	basic_machine=$basic_machine-unknown

371	376	\| alphapca5[67]-* \| alpha64pca5[67]-* \| arc-* \| arceb-* \
372	377	\| arm-* \| armbe-* \| armle-* \| armeb-* \| armv- \
373	378	\| avr-* \| avr32-* \
	379	\| ba-* \
374	380	\| be32-* \| be64-* \
375	381	\| bfin-* \| bs2000-* \
376	382	\| c[123]* \| c30-* \| [cjt]90-* \| c4x-* \
377	383	\| c8051-* \| clipper-* \| craynv-* \| cydra-* \
378	384	\| d10v-* \| d30v-* \| dlx-* \
379		\| elxsi-* \
	385	\| e2k-* \| elxsi-* \
380	386	\| f30[01]-* \| f700-* \| fido-* \| fr30-* \| frv-* \| fx80-* \
381	387	\| h8300-* \| h8500-* \
382	388	\| hppa-* \| hppa1.[01]-* \| hppa2.0-* \| hppa2.0[nw]-* \| hppa64-* \

423	429	\| pdp10-* \| pdp11-* \| pj-* \| pjl-* \| pn-* \| power-* \
424	430	\| powerpc-* \| powerpc64-* \| powerpc64le-* \| powerpcle-* \
425	431	\| pyramid-* \
	432	\| riscv32-* \| riscv64-* \
426	433	\| rl78-* \| romp-* \| rs6000-* \| rx-* \
427	434	\| sh-* \| sh[1234]-* \| sh[24]a-* \| sh[24]aeb-* \| sh[23]e-* \| sh[34]eb-* \| sheb-* \| shbe-* \
428	435	\| shle-* \| sh[1234]le-* \| sh3ele-* \| sh64-* \| sh64le-* \
429	436	\| sparc-* \| sparc64-* \| sparc64b-* \| sparc64v-* \| sparc86x-* \| sparclet-* \
430	437	\| sparclite-* \
431		\| sparcv8-* \| sparcv9-* \| sparcv9b-* \| sparcv9v-* \| sv1-* \| sx?-* \
	438	\| sparcv8-* \| sparcv9-* \| sparcv9b-* \| sparcv9v-* \| sv1-* \| sx- \
432	439	\| tahoe-* \
433	440	\| tic30-* \| tic4x-* \| tic54x-* \| tic55x-* \| tic6x-* \| tic80-* \
434	441	\| tile- \

436	443	\| ubicom32-* \
437	444	\| v850-* \| v850e-* \| v850e1-* \| v850es-* \| v850e2-* \| v850e2v3-* \
438	445	\| vax-* \
	446	\| visium-* \
439	447	\| we32k-* \
440	448	\| x86-* \| x86_64-* \| xc16x-* \| xps100-* \
441	449	\| xstormy16-* \| xtensa- \

511	519	aros)
512	520	basic_machine=i386-pc
513	521	os=-aros
	522	;;
	523	asmjs)
	524	basic_machine=asmjs-unknown
514	525	;;
515	526	aux)
516	527	basic_machine=m68k-apple

772	783	isi68 \| isi)
773	784	basic_machine=m68k-isi
774	785	os=-sysv
	786	;;
	787	leon-\|leon[3-9]-)
	788	basic_machine=sparc-`echo $basic_machine \| sed 's/-.*//'`
775	789	;;
776	790	m68knommu)
777	791	basic_machine=m68k-unknown

1364	1378	\| -hpux* \| -unos* \| -osf* \| -luna* \| -dgux* \| -auroraux* \| -solaris* \
1365	1379	\| -sym* \| -kopensolaris* \| -plan9* \
1366	1380	\| -amigaos* \| -amigados* \| -msdos* \| -newsos* \| -unicos* \| -aof* \
1367		\| -aos* \| -aros* \
	1381	\| -aos* \| -aros* \| -cloudabi* \| -sortix* \
1368	1382	\| -nindy* \| -vxsim* \| -vxworks* \| -ebmon* \| -hms* \| -mvs* \
1369	1383	\| -clix* \| -riscos* \| -uniplus* \| -iris* \| -rtu* \| -xenix* \
1370	1384	\| -hiux* \| -386bsd* \| -knetbsd* \| -mirbsd* \| -netbsd* \

+1897

-1347

configure less more

0	0	#! /bin/sh
1	1	# Guess values for system-dependent variables and create Makefiles.
2		# Generated by GNU Autoconf 2.69 for teckit 2.5.4.
	2	# Generated by GNU Autoconf 2.69 for teckit 2.5.8.
3	3	#
4	4	# Report bugs to <nrsi@sil.org>.
5	5	#

588	588	# Identity of this package.
589	589	PACKAGE_NAME='teckit'
590	590	PACKAGE_TARNAME='teckit'
591		PACKAGE_VERSION='2.5.4'
592		PACKAGE_STRING='teckit 2.5.4'
	591	PACKAGE_VERSION='2.5.8'
	592	PACKAGE_STRING='teckit 2.5.8'
593	593	PACKAGE_BUGREPORT='nrsi@sil.org'
594	594	PACKAGE_URL=''
595	595

649	649	RC
650	650	CXXCPP
651	651	CPP
	652	LT_SYS_LIBRARY_PATH
652	653	OTOOL64
653	654	OTOOL
654	655	LIPO

754	755	docdir
755	756	oldincludedir
756	757	includedir
	758	runstatedir
757	759	localstatedir
758	760	sharedstatedir
759	761	sysconfdir

783	785	enable_static
784	786	with_pic
785	787	enable_fast_install
	788	with_aix_soname
786	789	with_gnu_ld
787	790	with_sysroot
788	791	enable_libtool_lock

807	810	CCC
808	811	CC
809	812	CFLAGS
	813	LT_SYS_LIBRARY_PATH
810	814	CPP
811	815	CXXCPP'
812	816

847	851	sysconfdir='${prefix}/etc'
848	852	sharedstatedir='${prefix}/com'
849	853	localstatedir='${prefix}/var'
	854	runstatedir='${localstatedir}/run'
850	855	includedir='${prefix}/include'
851	856	oldincludedir='/usr/include'
852	857	docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'

1099	1104	\| -silent \| --silent \| --silen \| --sile \| --sil)
1100	1105	silent=yes ;;
1101	1106
	1107	-runstatedir \| --runstatedir \| --runstatedi \| --runstated \
	1108	\| --runstate \| --runstat \| --runsta \| --runst \| --runs \
	1109	\| --run \| --ru \| --r)
	1110	ac_prev=runstatedir ;;
	1111	-runstatedir=* \| --runstatedir=* \| --runstatedi=* \| --runstated=* \
	1112	\| --runstate=* \| --runstat=* \| --runsta=* \| --runst=* \| --runs=* \
	1113	\| --run=* \| --ru=* \| --r=*)
	1114	runstatedir=$ac_optarg ;;
	1115
1102	1116	-sbindir \| --sbindir \| --sbindi \| --sbind \| --sbin \| --sbi \| --sb)
1103	1117	ac_prev=sbindir ;;
1104	1118	-sbindir=* \| --sbindir=* \| --sbindi=* \| --sbind=* \| --sbin=* \

1236	1250	for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
1237	1251	datadir sysconfdir sharedstatedir localstatedir includedir \
1238	1252	oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1239		libdir localedir mandir
	1253	libdir localedir mandir runstatedir
1240	1254	do
1241	1255	eval ac_val=\$$ac_var
1242	1256	# Remove trailing slashes.

1349	1363	# Omit some internal or obsolete options to make the list less imposing.
1350	1364	# This message is too long to be a string in the A/UX 3.1 sh.
1351	1365	cat <<_ACEOF
1352		\`configure' configures teckit 2.5.4 to adapt to many kinds of systems.
	1366	\`configure' configures teckit 2.5.8 to adapt to many kinds of systems.
1353	1367
1354	1368	Usage: $0 [OPTION]... [VAR=VALUE]...
1355	1369

1389	1403	--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
1390	1404	--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
1391	1405	--localstatedir=DIR modifiable single-machine data [PREFIX/var]
	1406	--runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]
1392	1407	--libdir=DIR object code libraries [EPREFIX/lib]
1393	1408	--includedir=DIR C header files [PREFIX/include]
1394	1409	--oldincludedir=DIR C header files for non-gcc [/usr/include]

1420	1435
1421	1436	if test -n "$ac_init_help"; then
1422	1437	case $ac_init_help in
1423		short \| recursive ) echo "Configuration of teckit 2.5.4:";;
	1438	short \| recursive ) echo "Configuration of teckit 2.5.8:";;
1424	1439	esac
1425	1440	cat <<\_ACEOF
1426	1441

1453	1468	--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
1454	1469	--with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use
1455	1470	both]
	1471	--with-aix-soname=aix\|svr4\|both
	1472	shared library versioning (aka "SONAME") variant to
	1473	provide on AIX, [default=aix].
1456	1474	--with-gnu-ld assume the C compiler uses GNU ld [default=no]
1457		--with-sysroot=DIR Search for dependent libraries within DIR
1458		(or the compiler's sysroot if not specified).
	1475	--with-sysroot[=DIR] Search for dependent libraries within DIR (or the
	1476	compiler's sysroot if not specified).
1459	1477	--with-old-lib-names Use old library names (for Windows only)
1460	1478	--without-system-zlib Don't use installed zlib library
1461	1479	--with-zlib-libdir=DIR Specify directory where the zlib library resides.

1471	1489	you have headers in a nonstandard directory <include dir>
1472	1490	CC C compiler command
1473	1491	CFLAGS C compiler flags
	1492	LT_SYS_LIBRARY_PATH
	1493	User-defined run-time library search path.
1474	1494	CPP C preprocessor
1475	1495	CXXCPP C++ preprocessor
1476	1496

1540	1560	test -n "$ac_init_help" && exit $ac_status
1541	1561	if $ac_init_version; then
1542	1562	cat <<\_ACEOF
1543		teckit configure 2.5.4
	1563	teckit configure 2.5.8
1544	1564	generated by GNU Autoconf 2.69
1545	1565
1546	1566	Copyright (C) 2012 Free Software Foundation, Inc.

2030	2050	This file contains any messages produced by compilers while
2031	2051	running configure, to aid debugging if configure makes a mistake.
2032	2052
2033		It was created by teckit $as_me 2.5.4, which was
	2053	It was created by teckit $as_me 2.5.8, which was
2034	2054	generated by GNU Autoconf 2.69. Invocation command line was
2035	2055
2036	2056	$ $0 $@

2522	2542	NONENONEs,x,x, &&
2523	2543	program_prefix=${target_alias}-
2524	2544
2525		am__api_version='1.14'
	2545	am__api_version='1.15'
2526	2546
2527	2547	# Find a good install program. We prefer a C program (faster),
2528	2548	# so one script is as good as another. But avoid the broken or

2714	2734	$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2715	2735	fi
2716	2736
2717		if test x"${install_sh}" != xset; then
	2737	if test x"${install_sh+set}" != xset; then
2718	2738	case $am_aux_dir in
2719	2739	\ \| \ )
2720	2740	install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;

3008	3028
3009	3029	# Define the identity of the package.
3010	3030	PACKAGE='teckit'
3011		VERSION='2.5.4'
	3031	VERSION='2.5.8'
3012	3032
3013	3033
3014	3034	cat >>confdefs.h <<_ACEOF

3042	3062	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
3043	3063	mkdir_p='$(MKDIR_P)'
3044	3064
3045		# We need awk for the "check" target. The system "awk" is bad on
3046		# some platforms.
	3065	# We need awk for the "check" target (and possibly the TAP driver). The
	3066	# system "awk" is bad on some platforms.
3047	3067	# Always define AMTAR for backward compatibility. Yes, it's still used
3048	3068	# in the wild :-( We should find a proper way to deprecate it ...
3049	3069	AMTAR='$${TAR-tar}'

4600	4620
4601	4621
4602	4622
4603		macro_version='2.4.2'
4604		macro_revision='1.3337'
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
4617
4618		ltmain="$ac_aux_dir/ltmain.sh"
	4623	macro_version='2.4.6'
	4624	macro_revision='2.4.6'
	4625
	4626
	4627
	4628
	4629
	4630
	4631
	4632
	4633
	4634
	4635
	4636
	4637
	4638	ltmain=$ac_aux_dir/ltmain.sh
4619	4639
4620	4640	# Backslashify metacharacters that are still active within
4621	4641	# double-quoted strings.

4664	4684	$ECHO ""
4665	4685	}
4666	4686
4667		case "$ECHO" in
	4687	case $ECHO in
4668	4688	printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
4669	4689	$as_echo "printf" >&6; } ;;
4670	4690	print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5

4987	5007
4988	5008	# Check whether --with-gnu-ld was given.
4989	5009	if test "${with_gnu_ld+set}" = set; then :
4990		withval=$with_gnu_ld; test "$withval" = no \|\| with_gnu_ld=yes
	5010	withval=$with_gnu_ld; test no = "$withval" \|\| with_gnu_ld=yes
4991	5011	else
4992	5012	with_gnu_ld=no
4993	5013	fi
4994	5014
4995	5015	ac_prog=ld
4996		if test "$GCC" = yes; then
	5016	if test yes = "$GCC"; then
4997	5017	# Check if gcc -print-prog-name=ld gives a path.
4998	5018	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
4999	5019	$as_echo_n "checking for ld used by $CC... " >&6; }
5000	5020	case $host in
5001	5021	--mingw*)
5002		# gcc leaves a trailing carriage return which upsets mingw
	5022	# gcc leaves a trailing carriage return, which upsets mingw
5003	5023	ac_prog=`($CC -print-prog-name=ld) 2>&5 \| tr -d '\015'` ;;
5004	5024	*)
5005	5025	ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

5013	5033	while $ECHO "$ac_prog" \| $GREP "$re_direlt" > /dev/null 2>&1; do
5014	5034	ac_prog=`$ECHO $ac_prog\| $SED "s%$re_direlt%/%"`
5015	5035	done
5016		test -z "$LD" && LD="$ac_prog"
	5036	test -z "$LD" && LD=$ac_prog
5017	5037	;;
5018	5038	"")
5019	5039	# If it fails, then pretend we aren't using GCC.

5024	5044	with_gnu_ld=unknown
5025	5045	;;
5026	5046	esac
5027		elif test "$with_gnu_ld" = yes; then
	5047	elif test yes = "$with_gnu_ld"; then
5028	5048	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
5029	5049	$as_echo_n "checking for GNU ld... " >&6; }
5030	5050	else

5035	5055	$as_echo_n "(cached) " >&6
5036	5056	else
5037	5057	if test -z "$LD"; then
5038		lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
	5058	lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
5039	5059	for ac_dir in $PATH; do
5040		IFS="$lt_save_ifs"
	5060	IFS=$lt_save_ifs
5041	5061	test -z "$ac_dir" && ac_dir=.
5042	5062	if test -f "$ac_dir/$ac_prog" \|\| test -f "$ac_dir/$ac_prog$ac_exeext"; then
5043		lt_cv_path_LD="$ac_dir/$ac_prog"
	5063	lt_cv_path_LD=$ac_dir/$ac_prog
5044	5064	# Check to see if the program is GNU ld. I'd rather use --version,
5045	5065	# but apparently some variants of GNU ld only accept -v.
5046	5066	# Break only if it was the GNU/non-GNU ld that we prefer.
5047	5067	case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
5048	5068	GNU \| 'with BFD')
5049		test "$with_gnu_ld" != no && break
	5069	test no != "$with_gnu_ld" && break
5050	5070	;;
5051	5071	*)
5052		test "$with_gnu_ld" != yes && break
	5072	test yes != "$with_gnu_ld" && break
5053	5073	;;
5054	5074	esac
5055	5075	fi
5056	5076	done
5057		IFS="$lt_save_ifs"
5058		else
5059		lt_cv_path_LD="$LD" # Let the user override the test with a path.
5060		fi
5061		fi
5062
5063		LD="$lt_cv_path_LD"
	5077	IFS=$lt_save_ifs
	5078	else
	5079	lt_cv_path_LD=$LD # Let the user override the test with a path.
	5080	fi
	5081	fi
	5082
	5083	LD=$lt_cv_path_LD
5064	5084	if test -n "$LD"; then
5065	5085	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
5066	5086	$as_echo "$LD" >&6; }

5103	5123	else
5104	5124	if test -n "$NM"; then
5105	5125	# Let the user override the test.
5106		lt_cv_path_NM="$NM"
5107		else
5108		lt_nm_to_check="${ac_tool_prefix}nm"
	5126	lt_cv_path_NM=$NM
	5127	else
	5128	lt_nm_to_check=${ac_tool_prefix}nm
5109	5129	if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
5110	5130	lt_nm_to_check="$lt_nm_to_check nm"
5111	5131	fi
5112	5132	for lt_tmp_nm in $lt_nm_to_check; do
5113		lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
	5133	lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
5114	5134	for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
5115		IFS="$lt_save_ifs"
	5135	IFS=$lt_save_ifs
5116	5136	test -z "$ac_dir" && ac_dir=.
5117		tmp_nm="$ac_dir/$lt_tmp_nm"
5118		if test -f "$tmp_nm" \|\| test -f "$tmp_nm$ac_exeext" ; then
	5137	tmp_nm=$ac_dir/$lt_tmp_nm
	5138	if test -f "$tmp_nm" \|\| test -f "$tmp_nm$ac_exeext"; then
5119	5139	# Check to see if the nm accepts a BSD-compat flag.
5120		# Adding the `sed 1q' prevents false positives on HP-UX, which says:
	5140	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
5121	5141	# nm: unknown option "B" ignored
5122	5142	# Tru64's nm complains that /dev/null is an invalid object file
5123		case `"$tmp_nm" -B /dev/null 2>&1 \| sed '1q'` in
5124		/dev/null \| 'Invalid file or object type')
	5143	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
	5144	case $build_os in
	5145	mingw*) lt_bad_file=conftest.nm/nofile ;;
	5146	*) lt_bad_file=/dev/null ;;
	5147	esac
	5148	case `"$tmp_nm" -B $lt_bad_file 2>&1 \| sed '1q'` in
	5149	$lt_bad_file \| 'Invalid file or object type')
5125	5150	lt_cv_path_NM="$tmp_nm -B"
5126		break
	5151	break 2
5127	5152	;;
5128	5153	*)
5129	5154	case `"$tmp_nm" -p /dev/null 2>&1 \| sed '1q'` in
5130	5155	/dev/null)
5131	5156	lt_cv_path_NM="$tmp_nm -p"
5132		break
	5157	break 2
5133	5158	;;
5134	5159	*)
5135	5160	lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

5140	5165	esac
5141	5166	fi
5142	5167	done
5143		IFS="$lt_save_ifs"
	5168	IFS=$lt_save_ifs
5144	5169	done
5145	5170	: ${lt_cv_path_NM=no}
5146	5171	fi
5147	5172	fi
5148	5173	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
5149	5174	$as_echo "$lt_cv_path_NM" >&6; }
5150		if test "$lt_cv_path_NM" != "no"; then
5151		NM="$lt_cv_path_NM"
	5175	if test no != "$lt_cv_path_NM"; then
	5176	NM=$lt_cv_path_NM
5152	5177	else
5153	5178	# Didn't find any BSD compatible name lister, look for dumpbin.
5154	5179	if test -n "$DUMPBIN"; then :

5254	5279	fi
5255	5280	fi
5256	5281
5257		case `$DUMPBIN -symbols /dev/null 2>&1 \| sed '1q'` in
	5282	case `$DUMPBIN -symbols -headers /dev/null 2>&1 \| sed '1q'` in
5258	5283	COFF)
5259		DUMPBIN="$DUMPBIN -symbols"
	5284	DUMPBIN="$DUMPBIN -symbols -headers"
5260	5285	;;
5261	5286	*)
5262	5287	DUMPBIN=:

5264	5289	esac
5265	5290	fi
5266	5291
5267		if test "$DUMPBIN" != ":"; then
5268		NM="$DUMPBIN"
	5292	if test : != "$DUMPBIN"; then
	5293	NM=$DUMPBIN
5269	5294	fi
5270	5295	fi
5271	5296	test -z "$NM" && NM=nm

5316	5341	$as_echo_n "(cached) " >&6
5317	5342	else
5318	5343	i=0
5319		teststring="ABCD"
	5344	teststring=ABCD
5320	5345
5321	5346	case $build_os in
5322	5347	msdosdjgpp*)

5356	5381	lt_cv_sys_max_cmd_len=8192;
5357	5382	;;
5358	5383
5359		netbsd* \| freebsd* \| openbsd* \| darwin* \| dragonfly*)
	5384	bitrig* \| darwin* \| dragonfly* \| freebsd* \| netbsd* \| openbsd*)
5360	5385	# This has been around since 386BSD, at least. Likely further.
5361	5386	if test -x /sbin/sysctl; then
5362	5387	lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`

5407	5432	*)
5408	5433	lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
5409	5434	if test -n "$lt_cv_sys_max_cmd_len" && \
5410		test undefined != "$lt_cv_sys_max_cmd_len"; then
	5435	test undefined != "$lt_cv_sys_max_cmd_len"; then
5411	5436	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
5412	5437	lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
5413	5438	else
5414	5439	# Make teststring a little bigger before we do anything with it.
5415	5440	# a 1K string should be a reasonable start.
5416		for i in 1 2 3 4 5 6 7 8 ; do
	5441	for i in 1 2 3 4 5 6 7 8; do
5417	5442	teststring=$teststring$teststring
5418	5443	done
5419	5444	SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
5420	5445	# If test is not a shell built-in, we'll probably end up computing a
5421	5446	# maximum length that is only half of the actual maximum length, but
5422	5447	# we can't tell.
5423		while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
	5448	while { test X`env echo "$teststring$teststring" 2>/dev/null` \
5424	5449	= "X$teststring$teststring"; } >/dev/null 2>&1 &&
5425		test $i != 17 # 1/2 MB should be enough
	5450	test 17 != "$i" # 1/2 MB should be enough
5426	5451	do
5427	5452	i=`expr $i + 1`
5428	5453	teststring=$teststring$teststring

5440	5465
5441	5466	fi
5442	5467
5443		if test -n $lt_cv_sys_max_cmd_len ; then
	5468	if test -n "$lt_cv_sys_max_cmd_len"; then
5444	5469	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
5445	5470	$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
5446	5471	else

5457	5482	: ${CP="cp -f"}
5458	5483	: ${MV="mv -f"}
5459	5484	: ${RM="rm -f"}
5460
5461		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
5462		$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
5463		# Try some XSI features
5464		xsi_shell=no
5465		( _lt_dummy="a/b/c"
5466		test "${_lt_dummy##/},${_lt_dummy%/},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
5467		= c,a/b,b/c, \
5468		&& eval 'test $(( 1 + 1 )) -eq 2 \
5469		&& test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
5470		&& xsi_shell=yes
5471		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
5472		$as_echo "$xsi_shell" >&6; }
5473
5474
5475		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
5476		$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
5477		lt_shell_append=no
5478		( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
5479		>/dev/null 2>&1 \
5480		&& lt_shell_append=yes
5481		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
5482		$as_echo "$lt_shell_append" >&6; }
5483
5484	5485
5485	5486	if ( (MAIL=60; unset MAIL) \|\| exit) >/dev/null 2>&1; then
5486	5487	lt_unset=unset

5604	5605	reload_cmds='$LD$reload_flag -o $output$reload_objs'
5605	5606	case $host_os in
5606	5607	cygwin* \| mingw* \| pw32* \| cegcc*)
5607		if test "$GCC" != yes; then
	5608	if test yes != "$GCC"; then
5608	5609	reload_cmds=false
5609	5610	fi
5610	5611	;;
5611	5612	darwin*)
5612		if test "$GCC" = yes; then
5613		reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
	5613	if test yes = "$GCC"; then
	5614	reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
5614	5615	else
5615	5616	reload_cmds='$LD$reload_flag -o $output$reload_objs'
5616	5617	fi

5738	5739	# Need to set the preceding variable on all platforms that support
5739	5740	# interlibrary dependencies.
5740	5741	# 'none' -- dependencies not supported.
5741		# `unknown' -- same as none, but documents that we really don't know.
	5742	# 'unknown' -- same as none, but documents that we really don't know.
5742	5743	# 'pass_all' -- all dependencies passed with no checks.
5743	5744	# 'test_compile' -- check by making test program.
5744	5745	# 'file_magic [[regex]]' -- check by looking for files in library path
5745		# which responds to the $file_magic_cmd with a given extended regex.
5746		# If you have `file' or equivalent on your system and you're not sure
5747		# whether `pass_all' will always work, you probably want this one.
	5746	# that responds to the $file_magic_cmd with a given extended regex.
	5747	# If you have 'file' or equivalent on your system and you're not sure
	5748	# whether 'pass_all' will always work, you probably want this one.
5748	5749
5749	5750	case $host_os in
5750	5751	aix[4-9]*)

5771	5772	# Base MSYS/MinGW do not provide the 'file' command needed by
5772	5773	# func_win32_libid shell function, so use a weaker test based on 'objdump',
5773	5774	# unless we find 'file', for example because we are cross-compiling.
5774		# func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
5775		if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
	5775	if ( file / ) >/dev/null 2>&1; then
5776	5776	lt_cv_deplibs_check_method='file_magic ^x86 archive import\|^x86 DLL'
5777	5777	lt_cv_file_magic_cmd='func_win32_libid'
5778	5778	else

5868	5868	lt_cv_deplibs_check_method=pass_all
5869	5869	;;
5870	5870
5871		openbsd*)
5872		if test -z "`echo __ELF__ \| $CC -E - \| $GREP __ELF__`" \|\| test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
	5871	openbsd* \| bitrig*)
	5872	if test -z "`echo __ELF__ \| $CC -E - \| $GREP __ELF__`"; then
5873	5873	lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+\|\.so\|_pic\.a)$'
5874	5874	else
5875	5875	lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+\|_pic\.a)$'

5922	5922	tpf*)
5923	5923	lt_cv_deplibs_check_method=pass_all
5924	5924	;;
	5925	os2*)
	5926	lt_cv_deplibs_check_method=pass_all
	5927	;;
5925	5928	esac
5926	5929
5927	5930	fi

6079	6082
6080	6083	case $host_os in
6081	6084	cygwin* \| mingw* \| pw32* \| cegcc*)
6082		# two different shell functions defined in ltmain.sh
6083		# decide which to use based on capabilities of $DLLTOOL
	6085	# two different shell functions defined in ltmain.sh;
	6086	# decide which one to use based on capabilities of $DLLTOOL
6084	6087	case `$DLLTOOL --help 2>&1` in
6085	6088	--identify-strict)
6086	6089	lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib

6092	6095	;;
6093	6096	*)
6094	6097	# fallback: assume linklib IS sharedlib
6095		lt_cv_sharedlib_from_linklib_cmd="$ECHO"
	6098	lt_cv_sharedlib_from_linklib_cmd=$ECHO
6096	6099	;;
6097	6100	esac
6098	6101

6247	6250	ac_status=$?
6248	6251	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6249	6252	test $ac_status = 0; }
6250		if test "$ac_status" -eq 0; then
	6253	if test 0 -eq "$ac_status"; then
6251	6254	# Ensure the archiver fails upon bogus file names.
6252	6255	rm -f conftest.$ac_objext libconftest.a
6253	6256	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5

6255	6258	ac_status=$?
6256	6259	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6257	6260	test $ac_status = 0; }
6258		if test "$ac_status" -ne 0; then
	6261	if test 0 -ne "$ac_status"; then
6259	6262	lt_cv_ar_at_file=@
6260	6263	fi
6261	6264	fi

6268	6271	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
6269	6272	$as_echo "$lt_cv_ar_at_file" >&6; }
6270	6273
6271		if test "x$lt_cv_ar_at_file" = xno; then
	6274	if test no = "$lt_cv_ar_at_file"; then
6272	6275	archiver_list_spec=
6273	6276	else
6274	6277	archiver_list_spec=$lt_cv_ar_at_file

6485	6488
6486	6489	if test -n "$RANLIB"; then
6487	6490	case $host_os in
6488		openbsd*)
	6491	bitrig* \| openbsd*)
6489	6492	old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
6490	6493	;;
6491	6494	*)

6575	6578	symcode='[ABCDGISTW]'
6576	6579	;;
6577	6580	hpux*)
6578		if test "$host_cpu" = ia64; then
	6581	if test ia64 = "$host_cpu"; then
6579	6582	symcode='[ABCDEGRST]'
6580	6583	fi
6581	6584	;;

6608	6611	symcode='[ABCDGIRSTW]' ;;
6609	6612	esac
6610	6613
	6614	if test "$lt_cv_nm_interface" = "MS dumpbin"; then
	6615	# Gets list of data symbols to import.
	6616	lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* $.*$$/\1/p'"
	6617	# Adjust the below global symbol transforms to fixup imported variables.
	6618	lt_cdecl_hook=" -e 's/^I .* $.*$$/extern __declspec(dllimport) char \1;/p'"
	6619	lt_c_name_hook=" -e 's/^I .* $.$$/ {\"\1\", (void ) 0},/p'"
	6620	lt_c_name_lib_hook="\
	6621	-e 's/^I .* $lib.$$/ {\"\1\", (void ) 0},/p'\
	6622	-e 's/^I .* $.$$/ {\"lib\1\", (void ) 0},/p'"
	6623	else
	6624	# Disable hooks by default.
	6625	lt_cv_sys_global_symbol_to_import=
	6626	lt_cdecl_hook=
	6627	lt_c_name_hook=
	6628	lt_c_name_lib_hook=
	6629	fi
	6630
6611	6631	# Transform an extracted symbol line into a proper C declaration.
6612	6632	# Some systems (esp. on ia64) link data and code symbols differently,
6613	6633	# so use this general approach.
6614		lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* $.$$/extern int \1();/p' -e 's/^$symcode .* $.*$$/extern char \1;/p'"
	6634	lt_cv_sys_global_symbol_to_cdecl="sed -n"\
	6635	$lt_cdecl_hook\
	6636	" -e 's/^T .* $.*$$/extern int \1();/p'"\
	6637	" -e 's/^$symcode$symcode* .* $.*$$/extern char \1;/p'"
6615	6638
6616	6639	# Transform an extracted symbol line into symbol name and symbol address
6617		lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: $[^ ]$[ ]$/ {\\\"\1\\\", (void ) 0},/p' -e 's/^$symcode $[^ ]$ $[^ ]$$/ {\"\2\", (void *) \&\2},/p'"
6618		lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: $[^ ]$[ ]$/ {\\\"\1\\\", (void ) 0},/p' -e 's/^$symcode $[^ ]$ $lib[^ ]$$/ {\"\2\", (void ) \&\2},/p' -e 's/^$symcode $[^ ]$ $[^ ]$$/ {\"lib\2\", (void *) \&\2},/p'"
	6640	lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
	6641	$lt_c_name_hook\
	6642	" -e 's/^: $.$ .$/ {\"\1\", (void *) 0},/p'"\
	6643	" -e 's/^$symcode$symcode* .* $.$$/ {\"\1\", (void ) \&\1},/p'"
	6644
	6645	# Transform an extracted symbol line into symbol name with lib prefix and
	6646	# symbol address.
	6647	lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
	6648	$lt_c_name_lib_hook\
	6649	" -e 's/^: $.$ .$/ {\"\1\", (void *) 0},/p'"\
	6650	" -e 's/^$symcode$symcode* .* $lib.$$/ {\"\1\", (void ) \&\1},/p'"\
	6651	" -e 's/^$symcode$symcode* .* $.$$/ {\"lib\1\", (void ) \&\1},/p'"
6619	6652
6620	6653	# Handle CRLF in mingw tool chain
6621	6654	opt_cr=

6633	6666
6634	6667	# Write the raw and C identifiers.
6635	6668	if test "$lt_cv_nm_interface" = "MS dumpbin"; then
6636		# Fake it for dumpbin and say T for any non-static function
6637		# and D for any global variable.
	6669	# Fake it for dumpbin and say T for any non-static function,
	6670	# D for any global variable and I for any imported variable.
6638	6671	# Also find C++ and __fastcall symbols from MSVC++,
6639	6672	# which start with @ or ?.
6640	6673	lt_cv_sys_global_symbol_pipe="$AWK '"\
6641	6674	" {last_section=section; section=\$ 3};"\
6642	6675	" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
6643	6676	" /Section length .#relocs.(pick any)/{hide[last_section]=1};"\
	6677	" /^ Symbol name : /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
	6678	" /^ Type : code/{print \"T\",si,substr(si,length(prfx))};"\
	6679	" /^ Type : data/{print \"I\",si,substr(si,length(prfx))};"\
6644	6680	" \$ 0!~/External *\\|/{next};"\
6645	6681	" / 0+ UNDEF /{next}; / UNDEF $[^\|]$*()/{next};"\
6646	6682	" {if(hide[section]) next};"\
6647		" {f=0}; \$ 0~/.*\\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
6648		" {split(\$ 0, a, /\\|\|\r/); split(a[2], s)};"\
6649		" s[1]~/^[@?]/{print s[1], s[1]; next};"\
6650		" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
	6683	" {f=\"D\"}; \$ 0~/.*\\|/{f=\"T\"};"\
	6684	" {split(\$ 0,a,/\\|\|\r/); split(a[2],s)};"\
	6685	" s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
	6686	" s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
6651	6687	" ' prfx=^$ac_symprfx"
6652	6688	else
6653	6689	lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.[ ]$$symcode$symcode$[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"

6695	6731	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
6696	6732	cat <<_LT_EOF > conftest.$ac_ext
6697	6733	/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
6698		#if defined(_WIN32) \|\| defined(__CYGWIN__) \|\| defined(_WIN32_WCE)
6699		/* DATA imports from DLLs on WIN32 con't be const, because runtime
	6734	#if defined _WIN32 \|\| defined __CYGWIN__ \|\| defined _WIN32_WCE
	6735	/* DATA imports from DLLs on WIN32 can't be const, because runtime
6700	6736	relocations are performed -- see ld's documentation on pseudo-relocs. */
6701	6737	# define LT_DLSYM_CONST
6702		#elif defined(__osf__)
	6738	#elif defined __osf__
6703	6739	/* This system does not cope well with relocations in const data. */
6704	6740	# define LT_DLSYM_CONST
6705	6741	#else

6725	6761	{
6726	6762	{ "@PROGRAM@", (void *) 0 },
6727	6763	_LT_EOF
6728		$SED "s/^$symcode$symcode* $.$ $.$$/ {\"\2\", (void *) \&\2},/" < "$nlist" \| $GREP -v main >> conftest.$ac_ext
	6764	$SED "s/^$symcode$symcode* .* $.$$/ {\"\1\", (void ) \&\1},/" < "$nlist" \| $GREP -v main >> conftest.$ac_ext
6729	6765	cat <<\_LT_EOF >> conftest.$ac_ext
6730	6766	{0, (void *) 0}
6731	6767	};

6745	6781	mv conftest.$ac_objext conftstm.$ac_objext
6746	6782	lt_globsym_save_LIBS=$LIBS
6747	6783	lt_globsym_save_CFLAGS=$CFLAGS
6748		LIBS="conftstm.$ac_objext"
	6784	LIBS=conftstm.$ac_objext
6749	6785	CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
6750	6786	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
6751	6787	(eval $ac_link) 2>&5
6752	6788	ac_status=$?
6753	6789	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6754		test $ac_status = 0; } && test -s conftest${ac_exeext}; then
	6790	test $ac_status = 0; } && test -s conftest$ac_exeext; then
6755	6791	pipe_works=yes
6756	6792	fi
6757	6793	LIBS=$lt_globsym_save_LIBS

6772	6808	rm -rf conftest* conftst*
6773	6809
6774	6810	# Do not use the global_symbol_pipe unless it works.
6775		if test "$pipe_works" = yes; then
	6811	if test yes = "$pipe_works"; then
6776	6812	break
6777	6813	else
6778	6814	lt_cv_sys_global_symbol_pipe=

6825	6861
6826	6862
6827	6863
	6864
	6865
	6866
	6867
	6868
	6869
	6870
	6871
	6872
	6873
6828	6874	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
6829	6875	$as_echo_n "checking for sysroot... " >&6; }
6830	6876

6837	6883
6838	6884
6839	6885	lt_sysroot=
6840		case ${with_sysroot} in #(
	6886	case $with_sysroot in #(
6841	6887	yes)
6842		if test "$GCC" = yes; then
	6888	if test yes = "$GCC"; then
6843	6889	lt_sysroot=`$CC --print-sysroot 2>/dev/null`
6844	6890	fi
6845	6891	;; #(

6849	6895	no\|'')
6850	6896	;; #(
6851	6897	*)
6852		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5
6853		$as_echo "${with_sysroot}" >&6; }
	6898	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
	6899	$as_echo "$with_sysroot" >&6; }
6854	6900	as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
6855	6901	;;
6856	6902	esac

6862	6908
6863	6909
6864	6910
	6911	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
	6912	$as_echo_n "checking for a working dd... " >&6; }
	6913	if ${ac_cv_path_lt_DD+:} false; then :
	6914	$as_echo_n "(cached) " >&6
	6915	else
	6916	printf 0123456789abcdef0123456789abcdef >conftest.i
	6917	cat conftest.i conftest.i >conftest2.i
	6918	: ${lt_DD:=$DD}
	6919	if test -z "$lt_DD"; then
	6920	ac_path_lt_DD_found=false
	6921	# Loop through the user's path and test for each of PROGNAME-LIST
	6922	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
	6923	for as_dir in $PATH
	6924	do
	6925	IFS=$as_save_IFS
	6926	test -z "$as_dir" && as_dir=.
	6927	for ac_prog in dd; do
	6928	for ac_exec_ext in '' $ac_executable_extensions; do
	6929	ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
	6930	as_fn_executable_p "$ac_path_lt_DD" \|\| continue
	6931	if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
	6932	cmp -s conftest.i conftest.out \
	6933	&& ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
	6934	fi
	6935	$ac_path_lt_DD_found && break 3
	6936	done
	6937	done
	6938	done
	6939	IFS=$as_save_IFS
	6940	if test -z "$ac_cv_path_lt_DD"; then
	6941	:
	6942	fi
	6943	else
	6944	ac_cv_path_lt_DD=$lt_DD
	6945	fi
	6946
	6947	rm -f conftest.i conftest2.i conftest.out
	6948	fi
	6949	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
	6950	$as_echo "$ac_cv_path_lt_DD" >&6; }
	6951
	6952
	6953	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
	6954	$as_echo_n "checking how to truncate binary pipes... " >&6; }
	6955	if ${lt_cv_truncate_bin+:} false; then :
	6956	$as_echo_n "(cached) " >&6
	6957	else
	6958	printf 0123456789abcdef0123456789abcdef >conftest.i
	6959	cat conftest.i conftest.i >conftest2.i
	6960	lt_cv_truncate_bin=
	6961	if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
	6962	cmp -s conftest.i conftest.out \
	6963	&& lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
	6964	fi
	6965	rm -f conftest.i conftest2.i conftest.out
	6966	test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
	6967	fi
	6968	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
	6969	$as_echo "$lt_cv_truncate_bin" >&6; }
	6970
	6971
	6972
	6973
	6974
	6975
	6976
	6977	# Calculate cc_basename. Skip known compiler wrappers and cross-prefix.
	6978	func_cc_basename ()
	6979	{
	6980	for cc_temp in $*""; do
	6981	case $cc_temp in
	6982	compile \| [\\/]compile \| ccache \| [\\/]ccache ) ;;
	6983	distcc \| [\\/]distcc \| purify \| [\\/]purify ) ;;
	6984	\-*) ;;
	6985	*) break;;
	6986	esac
	6987	done
	6988	func_cc_basename_result=`$ECHO "$cc_temp" \| $SED "s%.*/%%; s%^$host_alias-%%"`
	6989	}
	6990
6865	6991	# Check whether --enable-libtool-lock was given.
6866	6992	if test "${enable_libtool_lock+set}" = set; then :
6867	6993	enableval=$enable_libtool_lock;
6868	6994	fi
6869	6995
6870		test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
	6996	test no = "$enable_libtool_lock" \|\| enable_libtool_lock=yes
6871	6997
6872	6998	# Some flags need to be propagated to the compiler or linker for good
6873	6999	# libtool support.
6874	7000	case $host in
6875	7001	ia64--hpux)
6876		# Find out which ABI we are using.
	7002	# Find out what ABI is being produced by ac_compile, and set mode
	7003	# options accordingly.
6877	7004	echo 'int i;' > conftest.$ac_ext
6878	7005	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6879	7006	(eval $ac_compile) 2>&5

6882	7009	test $ac_status = 0; }; then
6883	7010	case `/usr/bin/file conftest.$ac_objext` in
6884	7011	ELF-32)
6885		HPUX_IA64_MODE="32"
	7012	HPUX_IA64_MODE=32
6886	7013	;;
6887	7014	ELF-64)
6888		HPUX_IA64_MODE="64"
	7015	HPUX_IA64_MODE=64
6889	7016	;;
6890	7017	esac
6891	7018	fi
6892	7019	rm -rf conftest*
6893	7020	;;
6894	7021	--irix6*)
6895		# Find out which ABI we are using.
	7022	# Find out what ABI is being produced by ac_compile, and set linker
	7023	# options accordingly.
6896	7024	echo '#line '$LINENO' "configure"' > conftest.$ac_ext
6897	7025	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6898	7026	(eval $ac_compile) 2>&5
6899	7027	ac_status=$?
6900	7028	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6901	7029	test $ac_status = 0; }; then
6902		if test "$lt_cv_prog_gnu_ld" = yes; then
	7030	if test yes = "$lt_cv_prog_gnu_ld"; then
6903	7031	case `/usr/bin/file conftest.$ac_objext` in
6904	7032	32-bit)
6905	7033	LD="${LD-ld} -melf32bsmip"

6928	7056	rm -rf conftest*
6929	7057	;;
6930	7058
	7059	mips64-linux*)
	7060	# Find out what ABI is being produced by ac_compile, and set linker
	7061	# options accordingly.
	7062	echo '#line '$LINENO' "configure"' > conftest.$ac_ext
	7063	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
	7064	(eval $ac_compile) 2>&5
	7065	ac_status=$?
	7066	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
	7067	test $ac_status = 0; }; then
	7068	emul=elf
	7069	case `/usr/bin/file conftest.$ac_objext` in
	7070	32-bit)
	7071	emul="${emul}32"
	7072	;;
	7073	64-bit)
	7074	emul="${emul}64"
	7075	;;
	7076	esac
	7077	case `/usr/bin/file conftest.$ac_objext` in
	7078	MSB)
	7079	emul="${emul}btsmip"
	7080	;;
	7081	LSB)
	7082	emul="${emul}ltsmip"
	7083	;;
	7084	esac
	7085	case `/usr/bin/file conftest.$ac_objext` in
	7086	N32)
	7087	emul="${emul}n32"
	7088	;;
	7089	esac
	7090	LD="${LD-ld} -m $emul"
	7091	fi
	7092	rm -rf conftest*
	7093	;;
	7094
6931	7095	x86_64-kfreebsd-gnu\|x86_64-linux\|powerpc-linux*\| \
6932	7096	s390-linux\|s390-tpf\|sparc-linux*)
6933		# Find out which ABI we are using.
	7097	# Find out what ABI is being produced by ac_compile, and set linker
	7098	# options accordingly. Note that the listed cases only cover the
	7099	# situations where additional linker options are needed (such as when
	7100	# doing 32-bit compilation for a host where ld defaults to 64-bit, or
	7101	# vice versa); the common cases where no linker options are needed do
	7102	# not appear in the list.
6934	7103	echo 'int i;' > conftest.$ac_ext
6935	7104	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6936	7105	(eval $ac_compile) 2>&5

6953	7122	;;
6954	7123	esac
6955	7124	;;
6956		powerpc64le-*)
	7125	powerpc64le-linux)
6957	7126	LD="${LD-ld} -m elf32lppclinux"
6958	7127	;;
6959		powerpc64-*)
	7128	powerpc64-linux)
6960	7129	LD="${LD-ld} -m elf32ppclinux"
6961	7130	;;
6962	7131	s390x-linux)

6975	7144	x86_64-linux)
6976	7145	LD="${LD-ld} -m elf_x86_64"
6977	7146	;;
6978		powerpcle-*)
	7147	powerpcle-linux)
6979	7148	LD="${LD-ld} -m elf64lppc"
6980	7149	;;
6981		powerpc-*)
	7150	powerpc-linux)
6982	7151	LD="${LD-ld} -m elf64ppc"
6983	7152	;;
6984	7153	s390-linux\|s390-tpf)

6996	7165
6997	7166	--sco3.2v5*)
6998	7167	# On SCO OpenServer 5, we need -belf to get full-featured binaries.
6999		SAVE_CFLAGS="$CFLAGS"
	7168	SAVE_CFLAGS=$CFLAGS
7000	7169	CFLAGS="$CFLAGS -belf"
7001	7170	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
7002	7171	$as_echo_n "checking whether the C compiler needs -belf... " >&6; }

7036	7205	fi
7037	7206	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
7038	7207	$as_echo "$lt_cv_cc_needs_belf" >&6; }
7039		if test x"$lt_cv_cc_needs_belf" != x"yes"; then
	7208	if test yes != "$lt_cv_cc_needs_belf"; then
7040	7209	# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
7041		CFLAGS="$SAVE_CFLAGS"
	7210	CFLAGS=$SAVE_CFLAGS
7042	7211	fi
7043	7212	;;
7044	7213	-solaris*)
7045		# Find out which ABI we are using.
	7214	# Find out what ABI is being produced by ac_compile, and set linker
	7215	# options accordingly.
7046	7216	echo 'int i;' > conftest.$ac_ext
7047	7217	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
7048	7218	(eval $ac_compile) 2>&5

7054	7224	case $lt_cv_prog_gnu_ld in
7055	7225	yes*)
7056	7226	case $host in
7057		i?86--solaris)
	7227	i?86--solaris\|x86_64--solaris)
7058	7228	LD="${LD-ld} -m elf_x86_64"
7059	7229	;;
7060	7230	sparc--solaris*)

7063	7233	esac
7064	7234	# GNU ld 2.21 introduced _sol2 emulations. Use them if available.
7065	7235	if ${LD-ld} -V \| grep _sol2 >/dev/null 2>&1; then
7066		LD="${LD-ld}_sol2"
	7236	LD=${LD-ld}_sol2
7067	7237	fi
7068	7238	;;
7069	7239	*)

7079	7249	;;
7080	7250	esac
7081	7251
7082		need_locks="$enable_libtool_lock"
	7252	need_locks=$enable_libtool_lock
7083	7253
7084	7254	if test -n "$ac_tool_prefix"; then
7085	7255	# Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.

7190	7360	fi
7191	7361	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
7192	7362	$as_echo "$lt_cv_path_mainfest_tool" >&6; }
7193		if test "x$lt_cv_path_mainfest_tool" != xyes; then
	7363	if test yes != "$lt_cv_path_mainfest_tool"; then
7194	7364	MANIFEST_TOOL=:
7195	7365	fi
7196	7366

7693	7863	$as_echo_n "(cached) " >&6
7694	7864	else
7695	7865	lt_cv_apple_cc_single_mod=no
7696		if test -z "${LT_MULTI_MODULE}"; then
	7866	if test -z "$LT_MULTI_MODULE"; then
7697	7867	# By default we will add the -single_module flag. You can override
7698	7868	# by either setting the environment variable LT_MULTI_MODULE
7699	7869	# non-empty at configure time, or by adding -multi_module to the

7711	7881	cat conftest.err >&5
7712	7882	# Otherwise, if the output was created with a 0 exit code from
7713	7883	# the compiler, it worked.
7714		elif test -f libconftest.dylib && test $_lt_result -eq 0; then
	7884	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
7715	7885	lt_cv_apple_cc_single_mod=yes
7716	7886	else
7717	7887	cat conftest.err >&5

7750	7920	fi
7751	7921	rm -f core conftest.err conftest.$ac_objext \
7752	7922	conftest$ac_exeext conftest.$ac_ext
7753		LDFLAGS="$save_LDFLAGS"
	7923	LDFLAGS=$save_LDFLAGS
7754	7924
7755	7925	fi
7756	7926	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5

7779	7949	_lt_result=$?
7780	7950	if test -s conftest.err && $GREP force_load conftest.err; then
7781	7951	cat conftest.err >&5
7782		elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
	7952	elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
7783	7953	lt_cv_ld_force_load=yes
7784	7954	else
7785	7955	cat conftest.err >&5

7792	7962	$as_echo "$lt_cv_ld_force_load" >&6; }
7793	7963	case $host_os in
7794	7964	rhapsody* \| darwin1.[012])
7795		_lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
	7965	_lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
7796	7966	darwin1.*)
7797		_lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
	7967	_lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
7798	7968	darwin*) # darwin 5.x on
7799	7969	# if running on 10.5 or later, the deployment target defaults
7800	7970	# to the OS version, if on x86, and 10.4, the deployment
7801	7971	# target defaults to 10.4. Don't you love it?
7802	7972	case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
7803	7973	10.0,86-darwin8\|10.0,-darwin[91]*)
7804		_lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
7805		10.[012]*)
7806		_lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
	7974	_lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
	7975	10.[012][,.]*)
	7976	_lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
7807	7977	10.*)
7808		_lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
	7978	_lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
7809	7979	esac
7810	7980	;;
7811	7981	esac
7812		if test "$lt_cv_apple_cc_single_mod" = "yes"; then
	7982	if test yes = "$lt_cv_apple_cc_single_mod"; then
7813	7983	_lt_dar_single_mod='$single_module'
7814	7984	fi
7815		if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
7816		_lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
	7985	if test yes = "$lt_cv_ld_exported_symbols_list"; then
	7986	_lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
7817	7987	else
7818		_lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
	7988	_lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
7819	7989	fi
7820		if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
	7990	if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
7821	7991	_lt_dsymutil='~$DSYMUTIL $lib \|\| :'
7822	7992	else
7823	7993	_lt_dsymutil=
7824	7994	fi
7825	7995	;;
7826	7996	esac
	7997
	7998	# func_munge_path_list VARIABLE PATH
	7999	# -----------------------------------
	8000	# VARIABLE is name of variable containing _space_ separated list of
	8001	# directories to be munged by the contents of PATH, which is string
	8002	# having a format:
	8003	# "DIR[:DIR]:"
	8004	# string "DIR[ DIR]" will be prepended to VARIABLE
	8005	# ":DIR[:DIR]"
	8006	# string "DIR[ DIR]" will be appended to VARIABLE
	8007	# "DIRP[:DIRP]::[DIRA:]DIRA"
	8008	# string "DIRP[ DIRP]" will be prepended to VARIABLE and string
	8009	# "DIRA[ DIRA]" will be appended to VARIABLE
	8010	# "DIR[:DIR]"
	8011	# VARIABLE will be replaced by "DIR[ DIR]"
	8012	func_munge_path_list ()
	8013	{
	8014	case x$2 in
	8015	x)
	8016	;;
	8017	*:)
	8018	eval $1=\"`$ECHO $2 \| $SED 's/:/ /g'` \$$1\"
	8019	;;
	8020	x:*)
	8021	eval $1=\"\$$1 `$ECHO $2 \| $SED 's/:/ /g'`\"
	8022	;;
	8023	::)
	8024	eval $1=\"\$$1\ `$ECHO $2 \| $SED -e 's/.*:://' -e 's/:/ /g'`\"
	8025	eval $1=\"`$ECHO $2 \| $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
	8026	;;
	8027	*)
	8028	eval $1=\"`$ECHO $2 \| $SED 's/:/ /g'`\"
	8029	;;
	8030	esac
	8031	}
7827	8032
7828	8033	ac_ext=c
7829	8034	ac_cpp='$CPP $CPPFLAGS'

8110	8315
8111	8316	func_stripname_cnf ()
8112	8317	{
8113		case ${2} in
8114		.*) func_stripname_result=`$ECHO "${3}" \| $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
8115		*) func_stripname_result=`$ECHO "${3}" \| $SED "s%^${1}%%; s%${2}\$%%"`;;
	8318	case $2 in
	8319	.*) func_stripname_result=`$ECHO "$3" \| $SED "s%^$1%%; s%\\\\$2\$%%"`;;
	8320	*) func_stripname_result=`$ECHO "$3" \| $SED "s%^$1%%; s%$2\$%%"`;;
8116	8321	esac
8117	8322	} # func_stripname_cnf
8118	8323

8139	8344	*)
8140	8345	enable_shared=no
8141	8346	# Look at the argument we got. We use all the common list separators.
8142		lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
	8347	lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
8143	8348	for pkg in $enableval; do
8144		IFS="$lt_save_ifs"
	8349	IFS=$lt_save_ifs
8145	8350	if test "X$pkg" = "X$p"; then
8146	8351	enable_shared=yes
8147	8352	fi
8148	8353	done
8149		IFS="$lt_save_ifs"
	8354	IFS=$lt_save_ifs
8150	8355	;;
8151	8356	esac
8152	8357	else

8170	8375	*)
8171	8376	enable_static=no
8172	8377	# Look at the argument we got. We use all the common list separators.
8173		lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
	8378	lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
8174	8379	for pkg in $enableval; do
8175		IFS="$lt_save_ifs"
	8380	IFS=$lt_save_ifs
8176	8381	if test "X$pkg" = "X$p"; then
8177	8382	enable_static=yes
8178	8383	fi
8179	8384	done
8180		IFS="$lt_save_ifs"
	8385	IFS=$lt_save_ifs
8181	8386	;;
8182	8387	esac
8183	8388	else

8201	8406	*)
8202	8407	pic_mode=default
8203	8408	# Look at the argument we got. We use all the common list separators.
8204		lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
	8409	lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
8205	8410	for lt_pkg in $withval; do
8206		IFS="$lt_save_ifs"
	8411	IFS=$lt_save_ifs
8207	8412	if test "X$lt_pkg" = "X$lt_p"; then
8208	8413	pic_mode=yes
8209	8414	fi
8210	8415	done
8211		IFS="$lt_save_ifs"
	8416	IFS=$lt_save_ifs
8212	8417	;;
8213	8418	esac
8214	8419	else
8215	8420	pic_mode=default
8216	8421	fi
8217	8422
8218
8219		test -z "$pic_mode" && pic_mode=default
8220	8423
8221	8424
8222	8425

8233	8436	*)
8234	8437	enable_fast_install=no
8235	8438	# Look at the argument we got. We use all the common list separators.
8236		lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
	8439	lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
8237	8440	for pkg in $enableval; do
8238		IFS="$lt_save_ifs"
	8441	IFS=$lt_save_ifs
8239	8442	if test "X$pkg" = "X$p"; then
8240	8443	enable_fast_install=yes
8241	8444	fi
8242	8445	done
8243		IFS="$lt_save_ifs"
	8446	IFS=$lt_save_ifs
8244	8447	;;
8245	8448	esac
8246	8449	else

8254	8457
8255	8458
8256	8459
	8460	shared_archive_member_spec=
	8461	case $host,$enable_shared in
	8462	power--aix[5-9]*,yes)
	8463	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
	8464	$as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
	8465
	8466	# Check whether --with-aix-soname was given.
	8467	if test "${with_aix_soname+set}" = set; then :
	8468	withval=$with_aix_soname; case $withval in
	8469	aix\|svr4\|both)
	8470	;;
	8471	*)
	8472	as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
	8473	;;
	8474	esac
	8475	lt_cv_with_aix_soname=$with_aix_soname
	8476	else
	8477	if ${lt_cv_with_aix_soname+:} false; then :
	8478	$as_echo_n "(cached) " >&6
	8479	else
	8480	lt_cv_with_aix_soname=aix
	8481	fi
	8482
	8483	with_aix_soname=$lt_cv_with_aix_soname
	8484	fi
	8485
	8486	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
	8487	$as_echo "$with_aix_soname" >&6; }
	8488	if test aix != "$with_aix_soname"; then
	8489	# For the AIX way of multilib, we name the shared archive member
	8490	# based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
	8491	# and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
	8492	# Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
	8493	# the AIX toolchain works better with OBJECT_MODE set (default 32).
	8494	if test 64 = "${OBJECT_MODE-32}"; then
	8495	shared_archive_member_spec=shr_64
	8496	else
	8497	shared_archive_member_spec=shr
	8498	fi
	8499	fi
	8500	;;
	8501	*)
	8502	with_aix_soname=aix
	8503	;;
	8504	esac
	8505
	8506
	8507
	8508
	8509
	8510
	8511
8257	8512
8258	8513
8259	8514
8260	8515	# This can be used to rebuild libtool when needed
8261		LIBTOOL_DEPS="$ltmain"
	8516	LIBTOOL_DEPS=$ltmain
8262	8517
8263	8518	# Always use our own libtool.
8264	8519	LIBTOOL='$(SHELL) $(top_builddir)/libtool'

8307	8562
8308	8563
8309	8564
8310		if test -n "${ZSH_VERSION+set}" ; then
	8565	if test -n "${ZSH_VERSION+set}"; then
8311	8566	setopt NO_GLOB_SUBST
8312	8567	fi
8313	8568

8346	8601<