aboutsummaryrefslogtreecommitdiff
path: root/x11-fonts
diff options
context:
space:
mode:
authorJoe Marcus Clarke <marcus@FreeBSD.org>2003-07-18 22:02:56 +0000
committerJoe Marcus Clarke <marcus@FreeBSD.org>2003-07-18 22:02:56 +0000
commita844a8e778fc85174cbd550a335f31325f4c09ca (patch)
tree200b895104e1299b66fce94a2a9d34e4ffbe6741 /x11-fonts
parent4625bdd7f2f9cadb2b984706326ea5e86fa4be92 (diff)
downloadports-a844a8e778fc85174cbd550a335f31325f4c09ca.tar.gz
ports-a844a8e778fc85174cbd550a335f31325f4c09ca.zip
Revert some of the FreeType code in fontconfig to fix some font rendering
issues with Adboe fonts (particularly Helvetica and Times). Reported by: many
Notes
Notes: svn path=/head/; revision=85152
Diffstat (limited to 'x11-fonts')
-rw-r--r--x11-fonts/fontconfig/Makefile2
-rw-r--r--x11-fonts/fontconfig/files/patch_src_fcfreetype.c643
2 files changed, 644 insertions, 1 deletions
diff --git a/x11-fonts/fontconfig/Makefile b/x11-fonts/fontconfig/Makefile
index 45b49afe6c45..f44f7b836d41 100644
--- a/x11-fonts/fontconfig/Makefile
+++ b/x11-fonts/fontconfig/Makefile
@@ -7,7 +7,7 @@
PORTNAME= fontconfig
PORTVERSION= 2.2.90
-PORTREVISION= 1
+PORTREVISION= 2
CATEGORIES= x11-fonts
MASTER_SITES= http://www.fontconfig.org/release/ \
http://nexp.cs.pdx.edu/fontconfig/release/
diff --git a/x11-fonts/fontconfig/files/patch_src_fcfreetype.c b/x11-fonts/fontconfig/files/patch_src_fcfreetype.c
new file mode 100644
index 000000000000..7e9f4730055e
--- /dev/null
+++ b/x11-fonts/fontconfig/files/patch_src_fcfreetype.c
@@ -0,0 +1,643 @@
+--- src/fcfreetype.c.orig Fri Jul 18 17:54:08 2003
++++ src/fcfreetype.c Fri Jul 18 17:54:12 2003
+@@ -255,87 +255,6 @@
+ return 0;
+ }
+
+-typedef struct _FcStringConst {
+- const char *name;
+- int value;
+-} FcStringConst;
+-
+-static int
+-FcStringIsConst (const FcChar8 *string,
+- const FcStringConst *c,
+- int nc)
+-{
+- int i;
+-
+- for (i = 0; i < nc; i++)
+- if (FcStrCmpIgnoreBlanksAndCase (string, c[i].name) == 0)
+- return c[i].value;
+- return -1;
+-}
+-
+-static int
+-FcStringContainsConst (const FcChar8 *string,
+- const FcStringConst *c,
+- int nc)
+-{
+- int i;
+-
+- for (i = 0; i < nc; i++)
+- if (FcStrContainsIgnoreBlanksAndCase (string, c[i].name))
+- return c[i].value;
+- return -1;
+-}
+-
+-static const FcStringConst weightConsts[] = {
+- { "thin", FC_WEIGHT_THIN },
+- { "extralight", FC_WEIGHT_EXTRALIGHT },
+- { "ultralight", FC_WEIGHT_ULTRALIGHT },
+- { "light", FC_WEIGHT_LIGHT },
+- { "book", FC_WEIGHT_BOOK },
+- { "regular", FC_WEIGHT_REGULAR },
+- { "normal", FC_WEIGHT_NORMAL },
+- { "medium", FC_WEIGHT_MEDIUM },
+- { "demibold", FC_WEIGHT_DEMIBOLD },
+- { "demi", 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_WEIGHT_CONSTS (sizeof (weightConsts) / sizeof (weightConsts[0]))
+-
+-#define FcIsWeight(s) FcStringIsConst(s,weightConsts,NUM_WEIGHT_CONSTS)
+-#define FcContainsWeight(s) FcStringContainsConst (s,weightConsts,NUM_WEIGHT_CONSTS)
+-
+-static const FcStringConst widthConsts[] = {
+- { "ultracondensed", FC_WIDTH_ULTRACONDENSED },
+- { "extracondensed", FC_WIDTH_EXTRACONDENSED },
+- { "semicondensed", FC_WIDTH_SEMICONDENSED },
+- { "condensed", FC_WIDTH_CONDENSED }, /* must be after *condensed */
+- { "normal", FC_WIDTH_NORMAL },
+- { "semiexpanded", FC_WIDTH_SEMIEXPANDED },
+- { "extraexpanded", FC_WIDTH_EXTRAEXPANDED },
+- { "ultraexpanded", FC_WIDTH_ULTRAEXPANDED },
+- { "expanded", FC_WIDTH_EXPANDED }, /* must be after *expanded */
+-};
+-
+-#define NUM_WIDTH_CONSTS (sizeof (widthConsts) / sizeof (widthConsts[0]))
+-
+-#define FcIsWidth(s) FcStringIsConst(s,widthConsts,NUM_WIDTH_CONSTS)
+-#define FcContainsWidth(s) FcStringContainsConst (s,widthConsts,NUM_WIDTH_CONSTS)
+-
+-static const FcStringConst slantConsts[] = {
+- { "italic", FC_SLANT_ITALIC },
+- { "oblique", FC_SLANT_OBLIQUE },
+-};
+-
+-#define NUM_SLANT_CONSTS (sizeof (slantConsts) / sizeof (slantConsts[0]))
+-
+-#define FcIsSlant(s) FcStringIsConst(s,slantConsts,NUM_SLANT_CONSTS)
+-#define FcContainsSlant(s) FcStringContainsConst (s,slantConsts,NUM_SLANT_CONSTS)
+
+ FcPattern *
+ FcFreeTypeQuery (const FcChar8 *file,
+@@ -345,8 +264,8 @@
+ {
+ FT_Face face;
+ FcPattern *pat;
+- int slant = -1;
+- int weight = -1;
++ int slant;
++ int weight;
+ int width = -1;
+ int i;
+ FcCharSet *cs;
+@@ -358,9 +277,6 @@
+ int spacing;
+ TT_OS2 *os2;
+ PS_FontInfoRec psfontinfo;
+-#ifdef USE_FTBDF
+- BDF_PropertyRec prop;
+-#endif
+ TT_Header *head;
+ const FcChar8 *exclusiveLang = 0;
+ FT_SfntName sname;
+@@ -391,6 +307,15 @@
+ goto bail1;
+
+
++ slant = FC_SLANT_ROMAN;
++ if (face->style_flags & FT_STYLE_FLAG_ITALIC)
++ slant = FC_SLANT_ITALIC;
++
++
++ weight = FC_WEIGHT_MEDIUM;
++ if (face->style_flags & FT_STYLE_FLAG_BOLD)
++ weight = FC_WEIGHT_BOLD;
++
+ /*
+ * Get the OS/2 table
+ */
+@@ -673,15 +598,30 @@
+ }
+
+ if (FcDebug() & FC_DBG_SCAN)
+- printf ("\n\"%s\" \"%s\"\n", family, style ? style : (FcChar8 *) "<none>");
++ printf ("\"%s\" \"%s\" ", family, style ? style : (FcChar8 *) "<none>");
+
+ if (!FcPatternAddString (pat, FC_FAMILY, family))
++ {
++ if (family_allocated)
++ free (family);
++ if (style_allocated)
++ free (style);
+ goto bail1;
++ }
++
++ if (family_allocated)
++ free (family);
+
+ if (style)
+ {
+ if (!FcPatternAddString (pat, FC_STYLE, style))
++ {
++ if (style_allocated)
++ free (style);
+ goto bail1;
++ }
++ if (style_allocated)
++ free (style);
+ }
+
+ if (!FcPatternAddString (pat, FC_FILE, file))
+@@ -755,7 +695,7 @@
+ 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)
+@@ -774,6 +714,8 @@
+ 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;
+@@ -795,12 +737,36 @@
+
+ if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
+ {
+- if (weight == -1 && psfontinfo.weight)
++ if (psfontinfo.weight)
+ {
+- weight = FcIsWeight (psfontinfo.weight);
+- if (FcDebug() & FC_DBG_SCANV)
+- printf ("\tType1 weight %s maps to %d\n",
+- psfontinfo.weight, 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
+@@ -808,9 +774,9 @@
+ * Don't bother with italic_angle; FreeType already extracts that
+ * information for us and sticks it into style_flags
+ */
+- if (psfontinfo.italic_angle)
++ if (psfontinfo.italic_angle < 0)
+ slant = FC_SLANT_ITALIC;
+- else
++ else if (psfontinfo.italic_angle >= 0)
+ slant = FC_SLANT_ROMAN;
+ #endif
+
+@@ -835,6 +801,7 @@
+
+ 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))
+@@ -857,60 +824,33 @@
+ case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
+ }
+ }
+- if (width == -1 &&
+- MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
+- prop.type == BDF_PROPERTY_TYPE_ATOM)
++ else if (MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
++ prop.type == BDF_PROPERTY_TYPE_ATOM)
+ {
+- width = FcIsWidth (prop.u.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 ("\tsetwidth %s maps to %d\n", prop.u.atom, width);
++ 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
+
+- /*
+- * Look for weight, width and slant names in the style value
+- */
+- if (style)
+- {
+- if (weight == -1)
+- {
+- weight = FcContainsWeight (style);
+- if (FcDebug() & FC_DBG_SCANV)
+- printf ("\tStyle %s maps to weight %d\n", style, weight);
+- }
+- if (width == -1)
+- {
+- width = FcContainsWidth (style);
+- if (FcDebug() & FC_DBG_SCANV)
+- printf ("\tStyle %s maps to width %d\n", style, width);
+- }
+- if (slant == -1)
+- {
+- slant = FcContainsSlant (style);
+- if (FcDebug() & FC_DBG_SCANV)
+- printf ("\tStyle %s maps to slant %d\n", style, slant);
+- }
+- }
+- /*
+- * Pull default values from the FreeType flags if more
+- * specific values not found above
+- */
+- if (slant == -1)
+- {
+- slant = FC_SLANT_ROMAN;
+- if (face->style_flags & FT_STYLE_FLAG_ITALIC)
+- slant = FC_SLANT_ITALIC;
+- }
+-
+- if (weight == -1)
+- {
+- weight = FC_WEIGHT_MEDIUM;
+- if (face->style_flags & FT_STYLE_FLAG_BOLD)
+- weight = FC_WEIGHT_BOLD;
+- }
+-
+ if (!FcPatternAddInteger (pat, FC_SLANT, slant))
+ goto bail1;
+
+@@ -934,20 +874,6 @@
+ if (!cs)
+ goto bail1;
+
+-#ifdef USE_FTBDF
+- /* For PCF fonts, override the computed spacing with the one from
+- the property */
+- if(MY_Get_BDF_Property(face, "SPACING", &prop) == 0 &&
+- prop.type == BDF_PROPERTY_TYPE_ATOM) {
+- if(strcmp(prop.u.atom, "c") || strcmp(prop.u.atom, "C"))
+- spacing = FC_CHARCELL;
+- else if(strcmp(prop.u.atom, "m") || strcmp(prop.u.atom, "M"))
+- spacing = FC_MONO;
+- else if(strcmp(prop.u.atom, "p") || strcmp(prop.u.atom, "P"))
+- spacing = FC_PROPORTIONAL;
+- }
+-#endif
+-
+ /*
+ * Skip over PCF fonts that have no encoded characters; they're
+ * usually just Unicode fonts transcoded to some legacy encoding
+@@ -966,17 +892,17 @@
+ goto bail2;
+
+ if (!FcPatternAddLangSet (pat, FC_LANG, ls))
+- {
+- FcLangSetDestroy (ls);
+ goto bail2;
+- }
+-
+- FcLangSetDestroy (ls);
+
+ if (spacing != FC_PROPORTIONAL)
+ if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
+ goto bail2;
+
++ /*
++ * Drop our reference to the charset
++ */
++ FcCharSetDestroy (cs);
++
+ if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
+ {
+ for (i = 0; i < face->num_fixed_sizes; i++)
+@@ -985,63 +911,8 @@
+ goto bail1;
+ if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
+ goto bail1;
+-#ifdef USE_FTBDF
+- if(face->num_fixed_sizes == 1) {
+- int rc;
+- int value;
+- BDF_PropertyRec prop;
+-
+- rc = MY_Get_BDF_Property(face, "PIXEL_SIZE", &prop);
+- if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
+- value = prop.u.integer;
+- else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
+- value = prop.u.cardinal;
+- else
+- goto nevermind;
+- if(value != face->available_sizes[0].height)
+- /* ``impossible'' */
+- goto nevermind;
+-
+- rc = MY_Get_BDF_Property(face, "POINT_SIZE", &prop);
+- if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
+- value = prop.u.integer;
+- else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
+- value = prop.u.cardinal;
+- else
+- goto nevermind;
+- if(!FcPatternAddDouble(pat, FC_SIZE, value / 10.0))
+- goto nevermind;
+-
+- rc = MY_Get_BDF_Property(face, "RESOLUTION_Y", &prop);
+- if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
+- value = prop.u.integer;
+- else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
+- value = prop.u.cardinal;
+- else
+- goto nevermind;
+- if(!FcPatternAddDouble(pat, FC_DPI, (double)value))
+- goto nevermind;
+-
+- }
+- nevermind:
+- ;
+-#endif
+ }
+
+- /*
+- * Drop our reference to the charset
+- */
+- FcCharSetDestroy (cs);
+-
+- /*
+- * Deallocate family/style values
+- */
+-
+- if (family_allocated)
+- free (family);
+- if (style_allocated)
+- free (style);
+-
+ FT_Done_Face (face);
+ FT_Done_FreeType (ftLibrary);
+ return pat;
+@@ -1050,10 +921,6 @@
+ FcCharSetDestroy (cs);
+ bail1:
+ FcPatternDestroy (pat);
+- if (family_allocated)
+- free (family);
+- if (style_allocated)
+- free (style);
+ bail0:
+ FT_Done_Face (face);
+ bail:
+@@ -1596,107 +1463,6 @@
+ return 0;
+ }
+
+-#include "../fc-glyphname/fcglyphname.h"
+-
+-static FcChar32
+-FcHashGlyphName (const FcChar8 *name)
+-{
+- FcChar32 h = 0;
+- FcChar8 c;
+-
+- while ((c = *name++))
+- {
+- h = ((h << 1) | (h >> 31)) ^ c;
+- }
+- return h;
+-}
+-
+-/*
+- * Use Type1 glyph names for fonts which have reliable names
+- * and which export an Adobe Custom mapping
+- */
+-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++)
+- if (face->charmaps[map]->encoding == ft_encoding_adobe_custom)
+- return FcTrue;
+- return FcFalse;
+-}
+-
+-static FcChar8 *
+-FcUcs4ToGlyphName (FcChar32 ucs4)
+-{
+- int i = (int) (ucs4 % FC_GLYPHNAME_HASH);
+- int r = 0;
+- FcGlyphName *gn;
+-
+- while ((gn = ucs_to_name[i]))
+- {
+- if (gn->ucs == ucs4)
+- return gn->name;
+- if (!r)
+- {
+- r = (int) (ucs4 % FC_GLYPHNAME_REHASH);
+- if (!r)
+- r = 1;
+- }
+- i += r;
+- if (i >= FC_GLYPHNAME_HASH)
+- i -= FC_GLYPHNAME_HASH;
+- }
+- return 0;
+-}
+-
+-static FcChar32
+-FcGlyphNameToUcs4 (FcChar8 *name)
+-{
+- FcChar32 h = FcHashGlyphName (name);
+- int i = (int) (h % FC_GLYPHNAME_HASH);
+- int r = 0;
+- FcGlyphName *gn;
+-
+- while ((gn = name_to_ucs[i]))
+- {
+- if (!strcmp ((char *) name, (char *) gn->name))
+- return gn->ucs;
+- if (!r)
+- {
+- r = (int) (h % FC_GLYPHNAME_REHASH);
+- if (!r)
+- r = 1;
+- }
+- i += r;
+- if (i >= FC_GLYPHNAME_HASH)
+- i -= FC_GLYPHNAME_HASH;
+- }
+- return 0xffff;
+-}
+-
+-/*
+- * Search through a font for a glyph by name. This is
+- * currently a linear search as there doesn't appear to be
+- * any defined order within the font
+- */
+-static FT_UInt
+-FcFreeTypeGlyphNameIndex (FT_Face face, FcChar8 *name)
+-{
+- FT_UInt gindex;
+- FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
+-
+- for (gindex = 0; gindex < face->num_glyphs; gindex++)
+- {
+- if (FT_Get_Glyph_Name (face, gindex, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
+- if (!strcmp ((char *) name, (char *) name_buf))
+- return gindex;
+- }
+- 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
+@@ -1743,19 +1509,6 @@
+ if (glyphindex)
+ return glyphindex;
+ }
+- /*
+- * Check postscript name table if present
+- */
+- if (FcFreeTypeUseNames (face))
+- {
+- FcChar8 *name = FcUcs4ToGlyphName (ucs4);
+- if (name)
+- {
+- glyphindex = FcFreeTypeGlyphNameIndex (face, name);
+- if (glyphindex)
+- return glyphindex;
+- }
+- }
+ return 0;
+ }
+
+@@ -1764,7 +1517,7 @@
+ FT_UInt glyph, FcBlanks *blanks,
+ FT_Pos *advance)
+ {
+- FT_Int load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
++ FT_Int load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+ FT_GlyphSlot slot;
+
+ /*
+@@ -1835,9 +1588,6 @@
+ if (!fcs)
+ goto bail0;
+
+-#ifdef CHECK
+- printf ("Family %s style %s\n", face->family_name, face->style_name);
+-#endif
+ for (o = 0; o < NUM_DECODE; o++)
+ {
+ if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
+@@ -1945,54 +1695,15 @@
+ #endif
+ }
+ }
+- /*
+- * Add mapping from PS glyph names if available
+- */
+- if (FcFreeTypeUseNames (face))
+- {
+- FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
+-
+- for (glyph = 0; glyph < face->num_glyphs; glyph++)
+- {
+- if (FT_Get_Glyph_Name (face, glyph, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
+- {
+- ucs4 = FcGlyphNameToUcs4 (name_buf);
+- if (ucs4 != 0xffff &&
+- 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
+- }
+- }
+- }
+- }
+ #ifdef CHECK
+ printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
+ for (ucs4 = 0; ucs4 <= font_max; ucs4++)
+ {
+- FcBool has_char = (glyph = FcFreeTypeCharIndex (face, ucs4)) != 0;
++ FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
+ FcBool has_bit = FcCharSetHasChar (fcs, ucs4);
+
+ if (has_char && !has_bit)
+- {
+- if (!FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
+- printf ("Bitmap missing broken char 0x%x\n", ucs4);
+- else
+- printf ("Bitmap missing char 0x%x\n", ucs4);
+- }
++ printf ("Bitmap missing char 0x%x\n", ucs4);
+ else if (!has_char && has_bit)
+ printf ("Bitmap extra char 0x%x\n", ucs4);
+ }