Merge with HEAD and finish the GCC 4 cleanups (no more warnings!)
This commit is contained in:
Patrick Lam
parent
8cb4c56d99
commit
8245771d5a
19
ChangeLog
19
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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ FcCacheBankToIndex (int bank)
|
|||
FcChar8 *
|
||||
FcConfigHome (void)
|
||||
{
|
||||
return getenv ("HOME");
|
||||
return (FcChar8 *) getenv ("HOME");
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@
|
|||
__v__.u.d = va_arg (va, double); \
|
||||
break; \
|
||||
case FcTypeString: \
|
||||
__v__.u.s = va_arg (va, const char *); \
|
||||
__v__.u.s = va_arg (va, const FcChar8 *); \
|
||||
break; \
|
||||
case FcTypeBool: \
|
||||
__v__.u.b = va_arg (va, FcBool); \
|
||||
|
|
|
|||
|
|
@ -60,8 +60,8 @@ FcCacheHaveBank (int bank);
|
|||
|
||||
#define FC_DBG_CACHE_REF 1024
|
||||
|
||||
static FcChar8 *
|
||||
FcCacheReadString (int fd, FcChar8 *dest, int len)
|
||||
static char *
|
||||
FcCacheReadString (int fd, char *dest, int len)
|
||||
{
|
||||
FcChar8 c;
|
||||
FcBool escape;
|
||||
|
|
@ -101,7 +101,7 @@ FcCacheReadString (int fd, FcChar8 *dest, int len)
|
|||
}
|
||||
|
||||
static FcBool
|
||||
FcCacheWriteString (int fd, const FcChar8 *chars)
|
||||
FcCacheWriteString (int fd, const char *chars)
|
||||
{
|
||||
if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
|
||||
return FcFalse;
|
||||
|
|
@ -151,7 +151,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
|
|||
FcStrSet *staleDirs,
|
||||
const FcChar8 *cache_file)
|
||||
{
|
||||
FcChar8 name_buf[8192];
|
||||
char name_buf[8192];
|
||||
FcGlobalCacheDir *d, *next;
|
||||
char * current_arch_machine_name;
|
||||
char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
|
||||
|
|
@ -193,7 +193,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
|
|||
{
|
||||
FcCache md;
|
||||
|
||||
FcStrSetAdd (staleDirs, FcStrCopy (name_buf));
|
||||
FcStrSetAdd (staleDirs, FcStrCopy ((FcChar8 *)name_buf));
|
||||
read (cache->fd, &md, sizeof (FcCache));
|
||||
lseek (cache->fd, FcCacheNextOffset (lseek(cache->fd, 0, SEEK_CUR)) + md.count, SEEK_SET);
|
||||
continue;
|
||||
|
|
@ -206,7 +206,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
|
|||
d->next = cache->dirs;
|
||||
cache->dirs = d;
|
||||
|
||||
d->name = FcStrCopy (name_buf);
|
||||
d->name = (char *)FcStrCopy ((FcChar8 *)name_buf);
|
||||
d->ent = 0;
|
||||
d->offset = lseek (cache->fd, 0, SEEK_CUR);
|
||||
if (read (cache->fd, &d->metadata, sizeof (FcCache)) != sizeof (FcCache))
|
||||
|
|
@ -231,7 +231,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
|
|||
}
|
||||
|
||||
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;
|
||||
FcBool ret = FcFalse;
|
||||
|
|
@ -256,7 +256,7 @@ FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, con
|
|||
|
||||
FcBool
|
||||
FcGlobalCacheUpdate (FcGlobalCache *cache,
|
||||
const FcChar8 *name,
|
||||
const char *name,
|
||||
FcFontSet *set)
|
||||
{
|
||||
FcGlobalCacheDir * d;
|
||||
|
|
@ -281,7 +281,7 @@ FcGlobalCacheUpdate (FcGlobalCache *cache,
|
|||
|
||||
cache->updated = FcTrue;
|
||||
|
||||
d->name = FcStrCopy (name);
|
||||
d->name = (char *)FcStrCopy ((FcChar8 *)name);
|
||||
d->ent = FcDirCacheProduce (set, &d->metadata);
|
||||
d->offset = 0;
|
||||
return FcTrue;
|
||||
|
|
@ -618,12 +618,12 @@ FcCacheRead (FcConfig *config, FcGlobalCache * cache)
|
|||
static FcBool
|
||||
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;
|
||||
char * current_arch_machine_name;
|
||||
char candidate_arch_machine_name[9+MACHINE_SIGNATURE_SIZE];
|
||||
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)
|
||||
goto bail;
|
||||
|
|
@ -643,7 +643,7 @@ FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir)
|
|||
goto bail1;
|
||||
|
||||
while (strlen(FcCacheReadString (fd, subdirName, sizeof (subdirName))) > 0)
|
||||
FcStrSetAdd (dirs, subdirName);
|
||||
FcStrSetAdd (dirs, (FcChar8 *)subdirName);
|
||||
|
||||
if (!FcDirCacheConsume (fd, set))
|
||||
goto bail1;
|
||||
|
|
@ -689,7 +689,7 @@ static void *
|
|||
FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
|
||||
{
|
||||
void * current_dir_block, * final_dir_block;
|
||||
static int rand_state = 0;
|
||||
static unsigned int rand_state = 0;
|
||||
int bank;
|
||||
|
||||
if (!rand_state)
|
||||
|
|
@ -734,6 +734,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
|
|||
int fd, i;
|
||||
FcCache metadata;
|
||||
off_t current_arch_start = 0, truncate_to;
|
||||
|
||||
char * current_arch_machine_name, * header;
|
||||
void * current_dir_block;
|
||||
|
||||
|
|
@ -744,7 +745,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
|
|||
|
||||
if (!metadata.count)
|
||||
{
|
||||
unlink (cache_file);
|
||||
unlink ((char *)cache_file);
|
||||
free (cache_file);
|
||||
return FcTrue;
|
||||
}
|
||||
|
|
@ -755,7 +756,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
|
|||
if (FcDebug () & FC_DBG_CACHE)
|
||||
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)
|
||||
goto bail0;
|
||||
|
||||
|
|
@ -782,7 +783,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
|
|||
goto bail1;
|
||||
|
||||
for (i = 0; i < dirs->size; i++)
|
||||
FcCacheWriteString (fd, dirs->strs[i]);
|
||||
FcCacheWriteString (fd, (char *)dirs->strs[i]);
|
||||
FcCacheWriteString (fd, "");
|
||||
|
||||
write (fd, &metadata, sizeof(FcCache));
|
||||
|
|
@ -802,7 +803,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
|
|||
bail0:
|
||||
free (current_dir_block);
|
||||
bail:
|
||||
unlink (cache_file);
|
||||
unlink ((char *)cache_file);
|
||||
free (cache_file);
|
||||
return FcFalse;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1652,7 +1652,7 @@ FcConfigHome (void)
|
|||
home = getenv ("USERPROFILE");
|
||||
#endif
|
||||
|
||||
return home;
|
||||
return (FcChar8 *) home;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -136,7 +136,7 @@ FcDirScanConfig (FcFontSet *set,
|
|||
/*
|
||||
* Check ~/.fonts.cache-<version> file
|
||||
*/
|
||||
if (cache && FcGlobalCacheReadDir (set, dirs, cache, dir, config))
|
||||
if (cache && FcGlobalCacheReadDir (set, dirs, cache, (char *)dir, config))
|
||||
return FcTrue;
|
||||
}
|
||||
|
||||
|
|
@ -184,7 +184,7 @@ FcDirScanConfig (FcFontSet *set,
|
|||
* add the cache entry
|
||||
*/
|
||||
if (ret && cache)
|
||||
FcGlobalCacheUpdate (cache, dir, tmpSet);
|
||||
FcGlobalCacheUpdate (cache, (char *)dir, tmpSet);
|
||||
|
||||
for (i = 0; i < tmpSet->nfont; i++)
|
||||
FcFontSetAdd (set, tmpSet->fonts[i]);
|
||||
|
|
|
|||
191
src/fcfreetype.c
191
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) {
|
||||
|
|
|
|||
10
src/fcint.h
10
src/fcint.h
|
|
@ -323,7 +323,7 @@ typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
|
|||
|
||||
struct _FcGlobalCacheDir {
|
||||
struct _FcGlobalCacheDir *next;
|
||||
FcChar8 *name;
|
||||
char *name;
|
||||
FcCache metadata;
|
||||
off_t offset;
|
||||
void *ent;
|
||||
|
|
@ -422,7 +422,7 @@ FcBool
|
|||
FcGlobalCacheReadDir (FcFontSet *set,
|
||||
FcStrSet *dirs,
|
||||
FcGlobalCache *cache,
|
||||
const FcChar8 *dir,
|
||||
const char *dir,
|
||||
FcConfig *config);
|
||||
|
||||
void
|
||||
|
|
@ -432,7 +432,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache,
|
|||
|
||||
FcBool
|
||||
FcGlobalCacheUpdate (FcGlobalCache *cache,
|
||||
const FcChar8 *file,
|
||||
const char *file,
|
||||
FcFontSet *set);
|
||||
|
||||
FcBool
|
||||
|
|
@ -795,8 +795,8 @@ FcPatternFini (void);
|
|||
FcBool
|
||||
FcPatternAppend (FcPattern *p, FcPattern *s);
|
||||
|
||||
const char *
|
||||
FcStrStaticName (const char *name);
|
||||
const FcChar8 *
|
||||
FcStrStaticName (const FcChar8 *name);
|
||||
|
||||
FcChar32
|
||||
FcStringHash (const FcChar8 *s);
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ FcObjectSetAdd (FcObjectSet *os, const char *object)
|
|||
low = 0;
|
||||
mid = 0;
|
||||
c = 1;
|
||||
object = FcStrStaticName (object);
|
||||
object = (char *)FcStrStaticName ((FcChar8 *)object);
|
||||
while (low <= high)
|
||||
{
|
||||
mid = (low + high) >> 1;
|
||||
|
|
|
|||
80
src/fcpat.c
80
src/fcpat.c
|
|
@ -792,7 +792,7 @@ FcPatternHash (const FcPattern *p)
|
|||
for (i = 0; i < p->num; i++)
|
||||
{
|
||||
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));
|
||||
}
|
||||
return h;
|
||||
|
|
@ -1280,34 +1280,32 @@ FcPatternAppend (FcPattern *p, FcPattern *s)
|
|||
}
|
||||
|
||||
#define OBJECT_HASH_SIZE 31
|
||||
struct objectBucket {
|
||||
static struct objectBucket {
|
||||
struct objectBucket *next;
|
||||
FcChar32 hash;
|
||||
};
|
||||
static struct objectBucket *FcObjectBuckets[OBJECT_HASH_SIZE];
|
||||
} *FcObjectBuckets[OBJECT_HASH_SIZE];
|
||||
|
||||
const char *
|
||||
FcStrStaticName (const char *name)
|
||||
const FcChar8 *
|
||||
FcStrStaticName (const FcChar8 *name)
|
||||
{
|
||||
FcChar32 hash = FcStringHash ((const FcChar8 *) name);
|
||||
struct objectBucket **p;
|
||||
struct objectBucket *b;
|
||||
int size;
|
||||
FcChar32 hash = FcStringHash (name);
|
||||
struct objectBucket **p;
|
||||
struct objectBucket *b;
|
||||
int size;
|
||||
|
||||
for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next)
|
||||
)
|
||||
if (b->hash == hash && !strcmp (name, (char *) (b + 1)))
|
||||
return (char *) (b + 1);
|
||||
size = sizeof (struct objectBucket) + strlen (name) + 1;
|
||||
for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
|
||||
if (b->hash == hash && !strcmp ((char *)name, (char *) (b + 1)))
|
||||
return (FcChar8 *) (b + 1);
|
||||
size = sizeof (struct objectBucket) + strlen ((char *)name) + 1;
|
||||
b = malloc (size);
|
||||
FcMemAlloc (FC_MEM_STATICSTR, size);
|
||||
if (!b)
|
||||
return NULL;
|
||||
b->next = 0;
|
||||
b->hash = hash;
|
||||
strcpy ((char *) (b + 1), name);
|
||||
strcpy ((char *) (b + 1), (char *)name);
|
||||
*p = b;
|
||||
return (char *) (b + 1);
|
||||
return (FcChar8 *) (b + 1);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -1370,11 +1368,11 @@ FcPatternEltPtrCreateStatic (int bank, int i)
|
|||
static void
|
||||
FcStrNewBank (void);
|
||||
static int
|
||||
FcStrNeededBytes (const char * s);
|
||||
FcStrNeededBytes (const FcChar8 * s);
|
||||
static void *
|
||||
FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
|
||||
static const char *
|
||||
FcStrSerialize (int bank, const char * s);
|
||||
static const FcChar8 *
|
||||
FcStrSerialize (int bank, const FcChar8 * s);
|
||||
static void *
|
||||
FcStrUnserialize (FcCache metadata, void *block_ptr);
|
||||
|
||||
|
|
@ -1669,10 +1667,10 @@ FcValueListSerialize(int bank, FcValueList *pi)
|
|||
case FcTypeString:
|
||||
if (v->u.s)
|
||||
{
|
||||
const char * s = FcStrSerialize(bank, v->u.s);
|
||||
const FcChar8 * s = FcStrSerialize(bank, v->u.s);
|
||||
if (!s)
|
||||
return FcValueListPtrCreateDynamic(pi);
|
||||
v->u.s_off = s - (const char *)v;
|
||||
v->u.s_off = s - (const FcChar8 *)v;
|
||||
v->type |= FC_STORAGE_STATIC;
|
||||
}
|
||||
break;
|
||||
|
|
@ -1743,7 +1741,7 @@ FcValueListPtrCreateDynamic(FcValueList * p)
|
|||
return r;
|
||||
}
|
||||
|
||||
static char ** static_strs;
|
||||
static FcChar8 ** static_strs;
|
||||
static int static_str_bank_count = 0, fcstr_ptr, fcstr_count;
|
||||
|
||||
static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE];
|
||||
|
|
@ -1772,7 +1770,7 @@ FcStrNewBank (void)
|
|||
}
|
||||
|
||||
static int
|
||||
FcStrNeededBytes (const char * s)
|
||||
FcStrNeededBytes (const FcChar8 * s)
|
||||
{
|
||||
FcChar32 hash = FcStringHash ((const FcChar8 *) s);
|
||||
struct objectBucket **p;
|
||||
|
|
@ -1780,27 +1778,27 @@ FcStrNeededBytes (const char * s)
|
|||
int size;
|
||||
|
||||
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;
|
||||
size = sizeof (struct objectBucket) + strlen (s) + 1 + sizeof(char *);
|
||||
size = sizeof (struct objectBucket) + strlen ((char *)s) + 1 + sizeof(char *);
|
||||
b = malloc (size);
|
||||
FcMemAlloc (FC_MEM_STATICSTR, size);
|
||||
if (!b)
|
||||
return -1;
|
||||
b->next = 0;
|
||||
b->hash = hash;
|
||||
strcpy ((char *) (b + 1), s);
|
||||
*(char **)((char *) (b + 1) + strlen(s) + 1) = 0;
|
||||
strcpy ((char *) (b + 1), (char *)s);
|
||||
*(char **)((char *) (b + 1) + strlen((char *)s) + 1) = 0;
|
||||
*p = b;
|
||||
|
||||
fcstr_count += strlen(s) + 1;
|
||||
return strlen(s) + 1;
|
||||
fcstr_count += strlen((char *)s) + 1;
|
||||
return strlen((char *)s) + 1;
|
||||
}
|
||||
|
||||
static FcBool
|
||||
FcStrEnsureBank (int bi)
|
||||
{
|
||||
char ** ss;
|
||||
FcChar8 ** ss;
|
||||
|
||||
if (!static_strs || static_str_bank_count <= bi)
|
||||
{
|
||||
|
|
@ -1827,7 +1825,7 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
|
|||
return 0;
|
||||
|
||||
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));
|
||||
metadata->str_count = fcstr_count;
|
||||
fcstr_ptr = 0;
|
||||
|
|
@ -1835,8 +1833,8 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
|
|||
return block_ptr;
|
||||
}
|
||||
|
||||
static const char *
|
||||
FcStrSerialize (int bank, const char * s)
|
||||
static const FcChar8 *
|
||||
FcStrSerialize (int bank, const FcChar8 * s)
|
||||
{
|
||||
FcChar32 hash = FcStringHash ((const FcChar8 *) s);
|
||||
struct objectBucket **p;
|
||||
|
|
@ -1844,15 +1842,15 @@ FcStrSerialize (int bank, const char * s)
|
|||
int bi = FcCacheBankToIndex(bank);
|
||||
|
||||
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)
|
||||
{
|
||||
strcpy(static_strs[bi] + fcstr_ptr, s);
|
||||
*(char **)((char *) (b + 1) + strlen(s) + 1) = (static_strs[bi] + fcstr_ptr);
|
||||
fcstr_ptr += strlen(s) + 1;
|
||||
t = *(char **)(((char *)(b + 1)) + strlen (s) + 1);
|
||||
strcpy((char *)(static_strs[bi] + fcstr_ptr), (char *)s);
|
||||
*(FcChar8 **)((FcChar8 *) (b + 1) + strlen((char *)s) + 1) = (static_strs[bi] + fcstr_ptr);
|
||||
fcstr_ptr += strlen((char *)s) + 1;
|
||||
t = *(FcChar8 **)(((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1);
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
|
@ -1867,7 +1865,7 @@ FcStrUnserialize (FcCache metadata, void *block_ptr)
|
|||
return 0;
|
||||
|
||||
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 +
|
||||
(sizeof (char) * metadata.str_count));
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
11
src/fcxml.c
11
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))
|
||||
|
|
|
|||
Loading…
Reference in New Issue