Synchronised line endinge with release branch

1 files changed, 1198 insertions, 1198 deletions

diff --git a/fontconfig/src/fcstr.c b/fontconfig/src/fcstr.c
index 6aee5d288..8b94ecba5 100644
--- a/fontconfig/src/fcstr.c
+++ b/fontconfig/src/fcstr.c
@@ -1,1198 +1,1198 @@
-/*

- * fontconfig/src/fcstr.c

- *

- * Copyright © 2000 Keith Packard

- *

- * Permission to use, copy, modify, distribute, and sell this software and its

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of the author(s) not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  The authors make no

- * representations about the suitability of this software for any purpose.  It

- * is provided "as is" without express or implied warranty.

- *

- * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

- * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR

- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

- * PERFORMANCE OF THIS SOFTWARE.

- */

-

-#include "fcint.h"

-#include <stdlib.h>

-#include <ctype.h>

-#include <string.h>

-#ifdef _WIN32

-#include <windows.h>

-#endif

-

-FcChar8 *

-FcStrCopy (const FcChar8 *s)

-{

-    int     len;

-    FcChar8 *r;

-

-    if (!s)

-	return 0;

-    len = strlen ((char *) s) + 1;

-    r = (FcChar8 *) malloc (len);

-    if (!r)

-	return 0;

-    FcMemAlloc (FC_MEM_STRING, len);

-    memcpy (r, s, len);

-    return r;

-}

-

-FcChar8 *

-FcStrPlus (const FcChar8 *s1, const FcChar8 *s2)

-{

-    int	    l = strlen ((char *)s1) + strlen ((char *) s2) + 1;

-    FcChar8 *s = malloc (l);

-

-    if (!s)

-	return 0;

-    FcMemAlloc (FC_MEM_STRING, l);

-    strcpy ((char *) s, (char *) s1);

-    strcat ((char *) s, (char *) s2);

-    return s;

-}

-

-void

-FcStrFree (FcChar8 *s)

-{

-    FcMemFree (FC_MEM_STRING, strlen ((char *) s) + 1);

-    free (s);

-}

-

-

-#include "../fc-case/fccase.h"

-

-#define FcCaseFoldUpperCount(cf) \

-    ((cf)->method == FC_CASE_FOLD_FULL ? 1 : (cf)->count)

-

-#define FC_STR_CANON_BUF_LEN	1024

-

-typedef struct _FcCaseWalker {

-    const FcChar8   *read;

-    const FcChar8   *src;

-    FcChar8	    utf8[FC_MAX_CASE_FOLD_CHARS + 1];

-} FcCaseWalker;

-

-static void

-FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)

-{

-    w->src = src;

-    w->read = 0;

-}

-

-static FcChar8

-FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)

-{

-    FcChar32	ucs4;

-    int		slen;

-    int		len = strlen((char*)w->src);

-

-    slen = FcUtf8ToUcs4 (w->src - 1, &ucs4, len + 1);

-    if (slen <= 0)

-	return r;

-    if (FC_MIN_FOLD_CHAR <= ucs4 && ucs4 <= FC_MAX_FOLD_CHAR)

-    {

-	int min = 0;

-	int max = FC_NUM_CASE_FOLD;

-

-	while (min <= max)

-	{

-	    int		mid = (min + max) >> 1;

-	    FcChar32    low = fcCaseFold[mid].upper;

-	    FcChar32    high = low + FcCaseFoldUpperCount (&fcCaseFold[mid]);

-	

-	    if (high <= ucs4)

-		min = mid + 1;

-	    else if (ucs4 < low)

-		max = mid - 1;

-	    else

-	    {

-		const FcCaseFold    *fold = &fcCaseFold[mid];

-		int		    dlen;

-		

-		switch (fold->method) {

-		case  FC_CASE_FOLD_EVEN_ODD:

-		    if ((ucs4 & 1) != (fold->upper & 1))

-			return r;

-		    /* fall through ... */

-		default:

-		    dlen = FcUcs4ToUtf8 (ucs4 + fold->offset, w->utf8);

-		    break;

-		case FC_CASE_FOLD_FULL:

-		    dlen = fold->count;

-		    memcpy (w->utf8, fcCaseFoldChars + fold->offset, dlen);

-		    break;

-		}

-		

-		/* consume rest of src utf-8 bytes */

-		w->src += slen - 1;

-		

-		/* read from temp buffer */

-		w->utf8[dlen] = '\0';

-		w->read = w->utf8;

-		return *w->read++;

-	    }

-	}

-    }

-    return r;

-}

-

-static FcChar8

-FcStrCaseWalkerNext (FcCaseWalker *w)

-{

-    FcChar8	r;

-

-    if (w->read)

-    {

-	if ((r = *w->read++))

-	    return r;

-	w->read = 0;

-    }

-    r = *w->src++;

-

-    if ((r & 0xc0) == 0xc0)

-	return FcStrCaseWalkerLong (w, r);

-    if ('A' <= r && r <= 'Z')

-        r = r - 'A' + 'a';

-    return r;

-}

-

-static FcChar8

-FcStrCaseWalkerNextIgnoreBlanks (FcCaseWalker *w)

-{

-    FcChar8	r;

-

-    if (w->read)

-    {

-	if ((r = *w->read++))

-	    return r;

-	w->read = 0;

-    }

-    do

-    {

-	r = *w->src++;

-    } while (r == ' ');

-

-    if ((r & 0xc0) == 0xc0)

-	return FcStrCaseWalkerLong (w, r);

-    if ('A' <= r && r <= 'Z')

-        r = r - 'A' + 'a';

-    return r;

-}

-

-FcChar8 *

-FcStrDowncase (const FcChar8 *s)

-{

-    FcCaseWalker    w;

-    int		    len = 0;

-    FcChar8	    *dst, *d;

-

-    FcStrCaseWalkerInit (s, &w);

-    while (FcStrCaseWalkerNext (&w))

-	len++;

-    d = dst = malloc (len + 1);

-    if (!d)

-	return 0;

-    FcMemAlloc (FC_MEM_STRING, len + 1);

-    FcStrCaseWalkerInit (s, &w);

-    while ((*d++ = FcStrCaseWalkerNext (&w)));

-    return dst;

-}

-

-int

-FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcCaseWalker    w1, w2;

-    FcChar8	    c1, c2;

-

-    if (s1 == s2) return 0;

-

-    FcStrCaseWalkerInit (s1, &w1);

-    FcStrCaseWalkerInit (s2, &w2);

-

-    for (;;)

-    {

-	c1 = FcStrCaseWalkerNext (&w1);

-	c2 = FcStrCaseWalkerNext (&w2);

-	if (!c1 || (c1 != c2))

-	    break;

-    }

-    return (int) c1 - (int) c2;

-}

-

-int

-FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcCaseWalker    w1, w2;

-    FcChar8	    c1, c2;

-

-    if (s1 == s2) return 0;

-

-    FcStrCaseWalkerInit (s1, &w1);

-    FcStrCaseWalkerInit (s2, &w2);

-

-    for (;;)

-    {

-	c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);

-	c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);

-	if (!c1 || (c1 != c2))

-	    break;

-    }

-    return (int) c1 - (int) c2;

-}

-

-int

-FcStrCmp (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcChar8 c1, c2;

-

-    if (s1 == s2)

-	return 0;

-    for (;;)

-    {

-	c1 = *s1++;

-	c2 = *s2++;

-	if (!c1 || c1 != c2)

-	    break;

-    }

-    return (int) c1 - (int) c2;

-}

-

-/*

- * Return a hash value for a string

- */

-

-FcChar32

-FcStrHashIgnoreCase (const FcChar8 *s)

-{

-    FcChar32	    h = 0;

-    FcCaseWalker    w;

-    FcChar8	    c;

-

-    FcStrCaseWalkerInit (s, &w);

-    while ((c = FcStrCaseWalkerNext (&w)))

-	h = ((h << 3) ^ (h >> 3)) ^ c;

-    return h;

-}

-

-/*

- * Is the head of s1 equal to s2?

- */

-

-static FcBool

-FcStrIsAtIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcCaseWalker    w1, w2;

-    FcChar8	    c1, c2;

-

-    FcStrCaseWalkerInit (s1, &w1);

-    FcStrCaseWalkerInit (s2, &w2);

-

-    for (;;)

-    {

-	c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);

-	c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);

-	if (!c1 || (c1 != c2))

-	    break;

-    }

-    return c1 == c2 || !c2;

-}

-

-/*

- * Does s1 contain an instance of s2 (ignoring blanks and case)?

- */

-

-const FcChar8 *

-FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    while (*s1)

-    {

-	if (FcStrIsAtIgnoreBlanksAndCase (s1, s2))

-	    return s1;

-	s1++;

-    }

-    return 0;

-}

-

-static FcBool

-FcCharIsPunct (const FcChar8 c)

-{

-    if (c < '0')

-	return FcTrue;

-    if (c <= '9')

-	return FcFalse;

-    if (c < 'A')

-	return FcTrue;

-    if (c <= 'Z')

-	return FcFalse;

-    if (c < 'a')

-	return FcTrue;

-    if (c <= 'z')

-	return FcFalse;

-    if (c <= '~')

-	return FcTrue;

-    return FcFalse;

-}

-

-/*

- * Is the head of s1 equal to s2?

- */

-

-static FcBool

-FcStrIsAtIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcCaseWalker    w1, w2;

-    FcChar8	    c1, c2;

-

-    FcStrCaseWalkerInit (s1, &w1);

-    FcStrCaseWalkerInit (s2, &w2);

-

-    for (;;)

-    {

-	c1 = FcStrCaseWalkerNext (&w1);

-	c2 = FcStrCaseWalkerNext (&w2);

-	if (!c1 || (c1 != c2))

-	    break;

-    }

-    return c1 == c2 || !c2;

-}

-

-/*

- * Does s1 contain an instance of s2 (ignoring blanks and case)?

- */

-

-const FcChar8 *

-FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    while (*s1)

-    {

-	if (FcStrIsAtIgnoreCase (s1, s2))

-	    return s1;

-	s1++;

-    }

-    return 0;

-}

-

-/*

- * Does s1 contain an instance of s2 on a word boundary (ignoring case)?

- */

-

-const FcChar8 *

-FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcBool  wordStart = FcTrue;

-    int	    s1len = strlen ((char *) s1);

-    int	    s2len = strlen ((char *) s2);

-	

-    while (s1len >= s2len)

-    {

-	if (wordStart &&

-	    FcStrIsAtIgnoreCase (s1, s2) &&

-	    (s1len == s2len || FcCharIsPunct (s1[s2len])))

-	{

-	    return s1;

-	}

-	wordStart = FcFalse;

-	if (FcCharIsPunct (*s1))

-	    wordStart = FcTrue;

-	s1++;

-	s1len--;

-    }

-    return 0;

-}

-

-const FcChar8 *

-FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcCaseWalker    w1, w2;

-    FcChar8	    c1, c2;

-    const FcChar8   *cur;

-

-    if (!s1 || !s2)

-	return 0;

-

-    if (s1 == s2)

-	return s1;

-

-    FcStrCaseWalkerInit (s1, &w1);

-    FcStrCaseWalkerInit (s2, &w2);

-

-    c2 = FcStrCaseWalkerNext (&w2);

-

-    for (;;)

-    {

-	cur = w1.src;

-	c1 = FcStrCaseWalkerNext (&w1);

-	if (!c1)

-	    break;

-	if (c1 == c2)

-	{

-	    FcCaseWalker    w1t = w1;

-	    FcCaseWalker    w2t = w2;

-	    FcChar8	    c1t, c2t;

-

-	    for (;;)

-	    {

-		c1t = FcStrCaseWalkerNext (&w1t);

-		c2t = FcStrCaseWalkerNext (&w2t);

-

-		if (!c2t)

-		    return cur;

-		if (c2t != c1t)

-		    break;

-	    }

-	}

-    }

-    return 0;

-}

-

-const FcChar8 *

-FcStrStr (const FcChar8 *s1, const FcChar8 *s2)

-{

-    FcChar8 c1, c2;

-    const FcChar8 * p = s1;

-    const FcChar8 * b = s2;

-

-    if (!s1 || !s2)

-	return 0;

-

-    if (s1 == s2)

-	return s1;

-

-again:

-    c2 = *s2++;

-

-    if (!c2)

-	return 0;

-

-    for (;;)

-    {

-	p = s1;

-	c1 = *s1++;

-	if (!c1 || c1 == c2)

-	    break;

-    }

-

-    if (c1 != c2)

-	return 0;

-

-    for (;;)

-    {

-	c1 = *s1;

-	c2 = *s2;

-	if (c1 && c2 && c1 != c2)

-	{

-	    s1 = p + 1;

-	    s2 = b;

-	    goto again;

-	}

-	if (!c2)

-	    return p;

-	if (!c1)

-	    return 0;

-	++ s1;

-	++ s2;

-    }

-    /* never reached. */

-}

-

-int

-FcUtf8ToUcs4 (const FcChar8 *src_orig,

-	      FcChar32	    *dst,

-	      int	    len)

-{

-    const FcChar8   *src = src_orig;

-    FcChar8	    s;

-    int		    extra;

-    FcChar32	    result;

-

-    if (len == 0)

-	return 0;

-

-    s = *src++;

-    len--;

-

-    if (!(s & 0x80))

-    {

-	result = s;

-	extra = 0;

-    }

-    else if (!(s & 0x40))

-    {

-	return -1;

-    }

-    else if (!(s & 0x20))

-    {

-	result = s & 0x1f;

-	extra = 1;

-    }

-    else if (!(s & 0x10))

-    {

-	result = s & 0xf;

-	extra = 2;

-    }

-    else if (!(s & 0x08))

-    {

-	result = s & 0x07;

-	extra = 3;

-    }

-    else if (!(s & 0x04))

-    {

-	result = s & 0x03;

-	extra = 4;

-    }

-    else if ( ! (s & 0x02))

-    {

-	result = s & 0x01;

-	extra = 5;

-    }

-    else

-    {

-	return -1;

-    }

-    if (extra > len)

-	return -1;

-

-    while (extra--)

-    {

-	result <<= 6;

-	s = *src++;

-	

-	if ((s & 0xc0) != 0x80)

-	    return -1;

-	

-	result |= s & 0x3f;

-    }

-    *dst = result;

-    return src - src_orig;

-}

-

-FcBool

-FcUtf8Len (const FcChar8    *string,

-	   int		    len,

-	   int		    *nchar,

-	   int		    *wchar)

-{

-    int		n;

-    int		clen;

-    FcChar32	c;

-    FcChar32	max;

-

-    n = 0;

-    max = 0;

-    while (len)

-    {

-	clen = FcUtf8ToUcs4 (string, &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;

-}

-

-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)

-{

-    if (init)

-    {

-	buf->buf = init;

-	buf->size = size;

-    } else

-    {

-	buf->buf = buf->buf_static;

-	buf->size = sizeof (buf->buf_static);

-    }

-    buf->allocated = FcFalse;

-    buf->failed = FcFalse;

-    buf->len = 0;

-}

-

-void

-FcStrBufDestroy (FcStrBuf *buf)

-{

-    if (buf->allocated)

-    {

-	FcMemFree (FC_MEM_STRBUF, buf->size);

-	free (buf->buf);

-	FcStrBufInit (buf, 0, 0);

-    }

-}

-

-FcChar8 *

-FcStrBufDone (FcStrBuf *buf)

-{

-    FcChar8 *ret;

-

-    if (buf->failed)

-	ret = NULL;

-    else

-	ret = malloc (buf->len + 1);

-    if (ret)

-    {

-	FcMemAlloc (FC_MEM_STRING, buf->len + 1);

-	memcpy (ret, buf->buf, buf->len);

-	ret[buf->len] = '\0';

-    }

-    FcStrBufDestroy (buf);

-    return ret;

-}

-

-FcChar8 *

-FcStrBufDoneStatic (FcStrBuf *buf)

-{

-    FcStrBufChar (buf, '\0');

-

-    if (buf->failed)

-	return NULL;

-

-    return buf->buf;

-}

-

-FcBool

-FcStrBufChar (FcStrBuf *buf, FcChar8 c)

-{

-    if (buf->len == buf->size)

-    {

-	FcChar8	    *new;

-	int	    size;

-

-	if (buf->failed)

-	    return FcFalse;

-

-	if (buf->allocated)

-	{

-	    size = buf->size * 2;

-	    new = realloc (buf->buf, size);

-	}

-	else

-	{

-	    size = buf->size + 64;

-	    new = malloc (size);

-	    if (new)

-	    {

-		buf->allocated = FcTrue;

-		memcpy (new, buf->buf, buf->len);

-	    }

-	}

-	if (!new)

-	{

-	    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;

-    }

-    buf->buf[buf->len++] = c;

-    return FcTrue;

-}

-

-FcBool

-FcStrBufString (FcStrBuf *buf, const FcChar8 *s)

-{

-    FcChar8 c;

-    while ((c = *s++))

-	if (!FcStrBufChar (buf, c))

-	    return FcFalse;

-    return FcTrue;

-}

-

-FcBool

-FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len)

-{

-    while (len-- > 0)

-	if (!FcStrBufChar (buf, *s++))

-	    return FcFalse;

-    return FcTrue;

-}

-

-FcBool

-FcStrUsesHome (const FcChar8 *s)

-{

-    return *s == '~';

-}

-

-FcChar8 *

-FcStrCopyFilename (const FcChar8 *s)

-{

-    FcChar8 *new;

-

-    if (*s == '~')

-    {

-	FcChar8	*home = FcConfigHome ();

-	FcChar8	*full;

-	int	size;

-	if (!home)

-	    return 0;

-	size = strlen ((char *) home) + strlen ((char *) s);

-	full = (FcChar8 *) malloc (size);

-	if (!full)

-	    return 0;

-	strcpy ((char *) full, (char *) home);

-	strcat ((char *) full, (char *) s + 1);

-	new = FcStrCanonFilename (full);

-	free (full);

-    }

-    else

-	new = FcStrCanonFilename (s);

-    return new;

-}

-

-FcChar8 *

-FcStrLastSlash (const FcChar8  *path)

-{

-    FcChar8	    *slash;

-

-    slash = (FcChar8 *) strrchr ((const char *) path, '/');

-#ifdef _WIN32

-    {

-        FcChar8     *backslash;

-

-	backslash = (FcChar8 *) strrchr ((const char *) path, '\\');

-	if (!slash || (backslash && backslash > slash))

-	    slash = backslash;

-    }

-#endif

-

-    return slash;

-}

-

-FcChar8 *

-FcStrDirname (const FcChar8 *file)

-{

-    FcChar8 *slash;

-    FcChar8 *dir;

-

-    slash = FcStrLastSlash (file);

-    if (!slash)

-	return FcStrCopy ((FcChar8 *) ".");

-    dir = malloc ((slash - file) + 1);

-    if (!dir)

-	return 0;

-    FcMemAlloc (FC_MEM_STRING, (slash - file) + 1);

-    strncpy ((char *) dir, (const char *) file, slash - file);

-    dir[slash - file] = '\0';

-    return dir;

-}

-

-FcChar8 *

-FcStrBasename (const FcChar8 *file)

-{

-    FcChar8 *slash;

-

-    slash = FcStrLastSlash (file);

-    if (!slash)

-	return FcStrCopy (file);

-    return FcStrCopy (slash + 1);

-}

-

-static FcChar8 *

-FcStrCanonAbsoluteFilename (const FcChar8 *s)

-{

-    FcChar8 *file;

-    FcChar8 *f;

-    const FcChar8 *slash;

-    int size;

-

-    size = strlen ((char *) s) + 1;

-    file = malloc (size);

-    if (!file)

-	return NULL;

-    FcMemAlloc (FC_MEM_STRING, size);

-    slash = NULL;

-    f = file;

-    for (;;) {

-	if (*s == '/' || *s == '\0')

-	{

-	    if (slash)

-	    {

-		switch (s - slash) {

-		case 1:

-		    f -= 1;	/* squash // and trim final / from file */

-		    break;

-		case 2:

-		    if (!strncmp ((char *) slash, "/.", 2))

-		    {

-			f -= 2;	/* trim /. from file */

-		    }

-		    break;

-		case 3:

-		    if (!strncmp ((char *) slash, "/..", 3))

-		    {

-			f -= 3;	/* trim /.. from file */

-			while (f > file) {

-			    if (*--f == '/')

-				break;

-			}

-		    }

-		    break;

-		}

-	    }

-	    slash = s;

-	}

-	if (!(*f++ = *s++))

-	    break;

-    }

-    return file;

-}

-

-#ifdef _WIN32

-/*

- * Convert '\\' to '/' , remove double '/'

- */

-static void

-FcConvertDosPath (char *str)

-{

-  size_t len = strlen (str);

-  char *p = str;

-  char *dest = str;

-  char *end = str + len;

-  char last = 0;

-

-  if (*p == '\\')

-    {

-      *p = '/';

-      p++;

-      dest++;

-    }

-  while (p < end)

-    {

-      if (*p == '\\')

-	*p = '/';

-

-      if (*p != '/'

-	  || last != '/')

-	{

-	  *dest++ = *p;

-	}

-

-      last = *p;

-      p++;

-    }

-

-  *dest = 0;

-}

-#endif

-

-FcChar8 *

-FcStrCanonFilename (const FcChar8 *s)

-{

-#ifdef _WIN32

-    FcChar8 full[FC_MAX_FILE_LEN + 2];

-    int size = GetFullPathName (s, sizeof (full) -1,

-				full, NULL);

-

-    if (size == 0)

-	perror ("GetFullPathName");

-

-    FcConvertDosPath (full);

-    return FcStrCanonAbsoluteFilename (full);

-#else

-    if (s[0] == '/')

-	return FcStrCanonAbsoluteFilename (s);

-    else

-    {

-	FcChar8	*full;

-	FcChar8 *file;

-

-	FcChar8	cwd[FC_MAX_FILE_LEN + 2];

-	if (getcwd ((char *) cwd, FC_MAX_FILE_LEN) == NULL)

-	    return NULL;

-	strcat ((char *) cwd, "/");

-	full = FcStrPlus (cwd, s);

-	file = FcStrCanonAbsoluteFilename (full);

-	FcStrFree (full);

-	return file;

-    }

-#endif

-}

-

-

-FcStrSet *

-FcStrSetCreate (void)

-{

-    FcStrSet	*set = malloc (sizeof (FcStrSet));

-    if (!set)

-	return 0;

-    FcMemAlloc (FC_MEM_STRSET, sizeof (FcStrSet));

-    set->ref = 1;

-    set->num = 0;

-    set->size = 0;

-    set->strs = 0;

-    return set;

-}

-

-static FcBool

-_FcStrSetAppend (FcStrSet *set, FcChar8 *s)

-{

-    if (FcStrSetMember (set, s))

-    {

-	FcStrFree (s);

-	return FcTrue;

-    }

-    if (set->num == set->size)

-    {

-	FcChar8	**strs = malloc ((set->size + 2) * sizeof (FcChar8 *));

-

-	if (!strs)

-	    return FcFalse;

-	FcMemAlloc (FC_MEM_STRSET, (set->size + 2) * sizeof (FcChar8 *));

-	if (set->num)

-	    memcpy (strs, set->strs, set->num * sizeof (FcChar8 *));

-	if (set->strs)

-	{

-	    FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));

-	    free (set->strs);

-	}

-	set->size = set->size + 1;

-	set->strs = strs;

-    }

-    set->strs[set->num++] = s;

-    set->strs[set->num] = 0;

-    return FcTrue;

-}

-

-FcBool

-FcStrSetMember (FcStrSet *set, const FcChar8 *s)

-{

-    int	i;

-

-    for (i = 0; i < set->num; i++)

-	if (!FcStrCmp (set->strs[i], s))

-	    return FcTrue;

-    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)

-{

-    FcChar8 *new = FcStrCopy (s);

-    if (!new)

-	return FcFalse;

-    if (!_FcStrSetAppend (set, new))

-    {

-	FcStrFree (new);

-	return FcFalse;

-    }

-    return FcTrue;

-}

-

-FcBool

-FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s)

-{

-    FcChar8 *new = FcStrCopyFilename (s);

-    if (!new)

-	return FcFalse;

-    if (!_FcStrSetAppend (set, new))

-    {

-	FcStrFree (new);

-	return FcFalse;

-    }

-    return FcTrue;

-}

-

-FcBool

-FcStrSetDel (FcStrSet *set, const FcChar8 *s)

-{

-    int	i;

-

-    for (i = 0; i < set->num; i++)

-	if (!FcStrCmp (set->strs[i], s))

-	{

-	    FcStrFree (set->strs[i]);

-	    /*

-	     * copy remaining string pointers and trailing

-	     * NULL

-	     */

-	    memmove (&set->strs[i], &set->strs[i+1],

-		     (set->num - i) * sizeof (FcChar8 *));

-	    set->num--;

-	    return FcTrue;

-	}

-    return FcFalse;

-}

-

-void

-FcStrSetDestroy (FcStrSet *set)

-{

-    if (--set->ref == 0)

-    {

-	int	i;

-

-	for (i = 0; i < set->num; i++)

-	    FcStrFree (set->strs[i]);

-	if (set->strs)

-	{

-	    FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));

-	    free (set->strs);

-	}

-	FcMemFree (FC_MEM_STRSET, sizeof (FcStrSet));

-	free (set);

-    }

-}

-

-FcStrList *

-FcStrListCreate (FcStrSet *set)

-{

-    FcStrList	*list;

-

-    list = malloc (sizeof (FcStrList));

-    if (!list)

-	return 0;

-    FcMemAlloc (FC_MEM_STRLIST, sizeof (FcStrList));

-    list->set = set;

-    set->ref++;

-    list->n = 0;

-    return list;

-}

-

-FcChar8 *

-FcStrListNext (FcStrList *list)

-{

-    if (list->n >= list->set->num)

-	return 0;

-    return list->set->strs[list->n++];

-}

-

-void

-FcStrListDone (FcStrList *list)

-{

-    FcStrSetDestroy (list->set);

-    FcMemFree (FC_MEM_STRLIST, sizeof (FcStrList));

-    free (list);

-}

-

-#define __fcstr__

-#include "fcaliastail.h"

-#undef __fcstr__

+/*
+ * fontconfig/src/fcstr.c
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "fcint.h"
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+FcChar8 *
+FcStrCopy (const FcChar8 *s)
+{
+    int     len;
+    FcChar8 *r;
+
+    if (!s)
+	return 0;
+    len = strlen ((char *) s) + 1;
+    r = (FcChar8 *) malloc (len);
+    if (!r)
+	return 0;
+    FcMemAlloc (FC_MEM_STRING, len);
+    memcpy (r, s, len);
+    return r;
+}
+
+FcChar8 *
+FcStrPlus (const FcChar8 *s1, const FcChar8 *s2)
+{
+    int	    l = strlen ((char *)s1) + strlen ((char *) s2) + 1;
+    FcChar8 *s = malloc (l);
+
+    if (!s)
+	return 0;
+    FcMemAlloc (FC_MEM_STRING, l);
+    strcpy ((char *) s, (char *) s1);
+    strcat ((char *) s, (char *) s2);
+    return s;
+}
+
+void
+FcStrFree (FcChar8 *s)
+{
+    FcMemFree (FC_MEM_STRING, strlen ((char *) s) + 1);
+    free (s);
+}
+
+
+#include "../fc-case/fccase.h"
+
+#define FcCaseFoldUpperCount(cf) \
+    ((cf)->method == FC_CASE_FOLD_FULL ? 1 : (cf)->count)
+
+#define FC_STR_CANON_BUF_LEN	1024
+
+typedef struct _FcCaseWalker {
+    const FcChar8   *read;
+    const FcChar8   *src;
+    FcChar8	    utf8[FC_MAX_CASE_FOLD_CHARS + 1];
+} FcCaseWalker;
+
+static void
+FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)
+{
+    w->src = src;
+    w->read = 0;
+}
+
+static FcChar8
+FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)
+{
+    FcChar32	ucs4;
+    int		slen;
+    int		len = strlen((char*)w->src);
+
+    slen = FcUtf8ToUcs4 (w->src - 1, &ucs4, len + 1);
+    if (slen <= 0)
+	return r;
+    if (FC_MIN_FOLD_CHAR <= ucs4 && ucs4 <= FC_MAX_FOLD_CHAR)
+    {
+	int min = 0;
+	int max = FC_NUM_CASE_FOLD;
+
+	while (min <= max)
+	{
+	    int		mid = (min + max) >> 1;
+	    FcChar32    low = fcCaseFold[mid].upper;
+	    FcChar32    high = low + FcCaseFoldUpperCount (&fcCaseFold[mid]);
+	
+	    if (high <= ucs4)
+		min = mid + 1;
+	    else if (ucs4 < low)
+		max = mid - 1;
+	    else
+	    {
+		const FcCaseFold    *fold = &fcCaseFold[mid];
+		int		    dlen;
+		
+		switch (fold->method) {
+		case  FC_CASE_FOLD_EVEN_ODD:
+		    if ((ucs4 & 1) != (fold->upper & 1))
+			return r;
+		    /* fall through ... */
+		default:
+		    dlen = FcUcs4ToUtf8 (ucs4 + fold->offset, w->utf8);
+		    break;
+		case FC_CASE_FOLD_FULL:
+		    dlen = fold->count;
+		    memcpy (w->utf8, fcCaseFoldChars + fold->offset, dlen);
+		    break;
+		}
+		
+		/* consume rest of src utf-8 bytes */
+		w->src += slen - 1;
+		
+		/* read from temp buffer */
+		w->utf8[dlen] = '\0';
+		w->read = w->utf8;
+		return *w->read++;
+	    }
+	}
+    }
+    return r;
+}
+
+static FcChar8
+FcStrCaseWalkerNext (FcCaseWalker *w)
+{
+    FcChar8	r;
+
+    if (w->read)
+    {
+	if ((r = *w->read++))
+	    return r;
+	w->read = 0;
+    }
+    r = *w->src++;
+
+    if ((r & 0xc0) == 0xc0)
+	return FcStrCaseWalkerLong (w, r);
+    if ('A' <= r && r <= 'Z')
+        r = r - 'A' + 'a';
+    return r;
+}
+
+static FcChar8
+FcStrCaseWalkerNextIgnoreBlanks (FcCaseWalker *w)
+{
+    FcChar8	r;
+
+    if (w->read)
+    {
+	if ((r = *w->read++))
+	    return r;
+	w->read = 0;
+    }
+    do
+    {
+	r = *w->src++;
+    } while (r == ' ');
+
+    if ((r & 0xc0) == 0xc0)
+	return FcStrCaseWalkerLong (w, r);
+    if ('A' <= r && r <= 'Z')
+        r = r - 'A' + 'a';
+    return r;
+}
+
+FcChar8 *
+FcStrDowncase (const FcChar8 *s)
+{
+    FcCaseWalker    w;
+    int		    len = 0;
+    FcChar8	    *dst, *d;
+
+    FcStrCaseWalkerInit (s, &w);
+    while (FcStrCaseWalkerNext (&w))
+	len++;
+    d = dst = malloc (len + 1);
+    if (!d)
+	return 0;
+    FcMemAlloc (FC_MEM_STRING, len + 1);
+    FcStrCaseWalkerInit (s, &w);
+    while ((*d++ = FcStrCaseWalkerNext (&w)));
+    return dst;
+}
+
+int
+FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcCaseWalker    w1, w2;
+    FcChar8	    c1, c2;
+
+    if (s1 == s2) return 0;
+
+    FcStrCaseWalkerInit (s1, &w1);
+    FcStrCaseWalkerInit (s2, &w2);
+
+    for (;;)
+    {
+	c1 = FcStrCaseWalkerNext (&w1);
+	c2 = FcStrCaseWalkerNext (&w2);
+	if (!c1 || (c1 != c2))
+	    break;
+    }
+    return (int) c1 - (int) c2;
+}
+
+int
+FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcCaseWalker    w1, w2;
+    FcChar8	    c1, c2;
+
+    if (s1 == s2) return 0;
+
+    FcStrCaseWalkerInit (s1, &w1);
+    FcStrCaseWalkerInit (s2, &w2);
+
+    for (;;)
+    {
+	c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);
+	c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);
+	if (!c1 || (c1 != c2))
+	    break;
+    }
+    return (int) c1 - (int) c2;
+}
+
+int
+FcStrCmp (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcChar8 c1, c2;
+
+    if (s1 == s2)
+	return 0;
+    for (;;)
+    {
+	c1 = *s1++;
+	c2 = *s2++;
+	if (!c1 || c1 != c2)
+	    break;
+    }
+    return (int) c1 - (int) c2;
+}
+
+/*
+ * Return a hash value for a string
+ */
+
+FcChar32
+FcStrHashIgnoreCase (const FcChar8 *s)
+{
+    FcChar32	    h = 0;
+    FcCaseWalker    w;
+    FcChar8	    c;
+
+    FcStrCaseWalkerInit (s, &w);
+    while ((c = FcStrCaseWalkerNext (&w)))
+	h = ((h << 3) ^ (h >> 3)) ^ c;
+    return h;
+}
+
+/*
+ * Is the head of s1 equal to s2?
+ */
+
+static FcBool
+FcStrIsAtIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcCaseWalker    w1, w2;
+    FcChar8	    c1, c2;
+
+    FcStrCaseWalkerInit (s1, &w1);
+    FcStrCaseWalkerInit (s2, &w2);
+
+    for (;;)
+    {
+	c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);
+	c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);
+	if (!c1 || (c1 != c2))
+	    break;
+    }
+    return c1 == c2 || !c2;
+}
+
+/*
+ * Does s1 contain an instance of s2 (ignoring blanks and case)?
+ */
+
+const FcChar8 *
+FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    while (*s1)
+    {
+	if (FcStrIsAtIgnoreBlanksAndCase (s1, s2))
+	    return s1;
+	s1++;
+    }
+    return 0;
+}
+
+static FcBool
+FcCharIsPunct (const FcChar8 c)
+{
+    if (c < '0')
+	return FcTrue;
+    if (c <= '9')
+	return FcFalse;
+    if (c < 'A')
+	return FcTrue;
+    if (c <= 'Z')
+	return FcFalse;
+    if (c < 'a')
+	return FcTrue;
+    if (c <= 'z')
+	return FcFalse;
+    if (c <= '~')
+	return FcTrue;
+    return FcFalse;
+}
+
+/*
+ * Is the head of s1 equal to s2?
+ */
+
+static FcBool
+FcStrIsAtIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcCaseWalker    w1, w2;
+    FcChar8	    c1, c2;
+
+    FcStrCaseWalkerInit (s1, &w1);
+    FcStrCaseWalkerInit (s2, &w2);
+
+    for (;;)
+    {
+	c1 = FcStrCaseWalkerNext (&w1);
+	c2 = FcStrCaseWalkerNext (&w2);
+	if (!c1 || (c1 != c2))
+	    break;
+    }
+    return c1 == c2 || !c2;
+}
+
+/*
+ * Does s1 contain an instance of s2 (ignoring blanks and case)?
+ */
+
+const FcChar8 *
+FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    while (*s1)
+    {
+	if (FcStrIsAtIgnoreCase (s1, s2))
+	    return s1;
+	s1++;
+    }
+    return 0;
+}
+
+/*
+ * Does s1 contain an instance of s2 on a word boundary (ignoring case)?
+ */
+
+const FcChar8 *
+FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcBool  wordStart = FcTrue;
+    int	    s1len = strlen ((char *) s1);
+    int	    s2len = strlen ((char *) s2);
+	
+    while (s1len >= s2len)
+    {
+	if (wordStart &&
+	    FcStrIsAtIgnoreCase (s1, s2) &&
+	    (s1len == s2len || FcCharIsPunct (s1[s2len])))
+	{
+	    return s1;
+	}
+	wordStart = FcFalse;
+	if (FcCharIsPunct (*s1))
+	    wordStart = FcTrue;
+	s1++;
+	s1len--;
+    }
+    return 0;
+}
+
+const FcChar8 *
+FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcCaseWalker    w1, w2;
+    FcChar8	    c1, c2;
+    const FcChar8   *cur;
+
+    if (!s1 || !s2)
+	return 0;
+
+    if (s1 == s2)
+	return s1;
+
+    FcStrCaseWalkerInit (s1, &w1);
+    FcStrCaseWalkerInit (s2, &w2);
+
+    c2 = FcStrCaseWalkerNext (&w2);
+
+    for (;;)
+    {
+	cur = w1.src;
+	c1 = FcStrCaseWalkerNext (&w1);
+	if (!c1)
+	    break;
+	if (c1 == c2)
+	{
+	    FcCaseWalker    w1t = w1;
+	    FcCaseWalker    w2t = w2;
+	    FcChar8	    c1t, c2t;
+
+	    for (;;)
+	    {
+		c1t = FcStrCaseWalkerNext (&w1t);
+		c2t = FcStrCaseWalkerNext (&w2t);
+
+		if (!c2t)
+		    return cur;
+		if (c2t != c1t)
+		    break;
+	    }
+	}
+    }
+    return 0;
+}
+
+const FcChar8 *
+FcStrStr (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcChar8 c1, c2;
+    const FcChar8 * p = s1;
+    const FcChar8 * b = s2;
+
+    if (!s1 || !s2)
+	return 0;
+
+    if (s1 == s2)
+	return s1;
+
+again:
+    c2 = *s2++;
+
+    if (!c2)
+	return 0;
+
+    for (;;)
+    {
+	p = s1;
+	c1 = *s1++;
+	if (!c1 || c1 == c2)
+	    break;
+    }
+
+    if (c1 != c2)
+	return 0;
+
+    for (;;)
+    {
+	c1 = *s1;
+	c2 = *s2;
+	if (c1 && c2 && c1 != c2)
+	{
+	    s1 = p + 1;
+	    s2 = b;
+	    goto again;
+	}
+	if (!c2)
+	    return p;
+	if (!c1)
+	    return 0;
+	++ s1;
+	++ s2;
+    }
+    /* never reached. */
+}
+
+int
+FcUtf8ToUcs4 (const FcChar8 *src_orig,
+	      FcChar32	    *dst,
+	      int	    len)
+{
+    const FcChar8   *src = src_orig;
+    FcChar8	    s;
+    int		    extra;
+    FcChar32	    result;
+
+    if (len == 0)
+	return 0;
+
+    s = *src++;
+    len--;
+
+    if (!(s & 0x80))
+    {
+	result = s;
+	extra = 0;
+    }
+    else if (!(s & 0x40))
+    {
+	return -1;
+    }
+    else if (!(s & 0x20))
+    {
+	result = s & 0x1f;
+	extra = 1;
+    }
+    else if (!(s & 0x10))
+    {
+	result = s & 0xf;
+	extra = 2;
+    }
+    else if (!(s & 0x08))
+    {
+	result = s & 0x07;
+	extra = 3;
+    }
+    else if (!(s & 0x04))
+    {
+	result = s & 0x03;
+	extra = 4;
+    }
+    else if ( ! (s & 0x02))
+    {
+	result = s & 0x01;
+	extra = 5;
+    }
+    else
+    {
+	return -1;
+    }
+    if (extra > len)
+	return -1;
+
+    while (extra--)
+    {
+	result <<= 6;
+	s = *src++;
+	
+	if ((s & 0xc0) != 0x80)
+	    return -1;
+	
+	result |= s & 0x3f;
+    }
+    *dst = result;
+    return src - src_orig;
+}
+
+FcBool
+FcUtf8Len (const FcChar8    *string,
+	   int		    len,
+	   int		    *nchar,
+	   int		    *wchar)
+{
+    int		n;
+    int		clen;
+    FcChar32	c;
+    FcChar32	max;
+
+    n = 0;
+    max = 0;
+    while (len)
+    {
+	clen = FcUtf8ToUcs4 (string, &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;
+}
+
+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)
+{
+    if (init)
+    {
+	buf->buf = init;
+	buf->size = size;
+    } else
+    {
+	buf->buf = buf->buf_static;
+	buf->size = sizeof (buf->buf_static);
+    }
+    buf->allocated = FcFalse;
+    buf->failed = FcFalse;
+    buf->len = 0;
+}
+
+void
+FcStrBufDestroy (FcStrBuf *buf)
+{
+    if (buf->allocated)
+    {
+	FcMemFree (FC_MEM_STRBUF, buf->size);
+	free (buf->buf);
+	FcStrBufInit (buf, 0, 0);
+    }
+}
+
+FcChar8 *
+FcStrBufDone (FcStrBuf *buf)
+{
+    FcChar8 *ret;
+
+    if (buf->failed)
+	ret = NULL;
+    else
+	ret = malloc (buf->len + 1);
+    if (ret)
+    {
+	FcMemAlloc (FC_MEM_STRING, buf->len + 1);
+	memcpy (ret, buf->buf, buf->len);
+	ret[buf->len] = '\0';
+    }
+    FcStrBufDestroy (buf);
+    return ret;
+}
+
+FcChar8 *
+FcStrBufDoneStatic (FcStrBuf *buf)
+{
+    FcStrBufChar (buf, '\0');
+
+    if (buf->failed)
+	return NULL;
+
+    return buf->buf;
+}
+
+FcBool
+FcStrBufChar (FcStrBuf *buf, FcChar8 c)
+{
+    if (buf->len == buf->size)
+    {
+	FcChar8	    *new;
+	int	    size;
+
+	if (buf->failed)
+	    return FcFalse;
+
+	if (buf->allocated)
+	{
+	    size = buf->size * 2;
+	    new = realloc (buf->buf, size);
+	}
+	else
+	{
+	    size = buf->size + 64;
+	    new = malloc (size);
+	    if (new)
+	    {
+		buf->allocated = FcTrue;
+		memcpy (new, buf->buf, buf->len);
+	    }
+	}
+	if (!new)
+	{
+	    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;
+    }
+    buf->buf[buf->len++] = c;
+    return FcTrue;
+}
+
+FcBool
+FcStrBufString (FcStrBuf *buf, const FcChar8 *s)
+{
+    FcChar8 c;
+    while ((c = *s++))
+	if (!FcStrBufChar (buf, c))
+	    return FcFalse;
+    return FcTrue;
+}
+
+FcBool
+FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len)
+{
+    while (len-- > 0)
+	if (!FcStrBufChar (buf, *s++))
+	    return FcFalse;
+    return FcTrue;
+}
+
+FcBool
+FcStrUsesHome (const FcChar8 *s)
+{
+    return *s == '~';
+}
+
+FcChar8 *
+FcStrCopyFilename (const FcChar8 *s)
+{
+    FcChar8 *new;
+
+    if (*s == '~')
+    {
+	FcChar8	*home = FcConfigHome ();
+	FcChar8	*full;
+	int	size;
+	if (!home)
+	    return 0;
+	size = strlen ((char *) home) + strlen ((char *) s);
+	full = (FcChar8 *) malloc (size);
+	if (!full)
+	    return 0;
+	strcpy ((char *) full, (char *) home);
+	strcat ((char *) full, (char *) s + 1);
+	new = FcStrCanonFilename (full);
+	free (full);
+    }
+    else
+	new = FcStrCanonFilename (s);
+    return new;
+}
+
+FcChar8 *
+FcStrLastSlash (const FcChar8  *path)
+{
+    FcChar8	    *slash;
+
+    slash = (FcChar8 *) strrchr ((const char *) path, '/');
+#ifdef _WIN32
+    {
+        FcChar8     *backslash;
+
+	backslash = (FcChar8 *) strrchr ((const char *) path, '\\');
+	if (!slash || (backslash && backslash > slash))
+	    slash = backslash;
+    }
+#endif
+
+    return slash;
+}
+
+FcChar8 *
+FcStrDirname (const FcChar8 *file)
+{
+    FcChar8 *slash;
+    FcChar8 *dir;
+
+    slash = FcStrLastSlash (file);
+    if (!slash)
+	return FcStrCopy ((FcChar8 *) ".");
+    dir = malloc ((slash - file) + 1);
+    if (!dir)
+	return 0;
+    FcMemAlloc (FC_MEM_STRING, (slash - file) + 1);
+    strncpy ((char *) dir, (const char *) file, slash - file);
+    dir[slash - file] = '\0';
+    return dir;
+}
+
+FcChar8 *
+FcStrBasename (const FcChar8 *file)
+{
+    FcChar8 *slash;
+
+    slash = FcStrLastSlash (file);
+    if (!slash)
+	return FcStrCopy (file);
+    return FcStrCopy (slash + 1);
+}
+
+static FcChar8 *
+FcStrCanonAbsoluteFilename (const FcChar8 *s)
+{
+    FcChar8 *file;
+    FcChar8 *f;
+    const FcChar8 *slash;
+    int size;
+
+    size = strlen ((char *) s) + 1;
+    file = malloc (size);
+    if (!file)
+	return NULL;
+    FcMemAlloc (FC_MEM_STRING, size);
+    slash = NULL;
+    f = file;
+    for (;;) {
+	if (*s == '/' || *s == '\0')
+	{
+	    if (slash)
+	    {
+		switch (s - slash) {
+		case 1:
+		    f -= 1;	/* squash // and trim final / from file */
+		    break;
+		case 2:
+		    if (!strncmp ((char *) slash, "/.", 2))
+		    {
+			f -= 2;	/* trim /. from file */
+		    }
+		    break;
+		case 3:
+		    if (!strncmp ((char *) slash, "/..", 3))
+		    {
+			f -= 3;	/* trim /.. from file */
+			while (f > file) {
+			    if (*--f == '/')
+				break;
+			}
+		    }
+		    break;
+		}
+	    }
+	    slash = s;
+	}
+	if (!(*f++ = *s++))
+	    break;
+    }
+    return file;
+}
+
+#ifdef _WIN32
+/*
+ * Convert '\\' to '/' , remove double '/'
+ */
+static void
+FcConvertDosPath (char *str)
+{
+  size_t len = strlen (str);
+  char *p = str;
+  char *dest = str;
+  char *end = str + len;
+  char last = 0;
+
+  if (*p == '\\')
+    {
+      *p = '/';
+      p++;
+      dest++;
+    }
+  while (p < end)
+    {
+      if (*p == '\\')
+	*p = '/';
+
+      if (*p != '/'
+	  || last != '/')
+	{
+	  *dest++ = *p;
+	}
+
+      last = *p;
+      p++;
+    }
+
+  *dest = 0;
+}
+#endif
+
+FcChar8 *
+FcStrCanonFilename (const FcChar8 *s)
+{
+#ifdef _WIN32
+    FcChar8 full[FC_MAX_FILE_LEN + 2];
+    int size = GetFullPathName (s, sizeof (full) -1,
+				full, NULL);
+
+    if (size == 0)
+	perror ("GetFullPathName");
+
+    FcConvertDosPath (full);
+    return FcStrCanonAbsoluteFilename (full);
+#else
+    if (s[0] == '/')
+	return FcStrCanonAbsoluteFilename (s);
+    else
+    {
+	FcChar8	*full;
+	FcChar8 *file;
+
+	FcChar8	cwd[FC_MAX_FILE_LEN + 2];
+	if (getcwd ((char *) cwd, FC_MAX_FILE_LEN) == NULL)
+	    return NULL;
+	strcat ((char *) cwd, "/");
+	full = FcStrPlus (cwd, s);
+	file = FcStrCanonAbsoluteFilename (full);
+	FcStrFree (full);
+	return file;
+    }
+#endif
+}
+
+
+FcStrSet *
+FcStrSetCreate (void)
+{
+    FcStrSet	*set = malloc (sizeof (FcStrSet));
+    if (!set)
+	return 0;
+    FcMemAlloc (FC_MEM_STRSET, sizeof (FcStrSet));
+    set->ref = 1;
+    set->num = 0;
+    set->size = 0;
+    set->strs = 0;
+    return set;
+}
+
+static FcBool
+_FcStrSetAppend (FcStrSet *set, FcChar8 *s)
+{
+    if (FcStrSetMember (set, s))
+    {
+	FcStrFree (s);
+	return FcTrue;
+    }
+    if (set->num == set->size)
+    {
+	FcChar8	**strs = malloc ((set->size + 2) * sizeof (FcChar8 *));
+
+	if (!strs)
+	    return FcFalse;
+	FcMemAlloc (FC_MEM_STRSET, (set->size + 2) * sizeof (FcChar8 *));
+	if (set->num)
+	    memcpy (strs, set->strs, set->num * sizeof (FcChar8 *));
+	if (set->strs)
+	{
+	    FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));
+	    free (set->strs);
+	}
+	set->size = set->size + 1;
+	set->strs = strs;
+    }
+    set->strs[set->num++] = s;
+    set->strs[set->num] = 0;
+    return FcTrue;
+}
+
+FcBool
+FcStrSetMember (FcStrSet *set, const FcChar8 *s)
+{
+    int	i;
+
+    for (i = 0; i < set->num; i++)
+	if (!FcStrCmp (set->strs[i], s))
+	    return FcTrue;
+    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)
+{
+    FcChar8 *new = FcStrCopy (s);
+    if (!new)
+	return FcFalse;
+    if (!_FcStrSetAppend (set, new))
+    {
+	FcStrFree (new);
+	return FcFalse;
+    }
+    return FcTrue;
+}
+
+FcBool
+FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s)
+{
+    FcChar8 *new = FcStrCopyFilename (s);
+    if (!new)
+	return FcFalse;
+    if (!_FcStrSetAppend (set, new))
+    {
+	FcStrFree (new);
+	return FcFalse;
+    }
+    return FcTrue;
+}
+
+FcBool
+FcStrSetDel (FcStrSet *set, const FcChar8 *s)
+{
+    int	i;
+
+    for (i = 0; i < set->num; i++)
+	if (!FcStrCmp (set->strs[i], s))
+	{
+	    FcStrFree (set->strs[i]);
+	    /*
+	     * copy remaining string pointers and trailing
+	     * NULL
+	     */
+	    memmove (&set->strs[i], &set->strs[i+1],
+		     (set->num - i) * sizeof (FcChar8 *));
+	    set->num--;
+	    return FcTrue;
+	}
+    return FcFalse;
+}
+
+void
+FcStrSetDestroy (FcStrSet *set)
+{
+    if (--set->ref == 0)
+    {
+	int	i;
+
+	for (i = 0; i < set->num; i++)
+	    FcStrFree (set->strs[i]);
+	if (set->strs)
+	{
+	    FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));
+	    free (set->strs);
+	}
+	FcMemFree (FC_MEM_STRSET, sizeof (FcStrSet));
+	free (set);
+    }
+}
+
+FcStrList *
+FcStrListCreate (FcStrSet *set)
+{
+    FcStrList	*list;
+
+    list = malloc (sizeof (FcStrList));
+    if (!list)
+	return 0;
+    FcMemAlloc (FC_MEM_STRLIST, sizeof (FcStrList));
+    list->set = set;
+    set->ref++;
+    list->n = 0;
+    return list;
+}
+
+FcChar8 *
+FcStrListNext (FcStrList *list)
+{
+    if (list->n >= list->set->num)
+	return 0;
+    return list->set->strs[list->n++];
+}
+
+void
+FcStrListDone (FcStrList *list)
+{
+    FcStrSetDestroy (list->set);
+    FcMemFree (FC_MEM_STRLIST, sizeof (FcStrList));
+    free (list);
+}
+
+#define __fcstr__
+#include "fcaliastail.h"
+#undef __fcstr__