X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcfreetype.c;h=f2d0642031d9aff46e74f8fb2d458b7693a2be9b;hb=HEAD;hp=104786d68ccf390bab2919c2e28f4c05eaac681e;hpb=00c0972acae849ca3b18a7c76894c078185d3be4;p=fontconfig.git

diff --git a/src/fcfreetype.c b/src/fcfreetype.c
index 104786d..f2d0642 100644
--- a/src/fcfreetype.c
+++ b/src/fcfreetype.c
@@ -7,15 +7,15 @@
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
  *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
@@ -115,18 +115,19 @@ typedef struct {
 #define FC_ENCODING_MAC_ROMAN	"MACINTOSH"
 
 static const FcFtEncoding   fcFtEncoding[] = {
- {  TT_PLATFORM_APPLE_UNICODE,	TT_ENCODING_DONT_CARE,	"UCS-2BE" },
+ {  TT_PLATFORM_APPLE_UNICODE,	TT_ENCODING_DONT_CARE,	"UTF-16BE" },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_ID_ROMAN,	"MACINTOSH" },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_ID_JAPANESE,	"SJIS" },
+ {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_SYMBOL_CS,	"UTF-16BE" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_UNICODE_CS,	"UTF-16BE" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_SJIS,		"SJIS-WIN" },
- {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_GB2312,	"GB3212" },
+ {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_GB2312,	"GB2312" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_BIG_5,		"BIG-5" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_WANSUNG,	"Wansung" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_JOHAB,		"Johab" },
- {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_UCS_4,		"UCS4" },
+ {  TT_PLATFORM_MICROSOFT,	TT_MS_ID_UCS_4,		"UTF-16BE" },
  {  TT_PLATFORM_ISO,		TT_ISO_ID_7BIT_ASCII,	"ASCII" },
- {  TT_PLATFORM_ISO,		TT_ISO_ID_10646,	"UCS-2BE" },
+ {  TT_PLATFORM_ISO,		TT_ISO_ID_10646,	"UTF-16BE" },
  {  TT_PLATFORM_ISO,		TT_ISO_ID_8859_1,	"ISO-8859-1" },
 };
 
@@ -251,14 +252,14 @@ static const FcFtLanguage   fcFtLanguage[] = {
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_DZONGKHA,		    "dz" },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_JAVANESE,		    "jw" },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_SUNDANESE,	    "su" },
-    
+
 #if 0  /* these seem to be errors that have been dropped */
 
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_SCOTTISH_GAELIC },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_IRISH_GAELIC },
 
 #endif
-    
+
   /* The following codes are new as of 2000-03-10 */
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_GALICIAN,		    "gl" },
  {  TT_PLATFORM_MACINTOSH,	TT_MAC_LANGID_AFRIKAANS,	    "af" },
@@ -494,7 +495,7 @@ static const FcFtLanguage   fcFtLanguage[] = {
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_PASHTO_AFGHANISTAN,	"ps" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_FILIPINO_PHILIPPINES,	"phi" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_DHIVEHI_MALDIVES,		"div" },
-    
+
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_OROMO_ETHIOPIA,		"om" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_TIGRIGNA_ETHIOPIA,		"ti" },
  {  TT_PLATFORM_MICROSOFT,	TT_MS_LANGID_TIGRIGNA_ERYTHREA,		"ti" },
@@ -695,34 +696,6 @@ FcSfntNameTranscode (FT_SfntName *sname)
 	*u8 = '\0';
 	goto done;
     }
-    if (!strcmp (fromcode, FC_ENCODING_MAC_ROMAN))
-    {
-	FcChar8		*u8;
-	const FcCharMap	*map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
-	FcChar8		*src = (FcChar8 *) sname->string;
-	int		src_len = sname->string_len;
-	
-	/*
-	 * Convert AppleRoman to Utf8
-	 */
-	if (!map)
-	    return 0;
-
-	utf8 = malloc (sname->string_len * 3 + 1);
-	if (!utf8)
-	    return 0;
-
-	u8 = utf8;
-	while (src_len > 0)
-	{
-	    FcChar32	ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
-	    int		olen = FcUcs4ToUtf8 (ucs4, u8);
-	    src_len--;
-	    u8 += olen;
-	}
-	*u8 = '\0';
-	goto done;
-    }
 #if USE_ICONV
     cd = iconv_open ("UTF-8", fromcode);
     if (cd && cd != (iconv_t) (-1))
@@ -743,7 +716,7 @@ FcSfntNameTranscode (FT_SfntName *sname)
 	
 	while (in_bytes_left)
 	{
-	    size_t	did = iconv (cd, 
+	    size_t	did = iconv (cd,
 				 &inbuf, &in_bytes_left,
 				 &outbuf, &out_bytes_left);
 	    if (did == (size_t) (-1))
@@ -785,7 +758,7 @@ FcSfntNameLanguage (FT_SfntName *sname)
     {
 	language_id = TT_MAC_LANGID_JAPANESE;
     }
-    
+
     for (i = 0; i < NUM_FC_FT_LANGUAGE; i++)
 	if (fcFtLanguage[i].platform_id == platform_id &&
 	    (fcFtLanguage[i].language_id == TT_LANGUAGE_DONT_CARE ||
@@ -870,7 +843,7 @@ FcVendorMatch(const FT_Char vendor[4], const FT_Char *vendor_string)
 {
     /* vendor is not necessarily NUL-terminated. */
     int i, len;
-    
+
     len = strlen((char *) vendor_string);
     if (memcmp(vendor, vendor_string, len) != 0)
         return FcFalse;
@@ -926,7 +899,7 @@ static const FcChar8 *
 FcVendorFoundry(const FT_Char vendor[4])
 {
     int i;
-    
+
     if (vendor)
 	for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++)
 	    if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor))
@@ -1091,10 +1064,16 @@ static const FT_UShort platform_order[] = {
 #define NUM_PLATFORM_ORDER (sizeof (platform_order) / sizeof (platform_order[0]))
 
 static const FT_UShort nameid_order[] = {
+#ifdef TT_NAME_ID_WWS_FAMILY
+    TT_NAME_ID_WWS_FAMILY,
+#endif
     TT_NAME_ID_PREFERRED_FAMILY,
     TT_NAME_ID_FONT_FAMILY,
     TT_NAME_ID_MAC_FULL_NAME,
     TT_NAME_ID_FULL_NAME,
+#ifdef TT_NAME_ID_WWS_SUBFAMILY
+    TT_NAME_ID_WWS_SUBFAMILY,
+#endif
     TT_NAME_ID_PREFERRED_SUBFAMILY,
     TT_NAME_ID_FONT_SUBFAMILY,
     TT_NAME_ID_TRADEMARK,
@@ -1119,7 +1098,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 #if 0
     FcChar8	    *family = 0;
 #endif
-    FcChar8	    *complex;
+    FcChar8	    *complex_;
     const FcChar8   *foundry = 0;
     int		    spacing;
     TT_OS2	    *os2;
@@ -1133,7 +1112,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
     const FcChar8   *exclusiveLang = 0;
     FT_SfntName	    sname;
     FT_UInt    	    snamei, snamec;
-    
+
     int		    nfamily = 0;
     int		    nfamily_lang = 0;
     int		    nstyle = 0;
@@ -1145,7 +1124,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 
     FcChar8	    *style = 0;
     int		    st;
-    
+
     pat = FcPatternCreate ();
     if (!pat)
 	goto bail0;
@@ -1171,7 +1150,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
      * the Postscript FontInfo dictionary.  Finally, the
      * BDF properties will queried.
      */
-    
+
     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
         foundry = FcVendorFoundry(os2->achVendID);
 
@@ -1236,9 +1215,12 @@ FcFreeTypeQueryFace (const FT_Face  face,
 		    continue;
 
 		switch (sname.name_id) {
+#ifdef TT_NAME_ID_WWS_FAMILY
+		case TT_NAME_ID_WWS_FAMILY:
+#endif
 		case TT_NAME_ID_PREFERRED_FAMILY:
 		case TT_NAME_ID_FONT_FAMILY:
-#if 0	    
+#if 0	
 		case TT_NAME_ID_PS_NAME:
 		case TT_NAME_ID_UNIQUE_ID:
 #endif
@@ -1266,6 +1248,9 @@ FcFreeTypeQueryFace (const FT_Face  face,
 		    np = &nfullname;
 		    nlangp = &nfullname_lang;
 		    break;
+#ifdef TT_NAME_ID_WWS_SUBFAMILY
+		case TT_NAME_ID_WWS_SUBFAMILY:
+#endif
 		case TT_NAME_ID_PREFERRED_SUBFAMILY:
 		case TT_NAME_ID_FONT_SUBFAMILY:
 		    if (FcDebug () & FC_DBG_SCANV)
@@ -1322,7 +1307,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	}
     }
 
-    if (!nfamily && face->family_name && 
+    if (!nfamily && face->family_name &&
 	FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->family_name, (FcChar8 *) "") != 0)
     {
 	if (FcDebug () & FC_DBG_SCANV)
@@ -1331,7 +1316,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	    goto bail1;
 	++nfamily;
     }
-    
+
     if (!nstyle && face->style_name &&
 	FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->style_name, (FcChar8 *) "") != 0)
     {
@@ -1341,7 +1326,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	    goto bail1;
 	++nstyle;
     }
-    
+
     if (!nfamily)
     {
 	FcChar8	*start, *end;
@@ -1420,7 +1405,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	    }
 	    if (bits & (1 << bit))
 	    {
-		/* 
+		/*
 		 * If the font advertises support for multiple
 		 * "exclusive" languages, then include support
 		 * for any language found to have coverage
@@ -1478,21 +1463,21 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	    printf ("\tos2 width class %d maps to width %d\n",
 		    os2->usWidthClass, width);
     }
-    if (os2 && (complex = FcFontCapabilities(face)))
+    if (os2 && (complex_ = FcFontCapabilities(face)))
     {
-	if (!FcPatternAddString (pat, FC_CAPABILITY, complex))
+	if (!FcPatternAddString (pat, FC_CAPABILITY, complex_))
 	{
-	    free (complex);
+	    free (complex_);
 	    goto bail1;
 	}
-	free (complex);
+	free (complex_);
     }
 
     /*
      * Type 1: Check for FontInfo dictionary information
      * Code from g2@magestudios.net (Gerard Escalante)
      */
-    
+
 #if HAVE_FT_GET_PS_FONT_INFO
     if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
     {
@@ -1503,23 +1488,23 @@ FcFreeTypeQueryFace (const FT_Face  face,
     		printf ("\tType1 weight %s maps to %d\n",
 			psfontinfo.weight, weight);
 	}
-     
+
 #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)
-            slant = FC_SLANT_ITALIC; 
+            slant = FC_SLANT_ITALIC;
         else
-            slant = FC_SLANT_ROMAN; 
+            slant = FC_SLANT_ROMAN;
 #endif
 
         if(!foundry)
             foundry = FcNoticeFoundry(psfontinfo.notice);
     }
 #endif /* HAVE_FT_GET_PS_FONT_INFO */
-    
+
 #if HAVE_FT_GET_BDF_PROPERTY
     /*
      * Finally, look for a FOUNDRY BDF property if no other
@@ -1541,7 +1526,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
 	     prop.type == BDF_PROPERTY_TYPE_CARDINAL))
 	{
 	    FT_Int32	value;
-	    
+	
 	    if (prop.type == BDF_PROPERTY_TYPE_INTEGER)
 		value = prop.u.integer;
 	    else
@@ -1662,7 +1647,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
     /*
      * Skip over PCF fonts that have no encoded characters; they're
      * usually just Unicode fonts transcoded to some legacy encoding
-     * ftglue.c forces us to approximate whether a font is a PCF font
+     * FT forces us to approximate whether a font is a PCF font
      * or not by whether it has any BDF properties.  Try PIXEL_SIZE;
      * I don't know how to get a list of BDF properties on the font. -PL
      */
@@ -1718,7 +1703,7 @@ FcFreeTypeQueryFace (const FT_Face  face,
      * Drop our reference to the charset
      */
     FcCharSetDestroy (cs);
-    
+
     return pat;
 
 bail2:
@@ -1738,10 +1723,10 @@ FcFreeTypeQuery(const FcChar8	*file,
     FT_Face	    face;
     FT_Library	    ftLibrary;
     FcPattern	    *pat = NULL;
-    
+
     if (FT_Init_FreeType (&ftLibrary))
 	return NULL;
-    
+
     if (FT_New_Face (ftLibrary, (char *) file, id, &face))
 	goto bail;
 
@@ -1781,237 +1766,6 @@ typedef struct _FcFontDecode {
     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 */
@@ -2213,11 +1967,10 @@ 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  (int) (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
@@ -2298,7 +2051,7 @@ static FcBool
 FcFreeTypeUseNames (FT_Face face)
 {
     FT_Int  map;
-    
+
     if (!FT_Has_PS_Glyph_Names (face))
 	return FcFalse;
     for (map = 0; map < face->num_charmaps; map++)
@@ -2314,11 +2067,11 @@ FcUcs4ToGlyphName (FcChar32 ucs4)
     int		r = 0;
     FcGlyphId	gn;
 
-    while ((gn = ucs_to_name[i]) != -1)
+    while ((gn = _fc_ucs_to_name[i]) != -1)
     {
-	if (glyphs[gn].ucs == ucs4)
-	    return glyphs[gn].name;
-	if (!r) 
+	if (_fc_glyph_names[gn].ucs == ucs4)
+	    return _fc_glyph_names[gn].name;
+	if (!r)
 	{
 	    r = (int) (ucs4 % FC_GLYPHNAME_REHASH);
 	    if (!r)
@@ -2339,11 +2092,11 @@ FcGlyphNameToUcs4 (FcChar8 *name)
     int		r = 0;
     FcGlyphId	gn;
 
-    while ((gn = name_to_ucs[i]) != -1)
+    while ((gn = _fc_name_to_ucs[i]) != -1)
     {
-	if (!strcmp ((char *) name, (char *) glyphs[gn].name))
-	    return glyphs[gn].ucs;
-	if (!r) 
+	if (!strcmp ((char *) name, (char *) _fc_glyph_names[gn].name))
+	    return _fc_glyph_names[gn].ucs;
+	if (!r)
 	{
 	    r = (int) (h % FC_GLYPHNAME_REHASH);
 	    if (!r)
@@ -2466,14 +2219,14 @@ FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
 }
 
 static FcBool
-FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4, 
+FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
 		      FT_UInt glyph, FcBlanks *blanks,
 		      FT_Pos *advance,
 		      FcBool using_strike)
 {
     FT_Int	    load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
     FT_GlyphSlot    slot;
-    
+
     if (using_strike)
 	load_flags &= ~FT_LOAD_NO_SCALE;
 
@@ -2486,14 +2239,14 @@ FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
      */
     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) {
@@ -2525,9 +2278,6 @@ FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
     return FcFalse;
 }
 
-#define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
-#define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
-#define FC_ABS(a)   ((a) < 0 ? -(a) : (a))
 #define APPROXIMATELY_EQUAL(x,y) (FC_ABS ((x) - (y)) <= FC_MAX (FC_ABS (x), FC_ABS (y)) / 33)
 
 static FcCharSet *
@@ -2550,7 +2300,7 @@ FcFreeTypeCharSetAndSpacingForSize (FT_Face face, FcBlanks *blanks, int *spacing
     fcs = FcCharSetCreate ();
     if (!fcs)
 	goto bail0;
-    
+
 #if HAVE_FT_SELECT_SIZE
     if (strike_index >= 0) {
 	if (FT_Select_Size (face, strike_index) != FT_Err_Ok)
@@ -2577,10 +2327,10 @@ FcFreeTypeCharSetAndSpacingForSize (FT_Face face, FcBlanks *blanks, int *spacing
 	    {
 		ucs4 = map->ent[i].bmp;
 		glyph = FT_Get_Char_Index (face, map->ent[i].encode);
-		if (glyph && 
+		if (glyph &&
 		    FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance, using_strike))
 		{
-		    /* 
+		    /*
 		     * ignore glyphs with zero advance. They’re
 		     * combining characters, and while their behaviour
 		     * isn’t well defined for monospaced applications in
@@ -2692,7 +2442,7 @@ FcFreeTypeCharSetAndSpacingForSize (FT_Face face, FcBlanks *blanks, int *spacing
 	    if (FT_Get_Glyph_Name (face, glyph, name_buf, FC_GLYPHNAME_BUFLEN+1) == 0)
 	    {
 		ucs4 = FcGlyphNameToUcs4 (name_buf);
-		if (ucs4 != 0xffff && 
+		if (ucs4 != 0xffff &&
 		    FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance, using_strike))
 		{
 		    if (advance)
@@ -2762,13 +2512,13 @@ FcCharSet *
 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
 {
     FcCharSet	*cs;
-    
+
     cs = FcFreeTypeCharSetAndSpacingForSize (face, blanks, spacing, -1);
     /*
      * Check for bitmap-only ttf fonts that are missing the glyf table.
      * In that case, pick a size and look for glyphs in that size instead
      */
-    if (FcCharSetCount (cs) == 0) 
+    if (FcCharSetCount (cs) == 0)
     {
 	/* Check for non-scalable TT fonts */
 	if (!(face->face_flags & FT_FACE_FLAG_SCALABLE) &&
@@ -2780,7 +2530,7 @@ FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
 
 	    /* Select the face closest to 16 pixels tall */
 	    for (i = 1; i < face->num_fixed_sizes; i++) {
-		if (abs (face->available_sizes[i].height - 16) < 
+		if (abs (face->available_sizes[i].height - 16) <
 		    abs (face->available_sizes[strike_index].height - 16))
 		    strike_index = i;
 	    }
@@ -2803,10 +2553,6 @@ FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
 #define TTAG_GPOS  FT_MAKE_TAG( 'G', 'P', 'O', 'S' )
 #define TTAG_GSUB  FT_MAKE_TAG( 'G', 'S', 'U', 'B' )
 #define TTAG_SILF  FT_MAKE_TAG( 'S', 'i', 'l', 'f')
-#define TT_Err_Ok FT_Err_Ok
-#define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle
-#define TTO_Err_Empty_Script              0x1005
-#define TTO_Err_Invalid_SubTable          0x1001
 
 #define OTLAYOUT_HEAD	    "otlayout:"
 #define OTLAYOUT_HEAD_LEN   9
@@ -2820,9 +2566,9 @@ FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
  */
 #define FcIsSpace(x)	    (040 == (x))
 #define FcIsValidScript(x)  (FcIsLower(x) || FcIsUpper (x) || FcIsSpace(x))
-			     
+			
 static void
-addtag(FcChar8 *complex, FT_ULong tag)
+addtag(FcChar8 *complex_, FT_ULong tag)
 {
     FcChar8 tagstring[OTLAYOUT_ID_LEN + 1];
 
@@ -2831,7 +2577,7 @@ addtag(FcChar8 *complex, FT_ULong tag)
     tagstring[2] = (FcChar8)(tag >> 8),
     tagstring[3] = (FcChar8)(tag);
     tagstring[4] = '\0';
-    
+
     /* skip tags which aren't alphabetic, under the assumption that
      * they're probably broken
      */
@@ -2841,10 +2587,10 @@ addtag(FcChar8 *complex, FT_ULong tag)
 	!FcIsValidScript(tagstring[3]))
 	return;
 
-    if (*complex != '\0')
-	strcat ((char *) complex, " ");
-    strcat ((char *) complex, "otlayout:");
-    strcat ((char *) complex, (char *) tagstring);
+    if (*complex_ != '\0')
+	strcat ((char *) complex_, " ");
+    strcat ((char *) complex_, "otlayout:");
+    strcat ((char *) complex_, (char *) tagstring);
 }
 
 static int
@@ -2856,29 +2602,30 @@ compareulong (const void *a, const void *b)
 }
 
 
-static FT_Error
-GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *script_count)
+static int
+GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags)
 {
-    FT_ULong         cur_offset, new_offset, base_offset;
+    FT_ULong   cur_offset, new_offset, base_offset;
     FT_Stream  stream = face->stream;
     FT_Error   error;
-    FT_UShort          n, p;
+    FT_UShort  n, p;
     FT_Memory  memory;
+    int        script_count;
 
-    if ( !stream )
-	return TT_Err_Invalid_Face_Handle;
+    if (!stream)
+        return 0;
 
     memory = stream->memory;
 
     if (( error = ftglue_face_goto_table( face, tabletag, stream ) ))
-	return error;
+	return 0;
 
     base_offset = ftglue_stream_pos ( stream );
 
     /* skip version */
 
     if ( ftglue_stream_seek ( stream, base_offset + 4L ) || ftglue_stream_frame_enter( stream, 2L ) )
-	return error;
+	return 0;
 
     new_offset = GET_UShort() + base_offset;
 
@@ -2886,25 +2633,24 @@ GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *scri
 
     cur_offset = ftglue_stream_pos( stream );
 
-    if ( ftglue_stream_seek( stream, new_offset ) != TT_Err_Ok )
-	return error;
+    if ( ftglue_stream_seek( stream, new_offset ) != FT_Err_Ok )
+	return 0;
 
     base_offset = ftglue_stream_pos( stream );
 
     if ( ftglue_stream_frame_enter( stream, 2L ) )
-	return error;
+	return 0;
 
-    *script_count = GET_UShort ();
+    script_count = GET_UShort ();
 
     ftglue_stream_frame_exit( stream );
 
-    *stags = ftglue_alloc(memory, *script_count * sizeof( FT_ULong ), &error);
-
-    if (error)
-	return error;
+    *stags = malloc(script_count * sizeof (FT_ULong));
+    if (!stags)
+	return 0;
 
     p = 0;
-    for ( n = 0; n < *script_count; n++ )
+    for ( n = 0; n < script_count; n++ )
     {
         if ( ftglue_stream_frame_enter( stream, 6L ) )
 	    goto Fail;
@@ -2918,28 +2664,24 @@ GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *scri
 
 	error = ftglue_stream_seek( stream, new_offset );
 
-	if ( error == TT_Err_Ok )
+	if ( error == FT_Err_Ok )
 	    p++;
 
 	(void)ftglue_stream_seek( stream, cur_offset );
     }
 
     if (!p)
-    {
-	error = TTO_Err_Invalid_SubTable;
 	goto Fail;
-    }
 
     /* sort the tag list before returning it */
-    qsort(*stags, *script_count, sizeof(FT_ULong), compareulong);
+    qsort(*stags, script_count, sizeof(FT_ULong), compareulong);
 
-    return TT_Err_Ok;
+    return script_count;
 
 Fail:
-    *script_count = 0;
-    ftglue_free( memory, *stags );
+    free(*stags);
     *stags = NULL;
-    return error;
+    return 0;
 }
 
 static FcChar8 *
@@ -2951,53 +2693,50 @@ FcFontCapabilities(FT_Face face)
     FT_ULong *gsubtags=NULL, *gpostags=NULL;
     FT_UShort gsub_count=0, gpos_count=0;
     FT_ULong maxsize;
-    FT_Memory  memory = face->stream->memory;
-    FcChar8 *complex = NULL;
+    FcChar8 *complex_ = NULL;
     int indx1 = 0, indx2 = 0;
 
     err = FT_Load_Sfnt_Table(face, TTAG_SILF, 0, 0, &len);
     issilgraphitefont = ( err == FT_Err_Ok);
 
-    if (GetScriptTags(face, TTAG_GPOS, &gpostags, &gpos_count) != FT_Err_Ok)
-	gpos_count = 0;
-    if (GetScriptTags(face, TTAG_GSUB, &gsubtags, &gsub_count) != FT_Err_Ok)
-	gsub_count = 0;
-    
+    gpos_count = GetScriptTags(face, TTAG_GPOS, &gpostags);
+    gsub_count = GetScriptTags(face, TTAG_GSUB, &gsubtags);
+
     if (!issilgraphitefont && !gsub_count && !gpos_count)
     	goto bail;
 
-    maxsize = (((FT_ULong) gpos_count + (FT_ULong) gsub_count) * OTLAYOUT_LEN + 
+    maxsize = (((FT_ULong) gpos_count + (FT_ULong) gsub_count) * OTLAYOUT_LEN +
 	       (issilgraphitefont ? 13 : 0));
-    complex = malloc (sizeof (FcChar8) * maxsize);
-    if (!complex)
+    complex_ = malloc (sizeof (FcChar8) * maxsize);
+    if (!complex_)
 	goto bail;
 
-    complex[0] = '\0';
+    complex_[0] = '\0';
     if (issilgraphitefont)
-        strcpy((char *) complex, "ttable:Silf ");
+        strcpy((char *) complex_, "ttable:Silf ");
 
     while ((indx1 < gsub_count) || (indx2 < gpos_count)) {
 	if (indx1 == gsub_count) {
-	    addtag(complex, gpostags[indx2]);
+	    addtag(complex_, gpostags[indx2]);
 	    indx2++;
 	} else if ((indx2 == gpos_count) || (gsubtags[indx1] < gpostags[indx2])) {
-	    addtag(complex, gsubtags[indx1]);
+	    addtag(complex_, gsubtags[indx1]);
 	    indx1++;
 	} else if (gsubtags[indx1] == gpostags[indx2]) {
-	    addtag(complex, gsubtags[indx1]);
+	    addtag(complex_, gsubtags[indx1]);
 	    indx1++;
 	    indx2++;
 	} else {
-	    addtag(complex, gpostags[indx2]);
+	    addtag(complex_, gpostags[indx2]);
 	    indx2++;
 	}
     }
     if (FcDebug () & FC_DBG_SCANV)
-	printf("complex features in this font: %s\n", complex);
+	printf("complex_ features in this font: %s\n", complex_);
 bail:
-    ftglue_free(memory, gsubtags);
-    ftglue_free(memory, gpostags);
-    return complex;
+    free(gsubtags);
+    free(gpostags);
+    return complex_;
 }
 
 #define __fcfreetype__