walkero
/
fontconfig
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge with HEAD and finish the GCC 4 cleanups (no more warnings!)

This commit is contained in:
Patrick Lam 2005-09-11 02:16:09 +00:00
parent 8cb4c56d99
commit 8245771d5a
15 changed files with 209 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
ChangeLog
View File

@ -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> 2005-07-15 Carl Worth <cworth@cworth.org>
* src/fcint.h: * src/fcint.h:

4
doc/fontconfig-user.sgml
View File

@ -276,8 +276,8 @@ file version number (currently 1).
</para></refsect2> </para></refsect2>
<refsect2><title><sgmltag>include ignore_missing="no"</></title><para> <refsect2><title><sgmltag>include ignore_missing="no"</></title><para>
This element contains the name of an additional configuration file or This element contains the name of an additional configuration file or
directory. If a directory, every file within that directory starting with a directory. If a directory, every file within that directory starting with an
number will be processed in sorted order. When 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) 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 will also be incorporated into the configuration by passing the filename(s) to
FcConfigLoadAndParse. If 'ignore_missing' is set to "yes" instead of the FcConfigLoadAndParse. If 'ignore_missing' is set to "yes" instead of the

4
fc-glyphname/fc-glyphname.c
View File

@ -105,7 +105,7 @@ scan (FILE *f, char *filename)
gn = FcAllocGlyphName ((FcChar32) ucs, (FcChar8 *) name); gn = FcAllocGlyphName ((FcChar32) ucs, (FcChar8 *) name);
if (!gn) if (!gn)
fatal (filename, lineno, "out of memory"); fatal (filename, lineno, "out of memory");
len = strlen ((FcChar8 *) name); len = strlen (name);
if (len > max_name_len) if (len > max_name_len)
max_name_len = len; max_name_len = len;
raw[nraw++] = gn; raw[nraw++] = gn;
@ -286,7 +286,7 @@ main (int argc, char **argv)
for (i = 0; i < nraw; i++) for (i = 0; i < nraw; i++)
printf ("static struct { FcChar32 ucs; FcChar8 name[%d]; }" printf ("static struct { FcChar32 ucs; FcChar8 name[%d]; }"
" glyph%d = { 0x%lx, \"%s\" };\n", " 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); i, (unsigned long) raw[i]->ucs, raw[i]->name);
/* /*

2
fc-lang/fc-lang.c
View File

@ -56,7 +56,7 @@ FcCacheBankToIndex (int bank)
FcChar8 * FcChar8 *
FcConfigHome (void) FcConfigHome (void)
{ {
return getenv ("HOME"); return (FcChar8 *) getenv ("HOME");
} }
static void static void

8
fc-match/fc-match.c
View File

@ -167,17 +167,17 @@ main (int argc, char **argv)
FcChar8 *file; FcChar8 *file;
if (FcPatternGetString (fs->fonts[j], FC_FILE, 0, &file) != FcResultMatch) if (FcPatternGetString (fs->fonts[j], FC_FILE, 0, &file) != FcResultMatch)
file = "<unknown filename>"; file = (FcChar8 *) "<unknown filename>";
else else
{ {
FcChar8 *slash = strrchr (file, '/'); FcChar8 *slash = (FcChar8 *) strrchr ((char *) file, '/');
if (slash) if (slash)
file = slash+1; file = slash+1;
} }
if (FcPatternGetString (fs->fonts[j], FC_FAMILY, 0, &family) != FcResultMatch) 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) 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); printf ("%s: \"%s\" \"%s\"\n", file, family, style);
} }

2
fontconfig/fcprivate.h
View File

@ -59,7 +59,7 @@
__v__.u.d = va_arg (va, double); \ __v__.u.d = va_arg (va, double); \
break; \ break; \
case FcTypeString: \ case FcTypeString: \
__v__.u.s = va_arg (va, const char *); \ __v__.u.s = va_arg (va, const FcChar8 *); \
break; \ break; \
case FcTypeBool: \ case FcTypeBool: \
__v__.u.b = va_arg (va, FcBool); \ __v__.u.b = va_arg (va, FcBool); \

35
src/fccache.c
View File

@ -60,8 +60,8 @@ FcCacheHaveBank (int bank);
#define FC_DBG_CACHE_REF 1024 #define FC_DBG_CACHE_REF 1024
static FcChar8 * static char *
FcCacheReadString (int fd, FcChar8 *dest, int len) FcCacheReadString (int fd, char *dest, int len)
{ {
FcChar8 c; FcChar8 c;
FcBool escape; FcBool escape;
@ -101,7 +101,7 @@ FcCacheReadString (int fd, FcChar8 *dest, int len)
} }
static FcBool static FcBool
FcCacheWriteString (int fd, const FcChar8 *chars) FcCacheWriteString (int fd, const char *chars)
{ {
if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1) if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
return FcFalse; return FcFalse;
@ -151,7 +151,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
FcStrSet *staleDirs, FcStrSet *staleDirs,
const FcChar8 *cache_file) const FcChar8 *cache_file)
{ {
FcChar8 name_buf[8192]; char name_buf[8192];
FcGlobalCacheDir *d, *next; FcGlobalCacheDir *d, *next;
char * current_arch_machine_name; char * current_arch_machine_name;
char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9]; char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
@ -193,7 +193,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
{ {
FcCache md; FcCache md;
FcStrSetAdd (staleDirs, FcStrCopy (name_buf)); FcStrSetAdd (staleDirs, FcStrCopy ((FcChar8 *)name_buf));
read (cache->fd, &md, sizeof (FcCache)); read (cache->fd, &md, sizeof (FcCache));
lseek (cache->fd, FcCacheNextOffset (lseek(cache->fd, 0, SEEK_CUR)) + md.count, SEEK_SET); lseek (cache->fd, FcCacheNextOffset (lseek(cache->fd, 0, SEEK_CUR)) + md.count, SEEK_SET);
continue; continue;
@ -206,7 +206,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
d->next = cache->dirs; d->next = cache->dirs;
cache->dirs = d; cache->dirs = d;
d->name = FcStrCopy (name_buf); d->name = (char *)FcStrCopy ((FcChar8 *)name_buf);
d->ent = 0; d->ent = 0;
d->offset = lseek (cache->fd, 0, SEEK_CUR); d->offset = lseek (cache->fd, 0, SEEK_CUR);
if (read (cache->fd, &d->metadata, sizeof (FcCache)) != sizeof (FcCache)) if (read (cache->fd, &d->metadata, sizeof (FcCache)) != sizeof (FcCache))
@ -231,7 +231,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
} }
FcBool FcBool
FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, const FcChar8 *dir, FcConfig *config) FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, const char *dir, FcConfig *config)
{ {
FcGlobalCacheDir *d; FcGlobalCacheDir *d;
FcBool ret = FcFalse; FcBool ret = FcFalse;
@ -256,7 +256,7 @@ FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, con
FcBool FcBool
FcGlobalCacheUpdate (FcGlobalCache *cache, FcGlobalCacheUpdate (FcGlobalCache *cache,
const FcChar8 *name, const char *name,
FcFontSet *set) FcFontSet *set)
{ {
FcGlobalCacheDir * d; FcGlobalCacheDir * d;
@ -281,7 +281,7 @@ FcGlobalCacheUpdate (FcGlobalCache *cache,
cache->updated = FcTrue; cache->updated = FcTrue;
d->name = FcStrCopy (name); d->name = (char *)FcStrCopy ((FcChar8 *)name);
d->ent = FcDirCacheProduce (set, &d->metadata); d->ent = FcDirCacheProduce (set, &d->metadata);
d->offset = 0; d->offset = 0;
return FcTrue; return FcTrue;
@ -618,12 +618,12 @@ FcCacheRead (FcConfig *config, FcGlobalCache * cache)
static FcBool static FcBool
FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir) FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir)
{ {
FcChar8 *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE); char *cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
int fd; int fd;
char * current_arch_machine_name; char * current_arch_machine_name;
char candidate_arch_machine_name[9+MACHINE_SIGNATURE_SIZE]; char candidate_arch_machine_name[9+MACHINE_SIGNATURE_SIZE];
off_t current_arch_start = 0; off_t current_arch_start = 0;
FcChar8 subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1]; char subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1];
if (!cache_file) if (!cache_file)
goto bail; goto bail;
@ -643,7 +643,7 @@ FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir)
goto bail1; goto bail1;
while (strlen(FcCacheReadString (fd, subdirName, sizeof (subdirName))) > 0) while (strlen(FcCacheReadString (fd, subdirName, sizeof (subdirName))) > 0)
FcStrSetAdd (dirs, subdirName); FcStrSetAdd (dirs, (FcChar8 *)subdirName);
if (!FcDirCacheConsume (fd, set)) if (!FcDirCacheConsume (fd, set))
goto bail1; goto bail1;
@ -689,7 +689,7 @@ static void *
FcDirCacheProduce (FcFontSet *set, FcCache *metadata) FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
{ {
void * current_dir_block, * final_dir_block; void * current_dir_block, * final_dir_block;
static int rand_state = 0; static unsigned int rand_state = 0;
int bank; int bank;
if (!rand_state) if (!rand_state)
@ -734,6 +734,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
int fd, i; int fd, i;
FcCache metadata; FcCache metadata;
off_t current_arch_start = 0, truncate_to; off_t current_arch_start = 0, truncate_to;
char * current_arch_machine_name, * header; char * current_arch_machine_name, * header;
void * current_dir_block; void * current_dir_block;
@ -744,7 +745,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
if (!metadata.count) if (!metadata.count)
{ {
unlink (cache_file); unlink ((char *)cache_file);
free (cache_file); free (cache_file);
return FcTrue; return FcTrue;
} }
@ -755,7 +756,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
if (FcDebug () & FC_DBG_CACHE) if (FcDebug () & FC_DBG_CACHE)
printf ("FcDirCacheWriteDir cache_file \"%s\"\n", cache_file); printf ("FcDirCacheWriteDir cache_file \"%s\"\n", cache_file);
fd = open(cache_file, O_RDWR | O_CREAT, 0666); fd = open((char *)cache_file, O_RDWR | O_CREAT, 0666);
if (fd == -1) if (fd == -1)
goto bail0; goto bail0;
@ -782,7 +783,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
goto bail1; goto bail1;
for (i = 0; i < dirs->size; i++) for (i = 0; i < dirs->size; i++)
FcCacheWriteString (fd, dirs->strs[i]); FcCacheWriteString (fd, (char *)dirs->strs[i]);
FcCacheWriteString (fd, ""); FcCacheWriteString (fd, "");
write (fd, &metadata, sizeof(FcCache)); write (fd, &metadata, sizeof(FcCache));
@ -802,7 +803,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
bail0: bail0:
free (current_dir_block); free (current_dir_block);
bail: bail:
unlink (cache_file); unlink ((char *)cache_file);
free (cache_file); free (cache_file);
return FcFalse; return FcFalse;
} }

2
src/fccfg.c
View File

@ -1652,7 +1652,7 @@ FcConfigHome (void)
home = getenv ("USERPROFILE"); home = getenv ("USERPROFILE");
#endif #endif
return home; return (FcChar8 *) home;
} }
return 0; return 0;
} }

4
src/fcdir.c
View File

@ -136,7 +136,7 @@ FcDirScanConfig (FcFontSet *set,
/* /*
* Check ~/.fonts.cache-<version> file * Check ~/.fonts.cache-<version> file
*/ */
if (cache && FcGlobalCacheReadDir (set, dirs, cache, dir, config)) if (cache && FcGlobalCacheReadDir (set, dirs, cache, (char *)dir, config))
return FcTrue; return FcTrue;
} }
@ -184,7 +184,7 @@ FcDirScanConfig (FcFontSet *set,
* add the cache entry * add the cache entry
*/ */
if (ret && cache) if (ret && cache)
FcGlobalCacheUpdate (cache, dir, tmpSet); FcGlobalCacheUpdate (cache, (char *)dir, tmpSet);
for (i = 0; i < tmpSet->nfont; i++) for (i = 0; i < tmpSet->nfont; i++)
FcFontSetAdd (set, tmpSet->fonts[i]); FcFontSetAdd (set, tmpSet->fonts[i]);

191
src/fcfreetype.c
View File

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

10
src/fcint.h
View File

@ -323,7 +323,7 @@ typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
struct _FcGlobalCacheDir { struct _FcGlobalCacheDir {
struct _FcGlobalCacheDir *next; struct _FcGlobalCacheDir *next;
FcChar8 *name; char *name;
FcCache metadata; FcCache metadata;
off_t offset; off_t offset;
void *ent; void *ent;
@ -422,7 +422,7 @@ FcBool
FcGlobalCacheReadDir (FcFontSet *set, FcGlobalCacheReadDir (FcFontSet *set,
FcStrSet *dirs, FcStrSet *dirs,
FcGlobalCache *cache, FcGlobalCache *cache,
const FcChar8 *dir, const char *dir,
FcConfig *config); FcConfig *config);
void void
@ -432,7 +432,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
FcBool FcBool
FcGlobalCacheUpdate (FcGlobalCache *cache, FcGlobalCacheUpdate (FcGlobalCache *cache,
const FcChar8 *file, const char *file,
FcFontSet *set); FcFontSet *set);
FcBool FcBool
@ -795,8 +795,8 @@ FcPatternFini (void);
FcBool FcBool
FcPatternAppend (FcPattern *p, FcPattern *s); FcPatternAppend (FcPattern *p, FcPattern *s);
const char * const FcChar8 *
FcStrStaticName (const char *name); FcStrStaticName (const FcChar8 *name);
FcChar32 FcChar32
FcStringHash (const FcChar8 *s); FcStringHash (const FcChar8 *s);

2
src/fclist.c
View File

@ -67,7 +67,7 @@ FcObjectSetAdd (FcObjectSet *os, const char *object)
low = 0; low = 0;
mid = 0; mid = 0;
c = 1; c = 1;
object = FcStrStaticName (object); object = (char *)FcStrStaticName ((FcChar8 *)object);
while (low <= high) while (low <= high)
{ {
mid = (low + high) >> 1; mid = (low + high) >> 1;

80
src/fcpat.c
View File

@ -792,7 +792,7 @@ FcPatternHash (const FcPattern *p)
for (i = 0; i < p->num; i++) for (i = 0; i < p->num; i++)
{ {
h = (((h << 1) | (h >> 31)) ^ h = (((h << 1) | (h >> 31)) ^
FcStringHash (FcObjectPtrU ((FcPatternEltU(p->elts)+i)->object)) ^ FcStringHash ((FcChar8 *)FcObjectPtrU ((FcPatternEltU(p->elts)+i)->object)) ^
FcValueListHash ((FcPatternEltU(p->elts)+i)->values)); FcValueListHash ((FcPatternEltU(p->elts)+i)->values));
} }
return h; return h;
@ -1280,34 +1280,32 @@ FcPatternAppend (FcPattern *p, FcPattern *s)
} }
#define OBJECT_HASH_SIZE 31 #define OBJECT_HASH_SIZE 31
struct objectBucket { static struct objectBucket {
struct objectBucket *next; struct objectBucket *next;
FcChar32 hash; FcChar32 hash;
}; } *FcObjectBuckets[OBJECT_HASH_SIZE];
static struct objectBucket *FcObjectBuckets[OBJECT_HASH_SIZE];
const char * const FcChar8 *
FcStrStaticName (const char *name) FcStrStaticName (const FcChar8 *name)
{ {
FcChar32 hash = FcStringHash ((const FcChar8 *) name); FcChar32 hash = FcStringHash (name);
struct objectBucket **p; struct objectBucket **p;
struct objectBucket *b; struct objectBucket *b;
int size; int size;
for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next) for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
) if (b->hash == hash && !strcmp ((char *)name, (char *) (b + 1)))
if (b->hash == hash && !strcmp (name, (char *) (b + 1))) return (FcChar8 *) (b + 1);
return (char *) (b + 1); size = sizeof (struct objectBucket) + strlen ((char *)name) + 1;
size = sizeof (struct objectBucket) + strlen (name) + 1;
b = malloc (size); b = malloc (size);
FcMemAlloc (FC_MEM_STATICSTR, size); FcMemAlloc (FC_MEM_STATICSTR, size);
if (!b) if (!b)
return NULL; return NULL;
b->next = 0; b->next = 0;
b->hash = hash; b->hash = hash;
strcpy ((char *) (b + 1), name); strcpy ((char *) (b + 1), (char *)name);
*p = b; *p = b;
return (char *) (b + 1); return (FcChar8 *) (b + 1);
} }
static void static void
@ -1370,11 +1368,11 @@ FcPatternEltPtrCreateStatic (int bank, int i)
static void static void
FcStrNewBank (void); FcStrNewBank (void);
static int static int
FcStrNeededBytes (const char * s); FcStrNeededBytes (const FcChar8 * s);
static void * static void *
FcStrDistributeBytes (FcCache * metadata, void * block_ptr); FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
static const char * static const FcChar8 *
FcStrSerialize (int bank, const char * s); FcStrSerialize (int bank, const FcChar8 * s);
static void * static void *
FcStrUnserialize (FcCache metadata, void *block_ptr); FcStrUnserialize (FcCache metadata, void *block_ptr);
@ -1669,10 +1667,10 @@ FcValueListSerialize(int bank, FcValueList *pi)
case FcTypeString: case FcTypeString:
if (v->u.s) if (v->u.s)
{ {
const char * s = FcStrSerialize(bank, v->u.s); const FcChar8 * s = FcStrSerialize(bank, v->u.s);
if (!s) if (!s)
return FcValueListPtrCreateDynamic(pi); return FcValueListPtrCreateDynamic(pi);
v->u.s_off = s - (const char *)v; v->u.s_off = s - (const FcChar8 *)v;
v->type |= FC_STORAGE_STATIC; v->type |= FC_STORAGE_STATIC;
} }
break; break;
@ -1743,7 +1741,7 @@ FcValueListPtrCreateDynamic(FcValueList * p)
return r; return r;
} }
static char ** static_strs; static FcChar8 ** static_strs;
static int static_str_bank_count = 0, fcstr_ptr, fcstr_count; static int static_str_bank_count = 0, fcstr_ptr, fcstr_count;
static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE]; static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE];
@ -1772,7 +1770,7 @@ FcStrNewBank (void)
} }
static int static int
FcStrNeededBytes (const char * s) FcStrNeededBytes (const FcChar8 * s)
{ {
FcChar32 hash = FcStringHash ((const FcChar8 *) s); FcChar32 hash = FcStringHash ((const FcChar8 *) s);
struct objectBucket **p; struct objectBucket **p;
@ -1780,27 +1778,27 @@ FcStrNeededBytes (const char * s)
int size; int size;
for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next)) for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
if (b->hash == hash && !strcmp (s, (char *) (b + 1))) if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
return 0; return 0;
size = sizeof (struct objectBucket) + strlen (s) + 1 + sizeof(char *); size = sizeof (struct objectBucket) + strlen ((char *)s) + 1 + sizeof(char *);
b = malloc (size); b = malloc (size);
FcMemAlloc (FC_MEM_STATICSTR, size); FcMemAlloc (FC_MEM_STATICSTR, size);
if (!b) if (!b)
return -1; return -1;
b->next = 0; b->next = 0;
b->hash = hash; b->hash = hash;
strcpy ((char *) (b + 1), s); strcpy ((char *) (b + 1), (char *)s);
*(char **)((char *) (b + 1) + strlen(s) + 1) = 0; *(char **)((char *) (b + 1) + strlen((char *)s) + 1) = 0;
*p = b; *p = b;
fcstr_count += strlen(s) + 1; fcstr_count += strlen((char *)s) + 1;
return strlen(s) + 1; return strlen((char *)s) + 1;
} }
static FcBool static FcBool
FcStrEnsureBank (int bi) FcStrEnsureBank (int bi)
{ {
char ** ss; FcChar8 ** ss;
if (!static_strs || static_str_bank_count <= bi) if (!static_strs || static_str_bank_count <= bi)
{ {
@ -1827,7 +1825,7 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
return 0; return 0;
FcMemAlloc (FC_MEM_STRING, sizeof (char) * fcstr_count); FcMemAlloc (FC_MEM_STRING, sizeof (char) * fcstr_count);
static_strs[bi] = (char *)block_ptr; static_strs[bi] = (FcChar8 *)block_ptr;
block_ptr = (void *)((char *)block_ptr + (sizeof (char) * fcstr_count)); block_ptr = (void *)((char *)block_ptr + (sizeof (char) * fcstr_count));
metadata->str_count = fcstr_count; metadata->str_count = fcstr_count;
fcstr_ptr = 0; fcstr_ptr = 0;
@ -1835,8 +1833,8 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
return block_ptr; return block_ptr;
} }
static const char * static const FcChar8 *
FcStrSerialize (int bank, const char * s) FcStrSerialize (int bank, const FcChar8 * s)
{ {
FcChar32 hash = FcStringHash ((const FcChar8 *) s); FcChar32 hash = FcStringHash ((const FcChar8 *) s);
struct objectBucket **p; struct objectBucket **p;
@ -1844,15 +1842,15 @@ FcStrSerialize (int bank, const char * s)
int bi = FcCacheBankToIndex(bank); int bi = FcCacheBankToIndex(bank);
for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next)) for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
if (b->hash == hash && !strcmp (s, (char *) (b + 1))) if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
{ {
char * t = *(char **)(((char *)(b + 1)) + strlen (s) + 1); FcChar8 * t = *(FcChar8 **)(((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1);
if (!t) if (!t)
{ {
strcpy(static_strs[bi] + fcstr_ptr, s); strcpy((char *)(static_strs[bi] + fcstr_ptr), (char *)s);
*(char **)((char *) (b + 1) + strlen(s) + 1) = (static_strs[bi] + fcstr_ptr); *(FcChar8 **)((FcChar8 *) (b + 1) + strlen((char *)s) + 1) = (static_strs[bi] + fcstr_ptr);
fcstr_ptr += strlen(s) + 1; fcstr_ptr += strlen((char *)s) + 1;
t = *(char **)(((char *)(b + 1)) + strlen (s) + 1); t = *(FcChar8 **)(((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1);
} }
return t; return t;
} }
@ -1867,7 +1865,7 @@ FcStrUnserialize (FcCache metadata, void *block_ptr)
return 0; return 0;
FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata.str_count); FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata.str_count);
static_strs[bi] = (char *)block_ptr; static_strs[bi] = (FcChar8 *)block_ptr;
block_ptr = (void *)((char *)block_ptr + block_ptr = (void *)((char *)block_ptr +
(sizeof (char) * metadata.str_count)); (sizeof (char) * metadata.str_count));

2
src/fcstr.c
View File

@ -83,7 +83,7 @@ FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)
{ {
w->src = src; w->src = src;
w->read = 0; w->read = 0;
w->len = strlen (src); w->len = strlen ((char *) src);
} }
static FcChar8 static FcChar8

11
src/fcxml.c
View File

@ -1926,7 +1926,7 @@ FcParsePatelt (FcConfigParse *parse)
return; return;
} }
name = FcConfigGetAttribute (parse, "name"); name = (char *) FcConfigGetAttribute (parse, "name");
if (!name) if (!name)
{ {
FcConfigMessage (parse, FcSevereWarning, "missing pattern element name"); FcConfigMessage (parse, FcSevereWarning, "missing pattern element name");
@ -2264,11 +2264,16 @@ FcConfigParseAndLoadDir (FcConfig *config,
while (ret && (e = readdir (d))) 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' && 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); strcpy ((char *) base, (char *) e->d_name);
if (!FcStrSetAdd (files, file)) if (!FcStrSetAdd (files, file))