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 d3d9a8197dbff1f7cbd0d9fb82d141a6b71d3ce8..64ea29c1ffd0fc4806c7f3a9c16791f90d4cfeac 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 11a13e2b515ff81d814fe3cbe19cdd17a4e07b7b..5e240ddd14ee841bd6c6b628506b21e5904efcb9 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 5b38c72c832d7bc56763ddda38b190c19f0a0ed9..2c69c2b407dbbbf1785cabcd5e58cba4f71657d7 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 e88d75fe0ccb8a0b6e4654543710d6638c7ddc49..75e92f77581a729dc1f278b72edd20289e1a6d20 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 961a7a959e4a77c5342136d3f44135288d54663c..2a7972275423b4e4f97af080ce8714d137337a32 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 84c21e791c43ac145909d300291e8a6443048173..59137ca35884fcc34dc1f372b6b69b7b68e77cac 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 ee4af405644f847d25c191febe537831496e5642..979a17300fb7b5d9448ff0e6a5262a3ee49e53b1 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 254faae89f8f86634bf08a4e395034d5fdbfef31..2a21a13c58676e654b79f706c236bda5cd7be71d 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 730e44061eecfaa475bf6a598bc1a42a70a22c06..fb715a46c73a1f03eb11aa973f361e4742665c39 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 4176c73e874a17b11b566a4b3d5e263f6681c0de..7a48628f96b97a7d9ce7079ea8bf3f23fe07dde7 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))