632. Finish off the UTF-16 APIs in Xft, and fix the UTF-16 conversion code

[fontconfig.git] / src / fcstr.c

diff --git a/src/fcstr.c b/src/fcstr.c
index 796ccc320b33762ae3d5435a7c0e76711218bd00..a51be35b71932e41aca74b5b614873ff0b4917e2 100644 (file)
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -1,5 +1,5 @@
 /*
- * $XFree86: xc/lib/fontconfig/src/fcstr.c,v 1.3 2002/02/18 22:29:28 keithp Exp $
+ * $XFree86: xc/lib/fontconfig/src/fcstr.c,v 1.10 2002/08/31 22:17:32 keithp Exp $
  *
  * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
  *
@@ -79,7 +79,30 @@ FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
        if (c1 != c2)
            break;
     }
-    return (int) c2 - (int) c1;
+    return (int) c1 - (int) c2;
+}
+
+int
+FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcChar8 c1, c2;
+    
+    for (;;) 
+    {
+       do
+           c1 = *s1++;
+       while (c1 == ' ');
+       do
+           c2 = *s2++;
+       while (c2 == ' ');
+       if (!c1 || !c2)
+           break;
+       c1 = FcToLower (c1);
+       c2 = FcToLower (c2);
+       if (c1 != c2)
+           break;
+    }
+    return (int) c1 - (int) c2;
 }
 
 int
@@ -98,18 +121,18 @@ FcStrCmp (const FcChar8 *s1, const FcChar8 *s2)
        if (c1 != c2)
            break;
     }
-    return (int) c2 - (int) c1;
+    return (int) c1 - (int) c2;
 }
 
 int
-FcUtf8ToUcs4 (FcChar8   *src_orig,
-             FcChar32  *dst,
-             int       len)
+FcUtf8ToUcs4 (const FcChar8 *src_orig,
+             FcChar32      *dst,
+             int           len)
 {
-    FcChar8    *src = src_orig;
-    FcChar8    s;
-    int                extra;
-    FcChar32   result;
+    const FcChar8   *src = src_orig;
+    FcChar8        s;
+    int                    extra;
+    FcChar32       result;
 
     if (len == 0)
        return 0;
@@ -173,10 +196,10 @@ FcUtf8ToUcs4 (FcChar8   *src_orig,
 }
 
 FcBool
-FcUtf8Len (FcChar8     *string,
-           int         len,
-           int         *nchar,
-           int         *wchar)
+FcUtf8Len (const FcChar8    *string,
+          int              len,
+          int              *nchar,
+          int              *wchar)
 {
     int                n;
     int                clen;
@@ -206,6 +229,103 @@ FcUtf8Len (FcChar8        *string,
     return FcTrue;
 }
 
+int
+FcUcs4ToUtf8 (FcChar32 ucs4,
+             FcChar8   dest[FC_UTF8_MAX_LEN])
+{
+    int        bits;
+    FcChar8 *d = dest;
+    
+    if      (ucs4 <       0x80) {  *d++=  ucs4;                         bits= -6; }
+    else if (ucs4 <      0x800) {  *d++= ((ucs4 >>  6) & 0x1F) | 0xC0;  bits=  0; }
+    else if (ucs4 <    0x10000) {  *d++= ((ucs4 >> 12) & 0x0F) | 0xE0;  bits=  6; }
+    else if (ucs4 <   0x200000) {  *d++= ((ucs4 >> 18) & 0x07) | 0xF0;  bits= 12; }
+    else if (ucs4 <  0x4000000) {  *d++= ((ucs4 >> 24) & 0x03) | 0xF8;  bits= 18; }
+    else if (ucs4 < 0x80000000) {  *d++= ((ucs4 >> 30) & 0x01) | 0xFC;  bits= 24; }
+    else return 0;
+
+    for ( ; bits >= 0; bits-= 6) {
+       *d++= ((ucs4 >> bits) & 0x3F) | 0x80;
+    }
+    return d - dest;
+}
+
+#define GetUtf16(src,endian) \
+    ((FcChar16) ((src)[endian == FcEndianBig ? 0 : 1] << 8) | \
+     (FcChar16) ((src)[endian == FcEndianBig ? 1 : 0]))
+
+int
+FcUtf16ToUcs4 (const FcChar8   *src_orig,
+              FcEndian         endian,
+              FcChar32         *dst,
+              int              len)    /* in bytes */
+{
+    const FcChar8   *src = src_orig;
+    FcChar16       a, b;
+    FcChar32       result;
+
+    if (len < 2)
+       return 0;
+    
+    a = GetUtf16 (src, endian); src += 2; len -= 2;
+    
+    /* 
+     * Check for surrogate 
+     */
+    if ((a & 0xfc00) == 0xd800)
+    {
+       if (len < 2)
+           return 0;
+       b = GetUtf16 (src, endian); src += 2; len -= 2;
+       /*
+        * Check for invalid surrogate sequence
+        */
+       if ((b & 0xfc00) != 0xdc00)
+           return 0;
+       result = ((((FcChar32) a & 0x3ff) << 10) |
+                 ((FcChar32) b & 0x3ff)) + 0x10000;
+    }
+    else
+       result = a;
+    *dst = result;
+    return src - src_orig;
+}
+
+FcBool
+FcUtf16Len (const FcChar8   *string,
+           FcEndian        endian,
+           int             len,        /* in bytes */
+           int             *nchar,
+           int             *wchar)
+{
+    int                n;
+    int                clen;
+    FcChar32   c;
+    FcChar32   max;
+    
+    n = 0;
+    max = 0;
+    while (len)
+    {
+       clen = FcUtf16ToUcs4 (string, endian, &c, len);
+       if (clen <= 0)  /* malformed UTF8 string */
+           return FcFalse;
+       if (c > max)
+           max = c;
+       string += clen;
+       len -= clen;
+       n++;
+    }
+    *nchar = n;
+    if (max >= 0x10000)
+       *wchar = 4;
+    else if (max > 0x100)
+       *wchar = 2;
+    else
+       *wchar = 1;
+    return FcTrue;
+}
+
 void
 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size)
 {
@@ -221,6 +341,7 @@ FcStrBufDestroy (FcStrBuf *buf)
 {
     if (buf->allocated)
     {
+       FcMemFree (FC_MEM_STRBUF, buf->size);
        free (buf->buf);
        FcStrBufInit (buf, 0, 0);
     }
@@ -234,6 +355,7 @@ FcStrBufDone (FcStrBuf *buf)
     ret = malloc (buf->len + 1);
     if (ret)
     {
+       FcMemAlloc (FC_MEM_STRING, buf->len + 1);
        memcpy (ret, buf->buf, buf->len);
        ret[buf->len] = '\0';
     }
@@ -269,6 +391,9 @@ FcStrBufChar (FcStrBuf *buf, FcChar8 c)
            buf->failed = FcTrue;
            return FcFalse;
        }
+       if (buf->size)
+           FcMemFree (FC_MEM_STRBUF, buf->size);
+       FcMemAlloc (FC_MEM_STRBUF, size);
        buf->size = size;
        buf->buf = new;
     }
@@ -406,6 +531,18 @@ FcStrSetMember (FcStrSet *set, const FcChar8 *s)
     return FcFalse;
 }
 
+FcBool
+FcStrSetEqual (FcStrSet *sa, FcStrSet *sb)
+{
+    int        i;
+    if (sa->num != sb->num)
+       return FcFalse;
+    for (i = 0; i < sa->num; i++)
+       if (!FcStrSetMember (sb, sa->strs[i]))
+           return FcFalse;
+    return FcTrue;
+}
+
 FcBool
 FcStrSetAdd (FcStrSet *set, const FcChar8 *s)
 {