Various GCC 4 cleanups for signed vs unsigned char

Match only [0-9]*.conf files in <include>{directory}</include> elements to
    avoid loading *.rpmsave or .dpkg-old files. (otaylor)

diff --git a/ChangeLog b/ChangeLog
index d3d9a81..64ea29c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,22 @@
+2005-07-25  Keith Packard  <keithp@keithp.com>
+
+       * doc/fontconfig-user.sgml:
+       * fc-glyphname/fc-glyphname.c: (scan), (main):
+       * fc-lang/fc-lang.c: (FcConfigHome):
+       * fc-match/fc-match.c: (main):
+       * src/fccfg.c: (FcConfigHome):
+       * src/fcfreetype.c: (FcSfntNameTranscode), (FcSfntNameLanguage),
+       (FcVendorMatch), (FcFreeTypeQuery), (FcFreeTypeCharSetAndSpacing),
+       (addtag), (FcFontCapabilities):
+       * src/fcpat.c: (FcValueListEntCreate):
+       * src/fcstr.c: (FcStrCaseWalkerInit):
+       * src/fcxml.c: (FcParsePatelt), (FcConfigParseAndLoadDir):
+
+       Various GCC 4 cleanups for signed vs unsigned char
+
+       Match only [0-9]*.conf files in <include>{directory}</include>
+       elements to avoid loading *.rpmsave or .dpkg-old files. (otaylor)
+
 2005-07-15  Carl Worth  <cworth@cworth.org>
 
        * src/fcint.h:

diff --git a/doc/fontconfig-user.sgml b/doc/fontconfig-user.sgml
index 11a13e2..5e240dd 100644 (file)
--- a/doc/fontconfig-user.sgml
+++ b/doc/fontconfig-user.sgml
@@ -276,8 +276,8 @@ file version number (currently 1).
   </para></refsect2>
   <refsect2><title><sgmltag>include ignore_missing="no"</></title><para>
 This element contains the name of an additional configuration file or
-directory.  If a directory, every file within that directory starting with a
-number will be processed in sorted order.  When
+directory.  If a directory, every file within that directory starting with an
+ASCII digit (U+0030 - U+0039) and ending with the string ``.conf'' will be processed in sorted order.  When
 the XML datatype is traversed by FcConfigParse, the contents of the file(s)
 will also be incorporated into the configuration by passing the filename(s) to
 FcConfigLoadAndParse.  If 'ignore_missing' is set to "yes" instead of the

diff --git a/fc-glyphname/fc-glyphname.c b/fc-glyphname/fc-glyphname.c
index 5b38c72..2c69c2b 100644 (file)
--- a/fc-glyphname/fc-glyphname.c
+++ b/fc-glyphname/fc-glyphname.c
@@ -105,7 +105,7 @@ scan (FILE *f, char *filename)
        gn = FcAllocGlyphName ((FcChar32) ucs, (FcChar8 *) name);
        if (!gn)
            fatal (filename, lineno, "out of memory");
-       len = strlen ((FcChar8 *) name);
+       len = strlen (name);
        if (len > max_name_len)
            max_name_len = len;
        raw[nraw++] = gn;
@@ -286,7 +286,7 @@ main (int argc, char **argv)
     for (i = 0; i < nraw; i++)
        printf ("static struct { FcChar32 ucs; FcChar8 name[%d]; }"
                " glyph%d = { 0x%lx, \"%s\" };\n",
-               (int) strlen (raw[i]->name) + 1,
+               (int) strlen ((char *) raw[i]->name) + 1,
                i, (unsigned long) raw[i]->ucs, raw[i]->name);
 
     /*

diff --git a/fc-lang/fc-lang.c b/fc-lang/fc-lang.c
index e88d75f..75e92f7 100644 (file)
--- a/fc-lang/fc-lang.c
+++ b/fc-lang/fc-lang.c
@@ -50,7 +50,7 @@ FcMemFree (int kind, int size)
 FcChar8 *
 FcConfigHome (void)
 {
-    return getenv ("HOME");
+    return (FcChar8 *) getenv ("HOME");
 }
 
 static void 

diff --git a/fc-match/fc-match.c b/fc-match/fc-match.c
index 961a7a9..2a79722 100644 (file)
--- a/fc-match/fc-match.c
+++ b/fc-match/fc-match.c
@@ -167,17 +167,17 @@ main (int argc, char **argv)
                FcChar8 *file;
 
                if (FcPatternGetString (fs->fonts[j], FC_FILE, 0, &file) != FcResultMatch)
-                   file = "<unknown filename>";
+                   file = (FcChar8 *) "<unknown filename>";
                else
                {
-                   FcChar8 *slash = strrchr (file, '/');
+                   FcChar8 *slash = (FcChar8 *) strrchr ((char *) file, '/');
                    if (slash)
                        file = slash+1;
                }
                if (FcPatternGetString (fs->fonts[j], FC_FAMILY, 0, &family) != FcResultMatch)
-                   family = "<unknown family>";
+                   family = (FcChar8 *) "<unknown family>";
                if (FcPatternGetString (fs->fonts[j], FC_STYLE, 0, &style) != FcResultMatch)
-                   file = "<unknown style>";
+                   file = (FcChar8 *) "<unknown style>";
 
                printf ("%s: \"%s\" \"%s\"\n", file, family, style);
            }

diff --git a/src/fccfg.c b/src/fccfg.c
index 84c21e7..59137ca 100644 (file)
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -1607,7 +1607,7 @@ FcConfigHome (void)
            home = getenv ("USERPROFILE");
 #endif
 
-       return home;
+       return (FcChar8 *) home;
     }
     return 0;
 }

diff --git a/src/fcfreetype.c b/src/fcfreetype.c
index ee4af40..979a173 100644 (file)
--- a/src/fcfreetype.c
+++ b/src/fcfreetype.c
@@ -733,7 +733,7 @@ FcSfntNameTranscode (FT_SfntName *sname)
 #endif
     return 0;
 done:
-    if (FcStrCmpIgnoreBlanksAndCase (utf8, "") == 0)
+    if (FcStrCmpIgnoreBlanksAndCase (utf8, (FcChar8 *) "") == 0)
     {
        free (utf8);
        return 0;
@@ -749,7 +749,7 @@ FcSfntNameLanguage (FT_SfntName *sname)
        if (fcFtLanguage[i].platform_id == sname->platform_id &&
            (fcFtLanguage[i].language_id == TT_LANGUAGE_DONT_CARE ||
             fcFtLanguage[i].language_id == sname->language_id))
-           return fcFtLanguage[i].lang;
+           return (FcChar8 *) fcFtLanguage[i].lang;
     return 0;
 }
 
@@ -801,7 +801,7 @@ FcVendorMatch(const FT_Char vendor[4], const FT_Char *vendor_string)
     /* vendor is not necessarily NUL-terminated. */
     int i, len;
     
-    len = strlen(vendor_string);
+    len = strlen((char *) vendor_string);
     if (memcmp(vendor, vendor_string, len) != 0)
         return FcFalse;
     for (i = len; i < 4; i++)
@@ -895,23 +895,25 @@ FcStringContainsConst (const FcChar8          *string,
     return -1;
 }
 
+typedef FcChar8 *FC8;
+
 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 },
+    { (FC8) "thin",            FC_WEIGHT_THIN },
+    { (FC8) "extralight",      FC_WEIGHT_EXTRALIGHT },
+    { (FC8) "ultralight",      FC_WEIGHT_ULTRALIGHT },
+    { (FC8) "light",           FC_WEIGHT_LIGHT },
+    { (FC8) "book",            FC_WEIGHT_BOOK },
+    { (FC8) "regular",         FC_WEIGHT_REGULAR },
+    { (FC8) "normal",          FC_WEIGHT_NORMAL },
+    { (FC8) "medium",          FC_WEIGHT_MEDIUM },
+    { (FC8) "demibold",                FC_WEIGHT_DEMIBOLD },
+    { (FC8) "demi",            FC_WEIGHT_DEMIBOLD },
+    { (FC8) "semibold",                FC_WEIGHT_SEMIBOLD },
+    { (FC8) "bold",            FC_WEIGHT_BOLD },
+    { (FC8) "extrabold",       FC_WEIGHT_EXTRABOLD },
+    { (FC8) "ultrabold",       FC_WEIGHT_ULTRABOLD },
+    { (FC8) "black",           FC_WEIGHT_BLACK },
+    { (FC8) "heavy",           FC_WEIGHT_HEAVY },
 };
 
 #define NUM_WEIGHT_CONSTS  (sizeof (weightConsts) / sizeof (weightConsts[0]))
@@ -920,15 +922,15 @@ static const FcStringConst  weightConsts[] = {
 #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 */
+    { (FC8) "ultracondensed",  FC_WIDTH_ULTRACONDENSED },
+    { (FC8) "extracondensed",  FC_WIDTH_EXTRACONDENSED },
+    { (FC8) "semicondensed",   FC_WIDTH_SEMICONDENSED },
+    { (FC8) "condensed",       FC_WIDTH_CONDENSED },   /* must be after *condensed */
+    { (FC8) "normal",          FC_WIDTH_NORMAL },
+    { (FC8) "semiexpanded",    FC_WIDTH_SEMIEXPANDED },
+    { (FC8) "extraexpanded",   FC_WIDTH_EXTRAEXPANDED },
+    { (FC8) "ultraexpanded",   FC_WIDTH_ULTRAEXPANDED },
+    { (FC8) "expanded",                FC_WIDTH_EXPANDED },    /* must be after *expanded */
 };
 
 #define NUM_WIDTH_CONSTS    (sizeof (widthConsts) / sizeof (widthConsts[0]))
@@ -937,8 +939,8 @@ static const FcStringConst  widthConsts[] = {
 #define FcContainsWidth(s)  FcStringContainsConst (s,widthConsts,NUM_WIDTH_CONSTS)
 
 static const FcStringConst  slantConsts[] = {
-    { "italic",                FC_SLANT_ITALIC },
-    { "oblique",       FC_SLANT_OBLIQUE },
+    { (FC8) "italic",          FC_SLANT_ITALIC },
+    { (FC8) "oblique",         FC_SLANT_OBLIQUE },
 };
 
 #define NUM_SLANT_CONSTS    (sizeof (slantConsts) / sizeof (slantConsts[0]))
@@ -1154,7 +1156,7 @@ FcFreeTypeQuery (const FcChar8    *file,
                /* pad lang list with 'xx' to line up with elt */
                while (*nlangp < *np)
                {
-                   if (!FcPatternAddString (pat, eltlang, "xx"))
+                   if (!FcPatternAddString (pat, eltlang, (FcChar8 *) "xx"))
                        goto bail1;
                    ++*nlangp;
                }
@@ -1169,21 +1171,21 @@ FcFreeTypeQuery (const FcChar8  *file,
     }
     
     if (!nfamily && face->family_name && 
-       FcStrCmpIgnoreBlanksAndCase (face->family_name, "") != 0)
+       FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->family_name, (FcChar8 *) "") != 0)
     {
        if (FcDebug () & FC_DBG_SCANV)
            printf ("using FreeType family \"%s\"\n", face->family_name);
-       if (!FcPatternAddString (pat, FC_FAMILY, face->family_name))
+       if (!FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) face->family_name))
            goto bail1;
        ++nfamily;
     }
     
     if (!nstyle && face->style_name &&
-       FcStrCmpIgnoreBlanksAndCase (face->style_name, "") != 0)
+       FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->style_name, (FcChar8 *) "") != 0)
     {
        if (FcDebug () & FC_DBG_SCANV)
            printf ("using FreeType style \"%s\"\n", face->style_name);
-       if (!FcPatternAddString (pat, FC_STYLE, face->style_name))
+       if (!FcPatternAddString (pat, FC_STYLE, (FcChar8 *) face->style_name))
            goto bail1;
        ++nstyle;
     }
@@ -1400,7 +1402,7 @@ FcFreeTypeQuery (const FcChar8    *file,
     {
        if (weight == -1 && psfontinfo.weight)
        {
-           weight = FcIsWeight (psfontinfo.weight);
+           weight = FcIsWeight ((FcChar8 *) psfontinfo.weight);
            if (FcDebug() & FC_DBG_SCANV)
                printf ("\tType1 weight %s maps to %d\n",
                        psfontinfo.weight, weight);
@@ -1434,7 +1436,7 @@ FcFreeTypeQuery (const FcChar8    *file,
        BDF_PropertyRec prop;
        rc = MY_Get_BDF_Property(face, "FOUNDRY", &prop);
        if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM)
-           foundry = prop.u.atom;
+           foundry = (FcChar8 *) prop.u.atom;
     }
 
     if (width == -1)
@@ -1465,7 +1467,7 @@ FcFreeTypeQuery (const FcChar8    *file,
            MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
            prop.type == BDF_PROPERTY_TYPE_ATOM)
        {
-           width = FcIsWidth (prop.u.atom);
+           width = FcIsWidth ((FcChar8 *) prop.u.atom);
            if (FcDebug () & FC_DBG_SCANV)
                printf ("\tsetwidth %s maps to %d\n", prop.u.atom, width);
        }
@@ -1518,7 +1520,7 @@ FcFreeTypeQuery (const FcChar8    *file,
        width = FC_WIDTH_NORMAL;
 
     if (foundry == 0)
-       foundry = "unknown";
+       foundry = (FcChar8 *) "unknown";
 
     if (!FcPatternAddInteger (pat, FC_SLANT, slant))
        goto bail1;
@@ -1629,7 +1631,7 @@ FcFreeTypeQuery (const FcChar8    *file,
     {
        const char *font_format = FT_Get_X11_Font_Format (face);
        if (font_format)
-           FcPatternAddString (pat, FC_FONTFORMAT, font_format);
+           FcPatternAddString (pat, FC_FONTFORMAT, (FcChar8 *) font_format);
     }
 #endif
 
@@ -2453,22 +2455,33 @@ FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
                if (glyph && 
                    FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
                {
-                   if (!has_advance)
+                   /* 
+                    * ignore glyphs with zero advance. They’re
+                    * combining characters, and while their behaviour
+                    * isn’t well defined for monospaced applications in
+                    * Unicode, there are many fonts which include
+                    * zero-width combining characters in otherwise
+                    * monospaced fonts.
+                    */
+                   if (advance)
                    {
-                       has_advance = FcTrue;
-                       advance_one = advance;
+                       if (!has_advance)
+                       {
+                           has_advance = FcTrue;
+                           advance_one = advance;
+                       }
+                       else if (!APPROXIMATELY_EQUAL (advance, advance_one))
+                       {
+                           if (fixed_advance)
+                           {
+                               dual_advance = FcTrue;
+                               fixed_advance = FcFalse;
+                               advance_two = advance;
+                           }
+                           else if (!APPROXIMATELY_EQUAL (advance, advance_two))
+                               dual_advance = FcFalse;
+                       }
                    }
-                   else if (!APPROXIMATELY_EQUAL (advance, advance_one))
-                    {
-                        if (fixed_advance)
-                        {
-                            dual_advance = FcTrue;
-                            fixed_advance = FcFalse;
-                            advance_two = advance;
-                        }
-                        else if (!APPROXIMATELY_EQUAL (advance, advance_two))
-                            dual_advance = FcFalse;
-                    }
 
                    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
                    if (!leaf)
@@ -2511,22 +2524,25 @@ FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
                    if (glyph && FcFreeTypeCheckGlyph (face, ucs4, 
                                                       glyph, blanks, &advance))
                    {
-                       if (!has_advance)
+                       if (advance)
                        {
-                           has_advance = FcTrue;
-                           advance_one = advance;
+                           if (!has_advance)
+                           {
+                               has_advance = FcTrue;
+                               advance_one = advance;
+                           }
+                           else if (!APPROXIMATELY_EQUAL (advance, advance_one))
+                           {
+                               if (fixed_advance)
+                               {
+                                   dual_advance = FcTrue;
+                                   fixed_advance = FcFalse;
+                                   advance_two = advance;
+                               }
+                               else if (!APPROXIMATELY_EQUAL (advance, advance_two))
+                                   dual_advance = FcFalse;
+                           }
                        }
-                       else if (!APPROXIMATELY_EQUAL (advance, advance_one))
-                        {
-                            if (fixed_advance)
-                            {
-                                dual_advance = FcTrue;
-                                fixed_advance = FcFalse;
-                                advance_two = advance;
-                            }
-                            else if (!APPROXIMATELY_EQUAL (advance, advance_two))
-                                dual_advance = FcFalse;
-                        }
 
                        if (!leaf)
                        {
@@ -2578,22 +2594,25 @@ FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
                if (ucs4 != 0xffff && 
                    FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
                {
-                   if (!has_advance)
+                   if (advance)
                    {
-                       has_advance = FcTrue;
-                       advance_one = advance;
+                       if (!has_advance)
+                       {
+                           has_advance = FcTrue;
+                           advance_one = advance;
+                       }
+                       else if (!APPROXIMATELY_EQUAL (advance, advance_one))
+                       {
+                           if (fixed_advance)
+                           {
+                               dual_advance = FcTrue;
+                               fixed_advance = FcFalse;
+                               advance_two = advance;
+                           }
+                           else if (!APPROXIMATELY_EQUAL (advance, advance_two))
+                               dual_advance = FcFalse;
+                       }
                    }
-                   else if (!APPROXIMATELY_EQUAL (advance, advance_one))
-                    {
-                        if (fixed_advance)
-                        {
-                            dual_advance = FcTrue;
-                            fixed_advance = FcFalse;
-                            advance_two = advance;
-                        }
-                        else if (!APPROXIMATELY_EQUAL (advance, advance_two))
-                            dual_advance = FcFalse;
-                    }
                    leaf = FcCharSetFindLeafCreate (fcs, ucs4);
                    if (!leaf)
                        goto bail1;
@@ -2689,9 +2708,9 @@ addtag(FcChar8 *complex, FT_ULong tag)
        return;
 
     if (*complex != '\0')
-       strcat (complex, " ");
-    strcat (complex, "otlayout:");
-    strcat (complex, tagstring);
+       strcat ((char *) complex, " ");
+    strcat ((char *) complex, "otlayout:");
+    strcat ((char *) complex, (char *) tagstring);
 }
 
 static int
@@ -2820,7 +2839,7 @@ FcFontCapabilities(FT_Face face)
 
     complex[0] = '\0';
     if (issilgraphitefont)
-        strcpy(complex, "ttable:Silf ");
+        strcpy((char *) complex, "ttable:Silf ");
 
     while ((indx1 < gsub_count) || (indx2 < gpos_count)) {
        if (indx1 == gsub_count) {

diff --git a/src/fcpat.c b/src/fcpat.c
index 254faae..2a21a13 100644 (file)
--- a/src/fcpat.c
+++ b/src/fcpat.c
@@ -341,7 +341,7 @@ FcValueListEntCreate (FcValueList *h)
        if (l->value.type == FcTypeString)
        {
            new->value.type = FcTypeString;
-           new->value.u.s = FcObjectStaticName (l->value.u.s);
+           new->value.u.s = (FcChar8 *) FcObjectStaticName ((char *) l->value.u.s);
        }
        else
        {

diff --git a/src/fcstr.c b/src/fcstr.c
index 730e440..fb715a4 100644 (file)
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -83,7 +83,7 @@ FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)
 {
     w->src = src;
     w->read = 0;
-    w->len = strlen (src);
+    w->len = strlen ((char *) src);
 }
 
 static FcChar8

diff --git a/src/fcxml.c b/src/fcxml.c
index 4176c73..7a48628 100644 (file)
--- a/src/fcxml.c
+++ b/src/fcxml.c
@@ -1926,7 +1926,7 @@ FcParsePatelt (FcConfigParse *parse)
        return;
     }
 
-    name = FcConfigGetAttribute (parse, "name");
+    name = (char *) FcConfigGetAttribute (parse, "name");
     if (!name)
     {
        FcConfigMessage (parse, FcSevereWarning, "missing pattern element name");
@@ -2264,11 +2264,16 @@ FcConfigParseAndLoadDir (FcConfig       *config,
        
     while (ret && (e = readdir (d)))
     {
+       int d_len;
+#define TAIL       ".conf"
+#define TAIL_LEN    5
        /*
-        * Add all files of the form [0-9]*
+        * Add all files of the form [0-9]*.conf
         */
        if ('0' <= e->d_name[0] && e->d_name[0] <= '9' &&
-           strlen (e->d_name) < FC_MAX_FILE_LEN)
+           (d_len = strlen (e->d_name)) < FC_MAX_FILE_LEN &&
+           d_len > TAIL_LEN &&
+           strcmp (e->d_name + d_len - TAIL_LEN, TAIL) == 0)
        {
            strcpy ((char *) base, (char *) e->d_name);
            if (!FcStrSetAdd (files, file))