[linux.git] / fs / hfsplus / unicode.c

/*
 *  linux/fs/hfsplus/unicode.c
 *
 * Copyright (C) 2001
 * Brad Boyer ([email protected])
 * (C) 2003 Ardis Technologies <[email protected]>
 *
 * Handler routines for unicode strings
 */

#include <linux/types.h>
#include <linux/nls.h>
#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

/* Fold the case of a unicode char, given the 16 bit value */
/* Returns folded char, or 0 if ignorable */
static inline u16 case_fold(u16 c)
{
        u16 tmp;

        tmp = hfsplus_case_fold_table[c >> 8];
        if (tmp)
                tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
        else
                tmp = c;
        return tmp;
}

/* Compare unicode strings, return values like normal strcmp */
int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
		       const struct hfsplus_unistr *s2)
{
	u16 len1, len2, c1, c2;
	const hfsplus_unichr *p1, *p2;

	len1 = be16_to_cpu(s1->length);
	len2 = be16_to_cpu(s2->length);
	p1 = s1->unicode;
	p2 = s2->unicode;

	while (1) {
		c1 = c2 = 0;

		while (len1 && !c1) {
			c1 = case_fold(be16_to_cpu(*p1));
			p1++;
			len1--;
		}
		while (len2 && !c2) {
			c2 = case_fold(be16_to_cpu(*p2));
			p2++;
			len2--;
		}

		if (c1 != c2)
			return (c1 < c2) ? -1 : 1;
		if (!c1 && !c2)
			return 0;
	}
}

/* Compare names as a sequence of 16-bit unsigned integers */
int hfsplus_strcmp(const struct hfsplus_unistr *s1,
		   const struct hfsplus_unistr *s2)
{
	u16 len1, len2, c1, c2;
	const hfsplus_unichr *p1, *p2;
	int len;

	len1 = be16_to_cpu(s1->length);
	len2 = be16_to_cpu(s2->length);
	p1 = s1->unicode;
	p2 = s2->unicode;

	for (len = min(len1, len2); len > 0; len--) {
		c1 = be16_to_cpu(*p1);
		c2 = be16_to_cpu(*p2);
		if (c1 != c2)
			return c1 < c2 ? -1 : 1;
		p1++;
		p2++;
	}

	return len1 < len2 ? -1 :
	       len1 > len2 ? 1 : 0;
}


#define Hangul_SBase	0xac00
#define Hangul_LBase	0x1100
#define Hangul_VBase	0x1161
#define Hangul_TBase	0x11a7
#define Hangul_SCount	11172
#define Hangul_LCount	19
#define Hangul_VCount	21
#define Hangul_TCount	28
#define Hangul_NCount	(Hangul_VCount * Hangul_TCount)


static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
{
	int i, s, e;

	s = 1;
	e = p[1];
	if (!e || cc < p[s * 2] || cc > p[e * 2])
		return NULL;
	do {
		i = (s + e) / 2;
		if (cc > p[i * 2])
			s = i + 1;
		else if (cc < p[i * 2])
			e = i - 1;
		else
			return hfsplus_compose_table + p[i * 2 + 1];
	} while (s <= e);
	return NULL;
}

int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, char *astr, int *len_p)
{
	const hfsplus_unichr *ip;
	struct nls_table *nls = HFSPLUS_SB(sb).nls;
	u8 *op;
	u16 cc, c0, c1;
	u16 *ce1, *ce2;
	int i, len, ustrlen, res, compose;

	op = astr;
	ip = ustr->unicode;
	ustrlen = be16_to_cpu(ustr->length);
	len = *len_p;
	ce1 = NULL;
	compose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);

	while (ustrlen > 0) {
		c0 = be16_to_cpu(*ip++);
		ustrlen--;
		/* search for single decomposed char */
		if (likely(compose))
			ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
		if (ce1 && (cc = ce1[0])) {
			/* start of a possibly decomposed Hangul char */
			if (cc != 0xffff)
				goto done;
			if (!ustrlen)
				goto same;
			c1 = be16_to_cpu(*ip) - Hangul_VBase;
			if (c1 < Hangul_VCount) {
				/* compose the Hangul char */
				cc = (c0 - Hangul_LBase) * Hangul_VCount;
				cc = (cc + c1) * Hangul_TCount;
				cc += Hangul_SBase;
				ip++;
				ustrlen--;
				if (!ustrlen)
					goto done;
				c1 = be16_to_cpu(*ip) - Hangul_TBase;
				if (c1 > 0 && c1 < Hangul_TCount) {
					cc += c1;
					ip++;
					ustrlen--;
				}
				goto done;
			}
		}
		while (1) {
			/* main loop for common case of not composed chars */
			if (!ustrlen)
				goto same;
			c1 = be16_to_cpu(*ip);
			if (likely(compose))
				ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c1);
			if (ce1)
				break;
			switch (c0) {
			case 0:
				c0 = 0x2400;
				break;
			case '/':
				c0 = ':';
				break;
			}
			res = nls->uni2char(c0, op, len);
			if (res < 0) {
				if (res == -ENAMETOOLONG)
					goto out;
				*op = '?';
				res = 1;
			}
			op += res;
			len -= res;
			c0 = c1;
			ip++;
			ustrlen--;
		}
		ce2 = hfsplus_compose_lookup(ce1, c0);
		if (ce2) {
			i = 1;
			while (i < ustrlen) {
				ce1 = hfsplus_compose_lookup(ce2, be16_to_cpu(ip[i]));
				if (!ce1)
					break;
				i++;
				ce2 = ce1;
			}
			if ((cc = ce2[0])) {
				ip += i;
				ustrlen -= i;
				goto done;
			}
		}
	same:
		switch (c0) {
		case 0:
			cc = 0x2400;
			break;
		case '/':
			cc = ':';
			break;
		default:
			cc = c0;
		}
	done:
		res = nls->uni2char(cc, op, len);
		if (res < 0) {
			if (res == -ENAMETOOLONG)
				goto out;
			*op = '?';
			res = 1;
		}
		op += res;
		len -= res;
	}
	res = 0;
out:
	*len_p = (char *)op - astr;
	return res;
}

/*
 * Convert one or more ASCII characters into a single unicode character.
 * Returns the number of ASCII characters corresponding to the unicode char.
 */
static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
			      wchar_t *uc)
{
	int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc);
	if (size <= 0) {
		*uc = '?';
		size = 1;
	}
	switch (*uc) {
	case 0x2400:
		*uc = 0;
		break;
	case ':':
		*uc = '/';
		break;
	}
	return size;
}

/* Decomposes a single unicode character. */
static inline u16 *decompose_unichar(wchar_t uc, int *size)
{
	int off;

	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
	if (off == 0 || off == 0xffff)
		return NULL;

	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
	if (!off)
		return NULL;

	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
	if (!off)
		return NULL;

	off = hfsplus_decompose_table[off + (uc & 0xf)];
	*size = off & 3;
	if (*size == 0)
		return NULL;
	return hfsplus_decompose_table + (off / 4);
}

int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
		    const char *astr, int len)
{
	int size, dsize, decompose;
	u16 *dstr, outlen = 0;
	wchar_t c;

	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
		size = asc2unichar(sb, astr, len, &c);

		if (decompose && (dstr = decompose_unichar(c, &dsize))) {
			if (outlen + dsize > HFSPLUS_MAX_STRLEN)
				break;
			do {
				ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
			} while (--dsize > 0);
		} else
			ustr->unicode[outlen++] = cpu_to_be16(c);

		astr += size;
		len -= size;
	}
	ustr->length = cpu_to_be16(outlen);
	if (len > 0)
		return -ENAMETOOLONG;
	return 0;
}

/*
 * Hash a string to an integer as appropriate for the HFS+ filesystem.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
{
	struct super_block *sb = dentry->d_sb;
	const char *astr;
	const u16 *dstr;
	int casefold, decompose, size, dsize, len;
	unsigned long hash;
	wchar_t c;
	u16 c2;

	casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	hash = init_name_hash();
	astr = str->name;
	len = str->len;
	while (len > 0) {
		size = asc2unichar(sb, astr, len, &c);
		astr += size;
		len -= size;

		if (decompose && (dstr = decompose_unichar(c, &dsize))) {
			do {
				c2 = *dstr++;
				if (!casefold || (c2 = case_fold(c2)))
					hash = partial_name_hash(c2, hash);
			} while (--dsize > 0);
		} else {
			c2 = c;
			if (!casefold || (c2 = case_fold(c2)))
				hash = partial_name_hash(c2, hash);
		}
	}
	str->hash = end_name_hash(hash);

	return 0;
}

/*
 * Compare strings with HFS+ filename ordering.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2)
{
	struct super_block *sb = dentry->d_sb;
	int casefold, decompose, size;
	int dsize1, dsize2, len1, len2;
	const u16 *dstr1, *dstr2;
	const char *astr1, *astr2;
	u16 c1, c2;
	wchar_t c;

	casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	astr1 = s1->name;
	len1 = s1->len;
	astr2 = s2->name;
	len2 = s2->len;
	dsize1 = dsize2 = 0;
	dstr1 = dstr2 = NULL;

	while (len1 > 0 && len2 > 0) {
		if (!dsize1) {
			size = asc2unichar(sb, astr1, len1, &c);
			astr1 += size;
			len1 -= size;

			if (!decompose || !(dstr1 = decompose_unichar(c, &dsize1))) {
				c1 = c;
				dstr1 = &c1;
				dsize1 = 1;
			}
		}

		if (!dsize2) {
			size = asc2unichar(sb, astr2, len2, &c);
			astr2 += size;
			len2 -= size;

			if (!decompose || !(dstr2 = decompose_unichar(c, &dsize2))) {
				c2 = c;
				dstr2 = &c2;
				dsize2 = 1;
			}
		}

		c1 = *dstr1;
		c2 = *dstr2;
		if (casefold) {
			if  (!(c1 = case_fold(c1))) {
				dstr1++;
				dsize1--;
				continue;
			}
			if (!(c2 = case_fold(c2))) {
				dstr2++;
				dsize2--;
				continue;
			}
		}
		if (c1 < c2)
			return -1;
		else if (c1 > c2)
			return 1;

		dstr1++;
		dsize1--;
		dstr2++;
		dsize2--;
	}

	if (len1 < len2)
		return -1;
	if (len1 > len2)
		return 1;
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfsplus/unicode.c
	3	*
	4	* Copyright (C) 2001
	5	* Brad Boyer ([email protected])
	6	* (C) 2003 Ardis Technologies <[email protected]>
	7	*
	8	* Handler routines for unicode strings
	9	*/
	10
	11	#include <linux/types.h>
	12	#include <linux/nls.h>
	13	#include "hfsplus_fs.h"
	14	#include "hfsplus_raw.h"
	15
	16	/* Fold the case of a unicode char, given the 16 bit value */
	17	/* Returns folded char, or 0 if ignorable */
	18	static inline u16 case_fold(u16 c)
	19	{
	20	u16 tmp;
	21
	22	tmp = hfsplus_case_fold_table[c >> 8];
	23	if (tmp)
	24	tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
	25	else
	26	tmp = c;
	27	return tmp;
	28	}
	29
	30	/* Compare unicode strings, return values like normal strcmp */
2179d372 DE	31	int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
2179d372 DE	32	const struct hfsplus_unistr *s2)
1da177e4 LT	33	{
	34	u16 len1, len2, c1, c2;
	35	const hfsplus_unichr p1, p2;
	36
	37	len1 = be16_to_cpu(s1->length);
	38	len2 = be16_to_cpu(s2->length);
	39	p1 = s1->unicode;
	40	p2 = s2->unicode;
	41
	42	while (1) {
	43	c1 = c2 = 0;
	44
	45	while (len1 && !c1) {
	46	c1 = case_fold(be16_to_cpu(*p1));
	47	p1++;
	48	len1--;
	49	}
	50	while (len2 && !c2) {
	51	c2 = case_fold(be16_to_cpu(*p2));
	52	p2++;
	53	len2--;
	54	}
	55
	56	if (c1 != c2)
	57	return (c1 < c2) ? -1 : 1;
	58	if (!c1 && !c2)
	59	return 0;
	60	}
	61	}
	62
2179d372 DE	63	/* Compare names as a sequence of 16-bit unsigned integers */
	64	int hfsplus_strcmp(const struct hfsplus_unistr *s1,
	65	const struct hfsplus_unistr *s2)
	66	{
	67	u16 len1, len2, c1, c2;
	68	const hfsplus_unichr p1, p2;
	69	int len;
	70
	71	len1 = be16_to_cpu(s1->length);
	72	len2 = be16_to_cpu(s2->length);
	73	p1 = s1->unicode;
	74	p2 = s2->unicode;
	75
	76	for (len = min(len1, len2); len > 0; len--) {
	77	c1 = be16_to_cpu(*p1);
	78	c2 = be16_to_cpu(*p2);
	79	if (c1 != c2)
	80	return c1 < c2 ? -1 : 1;
	81	p1++;
	82	p2++;
	83	}
	84
	85	return len1 < len2 ? -1 :
	86	len1 > len2 ? 1 : 0;
	87	}
	88
	89
1da177e4 LT	90	#define Hangul_SBase 0xac00
	91	#define Hangul_LBase 0x1100
	92	#define Hangul_VBase 0x1161
	93	#define Hangul_TBase 0x11a7
	94	#define Hangul_SCount 11172
	95	#define Hangul_LCount 19
	96	#define Hangul_VCount 21
	97	#define Hangul_TCount 28
	98	#define Hangul_NCount (Hangul_VCount * Hangul_TCount)
	99
	100
	101	static u16 hfsplus_compose_lookup(u16 p, u16 cc)
	102	{
	103	int i, s, e;
	104
	105	s = 1;
	106	e = p[1];
	107	if (!e \|\| cc < p[s * 2] \|\| cc > p[e * 2])
	108	return NULL;
	109	do {
	110	i = (s + e) / 2;
	111	if (cc > p[i * 2])
	112	s = i + 1;
	113	else if (cc < p[i * 2])
	114	e = i - 1;
	115	else
	116	return hfsplus_compose_table + p[i * 2 + 1];
	117	} while (s <= e);
	118	return NULL;
	119	}
	120
	121	int hfsplus_uni2asc(struct super_block sb, const struct hfsplus_unistr ustr, char astr, int len_p)
	122	{
	123	const hfsplus_unichr *ip;
	124	struct nls_table *nls = HFSPLUS_SB(sb).nls;
	125	u8 *op;
	126	u16 cc, c0, c1;
	127	u16 ce1, ce2;
	128	int i, len, ustrlen, res, compose;
	129
	130	op = astr;
	131	ip = ustr->unicode;
	132	ustrlen = be16_to_cpu(ustr->length);
	133	len = *len_p;
	134	ce1 = NULL;
	135	compose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	136
	137	while (ustrlen > 0) {
	138	c0 = be16_to_cpu(*ip++);
	139	ustrlen--;
	140	/* search for single decomposed char */
	141	if (likely(compose))
	142	ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
	143	if (ce1 && (cc = ce1[0])) {
	144	/* start of a possibly decomposed Hangul char */
	145	if (cc != 0xffff)
	146	goto done;
	147	if (!ustrlen)
	148	goto same;
	149	c1 = be16_to_cpu(*ip) - Hangul_VBase;
	150	if (c1 < Hangul_VCount) {
	151	/* compose the Hangul char */
	152	cc = (c0 - Hangul_LBase) * Hangul_VCount;
	153	cc = (cc + c1) * Hangul_TCount;
154	cc += Hangul_SBase;
155	ip++;
156	ustrlen--;
157	if (!ustrlen)
158	goto done;
159	c1 = be16_to_cpu(*ip) - Hangul_TBase;
160	if (c1 > 0 && c1 < Hangul_TCount) {
161	cc += c1;
162	ip++;
163	ustrlen--;
164	}
165	goto done;
166	}
167	}
168	while (1) {
169	/* main loop for common case of not composed chars */
170	if (!ustrlen)
171	goto same;
172	c1 = be16_to_cpu(*ip);
173	if (likely(compose))
174	ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c1);
175	if (ce1)
176	break;
177	switch (c0) {
178	case 0:
179	c0 = 0x2400;
180	break;
181	case '/':
182	c0 = ':';
183	break;
184	}
185	res = nls->uni2char(c0, op, len);
186	if (res < 0) {
187	if (res == -ENAMETOOLONG)
188	goto out;
189	*op = '?';
190	res = 1;
191	}
192	op += res;
193	len -= res;
194	c0 = c1;
195	ip++;
196	ustrlen--;
197	}
198	ce2 = hfsplus_compose_lookup(ce1, c0);
199	if (ce2) {
200	i = 1;
201	while (i < ustrlen) {
202	ce1 = hfsplus_compose_lookup(ce2, be16_to_cpu(ip[i]));
203	if (!ce1)
204	break;
205	i++;
206	ce2 = ce1;
207	}
208	if ((cc = ce2[0])) {
209	ip += i;
210	ustrlen -= i;
211	goto done;
212	}
213	}
214	same:
215	switch (c0) {
216	case 0:
217	cc = 0x2400;
218	break;
219	case '/':
220	cc = ':';
221	break;
222	default:
223	cc = c0;
224	}
225	done:
226	res = nls->uni2char(cc, op, len);
227	if (res < 0) {
228	if (res == -ENAMETOOLONG)
229	goto out;
230	*op = '?';
231	res = 1;
232	}
233	op += res;
234	len -= res;
235	}
236	res = 0;
237	out:
238	len_p = (char )op - astr;
239	return res;
240	}
241
1e96b7ca DG	242	/*
	243	* Convert one or more ASCII characters into a single unicode character.
	244	* Returns the number of ASCII characters corresponding to the unicode char.
	245	*/
	246	static inline int asc2unichar(struct super_block sb, const char astr, int len,
	247	wchar_t *uc)
1da177e4	248	{
1e96b7ca DG	249	int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc);
	250	if (size <= 0) {
	251	*uc = '?';
	252	size = 1;
	253	}
	254	switch (*uc) {
	255	case 0x2400:
	256	*uc = 0;
	257	break;
	258	case ':':
	259	*uc = '/';
	260	break;
	261	}
	262	return size;
	263	}
	264
	265	/* Decomposes a single unicode character. */
	266	static inline u16 decompose_unichar(wchar_t uc, int size)
	267	{
	268	int off;
	269
	270	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
	271	if (off == 0 \|\| off == 0xffff)
	272	return NULL;
	273
	274	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
	275	if (!off)
	276	return NULL;
	277
	278	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
	279	if (!off)
	280	return NULL;
	281
	282	off = hfsplus_decompose_table[off + (uc & 0xf)];
	283	*size = off & 3;
	284	if (*size == 0)
	285	return NULL;
	286	return hfsplus_decompose_table + (off / 4);
	287	}
	288
	289	int hfsplus_asc2uni(struct super_block sb, struct hfsplus_unistr ustr,
	290	const char *astr, int len)
	291	{
	292	int size, dsize, decompose;
	293	u16 *dstr, outlen = 0;
1da177e4	294	wchar_t c;
1da177e4 LT	295
1da177e4 LT	296	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
1da177e4	297	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
1e96b7ca DG	298	size = asc2unichar(sb, astr, len, &c);
	299
	300	if (decompose && (dstr = decompose_unichar(c, &dsize))) {
	301	if (outlen + dsize > HFSPLUS_MAX_STRLEN)
1da177e4 LT	302	break;
1da177e4 LT	303	do {
1e96b7ca DG	304	ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
	305	} while (--dsize > 0);
	306	} else
	307	ustr->unicode[outlen++] = cpu_to_be16(c);
	308
	309	astr += size;
	310	len -= size;
1da177e4 LT	311	}
	312	ustr->length = cpu_to_be16(outlen);
	313	if (len > 0)
	314	return -ENAMETOOLONG;
	315	return 0;
	316	}
d45bce8f DG	317
	318	/*
	319	* Hash a string to an integer as appropriate for the HFS+ filesystem.
	320	* Composed unicode characters are decomposed and case-folding is performed
	321	* if the appropriate bits are (un)set on the superblock.
	322	*/
	323	int hfsplus_hash_dentry(struct dentry dentry, struct qstr str)
	324	{
	325	struct super_block *sb = dentry->d_sb;
	326	const char *astr;
	327	const u16 *dstr;
	328	int casefold, decompose, size, dsize, len;
	329	unsigned long hash;
	330	wchar_t c;
	331	u16 c2;
	332
	333	casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
	334	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	335	hash = init_name_hash();
	336	astr = str->name;
	337	len = str->len;
	338	while (len > 0) {
	339	size = asc2unichar(sb, astr, len, &c);
	340	astr += size;
	341	len -= size;
	342
	343	if (decompose && (dstr = decompose_unichar(c, &dsize))) {
	344	do {
	345	c2 = *dstr++;
	346	if (!casefold \|\| (c2 = case_fold(c2)))
	347	hash = partial_name_hash(c2, hash);
	348	} while (--dsize > 0);
	349	} else {
	350	c2 = c;
	351	if (!casefold \|\| (c2 = case_fold(c2)))
	352	hash = partial_name_hash(c2, hash);
	353	}
	354	}
	355	str->hash = end_name_hash(hash);
	356
	357	return 0;
	358	}
	359
	360	/*
	361	* Compare strings with HFS+ filename ordering.
	362	* Composed unicode characters are decomposed and case-folding is performed
	363	* if the appropriate bits are (un)set on the superblock.
	364	*/
	365	int hfsplus_compare_dentry(struct dentry dentry, struct qstr s1, struct qstr *s2)
	366	{
	367	struct super_block *sb = dentry->d_sb;
	368	int casefold, decompose, size;
	369	int dsize1, dsize2, len1, len2;
	370	const u16 dstr1, dstr2;
	371	const char astr1, astr2;
	372	u16 c1, c2;
	373	wchar_t c;
	374
	375	casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
	376	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
	377	astr1 = s1->name;
	378	len1 = s1->len;
	379	astr2 = s2->name;
	380	len2 = s2->len;
381	dsize1 = dsize2 = 0;
382	dstr1 = dstr2 = NULL;
383
384	while (len1 > 0 && len2 > 0) {
385	if (!dsize1) {
386	size = asc2unichar(sb, astr1, len1, &c);
387	astr1 += size;
388	len1 -= size;
389
390	if (!decompose \|\| !(dstr1 = decompose_unichar(c, &dsize1))) {
391	c1 = c;
392	dstr1 = &c1;
393	dsize1 = 1;
394	}
395	}
396
397	if (!dsize2) {
398	size = asc2unichar(sb, astr2, len2, &c);
399	astr2 += size;
400	len2 -= size;
401
402	if (!decompose \|\| !(dstr2 = decompose_unichar(c, &dsize2))) {
403	c2 = c;
404	dstr2 = &c2;
405	dsize2 = 1;
406	}
407	}
408
409	c1 = *dstr1;
410	c2 = *dstr2;
411	if (casefold) {
412	if (!(c1 = case_fold(c1))) {
413	dstr1++;
414	dsize1--;
415	continue;
416	}
417	if (!(c2 = case_fold(c2))) {
418	dstr2++;
419	dsize2--;
420	continue;
421	}
422	}
423	if (c1 < c2)
424	return -1;
425	else if (c1 > c2)
426	return 1;
427
428	dstr1++;
429	dsize1--;
430	dstr2++;
431	dsize2--;
432	}
433
434	if (len1 < len2)
435	return -1;
436	if (len1 > len2)
437	return 1;
438	return 0;
439	}