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

Replace silly avl sort with qsort, add FcPatternEqual

This commit is contained in:
Keith Packard 2002-05-22 04:37:07 +00:00
parent 446bb9c9e0
commit 0ab36ca8f9
8 changed files with 162 additions and 515 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
fontconfig/fontconfig.h
View File

@ -1,5 +1,5 @@
/* /*
* $XFree86: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.5 2002/03/01 01:00:54 keithp Exp $ * $XFree86: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.8 2002/05/21 17:06:22 keithp Exp $
* *
* Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
* *
@ -557,12 +557,18 @@ FcPatternDuplicate (FcPattern *p);
void void
FcValueDestroy (FcValue v); FcValueDestroy (FcValue v);
FcBool
FcValueEqual (FcValue va, FcValue vb);
FcValue FcValue
FcValueSave (FcValue v); FcValueSave (FcValue v);
void void
FcPatternDestroy (FcPattern *p); FcPatternDestroy (FcPattern *p);
FcBool
FcPatternEqual (FcPattern *pa, FcPattern *pb);
FcBool FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append); FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);

6
src/Imakefile
View File

@ -23,16 +23,16 @@ SOFONTCONFIGREV=1.0
INCLUDES=$(FREETYPE2INCLUDES) $(LIBXML2INCLUDES) -I.. INCLUDES=$(FREETYPE2INCLUDES) $(LIBXML2INCLUDES) -I..
DEFINES=-DFC_DEFAULT_FONTS='"$(FC_DEFAULT_FONTS)"' DEFINES=-DFC_DEFAULT_FONTS='"$(FC_DEFAULT_FONTS)"' -DHAVE_EXPAT
EXPATLIB=-lexpat EXPATLIB=-lexpat
REQUIREDLIBS=$(LDPRELIBS) $(FREETYPE2LIB) $(EXPATLIB) REQUIREDLIBS=$(LDPRELIBS) $(FREETYPE2LIB) $(EXPATLIB)
SRCS=fcatomic.c fcavl.c fcblanks.c fccache.c fccfg.c fccharset.c fcdbg.c \ SRCS=fcatomic.c fcblanks.c fccache.c fccfg.c fccharset.c fcdbg.c \
fcdefault.c fcdir.c fcfreetype.c fcfs.c fcinit.c fclist.c fcmatch.c \ fcdefault.c fcdir.c fcfreetype.c fcfs.c fcinit.c fclist.c fcmatch.c \
fcmatrix.c fcname.c fcpat.c fcstr.c fcxml.c fcmatrix.c fcname.c fcpat.c fcstr.c fcxml.c
OBJS=fcatomic.o fcavl.o fcblanks.o fccache.o fccfg.o fccharset.o fcdbg.o \ OBJS=fcatomic.o fcblanks.o fccache.o fccfg.o fccharset.o fcdbg.o \
fcdefault.o fcdir.o fcfreetype.o fcfs.o fcinit.o fclist.o fcmatch.o \ fcdefault.o fcdir.o fcfreetype.o fcfs.o fcinit.o fclist.o fcmatch.o \
fcmatrix.o fcname.o fcpat.o fcstr.o fcxml.o fcmatrix.o fcname.o fcpat.o fcstr.o fcxml.o

4
src/Makefile.in
View File

@ -1,5 +1,5 @@
# #
# $XFree86$ # $XFree86: xc/lib/fontconfig/src/Makefile.in,v 1.2 2002/05/21 17:48:15 keithp Exp $
# #
# Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. # Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
# #
@ -29,7 +29,6 @@ include $(TOPDIR)/config/Makedefs
LIBS=@LIBS@ LIBS=@LIBS@
SRCS=fcatomic.c \ SRCS=fcatomic.c \
fcavl.c \
fcblanks.c \ fcblanks.c \
fccache.c \ fccache.c \
fccfg.c \ fccfg.c \
@ -49,7 +48,6 @@ SRCS=fcatomic.c \
fcxml.c fcxml.c
OBJS=fcatomic.@OBJEXT@ \ OBJS=fcatomic.@OBJEXT@ \
fcavl.@OBJEXT@ \
fcblanks.@OBJEXT@ \ fcblanks.@OBJEXT@ \
fccache.@OBJEXT@ \ fccache.@OBJEXT@ \
fccfg.@OBJEXT@ \ fccfg.@OBJEXT@ \

419
src/fcavl.c
View File

@ -1,419 +0,0 @@
/*
* $XFree86: $
*
* Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
*
* 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.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD 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.
*/
/*
* Semi-Balanced trees (avl). This only contains two
* routines - insert and delete. Searching is
* reserved for the client to write.
*/
#include "fcint.h"
#include "fcavl.h"
static FcBool
FcAvlRebalanceRight (FcAvlNode **);
static FcBool
FcAvlRebalanceLeft (FcAvlNode **);
/*
* insert a new node
*
* this routine returns FcTrue if the tree has grown
* taller
*/
FcBool
FcAvlInsert (FcAvlMore more, FcAvlNode **treep, FcAvlNode *new)
{
if (!(*treep))
{
new->left = 0;
new->right = 0;
new->balance = 0;
*treep = new;
return FcTrue;
}
else
{
if ((*more) (new, *treep))
{
if (FcAvlInsert (more, &(*treep)->right, new))
switch (++(*treep)->balance) {
case 0:
return FcFalse;
case 1:
return FcTrue;
case 2:
(void) FcAvlRebalanceRight (treep);
}
}
else
{
if (FcAvlInsert (more, &(*treep)->left, new))
switch (--(*treep)->balance) {
case 0:
return FcFalse;
case -1:
return FcTrue;
case -2:
(void) FcAvlRebalanceLeft (treep);
}
}
}
return 0;
}
/*
* delete a node from a tree
*
* this routine return FcTrue if the tree has been shortened
*/
FcBool
FcAvlDelete (FcAvlMore more, FcAvlNode **treep, FcAvlNode *old)
{
if (!*treep)
return FcFalse; /* node not found */
if (old == *treep)
{
FcAvlNode *replacement;
FcAvlNode *replacement_parent;
int replacement_direction;
int delete_direction;
FcAvlNode *swap_temp;
int balance_temp;
/*
* find an empty down pointer (if any)
* and rehook the tree
*/
if (!old->right) {
(*treep) = old->left;
return FcTrue;
} else if (!old->left) {
(*treep) = old->right;
return FcTrue;
} else {
/*
* if both down pointers are full, then
* move a node from the bottom of the tree up here.
*
* This builds an incorrect tree -- the replacement
* node and the old node will not
* be in correct order. This doesn't matter as
* the old node will obviously not leave
* this routine alive.
*/
/*
* if the tree is left heavy, then go left
* else go right
*/
replacement_parent = old;
if (old->balance == -1) {
delete_direction = -1;
replacement_direction = -1;
replacement = old->left;
while (replacement->right) {
replacement_parent = replacement;
replacement_direction = 1;
replacement = replacement->right;
}
} else {
delete_direction = 1;
replacement_direction = 1;
replacement = old->right;
while (replacement->left) {
replacement_parent = replacement;
replacement_direction = -1;
replacement = replacement->left;
}
}
/*
* swap the replacement node into
* the tree where the node is to be removed
*
* this would be faster if only the data
* element was swapped -- but that
* won't work for kalypso. The alternate
* code would be:
data_temp = old->data;
to _be_deleted->data = replacement->data;
replacement->data = data_temp;
*/
swap_temp = old->left;
old->left = replacement->left;
replacement->left = swap_temp;
swap_temp = old->right;
old->right = replacement->right;
replacement->right = swap_temp;
balance_temp = old->balance;
old->balance = replacement->balance;
replacement->balance = balance_temp;
/*
* if the replacement node is directly below
* the to-be-removed node, hook the old
* node below it (instead of below itself!)
*/
if (replacement_parent == old)
replacement_parent = replacement;
if (replacement_direction == -1)
replacement_parent->left = old;
else
replacement_parent->right = old;
(*treep) = replacement;
/*
* delete the node from the sub-tree
*/
if (delete_direction == -1)
{
if (FcAvlDelete (more, &(*treep)->left, old))
{
switch (++(*treep)->balance) {
case 2:
abort ();
case 1:
return FcFalse;
case 0:
return FcTrue;
}
}
return 0;
}
else
{
if (FcAvlDelete (more, &(*treep)->right, old))
{
switch (--(*treep)->balance) {
case -2:
abort ();
case -1:
return FcFalse;
case 0:
return FcTrue;
}
}
return 0;
}
}
}
else if ((*more) (old, *treep))
{
if (FcAvlDelete (more, &(*treep)->right, old))
{
/*
* check the balance factors
* Note that the conditions are
* inverted from the insertion case
*/
switch (--(*treep)->balance) {
case 0:
return FcFalse;
case -1:
return FcTrue;
case -2:
return FcAvlRebalanceLeft (treep);
}
}
return 0;
}
else
{
if (FcAvlDelete (more, &(*treep)->left, old))
{
switch (++(*treep)->balance) {
case 0:
return FcTrue;
case 1:
return FcFalse;
case 2:
return FcAvlRebalanceRight (treep);
}
}
return 0;
}
/*NOTREACHED*/
}
/*
* two routines to rebalance the tree.
*
* rebalance_right -- the right sub-tree is too long
* rebalance_left -- the left sub-tree is too long
*
* These routines are the heart of avl trees, I've tried
* to make their operation reasonably clear with comments,
* but some study will be necessary to understand the
* algorithm.
*
* these routines return FcTrue if the resultant
* tree is shorter than the un-balanced version. This
* is only of interest to the delete routine as the
* balance after insertion can never actually shorten
* the tree.
*/
static FcBool
FcAvlRebalanceRight (FcAvlNode **treep)
{
FcAvlNode *temp;
/*
* rebalance the tree
*/
if ((*treep)->right->balance == -1) {
/*
* double whammy -- the inner sub-sub tree
* is longer than the outer sub-sub tree
*
* this is the "double rotation" from
* knuth. Scheme: replace the tree top node
* with the inner sub-tree top node and
* adjust the maze of pointers and balance
* factors accordingly.
*/
temp = (*treep)->right->left;
(*treep)->right->left = temp->right;
temp->right = (*treep)->right;
switch (temp->balance) {
case -1:
temp->right->balance = 1;
(*treep)->balance = 0;
break;
case 0:
temp->right->balance = 0;
(*treep)->balance = 0;
break;
case 1:
temp->right->balance = 0;
(*treep)->balance = -1;
break;
}
temp->balance = 0;
(*treep)->right = temp->left;
temp->left = (*treep);
(*treep) = temp;
return FcTrue;
} else {
/*
* a simple single rotation
*
* Scheme: replace the tree top node
* with the sub-tree top node
*/
temp = (*treep)->right->left;
(*treep)->right->left = (*treep);
(*treep) = (*treep)->right;
(*treep)->left->right = temp;
/*
* only two possible configurations --
* if the right sub-tree was balanced, then
* *both* sides of it were longer than the
* left side, so the resultant tree will
* have a long leg (the left inner leg being
* the same length as the right leg)
*/
if ((*treep)->balance == 0) {
(*treep)->balance = -1;
(*treep)->left->balance = 1;
return FcFalse;
} else {
(*treep)->balance = 0;
(*treep)->left->balance = 0;
return FcTrue;
}
}
}
static FcBool
FcAvlRebalanceLeft (FcAvlNode **treep)
{
FcAvlNode *temp;
/*
* rebalance the tree
*/
if ((*treep)->left->balance == 1) {
/*
* double whammy -- the inner sub-sub tree
* is longer than the outer sub-sub tree
*
* this is the "double rotation" from
* knuth. Scheme: replace the tree top node
* with the inner sub-tree top node and
* adjust the maze of pointers and balance
* factors accordingly.
*/
temp = (*treep)->left->right;
(*treep)->left->right = temp->left;
temp->left = (*treep)->left;
switch (temp->balance) {
case 1:
temp->left->balance = -1;
(*treep)->balance = 0;
break;
case 0:
temp->left->balance = 0;
(*treep)->balance = 0;
break;
case -1:
temp->left->balance = 0;
(*treep)->balance = 1;
break;
}
temp->balance = 0;
(*treep)->left = temp->right;
temp->right = (*treep);
(*treep) = temp;
return FcTrue;
} else {
/*
* a simple single rotation
*
* Scheme: replace the tree top node
* with the sub-tree top node
*/
temp = (*treep)->left->right;
(*treep)->left->right = (*treep);
(*treep) = (*treep)->left;
(*treep)->right->left = temp;
/*
* only two possible configurations --
* if the left sub-tree was balanced, then
* *both* sides of it were longer than the
* right side, so the resultant tree will
* have a long leg (the right inner leg being
* the same length as the left leg)
*/
if ((*treep)->balance == 0) {
(*treep)->balance = 1;
(*treep)->right->balance = -1;
return FcTrue;
} else {
(*treep)->balance = 0;
(*treep)->right->balance = 0;
return FcFalse;
}
}
}

46
src/fcavl.h
View File

@ -1,46 +0,0 @@
/*
* $XFree86: $
*
* Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
*
* 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.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD 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.
*/
#ifndef _FCAVL_H_
#define _FCAVL_H_
/*
* fcavl.h
*
* balanced binary tree
*/
typedef struct _FcAvlNode FcAvlNode;
struct _FcAvlNode {
FcAvlNode *left, *right;
short balance;
};
typedef FcBool (*FcAvlMore) (FcAvlNode *a, FcAvlNode *b);
FcBool FcAvlInsert (FcAvlMore more, FcAvlNode **tree, FcAvlNode *leaf);
int FcAvlDelete (FcAvlMore more, FcAvlNode **tree, FcAvlNode *leaf);
#endif /* _FCAVL_H_ */

54
src/fcmatch.c
View File

@ -383,43 +383,39 @@ FcFontMatch (FcConfig *config,
return FcFontSetMatch (config, sets, nsets, p, result); return FcFontSetMatch (config, sets, nsets, p, result);
} }
#include "fcavl.h"
typedef struct _FcSortNode { typedef struct _FcSortNode {
FcAvlNode avl;
FcPattern *pattern; FcPattern *pattern;
double score[NUM_MATCHER]; double score[NUM_MATCHER];
} FcSortNode; } FcSortNode;
static FcBool static int
FcSortMore (FcAvlNode *aa, FcAvlNode *ab) FcSortCompare (const void *aa, const void *ab)
{ {
FcSortNode *a = (FcSortNode *) aa; FcSortNode *a = *(FcSortNode **) aa;
FcSortNode *b = (FcSortNode *) ab; FcSortNode *b = *(FcSortNode **) ab;
int i; int i;
for (i = 0; i < NUM_MATCHER; i++) for (i = 0; i < NUM_MATCHER; i++)
{ {
if (a->score[i] > b->score[i]) if (a->score[i] > b->score[i])
return FcTrue; return -1;
if (a->score[i] < b->score[i]) if (a->score[i] < b->score[i])
return FcFalse; return 1;
} }
if (aa > ab) return 0;
return FcTrue;
return FcFalse;
} }
static FcBool static FcBool
FcSortWalk (FcSortNode *n, FcFontSet *fs, FcCharSet **cs, FcBool trim) FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **cs, FcBool trim)
{ {
FcCharSet *ncs; FcCharSet *ncs;
FcSortNode *node;
if (!n) while (nnode--)
return FcTrue; {
if (!FcSortWalk ((FcSortNode *) n->avl.left, fs, cs, trim)) node = *n++;
return FcFalse; if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) ==
if (FcPatternGetCharSet (n->pattern, FC_CHARSET, 0, &ncs) == FcResultMatch) FcResultMatch)
{ {
if (!trim || !*cs || FcCharSetSubtractCount (ncs, *cs) != 0) if (!trim || !*cs || FcCharSetSubtractCount (ncs, *cs) != 0)
{ {
@ -433,12 +429,11 @@ FcSortWalk (FcSortNode *n, FcFontSet *fs, FcCharSet **cs, FcBool trim)
else else
ncs = FcCharSetCopy (ncs); ncs = FcCharSetCopy (ncs);
*cs = ncs; *cs = ncs;
if (!FcFontSetAdd (fs, n->pattern)) if (!FcFontSetAdd (fs, node->pattern))
return FcFalse; return FcFalse;
} }
} }
if (!FcSortWalk ((FcSortNode *) n->avl.right, fs, cs, trim)) }
return FcFalse;
return FcTrue; return FcTrue;
} }
@ -454,8 +449,8 @@ FcFontSetSort (FcConfig *config,
FcFontSet *ret; FcFontSet *ret;
FcFontSet *s; FcFontSet *s;
FcSortNode *nodes; FcSortNode *nodes;
FcSortNode **nodeps, **nodep;
int nnodes; int nnodes;
FcSortNode *root;
FcSortNode *new; FcSortNode *new;
FcCharSet *cs; FcCharSet *cs;
int set; int set;
@ -472,12 +467,13 @@ FcFontSetSort (FcConfig *config,
} }
if (!nnodes) if (!nnodes)
goto bail0; goto bail0;
nodes = malloc (nnodes * sizeof (FcSortNode)); nodes = malloc (nnodes * sizeof (FcSortNode) + nnodes * sizeof (FcSortNode *));
if (!nodes) if (!nodes)
goto bail0; goto bail0;
nodeps = (FcSortNode **) nodes + nnodes;
root = 0;
new = nodes; new = nodes;
nodep = nodeps;
for (set = 0; set < nsets; set++) for (set = 0; set < nsets; set++)
{ {
s = sets[set]; s = sets[set];
@ -502,18 +498,24 @@ FcFontSetSort (FcConfig *config,
} }
printf ("\n"); printf ("\n");
} }
FcAvlInsert (FcSortMore, (FcAvlNode **) &root, &new->avl); *nodep = new;
new++; new++;
nodep++;
} }
} }
nnodes = new - nodes;
qsort (nodeps, sizeof (FcSortNode *), nnodes,
FcSortCompare);
ret = FcFontSetCreate (); ret = FcFontSetCreate ();
if (!ret) if (!ret)
goto bail1; goto bail1;
cs = 0; cs = 0;
if (!FcSortWalk (root, ret, &cs, trim)) if (!FcSortWalk (nodeps, nnodes, ret, &cs, trim))
goto bail2; goto bail2;
*csp = cs; *csp = cs;

109
src/fcpat.c
View File

@ -1,5 +1,5 @@
/* /*
* $XFree86: xc/lib/fontconfig/src/fcpat.c,v 1.2 2002/02/15 06:01:28 keithp Exp $ * $XFree86: xc/lib/fontconfig/src/fcpat.c,v 1.3 2002/02/19 07:50:44 keithp Exp $
* *
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
* *
@ -109,6 +109,58 @@ FcValueListDestroy (FcValueList *l)
} }
} }
FcBool
FcValueEqual (FcValue va, FcValue vb)
{
if (va.type != vb.type)
{
if (va.type == FcTypeInteger)
{
va.type = FcTypeDouble;
va.u.d = va.u.i;
}
if (vb.type == FcTypeInteger)
{
vb.type = FcTypeDouble;
vb.u.d = vb.u.i;
}
if (va.type != vb.type)
return FcFalse;
}
switch (va.type) {
case FcTypeVoid:
return FcTrue;
case FcTypeInteger:
return va.u.i == vb.u.i;
case FcTypeDouble:
return va.u.d == vb.u.d;
case FcTypeString:
return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
case FcTypeBool:
return va.u.b == vb.u.b;
case FcTypeMatrix:
return FcMatrixEqual (va.u.m, vb.u.m);
case FcTypeCharSet:
return FcCharSetEqual (va.u.c, vb.u.c);
}
return FcFalse;
}
static FcBool
FcValueListEqual (FcValueList *la, FcValueList *lb)
{
while (la && lb)
{
if (!FcValueEqual (la->value, lb->value))
return FcFalse;
la = la->next;
lb = lb->next;
}
if (la || lb)
return FcFalse;
return FcTrue;
}
void void
FcPatternDestroy (FcPattern *p) FcPatternDestroy (FcPattern *p)
{ {
@ -136,18 +188,40 @@ FcPatternFind (FcPattern *p, const char *object, FcBool insert)
int s; int s;
FcPatternElt *e; FcPatternElt *e;
int low, high;
/* match existing */ /* match existing */
for (i = 0; i < p->num; i++) low = 0;
high = p->num;
while (low + 1 < high)
{ {
if (!FcStrCmpIgnoreCase ((FcChar8 *) object, (FcChar8 *) p->elts[i].object)) i = (low + high) >> 1;
s = FcStrCmpIgnoreCase ((FcChar8 *) object, (FcChar8 *) p->elts[i].object);
if (s == 0)
return &p->elts[i]; return &p->elts[i];
if (s < 0)
low = i;
else
high = i;
}
i = low;
while (i < high)
{
s = FcStrCmpIgnoreCase ((FcChar8 *) object, (FcChar8 *) p->elts[i].object);
if (s == 0)
return &p->elts[i];
if (s > 0)
break;
i++;
} }
if (!insert) if (!insert)
return FcFalse; return 0;
/* grow array */ /* grow array */
if (i == p->size) if (p->num + 1 >= p->size)
{ {
s = p->size + 16; s = p->size + 16;
if (p->elts) if (p->elts)
@ -168,14 +242,39 @@ FcPatternFind (FcPattern *p, const char *object, FcBool insert)
} }
} }
/* move elts up */
memmove (p->elts + i + 1,
p->elts + i,
sizeof (FcPatternElt) *
(p->num - i));
/* bump count */ /* bump count */
p->num++; p->num++;
p->elts[i].object = object; p->elts[i].object = object;
p->elts[i].values = 0;
return &p->elts[i]; return &p->elts[i];
} }
FcBool
FcPatternEqual (FcPattern *pa, FcPattern *pb)
{
int i;
if (pa->num != pb->num)
return FcFalse;
for (i = 0; i < pa->num; i++)
{
if (FcStrCmpIgnoreCase ((FcChar8 *) pa->elts[i].object,
(FcChar8 *) pb->elts[i].object) != 0)
return FcFalse;
if (!FcValueListEqual (pa->elts[i].values, pb->elts[i].values))
return FcFalse;
}
return FcTrue;
}
FcBool FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append) FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
{ {

9
src/fcxml.c
View File

@ -1,5 +1,5 @@
/* /*
* $XFree86: xc/lib/fontconfig/src/fcxml.c,v 1.6 2002/02/28 16:51:48 keithp Exp $ * $XFree86: xc/lib/fontconfig/src/fcxml.c,v 1.7 2002/05/21 17:06:22 keithp Exp $
* *
* Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
* *
@ -24,11 +24,18 @@
#include <stdarg.h> #include <stdarg.h>
#include "fcint.h" #include "fcint.h"
#if HAVE_EXPAT
#if HAVE_XMLPARSE_H #if HAVE_XMLPARSE_H
#include <xmlparse.h> #include <xmlparse.h>
#else #else
#include <expat.h> #include <expat.h>
#endif #endif
#endif
#if HAVE_XML2
#include "fclibxml2.h"
#endif
FcTest * FcTest *
FcTestCreate (FcQual qual, const FcChar8 *field, FcOp compare, FcExpr *expr) FcTestCreate (FcQual qual, const FcChar8 *field, FcOp compare, FcExpr *expr)