rocklinux/package/x11/xfree86/fontconfig-update.patch

# --- ROCK-COPYRIGHT-NOTE-BEGIN ---
# 
# This copyright note is auto-generated by ./scripts/Create-CopyPatch.
# Please add additional copyright information _after_ the line containing
# the ROCK-COPYRIGHT-NOTE-END tag. Otherwise it might get removed by
# the ./scripts/Create-CopyPatch script. Do not edit this copyright text!
# 
# ROCK Linux: rock-src/package/x11/xfree86/fontconfig-update.patch
# ROCK Linux is Copyright (C) 1998 - 2004 Clifford Wolf
# 
# This patch file is dual-licensed. It is available under the license the
# patched project is licensed under, as long as it is an OpenSource license
# as defined at http://www.opensource.org/ (e.g. BSD, X11) or under the terms
# of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
# 
# --- ROCK-COPYRIGHT-NOTE-END ---

This updates the fontconfig version included inside XFree to Keith's
external and official 2.2.1 release.

The patch matches the license of these projects (X11/BSD/...) and
is intended for inclusion into XFree. The GPL license above is only
the ROCK Linux license as it.

  - Rene Rebe <rene@rocklinux.org>
  - Juergen Sawinski <george@mpimf-heidelberg.mpg.de>

--- xc/lib/fontconfig/Imakefile~	2003-12-19 05:45:53.000000000 +0100
+++ xc-fontconfig/lib/fontconfig/Imakefile	2003-12-21 16:16:33.000000000 +0100
@@ -7,6 +7,8 @@
 #define DoProfileLib ProfileLibFontconfig
 #define HasSharedData YES
 #define LibName fontconfig
+
+SOFONTCONFIGREV=2.2
 #define SoRev SOFONTCONFIGREV
 
 #define IncSubdir fontconfig
--- xc/extras/fontconfig/src/fcfreetype.c	2003-11-21 06:56:14.000000000 +0100
+++ xc-fontconfig/extras/fontconfig/src/fcfreetype.c	2003-12-21 16:20:08.000000000 +0100
@@ -22,6 +22,28 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
+/*
+  Copyright � 2002-2003 by Juliusz Chroboczek
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -33,6 +55,19 @@
 #include FT_SFNT_NAMES_H
 #include FT_TRUETYPE_IDS_H
 
+#include <freetype/t1tables.h>
+
+#if (FREETYPE_MINOR > 1 || (FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 4))
+#include <freetype/ftbdf.h>
+#include <freetype/ftmodule.h>
+#define USE_FTBDF
+#define HAS_BDF_PROPERTY(f) ((f) && (f)->driver && \
+                           (f)->driver->root.clazz->get_interface)
+#define MY_Get_BDF_Property(f,n,p) (HAS_BDF_PROPERTY(f) ? \
+                                  FT_Get_BDF_Property(f,n,p) : \
+                                  FT_Err_Invalid_Argument)
+#endif
+
 /*
  * Keep Han languages separated by eliminating languages
  * that the codePageRange bits says aren't supported
@@ -90,7 +125,8 @@
 	return FcTrue;
     if (page == 0xfb)
 	return FcTrue;
-    if (page == 0xff)
+    /* halfwidth forms, don't include kana or white parens */
+    if (0xff01 <= ucs4 && ucs4 <= 0xff5e)
 	return FcTrue;
     return FcFalse;
 }
@@ -112,6 +148,115 @@
     return FcTrue;
 }
 
+/* Order is significant.  For example, some B&H fonts are hinted by
+   URW++, and both strings appear in the notice. */
+
+static const struct {
+    const FcChar8   *notice;
+    const FcChar8   *foundry;
+} FcNoticeFoundries[] = {
+    { (const FcChar8*) "Bigelow",	(const FcChar8 *) "b&h" },
+    { (const FcChar8*) "Adobe",		(const FcChar8 *) "adobe" },
+    { (const FcChar8*) "Bitstream",	(const FcChar8 *) "bitstream" },
+    { (const FcChar8*) "Monotype",	(const FcChar8 *) "monotype" },
+    { (const FcChar8*) "Linotype",	(const FcChar8 *) "linotype" },
+    { (const FcChar8*) "LINOTYPE-HELL", (const FcChar8 *) "linotype" },
+    { (const FcChar8*) "IBM",		(const FcChar8 *) "ibm" },
+    { (const FcChar8*) "URW",		(const FcChar8 *) "urw" },
+    { (const FcChar8*) "International Typeface Corporation", 
+					(const FcChar8 *) "itc" },
+    { (const FcChar8*) "Tiro Typeworks",(const FcChar8 *) "tiro" },
+    { (const FcChar8*) "XFree86",	(const FcChar8 *) "xfree86" },
+    { (const FcChar8*) "Microsoft",	(const FcChar8 *) "microsoft" },
+    { (const FcChar8*) "Omega",		(const FcChar8 *) "omega" },
+    { (const FcChar8*) "Font21",	(const FcChar8 *) "hwan" },
+    { (const FcChar8*) "HanYang System",(const FcChar8 *) "hanyang" }
+};
+
+#define NUM_NOTICE_FOUNDRIES	(sizeof (FcNoticeFoundries) / sizeof (FcNoticeFoundries[0]))
+
+static const FcChar8 *
+FcNoticeFoundry(const char *notice)
+{
+    int i;
+
+    if (notice)
+	for(i = 0; i < NUM_NOTICE_FOUNDRIES; i++)
+	    if (strstr ((const char *) notice, (const char *) FcNoticeFoundries[i].notice))
+		return FcNoticeFoundries[i].foundry;
+    return 0;
+}
+
+static FcBool
+FcVendorMatch(const char *vendor, const char *vendor_string)
+{
+    /* vendor is not necessarily NUL-terminated. */
+    int i, len;
+    
+    len = strlen(vendor_string);
+    if (memcmp(vendor, vendor_string, len) != 0)
+        return FcFalse;
+    for (i = len; i < 4; i++)
+        if (vendor[i] != ' ' && vendor[i] != '\0')
+            return FcFalse;
+    return FcTrue;
+}
+
+/* This table is partly taken from ttmkfdir by Joerg Pommnitz. */
+
+/* It should not contain useless entries (such as UNKN) nor duplicate
+   entries for padding both with spaces and NULs. */
+
+static const struct {
+    const FcChar8   *vendor;
+    const FcChar8   *foundry;
+} FcVendorFoundries[] = {
+    { (const FcChar8*) "ADBE", (const FcChar8 *) "adobe"},
+    { (const FcChar8*) "AGFA", (const FcChar8 *) "agfa"},
+    { (const FcChar8*) "ALTS", (const FcChar8 *) "altsys"},
+    { (const FcChar8*) "APPL", (const FcChar8 *) "apple"},
+    { (const FcChar8*) "ARPH", (const FcChar8 *) "arphic"},
+    { (const FcChar8*) "ATEC", (const FcChar8 *) "alltype"},
+    { (const FcChar8*) "B&H",  (const FcChar8 *) "b&h"},
+    { (const FcChar8*) "BITS", (const FcChar8 *) "bitstream"},
+    { (const FcChar8*) "CANO", (const FcChar8 *) "cannon"},
+    { (const FcChar8*) "DYNA", (const FcChar8 *) "dynalab"},
+    { (const FcChar8*) "EPSN", (const FcChar8 *) "epson"},
+    { (const FcChar8*) "FJ",   (const FcChar8 *) "fujitsu"},
+    { (const FcChar8*) "IBM",  (const FcChar8 *) "ibm"},
+    { (const FcChar8*) "ITC",  (const FcChar8 *) "itc"},
+    { (const FcChar8*) "IMPR", (const FcChar8 *) "impress"},
+    { (const FcChar8*) "LARA", (const FcChar8 *) "larabiefonts"},
+    { (const FcChar8*) "LEAF", (const FcChar8 *) "interleaf"},
+    { (const FcChar8*) "LETR", (const FcChar8 *) "letraset"},
+    { (const FcChar8*) "LINO", (const FcChar8 *) "linotype"},
+    { (const FcChar8*) "MACR", (const FcChar8 *) "macromedia"},
+    { (const FcChar8*) "MONO", (const FcChar8 *) "monotype"},
+    { (const FcChar8*) "MS",   (const FcChar8 *) "microsoft"},
+    { (const FcChar8*) "MT",   (const FcChar8 *) "monotype"},
+    { (const FcChar8*) "NEC",  (const FcChar8 *) "nec"},
+    { (const FcChar8*) "PARA", (const FcChar8 *) "paratype"},
+    { (const FcChar8*) "QMSI", (const FcChar8 *) "qms"},
+    { (const FcChar8*) "RICO", (const FcChar8 *) "ricoh"},
+    { (const FcChar8*) "URW",  (const FcChar8 *) "urw"},
+    { (const FcChar8*) "Y&Y",  (const FcChar8 *) "y&y"}
+};
+
+#define NUM_VENDOR_FOUNDRIES	(sizeof (FcVendorFoundries) / sizeof (FcVendorFoundries[0]))
+
+static const FcChar8 *
+FcVendorFoundry(const char *vendor)
+{
+    int i;
+    
+    if (vendor)
+	for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++)
+	    if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor))
+		return FcVendorFoundries[i].foundry;
+    return 0;
+}
+
+
 FcPattern *
 FcFreeTypeQuery (const FcChar8	*file,
 		 int		id,
@@ -122,13 +267,17 @@
     FcPattern	    *pat;
     int		    slant;
     int		    weight;
+    int		    width = -1;
     int		    i;
     FcCharSet	    *cs;
     FcLangSet	    *ls;
     FT_Library	    ftLibrary;
-    FcChar8	    *family;
-    FcChar8	    *style;
+    FcChar8	    *family = 0;
+    FcChar8	    *style = 0;
+    const FcChar8   *foundry = 0;
+    int		    spacing;
     TT_OS2	    *os2;
+    PS_FontInfoRec  psfontinfo;
     TT_Header	    *head;
     const FcChar8   *exclusiveLang = 0;
     FT_SfntName	    sname;
@@ -163,23 +312,32 @@
     if (face->style_flags & FT_STYLE_FLAG_ITALIC)
 	slant = FC_SLANT_ITALIC;
 
-    if (!FcPatternAddInteger (pat, FC_SLANT, slant))
-	goto bail1;
 
     weight = FC_WEIGHT_MEDIUM;
     if (face->style_flags & FT_STYLE_FLAG_BOLD)
 	weight = FC_WEIGHT_BOLD;
 
-    if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
-	goto bail1;
+    /*
+     * Get the OS/2 table
+     */
+    os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
+
+    /*
+     * Look first in the OS/2 table for the foundry, if
+     * not found here, the various notices will be searched for
+     * that information, either from the sfnt name tables or
+     * the Postscript FontInfo dictionary.  Finally, the
+     * BDF properties will queried.
+     */
+    
+    if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
+        foundry = FcVendorFoundry(os2->achVendID);
 
     /*
      * Grub through the name table looking for family
      * and style names.  FreeType makes quite a hash
      * of them
      */
-    family = 0;
-    style = 0;
     snamec = FT_Get_Sfnt_Name_Count (face);
     for (snamei = 0; snamei < snamec; snamei++)
     {
@@ -289,7 +447,9 @@
 	    prio |= FC_NAME_PRIO_NAME_PS;
 	    break;
 	case TT_NAME_ID_FONT_SUBFAMILY:
-	    break;
+        case TT_NAME_ID_TRADEMARK:
+        case TT_NAME_ID_MANUFACTURER:
+            break;
 	default:
 	    continue;
 	}
@@ -402,6 +562,12 @@
 		style_prio = prio;
 	    }
 	    break;
+        case TT_NAME_ID_TRADEMARK:
+        case TT_NAME_ID_MANUFACTURER:
+	    /* If the foundry wasn't found in the OS/2 table, look here */
+            if(!foundry)
+                foundry = FcNoticeFoundry(utf8);
+            break;
 	}
 	if (utf8)
 	    free (utf8);
@@ -468,7 +634,12 @@
     if (!FcPatternAddString (pat, FC_SOURCE, (FcChar8 *) "FreeType"))
 	goto bail1;
 
-#if 1
+#if 0
+    /*
+     * don't even try this -- CJK 'monospace' fonts are really
+     * dual width, and most other fonts don't bother to set
+     * the attribute.  Sigh.
+     */
     if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
 	if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
 	    goto bail1;
@@ -489,10 +660,6 @@
 	    goto bail1;
     }
 
-    /*
-     * Get the OS/2 table and poke about
-     */
-    os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
     {
 	for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
@@ -526,10 +693,185 @@
 	}
     }
 
+    if (os2 && os2->version != 0xffff)
+    {
+	if (os2->usWeightClass == 0)
+	    weight = -1;
+	else if (os2->usWeightClass < 150)
+	    weight = FC_WEIGHT_THIN;
+	else if (os2->usWeightClass < 250)
+	    weight = FC_WEIGHT_EXTRALIGHT;
+	else if (os2->usWeightClass < 350)
+	    weight = FC_WEIGHT_LIGHT;
+	else if (os2->usWeightClass < 450)
+	    weight = FC_WEIGHT_REGULAR;
+	else if (os2->usWeightClass < 550)
+	    weight = FC_WEIGHT_MEDIUM;
+	else if (os2->usWeightClass < 650)
+	    weight = FC_WEIGHT_SEMIBOLD;
+	else if (os2->usWeightClass < 750)
+	    weight = FC_WEIGHT_BOLD;
+	else if (os2->usWeightClass < 850)
+	    weight = FC_WEIGHT_EXTRABOLD;
+	else if (os2->usWeightClass < 950)
+	    weight = FC_WEIGHT_BLACK;
+	else
+	    weight = FC_WEIGHT_MEDIUM;
+
+	switch (os2->usWidthClass) {
+	case 1:	width = FC_WIDTH_ULTRACONDENSED; break;
+	case 2:	width = FC_WIDTH_EXTRACONDENSED; break;
+	case 3:	width = FC_WIDTH_CONDENSED; break;
+	case 4:	width = FC_WIDTH_SEMICONDENSED; break;
+	case 5:	width = FC_WIDTH_NORMAL; break;
+	case 6:	width = FC_WIDTH_SEMIEXPANDED; break;
+	case 7:	width = FC_WIDTH_EXPANDED; break;
+	case 8:	width = FC_WIDTH_EXTRAEXPANDED; break;
+	case 9:	width = FC_WIDTH_ULTRAEXPANDED; break;
+	}
+    }
+
+    /*
+     * Type 1: Check for FontInfo dictionary information
+     * Code from g2@magestudios.net (Gerard Escalante)
+     */
+    
+    if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
+    {
+	if (psfontinfo.weight)
+	{
+	    static struct {
+		char    *name;
+		int	value;
+	    } ps_weights[] = {
+		{ "thin",		FC_WEIGHT_THIN },
+		{ "extralight",		FC_WEIGHT_EXTRALIGHT },
+		{ "ultralight",		FC_WEIGHT_ULTRALIGHT },
+		{ "light",		FC_WEIGHT_LIGHT },
+		{ "regular",		FC_WEIGHT_REGULAR },
+		{ "normal",		FC_WEIGHT_NORMAL },
+		{ "medium",		FC_WEIGHT_MEDIUM },
+		{ "demibold",		FC_WEIGHT_DEMIBOLD },
+		{ "semibold",		FC_WEIGHT_SEMIBOLD },
+		{ "bold",		FC_WEIGHT_BOLD },
+		{ "extrabold",		FC_WEIGHT_EXTRABOLD },
+		{ "ultrabold",		FC_WEIGHT_ULTRABOLD },
+		{ "black",		FC_WEIGHT_BLACK },
+		{ "heavy",		FC_WEIGHT_HEAVY },
+	    };
+#define NUM_PS_WEIGHTS	(sizeof (ps_weights) / sizeof (ps_weights[0]))
+	    int	w;
+	    for (w = 0; w < NUM_PS_WEIGHTS; w++)
+		if (!FcStrCmpIgnoreCase ((FcChar8 *) ps_weights[w].name,
+					 (FcChar8 *) psfontinfo.weight))
+		{
+		    weight = ps_weights[w].value;
+		    break;
+		}
+	}
+     
+#if 0
+	/* 
+	 * Don't bother with italic_angle; FreeType already extracts that
+	 * information for us and sticks it into style_flags
+	 */
+        if (psfontinfo.italic_angle < 0) 
+            slant = FC_SLANT_ITALIC; 
+        else if (psfontinfo.italic_angle >= 0) 
+            slant = FC_SLANT_ROMAN; 
+#endif
+
+        if(!foundry)
+            foundry = FcNoticeFoundry(psfontinfo.notice);
+    }
+    
+#ifdef USE_FTBDF
+    /*
+     * Finally, look for a FOUNDRY BDF property if no other
+     * mechanism has managed to locate a foundry
+     */
+
+    if (!foundry)
+    {
+	int             rc;
+	BDF_PropertyRec prop;
+	rc = MY_Get_BDF_Property(face, "FOUNDRY", &prop);
+	if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM)
+	    foundry = prop.u.atom;
+    }
+
+    if (width == -1)
+    {
+	BDF_PropertyRec prop;
+	if (MY_Get_BDF_Property(face, "RELATIVE_SETWIDTH", &prop) == 0 &&
+	    (prop.type == BDF_PROPERTY_TYPE_INTEGER ||
+	     prop.type == BDF_PROPERTY_TYPE_CARDINAL))
+	{
+	    FT_Int32	value;
+	    
+	    if (prop.type == BDF_PROPERTY_TYPE_INTEGER)
+		value = prop.u.integer;
+	    else
+		value = (FT_Int32) prop.u.cardinal;
+	    switch ((value + 5) / 10) {
+	    case 1: width = FC_WIDTH_ULTRACONDENSED; break;
+	    case 2: width = FC_WIDTH_EXTRACONDENSED; break;
+	    case 3: width = FC_WIDTH_CONDENSED; break;
+	    case 4: width = FC_WIDTH_SEMICONDENSED; break;
+	    case 5: width = FC_WIDTH_NORMAL; break;
+	    case 6: width = FC_WIDTH_SEMIEXPANDED; break;
+	    case 7: width = FC_WIDTH_EXPANDED; break;
+	    case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
+	    case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
+	    }
+	}
+	else if (MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
+		 prop.type == BDF_PROPERTY_TYPE_ATOM)
+	{
+	    static struct {
+		FcChar8	    *width_name;
+		int	    width;
+	    } FcSetWidths[] = {
+		{ "Condensed",	    FC_WIDTH_CONDENSED },
+		{ "SemiCondensed",  FC_WIDTH_SEMICONDENSED },
+		{ "Normal",	    FC_WIDTH_NORMAL },
+	    };
+	    int	i;
+
+	    if (FcDebug () & FC_DBG_SCANV)
+		printf ("\nsetwidth: %s\n", prop.u.atom);
+	    for (i = 0; i < sizeof (FcSetWidths) / sizeof (FcSetWidths[0]); i++)
+		if (!FcStrCmpIgnoreCase ((FcChar8 *) prop.u.atom,
+					 FcSetWidths[i].width_name))
+		{
+		    width = FcSetWidths[i].width;
+		    break;
+		}
+	}
+    }
+
+#endif
+
+    if (!FcPatternAddInteger (pat, FC_SLANT, slant))
+	goto bail1;
+
+    if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
+	goto bail1;
+
+    if (width != -1)
+	if (!FcPatternAddInteger (pat, FC_WIDTH, width))
+	    goto bail1;
+
+    if(foundry) 
+    {
+        if(!FcPatternAddString (pat, FC_FOUNDRY, foundry))
+            goto bail1;
+    }
+
     /*
      * Compute the unicode coverage for the font
      */
-    cs = FcFreeTypeCharSet (face, blanks);
+    cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
     if (!cs)
 	goto bail1;
 
@@ -553,6 +895,10 @@
     if (!FcPatternAddLangSet (pat, FC_LANG, ls))
 	goto bail2;
 
+    if (spacing != FC_PROPORTIONAL)
+	if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
+	    goto bail2;
+
     /*
      * Drop our reference to the charset
      */
@@ -582,3 +928,802 @@
     FT_Done_FreeType (ftLibrary);
     return 0;
 }
+
+
+/*
+ * Figure out whether the available freetype has FT_Get_Next_Char
+ */
+
+#if FREETYPE_MAJOR > 2
+# define HAS_NEXT_CHAR
+#else
+# if FREETYPE_MAJOR == 2
+#  if FREETYPE_MINOR > 0
+#   define HAS_NEXT_CHAR
+#  else
+#   if FREETYPE_MINOR == 0
+#    if FREETYPE_PATCH >= 9
+#     define HAS_NEXT_CHAR
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+/*
+ * For our purposes, this approximation is sufficient
+ */
+#ifndef HAS_NEXT_CHAR
+#define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
+#define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
+					  (*(gi) = 0), 0 : \
+					  (*(gi) = 1), (ucs4) + 1)
+#warning "No FT_Get_Next_Char"
+#endif
+
+typedef struct _FcCharEnt {
+    FcChar16	    bmp;
+    unsigned char   encode;
+} FcCharEnt;
+
+struct _FcCharMap {
+    const FcCharEnt *ent;
+    int		    nent;
+};
+
+typedef struct _FcFontDecode {
+    FT_Encoding	    encoding;
+    const FcCharMap *map;
+    FcChar32	    max;
+} FcFontDecode;
+
+static const FcCharEnt AppleRomanEnt[] = {
+    { 0x0020, 0x20 }, /* SPACE */
+    { 0x0021, 0x21 }, /* EXCLAMATION MARK */
+    { 0x0022, 0x22 }, /* QUOTATION MARK */
+    { 0x0023, 0x23 }, /* NUMBER SIGN */
+    { 0x0024, 0x24 }, /* DOLLAR SIGN */
+    { 0x0025, 0x25 }, /* PERCENT SIGN */
+    { 0x0026, 0x26 }, /* AMPERSAND */
+    { 0x0027, 0x27 }, /* APOSTROPHE */
+    { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
+    { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
+    { 0x002A, 0x2A }, /* ASTERISK */
+    { 0x002B, 0x2B }, /* PLUS SIGN */
+    { 0x002C, 0x2C }, /* COMMA */
+    { 0x002D, 0x2D }, /* HYPHEN-MINUS */
+    { 0x002E, 0x2E }, /* FULL STOP */
+    { 0x002F, 0x2F }, /* SOLIDUS */
+    { 0x0030, 0x30 }, /* DIGIT ZERO */
+    { 0x0031, 0x31 }, /* DIGIT ONE */
+    { 0x0032, 0x32 }, /* DIGIT TWO */
+    { 0x0033, 0x33 }, /* DIGIT THREE */
+    { 0x0034, 0x34 }, /* DIGIT FOUR */
+    { 0x0035, 0x35 }, /* DIGIT FIVE */
+    { 0x0036, 0x36 }, /* DIGIT SIX */
+    { 0x0037, 0x37 }, /* DIGIT SEVEN */
+    { 0x0038, 0x38 }, /* DIGIT EIGHT */
+    { 0x0039, 0x39 }, /* DIGIT NINE */
+    { 0x003A, 0x3A }, /* COLON */
+    { 0x003B, 0x3B }, /* SEMICOLON */
+    { 0x003C, 0x3C }, /* LESS-THAN SIGN */
+    { 0x003D, 0x3D }, /* EQUALS SIGN */
+    { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
+    { 0x003F, 0x3F }, /* QUESTION MARK */
+    { 0x0040, 0x40 }, /* COMMERCIAL AT */
+    { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
+    { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
+    { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
+    { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
+    { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
+    { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
+    { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
+    { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
+    { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
+    { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
+    { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
+    { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
+    { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
+    { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
+    { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
+    { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
+    { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
+    { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
+    { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
+    { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
+    { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
+    { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
+    { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
+    { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
+    { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
+    { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
+    { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
+    { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
+    { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
+    { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
+    { 0x005F, 0x5F }, /* LOW LINE */
+    { 0x0060, 0x60 }, /* GRAVE ACCENT */
+    { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
+    { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
+    { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
+    { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
+    { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
+    { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
+    { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
+    { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
+    { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
+    { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
+    { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
+    { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
+    { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
+    { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
+    { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
+    { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
+    { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
+    { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
+    { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
+    { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
+    { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
+    { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
+    { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
+    { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
+    { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
+    { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
+    { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
+    { 0x007C, 0x7C }, /* VERTICAL LINE */
+    { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
+    { 0x007E, 0x7E }, /* TILDE */
+    { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
+    { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
+    { 0x00A2, 0xA2 }, /* CENT SIGN */
+    { 0x00A3, 0xA3 }, /* POUND SIGN */
+    { 0x00A5, 0xB4 }, /* YEN SIGN */
+    { 0x00A7, 0xA4 }, /* SECTION SIGN */
+    { 0x00A8, 0xAC }, /* DIAERESIS */
+    { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
+    { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
+    { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+    { 0x00AC, 0xC2 }, /* NOT SIGN */
+    { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
+    { 0x00AF, 0xF8 }, /* MACRON */
+    { 0x00B0, 0xA1 }, /* DEGREE SIGN */
+    { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
+    { 0x00B4, 0xAB }, /* ACUTE ACCENT */
+    { 0x00B5, 0xB5 }, /* MICRO SIGN */
+    { 0x00B6, 0xA6 }, /* PILCROW SIGN */
+    { 0x00B7, 0xE1 }, /* MIDDLE DOT */
+    { 0x00B8, 0xFC }, /* CEDILLA */
+    { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
+    { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+    { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
+    { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
+    { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
+    { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+    { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
+    { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
+    { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
+    { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
+    { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
+    { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
+    { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
+    { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+    { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
+    { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
+    { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
+    { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+    { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
+    { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
+    { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
+    { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
+    { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+    { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
+    { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
+    { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
+    { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
+    { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
+    { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+    { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
+    { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
+    { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
+    { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
+    { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
+    { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
+    { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
+    { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
+    { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
+    { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
+    { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
+    { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
+    { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
+    { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
+    { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
+    { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
+    { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
+    { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
+    { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
+    { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
+    { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
+    { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
+    { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
+    { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
+    { 0x00F7, 0xD6 }, /* DIVISION SIGN */
+    { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
+    { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
+    { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
+    { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
+    { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
+    { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
+    { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
+    { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
+    { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
+    { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
+    { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
+    { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
+    { 0x02C7, 0xFF }, /* CARON */
+    { 0x02D8, 0xF9 }, /* BREVE */
+    { 0x02D9, 0xFA }, /* DOT ABOVE */
+    { 0x02DA, 0xFB }, /* RING ABOVE */
+    { 0x02DB, 0xFE }, /* OGONEK */
+    { 0x02DC, 0xF7 }, /* SMALL TILDE */
+    { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
+    { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
+    { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
+    { 0x2013, 0xD0 }, /* EN DASH */
+    { 0x2014, 0xD1 }, /* EM DASH */
+    { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
+    { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
+    { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
+    { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
+    { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
+    { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
+    { 0x2020, 0xA0 }, /* DAGGER */
+    { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
+    { 0x2022, 0xA5 }, /* BULLET */
+    { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
+    { 0x2030, 0xE4 }, /* PER MILLE SIGN */
+    { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
+    { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
+    { 0x2044, 0xDA }, /* FRACTION SLASH */
+    { 0x20AC, 0xDB }, /* EURO SIGN */
+    { 0x2122, 0xAA }, /* TRADE MARK SIGN */
+    { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
+    { 0x2206, 0xC6 }, /* INCREMENT */
+    { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
+    { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
+    { 0x221A, 0xC3 }, /* SQUARE ROOT */
+    { 0x221E, 0xB0 }, /* INFINITY */
+    { 0x222B, 0xBA }, /* INTEGRAL */
+    { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
+    { 0x2260, 0xAD }, /* NOT EQUAL TO */
+    { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
+    { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
+    { 0x25CA, 0xD7 }, /* LOZENGE */
+    { 0xF8FF, 0xF0 }, /* Apple logo */
+    { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
+    { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
+};
+
+static const FcCharMap AppleRoman = {
+    AppleRomanEnt,
+    sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
+};
+
+static const FcCharEnt AdobeSymbolEnt[] = {
+    { 0x0020, 0x20 }, /* SPACE	# space */
+    { 0x0021, 0x21 }, /* EXCLAMATION MARK	# exclam */
+    { 0x0023, 0x23 }, /* NUMBER SIGN	# numbersign */
+    { 0x0025, 0x25 }, /* PERCENT SIGN	# percent */
+    { 0x0026, 0x26 }, /* AMPERSAND	# ampersand */
+    { 0x0028, 0x28 }, /* LEFT PARENTHESIS	# parenleft */
+    { 0x0029, 0x29 }, /* RIGHT PARENTHESIS	# parenright */
+    { 0x002B, 0x2B }, /* PLUS SIGN	# plus */
+    { 0x002C, 0x2C }, /* COMMA	# comma */
+    { 0x002E, 0x2E }, /* FULL STOP	# period */
+    { 0x002F, 0x2F }, /* SOLIDUS	# slash */
+    { 0x0030, 0x30 }, /* DIGIT ZERO	# zero */
+    { 0x0031, 0x31 }, /* DIGIT ONE	# one */
+    { 0x0032, 0x32 }, /* DIGIT TWO	# two */
+    { 0x0033, 0x33 }, /* DIGIT THREE	# three */
+    { 0x0034, 0x34 }, /* DIGIT FOUR	# four */
+    { 0x0035, 0x35 }, /* DIGIT FIVE	# five */
+    { 0x0036, 0x36 }, /* DIGIT SIX	# six */
+    { 0x0037, 0x37 }, /* DIGIT SEVEN	# seven */
+    { 0x0038, 0x38 }, /* DIGIT EIGHT	# eight */
+    { 0x0039, 0x39 }, /* DIGIT NINE	# nine */
+    { 0x003A, 0x3A }, /* COLON	# colon */
+    { 0x003B, 0x3B }, /* SEMICOLON	# semicolon */
+    { 0x003C, 0x3C }, /* LESS-THAN SIGN	# less */
+    { 0x003D, 0x3D }, /* EQUALS SIGN	# equal */
+    { 0x003E, 0x3E }, /* GREATER-THAN SIGN	# greater */
+    { 0x003F, 0x3F }, /* QUESTION MARK	# question */
+    { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET	# bracketleft */
+    { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET	# bracketright */
+    { 0x005F, 0x5F }, /* LOW LINE	# underscore */
+    { 0x007B, 0x7B }, /* LEFT CURLY BRACKET	# braceleft */
+    { 0x007C, 0x7C }, /* VERTICAL LINE	# bar */
+    { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET	# braceright */
+    { 0x00A0, 0x20 }, /* NO-BREAK SPACE	# space */
+    { 0x00AC, 0xD8 }, /* NOT SIGN	# logicalnot */
+    { 0x00B0, 0xB0 }, /* DEGREE SIGN	# degree */
+    { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN	# plusminus */
+    { 0x00B5, 0x6D }, /* MICRO SIGN	# mu */
+    { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN	# multiply */
+    { 0x00F7, 0xB8 }, /* DIVISION SIGN	# divide */
+    { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK	# florin */
+    { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA	# Alpha */
+    { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA	# Beta */
+    { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA	# Gamma */
+    { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA	# Delta */
+    { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON	# Epsilon */
+    { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA	# Zeta */
+    { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA	# Eta */
+    { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA	# Theta */
+    { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA	# Iota */
+    { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA	# Kappa */
+    { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA	# Lambda */
+    { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU	# Mu */
+    { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU	# Nu */
+    { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI	# Xi */
+    { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON	# Omicron */
+    { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI	# Pi */
+    { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO	# Rho */
+    { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA	# Sigma */
+    { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU	# Tau */
+    { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON	# Upsilon */
+    { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI	# Phi */
+    { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI	# Chi */
+    { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI	# Psi */
+    { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA	# Omega */
+    { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA	# alpha */
+    { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA	# beta */
+    { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA	# gamma */
+    { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA	# delta */
+    { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON	# epsilon */
+    { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA	# zeta */
+    { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA	# eta */
+    { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA	# theta */
+    { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA	# iota */
+    { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA	# kappa */
+    { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA	# lambda */
+    { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU	# mu */
+    { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU	# nu */
+    { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI	# xi */
+    { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON	# omicron */
+    { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI	# pi */
+    { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO	# rho */
+    { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA	# sigma1 */
+    { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA	# sigma */
+    { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU	# tau */
+    { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON	# upsilon */
+    { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI	# phi */
+    { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI	# chi */
+    { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI	# psi */
+    { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA	# omega */
+    { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL	# theta1 */
+    { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL	# Upsilon1 */
+    { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL	# phi1 */
+    { 0x03D6, 0x76 }, /* GREEK PI SYMBOL	# omega1 */
+    { 0x2022, 0xB7 }, /* BULLET	# bullet */
+    { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS	# ellipsis */
+    { 0x2032, 0xA2 }, /* PRIME	# minute */
+    { 0x2033, 0xB2 }, /* DOUBLE PRIME	# second */
+    { 0x2044, 0xA4 }, /* FRACTION SLASH	# fraction */
+    { 0x20AC, 0xA0 }, /* EURO SIGN	# Euro */
+    { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I	# Ifraktur */
+    { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P	# weierstrass */
+    { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R	# Rfraktur */
+    { 0x2126, 0x57 }, /* OHM SIGN	# Omega */
+    { 0x2135, 0xC0 }, /* ALEF SYMBOL	# aleph */
+    { 0x2190, 0xAC }, /* LEFTWARDS ARROW	# arrowleft */
+    { 0x2191, 0xAD }, /* UPWARDS ARROW	# arrowup */
+    { 0x2192, 0xAE }, /* RIGHTWARDS ARROW	# arrowright */
+    { 0x2193, 0xAF }, /* DOWNWARDS ARROW	# arrowdown */
+    { 0x2194, 0xAB }, /* LEFT RIGHT ARROW	# arrowboth */
+    { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS	# carriagereturn */
+    { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW	# arrowdblleft */
+    { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW	# arrowdblup */
+    { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW	# arrowdblright */
+    { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW	# arrowdbldown */
+    { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW	# arrowdblboth */
+    { 0x2200, 0x22 }, /* FOR ALL	# universal */
+    { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL	# partialdiff */
+    { 0x2203, 0x24 }, /* THERE EXISTS	# existential */
+    { 0x2205, 0xC6 }, /* EMPTY SET	# emptyset */
+    { 0x2206, 0x44 }, /* INCREMENT	# Delta */
+    { 0x2207, 0xD1 }, /* NABLA	# gradient */
+    { 0x2208, 0xCE }, /* ELEMENT OF	# element */
+    { 0x2209, 0xCF }, /* NOT AN ELEMENT OF	# notelement */
+    { 0x220B, 0x27 }, /* CONTAINS AS MEMBER	# suchthat */
+    { 0x220F, 0xD5 }, /* N-ARY PRODUCT	# product */
+    { 0x2211, 0xE5 }, /* N-ARY SUMMATION	# summation */
+    { 0x2212, 0x2D }, /* MINUS SIGN	# minus */
+    { 0x2215, 0xA4 }, /* DIVISION SLASH	# fraction */
+    { 0x2217, 0x2A }, /* ASTERISK OPERATOR	# asteriskmath */
+    { 0x221A, 0xD6 }, /* SQUARE ROOT	# radical */
+    { 0x221D, 0xB5 }, /* PROPORTIONAL TO	# proportional */
+    { 0x221E, 0xA5 }, /* INFINITY	# infinity */
+    { 0x2220, 0xD0 }, /* ANGLE	# angle */
+    { 0x2227, 0xD9 }, /* LOGICAL AND	# logicaland */
+    { 0x2228, 0xDA }, /* LOGICAL OR	# logicalor */
+    { 0x2229, 0xC7 }, /* INTERSECTION	# intersection */
+    { 0x222A, 0xC8 }, /* UNION	# union */
+    { 0x222B, 0xF2 }, /* INTEGRAL	# integral */
+    { 0x2234, 0x5C }, /* THEREFORE	# therefore */
+    { 0x223C, 0x7E }, /* TILDE OPERATOR	# similar */
+    { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO	# congruent */
+    { 0x2248, 0xBB }, /* ALMOST EQUAL TO	# approxequal */
+    { 0x2260, 0xB9 }, /* NOT EQUAL TO	# notequal */
+    { 0x2261, 0xBA }, /* IDENTICAL TO	# equivalence */
+    { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO	# lessequal */
+    { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO	# greaterequal */
+    { 0x2282, 0xCC }, /* SUBSET OF	# propersubset */
+    { 0x2283, 0xC9 }, /* SUPERSET OF	# propersuperset */
+    { 0x2284, 0xCB }, /* NOT A SUBSET OF	# notsubset */
+    { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO	# reflexsubset */
+    { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO	# reflexsuperset */
+    { 0x2295, 0xC5 }, /* CIRCLED PLUS	# circleplus */
+    { 0x2297, 0xC4 }, /* CIRCLED TIMES	# circlemultiply */
+    { 0x22A5, 0x5E }, /* UP TACK	# perpendicular */
+    { 0x22C5, 0xD7 }, /* DOT OPERATOR	# dotmath */
+    { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL	# integraltp */
+    { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL	# integralbt */
+    { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET	# angleleft */
+    { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET	# angleright */
+    { 0x25CA, 0xE0 }, /* LOZENGE	# lozenge */
+    { 0x2660, 0xAA }, /* BLACK SPADE SUIT	# spade */
+    { 0x2663, 0xA7 }, /* BLACK CLUB SUIT	# club */
+    { 0x2665, 0xA9 }, /* BLACK HEART SUIT	# heart */
+    { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT	# diamond */
+    { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF	# copyrightserif (CUS) */
+    { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF	# registerserif (CUS) */
+    { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF	# trademarkserif (CUS) */
+    { 0xF8E5, 0x60 }, /* RADICAL EXTENDER	# radicalex (CUS) */
+    { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER	# arrowvertex (CUS) */
+    { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER	# arrowhorizex (CUS) */
+    { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF	# registersans (CUS) */
+    { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF	# copyrightsans (CUS) */
+    { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF	# trademarksans (CUS) */
+    { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP	# parenlefttp (CUS) */
+    { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER	# parenleftex (CUS) */
+    { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM	# parenleftbt (CUS) */
+    { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP	# bracketlefttp (CUS) */
+    { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER	# bracketleftex (CUS) */
+    { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM	# bracketleftbt (CUS) */
+    { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP	# bracelefttp (CUS) */
+    { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID	# braceleftmid (CUS) */
+    { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM	# braceleftbt (CUS) */
+    { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER	# braceex (CUS) */
+    { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER	# integralex (CUS) */
+    { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP	# parenrighttp (CUS) */
+    { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER	# parenrightex (CUS) */
+    { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM	# parenrightbt (CUS) */
+    { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP	# bracketrighttp (CUS) */
+    { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER	# bracketrightex (CUS) */
+    { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM	# bracketrightbt (CUS) */
+    { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP	# bracerighttp (CUS) */
+    { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID	# bracerightmid (CUS) */
+    { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM	# bracerightbt (CUS) */
+};
+
+static const FcCharMap AdobeSymbol = {
+    AdobeSymbolEnt,
+    sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
+};
+    
+static const FcFontDecode fcFontDecoders[] = {
+    { ft_encoding_unicode,	0,		(1 << 21) - 1 },
+    { ft_encoding_symbol,	&AdobeSymbol,	(1 << 16) - 1 },
+    { ft_encoding_apple_roman,	&AppleRoman,	(1 << 16) - 1 },
+};
+
+#define NUM_DECODE  (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
+
+FcChar32
+FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
+{
+    int		low, high, mid;
+    FcChar16	bmp;
+
+    low = 0;
+    high = map->nent - 1;
+    if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
+	return ~0;
+    while (low <= high)
+    {
+	mid = (high + low) >> 1;
+	bmp = map->ent[mid].bmp;
+	if (ucs4 == bmp)
+	    return (FT_ULong) map->ent[mid].encode;
+	if (ucs4 < bmp)
+	    high = mid - 1;
+	else
+	    low = mid + 1;
+    }
+    return ~0;
+}
+
+FcChar32
+FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
+{
+    int	    i;
+
+    for (i = 0; i < map->nent; i++)
+	if (map->ent[i].encode == private)
+	    return (FcChar32) map->ent[i].bmp;
+    return ~0;
+}
+
+const FcCharMap *
+FcFreeTypeGetPrivateMap (FT_Encoding encoding)
+{
+    int	i;
+
+    for (i = 0; i < NUM_DECODE; i++)
+	if (fcFontDecoders[i].encoding == encoding)
+	    return fcFontDecoders[i].map;
+    return 0;
+}
+
+/*
+ * Map a UCS4 glyph to a glyph index.  Use all available encoding
+ * tables to try and find one that works.  This information is expected
+ * to be cached by higher levels, so performance isn't critical
+ */
+
+FT_UInt
+FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
+{
+    int		    initial, offset, decode;
+    FT_UInt	    glyphindex;
+    FcChar32	    charcode;
+
+    initial = 0;
+    /*
+     * Find the current encoding
+     */
+    if (face->charmap)
+    {
+	for (; initial < NUM_DECODE; initial++)
+	    if (fcFontDecoders[initial].encoding == face->charmap->encoding)
+		break;
+	if (initial == NUM_DECODE)
+	    initial = 0;
+    }
+    /*
+     * Check each encoding for the glyph, starting with the current one
+     */
+    for (offset = 0; offset < NUM_DECODE; offset++)
+    {
+	decode = (initial + offset) % NUM_DECODE;
+	if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
+	    if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
+		continue;
+	if (fcFontDecoders[decode].map)
+	{
+	    charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
+	    if (charcode == ~0)
+		continue;
+	}
+	else
+	    charcode = ucs4;
+	glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
+	if (glyphindex)
+	    return glyphindex;
+    }
+    return 0;
+}
+
+static FcBool
+FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4, 
+		      FT_UInt glyph, FcBlanks *blanks,
+		      FT_Pos *advance)
+{
+    FT_Int	    load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+    FT_GlyphSlot    slot;
+    
+    /*
+     * When using scalable fonts, only report those glyphs
+     * which can be scaled; otherwise those fonts will
+     * only be available at some sizes, and never when
+     * transformed.  Avoid this by simply reporting bitmap-only
+     * glyphs as missing
+     */
+    if (face->face_flags & FT_FACE_FLAG_SCALABLE)
+	load_flags |= FT_LOAD_NO_BITMAP;
+    
+    if (FT_Load_Glyph (face, glyph, load_flags))
+	return FcFalse;
+    
+    slot = face->glyph;
+    if (!glyph)
+	return FcFalse;
+    
+    *advance = slot->metrics.horiAdvance;
+
+    switch (slot->format) {
+    case ft_glyph_format_bitmap:
+	/*
+	 * Bitmaps are assumed to be reasonable; if
+	 * this proves to be a rash assumption, this
+	 * code can be easily modified
+	 */
+	return FcTrue;
+    case ft_glyph_format_outline:
+	/*
+	 * Glyphs with contours are always OK
+	 */
+	if (slot->outline.n_contours != 0)
+	    return FcTrue;
+	/*
+	 * Glyphs with no contours are only OK if
+	 * they're members of the Blanks set specified
+	 * in the configuration.  If blanks isn't set,
+	 * then allow any glyph to be blank
+	 */
+	if (!blanks || FcBlanksIsMember (blanks, ucs4))
+	    return FcTrue;
+	/* fall through ... */
+    default:
+	break;
+    }
+    return FcFalse;
+}
+
+FcCharSet *
+FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
+{
+    FcChar32	    page, off, max, ucs4;
+#ifdef CHECK
+    FcChar32	    font_max = 0;
+#endif
+    FcCharSet	    *fcs;
+    FcCharLeaf	    *leaf;
+    const FcCharMap *map;
+    int		    o;
+    int		    i;
+    FT_UInt	    glyph;
+    FT_Pos	    advance, all_advance = 0;
+    FcBool	    has_advance = FcFalse, fixed_advance = FcTrue;
+
+    fcs = FcCharSetCreate ();
+    if (!fcs)
+	goto bail0;
+    
+    for (o = 0; o < NUM_DECODE; o++)
+    {
+	if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
+	    continue;
+	map = fcFontDecoders[o].map;
+	if (map)
+	{
+	    /*
+	     * Non-Unicode tables are easy; there's a list of all possible
+	     * characters
+	     */
+	    for (i = 0; i < map->nent; i++)
+	    {
+		ucs4 = map->ent[i].bmp;
+		glyph = FT_Get_Char_Index (face, map->ent[i].encode);
+		if (glyph && 
+		    FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
+		{
+		    if (!has_advance)
+		    {
+			has_advance = FcTrue;
+			all_advance = advance;
+		    }
+		    else if (advance != all_advance)
+			fixed_advance = FcFalse;
+		    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
+		    if (!leaf)
+			goto bail1;
+		    leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
+#ifdef CHECK
+		    if (ucs4 > font_max)
+			font_max = ucs4;
+#endif
+		}
+	    }
+	}
+	else
+	{
+	    FT_UInt gindex;
+	  
+	    max = fcFontDecoders[o].max;
+	    /*
+	     * Find the first encoded character in the font
+	     */
+	    if (FT_Get_Char_Index (face, 0))
+	    {
+		ucs4 = 0;
+		gindex = 1;
+	    }
+	    else
+	    {
+		ucs4 = FT_Get_Next_Char (face, 0, &gindex);
+		if (!ucs4)
+		    gindex = 0;
+	    }
+
+	    while (gindex)
+	    {
+		page = ucs4 >> 8;
+		leaf = 0;
+		while ((ucs4 >> 8) == page)
+		{
+		    glyph = FT_Get_Char_Index (face, ucs4);
+		    if (glyph && FcFreeTypeCheckGlyph (face, ucs4, 
+						       glyph, blanks, &advance))
+		    {
+			if (!has_advance)
+			{
+			    has_advance = FcTrue;
+			    all_advance = advance;
+			}
+			else if (advance != all_advance)
+			    fixed_advance = FcFalse;
+			if (!leaf)
+			{
+			    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
+			    if (!leaf)
+				goto bail1;
+			}
+			off = ucs4 & 0xff;
+			leaf->map[off >> 5] |= (1 << (off & 0x1f));
+#ifdef CHECK
+			if (ucs4 > font_max)
+			    font_max = ucs4;
+#endif
+		    }
+		    ucs4++;
+		}
+		ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
+		if (!ucs4)
+		    gindex = 0;
+	    }
+#ifdef CHECK
+	    for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
+	    {
+		FcBool	    FT_Has, FC_Has;
+
+		FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
+		FC_Has = FcCharSetHasChar (fcs, ucs4);
+		if (FT_Has != FC_Has)
+		{
+		    printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
+		}
+	    }
+#endif
+	}
+    }
+#ifdef CHECK
+    printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
+    for (ucs4 = 0; ucs4 <= font_max; ucs4++)
+    {
+	FcBool	has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
+	FcBool	has_bit = FcCharSetHasChar (fcs, ucs4);
+
+	if (has_char && !has_bit)
+	    printf ("Bitmap missing char 0x%x\n", ucs4);
+	else if (!has_char && has_bit)
+	    printf ("Bitmap extra char 0x%x\n", ucs4);
+    }
+#endif
+    if (fixed_advance)
+	*spacing = FC_MONO;
+    else
+	*spacing = FC_PROPORTIONAL;
+    return fcs;
+bail1:
+    FcCharSetDestroy (fcs);
+bail0:
+    return 0;
+}
+
+FcCharSet *
+FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
+{
+    int spacing;
+
+    return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
+}
--- xc/extras/fontconfig/src/fccache.c	2003-12-03 05:57:04.000000000 +0100
+++ xc-fontconfig/extras/fontconfig/src/fccache.c	2003-12-21 12:27:04.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fccache.c,v 1.12 2002/08/22 07:36:44 keithp Exp $
+ *
+ * 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
@@ -187,9 +189,19 @@
     if (dir)
 	if (!FcCacheWriteChars (f, dir))
 	    return FcFalse;
+#ifdef _WIN32
+    if (dir &&
+	dir[strlen((const char *) dir) - 1] != '/' &&
+	dir[strlen((const char *) dir) - 1] != '\\')
+    {
+	if (!FcCacheWriteChars (f, "\\"))
+	    return FcFalse;
+    }
+#else
     if (dir && dir[strlen((const char *) dir) - 1] != '/')
 	if (PUTC ('/', f) == EOF)
 	    return FcFalse;
+#endif
     if (!FcCacheWriteChars (f, file))
 	return FcFalse;
     if (PUTC ('"', f) == EOF)
@@ -257,8 +269,13 @@
 	    return FcFalse;
     }
     strncpy ((char *) path, (const char *) dir, dir_len);
+#ifdef _WIN32
+    if (dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\' )
+	path[dir_len++] = '\\';
+#else
     if (dir[dir_len - 1] != '/')
 	path[dir_len++] = '/';
+#endif
     strcpy ((char *) path + dir_len, (const char *) file);
     if (!FcStrCmp (name, FC_FONT_FILE_DIR))
     {
@@ -294,28 +311,28 @@
 }
 
 static unsigned int
-FcCacheHash (const FcChar8 *string)
+FcCacheHash (const FcChar8 *string, int len)
 {
     unsigned int    h = 0;
     FcChar8	    c;
 
-    while ((c = *string++))
+    while (len-- && (c = *string++))
 	h = (h << 1) ^ c;
-    return 0;
+    return h;
 }
 
 /*
  * Verify the saved timestamp for a file
  */
 FcBool
-FcGlobalCacheCheckTime (FcGlobalCacheInfo *info)
+FcGlobalCacheCheckTime (const FcChar8 *file, FcGlobalCacheInfo *info)
 {
     struct stat	    statb;
 
-    if (stat ((char *) info->file, &statb) < 0)
+    if (stat ((char *) file, &statb) < 0)
     {
 	if (FcDebug () & FC_DBG_CACHE)
-	    printf (" file missing\n");
+	    printf (" file %s missing\n", file);
 	return FcFalse;
     }
     if (statb.st_mtime != info->time)
@@ -360,7 +377,7 @@
     FcFilePathInfo  i;
     FcChar8	    *slash;
 
-    slash = (FcChar8 *) strrchr ((const char *) path, '/');
+    slash = FcStrLastSlash (path);
     if (slash)
     {
         i.dir = path;
@@ -375,7 +392,7 @@
 	i.dir_len = 1;
 	i.base = path;
     }
-    i.base_hash = FcCacheHash (i.base);
+    i.base_hash = FcCacheHash (i.base, -1);
     return i;
 }
 
@@ -385,7 +402,7 @@
 		     int	    len,
 		     FcBool	    create_missing)
 {
-    unsigned int	hash = FcCacheHash (dir);
+    unsigned int	hash = FcCacheHash (dir, len);
     FcGlobalCacheDir	*d, **prev;
 
     for (prev = &cache->ents[hash % FC_GLOBAL_CACHE_DIR_HASH_SIZE];
@@ -426,13 +443,29 @@
 FcGlobalCacheDirAdd (FcGlobalCache  *cache,
 		     const FcChar8  *dir,
 		     time_t	    time,
-		     FcBool	    replace)
+		     FcBool	    replace,
+		     FcBool	    create_missing)
 {
     FcGlobalCacheDir	*d;
     FcFilePathInfo	i;
     FcGlobalCacheSubdir	*subdir;
     FcGlobalCacheDir	*parent;
 
+    i = FcFilePathInfoGet (dir);
+    parent = FcGlobalCacheDirGet (cache, i.dir, i.dir_len, create_missing);
+    /*
+     * Tricky here -- directories containing fonts.cache-1 files
+     * need entries only when the parent doesn't have a cache file.
+     * That is, when the parent already exists in the cache, is
+     * referenced and has a "real" timestamp.  The time of 0 is
+     * special and marks directories which got stuck in the
+     * global cache for this very reason.  Yes, it could
+     * use a separate boolean field, and probably should.
+     */
+    if (!parent || (!create_missing && 
+		    (!parent->info.referenced ||
+		    (parent->info.time == 0))))
+	return 0;
     /*
      * Add this directory to the cache
      */
@@ -440,13 +473,9 @@
     if (!d)
 	return 0;
     d->info.time = time;
-    i = FcFilePathInfoGet (dir);
     /*
      * Add this directory to the subdirectory list of the parent
      */
-    parent = FcGlobalCacheDirGet (cache, i.dir, i.dir_len, FcTrue);
-    if (!parent)
-	return 0;
     subdir = malloc (sizeof (FcGlobalCacheSubdir));
     if (!subdir)
 	return 0;
@@ -483,6 +512,30 @@
     free (d);
 }
 
+/*
+ * If the parent is in the global cache and referenced, add
+ * an entry for 'dir' to the global cache.  This is used
+ * for directories with fonts.cache files
+ */
+
+void
+FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
+			      const FcChar8 *dir)
+{
+    FcGlobalCacheInfo	*info;
+    info = FcGlobalCacheDirAdd (cache, dir, 0, FcFalse, FcFalse);
+    if (info && !info->referenced)
+    {
+	info->referenced = FcTrue;
+	cache->referenced++;
+    }
+}
+
+/*
+ * Check to see if the global cache contains valid data for 'dir'.
+ * If so, scan the global cache for files and directories in 'dir'.
+ * else, return False.
+ */
 FcBool
 FcGlobalCacheScanDir (FcFontSet		*set,
 		      FcStrSet		*dirs,
@@ -496,6 +549,7 @@
     int			h;
     int			dir_len;
     FcGlobalCacheSubdir	*subdir;
+    FcBool		any_in_cache = FcFalse;
 
     if (FcDebug() & FC_DBG_CACHE)
 	printf ("FcGlobalCacheScanDir %s\n", dir);
@@ -507,19 +561,27 @@
 	return FcFalse;
     }
 
-    if (!FcGlobalCacheCheckTime (&d->info))
+    /*
+     * See if the timestamp recorded in the global cache
+     * matches the directory time, if not, return False
+     */
+    if (!FcGlobalCacheCheckTime (d->info.file, &d->info))
     {
 	if (FcDebug () & FC_DBG_CACHE)
 	    printf ("\tdir cache entry time mismatch\n");
 	return FcFalse;
     }
 
+    /*
+     * Add files from 'dir' to the fontset
+     */
     dir_len = strlen ((const char *) dir);
     for (h = 0; h < FC_GLOBAL_CACHE_FILE_HASH_SIZE; h++)
 	for (f = d->ents[h]; f; f = f->next)
 	{
 	    if (FcDebug() & FC_DBG_CACHEV)
 		printf ("FcGlobalCacheScanDir add file %s\n", f->info.file);
+	    any_in_cache = FcTrue;
 	    if (!FcCacheFontSetAdd (set, dirs, dir, dir_len,
 				    f->info.file, f->name))
 	    {
@@ -528,11 +590,14 @@
 	    }
 	    FcGlobalCacheReferenced (cache, &f->info);
 	}
+    /*
+     * Add directories in 'dir' to 'dirs'
+     */
     for (subdir = d->subdirs; subdir; subdir = subdir->next)
     {
-	FcFilePathInfo info;
+	FcFilePathInfo	info = FcFilePathInfoGet (subdir->ent->info.file);
 	
-	info = FcFilePathInfoGet (subdir->ent->info.file);
+        any_in_cache = FcTrue;
 	if (!FcCacheFontSetAdd (set, dirs, dir, dir_len,
 				info.base, FC_FONT_FILE_DIR))
 	{
@@ -544,7 +609,15 @@
     
     FcGlobalCacheReferenced (cache, &d->info);
 
-    return FcTrue;
+    /*
+     * To recover from a bug in previous versions of fontconfig,
+     * return FcFalse if no entries in the cache were found
+     * for this directory.  This will cause any empty directories
+     * to get rescanned every time fontconfig is initialized.  This
+     * might get removed at some point when the older cache files are
+     * presumably fixed.
+     */
+    return any_in_cache;
 }
 
 /*
@@ -576,7 +649,7 @@
 	}
     }
     if (count)
-	*count = max;
+	*count = max + 1;
     return match;
 }
     
@@ -713,7 +786,7 @@
 	if (FcDebug () & FC_DBG_CACHEV)
 	    printf ("FcGlobalCacheLoad \"%s\" \"%20.20s\"\n", file, name);
 	if (!FcStrCmp (name, FC_FONT_FILE_DIR))
-	    info = FcGlobalCacheDirAdd (cache, file, time, FcFalse);
+	    info = FcGlobalCacheDirAdd (cache, file, time, FcFalse, FcTrue);
 	else
 	    info = FcGlobalCacheFileAdd (cache, file, id, time, name, FcFalse);
 	if (!info)
@@ -743,14 +816,17 @@
 		     int	    id,
 		     const FcChar8  *name)
 {
+    const FcChar8	*match;
     struct stat		statb;
     FcGlobalCacheInfo	*info;
 
+    match = file;
+
     if (stat ((char *) file, &statb) < 0)
 	return FcFalse;
     if (S_ISDIR (statb.st_mode))
 	info = FcGlobalCacheDirAdd (cache, file, statb.st_mtime, 
-				   FcTrue);
+				    FcTrue, FcTrue);
     else
 	info = FcGlobalCacheFileAdd (cache, file, id, statb.st_mtime, 
 				    name, FcTrue);
@@ -780,9 +856,11 @@
     if (cache->broken)
 	return FcFalse;
 
+#if defined (HAVE_GETUID) && defined (HAVE_GETEUID)
     /* Set-UID programs can't safely update the cache */
     if (getuid () != geteuid ())
 	return FcFalse;
+#endif
     
     atomic = FcAtomicCreate (cache_file);
     if (!atomic)
@@ -973,7 +1051,7 @@
 {
     const FcChar8   *cache_slash;
 
-    cache_slash = (const FcChar8 *) strrchr ((const char *) cache, '/');
+    cache_slash = FcStrLastSlash (cache);
     if (cache_slash && !strncmp ((const char *) cache, (const char *) file,
 				 (cache_slash + 1) - cache))
 	return file + ((cache_slash + 1) - cache);
--- xc/extras/fontconfig/src/fcstr.c	2003-11-21 06:56:14.000000000 +0100
+++ xc-fontconfig/extras/fontconfig/src/fcstr.c	2003-12-21 16:22:58.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fcstr.c,v 1.10 2002/08/31 22:17:32 keithp Exp $
+ *
+ * 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
@@ -71,11 +73,7 @@
     {
 	c1 = *s1++;
 	c2 = *s2++;
-	if (!c1 || !c2)
-	    break;
-	c1 = FcToLower (c1);
-	c2 = FcToLower (c2);
-	if (c1 != c2)
+	if (!c1 || (c1 != c2 && (c1 = FcToLower(c1)) != (c2 = FcToLower(c2))))
 	    break;
     }
     return (int) c1 - (int) c2;
@@ -94,11 +92,7 @@
 	do
 	    c2 = *s2++;
 	while (c2 == ' ');
-	if (!c1 || !c2)
-	    break;
-	c1 = FcToLower (c1);
-	c2 = FcToLower (c2);
-	if (c1 != c2)
+	if (!c1 || (c1 != c2 && (c1 = FcToLower(c1)) != (c2 = FcToLower(c2))))
 	    break;
     }
     return (int) c1 - (int) c2;
@@ -115,9 +109,7 @@
     {
 	c1 = *s1++;
 	c2 = *s2++;
-	if (!c1 || !c2)
-	    break;
-	if (c1 != c2)
+	if (!c1 || c1 != c2)
 	    break;
     }
     return (int) c1 - (int) c2;
@@ -419,6 +411,12 @@
     return FcTrue;
 }
 
+FcBool
+FcStrUsesHome (const FcChar8 *s)
+{
+    return *s == '~';
+}
+
 FcChar8 *
 FcStrCopyFilename (const FcChar8 *s)
 {
@@ -426,7 +424,7 @@
     
     if (*s == '~')
     {
-	FcChar8	*home = (FcChar8 *) getenv ("HOME");
+        FcChar8 *home = FcConfigHome ();
 	int	size;
 	if (!home)
 	    return 0;
@@ -451,12 +449,31 @@
 }
 
 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 = (FcChar8 *) strrchr ((char *) file, '/');
+    slash = FcStrLastSlash (file);
     if (!slash)
 	return FcStrCopy ((FcChar8 *) ".");
     dir = malloc ((slash - file) + 1);
@@ -473,7 +490,7 @@
 {
     FcChar8 *slash;
 
-    slash = (FcChar8 *) strrchr ((char *) file, '/');
+    slash = FcStrLastSlash (file);
     if (!slash)
 	return FcStrCopy (file);
     return FcStrCopy (slash + 1);
--- xc/extras/fontconfig/fontconfig/fcfreetype.h	2003-11-21 06:56:14.000000000 +0100
+++ xc-fontconfig/extras/fontconfig/fontconfig/fcfreetype.h	2003-12-21 12:27:04.000000000 +0100
@@ -31,6 +31,9 @@
 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4);
 
 FcCharSet *
+FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing);
+    
+FcCharSet *
 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks);
 
 FcResult
diff -urN xc/extras/fontconfig/Imakefile xc-fontconfig/extras/fontconfig/Imakefile
--- xc/extras/fontconfig/Imakefile	2003-09-25 13:01:13.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/Imakefile	2003-11-21 01:42:41.000000000 +0100
@@ -7,6 +7,9 @@
 
 SUBDIRS=fontconfig $(LINTSUBDIRS)
 
+SOFONTCONFIGREV=2.2
+#define SoRev SOFONTCONFIGREV
+
 FONTCONFIG_REVISION=1
 
 #ifndef FontconfigFontsConfDir
diff -urN xc/extras/fontconfig/configure xc-fontconfig/extras/fontconfig/configure
--- xc/extras/fontconfig/configure	2003-09-25 13:01:14.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/configure	2003-11-21 01:35:12.000000000 +0100
@@ -1248,7 +1248,7 @@
 fi
 
 
-PACKAGE_VERSION=1.0.1
+PACKAGE_VERSION=2.2.1
 
 # Set major version
 PACKAGE_MAJOR=`echo $PACKAGE_VERSION | awk -F . '{ print $1 }'`
diff -urN xc/extras/fontconfig/configure.in xc-fontconfig/extras/fontconfig/configure.in
--- xc/extras/fontconfig/configure.in	2003-09-25 13:01:14.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/configure.in	2003-11-21 01:35:12.000000000 +0100
@@ -43,7 +43,7 @@
 AC_PROG_LN_S
 AC_PATH_X
 
-PACKAGE_VERSION=1.0.1
+PACKAGE_VERSION=2.2.1
 
 # Set major version
 PACKAGE_MAJOR=`echo $PACKAGE_VERSION | awk -F . '{ print $1 }'`
diff -urN xc/extras/fontconfig/fc-cache/fc-cache.c xc-fontconfig/extras/fontconfig/fc-cache/fc-cache.c
--- xc/extras/fontconfig/fc-cache/fc-cache.c	2003-09-25 13:01:15.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fc-cache/fc-cache.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/fc-cache/fc-cache.c,v 1.2 2003/09/13 21:33:00 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/fc-cache/fc-cache.c,v 1.8tsi Exp $
  *
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2002 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
@@ -36,9 +36,6 @@
 #define HAVE_GETOPT_LONG 1
 #endif
 #define HAVE_GETOPT 1
-#if defined(ISC) || defined(Lynx)
-#define HAVE_OPTARG_IN_UNISTD 0
-#endif
 #endif
 
 #ifndef HAVE_GETOPT
@@ -47,9 +44,6 @@
 #ifndef HAVE_GETOPT_LONG
 #define HAVE_GETOPT_LONG 0
 #endif
-#ifndef HAVE_OPTARG_IN_UNISTD
-#define HAVE_OPTARG_IN_UNISTD HAVE_GETOPT
-#endif
 
 #if HAVE_GETOPT_LONG
 #undef  _GNU_SOURCE
@@ -57,13 +51,14 @@
 #include <getopt.h>
 const struct option longopts[] = {
     {"force", 0, 0, 'f'},
+    {"system-only", 0, 0, 's'},
     {"version", 0, 0, 'V'},
     {"verbose", 0, 0, 'v'},
     {"help", 0, 0, '?'},
     {NULL,0,0,0},
 };
 #else
-#if HAVE_GETOPT && !HAVE_OPTARG_IN_UNISTD
+#if HAVE_GETOPT
 extern char *optarg;
 extern int optind, opterr, optopt;
 #endif
@@ -78,6 +73,7 @@
 	     "(all directories in font configuration by default).\n");
     fprintf (stderr, "\n");
     fprintf (stderr, "  -f, --force          scan directories with apparently valid caches\n");
+    fprintf (stderr, "  -s, --system-only    scan system-wide directories only\n");
     fprintf (stderr, "  -v, --verbose        display status information while busy\n");
     fprintf (stderr, "  -V, --version        display font config version and exit\n");
     fprintf (stderr, "  -?, --help           display this help and exit\n");
@@ -135,21 +131,33 @@
 	    continue;
 	}
 	
-	if (stat ((char *) dir, &statb) == -1)
+	if (access ((char *) dir, W_OK) < 0)
 	{
-	    if (errno == ENOENT || errno == ENOTDIR)
-	    {
+	    switch (errno) {
+	    case ENOENT:
+	    case ENOTDIR:
 		if (verbose)
-		    printf ("no such directory, skipping\n");
-	    }
-	    else
-	    {
+		    printf ("skipping, no such directory\n");
+		break;
+	    case EACCES:
+	    case EROFS:
+		if (verbose)
+		    printf ("skipping, no write access\n");
+		break;
+	    default:
 		fprintf (stderr, "\"%s\": ", dir);
 		perror ("");
 		ret++;
 	    }
 	    continue;
 	}
+	if (stat ((char *) dir, &statb) == -1)
+	{
+	    fprintf (stderr, "\"%s\": ", dir);
+	    perror ("");
+	    ret++;
+	    continue;
+	}
 	if (!S_ISDIR (statb.st_mode))
 	{
 	    fprintf (stderr, "\"%s\": not a directory, skipping\n", dir);
@@ -200,6 +208,7 @@
     FcStrList	*list;
     FcBool    	verbose = FcFalse;
     FcBool	force = FcFalse;
+    FcBool	systemOnly = FcFalse;
     FcConfig	*config;
     int		i;
     int		ret;
@@ -216,6 +225,9 @@
 	case 'f':
 	    force = FcTrue;
 	    break;
+	case 's':
+	    systemOnly = FcTrue;
+	    break;
 	case 'V':
 	    fprintf (stderr, "fontconfig version %d.%d.%d\n", 
 		     FC_MAJOR, FC_MINOR, FC_REVISION);
@@ -232,6 +244,8 @@
     i = 1;
 #endif
 
+    if (systemOnly)
+	FcConfigEnableHome (FcFalse);
     config = FcInitLoadConfig ();
     if (!config)
     {
diff -urN xc/extras/fontconfig/fc-lang/fc-lang.c xc-fontconfig/extras/fontconfig/fc-lang/fc-lang.c
--- xc/extras/fontconfig/fc-lang/fc-lang.c	2003-06-04 18:29:38.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fc-lang/fc-lang.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/fc-lang/fc-lang.c,v 1.3 2002/08/22 07:36:43 keithp Exp $
+ *
+ * Copyright � 2002 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
@@ -19,22 +21,38 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/fc-lang/fc-lang.c,v 1.2 2003/06/04 16:29:38 dawes Exp $ */
 
 #include "fcint.h"
+#include "fccharset.c"
+#include "fcstr.c"
 
 /*
  * fc-lang
  *
  * Read a set of language orthographies and build C declarations for
  * charsets which can then be used to identify which languages are
- * supported by a given font.  Note that it would be nice if
- * this could be done while compiling the library, but this
- * code uses a number of routines from the library.  It's
- * expediant to just ship the pre-built version along with the
- * source orthographies.
+ * supported by a given font.  Note that this uses some utilities
+ * from the fontconfig library, so the necessary file is simply
+ * included in this compilation.  A couple of extra utility
+ * functions are also needed in slightly modified form
  */
 
+void
+FcMemAlloc (int kind, int size)
+{
+}
+
+void
+FcMemFree (int kind, int size)
+{
+}
+
+FcChar8 *
+FcConfigHome (void)
+{
+    return getenv ("HOME");
+}
+
 static void 
 fatal (char *file, int lineno, char *msg)
 {
@@ -146,8 +164,8 @@
 
     while ((c = *name++))
     {
-	if (isupper (c))
-	    c = tolower (c);
+	if (isupper ((int) (unsigned char) c))
+	    c = tolower ((int) (unsigned char) c);
 	if (c == '_')
 	    c = '-';
 	if (c == ' ')
@@ -189,6 +207,9 @@
     char	line[1024];
     FcChar32	map[MAX_LANG_SET_MAP];
     int		num_lang_set_map;
+    int		setRangeStart[26];
+    int		setRangeEnd[26];
+    FcChar8	setRangeChar;
     
     while (*++argv)
     {
@@ -282,6 +303,21 @@
     }
 
     /*
+     * Find ranges for each letter for faster searching
+     */
+    setRangeChar = 'a';
+    for (i = 0; sets[i]; i++)
+    {
+	char	c = names[i][0];
+	
+	while (setRangeChar <= c && c <= 'z')
+	    setRangeStart[setRangeChar++ - 'a'] = i;
+    }
+    for (setRangeChar = 'a'; setRangeChar < 'z'; setRangeChar++)
+	setRangeEnd[setRangeChar - 'a'] = setRangeStart[setRangeChar+1-'a'] - 1;
+    setRangeEnd[setRangeChar - 'a'] = i - 1;
+    
+    /*
      * Dump arrays
      */
     for (i = 0; sets[i]; i++)
@@ -325,13 +361,16 @@
 	printf ("};\n\n");
     }
     printf ("#undef L\n\n");
+    
     /*
      * Dump sets
      */
+
     printf ("static const FcLangCharSet  fcLangCharSets[] = {\n");
     for (i = 0; sets[i]; i++)
     {
 	int	j = duplicate[i];
+
 	if (j < 0)
 	    j = i;
 	printf ("    { (FcChar8 *) \"%s\",\n"
@@ -386,6 +425,19 @@
 	printf ("#define NUM_COUNTRY_SET %d\n", ncountry_ent);
     }
     
+
+    /*
+     * Dump sets start/finish for the fastpath
+     */
+    printf ("static const FcLangCharSetRange  fcLangCharSetRanges[] = {\n");
+    for (setRangeChar = 'a'; setRangeChar <= 'z' ; setRangeChar++)
+    {
+	printf ("    { %d, %d }, /* %c */\n",
+		setRangeStart[setRangeChar - 'a'],
+		setRangeEnd[setRangeChar - 'a'], setRangeChar);
+    }
+    printf ("};\n\n");
+ 
     while (fgets (line, sizeof (line), stdin))
 	fputs (line, stdout);
     
diff -urN xc/extras/fontconfig/fc-lang/fclang.h xc-fontconfig/extras/fontconfig/fc-lang/fclang.h
--- xc/extras/fontconfig/fc-lang/fclang.h	2003-06-04 18:29:38.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fc-lang/fclang.h	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/fc-lang/fclang.tmpl.h,v 1.1 2002/07/06 23:21:36 keithp Exp $
+ *
+ * Copyright � 2002 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
@@ -19,11 +21,10 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/fc-lang/fclang.h,v 1.2 2003/06/04 16:29:38 dawes Exp $ */
 
-/* total size: 877 unique leaves: 599 */
+/* total size: 881 unique leaves: 602 */
 
-static const FcCharLeaf	leaves[599] = {
+static const FcCharLeaf	leaves[602] = {
     { { /* 0 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x08104404, 0x08104404,
@@ -41,11 +42,11 @@
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
     { { /* 4 */
-    0xffffff7f, 0xffffffff, 0x3d7f3d7f, 0xffffffff,
-    0xffff3d7f, 0x7f3d7fff, 0xff7f7f3d, 0xffff7fff,
+    0xff7fff7f, 0xff01ff7f, 0x00003d7f, 0x00ff00ff,
+    0x00ff3d7f, 0x003d7fff, 0xff7f7f00, 0x00ff7f00,
     } },
     { { /* 5 */
-    0x7f3d7fff, 0xffffffff, 0x07ffff7f, 0x00000000,
+    0x003d7f00, 0xffff01ff, 0x007fff7f, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
     { { /* 6 */
@@ -213,8 +214,8 @@
     0x00000000, 0x00000000, 0x90400010, 0x10400010,
     } },
     { { /* 47 */
-    0x00000000, 0x00000000, 0x00000000, 0x44300000,
-    0xffffd7f0, 0xfffffffb, 0x00007fff, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0xffffd740, 0xfffffffb, 0x00007fff, 0x00000000,
     } },
     { { /* 48 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
@@ -1313,1110 +1314,1122 @@
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
     { { /* 322 */
+    0xff7fff7f, 0xff01ff00, 0x3dff3d7f, 0xffff7fff,
+    0xffff0000, 0x003d7fff, 0xff7f7f3d, 0x00ff7fff,
+    } },
+    { { /* 323 */
+    0x003d7fff, 0xffffffff, 0x007fff00, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    } },
+    { { /* 324 */
+    0xff7fff7f, 0xff01ff00, 0x00003d7f, 0xffff7fff,
+    0x00ff0000, 0x003d7f7f, 0xff7f7f00, 0x00ff7f00,
+    } },
+    { { /* 325 */
     0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000,
     0x00c00000, 0x0000c00c, 0x03000000, 0x00000000,
     } },
-    { { /* 323 */
+    { { /* 326 */
     0x000fdfff, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 324 */
+    { { /* 327 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x00100400, 0x00100400,
     } },
-    { { /* 325 */
+    { { /* 328 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x18404084, 0x18404084,
     } },
-    { { /* 326 */
+    { { /* 329 */
     0xc0000000, 0x00030000, 0xc0000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 327 */
+    { { /* 330 */
     0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000,
     0x00c00000, 0x0c00c00c, 0x03000000, 0x00000000,
     } },
-    { { /* 328 */
+    { { /* 331 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x00220008, 0x00220008,
     } },
-    { { /* 329 */
+    { { /* 332 */
     0x00000000, 0x00000300, 0x00000000, 0x00000300,
     0x00010040, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 330 */
+    { { /* 333 */
     0x00000000, 0x00000000, 0x08100000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 331 */
+    { { /* 334 */
     0x00000048, 0x00000200, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 332 */
+    { { /* 335 */
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x30000000, 0x00000000, 0x03000000,
     } },
-    { { /* 333 */
+    { { /* 336 */
     0xffff00d0, 0xffffffff, 0x00d0ffff, 0x00000000,
     0x00030000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 334 */
+    { { /* 337 */
     0xffff0002, 0xffffe5ff, 0x0002e5ff, 0x00000000,
     0x0c0c0000, 0x000c0000, 0x00000000, 0x00030000,
     } },
-    { { /* 335 */
+    { { /* 338 */
     0x000c0000, 0x30000000, 0x00000c30, 0x00030000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 336 */
+    { { /* 339 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x263c370f, 0x263c370f,
     } },
-    { { /* 337 */
+    { { /* 340 */
     0x0003000c, 0x00000300, 0x00000000, 0x00000300,
     0x00000000, 0x00018003, 0x00000000, 0x00000000,
     } },
-    { { /* 338 */
+    { { /* 341 */
     0x0800024f, 0x00000008, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 339 */
+    { { /* 342 */
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0xffffffff, 0xffffffff, 0x03ffffff,
     } },
-    { { /* 340 */
+    { { /* 343 */
     0x00000000, 0x00000000, 0x077dfffe, 0x077dfffe,
     0x00000000, 0x00000000, 0x10400010, 0x10400010,
     } },
-    { { /* 341 */
+    { { /* 344 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x10400010, 0x10400010,
     } },
-    { { /* 342 */
+    { { /* 345 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x081047a4, 0x081047a4,
     } },
-    { { /* 343 */
+    { { /* 346 */
     0x0c0030c0, 0x00000000, 0x0f30001e, 0x66000003,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 344 */
+    { { /* 347 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x000a0a09, 0x000a0a09,
     } },
-    { { /* 345 */
+    { { /* 348 */
     0x00000000, 0x00000000, 0x00000c00, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 346 */
+    { { /* 349 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x00400810, 0x00400810,
     } },
-    { { /* 347 */
+    { { /* 350 */
     0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe,
     0x00000000, 0x00000000, 0x0e3c770f, 0x0e3c770f,
     } },
-    { { /* 348 */
+    { { /* 351 */
     0x0c000000, 0x00000300, 0x00000018, 0x00000300,
     0x00000000, 0x00000000, 0x001fe000, 0x03000000,
     } },
-    { { /* 349 */
+    { { /* 352 */
     0x0000100f, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 350 */
+    { { /* 353 */
     0x00000000, 0xc0000000, 0x00000000, 0x0000000c,
     0x00000000, 0x33000000, 0x00003000, 0x00000000,
     } },
-    { { /* 351 */
+    { { /* 354 */
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000280, 0x00000000,
     } },
-    { { /* 352 */
+    { { /* 355 */
     0x7f7b7f8b, 0xef553db4, 0xf35dfba8, 0x400b0243,
     0x8d3efb40, 0x8c2c7bf7, 0xe3fa6eff, 0xa8ed1d3a,
     } },
-    { { /* 353 */
+    { { /* 356 */
     0xcf83e602, 0x35558cf5, 0xffabe048, 0xd85992b9,
     0x2892ab18, 0x8020d7e9, 0xf583c438, 0x450ae74a,
     } },
-    { { /* 354 */
+    { { /* 357 */
     0x9714b000, 0x54007762, 0x1420d188, 0xc8c01020,
     0x00002121, 0x0c0413a8, 0x04408000, 0x082870c0,
     } },
-    { { /* 355 */
+    { { /* 358 */
     0x000408c0, 0x80000002, 0x14722b7b, 0x3bfb7924,
     0x1ae43327, 0x38ef9835, 0x28029ad1, 0xbf69a813,
     } },
-    { { /* 356 */
+    { { /* 359 */
     0x2fc665cf, 0xafc96b11, 0x5053340f, 0xa00486a2,
     0xe8090106, 0xc00e3f0f, 0x81450a88, 0xc6010010,
     } },
-    { { /* 357 */
+    { { /* 360 */
     0x26e1a161, 0xce00444b, 0xd4eec7aa, 0x85bbcadf,
     0xa5203a74, 0x8840436c, 0x8bd23f06, 0x3befff79,
     } },
-    { { /* 358 */
+    { { /* 361 */
     0xe8eff75a, 0x5b36fbcb, 0x1bfd0d49, 0x39ee0154,
     0x2e75d855, 0xa91abfd8, 0xf6bff3d7, 0xb40c67e0,
     } },
-    { { /* 359 */
+    { { /* 362 */
     0x081382c2, 0xd08bd49d, 0x1061065a, 0x59e074f2,
     0xb3128f9f, 0x6aaa0080, 0xb05e3230, 0x60ac9d7a,
     } },
-    { { /* 360 */
+    { { /* 363 */
     0xc900d303, 0x8a563098, 0x13907000, 0x18421f14,
     0x0008c060, 0x10808008, 0xec900400, 0xe6332817,
     } },
-    { { /* 361 */
+    { { /* 364 */
     0x90000758, 0x4e09f708, 0xfc83f485, 0x18c8af53,
     0x080c187c, 0x01146adf, 0xa734c80c, 0x2710a011,
     } },
-    { { /* 362 */
+    { { /* 365 */
     0x422228c5, 0x00210413, 0x41123010, 0x40001820,
     0xc60c022b, 0x10000300, 0x00220022, 0x02495810,
     } },
-    { { /* 363 */
+    { { /* 366 */
     0x9670a094, 0x1792eeb0, 0x05f2cb96, 0x23580025,
     0x42cc25de, 0x4a04cf38, 0x359f0c40, 0x8a001128,
     } },
-    { { /* 364 */
+    { { /* 367 */
     0x910a13fa, 0x10560229, 0x04200641, 0x84f00484,
     0x0c040000, 0x412c0400, 0x11541206, 0x00020a4b,
     } },
-    { { /* 365 */
+    { { /* 368 */
     0x00c00200, 0x00940000, 0xbfbb0001, 0x242b167c,
     0x7fa89bbb, 0xe3790c7f, 0xe00d10f4, 0x9f014132,
     } },
-    { { /* 366 */
+    { { /* 369 */
     0x35728652, 0xff1210b4, 0x4223cf27, 0x8602c06b,
     0x1fd33106, 0xa1aa3a0c, 0x02040812, 0x08012572,
     } },
-    { { /* 367 */
+    { { /* 370 */
     0x485040cc, 0x601062d0, 0x29001c80, 0x00109a00,
     0x22000004, 0x00800000, 0x68002020, 0x609ecbe6,
     } },
-    { { /* 368 */
+    { { /* 371 */
     0x3f73916e, 0x398260c0, 0x48301034, 0xbd5c0006,
     0xd6fb8cd1, 0x43e820e1, 0x084e0600, 0xc4d00500,
     } },
-    { { /* 369 */
+    { { /* 372 */
     0x89aa8d1f, 0x1602a6e1, 0x21ed0001, 0x1a8b3656,
     0x13a51fb7, 0x30a06502, 0x23c7b278, 0xe9226c93,
     } },
-    { { /* 370 */
+    { { /* 373 */
     0x3a74e47f, 0x98208fe3, 0x2625280e, 0xbf49bf9c,
     0xac543218, 0x1916b949, 0xb5220c60, 0x0659fbc1,
     } },
-    { { /* 371 */
+    { { /* 374 */
     0x8420e343, 0x800008d9, 0x20225500, 0x00a10184,
     0x20104800, 0x40801380, 0x00160d04, 0x80200040,
     } },
-    { { /* 372 */
+    { { /* 375 */
     0x8de7fd40, 0xe0985436, 0x091e7b8b, 0xd249fec8,
     0x8dee0611, 0xba221937, 0x9fdd77f4, 0xf0daf3ec,
     } },
-    { { /* 373 */
+    { { /* 376 */
     0xec424386, 0x26048d3f, 0xc021fa6c, 0x0cc2628e,
     0x0145d785, 0x559977ad, 0x4045e250, 0xa154260b,
     } },
-    { { /* 374 */
+    { { /* 377 */
     0x58199827, 0xa4103443, 0x411405f2, 0x07002280,
     0x426600b4, 0x15a17210, 0x41856025, 0x00000054,
     } },
-    { { /* 375 */
+    { { /* 378 */
     0x01040201, 0xcb70c820, 0x6a629320, 0x0095184c,
     0x9a8b1880, 0x3201aab2, 0x00c4d87a, 0x04c3f3e5,
     } },
-    { { /* 376 */
+    { { /* 379 */
     0xa238d44d, 0x5072a1a1, 0x84fc980a, 0x44d1c152,
     0x20c21094, 0x42104180, 0x3a000000, 0xd29d0240,
     } },
-    { { /* 377 */
+    { { /* 380 */
     0xa8b12f01, 0x2432bd40, 0xd04bd34d, 0xd0ada723,
     0x75a10a92, 0x01e9adac, 0x771f801a, 0xa01b9225,
     } },
-    { { /* 378 */
+    { { /* 381 */
     0x20cadfa1, 0x738c0602, 0x003b577f, 0x00d00bff,
     0x0088806a, 0x0029a1c4, 0x05242a05, 0x16234009,
     } },
-    { { /* 379 */
+    { { /* 382 */
     0x80056822, 0xa2112011, 0x64900004, 0x13824849,
     0x193023d5, 0x08922980, 0x88115402, 0xa0042001,
     } },
-    { { /* 380 */
+    { { /* 383 */
     0x81800400, 0x60228502, 0x0b010090, 0x12020022,
     0x00834011, 0x00001a01, 0x00000000, 0x00000000,
     } },
-    { { /* 381 */
+    { { /* 384 */
     0x00000000, 0x4684009f, 0x020012c8, 0x1a0004fc,
     0x0c4c2ede, 0x80b80402, 0x0afca826, 0x22288c02,
     } },
-    { { /* 382 */
+    { { /* 385 */
     0x8f7ba0e0, 0x2135c7d6, 0xf8b106c7, 0x62550713,
     0x8a19936e, 0xfb0e6efa, 0x48f91630, 0x7debcd2f,
     } },
-    { { /* 383 */
+    { { /* 386 */
     0x4e845892, 0x7a2e4ca0, 0x561eedea, 0x1190c649,
     0xe83a5324, 0x8124cfdb, 0x634218f1, 0x1a8a5853,
     } },
-    { { /* 384 */
+    { { /* 387 */
     0x24d37420, 0x0514aa3b, 0x89586018, 0xc0004800,
     0x91018268, 0x2cd684a4, 0xc4ba8886, 0x02100377,
     } },
-    { { /* 385 */
+    { { /* 388 */
     0x00388244, 0x404aae11, 0x510028c0, 0x15146044,
     0x10007310, 0x02480082, 0x40060205, 0x0000c003,
     } },
-    { { /* 386 */
+    { { /* 389 */
     0x0c020000, 0x02200008, 0x40009000, 0xd161b800,
     0x32744621, 0x3b8af800, 0x8b00050f, 0x2280bbd0,
     } },
-    { { /* 387 */
+    { { /* 390 */
     0x07690600, 0x00438040, 0x50005420, 0x250c41d0,
     0x83108410, 0x02281101, 0x00304008, 0x020040a1,
     } },
-    { { /* 388 */
+    { { /* 391 */
     0x20000040, 0xabe31500, 0xaa443180, 0xc624c2c6,
     0x8004ac13, 0x03d1b000, 0x4285611e, 0x1d9ff303,
     } },
-    { { /* 389 */
+    { { /* 392 */
     0x78e8440a, 0xc3925e26, 0x00852000, 0x4000b001,
     0x88424a90, 0x0c8dca04, 0x4203a705, 0x000422a1,
     } },
-    { { /* 390 */
+    { { /* 393 */
     0x0c018668, 0x10795564, 0xdea00002, 0x40c12000,
     0x5001488b, 0x04000380, 0x50040000, 0x80d0c05d,
     } },
-    { { /* 391 */
+    { { /* 394 */
     0x970aa010, 0x4dafbb20, 0x1e10d921, 0x83140460,
     0xa6d68848, 0x733fd83b, 0x497427bc, 0x92130ddc,
     } },
-    { { /* 392 */
+    { { /* 395 */
     0x8ba1142b, 0xd1392e75, 0x50503009, 0x69008808,
     0x024a49d4, 0x80164010, 0x89d7e564, 0x5316c020,
     } },
-    { { /* 393 */
+    { { /* 396 */
     0x86002b92, 0x15e0a345, 0x0c03008b, 0xe200196e,
     0x80067031, 0xa82916a5, 0x18802000, 0xe1487aac,
     } },
-    { { /* 394 */
+    { { /* 397 */
     0xb5d63207, 0x5f9132e8, 0x20e550a1, 0x10807c00,
     0x9d8a7280, 0x421f00aa, 0x02310e22, 0x04941100,
     } },
-    { { /* 395 */
+    { { /* 398 */
     0x40080022, 0x5c100010, 0xfcc80343, 0x0580a1a5,
     0x04008433, 0x6e080080, 0x81262a4b, 0x2901aad8,
     } },
-    { { /* 396 */
+    { { /* 399 */
     0x4490684d, 0xba880009, 0x00820040, 0x87d10000,
     0xb1e6215b, 0x80083161, 0xc2400800, 0xa600a069,
     } },
-    { { /* 397 */
+    { { /* 400 */
     0x4a328d58, 0x550a5d71, 0x2d579aa0, 0x4aa64005,
     0x30b12021, 0x01123fc6, 0x260a10c2, 0x50824462,
     } },
-    { { /* 398 */
+    { { /* 401 */
     0x80409880, 0x810004c0, 0x00002003, 0x38180000,
     0xf1a60200, 0x720e4434, 0x92e035a2, 0x09008101,
     } },
-    { { /* 399 */
+    { { /* 402 */
     0x00000400, 0x00008885, 0x00000000, 0x00804000,
     0x00000000, 0x00004040, 0x00000000, 0x00000000,
     } },
-    { { /* 400 */
+    { { /* 403 */
     0x00000000, 0x08000000, 0x00000082, 0x00000000,
     0x88000004, 0xe7efbfff, 0xffbfffff, 0xfdffefef,
     } },
-    { { /* 401 */
+    { { /* 404 */
     0xbffefbff, 0x057fffff, 0x85b30034, 0x42164706,
     0xe4105402, 0xb3058092, 0x81305422, 0x180b4263,
     } },
-    { { /* 402 */
+    { { /* 405 */
     0x13f5387b, 0xa9ea07e5, 0x05143c4c, 0x80020600,
     0xbd481ad9, 0xf496ee37, 0x7ec0705f, 0x355fbfb2,
     } },
-    { { /* 403 */
+    { { /* 406 */
     0x455fe644, 0x41469000, 0x063b1d40, 0xfe1362a1,
     0x39028505, 0x0c080548, 0x0000144f, 0x58183488,
     } },
-    { { /* 404 */
+    { { /* 407 */
     0xd8153077, 0x4bfbbd0e, 0x85008a90, 0xe61dc100,
     0xb386ed14, 0x639bff72, 0xd9befd92, 0x0a92887b,
     } },
-    { { /* 405 */
+    { { /* 408 */
     0x1cb2d3fe, 0x177ab980, 0xdc1782c9, 0x3980fffb,
     0x590c4260, 0x37df0f01, 0xb15094a3, 0x23070623,
     } },
-    { { /* 406 */
+    { { /* 409 */
     0x3102f85a, 0x310201f0, 0x1e820040, 0x056a3a0a,
     0x12805b84, 0xa7148002, 0xa04b2612, 0x90011069,
     } },
-    { { /* 407 */
+    { { /* 410 */
     0x848a1000, 0x3f801802, 0x42400708, 0x4e140110,
     0x180080b0, 0x0281c510, 0x10298202, 0x88000210,
     } },
-    { { /* 408 */
+    { { /* 411 */
     0x00420020, 0x11000280, 0x4413e000, 0xfe025804,
     0x30283c07, 0x04739798, 0xcb13ced1, 0x431f6210,
     } },
-    { { /* 409 */
+    { { /* 412 */
     0x55ac278d, 0xc892422e, 0x02885380, 0x78514039,
     0x8088292c, 0x2428b900, 0x080e0c41, 0x42004421,
     } },
-    { { /* 410 */
+    { { /* 413 */
     0x08680408, 0x12040006, 0x02903031, 0xe0855b3e,
     0x10442936, 0x10822814, 0x83344266, 0x531b013c,
     } },
-    { { /* 411 */
+    { { /* 414 */
     0x0e0d0404, 0x00510c22, 0xc0000012, 0x88000040,
     0x0000004a, 0x00000000, 0x5447dff6, 0x00088868,
     } },
-    { { /* 412 */
+    { { /* 415 */
     0x00000081, 0x40000000, 0x00000100, 0x02000000,
     0x00080600, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 413 */
+    { { /* 416 */
     0x00000080, 0x00000040, 0x00000000, 0x00001040,
     0x00000000, 0xf7fdefff, 0xfffeff7f, 0xfffffbff,
     } },
-    { { /* 414 */
+    { { /* 417 */
     0xbffffdff, 0x00ffffff, 0x042012c2, 0x07080c06,
     0x01101624, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 415 */
+    { { /* 418 */
     0xe0000000, 0xfffffffe, 0x7f79ffff, 0x00f928df,
     0x80120c32, 0xd53a0008, 0xecc2d858, 0x2fa89d18,
     } },
-    { { /* 416 */
+    { { /* 419 */
     0xe0109620, 0x2622d60c, 0x02060f97, 0x9055b240,
     0x501180a2, 0x04049800, 0x00004000, 0x00000000,
     } },
-    { { /* 417 */
+    { { /* 420 */
     0x00000000, 0x00000000, 0x00000000, 0xfffffbc0,
     0xdffbeffe, 0x62430b08, 0xfb3b41b6, 0x23896f74,
     } },
-    { { /* 418 */
+    { { /* 421 */
     0xecd7ae7f, 0x5960e047, 0x098fa096, 0xa030612c,
     0x2aaa090d, 0x4f7bd44e, 0x388bc4b2, 0x6110a9c6,
     } },
-    { { /* 419 */
+    { { /* 422 */
     0x42000014, 0x0202800c, 0x6485fe48, 0xe3f7d63e,
     0x0c073aa0, 0x0430e40c, 0x1002f680, 0x00000000,
     } },
-    { { /* 420 */
+    { { /* 423 */
     0x00000000, 0x00000000, 0x00000000, 0x00100000,
     0x00004000, 0x00004000, 0x00000100, 0x00000000,
     } },
-    { { /* 421 */
+    { { /* 424 */
     0x00000000, 0x40000000, 0x00000000, 0x00000400,
     0x00008000, 0x00000000, 0x00400400, 0x00000000,
     } },
-    { { /* 422 */
+    { { /* 425 */
     0x00000000, 0x40000000, 0x00000000, 0x00000800,
     0xfebdffe0, 0xffffffff, 0xfbe77f7f, 0xf7ffffbf,
     } },
-    { { /* 423 */
+    { { /* 426 */
     0xefffffff, 0xdff7ff7e, 0xfbdff6f7, 0x804fbffe,
     0x00000000, 0x00000000, 0x00000000, 0x7fffef00,
     } },
-    { { /* 424 */
+    { { /* 427 */
     0xb6f7ff7f, 0xb87e4406, 0x88313bf5, 0x00f41796,
     0x1391a960, 0x72490080, 0x0024f2f3, 0x42c88701,
     } },
-    { { /* 425 */
+    { { /* 428 */
     0x5048e3d3, 0x43052400, 0x4a4c0000, 0x10580227,
     0x01162820, 0x0014a809, 0x00000000, 0x00683ec0,
     } },
-    { { /* 426 */
+    { { /* 429 */
     0x00000000, 0x00000000, 0x00000000, 0xffe00000,
     0xfddbb7ff, 0x000000f7, 0xc72e4000, 0x00000180,
     } },
-    { { /* 427 */
+    { { /* 430 */
     0x00012000, 0x00004000, 0x00300000, 0xb4f7ffa8,
     0x03ffadf3, 0x00000120, 0x00000000, 0x00000000,
     } },
-    { { /* 428 */
+    { { /* 431 */
     0x00000000, 0x00000000, 0x00000000, 0xfffbf000,
     0xfdcf9df7, 0x15c301bf, 0x810a1827, 0x0a00a842,
     } },
-    { { /* 429 */
+    { { /* 432 */
     0x80088108, 0x18048008, 0x0012a3be, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 430 */
+    { { /* 433 */
     0x00000000, 0x00000000, 0x00000000, 0x90000000,
     0xdc3769e6, 0x3dff6bff, 0xf3f9fcf8, 0x00000004,
     } },
-    { { /* 431 */
+    { { /* 434 */
     0x80000000, 0xe7eebf6f, 0x5da2dffe, 0xc00b3fd8,
     0xa00c0984, 0x69100040, 0xb912e210, 0x5a0086a5,
     } },
-    { { /* 432 */
+    { { /* 435 */
     0x02896800, 0x6a809005, 0x00030010, 0x80000000,
     0x8e001ff9, 0x00000001, 0x00000000, 0x00000000,
     } },
-    { { /* 433 */
+    { { /* 436 */
     0x14000010, 0xa0c09512, 0x0c000200, 0x01000400,
     0x050002a3, 0x98800009, 0x00004000, 0x01004c00,
     } },
-    { { /* 434 */
+    { { /* 437 */
     0x04800008, 0x02840300, 0x00000824, 0x00040000,
     0x00000400, 0x20010904, 0x00001100, 0x22050030,
     } },
-    { { /* 435 */
+    { { /* 438 */
     0x00000108, 0x08104000, 0x01400000, 0x00001040,
     0x00010102, 0x10000040, 0x82012000, 0x10100002,
     } },
-    { { /* 436 */
+    { { /* 439 */
     0x00006002, 0x00000800, 0x00400000, 0x02100401,
     0x14400144, 0x013c4980, 0x880e8288, 0x50102014,
     } },
-    { { /* 437 */
+    { { /* 440 */
     0x80000824, 0x101000c1, 0x02800000, 0x02080101,
     0x04118000, 0x02200112, 0x00031020, 0x02000003,
     } },
-    { { /* 438 */
+    { { /* 441 */
     0x00000002, 0x090c1090, 0xa0004004, 0x60102290,
     0x00080000, 0x00414f45, 0x07071026, 0x40c00001,
     } },
-    { { /* 439 */
+    { { /* 442 */
     0x04580000, 0x0014800a, 0x00002800, 0x00002600,
     0x50988020, 0x02140018, 0x04013800, 0x00008008,
     } },
-    { { /* 440 */
+    { { /* 443 */
     0x41082004, 0x80000928, 0x20080280, 0x020e0a00,
     0x00010040, 0x16110200, 0x41800002, 0x08231400,
     } },
-    { { /* 441 */
+    { { /* 444 */
     0x40020020, 0x0080202f, 0x2015a008, 0x1c000002,
     0xc0040e00, 0x82028012, 0x00400000, 0x2002a004,
     } },
-    { { /* 442 */
+    { { /* 445 */
     0x20200001, 0xa0040000, 0x8890004c, 0xc4000080,
     0x10012500, 0x48100482, 0x60800110, 0x40008040,
     } },
-    { { /* 443 */
+    { { /* 446 */
     0x00040008, 0x04000044, 0x90000091, 0x000c1200,
     0x06040000, 0x08610480, 0x10010800, 0x080d0001,
     } },
-    { { /* 444 */
+    { { /* 447 */
     0x800204b4, 0x00140000, 0x00000000, 0x00200020,
     0x84100200, 0x01811000, 0x02000210, 0x03018800,
     } },
-    { { /* 445 */
+    { { /* 448 */
     0x04042804, 0x20001c92, 0x02100020, 0x4202490a,
     0x02420146, 0x00000803, 0x0008c008, 0x44050010,
     } },
-    { { /* 446 */
+    { { /* 449 */
     0x80222000, 0x00000800, 0x00008452, 0x10502140,
     0xe0410005, 0x00000400, 0x00a00008, 0x80080000,
     } },
-    { { /* 447 */
+    { { /* 450 */
     0x50180020, 0x00000009, 0x40080600, 0x00000000,
     0x56000020, 0x04000000, 0x00020006, 0x00208220,
     } },
-    { { /* 448 */
+    { { /* 451 */
     0x01210000, 0x40009000, 0x08c00140, 0x08110000,
     0x00004820, 0x02400810, 0x08800002, 0x00200000,
     } },
-    { { /* 449 */
+    { { /* 452 */
     0x00040a00, 0x00004000, 0x40000104, 0x84000000,
     0x02040048, 0x20000000, 0x00012000, 0x1b100000,
     } },
-    { { /* 450 */
+    { { /* 453 */
     0x00007000, 0x04000020, 0x10032000, 0x0804000a,
     0x00000008, 0x04020090, 0x88000014, 0x00000000,
     } },
-    { { /* 451 */
+    { { /* 454 */
     0x00000000, 0x08020008, 0x00040400, 0x40a00000,
     0x40000000, 0x00080090, 0x40800000, 0x20000388,
     } },
-    { { /* 452 */
+    { { /* 455 */
     0x02001080, 0x20010004, 0x12010004, 0x20008011,
     0x13200082, 0x02800000, 0x04098001, 0x00000004,
     } },
-    { { /* 453 */
+    { { /* 456 */
     0x00000000, 0x02801000, 0x00001000, 0x00000100,
     0x20010024, 0x00000050, 0x80200028, 0x00000020,
     } },
-    { { /* 454 */
+    { { /* 457 */
     0x01000000, 0x00a24000, 0x00000000, 0x82001010,
     0x00000800, 0x02000000, 0x40020002, 0x59000044,
     } },
-    { { /* 455 */
+    { { /* 458 */
     0x00000080, 0x0d040000, 0x04000000, 0x10020000,
     0x00022000, 0x00508000, 0x20080001, 0x000004a2,
     } },
-    { { /* 456 */
+    { { /* 459 */
     0xc0020400, 0x00310000, 0x80002000, 0x00002800,
     0x00000b60, 0x40200000, 0x00120000, 0x80000009,
     } },
-    { { /* 457 */
+    { { /* 460 */
     0x41000000, 0x00010008, 0x00880910, 0x20080888,
     0x04044020, 0x80482010, 0x00006000, 0x00020000,
     } },
-    { { /* 458 */
+    { { /* 461 */
     0x42405004, 0x00400020, 0x00000010, 0x00000886,
     0x00008000, 0x80021011, 0x00c00000, 0x42000000,
     } },
-    { { /* 459 */
+    { { /* 462 */
     0x4801201f, 0x40c00004, 0x20600480, 0x00000020,
     0x01000110, 0x22400040, 0x00000428, 0x00000000,
     } },
-    { { /* 460 */
+    { { /* 463 */
     0x0f00020f, 0x40401000, 0x00200048, 0x000c0092,
     0x81000421, 0x00040004, 0x00620001, 0x06000202,
     } },
-    { { /* 461 */
+    { { /* 464 */
     0x14001808, 0x00083800, 0x008c1028, 0x04120028,
     0x22008404, 0x40260880, 0x01100700, 0x00400000,
     } },
-    { { /* 462 */
+    { { /* 465 */
     0x20000020, 0x00200000, 0x00840000, 0x04108000,
     0x00000002, 0x00000000, 0x10000002, 0x04000402,
     } },
-    { { /* 463 */
+    { { /* 466 */
     0x10000000, 0x26a20000, 0x05000200, 0x82204000,
     0x80000000, 0x00048404, 0x80004800, 0x80000400,
     } },
-    { { /* 464 */
+    { { /* 467 */
     0x00000064, 0x00000050, 0x18804000, 0x00060000,
     0x00408002, 0x02020030, 0x00000000, 0x40000000,
     } },
-    { { /* 465 */
+    { { /* 468 */
     0x01208414, 0x00000600, 0x02018000, 0x10400000,
     0x04000840, 0x09200000, 0x2e000000, 0x04000304,
     } },
-    { { /* 466 */
+    { { /* 469 */
     0x00c01810, 0x20100010, 0x10400010, 0x02100000,
     0xa0000402, 0x48200000, 0x06080000, 0x01400000,
     } },
-    { { /* 467 */
+    { { /* 470 */
     0x40000008, 0x00001000, 0x10112800, 0xc2a09080,
     0x00008a02, 0x3a0000e9, 0x80611011, 0x40220000,
     } },
-    { { /* 468 */
+    { { /* 471 */
     0x20000020, 0x48381a00, 0x00028421, 0x54ea0800,
     0x01425100, 0x0490200c, 0x20020000, 0x00600800,
     } },
-    { { /* 469 */
+    { { /* 472 */
     0x00e0c201, 0x00004810, 0x10a10001, 0x00000040,
     0x80108084, 0x00042000, 0x00002000, 0x00000004,
     } },
-    { { /* 470 */
+    { { /* 473 */
     0x00010014, 0x03005d00, 0x00008102, 0x00120000,
     0x51009000, 0x04000480, 0x0021c200, 0x0a888056,
     } },
-    { { /* 471 */
+    { { /* 474 */
     0xd2b60004, 0x13800000, 0x204803a8, 0x04501921,
     0x0a003004, 0x02100010, 0x00091100, 0x01070080,
     } },
-    { { /* 472 */
+    { { /* 475 */
     0x42004020, 0x08300000, 0x002a2444, 0x04046081,
     0x40046008, 0x00120000, 0x10000108, 0x00000000,
     } },
-    { { /* 473 */
+    { { /* 476 */
     0x00000084, 0x08001000, 0x0012e001, 0x045880c0,
     0x00010000, 0x00800022, 0x02401000, 0x00000000,
     } },
-    { { /* 474 */
+    { { /* 477 */
     0x4000d000, 0x00000850, 0x01000009, 0x0d840000,
     0x01080000, 0x42008000, 0x20000828, 0x40100040,
     } },
-    { { /* 475 */
+    { { /* 478 */
     0x51000100, 0x32000000, 0x001a0894, 0x04000040,
     0x00002102, 0x03428000, 0x018c0080, 0x00234010,
     } },
-    { { /* 476 */
+    { { /* 479 */
     0x00000040, 0x185c4000, 0x03000000, 0x40020004,
     0xa20200c9, 0x00000220, 0x00101050, 0x00120004,
     } },
-    { { /* 477 */
+    { { /* 480 */
     0x00000040, 0x44002400, 0x00000228, 0x20000020,
     0x000a0008, 0x18010000, 0x3c08830c, 0x40000684,
     } },
-    { { /* 478 */
+    { { /* 481 */
     0x80101800, 0x02000280, 0x0020000c, 0x08009004,
     0x00040000, 0x0004000c, 0x00018000, 0x14001000,
     } },
-    { { /* 479 */
+    { { /* 482 */
     0x08240000, 0x00200000, 0x20420014, 0x58112000,
     0x10004048, 0x010050c0, 0x0408228c, 0x12282040,
     } },
-    { { /* 480 */
+    { { /* 483 */
     0x00000000, 0x00000020, 0x24002000, 0x00000000,
     0x00800a00, 0x00080910, 0x1019a000, 0x60200030,
     } },
-    { { /* 481 */
+    { { /* 484 */
     0x00000080, 0x00000080, 0x08000000, 0x800050a0,
     0x80044000, 0x04001010, 0x80008080, 0x00000000,
     } },
-    { { /* 482 */
+    { { /* 485 */
     0x00000040, 0x00800000, 0x000c4283, 0x01020000,
     0x00888000, 0x00104008, 0x20000000, 0x04000080,
     } },
-    { { /* 483 */
+    { { /* 486 */
     0x20000104, 0x1802c021, 0x08100000, 0x0000004e,
     0x80000001, 0x30c00080, 0x00000040, 0x00401200,
     } },
-    { { /* 484 */
+    { { /* 487 */
     0x04945288, 0x00940400, 0x06400104, 0x10002000,
     0x00080010, 0x00400420, 0x00000102, 0x00408010,
     } },
-    { { /* 485 */
+    { { /* 488 */
     0x05000000, 0x40002240, 0x00100000, 0x0e400024,
     0x00000080, 0x80000440, 0x01018410, 0xb1804004,
     } },
-    { { /* 486 */
+    { { /* 489 */
     0x25000800, 0x20000000, 0x00800000, 0x0000804c,
     0x10020020, 0x42001000, 0x00082000, 0x00002000,
     } },
-    { { /* 487 */
+    { { /* 490 */
     0x11500020, 0x40004053, 0x11280500, 0x80060014,
     0x004c0101, 0x60002008, 0x44000000, 0x01000036,
     } },
-    { { /* 488 */
+    { { /* 491 */
     0x00010028, 0x01180000, 0x84041804, 0x00098000,
     0x00800000, 0x00000000, 0x00400002, 0x10004001,
     } },
-    { { /* 489 */
+    { { /* 492 */
     0x0051a004, 0x00008100, 0x00000024, 0x40041000,
     0x00040000, 0x00042001, 0x00000000, 0x00008000,
     } },
-    { { /* 490 */
+    { { /* 493 */
     0x00000000, 0x00000000, 0x00000000, 0x20030000,
     0x00001840, 0x00020220, 0x04404002, 0x00204000,
     } },
-    { { /* 491 */
+    { { /* 494 */
     0x01008010, 0x00002080, 0x40008064, 0x00004031,
     0x10018090, 0x80304001, 0x000080a0, 0x80200040,
     } },
-    { { /* 492 */
+    { { /* 495 */
     0x00000001, 0x00000010, 0x00102088, 0x00800020,
     0x00120681, 0x100002a0, 0x00000042, 0x00000080,
     } },
-    { { /* 493 */
+    { { /* 496 */
     0x10000000, 0x21000a00, 0x00000200, 0x40000080,
     0x10110000, 0x00108200, 0x04000000, 0x00000400,
     } },
-    { { /* 494 */
+    { { /* 497 */
     0x80001000, 0x80002000, 0x40003008, 0x00000204,
     0x0801000a, 0x40000001, 0x00000000, 0x00000004,
     } },
-    { { /* 495 */
+    { { /* 498 */
     0x00000000, 0x00000000, 0x00020000, 0x00000000,
     0x88000000, 0x00002000, 0x08502000, 0x00840a00,
     } },
-    { { /* 496 */
+    { { /* 499 */
     0x31061808, 0x00000000, 0x00000000, 0x04000000,
     0x00000004, 0x00000240, 0x00100009, 0x00000000,
     } },
-    { { /* 497 */
+    { { /* 500 */
     0x00004002, 0x04002500, 0x00008040, 0x40a20100,
     0x00000001, 0x12412080, 0x04004008, 0x00042014,
     } },
-    { { /* 498 */
+    { { /* 501 */
     0x02000000, 0x00012000, 0x10000402, 0x000040c0,
     0x00080000, 0x5fe800a1, 0x04019402, 0x02000000,
     } },
-    { { /* 499 */
+    { { /* 502 */
     0x00040100, 0x00880000, 0x00401000, 0x00001012,
     0x00000000, 0x08004100, 0x00000010, 0x00000000,
     } },
-    { { /* 500 */
+    { { /* 503 */
     0x00000000, 0x00000000, 0x52020000, 0x10410080,
     0x00005000, 0x08400200, 0x80400010, 0x44400020,
     } },
-    { { /* 501 */
+    { { /* 504 */
     0x00084100, 0x10200d02, 0xa1200012, 0x00804804,
     0x00008212, 0xc6024000, 0x08100000, 0x205c1828,
     } },
-    { { /* 502 */
+    { { /* 505 */
     0x00000088, 0x00031000, 0x8000013f, 0x21184b44,
     0x100100f2, 0xa9002001, 0x08080840, 0x001b0001,
     } },
-    { { /* 503 */
+    { { /* 506 */
     0x28800112, 0x400020f0, 0x0910200c, 0x0a0010a0,
     0x80000020, 0x00000004, 0x1000000a, 0x00400000,
     } },
-    { { /* 504 */
+    { { /* 507 */
     0x00000000, 0x00002000, 0x00000080, 0x81000000,
     0x02c00020, 0x000004c5, 0x00000000, 0x00100100,
     } },
-    { { /* 505 */
+    { { /* 508 */
     0x20000000, 0x01080000, 0x00400022, 0x08000200,
     0x00408002, 0x20400028, 0x00000000, 0x00100000,
     } },
-    { { /* 506 */
+    { { /* 509 */
     0x08000008, 0x00420002, 0xa0a20003, 0x00022000,
     0x88000280, 0x65160000, 0x00040105, 0x00244041,
     } },
-    { { /* 507 */
+    { { /* 510 */
     0x80300000, 0x00184008, 0x00000880, 0x00201140,
     0x00000000, 0x02900000, 0x50004588, 0x00221043,
     } },
-    { { /* 508 */
+    { { /* 511 */
     0x12004000, 0x0b800000, 0x20002405, 0x0000000c,
     0x08000000, 0x11000410, 0x04000030, 0x00200043,
     } },
-    { { /* 509 */
+    { { /* 512 */
     0x80011000, 0x18008042, 0x11000000, 0x00001008,
     0x00008000, 0x24440000, 0x00800000, 0x80100005,
     } },
-    { { /* 510 */
+    { { /* 513 */
     0x00108204, 0x02102400, 0x00010001, 0x80000200,
     0xa080e80a, 0x00010000, 0x20008000, 0x80122200,
     } },
-    { { /* 511 */
+    { { /* 514 */
     0x88211404, 0x04208041, 0x20088020, 0x18040000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 512 */
+    { { /* 515 */
     0x00401004, 0x02100002, 0x40014210, 0x50006000,
     0x00080008, 0x20000820, 0x00100211, 0x10000000,
     } },
-    { { /* 513 */
+    { { /* 516 */
     0x91005400, 0x00000000, 0x00000000, 0x08000000,
     0x41610032, 0xa0029d44, 0x000000d2, 0x41020004,
     } },
-    { { /* 514 */
+    { { /* 517 */
     0x00800104, 0x020000c0, 0x04090030, 0x80000204,
     0x82004000, 0x00000020, 0x00000000, 0x00000000,
     } },
-    { { /* 515 */
+    { { /* 518 */
     0x00000080, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 516 */
+    { { /* 519 */
     0xc373ff8b, 0x1b0f6840, 0xf34ce9ac, 0xc0080200,
     0xca3e795c, 0x06487976, 0xf7f02fdf, 0xa8ff033a,
     } },
-    { { /* 517 */
+    { { /* 520 */
     0x233fef37, 0xfd59b004, 0xfffff3ca, 0xfff9de9f,
     0x7df7abff, 0x8eecc000, 0xffdbeebf, 0x45fad003,
     } },
-    { { /* 518 */
+    { { /* 521 */
     0xdffefae1, 0x10abbfef, 0xfcaaffeb, 0x24fdef3f,
     0x7f7678ad, 0xedfff00c, 0x2cfacff6, 0xeb6bf7f9,
     } },
-    { { /* 519 */
+    { { /* 522 */
     0x95bf1ffd, 0xbfbf6677, 0xfeb43bfb, 0x11e27bae,
     0x41bea681, 0x72c31435, 0x71917d70, 0x276b0003,
     } },
-    { { /* 520 */
+    { { /* 523 */
     0x70cf57cb, 0x0def4732, 0xfc747eda, 0xbdb4fe06,
     0x8bca3f9f, 0x58007e49, 0xebec228f, 0xddbb8a5c,
     } },
-    { { /* 521 */
+    { { /* 524 */
     0xb6e7ef60, 0xf293a40f, 0x549e37bb, 0x9bafd04b,
     0xf7d4c414, 0x0a1430b0, 0x88d02f08, 0x192fff7e,
     } },
-    { { /* 522 */
+    { { /* 525 */
     0xfb07ffda, 0x7beb7ff1, 0x0010c5ef, 0xfdff99ff,
     0x056779d7, 0xfdcbffe7, 0x4040c3ff, 0xbd8e6ff7,
     } },
-    { { /* 523 */
+    { { /* 526 */
     0x0497dffa, 0x5bfff4c0, 0xd0e7ed7b, 0xf8e0047e,
     0xb73eff9f, 0x882e7dfe, 0xbe7ffffd, 0xf6c483fe,
     } },
-    { { /* 524 */
+    { { /* 527 */
     0xb8fdf357, 0xef7dd680, 0x47885767, 0xc3dfff7d,
     0x37a9f0ff, 0x70fc7de0, 0xec9a3f6f, 0x86814cb3,
     } },
-    { { /* 525 */
+    { { /* 528 */
     0xdd5c3f9e, 0x4819f70d, 0x0007fea3, 0x38ffaf56,
     0xefb8980d, 0xb760403d, 0x9035d8ce, 0x3fff72bf,
     } },
-    { { /* 526 */
+    { { /* 529 */
     0x7a117ff7, 0xabfff7bb, 0x6fbeff00, 0xfe72a93c,
     0xf11bcfef, 0xf40adb6b, 0xef7ec3e6, 0xf6109b9c,
     } },
-    { { /* 527 */
+    { { /* 530 */
     0x16f4f048, 0x5182feb5, 0x15bbc7b1, 0xfbdf6e87,
     0x63cde43f, 0x7e7ec1ff, 0x7d5ffdeb, 0xfcfe777b,
     } },
-    { { /* 528 */
+    { { /* 531 */
     0xdbea960b, 0x53e86229, 0xfdef37df, 0xbd8136f5,
     0xfcbddc18, 0xffffd2e4, 0xffe03fd7, 0xabf87f6f,
     } },
-    { { /* 529 */
+    { { /* 532 */
     0x6ed99bae, 0xf115f5fb, 0xbdfb79a9, 0xadaf5a3c,
     0x1facdbba, 0x837971fc, 0xc35f7cf7, 0x0567dfff,
     } },
-    { { /* 530 */
+    { { /* 533 */
     0x8467ff9a, 0xdf8b1534, 0x3373f9f3, 0x5e1af7bd,
     0xa03fbf40, 0x01ebffff, 0xcfdddfc0, 0xabd37500,
     } },
-    { { /* 531 */
+    { { /* 534 */
     0xeed6f8c3, 0xb7ff43fd, 0x42275eaf, 0xf6869bac,
     0xf6bc27d7, 0x35b7f787, 0xe176aacd, 0xe29f49e7,
     } },
-    { { /* 532 */
+    { { /* 535 */
     0xaff2545c, 0x61d82b3f, 0xbbb8fc3b, 0x7b7dffcf,
     0x1ce0bf95, 0x43ff7dfd, 0xfffe5ff6, 0xc4ced3ef,
     } },
-    { { /* 533 */
+    { { /* 536 */
     0xadbc8db6, 0x11eb63dc, 0x23d0df59, 0xf3dbbeb4,
     0xdbc71fe7, 0xfae4ff63, 0x63f7b22b, 0xadbaed3b,
     } },
-    { { /* 534 */
+    { { /* 537 */
     0x7efffe01, 0x02bcfff7, 0xef3932ff, 0x8005fffc,
     0xbcf577fb, 0xfff7010d, 0xbf3afffb, 0xdfff0057,
     } },
-    { { /* 535 */
+    { { /* 538 */
     0xbd7def7b, 0xc8d4db88, 0xed7cfff3, 0x56ff5dee,
     0xac5f7e0d, 0xd57fff96, 0xc1403fee, 0xffe76ff9,
     } },
-    { { /* 536 */
+    { { /* 539 */
     0x8e77779b, 0xe45d6ebf, 0x5f1f6fcf, 0xfedfe07f,
     0x01fed7db, 0xfb7bff00, 0x1fdfffd4, 0xfffff800,
     } },
-    { { /* 537 */
+    { { /* 540 */
     0x007bfb8f, 0x7f5cbf00, 0x07f3ffff, 0x3de7eba0,
     0xfbd7f7bf, 0x6003ffbf, 0xbfedfffd, 0x027fefbb,
     } },
-    { { /* 538 */
+    { { /* 541 */
     0xddfdfe40, 0xe2f9fdff, 0xfb1f680b, 0xaffdfbe3,
     0xf7ed9fa4, 0xf80f7a7d, 0x0fd5eebe, 0xfd9fbb5d,
     } },
-    { { /* 539 */
+    { { /* 542 */
     0x3bf9f2db, 0xebccfe7f, 0x73fa876a, 0x9ffc95fc,
     0xfaf7109f, 0xbbcdddb7, 0xeccdf87e, 0x3c3ff366,
     } },
-    { { /* 540 */
+    { { /* 543 */
     0xb03ffffd, 0x067ee9f7, 0xfe0696ae, 0x5fd7d576,
     0xa3f33fd1, 0x6fb7cf07, 0x7f449fd1, 0xd3dd7b59,
     } },
-    { { /* 541 */
+    { { /* 544 */
     0xa9bdaf3b, 0xff3a7dcf, 0xf6ebfbe0, 0xffffb401,
     0xb7bf7afa, 0x0ffdc000, 0xff1fff7f, 0x95fffefc,
     } },
-    { { /* 542 */
+    { { /* 545 */
     0xb5dc0000, 0x3f3eef63, 0x001bfb7f, 0xfbf6e800,
     0xb8df9eef, 0x003fff9f, 0xf5ff7bd0, 0x3fffdfdb,
     } },
-    { { /* 543 */
+    { { /* 546 */
     0x00bffdf0, 0xbbbd8420, 0xffdedf37, 0x0ff3ff6d,
     0x5efb604c, 0xfafbfffb, 0x0219fe5e, 0xf9de79f4,
     } },
-    { { /* 544 */
+    { { /* 547 */
     0xebfaa7f7, 0xff3401eb, 0xef73ebd3, 0xc040afd7,
     0xdcff72bb, 0x2fd8f17f, 0xfe0bb8ec, 0x1f0bdda3,
     } },
-    { { /* 545 */
+    { { /* 548 */
     0x47cf8f1d, 0xffdeb12b, 0xda737fee, 0xcbc424ff,
     0xcbf2f75d, 0xb4edecfd, 0x4dddbff9, 0xfb8d99dd,
     } },
-    { { /* 546 */
+    { { /* 549 */
     0xaf7bbb7f, 0xc959ddfb, 0xfab5fc4f, 0x6d5fafe3,
     0x3f7dffff, 0xffdb7800, 0x7effb6ff, 0x022ffbaf,
     } },
-    { { /* 547 */
+    { { /* 550 */
     0xefc7ff9b, 0xffffffa5, 0xc7000007, 0xfff1f7ff,
     0x01bf7ffd, 0xfdbcdc00, 0xffffbff5, 0x3effff7f,
     } },
-    { { /* 548 */
+    { { /* 551 */
     0xbe000029, 0xff7ff9ff, 0xfd7e6efb, 0x039ecbff,
     0xfbdde300, 0xf6dfccff, 0x117fffff, 0xfbf6f800,
     } },
-    { { /* 549 */
+    { { /* 552 */
     0xd73ce7ef, 0xdfeffeef, 0xedbfc00b, 0xfdcdfedf,
     0x40fd7bf5, 0xb75fffff, 0xf930ffdf, 0xdc97fbdf,
     } },
-    { { /* 550 */
+    { { /* 553 */
     0xbff2fef3, 0xdfbf8fdf, 0xede6177f, 0x35530f7f,
     0x877e447c, 0x45bbfa12, 0x779eede0, 0xbfd98017,
     } },
-    { { /* 551 */
+    { { /* 554 */
     0xde897e55, 0x0447c16f, 0xf75d7ade, 0x290557ff,
     0xfe9586f7, 0xf32f97b3, 0x9f75cfff, 0xfb1771f7,
     } },
-    { { /* 552 */
+    { { /* 555 */
     0xee1934ee, 0xef6137cc, 0xef4c9fd6, 0xfbddd68f,
     0x6def7b73, 0xa431d7fe, 0x97d75e7f, 0xffd80f5b,
     } },
-    { { /* 553 */
+    { { /* 556 */
     0x7bce9d83, 0xdcff22ec, 0xef87763d, 0xfdeddfe7,
     0xa0fc4fff, 0xdbfc3b77, 0x7fdc3ded, 0xf5706fa9,
     } },
-    { { /* 554 */
+    { { /* 557 */
     0x2c403ffb, 0x847fff7f, 0xdeb7ec57, 0xf22fe69c,
     0xd5b50feb, 0xede7afeb, 0xfff08c2f, 0xe8f0537f,
     } },
-    { { /* 555 */
+    { { /* 558 */
     0xb5ffb99d, 0xe78fff66, 0xbe10d981, 0xe3c19c7c,
     0x27339cd1, 0xff6d0cbc, 0xefb7fcb7, 0xffffa0df,
     } },
-    { { /* 556 */
+    { { /* 559 */
     0xfe7bbf0b, 0x353fa3ff, 0x97cd13cc, 0xfb277637,
     0x7e6ccfd6, 0xed31ec50, 0xfc1c677c, 0x5fbff6fa,
     } },
-    { { /* 557 */
+    { { /* 560 */
     0xae2f0fba, 0x7ffea3ad, 0xde74fcf0, 0xf200ffef,
     0xfea2fbbf, 0xbcff3daf, 0x5fb9f694, 0x3f8ff3ad,
     } },
-    { { /* 558 */
+    { { /* 561 */
     0xa01ff26c, 0x01bfffef, 0x70057728, 0xda03ff35,
     0xc7fad2f9, 0x5c1d3fbf, 0xec33ff3a, 0xfe9cb7af,
     } },
-    { { /* 559 */
+    { { /* 562 */
     0x7a9f5236, 0xe722bffa, 0xfcff9ff7, 0xb61d2fbb,
     0x1dfded06, 0xefdf7dd7, 0xf166eb23, 0x0dc07ed9,
     } },
-    { { /* 560 */
+    { { /* 563 */
     0xdfbf3d3d, 0xba83c945, 0x9dd07dd1, 0xcf737b87,
     0xc3f59ff3, 0xc5fedf0d, 0x83020cb3, 0xaec0e879,
     } },
-    { { /* 561 */
+    { { /* 564 */
     0x6f0fc773, 0x093ffd7d, 0x0157fff1, 0x01ff62fb,
     0x3bf3fdb4, 0x43b2b013, 0xff305ed3, 0xeb9f0fff,
     } },
-    { { /* 562 */
+    { { /* 565 */
     0xf203feef, 0xfb893fef, 0x9e9937a9, 0xa72cdef9,
     0xc1f63733, 0xfe3e812e, 0xf2f75d20, 0x69d7d585,
     } },
-    { { /* 563 */
+    { { /* 566 */
     0xffffffff, 0xff6fdb07, 0xd97fc4ff, 0xbe0fefce,
     0xf05ef17b, 0xffb7f6cf, 0xef845ef7, 0x0edfd7cb,
     } },
-    { { /* 564 */
+    { { /* 567 */
     0xfcffff08, 0xffffee3f, 0xd7ff13ff, 0x7ffdaf0f,
     0x1ffabdc7, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 565 */
+    { { /* 568 */
     0x00000000, 0xe7400000, 0xf933bd38, 0xfeed7feb,
     0x7c767fe8, 0xffefb3f7, 0xd8b7feaf, 0xfbbfff6f,
     } },
-    { { /* 566 */
+    { { /* 569 */
     0xdbf7f8fb, 0xe2f91752, 0x754785c8, 0xe3ef9090,
     0x3f6d9ef4, 0x0536ee2e, 0x7ff3f7bc, 0x7f3fa07b,
     } },
-    { { /* 567 */
+    { { /* 570 */
     0xeb600567, 0x6601babe, 0x583ffcd8, 0x87dfcaf7,
     0xffa0bfcd, 0xfebf5bcd, 0xefa7b6fd, 0xdf9c77ef,
     } },
-    { { /* 568 */
+    { { /* 571 */
     0xf8773fb7, 0xb7fc9d27, 0xdfefcab5, 0xf1b6fb5a,
     0xef1fec39, 0x7ffbfbbf, 0xdafe000d, 0x4e7fbdfb,
     } },
-    { { /* 569 */
+    { { /* 572 */
     0x5ac033ff, 0x9ffebff5, 0x005fffbf, 0xfdf80000,
     0x6ffdffca, 0xa001cffd, 0xfbf2dfff, 0xff7fdfbf,
     } },
-    { { /* 570 */
+    { { /* 573 */
     0x080ffeda, 0xbfffba08, 0xeed77afd, 0x67f9fbeb,
     0xff93e044, 0x9f57df97, 0x08dffef7, 0xfedfdf80,
     } },
-    { { /* 571 */
+    { { /* 574 */
     0xf7feffc5, 0x6803fffb, 0x6bfa67fb, 0x5fe27fff,
     0xff73ffff, 0xe7fb87df, 0xf7a7ebfd, 0xefc7bf7e,
     } },
-    { { /* 572 */
+    { { /* 575 */
     0xdf821ef3, 0xdf7e76ff, 0xda7d79c9, 0x1e9befbe,
     0x77fb7ce0, 0xfffb87be, 0xffdb1bff, 0x4fe03f5c,
     } },
-    { { /* 573 */
+    { { /* 576 */
     0x5f0e7fff, 0xddbf77ff, 0xfffff04f, 0x0ff8ffff,
     0xfddfa3be, 0xfffdfc1c, 0xfb9e1f7d, 0xdedcbdff,
     } },
-    { { /* 574 */
+    { { /* 577 */
     0xbafb3f6f, 0xfbefdf7f, 0x2eec7d1b, 0xf2f7af8e,
     0xcfee7b0f, 0x77c61d96, 0xfff57e07, 0x7fdfd982,
     } },
-    { { /* 575 */
+    { { /* 578 */
     0xc7ff5ee6, 0x79effeee, 0xffcf9a56, 0xde5efe5f,
     0xf9e8896e, 0xe6c4f45e, 0xbe7c0001, 0xdddf3b7f,
     } },
-    { { /* 576 */
+    { { /* 579 */
     0xe9efd59d, 0xde5334ac, 0x4bf7f573, 0x9eff7b4f,
     0x476eb8fe, 0xff450dfb, 0xfbfeabfd, 0xddffe9d7,
     } },
-    { { /* 577 */
+    { { /* 580 */
     0x7fffedf7, 0x7eebddfd, 0xb7ffcfe7, 0xef91bde9,
     0xd77c5d75, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 578 */
+    { { /* 581 */
     0x00000000, 0xfa800000, 0xb4f1ffee, 0x2fefbf76,
     0x77bfb677, 0xfffd9fbf, 0xf6ae95bf, 0x7f3b75ff,
     } },
-    { { /* 579 */
+    { { /* 582 */
     0x0af9a7f5, 0x00000000, 0x00000000, 0x2bddfbd0,
     0x9a7ff633, 0xd6fcfdab, 0xbfebf9e6, 0xf41fdfdf,
     } },
-    { { /* 580 */
+    { { /* 583 */
     0xffffa6fd, 0xf37b4aff, 0xfef97fb7, 0x1d5cb6ff,
     0xe5ff7ff6, 0x24041f7b, 0xf99ebe05, 0xdff2dbe3,
     } },
-    { { /* 581 */
+    { { /* 584 */
     0xfdff6fef, 0xcbfcd679, 0xefffebfd, 0x0000001f,
     0x98000000, 0x8017e148, 0x00fe6a74, 0xfdf16d7f,
     } },
-    { { /* 582 */
+    { { /* 585 */
     0xfef3b87f, 0xf176e01f, 0x7b3fee96, 0xfffdeb8d,
     0xcbb3adff, 0xe17f84ef, 0xbff04daa, 0xfe3fbf3f,
     } },
-    { { /* 583 */
+    { { /* 586 */
     0xffd7ebff, 0xcf7fffdf, 0x85edfffb, 0x07bcd73f,
     0xfe0faeff, 0x76bffdaf, 0x37bbfaef, 0xa3ba7fdc,
     } },
-    { { /* 584 */
+    { { /* 587 */
     0x56f7b6ff, 0xe7df60f8, 0x4cdfff61, 0xff45b0fb,
     0x3ffa7ded, 0x18fc1fff, 0xe3afffff, 0xdf83c7d3,
     } },
-    { { /* 585 */
+    { { /* 588 */
     0xef7dfb57, 0x1378efff, 0x5ff7fec0, 0x5ee334bb,
     0xeff6f70d, 0x00bfd7fe, 0xf7f7f59d, 0xffe051de,
     } },
-    { { /* 586 */
+    { { /* 589 */
     0x037ffec9, 0xbfef5f01, 0x60a79ff1, 0xf1ffef1d,
     0x0000000f, 0x00000000, 0x00000000, 0x00000000,
     } },
-    { { /* 587 */
+    { { /* 590 */
     0x00000000, 0x00000000, 0x00000000, 0x3c800000,
     0xd91ffb4d, 0xfee37b3a, 0xdc7f3fe9, 0x0000003f,
     } },
-    { { /* 588 */
+    { { /* 591 */
     0x50000000, 0xbe07f51f, 0xf91bfc1d, 0x71ffbc1e,
     0x5bbe6ff9, 0x9b1b5796, 0xfffc7fff, 0xafe7872e,
     } },
-    { { /* 589 */
+    { { /* 592 */
     0xf34febf5, 0xe725dffd, 0x5d440bdc, 0xfddd5747,
     0x7790ed3f, 0x8ac87d7f, 0xf3f9fafa, 0xef4b202a,
     } },
-    { { /* 590 */
+    { { /* 593 */
     0x79cff5ff, 0x0ba5abd3, 0xfb8ff77a, 0x001f8ebd,
     0x00000000, 0xfd4ef300, 0x88001a57, 0x7654aeac,
     } },
-    { { /* 591 */
+    { { /* 594 */
     0xcdff17ad, 0xf42fffb2, 0xdbff5baa, 0x00000002,
     0x73c00000, 0x2e3ff9ea, 0xbbfffa8e, 0xffd376bc,
     } },
-    { { /* 592 */
+    { { /* 595 */
     0x7e72eefe, 0xe7f77ebd, 0xcefdf77f, 0x00000ff5,
     0x00000000, 0xdb9ba900, 0x917fa4c7, 0x7ecef8ca,
     } },
-    { { /* 593 */
+    { { /* 596 */
     0xc7e77d7a, 0xdcaecbbd, 0x8f76fd7e, 0x7cf391d3,
     0x4c2f01e5, 0xa360ed77, 0x5ef807db, 0x21811df7,
     } },
-    { { /* 594 */
+    { { /* 597 */
     0x309c6be0, 0xfade3b3a, 0xc3f57f53, 0x07ba61cd,
     0x00000000, 0x00000000, 0x00000000, 0xbefe26e0,
     } },
-    { { /* 595 */
+    { { /* 598 */
     0xebb503f9, 0xe9cbe36d, 0xbfde9c2f, 0xabbf9f83,
     0xffd51ff7, 0xdffeb7df, 0xffeffdae, 0xeffdfb7e,
     } },
-    { { /* 596 */
+    { { /* 599 */
     0x6ebfaaff, 0x00000000, 0x00000000, 0xb6200000,
     0xbe9e7fcd, 0x58f162b3, 0xfd7bf10d, 0xbefde9f1,
     } },
-    { { /* 597 */
+    { { /* 600 */
     0x5f6dc6c3, 0x69ffff3d, 0xfbf4ffcf, 0x4ff7dcfb,
     0x11372000, 0x00000015, 0x00000000, 0x00000000,
     } },
-    { { /* 598 */
+    { { /* 601 */
     0x00003000, 0x00000000, 0x00000000, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000,
     } },
@@ -3420,8 +3433,24 @@
     0x000e,
 };
 
+static const FcCharLeaf *leaves_ti_er[2] = {
+    L(322), L(323),
+};
+
+static const FcChar16 numbers_ti_er[2] = {
+    0x0012, 0x0013,
+};
+
+static const FcCharLeaf *leaves_tig[2] = {
+    L(324), L(323),
+};
+
+static const FcChar16 numbers_tig[2] = {
+    0x0012, 0x0013,
+};
+
 static const FcCharLeaf *leaves_tk[1] = {
-    L(322),
+    L(325),
 };
 
 static const FcChar16 numbers_tk[1] = {
@@ -3429,7 +3458,7 @@
 };
 
 static const FcCharLeaf *leaves_tl[1] = {
-    L(323),
+    L(326),
 };
 
 static const FcChar16 numbers_tl[1] = {
@@ -3437,7 +3466,7 @@
 };
 
 static const FcCharLeaf *leaves_tn[1] = {
-    L(324),
+    L(327),
 };
 
 static const FcChar16 numbers_tn[1] = {
@@ -3445,7 +3474,7 @@
 };
 
 static const FcCharLeaf *leaves_tr[2] = {
-    L(325), L(326),
+    L(328), L(329),
 };
 
 static const FcChar16 numbers_tr[2] = {
@@ -3453,7 +3482,7 @@
 };
 
 static const FcCharLeaf *leaves_tt[1] = {
-    L(327),
+    L(330),
 };
 
 static const FcChar16 numbers_tt[1] = {
@@ -3461,7 +3490,7 @@
 };
 
 static const FcCharLeaf *leaves_tw[5] = {
-    L(328), L(329), L(330), L(331), L(332),
+    L(331), L(332), L(333), L(334), L(335),
 };
 
 static const FcChar16 numbers_tw[5] = {
@@ -3469,7 +3498,7 @@
 };
 
 static const FcCharLeaf *leaves_uk[1] = {
-    L(333),
+    L(336),
 };
 
 static const FcChar16 numbers_uk[1] = {
@@ -3477,7 +3506,7 @@
 };
 
 static const FcCharLeaf *leaves_uz[1] = {
-    L(334),
+    L(337),
 };
 
 static const FcChar16 numbers_uz[1] = {
@@ -3485,7 +3514,7 @@
 };
 
 static const FcCharLeaf *leaves_ven[2] = {
-    L( 15), L(335),
+    L( 15), L(338),
 };
 
 static const FcChar16 numbers_ven[2] = {
@@ -3493,7 +3522,7 @@
 };
 
 static const FcCharLeaf *leaves_vi[4] = {
-    L(336), L(337), L(338), L(339),
+    L(339), L(340), L(341), L(342),
 };
 
 static const FcChar16 numbers_vi[4] = {
@@ -3501,7 +3530,7 @@
 };
 
 static const FcCharLeaf *leaves_vo[1] = {
-    L(340),
+    L(343),
 };
 
 static const FcChar16 numbers_vo[1] = {
@@ -3509,7 +3538,7 @@
 };
 
 static const FcCharLeaf *leaves_vot[2] = {
-    L(341), L( 52),
+    L(344), L( 52),
 };
 
 static const FcChar16 numbers_vot[2] = {
@@ -3517,7 +3546,7 @@
 };
 
 static const FcCharLeaf *leaves_wa[1] = {
-    L(342),
+    L(345),
 };
 
 static const FcChar16 numbers_wa[1] = {
@@ -3525,7 +3554,7 @@
 };
 
 static const FcCharLeaf *leaves_wen[2] = {
-    L(294), L(343),
+    L(294), L(346),
 };
 
 static const FcChar16 numbers_wen[2] = {
@@ -3533,7 +3562,7 @@
 };
 
 static const FcCharLeaf *leaves_wo[2] = {
-    L(344), L(345),
+    L(347), L(348),
 };
 
 static const FcChar16 numbers_wo[2] = {
@@ -3541,7 +3570,7 @@
 };
 
 static const FcCharLeaf *leaves_yap[1] = {
-    L(346),
+    L(349),
 };
 
 static const FcChar16 numbers_yap[1] = {
@@ -3549,7 +3578,7 @@
 };
 
 static const FcCharLeaf *leaves_yo[4] = {
-    L(347), L(348), L(349), L(350),
+    L(350), L(351), L(352), L(353),
 };
 
 static const FcChar16 numbers_yo[4] = {
@@ -3557,17 +3586,17 @@
 };
 
 static const FcCharLeaf *leaves_zh_cn[82] = {
-    L(351), L(352), L(353), L(354), L(355), L(356), L(357), L(358),
-    L(359), L(360), L(361), L(362), L(363), L(364), L(365), L(366),
-    L(367), L(368), L(369), L(370), L(371), L(372), L(373), L(374),
-    L(375), L(376), L(377), L(378), L(379), L(380), L(381), L(382),
-    L(383), L(384), L(385), L(386), L(387), L(388), L(389), L(390),
-    L(391), L(392), L(393), L(394), L(395), L(396), L(397), L(398),
-    L(399), L(400), L(401), L(402), L(403), L(404), L(405), L(406),
-    L(407), L(408), L(409), L(410), L(411), L(412), L(413), L(414),
-    L(415), L(416), L(417), L(418), L(419), L(420), L(421), L(422),
-    L(423), L(424), L(425), L(426), L(427), L(428), L(429), L(430),
-    L(431), L(432),
+    L(354), L(355), L(356), L(357), L(358), L(359), L(360), L(361),
+    L(362), L(363), L(364), L(365), L(366), L(367), L(368), L(369),
+    L(370), L(371), L(372), L(373), L(374), L(375), L(376), L(377),
+    L(378), L(379), L(380), L(381), L(382), L(383), L(384), L(385),
+    L(386), L(387), L(388), L(389), L(390), L(391), L(392), L(393),
+    L(394), L(395), L(396), L(397), L(398), L(399), L(400), L(401),
+    L(402), L(403), L(404), L(405), L(406), L(407), L(408), L(409),
+    L(410), L(411), L(412), L(413), L(414), L(415), L(416), L(417),
+    L(418), L(419), L(420), L(421), L(422), L(423), L(424), L(425),
+    L(426), L(427), L(428), L(429), L(430), L(431), L(432), L(433),
+    L(434), L(435),
 };
 
 static const FcChar16 numbers_zh_cn[82] = {
@@ -3585,17 +3614,17 @@
 };
 
 static const FcCharLeaf *leaves_zh_hk[83] = {
-    L(433), L(434), L(435), L(436), L(437), L(438), L(439), L(440),
-    L(441), L(442), L(443), L(444), L(445), L(446), L(447), L(448),
-    L(449), L(450), L(451), L(452), L(453), L(454), L(455), L(456),
-    L(457), L(458), L(459), L(460), L(461), L(462), L(463), L(464),
-    L(465), L(466), L(467), L(468), L(469), L(470), L(471), L(472),
-    L(473), L(474), L(475), L(476), L(477), L(478), L(479), L(480),
-    L(481), L(482), L(483), L(484), L(485), L(486), L(487), L(488),
-    L(489), L(490), L(491), L(492), L(493), L(494), L(495), L(496),
-    L(497), L(498), L(499), L(500), L(501), L(502), L(503), L(504),
-    L(505), L(506), L(507), L(508), L(509), L(510), L(511), L(512),
-    L(513), L(514), L(515),
+    L(436), L(437), L(438), L(439), L(440), L(441), L(442), L(443),
+    L(444), L(445), L(446), L(447), L(448), L(449), L(450), L(451),
+    L(452), L(453), L(454), L(455), L(456), L(457), L(458), L(459),
+    L(460), L(461), L(462), L(463), L(464), L(465), L(466), L(467),
+    L(468), L(469), L(470), L(471), L(472), L(473), L(474), L(475),
+    L(476), L(477), L(478), L(479), L(480), L(481), L(482), L(483),
+    L(484), L(485), L(486), L(487), L(488), L(489), L(490), L(491),
+    L(492), L(493), L(494), L(495), L(496), L(497), L(498), L(499),
+    L(500), L(501), L(502), L(503), L(504), L(505), L(506), L(507),
+    L(508), L(509), L(510), L(511), L(512), L(513), L(514), L(515),
+    L(516), L(517), L(518),
 };
 
 static const FcChar16 numbers_zh_hk[83] = {
@@ -3613,17 +3642,17 @@
 };
 
 static const FcCharLeaf *leaves_zh_mo[83] = {
-    L(516), L(517), L(518), L(519), L(520), L(521), L(522), L(523),
-    L(524), L(525), L(526), L(527), L(528), L(529), L(530), L(531),
-    L(532), L(533), L(534), L(535), L(536), L(537), L(538), L(539),
-    L(540), L(541), L(542), L(543), L(544), L(545), L(546), L(547),
-    L(548), L(549), L(550), L(551), L(552), L(553), L(554), L(555),
-    L(556), L(557), L(558), L(559), L(560), L(561), L(562), L(563),
-    L(564), L(565), L(566), L(567), L(568), L(569), L(570), L(571),
-    L(572), L(573), L(574), L(575), L(576), L(577), L(578), L(579),
-    L(580), L(581), L(582), L(583), L(584), L(585), L(586), L(587),
-    L(588), L(589), L(590), L(591), L(592), L(593), L(594), L(595),
-    L(596), L(597), L(598),
+    L(519), L(520), L(521), L(522), L(523), L(524), L(525), L(526),
+    L(527), L(528), L(529), L(530), L(531), L(532), L(533), L(534),
+    L(535), L(536), L(537), L(538), L(539), L(540), L(541), L(542),
+    L(543), L(544), L(545), L(546), L(547), L(548), L(549), L(550),
+    L(551), L(552), L(553), L(554), L(555), L(556), L(557), L(558),
+    L(559), L(560), L(561), L(562), L(563), L(564), L(565), L(566),
+    L(567), L(568), L(569), L(570), L(571), L(572), L(573), L(574),
+    L(575), L(576), L(577), L(578), L(579), L(580), L(581), L(582),
+    L(583), L(584), L(585), L(586), L(587), L(588), L(589), L(590),
+    L(591), L(592), L(593), L(594), L(595), L(596), L(597), L(598),
+    L(599), L(600), L(601),
 };
 
 static const FcChar16 numbers_zh_mo[83] = {
@@ -3931,8 +3960,12 @@
       { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_tg, (FcChar16 *) numbers_tg } },
     { (FcChar8 *) "th",
       { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_th, (FcChar16 *) numbers_th } },
-    { (FcChar8 *) "ti",
-      { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_am, (FcChar16 *) numbers_am } },
+    { (FcChar8 *) "ti-er",
+      { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_ti_er, (FcChar16 *) numbers_ti_er } },
+    { (FcChar8 *) "ti-et",
+      { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_ti_er, (FcChar16 *) numbers_ti_er } },
+    { (FcChar8 *) "tig",
+      { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_tig, (FcChar16 *) numbers_tig } },
     { (FcChar8 *) "tk",
       { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_tk, (FcChar16 *) numbers_tk } },
     { (FcChar8 *) "tl",
@@ -3995,11 +4028,41 @@
       { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_fj, (FcChar16 *) numbers_fj } },
 };
 
-#define NUM_LANG_CHAR_SET	175
+#define NUM_LANG_CHAR_SET	177
 #define NUM_LANG_SET_MAP	6
 
 static const FcChar32 fcLangCountrySets[][NUM_LANG_SET_MAP] = {
-    { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00003e00, }, /* zh */
+    { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00030000, 0x00000000, }, /* ti */
+    { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000f800, }, /* zh */
+};
+
+#define NUM_COUNTRY_SET 2
+static const FcLangCharSetRange  fcLangCharSetRanges[] = {
+    { 0, 8 }, /* a */
+    { 9, 21 }, /* b */
+    { 22, 31 }, /* c */
+    { 32, 34 }, /* d */
+    { 35, 40 }, /* e */
+    { 41, 48 }, /* f */
+    { 49, 55 }, /* g */
+    { 56, 63 }, /* h */
+    { 64, 72 }, /* i */
+    { 73, 73 }, /* j */
+    { 74, 88 }, /* k */
+    { 89, 94 }, /* l */
+    { 95, 104 }, /* m */
+    { 105, 110 }, /* n */
+    { 111, 114 }, /* o */
+    { 115, 116 }, /* p */
+    { 117, 116 }, /* q */
+    { 117, 119 }, /* r */
+    { 120, 139 }, /* s */
+    { 140, 155 }, /* t */
+    { 156, 159 }, /* u */
+    { 160, 163 }, /* v */
+    { 164, 166 }, /* w */
+    { 167, 167 }, /* x */
+    { 168, 170 }, /* y */
+    { 171, 176 }, /* z */
 };
 
-#define NUM_COUNTRY_SET 1
diff -urN xc/extras/fontconfig/fc-lang/fclang.tmpl.h xc-fontconfig/extras/fontconfig/fc-lang/fclang.tmpl.h
--- xc/extras/fontconfig/fc-lang/fclang.tmpl.h	2003-09-25 13:01:18.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fc-lang/fclang.tmpl.h	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/fc-lang/fclang.tmpl.h,v 1.1.1.1 2003/06/04 02:56:47 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/fc-lang/fclang.tmpl.h,v 1.1 2002/07/06 23:21:36 keithp Exp $
  *
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2002 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
diff -urN xc/extras/fontconfig/fc-list/fc-list.c xc-fontconfig/extras/fontconfig/fc-list/fc-list.c
--- xc/extras/fontconfig/fc-list/fc-list.c	2003-09-25 13:01:21.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fc-list/fc-list.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/fc-list/fc-list.c,v 1.5 2002/06/30 23:45:40 keithp Exp $
+ *
+ * Copyright � 2002 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/fc-list/fc-list.c,v 1.3 2003/09/13 21:33:00 dawes Exp $ */
 
 #include <fontconfig/fontconfig.h>
 #include <stdio.h>
@@ -32,9 +33,6 @@
 #define HAVE_GETOPT_LONG 1
 #endif
 #define HAVE_GETOPT 1
-#if defined(ISC) || defined(Lynx)
-#define HAVE_OPTARG_IN_UNISTD 0
-#endif
 #endif
 
 #ifndef HAVE_GETOPT
@@ -43,9 +41,6 @@
 #ifndef HAVE_GETOPT_LONG
 #define HAVE_GETOPT_LONG 0
 #endif
-#ifndef HAVE_OPTARG_IN_UNISTD
-#define HAVE_OPTARG_IN_UNISTD HAVE_GETOPT
-#endif
 
 #if HAVE_GETOPT_LONG
 #undef  _GNU_SOURCE
@@ -58,7 +53,7 @@
     {NULL,0,0,0},
 };
 #else
-#if HAVE_GETOPT && !HAVE_OPTARG_IN_UNISTD
+#if HAVE_GETOPT
 extern char *optarg;
 extern int optind, opterr, optopt;
 #endif
@@ -66,25 +61,20 @@
 
 static void usage (char *program)
 {
-#if HAVE_GETOPT_LONG || HAVE_GETOPT
-    fprintf (stderr,
-	     "usage: %s [-V?] [--version] [--help] [pattern] {element ...} \n",
+    fprintf (stderr, "usage: %s [-vV?] [--verbose] [--version] [--help] [pattern] {element ...} \n",
 	     program);
     fprintf (stderr, "List fonts matching [pattern]\n");
     fprintf (stderr, "\n");
-    fprintf (stderr,
-	     "  -V, --version        display font config version and exit\n");
+    fprintf (stderr, "  -v, --verbose        display status information while busy\n");
+    fprintf (stderr, "  -V, --version        display font config version and exit\n");
     fprintf (stderr, "  -?, --help           display this help and exit\n");
-#else
-    fprintf (stderr, "usage: %s [pattern] {element ...} \n", program);
-    fprintf (stderr, "List fonts matching [pattern]\n");
-#endif
     exit (1);
 }
 
 int
 main (int argc, char **argv)
 {
+    int		verbose = 0;
     int		i;
     FcObjectSet *os = 0;
     FcFontSet	*fs;
@@ -104,7 +94,7 @@
 		     FC_MAJOR, FC_MINOR, FC_REVISION);
 	    exit (0);
 	case 'v':
-	    /* Ignore */
+	    verbose = 1;
 	    break;
 	default:
 	    usage (argv[0]);
diff -urN xc/extras/fontconfig/fontconfig/fcprivate.h xc-fontconfig/extras/fontconfig/fontconfig/fcprivate.h
--- xc/extras/fontconfig/fontconfig/fcprivate.h	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fontconfig/fcprivate.h	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/fontconfig/fcprivate.h,v 1.5 2002/08/19 19:32:04 keithp Exp $
+ *
+ * Copyright � 2001 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/fontconfig/fcprivate.h,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #ifndef _FCPRIVATE_H_
 #define _FCPRIVATE_H_
diff -urN xc/extras/fontconfig/fontconfig/fontconfig.h xc-fontconfig/extras/fontconfig/fontconfig/fontconfig.h
--- xc/extras/fontconfig/fontconfig/fontconfig.h	2003-09-25 13:01:21.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/fontconfig/fontconfig.h	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/fontconfig/fontconfig.h,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.30 2002/09/26 00:17:27 keithp Exp $
  *
- * Copyright � 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2001 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
@@ -33,11 +33,14 @@
 typedef int		FcBool;
 
 /*
- * Current Fontconfig version number
+ * Current Fontconfig version number.  This same number
+ * must appear in the fontconfig configure.in file. Yes,
+ * it'a a pain to synchronize version numbers like this.
  */
-#define FC_MAJOR	1
-#define FC_MINOR	0
-#define FC_REVISION	2
+
+#define FC_MAJOR	2
+#define FC_MINOR	2
+#define FC_REVISION	1
 
 #define FC_VERSION	((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))
 
@@ -70,6 +73,7 @@
 #define FC_VERTICAL_LAYOUT  "verticallayout"	/* Bool (false) */
 #define FC_AUTOHINT	    "autohint"		/* Bool (false) */
 #define FC_GLOBAL_ADVANCE   "globaladvance"	/* Bool (true) */
+#define FC_WIDTH	    "width"		/* Int */
 #define FC_FILE		    "file"		/* String */
 #define FC_INDEX	    "index"		/* Int */
 #define FC_FT_FACE	    "ftface"		/* FT_Face */
@@ -93,19 +97,38 @@
 #define FC_CHAR_HEIGHT	    "charheight"/* Int */
 #define FC_MATRIX	    "matrix"    /* FcMatrix */
 
-#define FC_WEIGHT_LIGHT	    0
-#define FC_WEIGHT_MEDIUM    100
-#define FC_WEIGHT_DEMIBOLD  180
-#define FC_WEIGHT_BOLD	    200
-#define FC_WEIGHT_BLACK	    210
-
-#define FC_SLANT_ROMAN	    0
-#define FC_SLANT_ITALIC	    100
-#define FC_SLANT_OBLIQUE    110
-
-#define FC_PROPORTIONAL	    0
-#define FC_MONO		    100
-#define FC_CHARCELL	    110
+#define FC_WEIGHT_THIN		    0
+#define FC_WEIGHT_EXTRALIGHT	    40
+#define FC_WEIGHT_ULTRALIGHT	    FC_WEIGHT_EXTRALIGHT
+#define FC_WEIGHT_LIGHT		    50
+#define FC_WEIGHT_REGULAR	    80
+#define FC_WEIGHT_NORMAL	    FC_WEIGHT_REGULAR
+#define FC_WEIGHT_MEDIUM	    100
+#define FC_WEIGHT_DEMIBOLD	    180
+#define FC_WEIGHT_SEMIBOLD	    FC_WEIGHT_DEMIBOLD
+#define FC_WEIGHT_BOLD		    200
+#define FC_WEIGHT_EXTRABOLD	    205
+#define FC_WEIGHT_ULTRABOLD	    FC_WEIGHT_EXTRABOLD
+#define FC_WEIGHT_BLACK		    210
+#define FC_WEIGHT_HEAVY		    FC_WEIGHT_BLACK
+
+#define FC_SLANT_ROMAN		    0
+#define FC_SLANT_ITALIC		    100
+#define FC_SLANT_OBLIQUE	    110
+
+#define FC_WIDTH_ULTRACONDENSED	    50
+#define FC_WIDTH_EXTRACONDENSED	    63
+#define FC_WIDTH_CONDENSED	    75
+#define FC_WIDTH_SEMICONDENSED	    87
+#define FC_WIDTH_NORMAL		    100
+#define FC_WIDTH_SEMIEXPANDED	    113
+#define FC_WIDTH_EXPANDED	    125
+#define FC_WIDTH_EXTRAEXPANDED	    150
+#define FC_WIDTH_ULTRAEXPANDED	    200
+
+#define FC_PROPORTIONAL		    0
+#define FC_MONO			    100
+#define FC_CHARCELL		    110
 
 /* sub-pixel order */
 #define FC_RGBA_UNKNOWN	    0
@@ -242,6 +265,12 @@
 
 /* fccfg.c */
 FcChar8 *
+FcConfigHome (void);
+
+FcBool
+FcConfigEnableHome (FcBool enable);
+
+FcChar8 *
 FcConfigFilename (const FcChar8 *url);
     
 FcConfig *
@@ -451,6 +480,9 @@
 FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
 
 FcBool
+FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
+
+FcBool
 FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
 
 FcChar32
@@ -694,7 +726,9 @@
 FcChar8 *
 FcStrCopyFilename (const FcChar8 *s);
     
-#define FcToLower(c)	(('A' <= (c) && (c) <= 'Z') ? (c) - 'A' + 'a' : (c))
+#define FcIsUpper(c)	(('A' <= (c) && (c) <= 'Z'))
+#define FcIsLower(c)	(('a' <= (c) && (c) <= 'z'))
+#define FcToLower(c)	(FcIsUpper(c) ? (c) - 'A' + 'a' : (c))
 
 int
 FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
diff -urN xc/extras/fontconfig/local.def xc-fontconfig/extras/fontconfig/local.def
--- xc/extras/fontconfig/local.def	2003-09-25 13:01:14.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/local.def	2003-11-21 01:35:12.000000000 +0100
@@ -41,7 +41,7 @@
 #endif
 
 #if SharedLibFontconfig
-#define SharedFontconfigRev 1.0
+#define SharedFontconfigRev 2.2
 SharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),SOXLIBREV,SharedFontconfigRev)
 #else
 ProjectUnsharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),BuildLibDir)
diff -urN xc/extras/fontconfig/src/Imakefile xc-fontconfig/extras/fontconfig/src/Imakefile
--- xc/extras/fontconfig/src/Imakefile	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/Imakefile	2003-11-21 01:35:12.000000000 +0100
@@ -16,7 +16,7 @@
 #define DoProfileLib ProfileLibFontconfig
 #define HasSharedData YES
 #define LibName fontconfig
-SOFONTCONFIGREV=1.0
+SOFONTCONFIGREV=2.2
 #define SoRev SOFONTCONFIGREV
 
 #include <Threads.tmpl>
diff -urN xc/extras/fontconfig/src/fcatomic.c xc-fontconfig/extras/fontconfig/src/fcatomic.c
--- xc/extras/fontconfig/src/fcatomic.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcatomic.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcatomic.c,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcatomic.c,v 1.2 2002/03/04 21:15:28 tsi Exp $
  *
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2002 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
@@ -30,7 +30,7 @@
  * Uses only regular filesystem calls so it should
  * work even in the absense of functioning file locking
  *
- *  Four files:
+ * On Unix, four files are used:
  *	file	    - the data file accessed by other apps.
  *	new	    - a new version of the data file while it's being written
  *	lck	    - the lock file
@@ -41,6 +41,10 @@
  *	Attempt to link it to 'lck'
  *	Unlink 'tmp'
  *	If the link succeeded, the lock is held
+ *
+ * On Windows, where there are no links, no tmp file is used, and lck
+ * is a directory that's mkdir'ed. If the mkdir succeeds, the lock is
+ * held.
  */
 
 #include "fcint.h"
@@ -51,6 +55,10 @@
 #include <stdlib.h>
 #include <time.h>
 
+#ifdef _WIN32
+#define mkdir(path,mode) _mkdir(path)
+#endif
+
 #define NEW_NAME	".NEW"
 #define LCK_NAME	".LCK"
 #define TMP_NAME	".TMP-XXXXXX"
@@ -96,6 +104,7 @@
     int		ret;
     struct stat	lck_stat;
 
+#ifdef HAVE_LINK
     strcpy ((char *) atomic->tmp, (char *) atomic->file);
     strcat ((char *) atomic->tmp, TMP_NAME);
     fd = mkstemp ((char *) atomic->tmp);
@@ -122,6 +131,9 @@
     }
     ret = link ((char *) atomic->tmp, (char *) atomic->lck);
     (void) unlink ((char *) atomic->tmp);
+#else
+    ret = mkdir ((char *) atomic->lck, 0600);
+#endif
     if (ret < 0)
     {
 	/*
@@ -135,8 +147,13 @@
 	    time_t  now = time (0);
 	    if ((long int) (now - lck_stat.st_mtime) > 10 * 60)
 	    {
+#ifdef HAVE_LINK
 		if (unlink ((char *) atomic->lck) == 0)
 		    return FcAtomicLock (atomic);
+#else
+		if (rmdir ((char *) atomic->lck) == 0)
+		    return FcAtomicLock (atomic);
+#endif
 	    }
 	}
 	return FcFalse;
@@ -174,7 +191,11 @@
 void
 FcAtomicUnlock (FcAtomic *atomic)
 {
+#ifdef HAVE_LINK
     unlink ((char *) atomic->lck);
+#else
+    rmdir ((char *) atomic->lck);
+#endif
 }
 
 void
diff -urN xc/extras/fontconfig/src/fcblanks.c xc-fontconfig/extras/fontconfig/src/fcblanks.c
--- xc/extras/fontconfig/src/fcblanks.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcblanks.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcblanks.c,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $
+ * $RCSId:$
  *
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2002 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
diff -urN xc/extras/fontconfig/src/fccfg.c xc-fontconfig/extras/fontconfig/src/fccfg.c
--- xc/extras/fontconfig/src/fccfg.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fccfg.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 2002/08/31 22:17:32 keithp Exp $
+ *
+ * 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
@@ -19,10 +21,15 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fccfg.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include "fcint.h"
 
+#if defined (_WIN32) && defined (PIC)
+#define STRICT
+#include <windows.h>
+#undef STRICT
+#endif
+
 FcConfig    *_fcConfig;
 
 FcConfig *
@@ -49,8 +56,9 @@
 	goto bail3;
     
     config->cache = 0;
-    if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
-	goto bail4;
+    if (FcConfigHome())
+	if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
+	    goto bail4;
 
     config->blanks = 0;
 
@@ -132,8 +140,10 @@
     while (s)
     {
 	n = s->next;
-	FcTestDestroy (s->test);
-	FcEditDestroy (s->edit);
+	if (s->test)
+	    FcTestDestroy (s->test);
+	if (s->edit)
+	    FcEditDestroy (s->edit);
 	s = n;
     }
 }
@@ -482,11 +492,13 @@
 }
 
 FcBool
-FcConfigCompareValue (FcValue	m,
-		      FcOp	op,
-		      FcValue	v)
-{
-    FcBool    ret = FcFalse;
+FcConfigCompareValue (const FcValue	m_o,
+		      FcOp		op,
+		      const FcValue	v_o)
+{
+    FcValue	m = m_o;
+    FcValue	v = v_o;
+    FcBool	ret = FcFalse;
     
     m = FcConfigPromote (m, v);
     v = FcConfigPromote (v, m);
@@ -586,10 +598,10 @@
 	case FcTypeLangSet:
 	    switch (op) {
 	    case FcOpContains:
-		ret = FcLangSetCompare (v.u.l, m.u.l) != FcLangDifferentLang;
+		ret = FcLangSetContains (v.u.l, m.u.l);
 		break;
 	    case FcOpNotContains:
-		ret = FcLangSetCompare (v.u.l, m.u.l) == FcLangDifferentLang;
+		ret = FcLangSetContains (v.u.l, m.u.l);
 		break;
 	    case FcOpEqual:
 		ret = FcLangSetEqual (v.u.l, m.u.l);
@@ -636,6 +648,13 @@
 }
 
 
+#define _FcDoubleFloor(d)	((int) (d))
+#define _FcDoubleCeil(d)	((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
+#define FcDoubleFloor(d)	((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
+#define FcDoubleCeil(d)		((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
+#define FcDoubleRound(d)	FcDoubleFloor ((d) + 0.5)
+#define FcDoubleTrunc(d)	((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
+
 static FcValue
 FcConfigEvaluate (FcPattern *p, FcExpr *e)
 {
@@ -824,6 +843,70 @@
 	}
 	FcValueDestroy (vl);
 	break;
+    case FcOpFloor:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleFloor (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpCeil:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleCeil (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpRound:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleRound (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpTrunc:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleTrunc (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
     default:
 	v.type = FcTypeVoid;
 	break;
@@ -914,8 +997,16 @@
 	     FcBool	    append,
 	     FcValueList    *new)
 {
-    FcValueList    **prev, *last;
+    FcValueList	    **prev, *last, *v;
+    FcValueBinding  sameBinding;
     
+    if (position)
+	sameBinding = position->binding;
+    else
+	sameBinding = FcValueBindingWeak;
+    for (v = new; v; v = v->next)
+	if (v->binding == FcValueBindingSame)
+	    v->binding = sameBinding;
     if (append)
     {
 	if (position)
@@ -1141,6 +1232,14 @@
 		    !FcStrCmpIgnoreCase ((FcChar8 *) t->field, 
 					 (FcChar8 *) e->field))
 		{
+		    /* 
+		     * KLUDGE - the pattern may have been reallocated or
+		     * things may have been inserted or deleted above
+		     * this element by other edits.  Go back and find
+		     * the element again
+		     */
+		    if (e != s->edit && st[i].elt)
+			st[i].elt = FcPatternFindElt (p, t->field);
 		    if (!st[i].elt)
 			t = 0;
 		    break;
@@ -1254,9 +1353,57 @@
 }
 
 #ifndef FONTCONFIG_PATH
-#define FONTCONFIG_PATH	"/etc/fonts"
+#define FONTCONFIG_PATH        "/etc/fonts"
 #endif
 
+#if defined (_WIN32) && defined (PIC)
+
+static FcChar8 fontconfig_path[1000] = "";
+
+BOOL WINAPI
+DllMain (HINSTANCE hinstDLL,
+	 DWORD     fdwReason,
+	 LPVOID    lpvReserved)
+{
+  FcChar8 *p;
+
+  switch (fdwReason) {
+  case DLL_PROCESS_ATTACH:
+      if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
+			      sizeof (fontconfig_path)))
+	  break;
+
+      /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
+       * assume it's a Unix-style installation tree, and use
+       * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
+       * folder where the DLL is as FONTCONFIG_PATH.
+       */
+      p = strrchr (fontconfig_path, '\\');
+      if (p)
+      {
+	  *p = '\0';
+	  p = strrchr (fontconfig_path, '\\');
+	  if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
+		    FcStrCmpIgnoreCase (p + 1, "lib") == 0))
+	      *p = '\0';
+	  strcat (fontconfig_path, "\\etc\\fonts");
+      }
+      else
+          fontconfig_path[0] = '\0';
+      
+      break;
+  }
+
+  return TRUE;
+}
+
+#undef FONTCONFIG_PATH
+#define FONTCONFIG_PATH fontconfig_path
+
+#else /* !(_WIN32 && PIC) */
+
+#endif /* !(_WIN32 && PIC) */
+
 #ifndef FONTCONFIG_FILE
 #define FONTCONFIG_FILE	"fonts.conf"
 #endif
@@ -1273,9 +1420,16 @@
 	return 0;
 
     strcpy ((char *) path, (const char *) dir);
-    /* make sure there's a single separating / */
+    /* make sure there's a single separator */
+#ifdef _WIN32
+    if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
+		      path[strlen((char *) path)-1] != '\\')) &&
+	 (file[0] != '/' && file[0] != '\\'))
+	strcat ((char *) path, "\\");
+#else
     if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
 	strcat ((char *) path, "/");
+#endif
     strcat ((char *) path, (char *) file);
 
     FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
@@ -1302,11 +1456,7 @@
 	e = env;
 	npath++;
 	while (*e)
-#ifndef __UNIXOS2__
-	    if (*e++ == ':')
-#else
-	    if (*e++ == ';')
-#endif
+	    if (*e++ == FC_SEARCH_PATH_SEPARATOR)
 		npath++;
     }
     path = calloc (npath, sizeof (FcChar8 *));
@@ -1319,11 +1469,7 @@
 	e = env;
 	while (*e) 
 	{
-#ifndef __UNIXOS2__
-	    colon = (FcChar8 *) strchr ((char *) e, ':');
-#else
-	    colon = (FcChar8 *) strchr ((char *) e, ';');
-#endif
+	    colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
 	    if (!colon)
 		colon = e + strlen ((char *) e);
 	    path[i] = malloc (colon - e + 1);
@@ -1339,11 +1485,7 @@
 	}
     }
     
-#ifndef __UNIXOS2__
     dir = (FcChar8 *) FONTCONFIG_PATH;
-#else
-    dir = (FcChar8 *) __XOS2RedirRoot(FONTCONFIG_PATH);
-#endif
     path[i] = malloc (strlen ((char *) dir) + 1);
     if (!path[i])
 	goto bail1;
@@ -1368,6 +1510,33 @@
     free (path);
 }
 
+static FcBool	_FcConfigHomeEnabled = FcTrue;
+
+FcChar8 *
+FcConfigHome (void)
+{
+    if (_FcConfigHomeEnabled)
+    {
+        char *home = getenv ("HOME");
+
+#ifdef _WIN32
+	if (home == NULL)
+	    home = getenv ("USERPROFILE");
+#endif
+
+	return home;
+    }
+    return 0;
+}
+
+FcBool
+FcConfigEnableHome (FcBool enable)
+{
+    FcBool  prev = _FcConfigHomeEnabled;
+    _FcConfigHomeEnabled = enable;
+    return prev;
+}
+
 FcChar8 *
 FcConfigFilename (const FcChar8 *url)
 {
@@ -1380,14 +1549,26 @@
 	    url = (FcChar8 *) FONTCONFIG_FILE;
     }
     file = 0;
+
+#ifdef _WIN32
+    if (isalpha (*url) &&
+	url[1] == ':' &&
+	(url[2] == '/' || url[2] == '\\'))
+	goto absolute_path;
+#endif
+
     switch (*url) {
     case '~':
-	dir = (FcChar8 *) getenv ("HOME");
+	dir = FcConfigHome ();
 	if (dir)
 	    file = FcConfigFileExists (dir, url + 1);
 	else
 	    file = 0;
 	break;
+#ifdef _WIN32
+    case '\\':
+    absolute_path:
+#endif
     case '/':
 	file = FcConfigFileExists (0, url);
 	break;
diff -urN xc/extras/fontconfig/src/fccharset.c xc-fontconfig/extras/fontconfig/src/fccharset.c
--- xc/extras/fontconfig/src/fccharset.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fccharset.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fccharset.c,v 1.18 2002/08/22 07:36:44 keithp Exp $
+ *
+ * Copyright � 2001 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fccharset.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include <stdlib.h>
 #include "fcint.h"
@@ -171,7 +172,7 @@
  * if desired
  */
 
-static FcCharLeaf *
+FcCharLeaf *
 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4)
 {
     int			pos;
@@ -636,7 +637,7 @@
 		bi++;
 	}
     }
-    return FcTrue;
+    return ai >= a->num;
 }
 
 /*
@@ -1159,769 +1160,3 @@
     
     return FcTrue;
 }
-
-/*
- * Figure out whether the available freetype has FT_Get_Next_Char
- */
-
-#if FREETYPE_MAJOR > 2
-# define HAS_NEXT_CHAR
-#else
-# if FREETYPE_MAJOR == 2
-#  if FREETYPE_MINOR > 0
-#   define HAS_NEXT_CHAR
-#  else
-#   if FREETYPE_MINOR == 0
-#    if FREETYPE_PATCH >= 9
-#     define HAS_NEXT_CHAR
-#    endif
-#   endif
-#  endif
-# endif
-#endif
-
-/*
- * For our purposes, this approximation is sufficient
- */
-#ifndef HAS_NEXT_CHAR
-#define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
-#define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
-					  (*(gi) = 0), 0 : \
-					  (*(gi) = 1), (ucs4) + 1)
-#warning "No FT_Get_Next_Char"
-#endif
-
-typedef struct _FcCharEnt {
-    FcChar16	    bmp;
-    unsigned char   encode;
-} FcCharEnt;
-
-struct _FcCharMap {
-    const FcCharEnt *ent;
-    int		    nent;
-};
-
-typedef struct _FcFontDecode {
-    FT_Encoding	    encoding;
-    const FcCharMap *map;
-    FcChar32	    max;
-} FcFontDecode;
-
-static const FcCharEnt AppleRomanEnt[] = {
-    { 0x0020, 0x20 }, /* SPACE */
-    { 0x0021, 0x21 }, /* EXCLAMATION MARK */
-    { 0x0022, 0x22 }, /* QUOTATION MARK */
-    { 0x0023, 0x23 }, /* NUMBER SIGN */
-    { 0x0024, 0x24 }, /* DOLLAR SIGN */
-    { 0x0025, 0x25 }, /* PERCENT SIGN */
-    { 0x0026, 0x26 }, /* AMPERSAND */
-    { 0x0027, 0x27 }, /* APOSTROPHE */
-    { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
-    { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
-    { 0x002A, 0x2A }, /* ASTERISK */
-    { 0x002B, 0x2B }, /* PLUS SIGN */
-    { 0x002C, 0x2C }, /* COMMA */
-    { 0x002D, 0x2D }, /* HYPHEN-MINUS */
-    { 0x002E, 0x2E }, /* FULL STOP */
-    { 0x002F, 0x2F }, /* SOLIDUS */
-    { 0x0030, 0x30 }, /* DIGIT ZERO */
-    { 0x0031, 0x31 }, /* DIGIT ONE */
-    { 0x0032, 0x32 }, /* DIGIT TWO */
-    { 0x0033, 0x33 }, /* DIGIT THREE */
-    { 0x0034, 0x34 }, /* DIGIT FOUR */
-    { 0x0035, 0x35 }, /* DIGIT FIVE */
-    { 0x0036, 0x36 }, /* DIGIT SIX */
-    { 0x0037, 0x37 }, /* DIGIT SEVEN */
-    { 0x0038, 0x38 }, /* DIGIT EIGHT */
-    { 0x0039, 0x39 }, /* DIGIT NINE */
-    { 0x003A, 0x3A }, /* COLON */
-    { 0x003B, 0x3B }, /* SEMICOLON */
-    { 0x003C, 0x3C }, /* LESS-THAN SIGN */
-    { 0x003D, 0x3D }, /* EQUALS SIGN */
-    { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
-    { 0x003F, 0x3F }, /* QUESTION MARK */
-    { 0x0040, 0x40 }, /* COMMERCIAL AT */
-    { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
-    { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
-    { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
-    { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
-    { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
-    { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
-    { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
-    { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
-    { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
-    { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
-    { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
-    { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
-    { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
-    { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
-    { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
-    { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
-    { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
-    { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
-    { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
-    { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
-    { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
-    { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
-    { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
-    { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
-    { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
-    { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
-    { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
-    { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
-    { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
-    { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
-    { 0x005F, 0x5F }, /* LOW LINE */
-    { 0x0060, 0x60 }, /* GRAVE ACCENT */
-    { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
-    { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
-    { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
-    { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
-    { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
-    { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
-    { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
-    { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
-    { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
-    { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
-    { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
-    { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
-    { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
-    { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
-    { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
-    { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
-    { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
-    { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
-    { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
-    { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
-    { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
-    { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
-    { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
-    { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
-    { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
-    { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
-    { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
-    { 0x007C, 0x7C }, /* VERTICAL LINE */
-    { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
-    { 0x007E, 0x7E }, /* TILDE */
-    { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
-    { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
-    { 0x00A2, 0xA2 }, /* CENT SIGN */
-    { 0x00A3, 0xA3 }, /* POUND SIGN */
-    { 0x00A5, 0xB4 }, /* YEN SIGN */
-    { 0x00A7, 0xA4 }, /* SECTION SIGN */
-    { 0x00A8, 0xAC }, /* DIAERESIS */
-    { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
-    { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
-    { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
-    { 0x00AC, 0xC2 }, /* NOT SIGN */
-    { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
-    { 0x00AF, 0xF8 }, /* MACRON */
-    { 0x00B0, 0xA1 }, /* DEGREE SIGN */
-    { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
-    { 0x00B4, 0xAB }, /* ACUTE ACCENT */
-    { 0x00B5, 0xB5 }, /* MICRO SIGN */
-    { 0x00B6, 0xA6 }, /* PILCROW SIGN */
-    { 0x00B7, 0xE1 }, /* MIDDLE DOT */
-    { 0x00B8, 0xFC }, /* CEDILLA */
-    { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
-    { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
-    { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
-    { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
-    { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
-    { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
-    { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
-    { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
-    { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
-    { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
-    { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
-    { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
-    { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
-    { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
-    { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
-    { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
-    { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
-    { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
-    { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
-    { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
-    { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
-    { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
-    { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
-    { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
-    { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
-    { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
-    { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
-    { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
-    { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
-    { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
-    { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
-    { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
-    { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
-    { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
-    { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
-    { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
-    { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
-    { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
-    { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
-    { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
-    { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
-    { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
-    { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
-    { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
-    { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
-    { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
-    { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
-    { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
-    { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
-    { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
-    { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
-    { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
-    { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
-    { 0x00F7, 0xD6 }, /* DIVISION SIGN */
-    { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
-    { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
-    { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
-    { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
-    { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
-    { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
-    { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
-    { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
-    { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
-    { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
-    { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
-    { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
-    { 0x02C7, 0xFF }, /* CARON */
-    { 0x02D8, 0xF9 }, /* BREVE */
-    { 0x02D9, 0xFA }, /* DOT ABOVE */
-    { 0x02DA, 0xFB }, /* RING ABOVE */
-    { 0x02DB, 0xFE }, /* OGONEK */
-    { 0x02DC, 0xF7 }, /* SMALL TILDE */
-    { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
-    { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
-    { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
-    { 0x2013, 0xD0 }, /* EN DASH */
-    { 0x2014, 0xD1 }, /* EM DASH */
-    { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
-    { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
-    { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
-    { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
-    { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
-    { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
-    { 0x2020, 0xA0 }, /* DAGGER */
-    { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
-    { 0x2022, 0xA5 }, /* BULLET */
-    { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
-    { 0x2030, 0xE4 }, /* PER MILLE SIGN */
-    { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
-    { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
-    { 0x2044, 0xDA }, /* FRACTION SLASH */
-    { 0x20AC, 0xDB }, /* EURO SIGN */
-    { 0x2122, 0xAA }, /* TRADE MARK SIGN */
-    { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
-    { 0x2206, 0xC6 }, /* INCREMENT */
-    { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
-    { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
-    { 0x221A, 0xC3 }, /* SQUARE ROOT */
-    { 0x221E, 0xB0 }, /* INFINITY */
-    { 0x222B, 0xBA }, /* INTEGRAL */
-    { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
-    { 0x2260, 0xAD }, /* NOT EQUAL TO */
-    { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
-    { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
-    { 0x25CA, 0xD7 }, /* LOZENGE */
-    { 0xF8FF, 0xF0 }, /* Apple logo */
-    { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
-    { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
-};
-
-static const FcCharMap AppleRoman = {
-    AppleRomanEnt,
-    sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
-};
-
-static const FcCharEnt AdobeSymbolEnt[] = {
-    { 0x0020, 0x20 }, /* SPACE	# space */
-    { 0x0021, 0x21 }, /* EXCLAMATION MARK	# exclam */
-    { 0x0023, 0x23 }, /* NUMBER SIGN	# numbersign */
-    { 0x0025, 0x25 }, /* PERCENT SIGN	# percent */
-    { 0x0026, 0x26 }, /* AMPERSAND	# ampersand */
-    { 0x0028, 0x28 }, /* LEFT PARENTHESIS	# parenleft */
-    { 0x0029, 0x29 }, /* RIGHT PARENTHESIS	# parenright */
-    { 0x002B, 0x2B }, /* PLUS SIGN	# plus */
-    { 0x002C, 0x2C }, /* COMMA	# comma */
-    { 0x002E, 0x2E }, /* FULL STOP	# period */
-    { 0x002F, 0x2F }, /* SOLIDUS	# slash */
-    { 0x0030, 0x30 }, /* DIGIT ZERO	# zero */
-    { 0x0031, 0x31 }, /* DIGIT ONE	# one */
-    { 0x0032, 0x32 }, /* DIGIT TWO	# two */
-    { 0x0033, 0x33 }, /* DIGIT THREE	# three */
-    { 0x0034, 0x34 }, /* DIGIT FOUR	# four */
-    { 0x0035, 0x35 }, /* DIGIT FIVE	# five */
-    { 0x0036, 0x36 }, /* DIGIT SIX	# six */
-    { 0x0037, 0x37 }, /* DIGIT SEVEN	# seven */
-    { 0x0038, 0x38 }, /* DIGIT EIGHT	# eight */
-    { 0x0039, 0x39 }, /* DIGIT NINE	# nine */
-    { 0x003A, 0x3A }, /* COLON	# colon */
-    { 0x003B, 0x3B }, /* SEMICOLON	# semicolon */
-    { 0x003C, 0x3C }, /* LESS-THAN SIGN	# less */
-    { 0x003D, 0x3D }, /* EQUALS SIGN	# equal */
-    { 0x003E, 0x3E }, /* GREATER-THAN SIGN	# greater */
-    { 0x003F, 0x3F }, /* QUESTION MARK	# question */
-    { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET	# bracketleft */
-    { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET	# bracketright */
-    { 0x005F, 0x5F }, /* LOW LINE	# underscore */
-    { 0x007B, 0x7B }, /* LEFT CURLY BRACKET	# braceleft */
-    { 0x007C, 0x7C }, /* VERTICAL LINE	# bar */
-    { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET	# braceright */
-    { 0x00A0, 0x20 }, /* NO-BREAK SPACE	# space */
-    { 0x00AC, 0xD8 }, /* NOT SIGN	# logicalnot */
-    { 0x00B0, 0xB0 }, /* DEGREE SIGN	# degree */
-    { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN	# plusminus */
-    { 0x00B5, 0x6D }, /* MICRO SIGN	# mu */
-    { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN	# multiply */
-    { 0x00F7, 0xB8 }, /* DIVISION SIGN	# divide */
-    { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK	# florin */
-    { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA	# Alpha */
-    { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA	# Beta */
-    { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA	# Gamma */
-    { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA	# Delta */
-    { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON	# Epsilon */
-    { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA	# Zeta */
-    { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA	# Eta */
-    { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA	# Theta */
-    { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA	# Iota */
-    { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA	# Kappa */
-    { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA	# Lambda */
-    { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU	# Mu */
-    { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU	# Nu */
-    { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI	# Xi */
-    { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON	# Omicron */
-    { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI	# Pi */
-    { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO	# Rho */
-    { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA	# Sigma */
-    { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU	# Tau */
-    { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON	# Upsilon */
-    { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI	# Phi */
-    { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI	# Chi */
-    { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI	# Psi */
-    { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA	# Omega */
-    { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA	# alpha */
-    { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA	# beta */
-    { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA	# gamma */
-    { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA	# delta */
-    { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON	# epsilon */
-    { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA	# zeta */
-    { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA	# eta */
-    { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA	# theta */
-    { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA	# iota */
-    { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA	# kappa */
-    { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA	# lambda */
-    { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU	# mu */
-    { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU	# nu */
-    { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI	# xi */
-    { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON	# omicron */
-    { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI	# pi */
-    { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO	# rho */
-    { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA	# sigma1 */
-    { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA	# sigma */
-    { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU	# tau */
-    { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON	# upsilon */
-    { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI	# phi */
-    { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI	# chi */
-    { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI	# psi */
-    { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA	# omega */
-    { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL	# theta1 */
-    { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL	# Upsilon1 */
-    { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL	# phi1 */
-    { 0x03D6, 0x76 }, /* GREEK PI SYMBOL	# omega1 */
-    { 0x2022, 0xB7 }, /* BULLET	# bullet */
-    { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS	# ellipsis */
-    { 0x2032, 0xA2 }, /* PRIME	# minute */
-    { 0x2033, 0xB2 }, /* DOUBLE PRIME	# second */
-    { 0x2044, 0xA4 }, /* FRACTION SLASH	# fraction */
-    { 0x20AC, 0xA0 }, /* EURO SIGN	# Euro */
-    { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I	# Ifraktur */
-    { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P	# weierstrass */
-    { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R	# Rfraktur */
-    { 0x2126, 0x57 }, /* OHM SIGN	# Omega */
-    { 0x2135, 0xC0 }, /* ALEF SYMBOL	# aleph */
-    { 0x2190, 0xAC }, /* LEFTWARDS ARROW	# arrowleft */
-    { 0x2191, 0xAD }, /* UPWARDS ARROW	# arrowup */
-    { 0x2192, 0xAE }, /* RIGHTWARDS ARROW	# arrowright */
-    { 0x2193, 0xAF }, /* DOWNWARDS ARROW	# arrowdown */
-    { 0x2194, 0xAB }, /* LEFT RIGHT ARROW	# arrowboth */
-    { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS	# carriagereturn */
-    { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW	# arrowdblleft */
-    { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW	# arrowdblup */
-    { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW	# arrowdblright */
-    { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW	# arrowdbldown */
-    { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW	# arrowdblboth */
-    { 0x2200, 0x22 }, /* FOR ALL	# universal */
-    { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL	# partialdiff */
-    { 0x2203, 0x24 }, /* THERE EXISTS	# existential */
-    { 0x2205, 0xC6 }, /* EMPTY SET	# emptyset */
-    { 0x2206, 0x44 }, /* INCREMENT	# Delta */
-    { 0x2207, 0xD1 }, /* NABLA	# gradient */
-    { 0x2208, 0xCE }, /* ELEMENT OF	# element */
-    { 0x2209, 0xCF }, /* NOT AN ELEMENT OF	# notelement */
-    { 0x220B, 0x27 }, /* CONTAINS AS MEMBER	# suchthat */
-    { 0x220F, 0xD5 }, /* N-ARY PRODUCT	# product */
-    { 0x2211, 0xE5 }, /* N-ARY SUMMATION	# summation */
-    { 0x2212, 0x2D }, /* MINUS SIGN	# minus */
-    { 0x2215, 0xA4 }, /* DIVISION SLASH	# fraction */
-    { 0x2217, 0x2A }, /* ASTERISK OPERATOR	# asteriskmath */
-    { 0x221A, 0xD6 }, /* SQUARE ROOT	# radical */
-    { 0x221D, 0xB5 }, /* PROPORTIONAL TO	# proportional */
-    { 0x221E, 0xA5 }, /* INFINITY	# infinity */
-    { 0x2220, 0xD0 }, /* ANGLE	# angle */
-    { 0x2227, 0xD9 }, /* LOGICAL AND	# logicaland */
-    { 0x2228, 0xDA }, /* LOGICAL OR	# logicalor */
-    { 0x2229, 0xC7 }, /* INTERSECTION	# intersection */
-    { 0x222A, 0xC8 }, /* UNION	# union */
-    { 0x222B, 0xF2 }, /* INTEGRAL	# integral */
-    { 0x2234, 0x5C }, /* THEREFORE	# therefore */
-    { 0x223C, 0x7E }, /* TILDE OPERATOR	# similar */
-    { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO	# congruent */
-    { 0x2248, 0xBB }, /* ALMOST EQUAL TO	# approxequal */
-    { 0x2260, 0xB9 }, /* NOT EQUAL TO	# notequal */
-    { 0x2261, 0xBA }, /* IDENTICAL TO	# equivalence */
-    { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO	# lessequal */
-    { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO	# greaterequal */
-    { 0x2282, 0xCC }, /* SUBSET OF	# propersubset */
-    { 0x2283, 0xC9 }, /* SUPERSET OF	# propersuperset */
-    { 0x2284, 0xCB }, /* NOT A SUBSET OF	# notsubset */
-    { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO	# reflexsubset */
-    { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO	# reflexsuperset */
-    { 0x2295, 0xC5 }, /* CIRCLED PLUS	# circleplus */
-    { 0x2297, 0xC4 }, /* CIRCLED TIMES	# circlemultiply */
-    { 0x22A5, 0x5E }, /* UP TACK	# perpendicular */
-    { 0x22C5, 0xD7 }, /* DOT OPERATOR	# dotmath */
-    { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL	# integraltp */
-    { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL	# integralbt */
-    { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET	# angleleft */
-    { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET	# angleright */
-    { 0x25CA, 0xE0 }, /* LOZENGE	# lozenge */
-    { 0x2660, 0xAA }, /* BLACK SPADE SUIT	# spade */
-    { 0x2663, 0xA7 }, /* BLACK CLUB SUIT	# club */
-    { 0x2665, 0xA9 }, /* BLACK HEART SUIT	# heart */
-    { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT	# diamond */
-    { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF	# copyrightserif (CUS) */
-    { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF	# registerserif (CUS) */
-    { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF	# trademarkserif (CUS) */
-    { 0xF8E5, 0x60 }, /* RADICAL EXTENDER	# radicalex (CUS) */
-    { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER	# arrowvertex (CUS) */
-    { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER	# arrowhorizex (CUS) */
-    { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF	# registersans (CUS) */
-    { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF	# copyrightsans (CUS) */
-    { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF	# trademarksans (CUS) */
-    { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP	# parenlefttp (CUS) */
-    { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER	# parenleftex (CUS) */
-    { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM	# parenleftbt (CUS) */
-    { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP	# bracketlefttp (CUS) */
-    { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER	# bracketleftex (CUS) */
-    { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM	# bracketleftbt (CUS) */
-    { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP	# bracelefttp (CUS) */
-    { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID	# braceleftmid (CUS) */
-    { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM	# braceleftbt (CUS) */
-    { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER	# braceex (CUS) */
-    { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER	# integralex (CUS) */
-    { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP	# parenrighttp (CUS) */
-    { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER	# parenrightex (CUS) */
-    { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM	# parenrightbt (CUS) */
-    { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP	# bracketrighttp (CUS) */
-    { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER	# bracketrightex (CUS) */
-    { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM	# bracketrightbt (CUS) */
-    { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP	# bracerighttp (CUS) */
-    { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID	# bracerightmid (CUS) */
-    { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM	# bracerightbt (CUS) */
-};
-
-static const FcCharMap AdobeSymbol = {
-    AdobeSymbolEnt,
-    sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
-};
-    
-static const FcFontDecode fcFontDecoders[] = {
-    { ft_encoding_unicode,	0,		(1 << 21) - 1 },
-    { ft_encoding_symbol,	&AdobeSymbol,	(1 << 16) - 1 },
-    { ft_encoding_apple_roman,	&AppleRoman,	(1 << 16) - 1 },
-};
-
-#define NUM_DECODE  (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
-
-FcChar32
-FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
-{
-    int		low, high, mid;
-    FcChar16	bmp;
-
-    low = 0;
-    high = map->nent - 1;
-    if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
-	return ~0;
-    while (low <= high)
-    {
-	mid = (high + low) >> 1;
-	bmp = map->ent[mid].bmp;
-	if (ucs4 == bmp)
-	    return (FT_ULong) map->ent[mid].encode;
-	if (ucs4 < bmp)
-	    high = mid - 1;
-	else
-	    low = mid + 1;
-    }
-    return ~0;
-}
-
-FcChar32
-FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
-{
-    int	    i;
-
-    for (i = 0; i < map->nent; i++)
-	if (map->ent[i].encode == private)
-	    return (FcChar32) map->ent[i].bmp;
-    return ~0;
-}
-
-const FcCharMap *
-FcFreeTypeGetPrivateMap (FT_Encoding encoding)
-{
-    int	i;
-
-    for (i = 0; i < NUM_DECODE; i++)
-	if (fcFontDecoders[i].encoding == encoding)
-	    return fcFontDecoders[i].map;
-    return 0;
-}
-
-/*
- * Map a UCS4 glyph to a glyph index.  Use all available encoding
- * tables to try and find one that works.  This information is expected
- * to be cached by higher levels, so performance isn't critical
- */
-
-FT_UInt
-FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
-{
-    int		    initial, offset, decode;
-    FT_UInt	    glyphindex;
-    FcChar32	    charcode;
-
-    initial = 0;
-    /*
-     * Find the current encoding
-     */
-    if (face->charmap)
-    {
-	for (; initial < NUM_DECODE; initial++)
-	    if (fcFontDecoders[initial].encoding == face->charmap->encoding)
-		break;
-	if (initial == NUM_DECODE)
-	    initial = 0;
-    }
-    /*
-     * Check each encoding for the glyph, starting with the current one
-     */
-    for (offset = 0; offset < NUM_DECODE; offset++)
-    {
-	decode = (initial + offset) % NUM_DECODE;
-	if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
-	    if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
-		continue;
-	if (fcFontDecoders[decode].map)
-	{
-	    charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
-	    if (charcode == ~0)
-		continue;
-	}
-	else
-	    charcode = ucs4;
-	glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
-	if (glyphindex)
-	    return glyphindex;
-    }
-    return 0;
-}
-
-static FcBool
-FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4, 
-		      FT_UInt glyph, FcBlanks *blanks)
-{
-    FT_Int	    load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
-    FT_GlyphSlot    slot;
-    
-    /*
-     * When using scalable fonts, only report those glyphs
-     * which can be scaled; otherwise those fonts will
-     * only be available at some sizes, and never when
-     * transformed.  Avoid this by simply reporting bitmap-only
-     * glyphs as missing
-     */
-    if (face->face_flags & FT_FACE_FLAG_SCALABLE)
-	load_flags |= FT_LOAD_NO_BITMAP;
-    
-    if (FT_Load_Glyph (face, glyph, load_flags))
-	return FcFalse;
-    
-    slot = face->glyph;
-    if (!glyph)
-	return FcFalse;
-    
-    switch (slot->format) {
-    case ft_glyph_format_bitmap:
-	/*
-	 * Bitmaps are assumed to be reasonable; if
-	 * this proves to be a rash assumption, this
-	 * code can be easily modified
-	 */
-	return FcTrue;
-    case ft_glyph_format_outline:
-	/*
-	 * Glyphs with contours are always OK
-	 */
-	if (slot->outline.n_contours != 0)
-	    return FcTrue;
-	/*
-	 * Glyphs with no contours are only OK if
-	 * they're members of the Blanks set specified
-	 * in the configuration.  If blanks isn't set,
-	 * then allow any glyph to be blank
-	 */
-	if (!blanks || FcBlanksIsMember (blanks, ucs4))
-	    return FcTrue;
-	/* fall through ... */
-    default:
-	break;
-    }
-    return FcFalse;
-}
-
-FcCharSet *
-FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
-{
-    FcChar32	    page, off, ucs4;
-#ifdef CHECK
-    FcChar32	    font_max = 0;
-#endif
-    FcCharSet	    *fcs;
-    FcCharLeaf	    *leaf;
-    const FcCharMap *map;
-    int		    o;
-    int		    i;
-    FT_UInt	    glyph;
-
-    fcs = FcCharSetCreate ();
-    if (!fcs)
-	goto bail0;
-    
-    for (o = 0; o < NUM_DECODE; o++)
-    {
-	if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
-	    continue;
-	map = fcFontDecoders[o].map;
-	if (map)
-	{
-	    /*
-	     * Non-Unicode tables are easy; there's a list of all possible
-	     * characters
-	     */
-	    for (i = 0; i < map->nent; i++)
-	    {
-		ucs4 = map->ent[i].bmp;
-		glyph = FT_Get_Char_Index (face, map->ent[i].encode);
-		if (glyph && FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks))
-		{
-		    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
-		    if (!leaf)
-			goto bail1;
-		    leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
-#ifdef CHECK
-		    if (ucs4 > font_max)
-			font_max = ucs4;
-#endif
-		}
-	    }
-	}
-	else
-	{
-	    FT_UInt gindex;
-	  
-	    /*
-	     * Find the first encoded character in the font
-	     */
-	    if (FT_Get_Char_Index (face, 0))
-	    {
-		ucs4 = 0;
-		gindex = 1;
-	    }
-	    else
-	    {
-		ucs4 = FT_Get_Next_Char (face, 0, &gindex);
-		if (!ucs4)
-		    gindex = 0;
-	    }
-
-	    while (gindex)
-	    {
-		page = ucs4 >> 8;
-		leaf = 0;
-		while ((ucs4 >> 8) == page)
-		{
-		    glyph = FT_Get_Char_Index (face, ucs4);
-		    if (glyph && FcFreeTypeCheckGlyph (face, ucs4, 
-						       glyph, blanks))
-		    {
-			if (!leaf)
-			{
-			    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
-			    if (!leaf)
-				goto bail1;
-			}
-			off = ucs4 & 0xff;
-			leaf->map[off >> 5] |= (1 << (off & 0x1f));
-#ifdef CHECK
-			if (ucs4 > font_max)
-			    font_max = ucs4;
-#endif
-		    }
-		    ucs4++;
-		}
-		ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
-		if (!ucs4)
-		    gindex = 0;
-	    }
-#ifdef CHECK
-	    for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
-	    {
-		FcBool	    FT_Has, FC_Has;
-
-		FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
-		FC_Has = FcCharSetHasChar (fcs, ucs4);
-		if (FT_Has != FC_Has)
-		{
-		    printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
-		}
-	    }
-#endif
-	}
-    }
-#ifdef CHECK
-    printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
-    for (ucs4 = 0; ucs4 <= font_max; ucs4++)
-    {
-	FcBool	has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
-	FcBool	has_bit = FcCharSetHasChar (fcs, ucs4);
-
-	if (has_char && !has_bit)
-	    printf ("Bitmap missing char 0x%x\n", ucs4);
-	else if (!has_char && has_bit)
-	    printf ("Bitmap extra char 0x%x\n", ucs4);
-    }
-#endif
-    return fcs;
-bail1:
-    FcCharSetDestroy (fcs);
-bail0:
-    return 0;
-}
-
diff -urN xc/extras/fontconfig/src/fcdbg.c xc-fontconfig/extras/fontconfig/src/fcdbg.c
--- xc/extras/fontconfig/src/fcdbg.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcdbg.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcdbg.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcdbg.c,v 1.10 2002/08/22 18:53:22 keithp Exp $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -34,10 +34,10 @@
 	printf (" <void>");
 	break;
     case FcTypeInteger:
-	printf (" %d", v.u.i);
+	printf (" %d(i)", v.u.i);
 	break;
     case FcTypeDouble:
-	printf (" %g", v.u.d);
+	printf (" %g(f)", v.u.d);
 	break;
     case FcTypeString:
 	printf (" \"%s\"", v.u.s);
@@ -52,7 +52,8 @@
 	printf (" set");
 	break;
     case FcTypeLangSet:
-	printf (" langset");
+	printf (" ");
+	FcLangSetPrint (v.u.l);
 	break;
     case FcTypeFTFace:
 	printf (" face");
@@ -66,12 +67,35 @@
     for (; l; l = l->next)
     {
 	FcValuePrint (l->value);
-	if (l->binding == FcValueBindingWeak)
+	switch (l->binding) {
+	case FcValueBindingWeak:
 	    printf ("(w)");
+	    break;
+	case FcValueBindingStrong:
+	    printf ("(s)");
+	    break;
+	case FcValueBindingSame:
+	    printf ("(=)");
+	    break;
+	}
     }
 }
 
 void
+FcLangSetPrint (const FcLangSet *ls)
+{
+    FcStrBuf	buf;
+    FcChar8	init_buf[1024];
+    
+    FcStrBufInit (&buf, init_buf, sizeof (init_buf));
+    if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
+	printf ("%s", buf.buf);
+    else
+	printf ("langset (alloc error)");
+    FcStrBufDestroy (&buf);
+}
+
+void
 FcPatternPrint (const FcPattern *p)
 {
     int		    i;
@@ -129,6 +153,10 @@
     case FcOpNot: printf ("Not"); break;
     case FcOpNil: printf ("Nil"); break;
     case FcOpComma: printf ("Comma"); break;
+    case FcOpFloor: printf ("Floor"); break;
+    case FcOpCeil: printf ("Ceil"); break;
+    case FcOpRound: printf ("Round"); break;
+    case FcOpTrunc: printf ("Trunc"); break;
     case FcOpInvalid: printf ("Invalid"); break;
     }
 }
@@ -136,7 +164,8 @@
 void
 FcExprPrint (const FcExpr *expr)
 {
-    switch (expr->op) {
+    if (!expr) printf ("none");
+    else switch (expr->op) {
     case FcOpInteger: printf ("%d", expr->u.ival); break;
     case FcOpDouble: printf ("%g", expr->u.dval); break;
     case FcOpString: printf ("\"%s\"", expr->u.sval); break;
@@ -211,6 +240,22 @@
 	printf ("Not ");
 	FcExprPrint (expr->u.tree.left);
 	break;
+    case FcOpFloor:
+	printf ("Floor ");
+	FcExprPrint (expr->u.tree.left);
+	break;
+    case FcOpCeil:
+	printf ("Ceil ");
+	FcExprPrint (expr->u.tree.left);
+	break;
+    case FcOpRound:
+	printf ("Round ");
+	FcExprPrint (expr->u.tree.left);
+	break;
+    case FcOpTrunc:
+	printf ("Trunc ");
+	FcExprPrint (expr->u.tree.left);
+	break;
     case FcOpInvalid: printf ("Invalid"); break;
     }
 }
diff -urN xc/extras/fontconfig/src/fcdefault.c xc-fontconfig/extras/fontconfig/src/fcdefault.c
--- xc/extras/fontconfig/src/fcdefault.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcdefault.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcdefault.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcdefault.c,v 1.2 2002/07/09 22:08:14 keithp Exp $
  *
- * Copyright � 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2001 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
@@ -55,6 +55,9 @@
 	}
     }
 
+    if (FcPatternGet (pattern, FC_WIDTH, 0, &v) == FcResultNoMatch)
+	FcPatternAddInteger (pattern, FC_WIDTH, FC_WIDTH_NORMAL);
+
     for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
 	if (FcPatternGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
 	    FcPatternAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
diff -urN xc/extras/fontconfig/src/fcdir.c xc-fontconfig/extras/fontconfig/src/fcdir.c
--- xc/extras/fontconfig/src/fcdir.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcdir.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fcdir.c,v 1.9 2002/08/31 22:17:32 keithp Exp $
+ *
+ * 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fcdir.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include "fcint.h"
 #include <dirent.h>
@@ -46,6 +47,7 @@
     FcChar8		*name;
     FcPattern		*font;
     FcBool		ret = FcTrue;
+    FcBool		isDir;
     int			count = 0;
     FcGlobalCacheFile	*cache_file;
     FcGlobalCacheDir	*cache_dir;
@@ -68,7 +70,7 @@
 		/*
 		 * Found a cache entry for the file
 		 */
-		if (FcGlobalCacheCheckTime (&cache_file->info))
+		if (FcGlobalCacheCheckTime (file, &cache_file->info))
 		{
 		    name = cache_file->name;
 		    need_scan = FcFalse;
@@ -87,7 +89,8 @@
 						       strlen ((const char *) file),
 						       FcFalse)))
 	    {
-		if (FcGlobalCacheCheckTime (&cache_dir->info))
+		if (FcGlobalCacheCheckTime (cache_dir->info.file, 
+					    &cache_dir->info))
 		{
 		    font = 0;
 		    need_scan = FcFalse;
@@ -110,11 +113,11 @@
 	    font = FcFreeTypeQuery (file, id, blanks, &count);
 	    if (FcDebug () & FC_DBG_SCAN)
 		printf ("done\n");
+	    isDir = FcFalse;
 	    if (!font && FcFileIsDir (file))
 	    {
+		isDir = FcTrue;
 		ret = FcStrSetAdd (dirs, file);
-		if (cache && ret)
-		    FcGlobalCacheUpdate (cache, file, 0, FC_FONT_FILE_DIR);
 	    }
 	    /*
 	     * Update the cache
@@ -150,6 +153,11 @@
 
 #define FC_MAX_FILE_LEN	    4096
 
+/*
+ * Scan 'dir', adding font files to 'set' and
+ * subdirectories to 'dirs'
+ */
+
 FcBool
 FcDirScan (FcFontSet	    *set,
 	   FcStrSet	    *dirs,
@@ -170,7 +178,11 @@
 	 * Check fonts.cache-<version> file
 	 */
 	if (FcDirCacheReadDir (set, dirs, dir))
+	{
+	    if (cache)
+		FcGlobalCacheReferenceSubdir (cache, dir);
 	    return FcTrue;
+	}
     
 	/*
 	 * Check ~/.fonts.cache-<version> file
@@ -188,6 +200,9 @@
     strcat ((char *) file, "/");
     base = file + strlen ((char *) file);
     
+    if (FcDebug () & FC_DBG_SCAN)
+	printf ("\tScanning dir %s\n", dir);
+	
     d = opendir ((char *) dir);
     
     if (!d)
@@ -208,6 +223,10 @@
     }
     free (file);
     closedir (d);
+    /*
+     * Now that the directory has been scanned,
+     * add the cache entry 
+     */
     if (ret && cache)
 	FcGlobalCacheUpdate (cache, dir, 0, 0);
 	
diff -urN xc/extras/fontconfig/src/fcfs.c xc-fontconfig/extras/fontconfig/src/fcfs.c
--- xc/extras/fontconfig/src/fcfs.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcfs.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcfs.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $
+ * $RCSId: $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
diff -urN xc/extras/fontconfig/src/fcinit.c xc-fontconfig/extras/fontconfig/src/fcinit.c
--- xc/extras/fontconfig/src/fcinit.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcinit.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcinit.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcinit.c,v 1.7 2002/08/22 07:36:44 keithp Exp $
  *
- * Copyright � 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright � 2001 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
diff -urN xc/extras/fontconfig/src/fcint.h xc-fontconfig/extras/fontconfig/src/fcint.h
--- xc/extras/fontconfig/src/fcint.h	2003-11-02 05:40:29.000000000 +0100
+++ xc-fontconfig/extras/fontconfig/src/fcint.h	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcint.h,v 1.2 2003/10/22 17:15:22 tsi Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -53,6 +53,12 @@
 #define FC_FONT_FILE_INVALID	((FcChar8 *) ".")
 #define FC_FONT_FILE_DIR	((FcChar8 *) ".dir")
 
+#ifdef _WIN32
+#define FC_SEARCH_PATH_SEPARATOR ';'
+#else
+#define FC_SEARCH_PATH_SEPARATOR ':'
+#endif
+
 #define FC_DBG_MATCH	1
 #define FC_DBG_MATCHV	2
 #define FC_DBG_EDIT	4
@@ -97,7 +103,7 @@
 #define FC_MEM_NUM	    29
 
 typedef enum _FcValueBinding {
-    FcValueBindingWeak, FcValueBindingStrong
+    FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
 } FcValueBinding;
 
 typedef struct _FcValueList {
@@ -129,7 +135,8 @@
     FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains, FcOpNotContains,
     FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
     FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
-    FcOpNot, FcOpComma, FcOpInvalid
+    FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
+    FcOpInvalid
 } FcOp;
 
 typedef struct _FcExpr {
@@ -338,12 +345,16 @@
 FcGlobalCacheDestroy (FcGlobalCache *cache);
 
 FcBool
-FcGlobalCacheCheckTime (FcGlobalCacheInfo *info);
+FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
 
 void
 FcGlobalCacheReferenced (FcGlobalCache	    *cache,
 			 FcGlobalCacheInfo  *info);
 
+void
+FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
+			      const FcChar8 *dir);
+
 FcGlobalCacheDir *
 FcGlobalCacheDirGet (FcGlobalCache  *cache,
 		     const FcChar8  *dir,
@@ -421,9 +432,9 @@
 		  FcSetName	set);
 
 FcBool
-FcConfigCompareValue (FcValue m,
-		      FcOp    op,
-		      FcValue v);
+FcConfigCompareValue (const FcValue m,
+		      FcOp	    op,
+		      const FcValue v);
 
 /* fccharset.c */
 FcCharSet *
@@ -435,20 +446,17 @@
 FcCharSet *
 FcNameParseCharSet (FcChar8 *string);
 
-FcChar32
-FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
-
-FcChar32
-FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+FcCharLeaf *
+FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 
-const FcCharMap *
-FcFreeTypeGetPrivateMap (FT_Encoding encoding);
-    
 /* fcdbg.c */
 void
 FcValueListPrint (const FcValueList *l);
 
 void
+FcLangSetPrint (const FcLangSet *ls);
+
+void
 FcOpPrint (FcOp op);
 
 void
@@ -479,6 +487,15 @@
 FcBool
 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 
+FcChar32
+FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
+
+FcChar32
+FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+
+const FcCharMap *
+FcFreeTypeGetPrivateMap (FT_Encoding encoding);
+    
 /* fcfs.c */
 /* fcgram.y */
 int
@@ -636,4 +653,10 @@
 int
 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 
+FcBool
+FcStrUsesHome (const FcChar8 *s);
+
+FcChar8 *
+FcStrLastSlash (const FcChar8  *path);
+
 #endif /* _FC_INT_H_ */
diff -urN xc/extras/fontconfig/src/fclang.c xc-fontconfig/extras/fontconfig/src/fclang.c
--- xc/extras/fontconfig/src/fclang.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fclang.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fclang.c,v 1.7 2002/08/26 23:34:31 keithp Exp $
+ *
+ * Copyright � 2002 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fclang.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include "fcint.h"
 
@@ -28,6 +29,11 @@
     FcCharSet	charset;
 } FcLangCharSet;
 
+typedef struct {
+    int begin;
+    int end;
+} FcLangCharSetRange;
+
 #include "../fc-lang/fclang.h"
 
 struct _FcLangSet {
@@ -137,6 +143,37 @@
     }
 }
 
+/*
+ * Return FcTrue when s1 contains s2. 
+ *
+ * s1 contains s2 if s1 equals s2 or if s1 is a
+ * language with a country and s2 is just a language
+ */
+
+static FcBool
+FcLangContains (const FcChar8 *s1, const FcChar8 *s2)
+{
+    FcChar8	    c1, c2;
+
+    for (;;)
+    {
+	c1 = *s1++;
+	c2 = *s2++;
+	
+	c1 = FcToLower (c1);
+	c2 = FcToLower (c2);
+	if (c1 != c2)
+	{
+	    /* see if s1 has a country while s2 is mising one */
+	    if (c1 == '-' && c2 == '\0')
+		return FcTrue;
+	    return FcFalse;
+	}
+	else if (!c1)
+	    return FcTrue;
+    }
+}
+
 const FcCharSet *
 FcCharSetForLang (const FcChar8 *lang)
 {
@@ -222,16 +259,48 @@
 static int
 FcLangSetIndex (const FcChar8 *lang)
 {
-    int	    low, high, mid;
-    int	    cmp;
+    int	    low, high, mid = 0;
+    int	    cmp = 0;
+    FcChar8 firstChar = FcToLower(lang[0]); 
+    FcChar8 secondChar = firstChar ? FcToLower(lang[1]) : '\0';
+    
+    if (firstChar < 'a')
+    {
+	low = 0;
+	high = fcLangCharSetRanges[0].begin;
+    }
+    else if(firstChar > 'z')
+    {
+	low = fcLangCharSetRanges[25].begin;
+	high = NUM_LANG_CHAR_SET - 1;
+    }
+    else
+    {
+	low = fcLangCharSetRanges[firstChar - 'a'].begin;
+	high = fcLangCharSetRanges[firstChar - 'a'].end;
+	/* no matches */
+	if (low > high)
+	    return -low; /* next entry after where it would be */
+    }
 
-    low = 0;
-    high = NUM_LANG_CHAR_SET - 1;
     while (low <= high)
     {
 	mid = (high + low) >> 1;
-	cmp = FcStrCmpIgnoreCase (fcLangCharSets[mid].lang, lang);
-	if (cmp == 0) 
+	if(fcLangCharSets[mid].lang[0] != firstChar)
+	    cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang, lang);
+	else
+	{   /* fast path for resolving 2-letter languages (by far the most common) after
+	     * finding the first char (probably already true because of the hash table) */
+	    cmp = fcLangCharSets[mid].lang[1] - secondChar;
+	    if (cmp == 0 && 
+		(fcLangCharSets[mid].lang[2] != '\0' || 
+		 lang[2] != '\0'))
+	    {
+		cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang+2, 
+					 lang+2);
+	    }
+	}
+	if (cmp == 0)
 	    return mid;
 	if (cmp < 0)
 	    low = mid + 1;
@@ -411,32 +480,28 @@
 FcLangSet *
 FcNameParseLangSet (const FcChar8 *string)
 {
-    FcChar8	    lang[32];
-    const FcChar8   *end, *next;
+    FcChar8	    lang[32],c;
+    int i;
     FcLangSet	    *ls;
 
     ls = FcLangSetCreate ();
     if (!ls)
 	goto bail0;
 
-    while (string && *string) 
+    for(;;)
     {
-	end = (FcChar8 *) strchr ((char *) string, '|');
-	if (!end)
+	for(i = 0; i < 31;i++)
 	{
-	    end = string + strlen ((char *) string);
-	    next = end;
+	    c = *string++;
+	    if(c == '\0' || c == '|')
+		break; /* end of this code */
+	    lang[i] = c;
 	}
-	else
-	    next = end + 1;
-	if (end - string < sizeof (lang) - 1)
-	{
-	    strncpy ((char *) lang, (char *) string, end - string);
-	    lang[end-string] = '\0';
-	    if (!FcLangSetAdd (ls, lang))
-		goto bail1;
-	}
-	string = next;
+	lang[i] = '\0';
+	if (!FcLangSetAdd (ls, lang))
+	    goto bail1;
+	if(c == '\0')
+	    break;
     }
     return ls;
 bail1:
@@ -481,7 +546,7 @@
 	    if (!first)
 		if (!FcStrBufChar (buf, '|'))
 		    return FcFalse;
-	    if (!FcStrBufString (buf, extra));
+	    if (!FcStrBufString (buf, extra))
 		return FcFalse;
 	    first = FcFalse;
 	}
@@ -505,3 +570,113 @@
 	return FcStrSetEqual (lsa->extra, lsb->extra);
     return FcFalse;
 }
+
+static FcBool
+FcLangSetContainsLang (const FcLangSet *ls, const FcChar8 *lang)
+{
+    int		    id;
+    int		    i;
+
+    id = FcLangSetIndex (lang);
+    if (id < 0)
+	id = -id - 1;
+    else if (FcLangSetBitGet (ls, id))
+	return FcTrue;
+    /*
+     * search up and down among equal languages for a match
+     */
+    for (i = id - 1; i >= 0; i--)
+    {
+	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
+	    break;
+	if (FcLangSetBitGet (ls, i) &&
+	    FcLangContains (fcLangCharSets[i].lang, lang))
+	    return FcTrue;
+    }
+    for (i = id; i < NUM_LANG_CHAR_SET; i++)
+    {
+	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
+	    break;
+	if (FcLangSetBitGet (ls, i) &&
+	    FcLangContains (fcLangCharSets[i].lang, lang))
+	    return FcTrue;
+    }
+    if (ls->extra)
+    {
+	FcStrList	*list = FcStrListCreate (ls->extra);
+	FcChar8		*extra;
+	
+	if (list)
+	{
+	    while ((extra = FcStrListNext (list)))
+	    {
+		if (FcLangContains (extra, lang))
+		    break;
+	    }
+	    FcStrListDone (list);
+    	    if (extra)
+		return FcTrue;
+	}
+    }
+    return FcFalse;
+}
+
+/*
+ * return FcTrue if lsa contains every language in lsb
+ */
+FcBool
+FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb)
+{
+    int		    i, j;
+    FcChar32	    missing;
+
+    if (FcDebug() & FC_DBG_MATCHV)
+    {
+	printf ("FcLangSet "); FcLangSetPrint (lsa);
+	printf (" contains "); FcLangSetPrint (lsb);
+	printf ("\n");
+    }
+    /*
+     * check bitmaps for missing language support
+     */
+    for (i = 0; i < NUM_LANG_SET_MAP; i++)
+    {
+	missing = lsb->map[i] & ~lsa->map[i];
+	if (missing)
+	{
+	    for (j = 0; j < 32; j++)
+		if (missing & (1 << j)) 
+		{
+		    if (!FcLangSetContainsLang (lsa,
+						fcLangCharSets[i*32 + j].lang))
+		    {
+			if (FcDebug() & FC_DBG_MATCHV)
+			    printf ("\tMissing bitmap %s\n", fcLangCharSets[i*32+j].lang);
+			return FcFalse;
+		    }
+		}
+	}
+    }
+    if (lsb->extra)
+    {
+	FcStrList   *list = FcStrListCreate (lsb->extra);
+	FcChar8	    *extra;
+
+	if (list)
+	{
+	    while ((extra = FcStrListNext (list)))
+	    {
+		if (!FcLangSetContainsLang (lsa, extra))
+		{
+		    if (FcDebug() & FC_DBG_MATCHV)
+			printf ("\tMissing string %s\n", extra);
+		    break;
+		}
+	    }
+	    FcStrListDone (list);
+	    if (extra)
+		return FcFalse;
+	}
+    }
+    return FcTrue;
+}
diff -urN xc/extras/fontconfig/src/fclist.c xc-fontconfig/extras/fontconfig/src/fclist.c
--- xc/extras/fontconfig/src/fclist.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fclist.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fclist.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fclist.c,v 1.11tsi Exp $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -128,7 +128,7 @@
 
     for (v1 = v1orig; v1; v1 = v1->next)
 	for (v2 = v2orig; v2; v2 = v2->next)
-	    if (FcConfigCompareValue (v2->value, FcOpContains, v1->value))
+	    if (FcConfigCompareValue (v1->value, FcOpContains, v2->value))
 		return FcTrue;
     return FcFalse;
 }
diff -urN xc/extras/fontconfig/src/fcmatch.c xc-fontconfig/extras/fontconfig/src/fcmatch.c
--- xc/extras/fontconfig/src/fcmatch.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcmatch.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcmatch.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcmatch.c,v 1.20 2002/08/31 22:17:32 keithp Exp $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -28,13 +28,31 @@
 #include <stdio.h>
 
 static double
-FcCompareInteger (char *object, FcValue value1, FcValue value2)
+FcCompareNumber (char *object, FcValue value1, FcValue value2)
 {
-    int	v;
+    double  v1, v2, v;
     
-    if (value2.type != FcTypeInteger || value1.type != FcTypeInteger)
+    switch (value1.type) {
+    case FcTypeInteger:
+	v1 = (double) value1.u.i;
+	break;
+    case FcTypeDouble:
+	v1 = value1.u.d;
+	break;
+    default:
 	return -1.0;
-    v = value2.u.i - value1.u.i;
+    }
+    switch (value2.type) {
+    case FcTypeInteger:
+	v2 = (double) value2.u.i;
+	break;
+    case FcTypeDouble:
+	v2 = value2.u.d;
+	break;
+    default:
+	return -1.0;
+    }
+    v = v2 - v1;
     if (v < 0)
 	v = -v;
     return (double) v;
@@ -173,7 +191,7 @@
     { FC_LANG,		FcCompareLang,		3, 3 },
 #define MATCH_LANG	    3
     
-    { FC_SPACING,	FcCompareInteger,	5, 5 },
+    { FC_SPACING,	FcCompareNumber,	5, 5 },
 #define MATCH_SPACING	    4
     
     { FC_PIXEL_SIZE,	FcCompareSize,		6, 6 },
@@ -182,26 +200,29 @@
     { FC_STYLE,		FcCompareString,	7, 7 },
 #define MATCH_STYLE	    6
     
-    { FC_SLANT,		FcCompareInteger,	8, 8 },
+    { FC_SLANT,		FcCompareNumber,	8, 8 },
 #define MATCH_SLANT	    7
     
-    { FC_WEIGHT,	FcCompareInteger,	9, 9 },
+    { FC_WEIGHT,	FcCompareNumber,	9, 9 },
 #define MATCH_WEIGHT	    8
     
-    { FC_ANTIALIAS,	FcCompareBool,		10, 10 },
-#define MATCH_ANTIALIAS	    9
+    { FC_WIDTH,		FcCompareNumber,	10, 10 },
+#define MATCH_WIDTH	    9
+    
+    { FC_ANTIALIAS,	FcCompareBool,		11, 11 },
+#define MATCH_ANTIALIAS	    10
     
-    { FC_RASTERIZER,	FcCompareString,	11, 11 },
-#define MATCH_RASTERIZER    10
+    { FC_RASTERIZER,	FcCompareString,	12, 12 },
+#define MATCH_RASTERIZER    11
     
-    { FC_OUTLINE,	FcCompareBool,		12, 12 },
-#define MATCH_OUTLINE	    11
+    { FC_OUTLINE,	FcCompareBool,		13, 13 },
+#define MATCH_OUTLINE	    12
 
-    { FC_FONTVERSION,	FcCompareInteger,	13, 13 },
-#define MATCH_FONTVERSION   12
+    { FC_FONTVERSION,	FcCompareNumber,	14, 14 },
+#define MATCH_FONTVERSION   13
 };
 
-#define NUM_MATCH_VALUES    14
+#define NUM_MATCH_VALUES    15
 
 static FcBool
 FcCompareValueList (const char  *object,
@@ -255,7 +276,13 @@
     case 'p':
 	i = MATCH_PIXEL_SIZE; break;
     case 'w':
-	i = MATCH_WEIGHT; break;
+	switch (FcToLower (object[1])) {
+	case 'i':
+	    i = MATCH_WIDTH; break;
+	case 'e':
+	    i = MATCH_WEIGHT; break;
+	}
+	break;
     case 'r':
 	i = MATCH_RASTERIZER; break;
     case 'o':
diff -urN xc/extras/fontconfig/src/fcmatrix.c xc-fontconfig/extras/fontconfig/src/fcmatrix.c
--- xc/extras/fontconfig/src/fcmatrix.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcmatrix.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcmatrix.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $
+ * $RCSId: $
  *
  * Copyright � 2000 Tuomas J. Lukka
  *
diff -urN xc/extras/fontconfig/src/fcname.c xc-fontconfig/extras/fontconfig/src/fcname.c
--- xc/extras/fontconfig/src/fcname.c	2003-09-25 13:01:22.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcname.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/extras/fontconfig/src/fcname.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $
+ * $RCSId: xc/lib/fontconfig/src/fcname.c,v 1.15 2002/09/26 00:17:28 keithp Exp $
  *
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -33,6 +33,7 @@
     { FC_STYLE,		FcTypeString, },
     { FC_SLANT,		FcTypeInteger, },
     { FC_WEIGHT,	FcTypeInteger, },
+    { FC_WIDTH,		FcTypeInteger, },
     { FC_SIZE,		FcTypeDouble, },
     { FC_ASPECT,	FcTypeDouble, },
     { FC_PIXEL_SIZE,	FcTypeDouble, },
@@ -137,16 +138,33 @@
 }
 
 static const FcConstant _FcBaseConstants[] = {
+    { (FcChar8 *) "thin",	    "weight",   FC_WEIGHT_THIN, },
+    { (FcChar8 *) "extralight",	    "weight",   FC_WEIGHT_EXTRALIGHT, },
+    { (FcChar8 *) "ultralight",	    "weight",   FC_WEIGHT_EXTRALIGHT, },
     { (FcChar8 *) "light",	    "weight",   FC_WEIGHT_LIGHT, },
+    { (FcChar8 *) "regular",	    "weight",   FC_WEIGHT_REGULAR, },
     { (FcChar8 *) "medium",	    "weight",   FC_WEIGHT_MEDIUM, },
     { (FcChar8 *) "demibold",	    "weight",   FC_WEIGHT_DEMIBOLD, },
+    { (FcChar8 *) "semibold",	    "weight",   FC_WEIGHT_DEMIBOLD, },
     { (FcChar8 *) "bold",	    "weight",   FC_WEIGHT_BOLD, },
+    { (FcChar8 *) "extrabold",	    "weight",   FC_WEIGHT_EXTRABOLD, },
+    { (FcChar8 *) "ultrabold",	    "weight",   FC_WEIGHT_EXTRABOLD, },
     { (FcChar8 *) "black",	    "weight",   FC_WEIGHT_BLACK, },
 
     { (FcChar8 *) "roman",	    "slant",    FC_SLANT_ROMAN, },
     { (FcChar8 *) "italic",	    "slant",    FC_SLANT_ITALIC, },
     { (FcChar8 *) "oblique",	    "slant",    FC_SLANT_OBLIQUE, },
 
+    { (FcChar8 *) "ultracondensed", "width",	FC_WIDTH_ULTRACONDENSED },
+    { (FcChar8 *) "extracondensed", "width",	FC_WIDTH_EXTRACONDENSED },
+    { (FcChar8 *) "condensed",	    "width",	FC_WIDTH_CONDENSED },
+    { (FcChar8 *) "semicondensed", "width",	FC_WIDTH_SEMICONDENSED },
+    { (FcChar8 *) "normal",	    "width",	FC_WIDTH_NORMAL },
+    { (FcChar8 *) "semiexpanded",   "width",	FC_WIDTH_SEMIEXPANDED },
+    { (FcChar8 *) "expanded",	    "width",	FC_WIDTH_EXPANDED },
+    { (FcChar8 *) "extraexpanded",  "width",	FC_WIDTH_EXTRAEXPANDED },
+    { (FcChar8 *) "ultraexpanded",  "width",	FC_WIDTH_ULTRAEXPANDED },
+    
     { (FcChar8 *) "proportional",   "spacing",  FC_PROPORTIONAL, },
     { (FcChar8 *) "mono",	    "spacing",  FC_MONO, },
     { (FcChar8 *) "charcell",	    "spacing",  FC_CHARCELL, },
@@ -218,7 +236,7 @@
 {
     const FcConstantList    *l;
     int			    i;
-    
+
     for (l = _FcConstants; l; l = l->next)
     {
 	for (i = 0; i < l->nconsts; i++)
@@ -247,8 +265,7 @@
     char    c0, c1;
 
     c0 = *v;
-    if (isupper (c0))
-	c0 = tolower (c0);
+    c0 = FcToLower (c0);
     if (c0 == 't' || c0 == 'y' || c0 == '1')
     {
 	*result = FcTrue;
@@ -262,8 +279,7 @@
     if (c0 == 'o')
     {
 	c1 = v[1];
-	if (isupper (c1))
-	    c1 = tolower (c1);
+	c1 = FcToLower (c1);
 	if (c1 == 'n')
 	{
 	    *result = FcTrue;
diff -urN xc/extras/fontconfig/src/fcpat.c xc-fontconfig/extras/fontconfig/src/fcpat.c
--- xc/extras/fontconfig/src/fcpat.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcpat.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fcpat.c,v 1.18 2002/09/18 17:11:46 tsi Exp $
+ *
+ * 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fcpat.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include <stdlib.h>
 #include <string.h>
@@ -753,11 +754,14 @@
 FcPatternDel (FcPattern *p, const char *object)
 {
     FcPatternElt   *e;
+    int		    i;
 
     e = FcPatternFindElt (p, object);
     if (!e)
 	return FcFalse;
 
+    i = e - p->elts;
+    
     /* destroy value */
     FcValueListDestroy (e->values);
     
diff -urN xc/extras/fontconfig/src/fcxml.c xc-fontconfig/extras/fontconfig/src/fcxml.c
--- xc/extras/fontconfig/src/fcxml.c	2003-06-04 18:29:39.000000000 +0200
+++ xc-fontconfig/extras/fontconfig/src/fcxml.c	2003-11-21 01:35:12.000000000 +0100
@@ -1,5 +1,7 @@
 /*
- * Copyright � 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * $RCSId: xc/lib/fontconfig/src/fcxml.c,v 1.21 2002/08/22 18:53:22 keithp Exp $
+ *
+ * Copyright � 2002 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
@@ -19,7 +21,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-/* $XFree86: xc/extras/fontconfig/src/fcxml.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */
 
 #include <stdarg.h>
 #include "fcint.h"
@@ -34,6 +35,12 @@
 #include <expat.h>
 #endif
 
+#ifdef _WIN32
+#define STRICT
+#include <windows.h>
+#undef STRICT
+#endif
+
 FcTest *
 FcTestCreate (FcMatchKind   kind, 
 	      FcQual	    qual,
@@ -196,6 +203,8 @@
 void
 FcExprDestroy (FcExpr *e)
 {
+    if (!e)
+	return;
     switch (e->op) {
     case FcOpInteger:
 	break;
@@ -244,6 +253,10 @@
 	FcExprDestroy (e->u.tree.right);
 	/* fall through */
     case FcOpNot:
+    case FcOpFloor:
+    case FcOpCeil:
+    case FcOpRound:
+    case FcOpTrunc:
 	FcExprDestroy (e->u.tree.left);
 	break;
     case FcOpNil:
@@ -330,6 +343,10 @@
     FcElementDivide,
     FcElementNot,
     FcElementIf,
+    FcElementFloor,
+    FcElementCeil,
+    FcElementRound,
+    FcElementTrunc,
     FcElementUnknown
 } FcElement;
 
@@ -382,8 +399,12 @@
 	{ "divide",	FcElementDivide },
 	{ "not",	FcElementNot },
 	{ "if",		FcElementIf },
+	{ "floor",	FcElementFloor },
+	{ "ceil",	FcElementCeil },
+	{ "round",	FcElementRound },
+	{ "trunc",	FcElementTrunc },
 	
-	{ 0,		FcElementUnknown }
+	{ 0,		0 }
     };
 
     int	    i;
@@ -702,6 +723,7 @@
 static FcChar8 **
 FcConfigSaveAttr (const XML_Char **attr)
 {
+    int		n;
     int		slen;
     int		i;
     FcChar8	**new;
@@ -712,6 +734,7 @@
     slen = 0;
     for (i = 0; attr[i]; i++)
 	slen += strlen (attr[i]) + 1;
+    n = i;
     new = malloc ((i + 1) * sizeof (FcChar8 *) + slen);
     if (!new)
 	return 0;
@@ -1283,8 +1306,17 @@
     return expr;
 }
 
+/*
+ * This builds a tree of binary operations.  Note
+ * that every operator is defined so that if only
+ * a single operand is contained, the value of the
+ * whole expression is the value of the operand.
+ *
+ * This code reduces in that case to returning that
+ * operand.
+ */
 static FcExpr *
-FcPopExprs (FcConfigParse *parse, FcOp op)
+FcPopBinary (FcConfigParse *parse, FcOp op)
 {
     FcExpr  *left, *expr = 0, *new;
 
@@ -1309,9 +1341,39 @@
 }
 
 static void
-FcParseExpr (FcConfigParse *parse, FcOp op)
+FcParseBinary (FcConfigParse *parse, FcOp op)
 {
-    FcExpr  *expr = FcPopExprs (parse, op);
+    FcExpr  *expr = FcPopBinary (parse, op);
+    if (expr)
+	FcVStackPushExpr (parse, FcVStackExpr, expr);
+}
+
+/*
+ * This builds a a unary operator, it consumes only
+ * a single operand
+ */
+
+static FcExpr *
+FcPopUnary (FcConfigParse *parse, FcOp op)
+{
+    FcExpr  *operand, *new = 0;
+
+    if ((operand = FcPopExpr (parse)))
+    {
+	new = FcExprCreateOp (operand, op, 0);
+	if (!new)
+	{
+	    FcExprDestroy (operand);
+	    FcConfigMessage (parse, FcSevereError, "out of memory");
+	}
+    }
+    return new;
+}
+
+static void
+FcParseUnary (FcConfigParse *parse, FcOp op)
+{
+    FcExpr  *expr = FcPopUnary (parse, op);
     if (expr)
 	FcVStackPushExpr (parse, FcVStackExpr, expr);
 }
@@ -1440,7 +1502,7 @@
 	    return;
 	}
     }
-    expr = FcPopExprs (parse, FcOpComma);
+    expr = FcPopBinary (parse, FcOpComma);
     if (!expr)
     {
 	FcConfigMessage (parse, FcSevereWarning, "missing test expression");
@@ -1510,13 +1572,15 @@
 	    binding = FcValueBindingWeak;
 	else if (!strcmp ((char *) binding_string, "strong"))
 	    binding = FcValueBindingStrong;
+	else if (!strcmp ((char *) binding_string, "same"))
+	    binding = FcValueBindingSame;
 	else
 	{
 	    FcConfigMessage (parse, FcSevereWarning, "invalid edit binding \"%s\"", binding_string);
 	    return;
 	}
     }
-    expr = FcPopExprs (parse, FcOpComma);
+    expr = FcPopBinary (parse, FcOpComma);
     edit = FcEditCreate ((char *) FcStrCopy (name), mode, expr, binding);
     if (!edit)
     {
@@ -1595,8 +1659,35 @@
 	    FcConfigMessage (parse, FcSevereError, "out of memory");
 	    break;
 	}
-	if (!FcConfigAddDir (parse->config, data))
-	    FcConfigMessage (parse, FcSevereError, "out of memory");
+#ifdef _WIN32
+	if (strcmp (data, "WINDOWSFONTDIR") == 0)
+	{
+	    int rc;
+	    FcStrFree (data);
+	    data = malloc (1000);
+	    if (!data)
+	    {
+		FcConfigMessage (parse, FcSevereError, "out of memory");
+		break;
+	    }
+	    FcMemAlloc (FC_MEM_STRING, 1000);
+	    rc = GetWindowsDirectory (data, 800);
+	    if (rc == 0 || rc > 800)
+	    {
+		FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
+		FcStrFree (data);
+		break;
+	    }
+	    if (data [strlen (data) - 1] != '\\')
+		strcat (data, "\\");
+	    strcat (data, "fonts");
+	}
+#endif
+	if (!FcStrUsesHome (data) || FcConfigHome ())
+	{
+	    if (!FcConfigAddDir (parse->config, data))
+		FcConfigMessage (parse, FcSevereError, "out of memory");
+	}
 	FcStrFree (data);
 	break;
     case FcElementCache:
@@ -1606,8 +1697,11 @@
 	    FcConfigMessage (parse, FcSevereError, "out of memory");
 	    break;
 	}
-	if (!FcConfigSetCache (parse->config, data))
-	    FcConfigMessage (parse, FcSevereError, "out of memory");
+	if (!FcStrUsesHome (data) || FcConfigHome ())
+	{
+	    if (!FcConfigSetCache (parse->config, data))
+		FcConfigMessage (parse, FcSevereError, "out of memory");
+	}
 	FcStrFree (data);
 	break;
     case FcElementInclude:
@@ -1675,52 +1769,64 @@
 	FcParseString (parse, FcVStackConstant);
 	break;
     case FcElementOr:
-	FcParseExpr (parse, FcOpOr);
+	FcParseBinary (parse, FcOpOr);
 	break;
     case FcElementAnd:
-	FcParseExpr (parse, FcOpAnd);
+	FcParseBinary (parse, FcOpAnd);
 	break;
     case FcElementEq:
-	FcParseExpr (parse, FcOpEqual);
+	FcParseBinary (parse, FcOpEqual);
 	break;
     case FcElementNotEq:
-	FcParseExpr (parse, FcOpNotEqual);
+	FcParseBinary (parse, FcOpNotEqual);
 	break;
     case FcElementLess:
-	FcParseExpr (parse, FcOpLess);
+	FcParseBinary (parse, FcOpLess);
 	break;
     case FcElementLessEq:
-	FcParseExpr (parse, FcOpLessEqual);
+	FcParseBinary (parse, FcOpLessEqual);
 	break;
     case FcElementMore:
-	FcParseExpr (parse, FcOpMore);
+	FcParseBinary (parse, FcOpMore);
 	break;
     case FcElementMoreEq:
-	FcParseExpr (parse, FcOpMoreEqual);
+	FcParseBinary (parse, FcOpMoreEqual);
 	break;
     case FcElementContains:
-	FcParseExpr (parse, FcOpContains);
+	FcParseBinary (parse, FcOpContains);
 	break;
     case FcElementNotContains:
-	FcParseExpr (parse, FcOpNotContains);
+	FcParseBinary (parse, FcOpNotContains);
 	break;
     case FcElementPlus:
-	FcParseExpr (parse, FcOpPlus);
+	FcParseBinary (parse, FcOpPlus);
 	break;
     case FcElementMinus:
-	FcParseExpr (parse, FcOpMinus);
+	FcParseBinary (parse, FcOpMinus);
 	break;
     case FcElementTimes:
-	FcParseExpr (parse, FcOpTimes);
+	FcParseBinary (parse, FcOpTimes);
 	break;
     case FcElementDivide:
-	FcParseExpr (parse, FcOpDivide);
+	FcParseBinary (parse, FcOpDivide);
 	break;
     case FcElementNot:
-	FcParseExpr (parse, FcOpNot);
+	FcParseUnary (parse, FcOpNot);
 	break;
     case FcElementIf:
-	FcParseExpr (parse, FcOpQuest);
+	FcParseBinary (parse, FcOpQuest);
+	break;
+    case FcElementFloor:
+	FcParseUnary (parse, FcOpFloor);
+	break;
+    case FcElementCeil:
+	FcParseUnary (parse, FcOpCeil);
+	break;
+    case FcElementRound:
+	FcParseUnary (parse, FcOpRound);
+	break;
+    case FcElementTrunc:
+	FcParseUnary (parse, FcOpTrunc);
 	break;
     case FcElementUnknown:
 	break;
--- xc/lib/fontconfig/Imakefile	2004-01-07 09:50:05.000000000 +0100
+++ xc-fontconfig/lib/fontconfig/Imakefile	2004-01-07 09:55:24.000000000 +0100
@@ -47,7 +47,7 @@
 InstallManPage(fontconfig,$(LIBMANDIR))
 DependTarget()
 
-FONTCONFIG_VERSION=2.1.0
+FONTCONFIG_VERSION=2.2.1
 
 #ifndef FontconfigFontsConfDir
 #if NothingOutsideProjectRoot