Moved, renamed, and deleted files

The original directory structure was scattered and unorganized.
Changes are basically to make it look like kernel structure.

1 files changed, 0 insertions, 471 deletions

diff --git a/ANDROID_3.4.5/fs/hfsplus/unicode.c b/ANDROID_3.4.5/fs/hfsplus/unicode.c
deleted file mode 100644
index a32998f2..00000000
--- a/ANDROID_3.4.5/fs/hfsplus/unicode.c
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- *  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;
-}