HFS+: refactor ASCII to unicode conversion routine for later reuse

[safe/jmp/linux-2.6] / fs / hfsplus / unicode.c

diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index 060c690..5df0052 100644 (file)
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -28,7 +28,8 @@ static inline u16 case_fold(u16 c)
 }
 
 /* Compare unicode strings, return values like normal strcmp */
-int hfsplus_unistrcmp(const struct hfsplus_unistr *s1, const struct hfsplus_unistr *s2)
+int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
+                      const struct hfsplus_unistr *s2)
 {
        u16 len1, len2, c1, c2;
        const hfsplus_unichr *p1, *p2;
@@ -59,6 +60,33 @@ int hfsplus_unistrcmp(const struct hfsplus_unistr *s1, const struct hfsplus_unis
        }
 }
 
+/* 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
@@ -211,58 +239,75 @@ out:
        return res;
 }
 
-int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr, const char *astr, int len)
+/*
+ * 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)
 {
-       struct nls_table *nls = HFSPLUS_SB(sb).nls;
-       int size, off, decompose;
+       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;
-       u16 outlen = 0;
 
        decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
-
        while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
-               size = nls->char2uni(astr, len, &c);
-               if (size <= 0) {
-                       c = '?';
-                       size = 1;
-               }
-               astr += size;
-               len -= size;
-               switch (c) {
-               case 0x2400:
-                       c = 0;
-                       break;
-               case ':':
-                       c = '/';
-                       break;
-               }
-               if (c >= 0xc0 && decompose) {
-                       off = hfsplus_decompose_table[(c >> 12) & 0xf];
-                       if (!off)
-                               goto done;
-                       if (off == 0xffff) {
-                               goto done;
-                       }
-                       off = hfsplus_decompose_table[off + ((c >> 8) & 0xf)];
-                       if (!off)
-                               goto done;
-                       off = hfsplus_decompose_table[off + ((c >> 4) & 0xf)];
-                       if (!off)
-                               goto done;
-                       off = hfsplus_decompose_table[off + (c & 0xf)];
-                       size = off & 3;
-                       if (!size)
-                               goto done;
-                       off /= 4;
-                       if (outlen + size > HFSPLUS_MAX_STRLEN)
+               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(hfsplus_decompose_table[off++]);
-                       } while (--size > 0);
-                       continue;
-               }
-       done:
-               ustr->unicode[outlen++] = cpu_to_be16(c);
+                               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)