[apple/libc.git] / locale / FreeBSD / rune.c.patch

--- rune.c.orig	2004-11-25 11:38:19.000000000 -0800
+++ rune.c	2005-04-12 17:18:12.000000000 -0700
@@ -34,28 +34,98 @@
  * SUCH DAMAGE.
  */
 
+#ifndef RUNEOFF32
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)rune.c	8.1 (Berkeley) 6/4/93";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD: src/lib/libc/locale/rune.c,v 1.12 2004/07/29 06:16:19 tjr Exp $");
 
+#include "xlocale_private.h"
+
 #include "namespace.h"
 #include <arpa/inet.h>
 #include <errno.h>
+#endif /* !RUNEOFF32 */
 #include <runetype.h>
 #include <stdio.h>
+#ifndef RUNEOFF32
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include "un-namespace.h"
+#endif /* !RUNEOFF32 */
 
-_RuneLocale *
+#if defined(__LP64__) || defined(RUNEOFF32)
+/*
+ * Because the LC_CTYPE files were created with a 32-bit program, we need
+ * to adjust for the larger pointers in LP64 (the longs have already been
+ * replaced by 32-bit equivalents).  Also, natural alignment will pad
+ * 64-bit types to 8-byte boundaries, and make structures containing
+ * 64-bit types sized to 8-byte boundaries.
+ */
+#include <stddef.h>
+#ifndef RUNEOFF32
+#include "rune32.h"
+#define BYTES32BITS		4
+#define BYTES64BITS		8
+/* whether to skip over a pointer or not (one-to-one with off64) */
+int skip[] = {
+	1,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	1,
+	1,
+	0
+};
+#endif /* !RUNEOFF32 */
+int off64[] = {
+	offsetof(_RuneLocale, __sgetrune),
+	offsetof(_RuneLocale, __sputrune),
+	offsetof(_RuneLocale, __runetype_ext),
+	offsetof(_RuneLocale, __runetype_ext) + offsetof(_RuneRange, __ranges),
+	offsetof(_RuneLocale, __maplower_ext),
+	offsetof(_RuneLocale, __maplower_ext) + offsetof(_RuneRange, __ranges),
+	offsetof(_RuneLocale, __mapupper_ext),
+	offsetof(_RuneLocale, __mapupper_ext) + offsetof(_RuneRange, __ranges),
+	offsetof(_RuneLocale, __variable),
+	offsetof(_RuneLocale, __charclasses),
+	sizeof(_RuneLocale)
+};
+#define	NOFF			(sizeof(off64) / sizeof(int))
+#ifdef RUNEOFF32
+/*
+ * This program generates a header file (on stdout) that containes the 32-bit
+ * offsets, plus some 32-bit sizes
+ */
+main()
+{
+	int i;
+	printf("#define SIZEOF32_RUNEENTRY %d\n", sizeof(_RuneEntry));
+	printf("#define SIZEOF32_RUNELOCALE %d\n", sizeof(_RuneLocale));
+	printf("int off32[] = {\n");
+	for(i = 0; i < NOFF; i++)
+		printf("\t%d,\n", off64[i]);
+	printf("};\n");
+	return 0;
+}
+#endif /* RUNEOFF32 */
+#else /* !__LP64__ && !RUNEOFF32 */
+#define	SIZEOF32_RUNELOCALE	sizeof(_RuneLocale)
+#endif /* __LP64__ || RUNEOFF32 */
+
+#ifndef RUNEOFF32
+struct __xlocale_st_runelocale *
 _Read_RuneMagi(fp)
 	FILE *fp;
 {
-	char *data;
+	struct __xlocale_st_runelocale *data;
 	void *lastp;
 	_RuneLocale *rl;
 	_RuneEntry *rr;
@@ -65,13 +135,20 @@
 	if (_fstat(fileno(fp), &sb) < 0)
 		return (NULL);
 
-	if (sb.st_size < sizeof(_RuneLocale)) {
+	if (sb.st_size < SIZEOF32_RUNELOCALE) {
 		errno = EFTYPE;
 		return (NULL);
 	}
 
-	if ((data = malloc(sb.st_size)) == NULL)
+#ifdef __LP64__
+	/* will adjust later */
+	if ((data = (struct __xlocale_st_runelocale *)malloc(sizeof(struct __xlocale_st_runelocale))) == NULL)
+#else /* !__LP64__ */
+	if ((data = (struct __xlocale_st_runelocale *)malloc(sizeof(struct __xlocale_st_runelocale) - sizeof(_RuneLocale) + sb.st_size)) == NULL)
+#endif /* __LP64__ */
 		return (NULL);
+	data->__refcount = 1;
+	data->__free_extra = NULL;
 
 	errno = 0;
 	rewind(fp); /* Someone might have read the magic number once already */
@@ -82,26 +159,43 @@
 		return (NULL);
 	}
 
-	if (fread(data, sb.st_size, 1, fp) != 1) {
+	rl = &data->_CurrentRuneLocale;
+
+#ifdef __LP64__
+	if (fread(rl, SIZEOF32_RUNELOCALE, 1, fp) != 1)
+#else /* !__LP64__ */
+	if (fread(rl, sb.st_size, 1, fp) != 1)
+#endif /* __LP64__ */
+	{
 		saverr = errno;
 		free(data);
 		errno = saverr;
 		return (NULL);
 	}
 
-	rl = (_RuneLocale *)data;
-	lastp = data + sb.st_size;
+#ifndef __LP64__
+	lastp = (char *)rl + sb.st_size;
 
 	rl->__variable = rl + 1;
+#endif /* __LP64__ */
 
-	if (memcmp(rl->__magic, _RUNE_MAGIC_1, sizeof(rl->__magic))) {
+	if (memcmp(rl->__magic, _RUNE_MAGIC_A, sizeof(rl->__magic))) {
 		free(data);
 		errno = EFTYPE;
 		return (NULL);
 	}
 
+#ifdef __LP64__
+	/* shift things into the right position */
+	for (x = NOFF - 2; x >= 0; x--)
+		memmove((char *)rl + off64[x] + (skip[x] ? BYTES64BITS : 0),
+			(char *)rl + off32[x] + (skip[x] ? BYTES32BITS : 0),
+			off32[x + 1] - off32[x] - (skip[x] ? BYTES32BITS : 0));
+#endif /* __LP64__ */
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
 	rl->__invalid_rune = ntohl(rl->__invalid_rune);
 	rl->__variable_len = ntohl(rl->__variable_len);
+	rl->__ncharclasses = ntohl(rl->__ncharclasses);
 	rl->__runetype_ext.__nranges = ntohl(rl->__runetype_ext.__nranges);
 	rl->__maplower_ext.__nranges = ntohl(rl->__maplower_ext.__nranges);
 	rl->__mapupper_ext.__nranges = ntohl(rl->__mapupper_ext.__nranges);
@@ -111,7 +205,54 @@
 		rl->__maplower[x] = ntohl(rl->__maplower[x]);
 		rl->__mapupper[x] = ntohl(rl->__mapupper[x]);
 	}
+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
 
+#ifdef __LP64__
+	{
+	int count = rl->__runetype_ext.__nranges + rl->__maplower_ext.__nranges
+	    + rl->__mapupper_ext.__nranges;
+	int extra = sb.st_size - SIZEOF32_RUNELOCALE - count * SIZEOF32_RUNEENTRY - rl->__ncharclasses * sizeof(_RuneCharClass);
+	_RuneEntry *rp;
+
+	if (extra < 0) {
+		saverr = errno;
+		free(data);
+		errno = saverr;
+		return (NULL);
+	}
+	if ((data = (struct __xlocale_st_runelocale *)reallocf(data, sizeof(struct __xlocale_st_runelocale)
+	    + count * sizeof(_RuneEntry)
+	    + rl->__ncharclasses * sizeof(_RuneCharClass)
+	    + extra)) == NULL)
+		return (NULL);
+	rl = &data->_CurrentRuneLocale;
+	rl->__variable = rl + 1;
+	rp = (_RuneEntry *)rl->__variable;
+	for (x = 0; x < count; x++, rp++)
+		if (fread(rp, SIZEOF32_RUNEENTRY, 1, fp) != 1) {
+			saverr = errno;
+			free(data);
+			errno = saverr;
+			return (NULL);
+		}
+	if (rl->__ncharclasses > 0) {
+		if (fread(rp, sizeof(_RuneCharClass), rl->__ncharclasses, fp) != rl->__ncharclasses) {
+			saverr = errno;
+			free(data);
+			errno = saverr;
+			return (NULL);
+		}
+		rp = (_RuneEntry *)((char *)rp + rl->__ncharclasses * sizeof(_RuneCharClass));
+	}
+	if (extra > 0 && fread(rp, extra, 1, fp) != 1) {
+		saverr = errno;
+		free(data);
+		errno = saverr;
+		return (NULL);
+	}
+	lastp = (char *)rp + extra;
+	}
+#endif /* __LP64__ */
 	rl->__runetype_ext.__ranges = (_RuneEntry *)rl->__variable;
 	rl->__variable = rl->__runetype_ext.__ranges +
 	    rl->__runetype_ext.__nranges;
@@ -142,8 +283,10 @@
 	for (x = 0; x < rl->__runetype_ext.__nranges; ++x) {
 		rr = rl->__runetype_ext.__ranges;
 
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
 		rr[x].__min = ntohl(rr[x].__min);
 		rr[x].__max = ntohl(rr[x].__max);
+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
 		if ((rr[x].__map = ntohl(rr[x].__map)) == 0) {
 			int len = rr[x].__max - rr[x].__min + 1;
 			rr[x].__types = rl->__variable;
@@ -153,12 +296,15 @@
 				errno = EFTYPE;
 				return (NULL);
 			}
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
 			while (len-- > 0)
 				rr[x].__types[len] = ntohl(rr[x].__types[len]);
+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
 		} else
 			rr[x].__types = 0;
 	}
 
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
 	for (x = 0; x < rl->__maplower_ext.__nranges; ++x) {
 		rr = rl->__maplower_ext.__ranges;
 
@@ -174,6 +320,22 @@
 		rr[x].__max = ntohl(rr[x].__max);
 		rr[x].__map = ntohl(rr[x].__map);
 	}
+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
+
+	if (rl->__ncharclasses > 0) {
+		rl->__charclasses = (_RuneCharClass *)rl->__variable;
+		rl->__variable = (void *)(rl->__charclasses + rl->__ncharclasses);
+		if (rl->__variable > lastp) {
+			free(data);
+			errno = EFTYPE;
+			return (NULL);
+		}
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
+		for (x = 0; x < rl->__ncharclasses; ++x)
+			rl->__charclasses[x].__mask = ntohl(rl->__charclasses[x].__mask);
+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
+	}
+
 	if (((char *)rl->__variable) + rl->__variable_len > (char *)lastp) {
 		free(data);
 		errno = EFTYPE;
@@ -195,5 +357,7 @@
 	if (!rl->__mapupper_ext.__nranges)
 		rl->__mapupper_ext.__ranges = 0;
 
-	return (rl);
+	data->__datasize = lastp - (void *)data;
+	return (data);
 }
+#endif /* !RUNEOFF32 */
Commit	Line	Data
3d9156a7	1	--- rune.c.orig 2004-11-25 11:38:19.000000000 -0800
224c7076 A	2	+++ rune.c 2005-04-12 17:18:12.000000000 -0700
224c7076 A	3	@@ -34,28 +34,98 @@
3d9156a7 A	4	* SUCH DAMAGE.
3d9156a7 A	5	*/
9385eb3d	6
3d9156a7 A	7	+#ifndef RUNEOFF32
	8	#if defined(LIBC_SCCS) && !defined(lint)
	9	static char sccsid[] = "@(#)rune.c 8.1 (Berkeley) 6/4/93";
	10	#endif /* LIBC_SCCS and not lint */
	11	#include <sys/cdefs.h>
	12	__FBSDID("$FreeBSD: src/lib/libc/locale/rune.c,v 1.12 2004/07/29 06:16:19 tjr Exp $");
	13
	14	+#include "xlocale_private.h"
	15	+
9385eb3d	16	#include "namespace.h"
3d9156a7	17	#include <arpa/inet.h>
9385eb3d	18	#include <errno.h>
3d9156a7 A	19	+#endif /* !RUNEOFF32 */
3d9156a7 A	20	#include <runetype.h>
9385eb3d	21	#include <stdio.h>
3d9156a7 A	22	+#ifndef RUNEOFF32
	23	#include <string.h>
	24	#include <stdlib.h>
	25	#include <sys/types.h>
	26	#include <sys/stat.h>
	27	#include "un-namespace.h"
	28	+#endif /* !RUNEOFF32 */
224c7076 A	29
224c7076 A	30	-_RuneLocale *
3d9156a7 A	31	+#if defined(__LP64__) \|\| defined(RUNEOFF32)
	32	+/*
	33	+ * Because the LC_CTYPE files were created with a 32-bit program, we need
	34	+ * to adjust for the larger pointers in LP64 (the longs have already been
	35	+ * replaced by 32-bit equivalents). Also, natural alignment will pad
	36	+ * 64-bit types to 8-byte boundaries, and make structures containing
	37	+ * 64-bit types sized to 8-byte boundaries.
	38	+ */
	39	+#include <stddef.h>
	40	+#ifndef RUNEOFF32
	41	+#include "rune32.h"
	42	+#define BYTES32BITS 4
	43	+#define BYTES64BITS 8
	44	+/* whether to skip over a pointer or not (one-to-one with off64) */
224c7076	45	+int skip[] = {
3d9156a7 A	46	+ 1,
	47	+ 1,
	48	+ 0,
	49	+ 1,
	50	+ 0,
	51	+ 1,
	52	+ 0,
	53	+ 1,
	54	+ 1,
224c7076	55	+ 1,
3d9156a7 A	56	+ 0
	57	+};
	58	+#endif /* !RUNEOFF32 */
224c7076	59	+int off64[] = {
3d9156a7 A	60	+ offsetof(_RuneLocale, __sgetrune),
	61	+ offsetof(_RuneLocale, __sputrune),
	62	+ offsetof(_RuneLocale, __runetype_ext),
	63	+ offsetof(_RuneLocale, __runetype_ext) + offsetof(_RuneRange, __ranges),
	64	+ offsetof(_RuneLocale, __maplower_ext),
	65	+ offsetof(_RuneLocale, __maplower_ext) + offsetof(_RuneRange, __ranges),
	66	+ offsetof(_RuneLocale, __mapupper_ext),
	67	+ offsetof(_RuneLocale, __mapupper_ext) + offsetof(_RuneRange, __ranges),
	68	+ offsetof(_RuneLocale, __variable),
224c7076	69	+ offsetof(_RuneLocale, __charclasses),
3d9156a7 A	70	+ sizeof(_RuneLocale)
	71	+};
	72	+#define NOFF (sizeof(off64) / sizeof(int))
	73	+#ifdef RUNEOFF32
	74	+/*
	75	+ * This program generates a header file (on stdout) that containes the 32-bit
	76	+ * offsets, plus some 32-bit sizes
	77	+ */
	78	+main()
	79	+{
	80	+ int i;
	81	+ printf("#define SIZEOF32_RUNEENTRY %d\n", sizeof(_RuneEntry));
	82	+ printf("#define SIZEOF32_RUNELOCALE %d\n", sizeof(_RuneLocale));
224c7076	83	+ printf("int off32[] = {\n");
3d9156a7 A	84	+ for(i = 0; i < NOFF; i++)
	85	+ printf("\t%d,\n", off64[i]);
	86	+ printf("};\n");
	87	+ return 0;
	88	+}
	89	+#endif /* RUNEOFF32 */
	90	+#else /* !__LP64__ && !RUNEOFF32 */
	91	+#define SIZEOF32_RUNELOCALE sizeof(_RuneLocale)
	92	+#endif /* __LP64__ \|\| RUNEOFF32 */
224c7076	93	+
3d9156a7 A	94	+#ifndef RUNEOFF32
	95	+struct __xlocale_st_runelocale *
	96	_Read_RuneMagi(fp)
	97	FILE *fp;
	98	{
	99	- char *data;
	100	+ struct __xlocale_st_runelocale *data;
	101	void *lastp;
	102	_RuneLocale *rl;
	103	_RuneEntry *rr;
224c7076	104	@@ -65,13 +135,20 @@
3d9156a7 A	105	if (_fstat(fileno(fp), &sb) < 0)
	106	return (NULL);
	107
	108	- if (sb.st_size < sizeof(_RuneLocale)) {
	109	+ if (sb.st_size < SIZEOF32_RUNELOCALE) {
	110	errno = EFTYPE;
	111	return (NULL);
	112	}
	113
	114	- if ((data = malloc(sb.st_size)) == NULL)
	115	+#ifdef __LP64__
	116	+ /* will adjust later */
	117	+ if ((data = (struct __xlocale_st_runelocale *)malloc(sizeof(struct __xlocale_st_runelocale))) == NULL)
	118	+#else /* !__LP64__ */
	119	+ if ((data = (struct __xlocale_st_runelocale *)malloc(sizeof(struct __xlocale_st_runelocale) - sizeof(_RuneLocale) + sb.st_size)) == NULL)
	120	+#endif /* __LP64__ */
	121	return (NULL);
	122	+ data->__refcount = 1;
	123	+ data->__free_extra = NULL;
	124
	125	errno = 0;
	126	rewind(fp); /* Someone might have read the magic number once already */
224c7076	127	@@ -82,26 +159,43 @@
3d9156a7 A	128	return (NULL);
	129	}
	130
	131	- if (fread(data, sb.st_size, 1, fp) != 1) {
	132	+ rl = &data->_CurrentRuneLocale;
	133	+
	134	+#ifdef __LP64__
	135	+ if (fread(rl, SIZEOF32_RUNELOCALE, 1, fp) != 1)
	136	+#else /* !__LP64__ */
	137	+ if (fread(rl, sb.st_size, 1, fp) != 1)
	138	+#endif /* __LP64__ */
	139	+ {
	140	saverr = errno;
	141	free(data);
	142	errno = saverr;
	143	return (NULL);
	144	}
	145
	146	- rl = (_RuneLocale *)data;
	147	- lastp = data + sb.st_size;
	148	+#ifndef __LP64__
	149	+ lastp = (char *)rl + sb.st_size;
	150
	151	rl->__variable = rl + 1;
	152	+#endif /* __LP64__ */
	153
224c7076 A	154	- if (memcmp(rl->__magic, _RUNE_MAGIC_1, sizeof(rl->__magic))) {
224c7076 A	155	+ if (memcmp(rl->__magic, _RUNE_MAGIC_A, sizeof(rl->__magic))) {
3d9156a7	156	free(data);
224c7076	157	errno = EFTYPE;
3d9156a7 A	158	return (NULL);
	159	}
	160
	161	+#ifdef __LP64__
	162	+ /* shift things into the right position */
	163	+ for (x = NOFF - 2; x >= 0; x--)
	164	+ memmove((char *)rl + off64[x] + (skip[x] ? BYTES64BITS : 0),
	165	+ (char *)rl + off32[x] + (skip[x] ? BYTES32BITS : 0),
	166	+ off32[x + 1] - off32[x] - (skip[x] ? BYTES32BITS : 0));
	167	+#endif /* __LP64__ */
	168	+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
	169	rl->__invalid_rune = ntohl(rl->__invalid_rune);
	170	rl->__variable_len = ntohl(rl->__variable_len);
224c7076	171	+ rl->__ncharclasses = ntohl(rl->__ncharclasses);
3d9156a7	172	rl->__runetype_ext.__nranges = ntohl(rl->__runetype_ext.__nranges);
224c7076 A	173	rl->__maplower_ext.__nranges = ntohl(rl->__maplower_ext.__nranges);
	174	rl->__mapupper_ext.__nranges = ntohl(rl->__mapupper_ext.__nranges);
	175	@@ -111,7 +205,54 @@
3d9156a7 A	176	rl->__maplower[x] = ntohl(rl->__maplower[x]);
	177	rl->__mapupper[x] = ntohl(rl->__mapupper[x]);
	178	}
	179	+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
224c7076	180
3d9156a7 A	181	+#ifdef __LP64__
	182	+ {
	183	+ int count = rl->__runetype_ext.__nranges + rl->__maplower_ext.__nranges
	184	+ + rl->__mapupper_ext.__nranges;
224c7076	185	+ int extra = sb.st_size - SIZEOF32_RUNELOCALE - count * SIZEOF32_RUNEENTRY - rl->__ncharclasses * sizeof(_RuneCharClass);
3d9156a7	186	+ _RuneEntry *rp;
224c7076	187	+
3d9156a7 A	188	+ if (extra < 0) {
	189	+ saverr = errno;
	190	+ free(data);
	191	+ errno = saverr;
	192	+ return (NULL);
	193	+ }
224c7076 A	194	+ if ((data = (struct __xlocale_st_runelocale *)reallocf(data, sizeof(struct __xlocale_st_runelocale)
	195	+ + count * sizeof(_RuneEntry)
	196	+ + rl->__ncharclasses * sizeof(_RuneCharClass)
	197	+ + extra)) == NULL)
3d9156a7 A	198	+ return (NULL);
	199	+ rl = &data->_CurrentRuneLocale;
	200	+ rl->__variable = rl + 1;
	201	+ rp = (_RuneEntry *)rl->__variable;
	202	+ for (x = 0; x < count; x++, rp++)
	203	+ if (fread(rp, SIZEOF32_RUNEENTRY, 1, fp) != 1) {
	204	+ saverr = errno;
	205	+ free(data);
	206	+ errno = saverr;
	207	+ return (NULL);
	208	+ }
224c7076 A	209	+ if (rl->__ncharclasses > 0) {
	210	+ if (fread(rp, sizeof(_RuneCharClass), rl->__ncharclasses, fp) != rl->__ncharclasses) {
	211	+ saverr = errno;
	212	+ free(data);
	213	+ errno = saverr;
	214	+ return (NULL);
	215	+ }
	216	+ rp = (_RuneEntry )((char )rp + rl->__ncharclasses * sizeof(_RuneCharClass));
	217	+ }
3d9156a7 A	218	+ if (extra > 0 && fread(rp, extra, 1, fp) != 1) {
	219	+ saverr = errno;
	220	+ free(data);
	221	+ errno = saverr;
	222	+ return (NULL);
	223	+ }
	224	+ lastp = (char *)rp + extra;
	225	+ }
	226	+#endif /* __LP64__ */
	227	rl->__runetype_ext.__ranges = (_RuneEntry *)rl->__variable;
	228	rl->__variable = rl->__runetype_ext.__ranges +
	229	rl->__runetype_ext.__nranges;
224c7076	230	@@ -142,8 +283,10 @@
3d9156a7 A	231	for (x = 0; x < rl->__runetype_ext.__nranges; ++x) {
	232	rr = rl->__runetype_ext.__ranges;
	233
	234	+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
	235	rr[x].__min = ntohl(rr[x].__min);
	236	rr[x].__max = ntohl(rr[x].__max);
	237	+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
	238	if ((rr[x].__map = ntohl(rr[x].__map)) == 0) {
	239	int len = rr[x].__max - rr[x].__min + 1;
	240	rr[x].__types = rl->__variable;
224c7076	241	@@ -153,12 +296,15 @@
3d9156a7 A	242	errno = EFTYPE;
	243	return (NULL);
	244	}
	245	+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
	246	while (len-- > 0)
	247	rr[x].__types[len] = ntohl(rr[x].__types[len]);
	248	+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
	249	} else
	250	rr[x].__types = 0;
	251	}
	252
	253	+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
	254	for (x = 0; x < rl->__maplower_ext.__nranges; ++x) {
	255	rr = rl->__maplower_ext.__ranges;
	256
224c7076	257	@@ -174,6 +320,22 @@
3d9156a7 A	258	rr[x].__max = ntohl(rr[x].__max);
	259	rr[x].__map = ntohl(rr[x].__map);
	260	}
	261	+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
224c7076 A	262	+
	263	+ if (rl->__ncharclasses > 0) {
	264	+ rl->__charclasses = (_RuneCharClass *)rl->__variable;
	265	+ rl->__variable = (void *)(rl->__charclasses + rl->__ncharclasses);
	266	+ if (rl->__variable > lastp) {
	267	+ free(data);
	268	+ errno = EFTYPE;
	269	+ return (NULL);
	270	+ }
	271	+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
	272	+ for (x = 0; x < rl->__ncharclasses; ++x)
	273	+ rl->__charclasses[x].__mask = ntohl(rl->__charclasses[x].__mask);
	274	+#endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */
	275	+ }
	276	+
3d9156a7 A	277	if (((char )rl->__variable) + rl->__variable_len > (char )lastp) {
	278	free(data);
	279	errno = EFTYPE;
224c7076	280	@@ -195,5 +357,7 @@
3d9156a7 A	281	if (!rl->__mapupper_ext.__nranges)
	282	rl->__mapupper_ext.__ranges = 0;
	283
	284	- return (rl);
	285	+ data->__datasize = lastp - (void *)data;
	286	+ return (data);
	287	}
	288	+#endif /* !RUNEOFF32 */