From 857b7efe1e301f670329c6836da52fbab8c5df66 Mon Sep 17 00:00:00 2001 From: Akira TAGOH Date: Mon, 6 Dec 2010 12:10:17 +0900 Subject: [PATCH 1/5] Add charset editing feature. The syntax to add any characters to the charset table looks like: Buggy Sans charset 0x3220 To remove any characters from the charset table: Buggy Sans charset 0x06CC 0x06D2 0x06D3 You could also use the range element for convenience: ... 0x06CC 0x06D2 0x06D3 ... --- fonts.dtd | 4 +- src/Makefile.am | 4 +- src/fccfg.c | 19 ++++++ src/fcdbg.c | 2 + src/fcint.h | 9 ++- src/fcxml.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++-- 6 files changed, 185 insertions(+), 9 deletions(-) diff --git a/fonts.dtd b/fonts.dtd index cbdfdab..5f21e35 100644 --- a/fonts.dtd +++ b/fonts.dtd @@ -196,8 +196,8 @@ - - + + diff --git a/src/Makefile.am b/src/Makefile.am index 59b9c75..96500b4 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..ad9f7d2 100644 --- a/src/fccfg.c +++ b/src/fccfg.c @@ -1036,6 +1036,25 @@ 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; default: v.type = FcTypeVoid; break; diff --git a/src/fcdbg.c b/src/fcdbg.c index fc3b596..79e1953 100644 --- a/src/fcdbg.c +++ b/src/fcdbg.c @@ -160,6 +160,7 @@ 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 FcOpField: printf ("Field"); break; @@ -210,6 +211,7 @@ 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 FcOpNil: printf ("nil\n"); break; diff --git a/src/fcint.h b/src/fcint.h index 2bc7878..9519fff 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -216,7 +216,7 @@ struct _FcPattern { fs->fonts[i]) typedef enum _FcOp { - FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet, + FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpNil, FcOpField, FcOpConst, FcOpAssign, FcOpAssignReplace, @@ -507,6 +507,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/fcxml.c b/src/fcxml.c index 2bd67bf..94e2d4b 100644 --- a/src/fcxml.c +++ b/src/fcxml.c @@ -133,6 +133,18 @@ 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 * FcExprCreateField (FcConfig *config, const char *field) { @@ -185,6 +197,8 @@ FcExprDestroy (FcExpr *e) case FcOpMatrix: FcMatrixFree (e->u.mval); break; + case FcOpRange: + break; case FcOpCharSet: FcCharSetDestroy (e->u.cval); break; @@ -277,8 +291,9 @@ typedef enum _FcElement { FcElementDouble, FcElementString, FcElementMatrix, + FcElementRange, FcElementBool, - FcElementCharset, + FcElementCharSet, FcElementName, FcElementConst, FcElementOr, @@ -338,8 +353,9 @@ static const struct { { "double", FcElementDouble }, { "string", FcElementString }, { "matrix", FcElementMatrix }, + { "range", FcElementRange }, { "bool", FcElementBool }, - { "charset", FcElementCharset }, + { "charset", FcElementCharSet }, { "name", FcElementName }, { "const", FcElementConst }, { "or", FcElementOr }, @@ -401,7 +417,9 @@ typedef enum _FcVStackTag { FcVStackInteger, FcVStackDouble, FcVStackMatrix, + FcVStackRange, FcVStackBool, + FcVStackCharSet, FcVStackTest, FcVStackExpr, @@ -418,7 +436,9 @@ typedef struct _FcVStack { int integer; double _double; FcMatrix *matrix; + FcRange range; FcBool bool_; + FcCharSet *charset; FcTest *test; FcQual qual; @@ -741,6 +761,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 +784,20 @@ 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 FcVStackPushTest (FcConfigParse *parse, FcTest *test) { @@ -843,8 +889,12 @@ FcVStackPopAndDestroy (FcConfigParse *parse) case FcVStackMatrix: FcMatrixFree (vstack->u.matrix); break; + case FcVStackRange: case FcVStackBool: break; + case FcVStackCharSet: + FcCharSetDestroy (vstack->u.charset); + break; case FcVStackTest: FcTestDestroy (vstack->u.test); break; @@ -1241,6 +1291,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 +1362,48 @@ 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 FcBool FcConfigLexBinding (FcConfigParse *parse, const FcChar8 *binding_string, @@ -1515,9 +1650,14 @@ 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 FcVStackTest: break; case FcVStackExpr: @@ -1934,6 +2074,11 @@ 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; default: FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d", vstack->tag); @@ -2199,11 +2344,14 @@ 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 FcElementSelectfont: break; From 51e352a1bde91348888202539639a5a2d0d506d4 Mon Sep 17 00:00:00 2001 From: Akira TAGOH Date: Thu, 9 Dec 2010 11:32:26 +0900 Subject: [PATCH 2/5] add some document for range and charset. --- doc/fontconfig-user.sgml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/fontconfig-user.sgml b/doc/fontconfig-user.sgml index 219d906..ce6f158 100644 --- a/doc/fontconfig-user.sgml +++ b/doc/fontconfig-user.sgml @@ -431,6 +431,14 @@ 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><name></literal> Holds a property name. Evaluates to the first value from the property of From d975cdda782bb88c8bb6706889a554b2afb9f939 Mon Sep 17 00:00:00 2001 From: Akira TAGOH Date: Mon, 6 Dec 2010 12:18:23 +0900 Subject: [PATCH 3/5] Add the range support in blank element --- src/fcxml.c | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/src/fcxml.c b/src/fcxml.c index 94e2d4b..4d07f9d 100644 --- a/src/fcxml.c +++ b/src/fcxml.c @@ -1092,30 +1092,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 From 3c862aad9f49be4b098cb679a67449c85b58f1f5 Mon Sep 17 00:00:00 2001 From: Akira TAGOH Date: Mon, 6 Dec 2010 12:38:18 +0900 Subject: [PATCH 4/5] Add editing langset feature. The syntax to add any langset to the langset table looks like: Buggy Sans lang zh-cn zh-tw To remove any langset from the langset table: Buggy Sans lang ja --- fontconfig/fontconfig.h | 9 +++++ fonts.dtd | 5 +-- src/fccfg.c | 24 +++++++++++++ src/fcdbg.c | 6 ++++ src/fcint.h | 3 +- src/fclang.c | 62 ++++++++++++++++++++++++++++++++ src/fcxml.c | 80 +++++++++++++++++++++++++++++++++++++++++ 7 files changed, 186 insertions(+), 3 deletions(-) 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 5f21e35..d9d4b22 100644 --- a/fonts.dtd +++ b/fonts.dtd @@ -107,7 +107,7 @@ - + - @@ -198,6 +198,7 @@ + diff --git a/src/fccfg.c b/src/fccfg.c index ad9f7d2..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; @@ -1055,6 +1060,25 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e) 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 79e1953..cf2ff08 100644 --- a/src/fcdbg.c +++ b/src/fcdbg.c @@ -163,6 +163,7 @@ FcOpPrint (FcOp op) 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; @@ -214,6 +215,11 @@ FcExprPrint (const FcExpr *expr) 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 9519fff..3da6ec4 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -216,7 +216,7 @@ struct _FcPattern { fs->fonts[i]) typedef enum _FcOp { - FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, + FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet, FcOpNil, FcOpField, FcOpConst, FcOpAssign, FcOpAssignReplace, @@ -239,6 +239,7 @@ typedef struct _FcExpr { FcMatrix *mval; FcBool bval; FcCharSet *cval; + FcLangSet *lval; FcObject object; FcChar8 *constant; struct { 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 4d07f9d..1aa3e4c 100644 --- a/src/fcxml.c +++ b/src/fcxml.c @@ -145,6 +145,18 @@ FcExprCreateCharSet (FcConfig *config, FcCharSet *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) { @@ -202,6 +214,9 @@ FcExprDestroy (FcExpr *e) case FcOpCharSet: FcCharSetDestroy (e->u.cval); break; + case FcOpLangSet: + FcLangSetDestroy (e->u.lval); + break; case FcOpBool: break; case FcOpField: @@ -294,6 +309,7 @@ typedef enum _FcElement { FcElementRange, FcElementBool, FcElementCharSet, + FcElementLangSet, FcElementName, FcElementConst, FcElementOr, @@ -356,6 +372,7 @@ static const struct { { "range", FcElementRange }, { "bool", FcElementBool }, { "charset", FcElementCharSet }, + { "langset", FcElementLangSet }, { "name", FcElementName }, { "const", FcElementConst }, { "or", FcElementOr }, @@ -420,6 +437,7 @@ typedef enum _FcVStackTag { FcVStackRange, FcVStackBool, FcVStackCharSet, + FcVStackLangSet, FcVStackTest, FcVStackExpr, @@ -439,6 +457,7 @@ typedef struct _FcVStack { FcRange range; FcBool bool_; FcCharSet *charset; + FcLangSet *langset; FcTest *test; FcQual qual; @@ -571,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: @@ -798,6 +820,20 @@ FcVStackPushCharSet (FcConfigParse *parse, FcCharSet *charset) 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) { @@ -895,6 +931,9 @@ FcVStackPopAndDestroy (FcConfigParse *parse) case FcVStackCharSet: FcCharSetDestroy (vstack->u.charset); break; + case FcVStackLangSet: + FcLangSetDestroy (vstack->u.langset); + break; case FcVStackTest: FcTestDestroy (vstack->u.test); break; @@ -1411,6 +1450,36 @@ FcParseCharSet (FcConfigParse *parse) 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, @@ -1665,6 +1734,9 @@ FcPopExpr (FcConfigParse *parse) 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: @@ -2086,6 +2158,11 @@ FcPopValue (FcConfigParse *parse) 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); @@ -2360,6 +2437,9 @@ FcEndElement(void *userData, const XML_Char *name) case FcElementCharSet: FcParseCharSet (parse); break; + case FcElementLangSet: + FcParseLangSet (parse); + break; case FcElementSelectfont: break; case FcElementAcceptfont: From fa269cf812ee304534b0e4c44662202496008db0 Mon Sep 17 00:00:00 2001 From: Akira TAGOH Date: Thu, 9 Dec 2010 11:57:24 +0900 Subject: [PATCH 5/5] add some documents --- doc/fclangset.fncs | 30 ++++++++++++++++++++++++++++++ doc/fontconfig-user.sgml | 4 ++++ 2 files changed, 34 insertions(+) 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 ce6f158..b870825 100644 --- a/doc/fontconfig-user.sgml +++ b/doc/fontconfig-user.sgml @@ -439,6 +439,10 @@ 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