[linux-2.6-block.git] / fs / hfsplus / unicode.c

/*
 *  linux/fs/hfsplus/unicode.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * 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 = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);

	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];
		else
			cc = 0;
		if (cc) {
			/* 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;
			}
			cc = ce2[0];
			if (cc) {
				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 = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
		size = asc2unichar(sb, astr, len, &c);

		if (decompose)
			dstr = decompose_unichar(c, &dsize);
		else
			dstr = NULL;
		if (dstr) {
			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(const struct dentry *dentry, const struct inode *inode,
		struct qstr *str)
{
	struct super_block *sb = dentry->d_sb;
	const char *astr;
	const u16 *dstr;
	int casefold, decompose, size, len;
	unsigned long hash;
	wchar_t c;
	u16 c2;

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

		if (decompose)
			dstr = decompose_unichar(c, &dsize);
		else
			dstr = NULL;
		if (dstr) {
			do {
				c2 = *dstr++;
				if (casefold)
					c2 = case_fold(c2);
				if (!casefold || c2)
					hash = partial_name_hash(c2, hash);
			} while (--dsize > 0);
		} else {
			c2 = c;
			if (casefold)
				c2 = case_fold(c2);
			if (!casefold || 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(const struct dentry *parent,
		const struct inode *pinode,
		const struct dentry *dentry, const struct inode *inode,
		unsigned int len, const char *str, const struct qstr *name)
{
	struct super_block *sb = parent->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 = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
	astr1 = str;
	len1 = len;
	astr2 = name->name;
	len2 = name->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);
			if (!decompose || !dstr1) {
				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);
			if (!decompose || !dstr2) {
				c2 = c;
				dstr2 = &c2;
				dsize2 = 1;
			}
		}

		c1 = *dstr1;
		c2 = *dstr2;
		if (casefold) {
			c1 = case_fold(c1);
			if (!c1) {
				dstr1++;
				dsize1--;
				continue;
			}
			c2 = case_fold(c2);
			if (!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 (flar@allandria.com)
	6	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	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	{
20b7643d	20	u16 tmp;
1da177e4	21
20b7643d AS	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;
1da177e4 LT	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
2753cc28 AS	121	int hfsplus_uni2asc(struct super_block *sb,
	122	const struct hfsplus_unistr *ustr,
	123	char astr, int len_p)
1da177e4 LT	124	{
1da177e4 LT	125	const hfsplus_unichr *ip;
dd73a01a	126	struct nls_table *nls = HFSPLUS_SB(sb)->nls;
1da177e4 LT	127	u8 *op;
	128	u16 cc, c0, c1;
	129	u16 ce1, ce2;
	130	int i, len, ustrlen, res, compose;
	131
	132	op = astr;
	133	ip = ustr->unicode;
	134	ustrlen = be16_to_cpu(ustr->length);
	135	len = *len_p;
	136	ce1 = NULL;
84adede3	137	compose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
1da177e4 LT	138
	139	while (ustrlen > 0) {
	140	c0 = be16_to_cpu(*ip++);
	141	ustrlen--;
	142	/* search for single decomposed char */
	143	if (likely(compose))
	144	ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
2b4f9ca8 AS	145	if (ce1)
	146	cc = ce1[0];
	147	else
	148	cc = 0;
	149	if (cc) {
1da177e4 LT	150	/* start of a possibly decomposed Hangul char */
	151	if (cc != 0xffff)
	152	goto done;
	153	if (!ustrlen)
	154	goto same;
	155	c1 = be16_to_cpu(*ip) - Hangul_VBase;
	156	if (c1 < Hangul_VCount) {
	157	/* compose the Hangul char */
	158	cc = (c0 - Hangul_LBase) * Hangul_VCount;
	159	cc = (cc + c1) * Hangul_TCount;
	160	cc += Hangul_SBase;
	161	ip++;
	162	ustrlen--;
	163	if (!ustrlen)
	164	goto done;
	165	c1 = be16_to_cpu(*ip) - Hangul_TBase;
	166	if (c1 > 0 && c1 < Hangul_TCount) {
	167	cc += c1;
	168	ip++;
	169	ustrlen--;
	170	}
	171	goto done;
	172	}
	173	}
	174	while (1) {
	175	/* main loop for common case of not composed chars */
	176	if (!ustrlen)
	177	goto same;
	178	c1 = be16_to_cpu(*ip);
	179	if (likely(compose))
2753cc28 AS	180	ce1 = hfsplus_compose_lookup(
2753cc28 AS	181	hfsplus_compose_table, c1);
1da177e4 LT	182	if (ce1)
	183	break;
	184	switch (c0) {
	185	case 0:
	186	c0 = 0x2400;
	187	break;
	188	case '/':
	189	c0 = ':';
	190	break;
	191	}
	192	res = nls->uni2char(c0, op, len);
	193	if (res < 0) {
	194	if (res == -ENAMETOOLONG)
	195	goto out;
	196	*op = '?';
	197	res = 1;
	198	}
	199	op += res;
	200	len -= res;
	201	c0 = c1;
	202	ip++;
	203	ustrlen--;
	204	}
	205	ce2 = hfsplus_compose_lookup(ce1, c0);
	206	if (ce2) {
	207	i = 1;
	208	while (i < ustrlen) {
2753cc28 AS	209	ce1 = hfsplus_compose_lookup(ce2,
2753cc28 AS	210	be16_to_cpu(ip[i]));
1da177e4 LT	211	if (!ce1)
	212	break;
	213	i++;
	214	ce2 = ce1;
	215	}
2b4f9ca8 AS	216	cc = ce2[0];
2b4f9ca8 AS	217	if (cc) {
1da177e4 LT	218	ip += i;
	219	ustrlen -= i;
	220	goto done;
	221	}
	222	}
20b7643d	223	same:
1da177e4 LT	224	switch (c0) {
	225	case 0:
	226	cc = 0x2400;
	227	break;
	228	case '/':
	229	cc = ':';
	230	break;
	231	default:
	232	cc = c0;
	233	}
20b7643d	234	done:
1da177e4 LT	235	res = nls->uni2char(cc, op, len);
	236	if (res < 0) {
	237	if (res == -ENAMETOOLONG)
	238	goto out;
	239	*op = '?';
	240	res = 1;
	241	}
	242	op += res;
	243	len -= res;
	244	}
	245	res = 0;
	246	out:
	247	len_p = (char )op - astr;
	248	return res;
	249	}
	250
1e96b7ca DG	251	/*
	252	* Convert one or more ASCII characters into a single unicode character.
	253	* Returns the number of ASCII characters corresponding to the unicode char.
	254	*/
	255	static inline int asc2unichar(struct super_block sb, const char astr, int len,
	256	wchar_t *uc)
1da177e4	257	{
dd73a01a	258	int size = HFSPLUS_SB(sb)->nls->char2uni(astr, len, uc);
1e96b7ca DG	259	if (size <= 0) {
	260	*uc = '?';
	261	size = 1;
	262	}
	263	switch (*uc) {
	264	case 0x2400:
	265	*uc = 0;
	266	break;
	267	case ':':
	268	*uc = '/';
	269	break;
	270	}
	271	return size;
	272	}
	273
	274	/* Decomposes a single unicode character. */
	275	static inline u16 decompose_unichar(wchar_t uc, int size)
	276	{
	277	int off;
	278
	279	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
	280	if (off == 0 \|\| off == 0xffff)
	281	return NULL;
	282
	283	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
	284	if (!off)
	285	return NULL;
	286
	287	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
	288	if (!off)
	289	return NULL;
	290
	291	off = hfsplus_decompose_table[off + (uc & 0xf)];
	292	*size = off & 3;
	293	if (*size == 0)
	294	return NULL;
	295	return hfsplus_decompose_table + (off / 4);
	296	}
	297
	298	int hfsplus_asc2uni(struct super_block sb, struct hfsplus_unistr ustr,
	299	const char *astr, int len)
	300	{
	301	int size, dsize, decompose;
	302	u16 *dstr, outlen = 0;
1da177e4	303	wchar_t c;
1da177e4	304
84adede3	305	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
1da177e4	306	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
1e96b7ca DG	307	size = asc2unichar(sb, astr, len, &c);
1e96b7ca DG	308
2b4f9ca8 AS	309	if (decompose)
	310	dstr = decompose_unichar(c, &dsize);
	311	else
	312	dstr = NULL;
	313	if (dstr) {
1e96b7ca	314	if (outlen + dsize > HFSPLUS_MAX_STRLEN)
1da177e4 LT	315	break;
1da177e4 LT	316	do {
1e96b7ca DG	317	ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
	318	} while (--dsize > 0);
	319	} else
	320	ustr->unicode[outlen++] = cpu_to_be16(c);
	321
	322	astr += size;
	323	len -= size;
1da177e4 LT	324	}
	325	ustr->length = cpu_to_be16(outlen);
	326	if (len > 0)
	327	return -ENAMETOOLONG;
	328	return 0;
	329	}
d45bce8f DG	330
	331	/*
	332	* Hash a string to an integer as appropriate for the HFS+ filesystem.
	333	* Composed unicode characters are decomposed and case-folding is performed
	334	* if the appropriate bits are (un)set on the superblock.
	335	*/
b1e6a015 NP	336	int hfsplus_hash_dentry(const struct dentry dentry, const struct inode inode,
b1e6a015 NP	337	struct qstr *str)
d45bce8f DG	338	{
	339	struct super_block *sb = dentry->d_sb;
	340	const char *astr;
	341	const u16 *dstr;
8aa84ab9	342	int casefold, decompose, size, len;
d45bce8f DG	343	unsigned long hash;
	344	wchar_t c;
	345	u16 c2;
	346
84adede3 CH	347	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	348	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
d45bce8f DG	349	hash = init_name_hash();
	350	astr = str->name;
	351	len = str->len;
	352	while (len > 0) {
8aa84ab9	353	int uninitialized_var(dsize);
d45bce8f DG	354	size = asc2unichar(sb, astr, len, &c);
	355	astr += size;
	356	len -= size;
	357
2b4f9ca8 AS	358	if (decompose)
	359	dstr = decompose_unichar(c, &dsize);
	360	else
	361	dstr = NULL;
	362	if (dstr) {
d45bce8f DG	363	do {
d45bce8f DG	364	c2 = *dstr++;
2b4f9ca8 AS	365	if (casefold)
	366	c2 = case_fold(c2);
	367	if (!casefold \|\| c2)
d45bce8f DG	368	hash = partial_name_hash(c2, hash);
	369	} while (--dsize > 0);
	370	} else {
	371	c2 = c;
2b4f9ca8 AS	372	if (casefold)
	373	c2 = case_fold(c2);
	374	if (!casefold \|\| c2)
d45bce8f DG	375	hash = partial_name_hash(c2, hash);
	376	}
	377	}
	378	str->hash = end_name_hash(hash);
	379
	380	return 0;
	381	}
	382
	383	/*
	384	* Compare strings with HFS+ filename ordering.
	385	* Composed unicode characters are decomposed and case-folding is performed
	386	* if the appropriate bits are (un)set on the superblock.
	387	*/
621e155a NP	388	int hfsplus_compare_dentry(const struct dentry *parent,
	389	const struct inode *pinode,
	390	const struct dentry dentry, const struct inode inode,
	391	unsigned int len, const char str, const struct qstr name)
d45bce8f	392	{
621e155a	393	struct super_block *sb = parent->d_sb;
d45bce8f DG	394	int casefold, decompose, size;
	395	int dsize1, dsize2, len1, len2;
	396	const u16 dstr1, dstr2;
	397	const char astr1, astr2;
	398	u16 c1, c2;
	399	wchar_t c;
	400
84adede3 CH	401	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	402	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
621e155a NP	403	astr1 = str;
	404	len1 = len;
	405	astr2 = name->name;
	406	len2 = name->len;
d45bce8f DG	407	dsize1 = dsize2 = 0;
	408	dstr1 = dstr2 = NULL;
	409
	410	while (len1 > 0 && len2 > 0) {
	411	if (!dsize1) {
	412	size = asc2unichar(sb, astr1, len1, &c);
	413	astr1 += size;
	414	len1 -= size;
	415
2753cc28 AS	416	if (decompose)
	417	dstr1 = decompose_unichar(c, &dsize1);
	418	if (!decompose \|\| !dstr1) {
d45bce8f DG	419	c1 = c;
	420	dstr1 = &c1;
	421	dsize1 = 1;
	422	}
	423	}
	424
	425	if (!dsize2) {
	426	size = asc2unichar(sb, astr2, len2, &c);
	427	astr2 += size;
	428	len2 -= size;
	429
2753cc28 AS	430	if (decompose)
	431	dstr2 = decompose_unichar(c, &dsize2);
	432	if (!decompose \|\| !dstr2) {
d45bce8f DG	433	c2 = c;
	434	dstr2 = &c2;
	435	dsize2 = 1;
	436	}
	437	}
	438
	439	c1 = *dstr1;
	440	c2 = *dstr2;
	441	if (casefold) {
2b4f9ca8 AS	442	c1 = case_fold(c1);
2b4f9ca8 AS	443	if (!c1) {
d45bce8f DG	444	dstr1++;
	445	dsize1--;
	446	continue;
	447	}
2b4f9ca8 AS	448	c2 = case_fold(c2);
2b4f9ca8 AS	449	if (!c2) {
d45bce8f DG	450	dstr2++;
	451	dsize2--;
	452	continue;
	453	}
	454	}
	455	if (c1 < c2)
	456	return -1;
	457	else if (c1 > c2)
	458	return 1;
	459
	460	dstr1++;
	461	dsize1--;
	462	dstr2++;
	463	dsize2--;
	464	}
	465
	466	if (len1 < len2)
	467	return -1;
	468	if (len1 > len2)
	469	return 1;
	470	return 0;
	471	}