Edit
IABSD.fr/xenocara/lib/fontconfig/src/fccfg.c
matthieu
- lib/fontconfig/src/fccfg.c
-
/* * fontconfig/src/fccfg.c * * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of Keith Packard not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. Keith Packard makes no * representations about the suitability of this software for any purpose. It * is provided "as is" without express or implied warranty. * * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ #include "fcint.h" #include <dirent.h> #include <sys/types.h> #if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT)) #define STRICT #include <windows.h> #undef STRICT #endif #if defined (_WIN32) && !defined (R_OK) #define R_OK 4 #endif FcConfig *_fcConfig; FcConfig * FcConfigCreate (void) { FcSetName set; FcConfig *config; config = malloc (sizeof (FcConfig)); if (!config) goto bail0; FcMemAlloc (FC_MEM_CONFIG, sizeof (FcConfig)); config->configDirs = FcStrSetCreate (); if (!config->configDirs) goto bail1; config->configFiles = FcStrSetCreate (); if (!config->configFiles) goto bail2; config->fontDirs = FcStrSetCreate (); if (!config->fontDirs) goto bail3; config->acceptGlobs = FcStrSetCreate (); if (!config->acceptGlobs) goto bail4; config->rejectGlobs = FcStrSetCreate (); if (!config->rejectGlobs) goto bail5; config->acceptPatterns = FcFontSetCreate (); if (!config->acceptPatterns) goto bail6; config->rejectPatterns = FcFontSetCreate (); if (!config->rejectPatterns) goto bail7; config->cacheDirs = FcStrSetCreate (); if (!config->cacheDirs) goto bail8; config->blanks = 0; config->substPattern = 0; config->substFont = 0; config->substScan = 0; config->maxObjects = 0; for (set = FcSetSystem; set <= FcSetApplication; set++) config->fonts[set] = 0; config->rescanTime = time(0); config->rescanInterval = 30; config->expr_pool = NULL; config->ref = 1; return config; bail8: FcFontSetDestroy (config->rejectPatterns); bail7: FcFontSetDestroy (config->acceptPatterns); bail6: FcStrSetDestroy (config->rejectGlobs); bail5: FcStrSetDestroy (config->acceptGlobs); bail4: FcStrSetDestroy (config->fontDirs); bail3: FcStrSetDestroy (config->configFiles); bail2: FcStrSetDestroy (config->configDirs); bail1: free (config); FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig)); bail0: return 0; } static FcFileTime FcConfigNewestFile (FcStrSet *files) { FcStrList *list = FcStrListCreate (files); FcFileTime newest = { 0, FcFalse }; FcChar8 *file; struct stat statb; if (list) { while ((file = FcStrListNext (list))) if (FcStat ((char *) file, &statb) == 0) if (!newest.set || statb.st_mtime - newest.time > 0) { newest.set = FcTrue; newest.time = statb.st_mtime; } FcStrListDone (list); } return newest; } FcBool FcConfigUptoDate (FcConfig *config) { FcFileTime config_time, config_dir_time, font_time; time_t now = time(0); if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } config_time = FcConfigNewestFile (config->configFiles); config_dir_time = FcConfigNewestFile (config->configDirs); font_time = FcConfigNewestFile (config->fontDirs); if ((config_time.set && config_time.time - config->rescanTime > 0) || (config_dir_time.set && (config_dir_time.time - config->rescanTime) > 0) || (font_time.set && (font_time.time - config->rescanTime) > 0)) { /* We need to check for potential clock problems here (OLPC ticket #6046) */ if ((config_time.set && (config_time.time - now) > 0) || (config_dir_time.set && (config_dir_time.time - now) > 0) || (font_time.set && (font_time.time - now) > 0)) { fprintf (stderr, "Fontconfig warning: Directory/file mtime in the future. New fonts may not be detected\n"); config->rescanTime = now; return FcTrue; } else return FcFalse; } config->rescanTime = now; return FcTrue; } static void FcSubstDestroy (FcSubst *s) { FcSubst *n; while (s) { n = s->next; if (s->test) FcTestDestroy (s->test); if (s->edit) FcEditDestroy (s->edit); free (s); FcMemFree (FC_MEM_SUBST, sizeof (FcSubst)); s = n; } } FcExpr * FcConfigAllocExpr (FcConfig *config) { if (!config->expr_pool || config->expr_pool->next == config->expr_pool->end) { FcExprPage *new_page; new_page = malloc (sizeof (FcExprPage)); if (!new_page) return 0; FcMemAlloc (FC_MEM_EXPR, sizeof (FcExprPage)); new_page->next_page = config->expr_pool; new_page->next = new_page->exprs; config->expr_pool = new_page; } return config->expr_pool->next++; } FcConfig * FcConfigReference (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } config->ref++; return config; } void FcConfigDestroy (FcConfig *config) { FcSetName set; FcExprPage *page; if (--config->ref > 0) return; if (config == _fcConfig) _fcConfig = 0; FcStrSetDestroy (config->configDirs); FcStrSetDestroy (config->fontDirs); FcStrSetDestroy (config->cacheDirs); FcStrSetDestroy (config->configFiles); FcStrSetDestroy (config->acceptGlobs); FcStrSetDestroy (config->rejectGlobs); FcFontSetDestroy (config->acceptPatterns); FcFontSetDestroy (config->rejectPatterns); if (config->blanks) FcBlanksDestroy (config->blanks); FcSubstDestroy (config->substPattern); FcSubstDestroy (config->substFont); FcSubstDestroy (config->substScan); for (set = FcSetSystem; set <= FcSetApplication; set++) if (config->fonts[set]) FcFontSetDestroy (config->fonts[set]); page = config->expr_pool; while (page) { FcExprPage *next = page->next_page; FcMemFree (FC_MEM_EXPR, sizeof (FcExprPage)); free (page); page = next; } free (config); FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig)); } /* * Add cache to configuration, adding fonts and directories */ FcBool FcConfigAddCache (FcConfig *config, FcCache *cache, FcSetName set, FcStrSet *dirSet) { FcFontSet *fs; intptr_t *dirs; int i; /* * Add fonts */ fs = FcCacheSet (cache); if (fs) { int nref = 0; for (i = 0; i < fs->nfont; i++) { FcPattern *font = FcFontSetFont (fs, i); FcChar8 *font_file; /* * Check to see if font is banned by filename */ if (FcPatternObjectGetString (font, FC_FILE_OBJECT, 0, &font_file) == FcResultMatch && !FcConfigAcceptFilename (config, font_file)) { continue; } /* * Check to see if font is banned by pattern */ if (!FcConfigAcceptFont (config, font)) continue; nref++; FcFontSetAdd (config->fonts[set], font); } FcDirCacheReference (cache, nref); } /* * Add directories */ dirs = FcCacheDirs (cache); if (dirs) { for (i = 0; i < cache->dirs_count; i++) { FcChar8 *dir = FcOffsetToPtr (dirs, dirs[i], FcChar8); if (FcConfigAcceptFilename (config, dir)) FcStrSetAddFilename (dirSet, dir); } } return FcTrue; } static FcBool FcConfigAddDirList (FcConfig *config, FcSetName set, FcStrSet *dirSet) { FcStrList *dirlist; FcChar8 *dir; FcCache *cache; dirlist = FcStrListCreate (dirSet); if (!dirlist) return FcFalse; while ((dir = FcStrListNext (dirlist))) { if (FcDebug () & FC_DBG_FONTSET) printf ("adding fonts from%s\n", dir); cache = FcDirCacheRead (dir, FcFalse, config); if (!cache) continue; FcConfigAddCache (config, cache, set, dirSet); FcDirCacheUnload (cache); } FcStrListDone (dirlist); return FcTrue; } /* * Scan the current list of directories in the configuration * and build the set of available fonts. */ FcBool FcConfigBuildFonts (FcConfig *config) { FcFontSet *fonts; if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } fonts = FcFontSetCreate (); if (!fonts) return FcFalse; FcConfigSetFonts (config, fonts, FcSetSystem); if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs)) return FcFalse; if (FcDebug () & FC_DBG_FONTSET) FcFontSetPrint (fonts); return FcTrue; } FcBool FcConfigSetCurrent (FcConfig *config) { if (config == _fcConfig) return FcTrue; if (!config->fonts) if (!FcConfigBuildFonts (config)) return FcFalse; if (_fcConfig) FcConfigDestroy (_fcConfig); _fcConfig = config; return FcTrue; } FcConfig * FcConfigGetCurrent (void) { if (!_fcConfig) if (!FcInit ()) return 0; return _fcConfig; } FcBool FcConfigAddConfigDir (FcConfig *config, const FcChar8 *d) { return FcStrSetAddFilename (config->configDirs, d); } FcStrList * FcConfigGetConfigDirs (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return FcStrListCreate (config->configDirs); } FcBool FcConfigAddFontDir (FcConfig *config, const FcChar8 *d) { return FcStrSetAddFilename (config->fontDirs, d); } FcBool FcConfigAddDir (FcConfig *config, const FcChar8 *d) { return (FcConfigAddConfigDir (config, d) && FcConfigAddFontDir (config, d)); } FcStrList * FcConfigGetFontDirs (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return FcStrListCreate (config->fontDirs); } FcBool FcConfigAddCacheDir (FcConfig *config, const FcChar8 *d) { return FcStrSetAddFilename (config->cacheDirs, d); } FcStrList * FcConfigGetCacheDirs (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return FcStrListCreate (config->cacheDirs); } FcBool FcConfigAddConfigFile (FcConfig *config, const FcChar8 *f) { FcBool ret; FcChar8 *file = FcConfigFilename (f); if (!file) return FcFalse; ret = FcStrSetAdd (config->configFiles, file); FcStrFree (file); return ret; } FcStrList * FcConfigGetConfigFiles (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return FcStrListCreate (config->configFiles); } FcChar8 * FcConfigGetCache (FcConfig *config) { return NULL; } FcFontSet * FcConfigGetFonts (FcConfig *config, FcSetName set) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return config->fonts[set]; } void FcConfigSetFonts (FcConfig *config, FcFontSet *fonts, FcSetName set) { if (config->fonts[set]) FcFontSetDestroy (config->fonts[set]); config->fonts[set] = fonts; } FcBlanks * FcConfigGetBlanks (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return config->blanks; } FcBool FcConfigAddBlank (FcConfig *config, FcChar32 blank) { FcBlanks *b, *freeme = 0; b = config->blanks; if (!b) { freeme = b = FcBlanksCreate (); if (!b) return FcFalse; } if (!FcBlanksAdd (b, blank)) { if (freeme) FcBlanksDestroy (freeme); return FcFalse; } config->blanks = b; return FcTrue; } int FcConfigGetRescanInterval (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return 0; } return config->rescanInterval; } FcBool FcConfigSetRescanInterval (FcConfig *config, int rescanInterval) { if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } config->rescanInterval = rescanInterval; return FcTrue; } /* * A couple of typos escaped into the library */ int FcConfigGetRescanInverval (FcConfig *config) { return FcConfigGetRescanInterval (config); } FcBool FcConfigSetRescanInverval (FcConfig *config, int rescanInterval) { return FcConfigSetRescanInterval (config, rescanInterval); } FcBool FcConfigAddEdit (FcConfig *config, FcTest *test, FcEdit *edit, FcMatchKind kind) { FcSubst *subst, **prev; FcTest *t; int num; switch (kind) { case FcMatchPattern: prev = &config->substPattern; break; case FcMatchFont: prev = &config->substFont; break; case FcMatchScan: prev = &config->substScan; break; default: return FcFalse; } subst = (FcSubst *) malloc (sizeof (FcSubst)); if (!subst) return FcFalse; FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst)); for (; *prev; prev = &(*prev)->next); *prev = subst; subst->next = 0; subst->test = test; subst->edit = edit; num = 0; for (t = test; t; t = t->next) { if (t->kind == FcMatchDefault) t->kind = kind; num++; } if (config->maxObjects < num) config->maxObjects = num; if (FcDebug () & FC_DBG_EDIT) { printf ("Add Subst "); FcSubstPrint (subst); } return FcTrue; } typedef struct _FcSubState { FcPatternElt *elt; FcValueList *value; } FcSubState; static FcValue FcConfigPromote (FcValue v, FcValue u) { if (v.type == FcTypeInteger) { v.type = FcTypeDouble; v.u.d = (double) v.u.i; } else if (v.type == FcTypeVoid && u.type == FcTypeMatrix) { v.u.m = &FcIdentityMatrix; v.type = FcTypeMatrix; } else if (v.type == FcTypeString && u.type == FcTypeLangSet) { v.u.l = FcLangSetPromote (v.u.s); v.type = FcTypeLangSet; } return v; } FcBool FcConfigCompareValue (const FcValue *left_o, FcOp op, const FcValue *right_o) { FcValue left = FcValueCanonicalize(left_o); FcValue right = FcValueCanonicalize(right_o); FcBool ret = FcFalse; left = FcConfigPromote (left, right); right = FcConfigPromote (right, left); if (left.type == right.type) { switch (left.type) { case FcTypeInteger: break; /* FcConfigPromote prevents this from happening */ case FcTypeDouble: switch (op) { case FcOpEqual: case FcOpContains: case FcOpListing: ret = left.u.d == right.u.d; break; case FcOpNotEqual: case FcOpNotContains: ret = left.u.d != right.u.d; break; case FcOpLess: ret = left.u.d < right.u.d; break; case FcOpLessEqual: ret = left.u.d <= right.u.d; break; case FcOpMore: ret = left.u.d > right.u.d; break; case FcOpMoreEqual: ret = left.u.d >= right.u.d; break; default: break; } break; case FcTypeBool: switch (op) { case FcOpEqual: case FcOpContains: case FcOpListing: ret = left.u.b == right.u.b; break; case FcOpNotEqual: case FcOpNotContains: ret = left.u.b != right.u.b; break; default: break; } break; case FcTypeString: switch (op) { case FcOpEqual: case FcOpListing: ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0; break; case FcOpContains: ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0; break; case FcOpNotEqual: ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0; break; case FcOpNotContains: ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0; break; default: break; } break; case FcTypeMatrix: switch (op) { case FcOpEqual: case FcOpContains: case FcOpListing: ret = FcMatrixEqual (left.u.m, right.u.m); break; case FcOpNotEqual: case FcOpNotContains: ret = !FcMatrixEqual (left.u.m, right.u.m); break; default: break; } break; case FcTypeCharSet: switch (op) { case FcOpContains: case FcOpListing: /* left contains right if right is a subset of left */ ret = FcCharSetIsSubset (right.u.c, left.u.c); break; case FcOpNotContains: /* left contains right if right is a subset of left */ ret = !FcCharSetIsSubset (right.u.c, left.u.c); break; case FcOpEqual: ret = FcCharSetEqual (left.u.c, right.u.c); break; case FcOpNotEqual: ret = !FcCharSetEqual (left.u.c, right.u.c); break; default: break; } break; case FcTypeLangSet: switch (op) { case FcOpContains: case FcOpListing: ret = FcLangSetContains (left.u.l, right.u.l); break; case FcOpNotContains: ret = !FcLangSetContains (left.u.l, right.u.l); break; case FcOpEqual: ret = FcLangSetEqual (left.u.l, right.u.l); break; case FcOpNotEqual: ret = !FcLangSetEqual (left.u.l, right.u.l); break; default: break; } break; case FcTypeVoid: switch (op) { case FcOpEqual: case FcOpContains: case FcOpListing: ret = FcTrue; break; default: break; } break; case FcTypeFTFace: switch (op) { case FcOpEqual: case FcOpContains: case FcOpListing: ret = left.u.f == right.u.f; break; case FcOpNotEqual: case FcOpNotContains: ret = left.u.f != right.u.f; break; default: break; } break; } } else { if (op == FcOpNotEqual || op == FcOpNotContains) ret = FcTrue; } return ret; } #define _FcDoubleFloor(d) ((int) (d)) #define _FcDoubleCeil(d) ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1)) #define FcDoubleFloor(d) ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d))) #define FcDoubleCeil(d) ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d))) #define FcDoubleRound(d) FcDoubleFloor ((d) + 0.5) #define FcDoubleTrunc(d) ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d))) static FcValue FcConfigEvaluate (FcPattern *p, FcExpr *e) { FcValue v, vl, vr; FcResult r; FcMatrix *m; FcChar8 *str; switch (e->op) { case FcOpInteger: v.type = FcTypeInteger; v.u.i = e->u.ival; break; case FcOpDouble: v.type = FcTypeDouble; v.u.d = e->u.dval; break; case FcOpString: v.type = FcTypeString; v.u.s = e->u.sval; v = FcValueSave (v); break; case FcOpMatrix: v.type = FcTypeMatrix; v.u.m = e->u.mval; v = FcValueSave (v); break; case FcOpCharSet: v.type = FcTypeCharSet; v.u.c = e->u.cval; v = FcValueSave (v); break; case FcOpBool: v.type = FcTypeBool; v.u.b = e->u.bval; break; case FcOpField: r = FcPatternObjectGet (p, e->u.object, 0, &v); if (r != FcResultMatch) v.type = FcTypeVoid; v = FcValueSave (v); break; case FcOpConst: if (FcNameConstant (e->u.constant, &v.u.i)) v.type = FcTypeInteger; else v.type = FcTypeVoid; break; case FcOpQuest: vl = FcConfigEvaluate (p, e->u.tree.left); if (vl.type == FcTypeBool) { if (vl.u.b) v = FcConfigEvaluate (p, e->u.tree.right->u.tree.left); else v = FcConfigEvaluate (p, e->u.tree.right->u.tree.right); } else v.type = FcTypeVoid; FcValueDestroy (vl); break; case FcOpEqual: case FcOpNotEqual: case FcOpLess: case FcOpLessEqual: case FcOpMore: case FcOpMoreEqual: case FcOpContains: case FcOpNotContains: case FcOpListing: vl = FcConfigEvaluate (p, e->u.tree.left); vr = FcConfigEvaluate (p, e->u.tree.right); v.type = FcTypeBool; v.u.b = FcConfigCompareValue (&vl, e->op, &vr); FcValueDestroy (vl); FcValueDestroy (vr); break; case FcOpOr: case FcOpAnd: case FcOpPlus: case FcOpMinus: case FcOpTimes: case FcOpDivide: vl = FcConfigEvaluate (p, e->u.tree.left); vr = FcConfigEvaluate (p, e->u.tree.right); vl = FcConfigPromote (vl, vr); vr = FcConfigPromote (vr, vl); if (vl.type == vr.type) { switch (vl.type) { case FcTypeDouble: switch (e->op) { case FcOpPlus: v.type = FcTypeDouble; v.u.d = vl.u.d + vr.u.d; break; case FcOpMinus: v.type = FcTypeDouble; v.u.d = vl.u.d - vr.u.d; break; case FcOpTimes: v.type = FcTypeDouble; v.u.d = vl.u.d * vr.u.d; break; case FcOpDivide: v.type = FcTypeDouble; v.u.d = vl.u.d / vr.u.d; break; default: v.type = FcTypeVoid; break; } if (v.type == FcTypeDouble && v.u.d == (double) (int) v.u.d) { v.type = FcTypeInteger; v.u.i = (int) v.u.d; } break; case FcTypeBool: switch (e->op) { case FcOpOr: v.type = FcTypeBool; v.u.b = vl.u.b || vr.u.b; break; case FcOpAnd: v.type = FcTypeBool; v.u.b = vl.u.b && vr.u.b; break; default: v.type = FcTypeVoid; break; } break; case FcTypeString: switch (e->op) { case FcOpPlus: v.type = FcTypeString; str = FcStrPlus (vl.u.s, vr.u.s); v.u.s = FcStrStaticName (str); FcStrFree (str); if (!v.u.s) v.type = FcTypeVoid; break; default: v.type = FcTypeVoid; break; } break; case FcTypeMatrix: switch (e->op) { case FcOpTimes: v.type = FcTypeMatrix; m = malloc (sizeof (FcMatrix)); if (m) { FcMemAlloc (FC_MEM_MATRIX, sizeof (FcMatrix)); FcMatrixMultiply (m, vl.u.m, vr.u.m); v.u.m = m; } else { v.type = FcTypeVoid; } break; default: v.type = FcTypeVoid; break; } break; default: v.type = FcTypeVoid; break; } } else v.type = FcTypeVoid; FcValueDestroy (vl); FcValueDestroy (vr); break; case FcOpNot: vl = FcConfigEvaluate (p, e->u.tree.left); switch (vl.type) { case FcTypeBool: v.type = FcTypeBool; v.u.b = !vl.u.b; break; default: v.type = FcTypeVoid; break; } FcValueDestroy (vl); break; case FcOpFloor: vl = FcConfigEvaluate (p, e->u.tree.left); switch (vl.type) { case FcTypeInteger: v = vl; break; case FcTypeDouble: v.type = FcTypeInteger; v.u.i = FcDoubleFloor (vl.u.d); break; default: v.type = FcTypeVoid; break; } FcValueDestroy (vl); break; case FcOpCeil: vl = FcConfigEvaluate (p, e->u.tree.left); switch (vl.type) { case FcTypeInteger: v = vl; break; case FcTypeDouble: v.type = FcTypeInteger; v.u.i = FcDoubleCeil (vl.u.d); break; default: v.type = FcTypeVoid; break; } FcValueDestroy (vl); break; case FcOpRound: vl = FcConfigEvaluate (p, e->u.tree.left); switch (vl.type) { case FcTypeInteger: v = vl; break; case FcTypeDouble: v.type = FcTypeInteger; v.u.i = FcDoubleRound (vl.u.d); break; default: v.type = FcTypeVoid; break; } FcValueDestroy (vl); break; case FcOpTrunc: vl = FcConfigEvaluate (p, e->u.tree.left); switch (vl.type) { case FcTypeInteger: v = vl; break; case FcTypeDouble: v.type = FcTypeInteger; v.u.i = FcDoubleTrunc (vl.u.d); break; default: v.type = FcTypeVoid; break; } FcValueDestroy (vl); break; default: v.type = FcTypeVoid; break; } return v; } static FcValueList * FcConfigMatchValueList (FcPattern *p, FcTest *t, FcValueList *values) { FcValueList *ret = 0; FcExpr *e = t->expr; FcValue value; FcValueList *v; while (e) { /* Compute the value of the match expression */ if (e->op == FcOpComma) { value = FcConfigEvaluate (p, e->u.tree.left); e = e->u.tree.right; } else { value = FcConfigEvaluate (p, e); e = 0; } for (v = values; v; v = FcValueListNext(v)) { /* Compare the pattern value to the match expression value */ if (FcConfigCompareValue (&v->value, t->op, &value)) { if (!ret) ret = v; } else { if (t->qual == FcQualAll) { ret = 0; break; } } } FcValueDestroy (value); } return ret; } static FcValueList * FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding) { FcValueList *l; if (!e) return 0; l = (FcValueList *) malloc (sizeof (FcValueList)); if (!l) return 0; FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList)); if (e->op == FcOpComma) { l->value = FcConfigEvaluate (p, e->u.tree.left); l->next = FcConfigValues (p, e->u.tree.right, binding); } else { l->value = FcConfigEvaluate (p, e); l->next = NULL; } l->binding = binding; if (l->value.type == FcTypeVoid) { FcValueList *next = FcValueListNext(l); FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList)); free (l); l = next; } return l; } static FcBool FcConfigAdd (FcValueListPtr *head, FcValueList *position, FcBool append, FcValueList *new) { FcValueListPtr *prev, last, v; FcValueBinding sameBinding; if (position) sameBinding = position->binding; else sameBinding = FcValueBindingWeak; for (v = new; v != NULL; v = FcValueListNext(v)) if (v->binding == FcValueBindingSame) v->binding = sameBinding; if (append) { if (position) prev = &position->next; else for (prev = head; *prev != NULL; prev = &(*prev)->next) ; } else { if (position) { for (prev = head; *prev != NULL; prev = &(*prev)->next) { if (*prev == position) break; } } else prev = head; if (FcDebug () & FC_DBG_EDIT) { if (*prev == NULL) printf ("position not on list\n"); } } if (FcDebug () & FC_DBG_EDIT) { printf ("%s list before ", append ? "Append" : "Prepend"); FcValueListPrint (*head); printf ("\n"); } if (new) { last = new; while (last->next != NULL) last = last->next; last->next = *prev; *prev = new; } if (FcDebug () & FC_DBG_EDIT) { printf ("%s list after ", append ? "Append" : "Prepend"); FcValueListPrint (*head); printf ("\n"); } return FcTrue; } static void FcConfigDel (FcValueListPtr *head, FcValueList *position) { FcValueListPtr *prev; for (prev = head; *prev != NULL; prev = &(*prev)->next) { if (*prev == position) { *prev = position->next; position->next = NULL; FcValueListDestroy (position); break; } } } static void FcConfigPatternAdd (FcPattern *p, FcObject object, FcValueList *list, FcBool append) { if (list) { FcPatternElt *e = FcPatternObjectInsertElt (p, object); if (!e) return; FcConfigAdd (&e->values, 0, append, list); } } /* * Delete all values associated with a field */ static void FcConfigPatternDel (FcPattern *p, FcObject object) { FcPatternElt *e = FcPatternObjectFindElt (p, object); if (!e) return; while (e->values != NULL) FcConfigDel (&e->values, e->values); } static void FcConfigPatternCanon (FcPattern *p, FcObject object) { FcPatternElt *e = FcPatternObjectFindElt (p, object); if (!e) return; if (e->values == NULL) FcPatternObjectDel (p, object); } FcBool FcConfigSubstituteWithPat (FcConfig *config, FcPattern *p, FcPattern *p_pat, FcMatchKind kind) { FcSubst *s; FcSubState *st; int i; FcTest *t; FcEdit *e; FcValueList *l; FcPattern *m; if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } switch (kind) { case FcMatchPattern: s = config->substPattern; break; case FcMatchFont: s = config->substFont; break; case FcMatchScan: s = config->substScan; break; default: return FcFalse; } st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState)); if (!st && config->maxObjects) return FcFalse; FcMemAlloc (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState)); if (FcDebug () & FC_DBG_EDIT) { printf ("FcConfigSubstitute "); FcPatternPrint (p); } for (; s; s = s->next) { /* * Check the tests to see if * they all match the pattern */ for (t = s->test, i = 0; t; t = t->next, i++) { if (FcDebug () & FC_DBG_EDIT) { printf ("FcConfigSubstitute test "); FcTestPrint (t); } st[i].elt = 0; if (kind == FcMatchFont && t->kind == FcMatchPattern) m = p_pat; else m = p; if (m) st[i].elt = FcPatternObjectFindElt (m, t->object); else st[i].elt = 0; /* * If there's no such field in the font, * then FcQualAll matches while FcQualAny does not */ if (!st[i].elt) { if (t->qual == FcQualAll) { st[i].value = 0; continue; } else break; } /* * Check to see if there is a match, mark the location * to apply match-relative edits */ st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values); if (!st[i].value) break; if (t->qual == FcQualFirst && st[i].value != st[i].elt->values) break; if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values) break; } if (t) { if (FcDebug () & FC_DBG_EDIT) printf ("No match\n"); continue; } if (FcDebug () & FC_DBG_EDIT) { printf ("Substitute "); FcSubstPrint (s); } for (e = s->edit; e; e = e->next) { /* * Evaluate the list of expressions */ l = FcConfigValues (p, e->expr, e->binding); /* * Locate any test associated with this field, skipping * tests associated with the pattern when substituting in * the font */ for (t = s->test, i = 0; t; t = t->next, i++) { if ((t->kind == FcMatchFont || kind == FcMatchPattern) && t->object == e->object) { /* * KLUDGE - the pattern may have been reallocated or * things may have been inserted or deleted above * this element by other edits. Go back and find * the element again */ if (e != s->edit && st[i].elt) st[i].elt = FcPatternObjectFindElt (p, t->object); if (!st[i].elt) t = 0; break; } } switch (e->op) { case FcOpAssign: /* * If there was a test, then replace the matched * value with the new list of values */ if (t) { FcValueList *thisValue = st[i].value; FcValueList *nextValue = thisValue; /* * Append the new list of values after the current value */ FcConfigAdd (&st[i].elt->values, thisValue, FcTrue, l); /* * Delete the marked value */ if (thisValue) FcConfigDel (&st[i].elt->values, thisValue); /* * Adjust any pointers into the value list to ensure * future edits occur at the same place */ for (t = s->test, i = 0; t; t = t->next, i++) { if (st[i].value == thisValue) st[i].value = nextValue; } break; } /* fall through ... */ case FcOpAssignReplace: /* * Delete all of the values and insert * the new set */ FcConfigPatternDel (p, e->object); FcConfigPatternAdd (p, e->object, l, FcTrue); /* * Adjust any pointers into the value list as they no * longer point to anything valid */ if (t) { FcPatternElt *thisElt = st[i].elt; for (t = s->test, i = 0; t; t = t->next, i++) { if (st[i].elt == thisElt) st[i].value = 0; } } break; case FcOpPrepend: if (t) { FcConfigAdd (&st[i].elt->values, st[i].value, FcFalse, l); break; } /* fall through ... */ case FcOpPrependFirst: FcConfigPatternAdd (p, e->object, l, FcFalse); break; case FcOpAppend: if (t) { FcConfigAdd (&st[i].elt->values, st[i].value, FcTrue, l); break; } /* fall through ... */ case FcOpAppendLast: FcConfigPatternAdd (p, e->object, l, FcTrue); break; default: FcValueListDestroy (l); break; } } /* * Now go through the pattern and eliminate * any properties without data */ for (e = s->edit; e; e = e->next) FcConfigPatternCanon (p, e->object); if (FcDebug () & FC_DBG_EDIT) { printf ("FcConfigSubstitute edit"); FcPatternPrint (p); } } FcMemFree (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState)); free (st); if (FcDebug () & FC_DBG_EDIT) { printf ("FcConfigSubstitute done"); FcPatternPrint (p); } return FcTrue; } FcBool FcConfigSubstitute (FcConfig *config, FcPattern *p, FcMatchKind kind) { return FcConfigSubstituteWithPat (config, p, 0, kind); } #if defined (_WIN32) # define WIN32_LEAN_AND_MEAN # define WIN32_EXTRA_LEAN # include <windows.h> static FcChar8 fontconfig_path[1000] = ""; # if (defined (PIC) || defined (DLL_EXPORT)) BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { FcChar8 *p; switch (fdwReason) { case DLL_PROCESS_ATTACH: if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path, sizeof (fontconfig_path))) break; /* If the fontconfig DLL is in a "bin" or "lib" subfolder, * assume it's a Unix-style installation tree, and use * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the * folder where the DLL is as FONTCONFIG_PATH. */ p = strrchr (fontconfig_path, '\\'); if (p) { *p = '\0'; p = strrchr (fontconfig_path, '\\'); if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 || FcStrCmpIgnoreCase (p + 1, "lib") == 0)) *p = '\0'; strcat (fontconfig_path, "\\etc\\fonts"); } else fontconfig_path[0] = '\0'; break; } return TRUE; } # endif /* !PIC */ #undef FONTCONFIG_PATH #define FONTCONFIG_PATH fontconfig_path #endif /* !_WIN32 */ #ifndef FONTCONFIG_FILE #define FONTCONFIG_FILE "fonts.conf" #endif static FcChar8 * FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file) { FcChar8 *path; if (!dir) dir = (FcChar8 *) ""; path = malloc (strlen ((char *) dir) + 1 + strlen ((char *) file) + 1); if (!path) return 0; strcpy ((char *) path, (const char *) dir); /* make sure there's a single separator */ #ifdef _WIN32 if ((!path[0] || (path[strlen((char *) path)-1] != '/' && path[strlen((char *) path)-1] != '\\')) && !(file[0] == '/' || file[0] == '\\' || (isalpha (file[0]) && file[1] == ':' && (file[2] == '/' || file[2] == '\\')))) strcat ((char *) path, "\\"); #else if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/') strcat ((char *) path, "/"); #endif strcat ((char *) path, (char *) file); FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1); if (access ((char *) path, R_OK) == 0) return path; FcStrFree (path); return 0; } static FcChar8 ** FcConfigGetPath (void) { FcChar8 **path; FcChar8 *env, *e, *colon; FcChar8 *dir; int npath; int i; npath = 2; /* default dir + null */ env = (FcChar8 *) getenv ("FONTCONFIG_PATH"); if (env) { e = env; npath++; while (*e) if (*e++ == FC_SEARCH_PATH_SEPARATOR) npath++; } path = calloc (npath, sizeof (FcChar8 *)); if (!path) goto bail0; i = 0; if (env) { e = env; while (*e) { colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR); if (!colon) colon = e + strlen ((char *) e); path[i] = malloc (colon - e + 1); if (!path[i]) goto bail1; strncpy ((char *) path[i], (const char *) e, colon - e); path[i][colon - e] = '\0'; if (*colon) e = colon + 1; else e = colon; i++; } } #ifdef _WIN32 if (fontconfig_path[0] == '\0') { char *p; if(!GetModuleFileName(NULL, fontconfig_path, sizeof(fontconfig_path))) goto bail1; p = strrchr (fontconfig_path, '\\'); if (p) *p = '\0'; strcat (fontconfig_path, "\\fonts"); } #endif dir = (FcChar8 *) FONTCONFIG_PATH; path[i] = malloc (strlen ((char *) dir) + 1); if (!path[i]) goto bail1; strcpy ((char *) path[i], (const char *) dir); return path; bail1: for (i = 0; path[i]; i++) free (path[i]); free (path); bail0: return 0; } static void FcConfigFreePath (FcChar8 **path) { FcChar8 **p; for (p = path; *p; p++) free (*p); free (path); } static FcBool _FcConfigHomeEnabled = FcTrue; FcChar8 * FcConfigHome (void) { if (_FcConfigHomeEnabled) { char *home = getenv ("HOME"); #ifdef _WIN32 if (home == NULL) home = getenv ("USERPROFILE"); #endif return (FcChar8 *) home; } return 0; } FcBool FcConfigEnableHome (FcBool enable) { FcBool prev = _FcConfigHomeEnabled; _FcConfigHomeEnabled = enable; return prev; } FcChar8 * FcConfigFilename (const FcChar8 *url) { FcChar8 *file, *dir, **path, **p; if (!url || !*url) { url = (FcChar8 *) getenv ("FONTCONFIG_FILE"); if (!url) url = (FcChar8 *) FONTCONFIG_FILE; } file = 0; #ifdef _WIN32 if (isalpha (*url) && url[1] == ':' && (url[2] == '/' || url[2] == '\\')) goto absolute_path; #endif switch (*url) { case '~': dir = FcConfigHome (); if (dir) file = FcConfigFileExists (dir, url + 1); else file = 0; break; #ifdef _WIN32 case '\\': absolute_path: #endif case '/': file = FcConfigFileExists (0, url); break; default: path = FcConfigGetPath (); if (!path) return 0; for (p = path; *p; p++) { file = FcConfigFileExists (*p, url); if (file) break; } FcConfigFreePath (path); break; } return file; } /* * Manage the application-specific fonts */ FcBool FcConfigAppFontAddFile (FcConfig *config, const FcChar8 *file) { FcFontSet *set; FcStrSet *subdirs; FcStrList *sublist; FcChar8 *subdir; if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } subdirs = FcStrSetCreate (); if (!subdirs) return FcFalse; set = FcConfigGetFonts (config, FcSetApplication); if (!set) { set = FcFontSetCreate (); if (!set) { FcStrSetDestroy (subdirs); return FcFalse; } FcConfigSetFonts (config, set, FcSetApplication); } if (!FcFileScanConfig (set, subdirs, config->blanks, file, config)) { FcStrSetDestroy (subdirs); return FcFalse; } if ((sublist = FcStrListCreate (subdirs))) { while ((subdir = FcStrListNext (sublist))) { FcConfigAppFontAddDir (config, subdir); } FcStrListDone (sublist); } FcStrSetDestroy (subdirs); return FcTrue; } FcBool FcConfigAppFontAddDir (FcConfig *config, const FcChar8 *dir) { FcFontSet *set; FcStrSet *dirs; if (!config) { config = FcConfigGetCurrent (); if (!config) return FcFalse; } dirs = FcStrSetCreate (); if (!dirs) return FcFalse; set = FcConfigGetFonts (config, FcSetApplication); if (!set) { set = FcFontSetCreate (); if (!set) { FcStrSetDestroy (dirs); return FcFalse; } FcConfigSetFonts (config, set, FcSetApplication); } FcStrSetAddFilename (dirs, dir); if (!FcConfigAddDirList (config, FcSetApplication, dirs)) { FcStrSetDestroy (dirs); return FcFalse; } FcStrSetDestroy (dirs); return FcTrue; } void FcConfigAppFontClear (FcConfig *config) { if (!config) { config = FcConfigGetCurrent (); if (!config) return; } FcConfigSetFonts (config, 0, FcSetApplication); } /* * Manage filename-based font source selectors */ FcBool FcConfigGlobAdd (FcConfig *config, const FcChar8 *glob, FcBool accept) { FcStrSet *set = accept ? config->acceptGlobs : config->rejectGlobs; return FcStrSetAdd (set, glob); } static FcBool FcConfigGlobMatch (const FcChar8 *glob, const FcChar8 *string) { FcChar8 c; while ((c = *glob++)) { switch (c) { case '*': /* short circuit common case */ if (!*glob) return FcTrue; /* short circuit another common case */ if (strchr ((char *) glob, '*') == 0) string += strlen ((char *) string) - strlen ((char *) glob); while (*string) { if (FcConfigGlobMatch (glob, string)) return FcTrue; string++; } return FcFalse; case '?': if (*string++ == '\0') return FcFalse; break; default: if (*string++ != c) return FcFalse; break; } } return *string == '\0'; } static FcBool FcConfigGlobsMatch (const FcStrSet *globs, const FcChar8 *string) { int i; for (i = 0; i < globs->num; i++) if (FcConfigGlobMatch (globs->strs[i], string)) return FcTrue; return FcFalse; } FcBool FcConfigAcceptFilename (FcConfig *config, const FcChar8 *filename) { if (FcConfigGlobsMatch (config->acceptGlobs, filename)) return FcTrue; if (FcConfigGlobsMatch (config->rejectGlobs, filename)) return FcFalse; return FcTrue; } /* * Manage font-pattern based font source selectors */ FcBool FcConfigPatternsAdd (FcConfig *config, FcPattern *pattern, FcBool accept) { FcFontSet *set = accept ? config->acceptPatterns : config->rejectPatterns; return FcFontSetAdd (set, pattern); } static FcBool FcConfigPatternsMatch (const FcFontSet *patterns, const FcPattern *font) { int i; for (i = 0; i < patterns->nfont; i++) if (FcListPatternMatchAny (patterns->fonts[i], font)) return FcTrue; return FcFalse; } FcBool FcConfigAcceptFont (FcConfig *config, const FcPattern *font) { if (FcConfigPatternsMatch (config->acceptPatterns, font)) return FcTrue; if (FcConfigPatternsMatch (config->rejectPatterns, font)) return FcFalse; return FcTrue; } #define __fccfg__ #include "fcaliastail.h" #undef __fccfg__