diff --git a/doc/fclangset.fncs b/doc/fclangset.fncs index f9d578e..fd1634f 100644 --- a/doc/fclangset.fncs +++ b/doc/fclangset.fncs @@ -58,6 +58,36 @@ two or three letter language from ISO 639 and Tt is a territory from ISO 3166. @@ +@RET@ FcBool +@FUNC@ FcLangSetDel +@TYPE1@ FcLangSet * @ARG1@ ls +@TYPE2@ const FcChar8 * @ARG2@ lang +@PURPOSE@ remove a language from a langset +@DESC@ +lang is removed from ls. +lang should be of the form Ll-Tt where Ll is a +two or three letter language from ISO 639 and Tt is a territory from ISO +3166. +@@ + +@RET@ FcLangSet * +@FUNC@ FcLangSetUnion +@TYPE1@ const FcLangSet * @ARG1@ ls_a +@TYPE2@ const FcLangSet * @ARG2@ ls_b +@PURPOSE@ Add langsets +@DESC@ +Returns a set including only those languages found in either ls_a or ls_b. +@@ + +@RET@ FcLangSet * +@FUNC@ FcLangSetSubtract +@TYPE1@ const FcLangSet * @ARG1@ ls_a +@TYPE2@ const FcLangSet * @ARG2@ ls_b +@PURPOSE@ Subtract langsets +@DESC@ +Returns a set including only those languages found in ls_a but not ls_b. +@@ + @RET@ FcLangResult @FUNC@ FcLangSetCompare @TYPE1@ const FcLangSet * @ARG1@ ls_a diff --git a/doc/fontconfig-user.sgml b/doc/fontconfig-user.sgml index 219d906..b870825 100644 --- a/doc/fontconfig-user.sgml +++ b/doc/fontconfig-user.sgml @@ -431,6 +431,18 @@ instead of -.5). <literal><matrix></literal> This element holds the four <double> elements of an affine transformation. + + <literal><range></literal> +This element holds the two <int> elements of a range +representation. + + <literal><charset></literal> +This element holds at least one <int> element of +an Unicode code point or more. + + <literal><langset></literal> +This element holds at least one <string> element of +a RFC-3066-style languages or more. <literal><name></literal> Holds a property name. Evaluates to the first value from the property of diff --git a/fontconfig/fontconfig.h b/fontconfig/fontconfig.h index 260955d..29a6ed4 100644 --- a/fontconfig/fontconfig.h +++ b/fontconfig/fontconfig.h @@ -584,6 +584,9 @@ FcLangSetCopy (const FcLangSet *ls); FcPublic FcBool FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang); +FcPublic FcBool +FcLangSetDel (FcLangSet *ls, const FcChar8 *lang); + FcPublic FcLangResult FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang); @@ -602,6 +605,12 @@ FcLangSetHash (const FcLangSet *ls); FcPublic FcStrSet * FcLangSetGetLangs (const FcLangSet *ls); +FcLangSet * +FcLangSetUnion (const FcLangSet *a, const FcLangSet *b); + +FcLangSet * +FcLangSetSubtract (const FcLangSet *a, const FcLangSet *b); + /* fclist.c */ FcPublic FcObjectSet * FcObjectSetCreate (void); diff --git a/fonts.dtd b/fonts.dtd index cbdfdab..d9d4b22 100644 --- a/fonts.dtd +++ b/fonts.dtd @@ -107,7 +107,7 @@ - + - @@ -196,8 +196,9 @@ - - + + + diff --git a/src/Makefile.am b/src/Makefile.am index e300fe9..090f9b1 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -140,7 +140,7 @@ PUBLIC_FILES = \ $(top_srcdir)/fontconfig/fontconfig.h \ $(top_srcdir)/src/fcdeprecate.h \ $(top_srcdir)/fontconfig/fcprivate.h - + PUBLIC_FT_FILES = \ $(top_srcdir)/fontconfig/fcfreetype.h @@ -160,7 +160,7 @@ fontconfig.def: $(PUBLIC_FILES) $(PUBLIC_FT_FILES) echo Generating $@ (echo EXPORTS; \ (cat $(PUBLIC_FILES) $(PUBLIC_FT_FILES) || echo 'FcERROR ()' ) | \ - grep '^Fc[^ ]* *(' | sed -e 's/ *(.*$$//' -e 's/^/ /' | \ + grep '^Fc[^ ]* *(' | sed -e 's/ *(.*$$//' -e 's/^/ /' | \ sort; \ echo LIBRARY libfontconfig-@LIBT_CURRENT_MINUS_AGE@.dll; \ echo VERSION @LIBT_CURRENT@.@LIBT_REVISION@) >$@ diff --git a/src/fccfg.c b/src/fccfg.c index 19a9fef..6812781 100644 --- a/src/fccfg.c +++ b/src/fccfg.c @@ -897,6 +897,11 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) v.u.c = e->u.cval; v = FcValueSave (v); break; + case FcOpLangSet: + v.type = FcTypeLangSet; + v.u.l = e->u.lval; + v = FcValueSave (v); + break; case FcOpBool: v.type = FcTypeBool; v.u.b = e->u.bval; @@ -1036,6 +1041,44 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) break; } break; + case FcTypeCharSet: + switch (e->op) { + case FcOpPlus: + v.type = FcTypeCharSet; + v.u.c = FcCharSetUnion (vl.u.c, vr.u.c); + if (!v.u.c) + v.type = FcTypeVoid; + break; + case FcOpMinus: + v.type = FcTypeCharSet; + v.u.c = FcCharSetSubtract (vl.u.c, vr.u.c); + if (!v.u.c) + v.type = FcTypeVoid; + break; + default: + v.type = FcTypeVoid; + break; + } + break; + case FcTypeLangSet: + switch (e->op) { + case FcOpPlus: + v.type = FcTypeLangSet; + v.u.l = FcLangSetUnion (vl.u.l, vr.u.l); + if (!v.u.l) + v.type = FcTypeVoid; + break; + case FcOpMinus: + v.type = FcTypeLangSet; + v.u.l = FcLangSetSubtract (vl.u.l, vr.u.l); + if (!v.u.l) + v.type = FcTypeVoid; + break; + default: + v.type = FcTypeVoid; + break; + } + break; default: v.type = FcTypeVoid; break; diff --git a/src/fcdbg.c b/src/fcdbg.c index fc3b596..cf2ff08 100644 --- a/src/fcdbg.c +++ b/src/fcdbg.c @@ -160,8 +160,10 @@ FcOpPrint (FcOp op) case FcOpDouble: printf ("Double"); break; case FcOpString: printf ("String"); break; case FcOpMatrix: printf ("Matrix"); break; + case FcOpRange: printf ("Range"); break; case FcOpBool: printf ("Bool"); break; case FcOpCharSet: printf ("CharSet"); break; + case FcOpLangSet: printf ("LangSet"); break; case FcOpField: printf ("Field"); break; case FcOpConst: printf ("Const"); break; case FcOpAssign: printf ("Assign"); break; @@ -210,8 +212,14 @@ FcExprPrint (const FcExpr *expr) expr->u.mval->xy, expr->u.mval->yx, expr->u.mval->yy); break; + case FcOpRange: break; case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break; case FcOpCharSet: printf ("charset\n"); break; + case FcOpLangSet: + printf ("langset:"); + FcLangSetPrint(expr->u.lval); + printf ("\n"); + break; case FcOpNil: printf ("nil\n"); break; case FcOpField: printf ("%s", FcObjectName(expr->u.object)); break; case FcOpConst: printf ("%s", expr->u.constant); break; diff --git a/src/fcint.h b/src/fcint.h index a859913..e662c37 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -220,7 +220,7 @@ struct _FcPattern { fs->fonts[i]) typedef enum _FcOp { - FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet, + FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet, FcOpNil, FcOpField, FcOpConst, FcOpAssign, FcOpAssignReplace, @@ -243,6 +243,7 @@ typedef struct _FcExpr { FcMatrix *mval; FcBool bval; FcCharSet *cval; + FcLangSet *lval; FcObject object; FcChar8 *constant; struct { @@ -511,6 +512,13 @@ typedef struct _FcFileTime { typedef struct _FcCharMap FcCharMap; +typedef struct _FcRange FcRange; + +struct _FcRange { + FcChar32 begin; + FcChar32 end; +}; + /* fcblanks.c */ /* fccache.c */ diff --git a/src/fclang.c b/src/fclang.c index 1c78328..be42b58 100644 --- a/src/fclang.c +++ b/src/fclang.c @@ -71,6 +71,20 @@ FcLangSetBitGet (const FcLangSet *ls, return ((ls->map[bucket] >> (id & 0x1f)) & 1) ? FcTrue : FcFalse; } +static void +FcLangSetBitReset (FcLangSet *ls, + unsigned int id) +{ + int bucket; + + id = fcLangCharSetIndices[id]; + bucket = id >> 5; + if (bucket >= ls->map_size) + return; /* shouldn't happen really */ + + ls->map[bucket] &= ~((FcChar32) 1 << (id & 0x1f)); +} + FcLangSet * FcFreeTypeLangSet (const FcCharSet *charset, const FcChar8 *exclusiveLang) @@ -400,6 +414,23 @@ FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang) return FcStrSetAdd (ls->extra, lang); } +FcBool +FcLangSetDel (FcLangSet *ls, const FcChar8 *lang) +{ + int id; + + id = FcLangSetIndex (lang); + if (id >= 0) + { + FcLangSetBitReset (ls, id); + } + else if (ls->extra) + { + FcStrSetDel (ls->extra, lang); + } + return FcTrue; +} + FcLangResult FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang) { @@ -818,6 +849,37 @@ FcLangSetGetLangs (const FcLangSet *ls) return langs; } +static FcLangSet * +FcLangSetOperate(const FcLangSet *a, + const FcLangSet *b, + FcBool (*func) (FcLangSet *ls, + const FcChar8 *s)) +{ + FcLangSet *langset = FcLangSetCopy (a); + FcStrList *sl = FcStrListCreate (FcLangSetGetLangs (b)); + FcChar8 *str; + + while ((str = FcStrListNext (sl))) + { + func (langset, str); + } + FcStrListDone (sl); + + return langset; +} + +FcLangSet * +FcLangSetUnion (const FcLangSet *a, const FcLangSet *b) +{ + return FcLangSetOperate(a, b, FcLangSetAdd); +} + +FcLangSet * +FcLangSetSubtract (const FcLangSet *a, const FcLangSet *b) +{ + return FcLangSetOperate(a, b, FcLangSetDel); +} + #define __fclang__ #include "fcaliastail.h" #include "fcftaliastail.h" diff --git a/src/fcxml.c b/src/fcxml.c index 2bd67bf..1aa3e4c 100644 --- a/src/fcxml.c +++ b/src/fcxml.c @@ -133,6 +133,30 @@ FcExprCreateBool (FcConfig *config, FcBool b) return e; } +static FcExpr * +FcExprCreateCharSet (FcConfig *config, FcCharSet *charset) +{ + FcExpr *e = FcConfigAllocExpr (config); + if (e) + { + e->op = FcOpCharSet; + e->u.cval = FcCharSetCopy (charset); + } + return e; +} + +static FcExpr * +FcExprCreateLangSet (FcConfig *config, FcLangSet *langset) +{ + FcExpr *e = FcConfigAllocExpr (config); + if (e) + { + e->op = FcOpLangSet; + e->u.lval = FcLangSetCopy (langset); + } + return e; +} + static FcExpr * FcExprCreateField (FcConfig *config, const char *field) { @@ -185,9 +209,14 @@ FcExprDestroy (FcExpr *e) case FcOpMatrix: FcMatrixFree (e->u.mval); break; + case FcOpRange: + break; case FcOpCharSet: FcCharSetDestroy (e->u.cval); break; + case FcOpLangSet: + FcLangSetDestroy (e->u.lval); + break; case FcOpBool: break; case FcOpField: @@ -277,8 +306,10 @@ typedef enum _FcElement { FcElementDouble, FcElementString, FcElementMatrix, + FcElementRange, FcElementBool, - FcElementCharset, + FcElementCharSet, + FcElementLangSet, FcElementName, FcElementConst, FcElementOr, @@ -338,8 +369,10 @@ static const struct { { "double", FcElementDouble }, { "string", FcElementString }, { "matrix", FcElementMatrix }, + { "range", FcElementRange }, { "bool", FcElementBool }, - { "charset", FcElementCharset }, + { "charset", FcElementCharSet }, + { "langset", FcElementLangSet }, { "name", FcElementName }, { "const", FcElementConst }, { "or", FcElementOr }, @@ -401,7 +434,10 @@ typedef enum _FcVStackTag { FcVStackInteger, FcVStackDouble, FcVStackMatrix, + FcVStackRange, FcVStackBool, + FcVStackCharSet, + FcVStackLangSet, FcVStackTest, FcVStackExpr, @@ -418,7 +454,10 @@ typedef struct _FcVStack { int integer; double _double; FcMatrix *matrix; + FcRange range; FcBool bool_; + FcCharSet *charset; + FcLangSet *langset; FcTest *test; FcQual qual; @@ -551,6 +590,9 @@ FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type) case FcOpCharSet: FcTypecheckValue (parse, FcTypeCharSet, type); break; + case FcOpLangSet: + FcTypecheckValue (parse, FcTypeLangSet, type); + break; case FcOpNil: break; case FcOpField: @@ -741,6 +783,18 @@ FcVStackPushMatrix (FcConfigParse *parse, FcMatrix *matrix) return FcTrue; } +static FcBool +FcVStackPushRange (FcConfigParse *parse, FcRange *range) +{ + FcVStack *vstack = FcVStackCreateAndPush (parse); + if (!vstack) + return FcFalse; + vstack->u.range.begin = range->begin; + vstack->u.range.end = range->end; + vstack->tag = FcVStackRange; + return FcTrue; +} + static FcBool FcVStackPushBool (FcConfigParse *parse, FcBool bool_) { @@ -752,6 +806,34 @@ FcVStackPushBool (FcConfigParse *parse, FcBool bool_) return FcTrue; } +static FcBool +FcVStackPushCharSet (FcConfigParse *parse, FcCharSet *charset) +{ + FcVStack *vstack; + if (!charset) + return FcFalse; + vstack = FcVStackCreateAndPush (parse); + if (!vstack) + return FcFalse; + vstack->u.charset = charset; + vstack->tag = FcVStackCharSet; + return FcTrue; +} + +static FcBool +FcVStackPushLangSet (FcConfigParse *parse, FcLangSet *langset) +{ + FcVStack *vstack; + if (!langset) + return FcFalse; + vstack = FcVStackCreateAndPush (parse); + if (!vstack) + return FcFalse; + vstack->u.langset = langset; + vstack->tag = FcVStackLangSet; + return FcTrue; +} + static FcBool FcVStackPushTest (FcConfigParse *parse, FcTest *test) { @@ -843,8 +925,15 @@ FcVStackPopAndDestroy (FcConfigParse *parse) case FcVStackMatrix: FcMatrixFree (vstack->u.matrix); break; + case FcVStackRange: case FcVStackBool: break; + case FcVStackCharSet: + FcCharSetDestroy (vstack->u.charset); + break; + case FcVStackLangSet: + FcLangSetDestroy (vstack->u.langset); + break; case FcVStackTest: FcTestDestroy (vstack->u.test); break; @@ -1042,30 +1131,37 @@ FcStartElement(void *userData, const XML_Char *name, const XML_Char **attr) static void FcParseBlank (FcConfigParse *parse) { - int n = FcVStackElements (parse); + int n = FcVStackElements (parse); + FcChar32 i; while (n-- > 0) { FcVStack *v = FcVStackFetch (parse, n); - if (v->tag != FcVStackInteger) - FcConfigMessage (parse, FcSevereError, "non-integer blank"); - else + if (!parse->config->blanks) { + parse->config->blanks = FcBlanksCreate (); if (!parse->config->blanks) - { - parse->config->blanks = FcBlanksCreate (); - if (!parse->config->blanks) - { - FcConfigMessage (parse, FcSevereError, "out of memory"); - break; - } - } + goto bail; + } + switch (v->tag) { + case FcVStackInteger: if (!FcBlanksAdd (parse->config->blanks, v->u.integer)) + goto bail; + break; + case FcVStackRange: + for (i = v->u.range.begin; i <= v->u.range.end; i++) { - FcConfigMessage (parse, FcSevereError, "out of memory"); - break; + if (!FcBlanksAdd (parse->config->blanks, i)) + goto bail; } + break; + default: + FcConfigMessage (parse, FcSevereError, "invalid element in blank"); + break; } } + return; + bail: + FcConfigMessage (parse, FcSevereError, "out of memory"); } static void @@ -1241,6 +1337,49 @@ FcParseMatrix (FcConfigParse *parse) FcVStackPushMatrix (parse, &m); } +static void +FcParseRange (FcConfigParse *parse) +{ + FcVStack *vstack; + FcRange r; + FcChar32 n; + int count = 1; + + while ((vstack = FcVStackPeek (parse))) + { + if (count < 0) + { + FcConfigMessage (parse, FcSevereError, "too many elements in range"); + return; + } + switch (vstack->tag) { + case FcVStackInteger: + n = vstack->u.integer; + break; + default: + FcConfigMessage (parse, FcSevereError, "invalid element in range"); + break; + } + if (count == 1) + r.end = n; + else + r.begin = n; + count--; + FcVStackPopAndDestroy (parse); + } + if (count < 0) + { + if (r.begin > r.end) + { + FcConfigMessage (parse, FcSevereError, "invalid range"); + return; + } + FcVStackPushRange (parse, &r); + } + else + FcConfigMessage (parse, FcSevereError, "invalid range"); +} + static FcBool FcConfigLexBool (FcConfigParse *parse, const FcChar8 *bool_) { @@ -1269,6 +1408,78 @@ FcParseBool (FcConfigParse *parse) FcStrBufDestroy (&parse->pstack->str); } +static void +FcParseCharSet (FcConfigParse *parse) +{ + FcVStack *vstack; + FcCharSet *charset = FcCharSetCreate (); + FcChar32 i; + int n = 0; + + while ((vstack = FcVStackPeek (parse))) + { + switch (vstack->tag) { + case FcVStackInteger: + if (!FcCharSetAddChar (charset, vstack->u.integer)) + { + FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", vstack->u.integer); + } + else + n++; + break; + case FcVStackRange: + for (i = vstack->u.range.begin; i <= vstack->u.range.end; i++) + { + if (!FcCharSetAddChar (charset, i)) + { + FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", i); + } + else + n++; + } + break; + default: + FcConfigMessage (parse, FcSevereError, "invalid element in charset"); + break; + } + FcVStackPopAndDestroy (parse); + } + if (n > 0) + FcVStackPushCharSet (parse, charset); + else + FcCharSetDestroy (charset); +} + +static void +FcParseLangSet (FcConfigParse *parse) +{ + FcVStack *vstack; + FcLangSet *langset = FcLangSetCreate (); + int n = 0; + + while ((vstack = FcVStackPeek (parse))) + { + switch (vstack->tag) { + case FcVStackString: + if (!FcLangSetAdd (langset, vstack->u.string)) + { + FcConfigMessage (parse, FcSevereWarning, "invalid langset: %s", vstack->u.string); + } + else + n++; + break; + default: + FcConfigMessage (parse, FcSevereError, "invalid element in langset"); + break; + } + FcVStackPopAndDestroy (parse); + } + if (n > 0) + FcVStackPushLangSet (parse, langset); + else + FcLangSetDestroy (langset); +} + static FcBool FcConfigLexBinding (FcConfigParse *parse, const FcChar8 *binding_string, @@ -1515,9 +1726,17 @@ FcPopExpr (FcConfigParse *parse) case FcVStackMatrix: expr = FcExprCreateMatrix (parse->config, vstack->u.matrix); break; + case FcVStackRange: + break; case FcVStackBool: expr = FcExprCreateBool (parse->config, vstack->u.bool_); break; + case FcVStackCharSet: + expr = FcExprCreateCharSet (parse->config, vstack->u.charset); + break; + case FcVStackLangSet: + expr = FcExprCreateLangSet (parse->config, vstack->u.langset); + break; case FcVStackTest: break; case FcVStackExpr: @@ -1934,6 +2153,16 @@ FcPopValue (FcConfigParse *parse) value.u.b = vstack->u.bool_; value.type = FcTypeBool; break; + case FcVStackCharSet: + value.u.c = FcCharSetCopy (vstack->u.charset); + if (value.u.c) + value.type = FcTypeCharSet; + break; + case FcVStackLangSet: + value.u.l = FcLangSetCopy (vstack->u.langset); + if (value.u.l) + value.type = FcTypeLangSet; + break; default: FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d", vstack->tag); @@ -2199,11 +2428,17 @@ FcEndElement(void *userData, const XML_Char *name) case FcElementMatrix: FcParseMatrix (parse); break; + case FcElementRange: + FcParseRange (parse); + break; case FcElementBool: FcParseBool (parse); break; - case FcElementCharset: -/* FcParseCharset (parse); */ + case FcElementCharSet: + FcParseCharSet (parse); + break; + case FcElementLangSet: + FcParseLangSet (parse); break; case FcElementSelectfont: break;