fc-arch/fc-arch.c | 14
fc-arch/fcarch.tmpl.h | 7
fc-lang/fc-lang.c | 186 ++++----
fontconfig/fontconfig.h | 3
src/Makefile.am | 1
src/fccache.c | 581 ++++++++++-----------------
src/fccfg.c | 102 ++--
src/fccharset.c | 493 +++++++---------------
src/fcdbg.c | 43 +-
src/fcdefault.c | 64 +-
src/fcfs.c | 133 +-----
src/fcint.h | 481 +++++++++++++---------
src/fclang.c | 120 +----
src/fclist.c | 86 +---
src/fcmatch.c | 179 +++-----
src/fcname.c | 142 +-----
src/fcpat.c | 1029 ++++++++++++++----------------------------------
src/fcserialize.c | 159 +++++++
src/fcstr.c | 1
src/fcxml.c | 15
20 files changed, 1563 insertions(+), 2276 deletions(-)
New commits:
diff-tree e3096d90fd3e0ba8b62d2c6df4cfb24f08a0766c (from 7ce196733129b0e664c1bdc20f973f15167292f7)
Author: Keith Packard <keithp@xxxxxxxxxxxxxxx>
Date: Wed Aug 30 04:24:03 2006 -0700
Fix build problems caused by cache rework.
Pagesize no longer matters in architecture decisions, the entire cache file
is mmaped into the library. However, lots of intptr_t values are in use now,
so that value is important.
fc-lang now requires fcserialize.c, which has been added to the repository.
diff --git a/fc-arch/fc-arch.c b/fc-arch/fc-arch.c
index 0179034..2fa6b18 100644
--- a/fc-arch/fc-arch.c
+++ b/fc-arch/fc-arch.c
@@ -26,9 +26,6 @@
#define ENDIAN_TEST 0x12345678
#define MACHINE_SIGNATURE_SIZE (9*21 + 1)
-#define MACHINE_ARCH_SIZE 32
-/* for when we don't have sysconf: */
-#define FC_HARDCODED_PAGESIZE 8192
static char *
FcCacheMachineSignature (void)
@@ -44,11 +41,12 @@ FcCacheMachineSignature (void)
(unsigned int)sizeof (char),
(unsigned int)sizeof (char *),
(unsigned int)sizeof (int),
+ (unsigned int)sizeof (intptr_t),
(unsigned int)sizeof (FcPattern),
(unsigned int)sizeof (FcPatternEltPtr),
(unsigned int)sizeof (struct FcPatternElt *),
(unsigned int)sizeof (FcPatternElt),
- (unsigned int)sizeof (FcObjectPtr),
+ (unsigned int)sizeof (FcObject),
(unsigned int)sizeof (FcValueListPtr),
(unsigned int)sizeof (FcValue),
(unsigned int)sizeof (FcValueBinding),
@@ -59,13 +57,7 @@ FcCacheMachineSignature (void)
(unsigned int)sizeof (FcChar16),
(unsigned int)sizeof (FcCharLeaf),
(unsigned int)sizeof (FcChar32),
- (unsigned int)sizeof (FcCache),
-#if defined (HAVE_SYSCONF)
- (unsigned int)sysconf(_SC_PAGESIZE)
-#else
- (unsigned int)FC_HARDCODED_PAGESIZE
-#endif
- );
+ (unsigned int)sizeof (FcCache));
return buf;
}
diff --git a/fc-arch/fcarch.tmpl.h b/fc-arch/fcarch.tmpl.h
index 4cf483f..b0712e5 100644
--- a/fc-arch/fcarch.tmpl.h
+++ b/fc-arch/fcarch.tmpl.h
@@ -28,8 +28,8 @@
@@@ name. Architecture names are used to construct file names, so
@@@ use something reasonable and don't include any spaces
@@@
-@@@ name endian char char* int Pattern EltPtr Elt * Elt ObjPtr VLPtr Value Binding VL * CharSet Leaf** Char16 * Char16 Leaf Char32 Cache PageSize
-x86 78563412_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_0000000c_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00001000
+@@@ name endian char char* int intptr_t Pattern EltPtr Elt * Elt ObjPtr VLPtr Value Binding VL * CharSet Leaf** Char16 * Char16 Leaf Char32 Cache
+x86 78563412_00000001_00000004_00000004_00000004_00000010_00000004_00000004_00000008_00000004_00000004_0000000c_00000004_00000004_00000010_00000004_00000004_00000002_00000020_00000004_00000018
x86-64 78563412_00000001_00000008_00000004_00000020_00000010_00000008_00000018_00000004_00000010_00000010_00000004_00000008_00000020_00000008_00000008_00000002_00000020_00000004_00000040_00001000
ppc-4k 12345678_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_00000010_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00001000
ppc-64k 12345678_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_00000010_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00010000
diff --git a/fc-lang/fc-lang.c b/fc-lang/fc-lang.c
index 631411d..324a0b2 100644
--- a/fc-lang/fc-lang.c
+++ b/fc-lang/fc-lang.c
@@ -25,6 +25,7 @@
#include "fcint.h"
#include "fccharset.c"
#include "fcstr.c"
+#include "fcserialize.c"
/*
* fc-lang
diff --git a/src/fcserialize.c b/src/fcserialize.c
new file mode 100644
index 0000000..5a4b4af
--- /dev/null
+++ b/src/fcserialize.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright © 2006 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 the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS 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"
+
+typedef union _FcAlign {
+ double d;
+ int i;
+ intptr_t ip;
+ off_t o;
+ FcBool b;
+ void *p;
+} FcAlign;
+
+intptr_t
+FcAlignSize (intptr_t size)
+{
+ intptr_t rem = size % sizeof (FcAlign);
+ if (rem)
+ size += sizeof (FcAlign) - rem;
+ return size;
+}
+
+/*
+ * Serialization helper object -- allocate space in the
+ * yet-to-be-created linear array for a serialized font set
+ */
+
+FcSerialize *
+FcSerializeCreate (void)
+{
+ FcSerialize *serialize;
+
+ serialize = malloc (sizeof (FcSerialize));
+ if (!serialize)
+ return NULL;
+ serialize->size = 0;
+ serialize->linear = NULL;
+ memset (serialize->buckets, '\0', sizeof (serialize->buckets));
+ return serialize;
+}
+
+void
+FcSerializeDestroy (FcSerialize *serialize)
+{
+ uintptr_t bucket;
+
+ for (bucket = 0; bucket < FC_SERIALIZE_HASH_SIZE; bucket++)
+ {
+ FcSerializeBucket *buck, *next;
+
+ for (buck = serialize->buckets[bucket]; buck; buck = next) {
+ next = buck->next;
+ free (buck);
+ }
+ }
+ free (serialize);
+}
+
+/*
+ * Allocate space for an object in the serialized array. Keep track
+ * of where the object is placed and only allocate one copy of each object
+ */
+
+FcBool
+FcSerializeAlloc (FcSerialize *serialize, const void *object, int size)
+{
+ uintptr_t bucket = ((uintptr_t) object) % FC_SERIALIZE_HASH_SIZE;
+ FcSerializeBucket *buck;
+
+ for (buck = serialize->buckets[bucket]; buck; buck = buck->next)
+ if (buck->object == object)
+ return FcTrue;
+ buck = malloc (sizeof (FcSerializeBucket));
+ if (!buck)
+ return FcFalse;
+ buck->object = object;
+ buck->offset = serialize->size;
+ buck->next = serialize->buckets[bucket];
+ serialize->buckets[bucket] = buck;
+ serialize->size += FcAlignSize (size);
+ return FcTrue;
+}
+
+/*
+ * Reserve space in the serialization array
+ */
+intptr_t
+FcSerializeReserve (FcSerialize *serialize, int size)
+{
+ intptr_t offset = serialize->size;
+ serialize->size += FcAlignSize (size);
+ return offset;
+}
+
+/*
+ * Given an object, return the offset in the serialized array where
+ * the serialized copy of the object is stored
+ */
+intptr_t
+FcSerializeOffset (FcSerialize *serialize, const void *object)
+{
+ uintptr_t bucket = ((uintptr_t) object) % FC_SERIALIZE_HASH_SIZE;
+ FcSerializeBucket *buck;
+
+ for (buck = serialize->buckets[bucket]; buck; buck = buck->next)
+ if (buck->object == object)
+ return buck->offset;
+ return 0;
+}
+
+/*
+ * Given a cache and an object, return a pointer to where
+ * the serialized copy of the object is stored
+ */
+void *
+FcSerializePtr (FcSerialize *serialize, const void *object)
+{
+ intptr_t offset = FcSerializeOffset (serialize, object);
+
+ if (!offset)
+ return NULL;
+ return (void *) ((char *) serialize->linear + offset);
+}
+
+FcBool
+FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str)
+{
+ return FcSerializeAlloc (serialize, str, strlen ((const char *) str) + 1);
+}
+
+FcChar8 *
+FcStrSerialize (FcSerialize *serialize, const FcChar8 *str)
+{
+ FcChar8 *str_serialize = FcSerializePtr (serialize, str);
+ if (!str_serialize)
+ return NULL;
+ strcpy ((char *) str_serialize, (const char *) str);
+ return str_serialize;
+}
diff-tree 7ce196733129b0e664c1bdc20f973f15167292f7 (from 2a9179d8895c1cc90d02917f7bb6fac30ffb6a62)
Author: Keith Packard <keithp@xxxxxxxxxxxxxxx>
Date: Wed Aug 30 04:16:22 2006 -0700
Rework cache files to use offsets for all data structures.
Replace all of the bank/id pairs with simple offsets, recode several
data structures to always use offsets inside the library to avoid
conditional paths. Exposed data structures use pointers to hold offsets,
setting the low bit to distinguish between offset and pointer.
Use offset-based data structures for lang charset encodings; eliminates
separate data structure format for that file.
Much testing will be needed; offsets are likely not detected everywhere in
the library yet.
diff --git a/fc-arch/fcarch.tmpl.h b/fc-arch/fcarch.tmpl.h
index 6e89ad9..4cf483f 100644
--- a/fc-arch/fcarch.tmpl.h
+++ b/fc-arch/fcarch.tmpl.h
@@ -31,4 +31,5 @@
@@@ name endian char char* int Pattern EltPtr Elt * Elt ObjPtr VLPtr Value Binding VL * CharSet Leaf** Char16 * Char16 Leaf Char32 Cache PageSize
x86 78563412_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_0000000c_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00001000
x86-64 78563412_00000001_00000008_00000004_00000020_00000010_00000008_00000018_00000004_00000010_00000010_00000004_00000008_00000020_00000008_00000008_00000002_00000020_00000004_00000040_00001000
-ppc 12345678_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_00000010_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00001000
+ppc-4k 12345678_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_00000010_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00001000
+ppc-64k 12345678_00000001_00000004_00000004_00000018_00000008_00000004_0000000c_00000004_00000008_00000010_00000004_00000004_00000014_00000004_00000004_00000002_00000020_00000004_00000038_00010000
diff --git a/fc-lang/fc-lang.c b/fc-lang/fc-lang.c
index b72893b..631411d 100644
--- a/fc-lang/fc-lang.c
+++ b/fc-lang/fc-lang.c
@@ -37,10 +37,6 @@
* functions are also needed in slightly modified form
*/
-const FcChar16 langBankNumbers[1]; /* place holders so that externs resolve */
-const FcCharLeaf langBankLeaves[1];
-const int langBankLeafIdx[1];
-
void
FcMemAlloc (int kind, int size)
{
@@ -51,18 +47,6 @@ FcMemFree (int kind, int size)
{
}
-int* _fcBankId = 0;
-int* _fcBankIdx = 0;
-FcValueList ** _fcValueLists = 0;
-FcPatternElt ** _fcPatternElts = 0;
-int FcDebugVal = 0;
-
-int
-FcCacheBankToIndexMTF (int bank)
-{
- return -1;
-}
-
FcChar8 *
FcConfigHome (void)
{
@@ -239,19 +223,18 @@ main (int argc, char **argv)
static char *files[MAX_LANG];
static FcCharSet *sets[MAX_LANG];
static int duplicate[MAX_LANG];
- static int offsets[MAX_LANG];
static int country[MAX_LANG];
static char *names[MAX_LANG];
static char *langs[MAX_LANG];
+ static int off[MAX_LANG];
FILE *f;
- int offset = 0;
int ncountry = 0;
int i = 0;
+ int nsets = 0;
int argi;
FcCharLeaf **leaves;
int total_leaves = 0;
- int offset_count = 0;
- int l, sl, tl;
+ int l, sl, tl, tn;
static char line[1024];
static FcChar32 map[MAX_LANG_SET_MAP];
int num_lang_set_map;
@@ -290,6 +273,7 @@ main (int argc, char **argv)
i++;
fclose (f);
}
+ nsets = i;
sets[i] = 0;
leaves = malloc (total_leaves * sizeof (FcCharLeaf *));
tl = 0;
@@ -301,10 +285,10 @@ main (int argc, char **argv)
for (sl = 0; sl < sets[i]->num; sl++)
{
for (l = 0; l < tl; l++)
- if (leaves[l] == FcCharSetGetLeaf(sets[i], sl))
+ if (leaves[l] == FcCharSetLeaf(sets[i], sl))
break;
if (l == tl)
- leaves[tl++] = FcCharSetGetLeaf(sets[i], sl);
+ leaves[tl++] = FcCharSetLeaf(sets[i], sl);
}
}
@@ -321,22 +305,6 @@ main (int argc, char **argv)
printf ("/* total size: %d unique leaves: %d */\n\n",
total_leaves, tl);
- /*
- * Dump leaves
- */
- printf ("const FcCharLeaf langBankLeaves[%d] = {\n", tl);
- for (l = 0; l < tl; l++)
- {
- printf (" { { /* %d */", l);
- for (i = 0; i < 256/32; i++)
- {
- if (i % 4 == 0)
- printf ("\n ");
- printf (" 0x%08x,", leaves[l]->map[i]);
- }
- printf ("\n } },\n");
- }
- printf ("};\n\n");
/*
* Find duplicate charsets
@@ -355,111 +323,121 @@ main (int argc, char **argv)
}
}
+ tn = 0;
+ for (i = 0; sets[i]; i++) {
+ if (duplicate[i] >= 0)
+ continue;
+ off[i] = tn;
+ tn += sets[i]->num;
+ }
+
+ printf ("#define LEAF0 (%d * sizeof (FcLangCharSet))\n", nsets);
+ printf ("#define OFF0 (LEAF0 + %d * sizeof (FcCharLeaf))\n", tl);
+ printf ("#define NUM0 (OFF0 + %d * sizeof (intptr_t))\n", tn);
+ printf ("#define SET(n) (n * sizeof (FcLangCharSet) + offsetof (FcLangCharSet, charset))\n");
+ printf ("#define OFF(s,o) (OFF0 + o * sizeof (intptr_t) - SET(s))\n");
+ printf ("#define NUM(s,n) (NUM0 + n * sizeof (FcChar16) - SET(s))\n");
+ printf ("#define LEAF(o,l) (LEAF0 + l * sizeof (FcCharLeaf) - (OFF0 + o * sizeof (intptr_t)))\n");
+ printf ("#define fcLangCharSets (fcLangData.langCharSets)\n");
+ printf ("\n");
+
+ printf ("static const struct {\n"
+ " FcLangCharSet langCharSets[%d];\n"
+ " FcCharLeaf leaves[%d];\n"
+ " intptr_t leaf_offsets[%d];\n"
+ " FcChar16 numbers[%d];\n"
+ "} fcLangData = {\n",
+ nsets, tl, tn, tn);
+
/*
- * Find ranges for each letter for faster searching
+ * Dump sets
*/
- setRangeChar = 'a';
+
+ printf ("{\n");
for (i = 0; sets[i]; i++)
{
- char c = names[i][0];
-
- while (setRangeChar <= c && c <= 'z')
- setRangeStart[setRangeChar++ - 'a'] = i;
+ int j = duplicate[i];
+
+ if (j < 0)
+ j = i;
+
+ printf (" { (FcChar8 *) \"%s\", "
+ " { FC_REF_CONSTANT, %d, OFF(%d,%d), NUM(%d,%d) } }, /* %d */\n",
+ langs[i],
+ sets[j]->num, i, off[j], i, off[j], i);
}
- for (setRangeChar = 'a'; setRangeChar < 'z'; setRangeChar++)
- setRangeEnd[setRangeChar - 'a'] = setRangeStart[setRangeChar+1-'a'] - 1;
- setRangeEnd[setRangeChar - 'a'] = i - 1;
+ printf ("},\n");
/*
- * Dump arrays
+ * Dump leaves
*/
- for (i = 0; sets[i]; i++)
+ printf ("{\n");
+ for (l = 0; l < tl; l++)
{
- int n;
-
- if (duplicate[i] >= 0)
- continue;
-
- for (n = 0; n < sets[i]->num; n++)
+ printf (" { { /* %d */", l);
+ for (i = 0; i < 256/32; i++)
{
- for (l = 0; l < tl; l++)
- if (leaves[l] == FcCharSetGetLeaf(sets[i], n))
- break;
- if (l == tl)
- fatal (names[i], 0, "can't find leaf");
- offset_count++;
+ if (i % 4 == 0)
+ printf ("\n ");
+ printf (" 0x%08x,", leaves[l]->map[i]);
}
- offsets[i] = offset;
- offset += sets[i]->num;
+ printf ("\n } },\n");
}
+ printf ("},\n");
- printf ("const int langBankLeafIdx[%d] = {\n",
- offset_count);
+ /*
+ * Dump leaves
+ */
+ printf ("{\n");
for (i = 0; sets[i]; i++)
{
int n;
if (duplicate[i] >= 0)
continue;
+ printf (" /* %s */\n", names[i]);
for (n = 0; n < sets[i]->num; n++)
{
- if (n % 8 == 0)
+ if (n % 4 == 0)
printf (" ");
for (l = 0; l < tl; l++)
- if (leaves[l] == FcCharSetGetLeaf(sets[i], n))
+ if (leaves[l] == FcCharSetLeaf(sets[i], n))
break;
if (l == tl)
fatal (names[i], 0, "can't find leaf");
- printf (" %3d,", l);
- if (n % 8 == 7)
+ printf (" LEAF(%3d,%3d),", off[i], l);
+ if (n % 4 == 3)
printf ("\n");
}
- if (n % 8 != 0)
+ if (n % 4 != 0)
printf ("\n");
}
- printf ("};\n\n");
-
- printf ("const FcChar16 langBankNumbers[%d] = {\n",
- offset_count);
+ printf ("},\n");
+
+ printf ("{\n");
for (i = 0; sets[i]; i++)
{
int n;
-
+
if (duplicate[i] >= 0)
continue;
+ printf (" /* %s */\n", names[i]);
for (n = 0; n < sets[i]->num; n++)
{
if (n % 8 == 0)
printf (" ");
- printf (" 0x%04x,", FcCharSetGetNumbers(sets[i])[n]);
+ printf (" 0x%04x,", FcCharSetNumbers (sets[i])[n]);
if (n % 8 == 7)
printf ("\n");
}
if (n % 8 != 0)
printf ("\n");
}
- printf ("};\n\n");
+ printf ("}\n");
- /*
- * Dump sets
- */
-
- printf ("const FcLangCharSet fcLangCharSets[] = {\n");
- for (i = 0; sets[i]; i++)
- {
- int j = duplicate[i];
-
- if (j < 0)
- j = i;
-
- printf (" { (FcChar8 *) \"%s\",\n"
- " { FC_REF_CONSTANT, %d, FC_BANK_LANGS, "
- "{ { %d, %d } } } }, /* %d */\n",
- langs[i],
- sets[j]->num, offsets[j], offsets[j], j);
- }
printf ("};\n\n");
+
printf ("#define NUM_LANG_CHAR_SET %d\n", i);
num_lang_set_map = (i + 31) / 32;
printf ("#define NUM_LANG_SET_MAP %d\n", num_lang_set_map);
@@ -507,6 +485,23 @@ main (int argc, char **argv)
/*
+ * Find ranges for each letter for faster searching
+ */
+ setRangeChar = 'a';
+ memset(setRangeStart, '\0', sizeof (setRangeStart));
+ memset(setRangeEnd, '\0', sizeof (setRangeEnd));
+ for (i = 0; sets[i]; i++)
+ {
+ char c = names[i][0];
+
+ while (setRangeChar <= c && c <= 'z')
+ setRangeStart[setRangeChar++ - 'a'] = i;
+ }
+ for (setRangeChar = 'a'; setRangeChar < 'z'; setRangeChar++)
+ setRangeEnd[setRangeChar - 'a'] = setRangeStart[setRangeChar+1-'a'] - 1;
+ setRangeEnd[setRangeChar - 'a'] = i - 1;
+
+ /*
* Dump sets start/finish for the fastpath
*/
printf ("static const FcLangCharSetRange fcLangCharSetRanges[] = {\n");
diff --git a/fontconfig/fontconfig.h b/fontconfig/fontconfig.h
index 8ef2f7c..410da1e 100644
--- a/fontconfig/fontconfig.h
+++ b/fontconfig/fontconfig.h
@@ -212,17 +212,14 @@ typedef struct _FcValue {
FcType type;
union {
const FcChar8 *s;
- int s_off;
int i;
FcBool b;
double d;
const FcMatrix *m;
const FcCharSet *c;
- int c_off;
void *f;
const FcPattern *p;
const FcLangSet *l;
- int l_off; /* this is a difference of char *s */
} u;
} FcValue;
diff --git a/src/Makefile.am b/src/Makefile.am
index 5d144bc..586594c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -95,6 +95,7 @@ libfontconfig_la_SOURCES = \
fcmatrix.c \
fcname.c \
fcpat.c \
+ fcserialize.c \
fcstr.c \
fcxml.c \
ftglue.h \
diff --git a/src/fccache.c b/src/fccache.c
index a677253..c1c58fb 100644
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -1,6 +1,4 @@
/*
- * $RCSId: xc/lib/fontconfig/src/fccache.c,v 1.12 2002/08/22 07:36:44 keithp Exp $
- *
* Copyright © 2000 Keith Packard
* Copyright © 2005 Patrick Lam
*
@@ -37,29 +35,12 @@
# include <windows.h>
#endif
-#define ENDIAN_TEST 0x12345678
-#define MACHINE_SIGNATURE_SIZE (9 + 5*20 + 1)
-/* for when we don't have sysconf: */
-#define FC_HARDCODED_PAGESIZE 8192
-
#ifndef O_BINARY
#define O_BINARY 0
#endif
-static FILE *
-FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path);
-
-static void *
-FcDirCacheProduce (FcFontSet *set, FcCache * metadata);
-
-static off_t
-FcCacheNextOffset(off_t w);
-
-static FcBool
-FcCacheHaveBank (int bank);
-
-static void
-FcCacheAddBankDir (int bank, const char * dir);
+static int
+FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, off_t *size);
struct MD5Context {
FcChar32 buf[4];
@@ -74,67 +55,17 @@ static void MD5Transform(FcChar32 buf[4]
#define FC_DBG_CACHE_REF 1024
-static char *
-FcCacheReadString (FILE *file, char *dest, int len)
-{
- int c;
- char *d = dest;
-
- if (len == 0)
- return 0;
-
- while ((c = getc (file)) != EOF && len > 0) {
- *d++ = c;
- if (c == '\0')
- return dest;
- len--;
- }
- return 0;
-}
-
-static FcBool
-FcCacheWriteString (int fd, const char *chars)
-{
- if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
- return FcFalse;
- return FcTrue;
-}
-
-/*
- * Find the next presumably-mmapable offset after the supplied file
- * position.
- */
-static off_t
-FcCacheNextOffset(off_t w)
-{
- static long pagesize = -1;
-
- if (w == -1)
- return w;
-
- if (pagesize == -1)
-#if defined (HAVE_SYSCONF)
- pagesize = sysconf(_SC_PAGESIZE);
-#else
- pagesize = FC_HARDCODED_PAGESIZE;
-#endif
- if (w % pagesize == 0)
- return w;
- else
- return ((w / pagesize)+1)*pagesize;
-}
-
/* Does not check that the cache has the appropriate arch section. */
FcBool
FcDirCacheValid (const FcChar8 *dir, FcConfig *config)
{
- FILE *file;
+ int fd;
- file = FcDirCacheOpen (config, dir, NULL);
+ fd = FcDirCacheOpen (config, dir, NULL);
- if (file == NULL)
+ if (fd < 0)
return FcFalse;
- fclose (file);
+ close (fd);
return FcTrue;
}
@@ -282,218 +213,281 @@ FcCacheRead (FcConfig *config)
* This searches the list of cache dirs for the relevant cache file,
* returning the first one found.
*/
-static FILE *
-FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path)
+static int
+FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, off_t *size)
{
- FILE *file = NULL;
- FcChar8 *cache_hashed = NULL;
+ int fd = -1;
FcChar8 cache_base[CACHEBASE_LEN];
FcStrList *list;
FcChar8 *cache_dir;
struct stat file_stat, dir_stat;
if (stat ((char *) dir, &dir_stat) < 0)
- return NULL;
+ return -1;
FcDirCacheBasename (dir, cache_base);
list = FcStrListCreate (config->cacheDirs);
if (!list)
- return NULL;
+ return -1;
while ((cache_dir = FcStrListNext (list)))
{
- cache_hashed = FcStrPlus (cache_dir, cache_base);
+ FcChar8 *cache_hashed = FcStrPlus (cache_dir, cache_base);
if (!cache_hashed)
break;
- file = fopen((char *) cache_hashed, "rb");
- if (file != NULL) {
- if (fstat (fileno (file), &file_stat) >= 0 &&
+ fd = open((char *) cache_hashed, O_RDONLY | O_BINARY);
+ FcStrFree (cache_hashed);
+ if (fd >= 0) {
+ if (fstat (fd, &file_stat) >= 0 &&
dir_stat.st_mtime <= file_stat.st_mtime)
{
+ if (size)
+ *size = file_stat.st_size;
break;
}
- fclose (file);
- file = NULL;
+ close (fd);
+ fd = -1;
}
- FcStrFree (cache_hashed);
- cache_hashed = NULL;
}
FcStrListDone (list);
-
- if (file == NULL)
- return NULL;
- if (cache_path)
- *cache_path = cache_hashed;
- else
- FcStrFree (cache_hashed);
+ return fd;
+}
- return file;
+#if 0
+static void
+FcDirCacheUnmap (FcCache *cache)
+{
+ if (cache->magic == FC_CACHE_MAGIC_COPY)
+ {
+ free (cache);
+ return;
+ }
+#if defined(HAVE_MMAP) || defined(__CYGWIN__)
+ munmap (cache, cache->size);
+#elif defined(_WIN32)
+ UnmapViewOfFile (cache);
+#endif
}
+#endif
/* read serialized state from the cache file */
-FcBool
-FcDirCacheConsume (FILE *file, FcFontSet *set, FcStrSet *dirs,
- const FcChar8 *dir, char *dirname)
+static FcCache *
+FcDirCacheMap (int fd, off_t size)
{
- FcCache metadata;
- void *current_dir_block;
- char subdir_name[FC_MAX_FILE_LEN + 1 + 12 + 1];
- int i;
-
- if (fread(&metadata, sizeof(FcCache), 1, file) != 1)
- goto bail;
- if (metadata.magic != FC_CACHE_MAGIC)
- goto bail;
-
- /* skip directory name; it's just for fc-cat */
- if (!FcCacheReadString (file, subdir_name, sizeof (subdir_name)))
- goto bail;
-
- if (dirname)
- strcpy (dirname, subdir_name);
+ FcCache *cache;
+ FcBool allocated = FcFalse;
- for (i = 0; i < metadata.subdirs; i++) {
- if (!FcCacheReadString (file, subdir_name, sizeof (subdir_name)))
- goto bail;
- FcStrSetAdd (dirs, (FcChar8 *)subdir_name);
- }
-
- if (metadata.count)
- {
- int fd = fileno (file);
+ if (size < sizeof (FcCache))
+ return NULL;
#if defined(HAVE_MMAP) || defined(__CYGWIN__)
- current_dir_block = mmap (0, metadata.count,
- PROT_READ, MAP_SHARED, fd, metadata.pos);
- if (current_dir_block == MAP_FAILED)
- goto bail;
+ cache = mmap (0, size, PROT_READ, MAP_SHARED, fd, 0);
#elif defined(_WIN32)
- {
- HANDLE hFileMap;
-
- hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL, PAGE_READONLY, 0, 0, NULL);
- if (hFileMap == NULL)
- goto bail;
+ {
+ HANDLE hFileMap;
- current_dir_block = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, metadata.pos, metadata.count);
- if (current_dir_block == NULL)
- {
- CloseHandle (hFileMap);
- goto bail;
- }
+ cache = NULL;
+ hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL,
+ PAGE_READONLY, 0, 0, NULL);
+ if (hFileMap != NULL)
+ {
+ cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0, size);
+ CloseHandle (hFileMap);
}
-#else
- if (lseek (fd, metatdata.pos, SEEK_SET) == -1)
- goto bail;
-
- current_dir_block = malloc (metadata.count);
- if (!current_dir_block)
- goto bail;
+ }
+#endif
+ if (!cache)
+ {
+ cache = malloc (size);
+ if (!cache)
+ return NULL;
- /* could also use CreateMappedViewOfFile under MinGW... */
- if (read (fd, current_dir_block, metadata.count) != metadata.count)
+ if (read (fd, cache, size) != size)
{
- free (current_dir_block);
- goto bail;
+ free (cache);
+ return NULL;
}
+ allocated = FcTrue;
+ }
+ if (cache->magic != FC_CACHE_MAGIC ||
+ cache->size != size)
+ {
+ if (allocated)
+ free (cache);
+ else
+ {
+#if defined(HAVE_MMAP) || defined(__CYGWIN__)
+ munmap (cache, size);
+#elif defined(_WIN32)
+ UnmapViewOfFile (cache);
#endif
- FcCacheAddBankDir (metadata.bank, (char *) dir);
- if (!FcFontSetUnserialize (&metadata, set, current_dir_block))
- goto bail;
+ }
+ return NULL;
}
- return FcTrue;
-
- bail:
- return FcFalse;
+ /* Mark allocated caches so they're freed rather than unmapped */
+ if (allocated)
+ cache->magic = FC_CACHE_MAGIC_COPY;
+
+ return cache;
}
FcBool
FcDirCacheRead (FcFontSet * set, FcStrSet * dirs,
const FcChar8 *dir, FcConfig *config)
{
- FILE *file;
-
- file = FcDirCacheOpen (config, dir, NULL);
- if (file == NULL)
- goto bail;
+ int fd;
+ FcCache *cache;
+ off_t size;
+ int i;
+ FcFontSet *cache_set;
+ intptr_t *cache_dirs;
+ FcPattern **cache_fonts;
- if (!FcDirCacheConsume (file, set, dirs, dir, NULL))
- goto bail1;
+ fd = FcDirCacheOpen (config, dir, &size);
+ if (fd < 0)
+ return FcFalse;
+ cache = FcDirCacheMap (fd, size);
+
+ if (!cache)
+ {
+ if (FcDebug() & FC_DBG_CACHE)
+ printf ("FcDirCacheRead failed to map cache for %s\n", dir);
+ close (fd);
+ return FcFalse;
+ }
+
+ cache_set = FcCacheSet (cache);
+ cache_fonts = FcFontSetFonts(cache_set);
+ if (FcDebug() & FC_DBG_CACHE)
+ printf ("FcDirCacheRead mapped cache for %s (%d fonts %d subdirs)\n",
+ dir, cache_set->nfont, cache->dirs_count);
+ for (i = 0; i < cache_set->nfont; i++)
+ {
+ FcPattern *font = FcEncodedOffsetToPtr (cache_set,
+ cache_fonts[i],
+ FcPattern);
+ if (FcDebug() & FC_DBG_CACHEV) {
+ printf ("Mapped font %d\n", i);
+ FcPatternPrint (font);
+ }
+ FcFontSetAdd (set, font);
+ }
+
+ cache_dirs = FcCacheDirs (cache);
+ for (i = 0; i < cache->dirs_count; i++)
+ FcStrSetAdd (dirs, FcOffsetToPtr (cache_dirs,
+ cache_dirs[i],
+ FcChar8));
+
if (config)
FcConfigAddFontDir (config, (FcChar8 *)dir);
- fclose (file);
+ close (fd);
return FcTrue;
-
-bail1:
- fclose (file);
-bail:
- return FcFalse;
}
+/*
+ * Cache file is:
+ *
+ * FcCache
+ * dir name
+ * subdirs
+ * FcFontSet
+ */
-static void *
-FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
+static FcCache *
+FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
{
- void * current_dir_block, * final_dir_block;
- static unsigned int rand_state = 0;
- int bank, needed_bytes_no_align;
-
-#if defined (HAVE_RAND_R)
- if (!rand_state)
- rand_state = time(0L);
- bank = rand_r(&rand_state);
+ FcSerialize *serialize = FcSerializeCreate ();
+ FcCache *cache;
+ int i;
+ intptr_t cache_offset;
+ intptr_t dirs_offset;
+ FcChar8 *dir_serialize;
+ intptr_t *dirs_serialize;
+ FcFontSet *set_serialize;
+
+ if (!serialize)
+ return NULL;
+ /*
+ * Space for cache structure
+ */
+ cache_offset = FcSerializeReserve (serialize, sizeof (FcCache));
+ /*
+ * Directory name
+ */
+ if (!FcStrSerializeAlloc (serialize, dir))
+ goto bail1;
+ /*
+ * Subdirs
+ */
+ dirs_offset = FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
+ for (i = 0; i < dirs->num; i++)
+ if (!FcStrSerializeAlloc (serialize, dirs->strs[i]))
+ goto bail1;
- while (FcCacheHaveBank(bank))
- bank = rand_r(&rand_state);
-#else
- if (!rand_state)
- {
- rand_state = 1;
- srand (time (0L));
- }
- bank = rand();
+ /*
+ * Patterns
+ */
+ if (!FcFontSetSerializeAlloc (serialize, set))
+ goto bail1;
+
+ /* Serialize layout complete. Now allocate space and fill it */
+ cache = malloc (serialize->size);
+ if (!cache)
+ goto bail1;
+ /* shut up valgrind */
+ memset (cache, 0, serialize->size);
- while (FcCacheHaveBank(bank))
- bank = rand();
-#endif
+ serialize->linear = cache;
- memset (metadata, 0, sizeof(FcCache));
- FcFontSetNewBank();
- needed_bytes_no_align = FcFontSetNeededBytes (set);
- metadata->count = needed_bytes_no_align +
- FcFontSetNeededBytesAlign ();
- metadata->magic = FC_CACHE_MAGIC;
- metadata->bank = bank;
+ cache->magic = FC_CACHE_MAGIC;
+ cache->size = serialize->size;
- if (!needed_bytes_no_align) /* not a failure, no fonts to write */
+ /*
+ * Serialize directory name
+ */
+ dir_serialize = FcStrSerialize (serialize, dir);
+ if (!dir_serialize)
+ goto bail2;
+ cache->dir = FcPtrToOffset (cache, dir_serialize);
+
+ /*
+ * Serialize sub dirs
+ */
+ dirs_serialize = FcSerializePtr (serialize, dirs);
+ if (!dirs_serialize)
+ goto bail2;
+ cache->dirs = FcPtrToOffset (cache, dirs_serialize);
+ cache->dirs_count = dirs->num;
+ for (i = 0; i < dirs->num; i++)
{
- /* no, you don't really need to write any bytes at all. */
- metadata->count = 0;
- return 0;
+ FcChar8 *d_serialize = FcStrSerialize (serialize, dirs->strs[i]);
+ if (!d_serialize)
+ goto bail2;
+ dirs_serialize[i] = FcPtrToOffset (dirs_serialize, d_serialize);
}
+
+ /*
+ * Serialize font set
+ */
+ set_serialize = FcFontSetSerialize (serialize, set);
+ if (!set_serialize)
+ goto bail2;
+ cache->set = FcPtrToOffset (cache, set_serialize);
- current_dir_block = malloc (metadata->count);
- if (!current_dir_block)
- goto bail;
- /* shut up valgrind */
- memset (current_dir_block, 0, metadata->count);
- final_dir_block = FcFontSetDistributeBytes (metadata, current_dir_block);
-
- if ((void *)((char *)current_dir_block+metadata->count) < final_dir_block)
- goto bail;
-
- if (!FcFontSetSerialize (bank, set))
- goto bail;
-
- return current_dir_block;
+ FcSerializeDestroy (serialize);
+
+ return cache;
- bail:
- free (current_dir_block);
- return 0;
+bail2:
+ free (cache);
+bail1:
+ FcSerializeDestroy (serialize);
+ return NULL;
}
static FcBool
@@ -524,14 +518,12 @@ FcDirCacheWrite (FcFontSet *set, FcStrSe
{
FcChar8 cache_base[CACHEBASE_LEN];
FcChar8 *cache_hashed;
- int fd, i;
+ int fd;
FcAtomic *atomic;
- FcCache metadata;
- void *current_dir_block = 0;
+ FcCache *cache;
FcStrList *list;
FcChar8 *cache_dir = NULL;
FcChar8 *test_dir;
- off_t header_len;
/*
* Write it to the first directory in the list which is writable
@@ -563,14 +555,15 @@ FcDirCacheWrite (FcFontSet *set, FcStrSe
FcStrListDone (list);
if (!cache_dir)
return FcFalse;
+
FcDirCacheBasename (dir, cache_base);
cache_hashed = FcStrPlus (cache_dir, cache_base);
if (!cache_hashed)
return FcFalse;
- current_dir_block = FcDirCacheProduce (set, &metadata);
+ cache = FcDirCacheProduce (set, dir, dirs);
- if (metadata.count && !current_dir_block)
+ if (!cache)
goto bail1;
if (FcDebug () & FC_DBG_CACHE)
@@ -579,54 +572,24 @@ FcDirCacheWrite (FcFontSet *set, FcStrSe
atomic = FcAtomicCreate ((FcChar8 *)cache_hashed);
if (!atomic)
- goto bail1;
+ goto bail2;
if (!FcAtomicLock (atomic))
- goto bail2;
+ goto bail3;
fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
if (fd == -1)
- goto bail3;
-
- /*
- * Compute file header length -- the FcCache followed by the subdir names
- */
- header_len = sizeof (FcCache);
- header_len += strlen ((char *) dir) + 1;
- for (i = 0; i < dirs->size; i++)
- header_len += strlen ((char *)dirs->strs[i]) + 1;
+ goto bail4;
- metadata.pos = FcCacheNextOffset (lseek (fd, 0, SEEK_CUR) + header_len);
- metadata.subdirs = dirs->size;
-
- /*
- * Write out the header
- */
- if (write (fd, &metadata, sizeof(FcCache)) != sizeof(FcCache))
+ if (write (fd, cache, cache->size) != cache->size)
{
- perror("write metadata");
+ perror ("write cache");
goto bail5;
}
-
- FcCacheWriteString (fd, (char *) dir);
-
- for (i = 0; i < dirs->size; i++)
- FcCacheWriteString (fd, (char *)dirs->strs[i]);
-
- if (metadata.count)
- {
- if (lseek (fd, metadata.pos, SEEK_SET) != metadata.pos)
- perror("lseek");
- else if (write (fd, current_dir_block, metadata.count) !=
- metadata.count)
- perror("write current_dir_block");
- free (current_dir_block);
- current_dir_block = 0;
- }
close(fd);
if (!FcAtomicReplaceOrig(atomic))
- goto bail3;
+ goto bail4;
FcStrFree ((FcChar8 *)cache_hashed);
FcAtomicUnlock (atomic);
FcAtomicDestroy (atomic);
@@ -634,99 +597,17 @@ FcDirCacheWrite (FcFontSet *set, FcStrSe
bail5:
close (fd);
- bail3:
+ bail4:
FcAtomicUnlock (atomic);
- bail2:
+ bail3:
FcAtomicDestroy (atomic);
+ bail2:
+ free (cache);
bail1:
FcStrFree ((FcChar8 *)cache_hashed);
- if (current_dir_block)
- free (current_dir_block);
- return FcFalse;
-}
-
-static int banks_ptr = 0, banks_alloc = 0;
-int * _fcBankId = 0, * _fcBankIdx = 0;
-static const char ** bankDirs = 0;
-
-static FcBool
-FcCacheHaveBank (int bank)
-{
- int i;
-
- if (bank < FC_BANK_FIRST)
- return FcTrue;
-
- for (i = 0; i < banks_ptr; i++)
- if (_fcBankId[i] == bank)
- return FcTrue;
-
return FcFalse;
}
-int
-FcCacheBankToIndexMTF (int bank)
-{
- int i, j;
-
- for (i = 0; i < banks_ptr; i++)
- if (_fcBankId[_fcBankIdx[i]] == bank)
- {
- int t = _fcBankIdx[i];
-
- for (j = i; j > 0; j--)
- _fcBankIdx[j] = _fcBankIdx[j-1];
- _fcBankIdx[0] = t;
- return t;
- }
-
- if (banks_ptr >= banks_alloc)
- {
- int * b, * bidx;
- const char ** bds;
-
- b = realloc (_fcBankId, (banks_alloc + 4) * sizeof(int));
- if (!b)
- return -1;
- _fcBankId = b;
-
- bidx = realloc (_fcBankIdx, (banks_alloc + 4) * sizeof(int));
- if (!bidx)
- return -1;
- _fcBankIdx = bidx;
-
- bds = realloc (bankDirs, (banks_alloc + 4) * sizeof (char *));
- if (!bds)
- return -1;
- bankDirs = bds;
-
- banks_alloc += 4;
- }
-
- i = banks_ptr++;
- _fcBankId[i] = bank;
- _fcBankIdx[i] = i;
- return i;
-}
-
-static void
-FcCacheAddBankDir (int bank, const char * dir)
-{
- int bi = FcCacheBankToIndexMTF (bank);
-
- if (bi < 0)
- return;
-
- bankDirs[bi] = (const char *)FcStrCopy ((FcChar8 *)dir);
-}
-
-const char *
-FcCacheFindBankDir (int bank)
-{
- int bi = FcCacheBankToIndex (bank);
- return bankDirs[bi];
-}
-
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
diff --git a/src/fccfg.c b/src/fccfg.c
index 586c656..4377ce6 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -310,11 +310,12 @@ FcConfigBuildFonts (FcConfig *config)
for (i = 0; i < cached_fonts->nfont; i++)
{
FcChar8 *cfn;
- FcPatternGetString (cached_fonts->fonts[i], FC_FILE, 0, &cfn);
+ FcPattern *font = cached_fonts->fonts[i];
+ FcPatternObjectGetString (font, FC_FILE_OBJECT, 0, &cfn);
- if (FcConfigAcceptFont (config, cached_fonts->fonts[i]) &&
+ if (FcConfigAcceptFont (config, font) &&
(cfn && FcConfigAcceptFilename (config, cfn)))
- FcFontSetAdd (fonts, cached_fonts->fonts[i]);
+ FcFontSetAdd (fonts, font);
cached_fonts->fonts[i] = 0; /* prevent free in FcFontSetDestroy */
}
@@ -841,7 +842,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *
v.u.b = e->u.bval;
break;
case FcOpField:
- r = FcPatternGet (p, e->u.field, 0, &v);
+ r = FcPatternObjectGet (p, e->u.object, 0, &v);
if (r != FcResultMatch)
v.type = FcTypeVoid;
v = FcValueSave (v);
@@ -1093,7 +1094,7 @@ FcConfigMatchValueList (FcPattern *p,
e = 0;
}
- for (v = values; v; v = FcValueListPtrU(v->next))
+ for (v = values; v; v = FcValueListNext(v))
{
/* Compare the pattern value to the match expression value */
if (FcConfigCompareValue (&v->value, t->op, &value))
@@ -1129,17 +1130,17 @@ FcConfigValues (FcPattern *p, FcExpr *e,
if (e->op == FcOpComma)
{
l->value = FcConfigEvaluate (p, e->u.tree.left);
- l->next = FcValueListPtrCreateDynamic(FcConfigValues (p, e->u.tree.right, binding));
+ l->next = FcConfigValues (p, e->u.tree.right, binding);
}
else
{
l->value = FcConfigEvaluate (p, e);
- l->next = FcValueListPtrCreateDynamic(0);
+ l->next = NULL;
}
l->binding = binding;
if (l->value.type == FcTypeVoid)
{
- FcValueList *next = FcValueListPtrU(l->next);
+ FcValueList *next = FcValueListNext(l);
FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
free (l);
@@ -1162,27 +1163,26 @@ FcConfigAdd (FcValueListPtr *head,
sameBinding = position->binding;
else
sameBinding = FcValueBindingWeak;
- for (v = FcValueListPtrCreateDynamic(new); FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next)
- if (FcValueListPtrU(v)->binding == FcValueBindingSame)
- FcValueListPtrU(v)->binding = sameBinding;
+ 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; FcValueListPtrU(*prev);
- prev = &(FcValueListPtrU(*prev)->next))
+ for (prev = head; *prev != NULL;
+ prev = &(*prev)->next)
;
}
else
{
if (position)
{
- for (prev = head; FcValueListPtrU(*prev);
- prev = &(FcValueListPtrU(*prev)->next))
+ for (prev = head; *prev != NULL;
+ prev = &(*prev)->next)
{
- if (FcValueListPtrU(*prev) == position)
+ if (*prev == position)
break;
}
}
@@ -1191,7 +1191,7 @@ FcConfigAdd (FcValueListPtr *head,
if (FcDebug () & FC_DBG_EDIT)
{
- if (!FcValueListPtrU(*prev))
+ if (*prev == NULL)
printf ("position not on list\n");
}
}
@@ -1205,12 +1205,12 @@ FcConfigAdd (FcValueListPtr *head,
if (new)
{
- last = FcValueListPtrCreateDynamic(new);
- while (FcValueListPtrU(FcValueListPtrU(last)->next))
- last = FcValueListPtrU(last)->next;
+ last = new;
+ while (last->next != NULL)
+ last = last->next;
- FcValueListPtrU(last)->next = *prev;
- *prev = FcValueListPtrCreateDynamic(new);
+ last->next = *prev;
+ *prev = new;
}
if (FcDebug () & FC_DBG_EDIT)
@@ -1229,14 +1229,13 @@ FcConfigDel (FcValueListPtr *head,
{
FcValueListPtr *prev;
- for (prev = head; FcValueListPtrU(*prev);
- prev = &(FcValueListPtrU(*prev)->next))
+ for (prev = head; *prev != NULL; prev = &(*prev)->next)
{
- if (FcValueListPtrU(*prev) == position)
+ if (*prev == position)
{
*prev = position->next;
- position->next = FcValueListPtrCreateDynamic(0);
- FcValueListDestroy (FcValueListPtrCreateDynamic(position));
+ position->next = NULL;
+ FcValueListDestroy (position);
break;
}
}
@@ -1244,13 +1243,13 @@ FcConfigDel (FcValueListPtr *head,
static void
FcConfigPatternAdd (FcPattern *p,
- const char *object,
+ FcObject object,
FcValueList *list,
FcBool append)
{
if (list)
{
- FcPatternElt *e = FcPatternInsertElt (p, object);
+ FcPatternElt *e = FcPatternObjectInsertElt (p, object);
if (!e)
return;
@@ -1263,24 +1262,24 @@ FcConfigPatternAdd (FcPattern *p,
*/
static void
FcConfigPatternDel (FcPattern *p,
- const char *object)
+ FcObject object)
{
- FcPatternElt *e = FcPatternFindElt (p, object);
+ FcPatternElt *e = FcPatternObjectFindElt (p, object);
if (!e)
return;
- while (FcValueListPtrU(e->values))
- FcConfigDel (&e->values, FcValueListPtrU(e->values));
+ while (e->values != NULL)
+ FcConfigDel (&e->values, e->values);
}
static void
FcConfigPatternCanon (FcPattern *p,
- const char *object)
+ FcObject object)
{
- FcPatternElt *e = FcPatternFindElt (p, object);
+ FcPatternElt *e = FcPatternObjectFindElt (p, object);
if (!e)
return;
- if (!FcValueListPtrU(e->values))
- FcPatternDel (p, object);
+ if (e->values == NULL)
+ FcPatternObjectDel (p, object);
}
FcBool
@@ -1337,7 +1336,7 @@ FcConfigSubstituteWithPat (FcConfig *
else
m = p;
if (m)
- st[i].elt = FcPatternFindElt (m, t->field);
+ st[i].elt = FcPatternObjectFindElt (m, t->object);
else
st[i].elt = 0;
/*
@@ -1358,12 +1357,12 @@ FcConfigSubstituteWithPat (FcConfig *
* Check to see if there is a match, mark the location
* to apply match-relative edits
*/
- st[i].value = FcConfigMatchValueList (m, t, FcValueListPtrU(st[i].elt->values));
+ st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
if (!st[i].value)
break;
- if (t->qual == FcQualFirst && st[i].value != FcValueListPtrU(st[i].elt->values))
+ if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
break;
- if (t->qual == FcQualNotFirst && st[i].value == FcValueListPtrU(st[i].elt->values))
+ if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
break;
}
if (t)
@@ -1391,8 +1390,7 @@ FcConfigSubstituteWithPat (FcConfig *
for (t = s->test, i = 0; t; t = t->next, i++)
{
if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
- !FcStrCmpIgnoreCase ((FcChar8 *) t->field,
- (FcChar8 *) e->field))
+ t->object == e->object)
{
/*
* KLUDGE - the pattern may have been reallocated or
@@ -1401,7 +1399,7 @@ FcConfigSubstituteWithPat (FcConfig *
* the element again
*/
if (e != s->edit && st[i].elt)
- st[i].elt = FcPatternFindElt (p, t->field);
+ st[i].elt = FcPatternObjectFindElt (p, t->object);
if (!st[i].elt)
t = 0;
break;
@@ -1416,7 +1414,7 @@ FcConfigSubstituteWithPat (FcConfig *
if (t)
{
FcValueList *thisValue = st[i].value;
- FcValueList *nextValue = thisValue ? FcValueListPtrU(thisValue->next) : 0;
+ FcValueList *nextValue = thisValue;
/*
* Append the new list of values after the current value
@@ -1444,8 +1442,8 @@ FcConfigSubstituteWithPat (FcConfig *
* Delete all of the values and insert
* the new set
*/
- FcConfigPatternDel (p, e->field);
- FcConfigPatternAdd (p, e->field, l, FcTrue);
+ 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
@@ -1468,7 +1466,7 @@ FcConfigSubstituteWithPat (FcConfig *
}
/* fall through ... */
case FcOpPrependFirst:
- FcConfigPatternAdd (p, e->field, l, FcFalse);
+ FcConfigPatternAdd (p, e->object, l, FcFalse);
break;
case FcOpAppend:
if (t)
@@ -1478,10 +1476,10 @@ FcConfigSubstituteWithPat (FcConfig *
}
/* fall through ... */
case FcOpAppendLast:
- FcConfigPatternAdd (p, e->field, l, FcTrue);
+ FcConfigPatternAdd (p, e->object, l, FcTrue);
break;
default:
- FcValueListDestroy (FcValueListPtrCreateDynamic(l));
+ FcValueListDestroy (l);
break;
}
}
@@ -1490,7 +1488,7 @@ FcConfigSubstituteWithPat (FcConfig *
* any properties without data
*/
for (e = s->edit; e; e = e->next)
- FcConfigPatternCanon (p, e->field);
+ FcConfigPatternCanon (p, e->object);
if (FcDebug () & FC_DBG_EDIT)
{
diff --git a/src/fccharset.c b/src/fccharset.c
index e0a0961..d55c611 100644
--- a/src/fccharset.c
+++ b/src/fccharset.c
@@ -29,33 +29,6 @@
/* #define CHATTY */
-static FcCharSet ** charsets = 0;
-static FcChar16 ** numbers = 0;
-static int charset_bank_count = 0, charset_ptr, charset_count;
-static int charset_numbers_ptr, charset_numbers_count;
-static FcCharLeaf ** leaves = 0;
-static int charset_leaf_ptr, charset_leaf_count;
-static int ** leaf_idx = 0;
-static int charset_leaf_idx_ptr, charset_leaf_idx_count;
-
-extern const FcChar16 langBankNumbers[];
-extern const FcCharLeaf langBankLeaves[];
-extern const int langBankLeafIdx[];
-
-static FcBool
-FcCharSetEnsureBank (int bi);
-
-void
-FcLangCharSetPopulate (void)
-{
- int bi = FcCacheBankToIndexMTF (FC_BANK_LANGS);
- FcCharSetEnsureBank (bi);
- charsets[bi] = 0;
- numbers[bi] = (FcChar16 *)langBankNumbers;
- leaves[bi] = (FcCharLeaf *)langBankLeaves;
- leaf_idx[bi] = (int *)langBankLeafIdx;
-}
-
FcCharSet *
FcCharSetCreate (void)
{
@@ -67,9 +40,8 @@ FcCharSetCreate (void)
FcMemAlloc (FC_MEM_CHARSET, sizeof (FcCharSet));
fcs->ref = 1;
fcs->num = 0;
- fcs->bank = FC_BANK_DYNAMIC;
- fcs->u.dyn.leaves = 0;
- fcs->u.dyn.numbers = 0;
+ fcs->leaves_offset = FcPtrToOffset (fcs, NULL);
+ fcs->numbers_offset = FcPtrToOffset (fcs, NULL);
return fcs;
}
@@ -86,27 +58,25 @@ void
FcCharSetDestroy (FcCharSet *fcs)
{
int i;
+
if (fcs->ref == FC_REF_CONSTANT)
return;
if (--fcs->ref > 0)
return;
- if (fcs->bank == FC_BANK_DYNAMIC)
+ for (i = 0; i < fcs->num; i++)
{
- for (i = 0; i < fcs->num; i++)
- {
- FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
- free (fcs->u.dyn.leaves[i]);
- }
- if (fcs->u.dyn.leaves)
- {
- FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcCharLeaf *));
- free (fcs->u.dyn.leaves);
- }
- if (fcs->u.dyn.numbers)
- {
- FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
- free (fcs->u.dyn.numbers);
- }
+ FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
+ free (FcCharSetLeaf (fcs, i));
+ }
+ if (FcCharSetLeaves (fcs))
+ {
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (intptr_t));
+ free (FcCharSetLeaves (fcs));
+ }
+ if (FcCharSetNumbers (fcs))
+ {
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (fcs));
}
FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (fcs);
@@ -121,7 +91,7 @@ FcCharSetDestroy (FcCharSet *fcs)
static int
FcCharSetFindLeafPos (const FcCharSet *fcs, FcChar32 ucs4)
{
- FcChar16 *numbers = FcCharSetGetNumbers(fcs);
+ FcChar16 *numbers = FcCharSetNumbers(fcs);
FcChar16 page;
int low = 0;
int high = fcs->num - 1;
@@ -150,7 +120,7 @@ FcCharSetFindLeaf (const FcCharSet *fcs,
{
int pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
- return FcCharSetGetLeaf(fcs, pos);
+ return FcCharSetLeaf(fcs, pos);
return 0;
}
@@ -160,68 +130,55 @@ FcCharSetPutLeaf (FcCharSet *fcs,
FcCharLeaf *leaf,
int pos)
{
- FcCharLeaf **leaves;
- FcChar16 *numbers;
+ intptr_t *leaves = FcCharSetLeaves (fcs);
+ FcChar16 *numbers = FcCharSetNumbers (fcs);
ucs4 >>= 8;
if (ucs4 >= 0x10000)
return FcFalse;
- if (fcs->bank != FC_BANK_DYNAMIC)
+ if (!leaves)
+ leaves = malloc (sizeof (*leaves));
+ else
{
- /* convert to dynamic */
- int i;
-
- leaves = malloc ((fcs->num + 1) * sizeof (FcCharLeaf *));
- if (!leaves)
- return FcFalse;
- FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcCharLeaf *));
- numbers = malloc ((fcs->num + 1) * sizeof (FcChar16));
- if (!numbers)
- {
- free (leaves);
- return FcFalse;
- }
- FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcChar16));
-
- for (i = 0; i < fcs->num; i++)
- leaves[i] = FcCharSetGetLeaf(fcs, i);
- memcpy (numbers, FcCharSetGetNumbers(fcs),
- fcs->num * sizeof (FcChar16));
+ intptr_t *new_leaves = realloc (leaves, (fcs->num + 1) *
+ sizeof (*leaves));
+ intptr_t distance = (intptr_t) new_leaves - (intptr_t) leaves;
+
+ if (new_leaves && distance)
+ {
+ int i;
- fcs->bank = FC_BANK_DYNAMIC;
- fcs->u.dyn.leaves = leaves;
- fcs->u.dyn.numbers = numbers;
+ for (i = 0; i < fcs->num; i++)
+ new_leaves[i] -= distance;
+ }
+ leaves = new_leaves;
}
+ if (!leaves)
+ return FcFalse;
+
+ if (fcs->num)
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (intptr_t));
+ FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (intptr_t));
+ fcs->leaves_offset = FcPtrToOffset (fcs, leaves);
+
+ if (!numbers)
+ numbers = malloc (sizeof (FcChar16));
else
- {
- if (!fcs->u.dyn.leaves)
- leaves = malloc (sizeof (FcCharLeaf *));
- else
- leaves = realloc (fcs->u.dyn.leaves, (fcs->num + 1) * sizeof (FcCharLeaf *));
- if (!leaves)
- return FcFalse;
- if (fcs->num)
- FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcCharLeaf *));
- FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcCharLeaf *));
- fcs->u.dyn.leaves = leaves;
- if (!fcs->u.dyn.numbers)
- numbers = malloc (sizeof (FcChar16));
- else
- numbers = realloc (fcs->u.dyn.numbers, (fcs->num + 1) * sizeof (FcChar16));
- if (!numbers)
- return FcFalse;
- if (fcs->num)
- FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
- FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcChar16));
- fcs->u.dyn.numbers = numbers;
- }
+ numbers = realloc (numbers, (fcs->num + 1) * sizeof (FcChar16));
+ if (!numbers)
+ return FcFalse;
+
+ if (fcs->num)
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
+ FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcChar16));
+ fcs->numbers_offset = FcPtrToOffset (fcs, numbers);
- memmove (fcs->u.dyn.leaves + pos + 1, fcs->u.dyn.leaves + pos,
- (fcs->num - pos) * sizeof (FcCharLeaf *));
- memmove (fcs->u.dyn.numbers + pos + 1, fcs->u.dyn.numbers + pos,
- (fcs->num - pos) * sizeof (FcChar16));
- fcs->u.dyn.numbers[pos] = (FcChar16) ucs4;
- fcs->u.dyn.leaves[pos] = leaf;
+ memmove (leaves + pos + 1, leaves + pos,
+ (fcs->num - pos) * sizeof (*leaves));
+ memmove (numbers + pos + 1, numbers + pos,
+ (fcs->num - pos) * sizeof (*numbers));
+ numbers[pos] = (FcChar16) ucs4;
+ leaves[pos] = FcPtrToOffset (leaves, leaf);
fcs->num++;
return FcTrue;
}
@@ -239,7 +196,7 @@ FcCharSetFindLeafCreate (FcCharSet *fcs,
pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
- return FcCharSetGetLeaf(fcs, pos);
+ return FcCharSetLeaf(fcs, pos);
leaf = calloc (1, sizeof (FcCharLeaf));
if (!leaf)
@@ -264,16 +221,9 @@ FcCharSetInsertLeaf (FcCharSet *fcs, FcC
if (pos >= 0)
{
FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
- if (fcs->bank == FC_BANK_DYNAMIC)
- {
- free (fcs->u.dyn.leaves[pos]);
- fcs->u.dyn.leaves[pos] = leaf;
- }
- else
- {
- int bi = FcCacheBankToIndex(fcs->bank);
- leaves[bi][leaf_idx[fcs->bank][fcs->u.stat.leafidx_offset]+pos] = *leaf;
- }
+ free (FcCharSetLeaf (fcs, pos));
+ FcCharSetLeaves(fcs)[pos] = FcPtrToOffset (FcCharSetLeaves(fcs),
+ leaf);
return FcTrue;
}
pos = -pos - 1;
@@ -324,9 +274,9 @@ FcCharSetIterSet (const FcCharSet *fcs,
iter->leaf = 0;
return;
}
- iter->ucs4 = (FcChar32) FcCharSetGetNumbers(fcs)[pos] << 8;
+ iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
}
- iter->leaf = FcCharSetGetLeaf(fcs, pos);
+ iter->leaf = FcCharSetLeaf(fcs, pos);
iter->pos = pos;
#ifdef CHATTY
printf ("set %08x: %08x\n", iter->ucs4, (FcChar32) iter->leaf);
@@ -344,8 +294,8 @@ FcCharSetIterNext (const FcCharSet *fcs,
}
else
{
- iter->ucs4 = (FcChar32) FcCharSetGetNumbers(fcs)[pos] << 8;
- iter->leaf = FcCharSetGetLeaf(fcs, pos);
+ iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
+ iter->leaf = FcCharSetLeaf(fcs, pos);
iter->pos = pos;
}
}
@@ -662,15 +612,15 @@ FcCharSetIsSubset (const FcCharSet *a, c
ai = 0;
while (ai < a->num && bi < b->num)
{
- an = FcCharSetGetNumbers(a)[ai];
- bn = FcCharSetGetNumbers(b)[bi];
+ an = FcCharSetNumbers(a)[ai];
+ bn = FcCharSetNumbers(b)[bi];
/*
* Check matching pages
*/
if (an == bn)
{
- FcChar32 *am = FcCharSetGetLeaf(a, ai)->map;
- FcChar32 *bm = FcCharSetGetLeaf(b, bi)->map;
+ FcChar32 *am = FcCharSetLeaf(a, ai)->map;
+ FcChar32 *bm = FcCharSetLeaf(b, bi)->map;
if (am != bm)
{
@@ -701,7 +651,7 @@ FcCharSetIsSubset (const FcCharSet *a, c
while (low <= high)
{
int mid = (low + high) >> 1;
- bn = FcCharSetGetNumbers(b)[mid];
+ bn = FcCharSetNumbers(b)[mid];
if (bn == an)
{
high = mid;
@@ -713,7 +663,7 @@ FcCharSetIsSubset (const FcCharSet *a, c
high = mid - 1;
}
bi = high;
- while (bi < b->num && FcCharSetGetNumbers(b)[bi] < an)
+ while (bi < b->num && FcCharSetNumbers(b)[bi] < an)
bi++;
}
}
@@ -1021,10 +971,10 @@ FcCharSetHash (FcCharSet *fcs)
/* hash in leaves */
for (i = 0; i < fcs->num * (int) (sizeof (FcCharLeaf *) / sizeof (FcChar32)); i++)
- hash = ((hash << 1) | (hash >> 31)) ^ (FcChar32)(FcCharSetGetLeaf(fcs, i)->map);
+ hash = ((hash << 1) | (hash >> 31)) ^ (FcChar32)(FcCharSetLeaf(fcs, i)->map);
/* hash in numbers */
for (i = 0; i < fcs->num; i++)
- hash = ((hash << 1) | (hash >> 31)) ^ *FcCharSetGetNumbers(fcs);
+ hash = ((hash << 1) | (hash >> 31)) ^ *FcCharSetNumbers(fcs);
return hash;
}
@@ -1041,6 +991,7 @@ FcCharSetFreezeBase (FcCharSet *fcs)
FcCharSetEnt **bucket = &FcCharSetHashTable[hash % FC_CHAR_SET_HASH_SIZE];
FcCharSetEnt *ent;
int size;
+ int i;
FcCharSetTotal++;
FcCharSetTotalEnts += fcs->num;
@@ -1048,15 +999,15 @@ FcCharSetFreezeBase (FcCharSet *fcs)
{
if (ent->hash == hash &&
ent->set.num == fcs->num &&
- !memcmp (FcCharSetGetNumbers(&ent->set),
- FcCharSetGetNumbers(fcs),
+ !memcmp (FcCharSetNumbers(&ent->set),
+ FcCharSetNumbers(fcs),
fcs->num * sizeof (FcChar16)))
{
FcBool ok = FcTrue;
int i;
for (i = 0; i < fcs->num; i++)
- if (FcCharSetGetLeaf(&ent->set, i) != FcCharSetGetLeaf(fcs, i))
+ if (FcCharSetLeaf(&ent->set, i) != FcCharSetLeaf(fcs, i))
ok = FcFalse;
if (ok)
return &ent->set;
@@ -1075,26 +1026,26 @@ FcCharSetFreezeBase (FcCharSet *fcs)
ent->set.ref = FC_REF_CONSTANT;
ent->set.num = fcs->num;
- ent->set.bank = fcs->bank;
- if (fcs->bank == FC_BANK_DYNAMIC)
+ if (fcs->num)
{
- if (fcs->num)
- {
- ent->set.u.dyn.leaves = (FcCharLeaf **) (ent + 1);
- ent->set.u.dyn.numbers = (FcChar16 *) (ent->set.u.dyn.leaves + fcs->num);
- memcpy (ent->set.u.dyn.leaves, fcs->u.dyn.leaves, fcs->num * sizeof (FcCharLeaf *));
- memcpy (ent->set.u.dyn.numbers, fcs->u.dyn.numbers, fcs->num * sizeof (FcChar16));
- }
- else
- {
- ent->set.u.dyn.leaves = 0;
- ent->set.u.dyn.numbers = 0;
- }
+ intptr_t *ent_leaves;
+
+ ent->set.leaves_offset = sizeof (ent->set);
+ ent->set.numbers_offset = (ent->set.leaves_offset +
+ fcs->num * sizeof (intptr_t));
+
+ ent_leaves = FcCharSetLeaves (&ent->set);
+ for (i = 0; i < fcs->num; i++)
+ ent_leaves[i] = FcPtrToOffset (ent_leaves,
+ FcCharSetLeaf (fcs, i));
+ memcpy (FcCharSetNumbers (&ent->set),
+ FcCharSetNumbers (fcs),
+ fcs->num * sizeof (FcChar16));
}
else
{
- ent->set.u.stat.leafidx_offset = fcs->u.stat.leafidx_offset;
- ent->set.u.stat.numbers_offset = fcs->u.stat.numbers_offset;
+ ent->set.leaves_offset = 0;
+ ent->set.numbers_offset = 0;
}
ent->hash = hash;
@@ -1140,26 +1091,23 @@ FcCharSetFreeze (FcCharSet *fcs)
goto bail0;
for (i = 0; i < fcs->num; i++)
{
- l = FcCharSetFreezeLeaf (FcCharSetGetLeaf(fcs, i));
+ l = FcCharSetFreezeLeaf (FcCharSetLeaf(fcs, i));
if (!l)
goto bail1;
- if (!FcCharSetInsertLeaf (b, FcCharSetGetNumbers(fcs)[i] << 8, l))
+ if (!FcCharSetInsertLeaf (b, FcCharSetNumbers(fcs)[i] << 8, l))
goto bail1;
}
n = FcCharSetFreezeBase (b);
bail1:
- if (b->bank == FC_BANK_DYNAMIC)
+ if (FcCharSetLeaves (b))
{
- if (b->u.dyn.leaves)
- {
- FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcCharLeaf *));
- free (b->u.dyn.leaves);
- }
- if (b->u.dyn.numbers)
- {
- FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcChar16));
- free (b->u.dyn.numbers);
- }
+ FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcCharLeaf *));
+ free (FcCharSetLeaves (b));
+ }
+ if (FcCharSetNumbers (b))
+ {
+ FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (b));
}
FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (b);
@@ -1225,20 +1173,17 @@ FcNameParseCharSet (FcChar8 *string)
#endif
n = FcCharSetFreezeBase (c);
bail1:
- if (c->bank == FC_BANK_DYNAMIC)
+ if (FcCharSetLeaves (c))
{
- if (c->u.dyn.leaves)
- {
- FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcCharLeaf *));
- free (c->u.dyn.leaves);
- }
- if (c->u.dyn.numbers)
- {
- FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcChar16));
- free (c->u.dyn.numbers);
- }
- FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
+ FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcCharLeaf *));
+ free (FcCharSetLeaves (c));
+ }
+ if (FcCharSetNumbers (c))
+ {
+ FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (c));
}
+ FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (c);
bail0:
return n;
@@ -1317,175 +1262,67 @@ FcNameUnparseCharSet (FcStrBuf *buf, con
return FcTrue;
}
-void
-FcCharSetNewBank(void)
-{
- charset_count = 0;
- charset_numbers_count = 0;
- charset_leaf_count = 0;
- charset_leaf_idx_count = 0;
-}
-
-int
-FcCharSetNeededBytes (const FcCharSet *c)
-{
- /* yes, there's redundancy */
- charset_count++;
- charset_leaf_idx_count += c->num;
- charset_leaf_count += c->num;
- charset_numbers_count += c->num;
- return sizeof (FcCharSet) +
- sizeof (int) * c->num + /* leaf_idx */
- sizeof (FcCharLeaf) * c->num + /* leaf */
- sizeof (FcChar16) * c->num; /* number */
-}
-
-int
-FcCharSetNeededBytesAlign (void)
-{
- return fc_alignof (FcCharSet) + fc_alignof (int) +
- fc_alignof (FcCharLeaf) + fc_alignof (FcChar16);
-}
-
-static FcBool
-FcCharSetEnsureBank (int bi)
+FcBool
+FcCharSetSerializeAlloc (FcSerialize *serialize, const FcCharSet *cs)
{
- if (!charsets || charset_bank_count <= bi)
- {
- int new_count = charset_bank_count + 2;
- FcCharSet ** cs;
- FcChar16 ** n;
- FcCharLeaf ** lvs;
- int ** lvi;
- int i;
-
- cs = realloc(charsets, sizeof(FcCharSet*) * new_count);
- if (!cs) return 0;
- n = realloc(numbers, sizeof(FcChar16*) * new_count);
- if (!n) return 0;
- lvs = realloc(leaves, sizeof(FcCharLeaf*) * new_count);
- if (!lvs) return 0;
- lvi = realloc(leaf_idx, sizeof(int*) * new_count);
- if (!lvi) return 0;
-
- charsets = cs; numbers = n; leaves = lvs; leaf_idx = lvi;
- for (i = charset_bank_count; i < new_count; i++)
- {
- charsets[i] = 0;
- numbers[i] = 0;
- leaves[i] = 0;
- leaf_idx[i] = 0;
- }
- charset_bank_count = new_count;
- }
+ intptr_t *leaves = FcCharSetLeaves (cs);
+ FcChar16 *numbers = FcCharSetNumbers (cs);
+ int i;
+
+ if (!FcSerializeAlloc (serialize, cs, sizeof (FcCharSet)))
+ return FcFalse;
+ if (!FcSerializeAlloc (serialize, leaves, cs->num * sizeof (intptr_t)))
+ return FcFalse;
+ if (!FcSerializeAlloc (serialize, numbers, cs->num * sizeof (FcChar16)))
+ return FcFalse;
+ for (i = 0; i < cs->num; i++)
+ if (!FcSerializeAlloc (serialize, FcCharSetLeaf(cs, i),
+ sizeof (FcCharLeaf)))
+ return FcFalse;
return FcTrue;
}
-
-void *
-FcCharSetDistributeBytes (FcCache * metadata, void * block_ptr)
+
+FcCharSet *
+FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs)
{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcCharSetEnsureBank(bi))
- return 0;
+ FcCharSet *cs_serialized = FcSerializePtr (serialize, cs);
+ intptr_t *leaves, *leaves_serialized;
+ FcChar16 *numbers, *numbers_serialized;
+ FcCharLeaf *leaf, *leaf_serialized;
+ int i;
- block_ptr = ALIGN (block_ptr, FcCharSet);
- charsets[bi] = (FcCharSet *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcCharSet) * charset_count));
- block_ptr = ALIGN (block_ptr, FcChar16);
- numbers[bi] = (FcChar16 *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(FcChar16) * charset_numbers_count));
- block_ptr = ALIGN (block_ptr, FcCharLeaf);
- leaves[bi] = (FcCharLeaf *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(FcCharLeaf) * charset_leaf_count));
- block_ptr = ALIGN (block_ptr, int);
- leaf_idx[bi] = (int *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(int) * charset_leaf_idx_count));
-
- metadata->charset_count = charset_count;
- metadata->charset_numbers_count = charset_numbers_count;
- metadata->charset_leaf_count = charset_leaf_count;
- metadata->charset_leaf_idx_count = charset_leaf_idx_count;
- charset_ptr = 0; charset_leaf_ptr = 0;
- charset_leaf_idx_ptr = 0; charset_numbers_ptr = 0;
- return block_ptr;
-}
+ if (!cs_serialized)
+ return NULL;
+
+ cs_serialized->ref = FC_REF_CONSTANT;
+ cs_serialized->num = cs->num;
-FcCharSet *
-FcCharSetSerialize(int bank, FcCharSet *c)
-{
- int i;
- FcCharSet new;
- int bi = FcCacheBankToIndex(bank), cp = charset_ptr;
+ leaves = FcCharSetLeaves (cs);
+ leaves_serialized = FcSerializePtr (serialize, leaves);
+ if (!leaves_serialized)
+ return NULL;
- new.ref = FC_REF_CONSTANT;
- new.bank = bank;
- new.u.stat.leafidx_offset = charset_leaf_idx_ptr;
- new.u.stat.numbers_offset = charset_numbers_ptr;
- new.num = c->num;
+ cs_serialized->leaves_offset = FcPtrToOffset (cs_serialized,
+ leaves_serialized);
+
+ numbers = FcCharSetNumbers (cs);
+ numbers_serialized = FcSerializePtr (serialize, numbers);
+ if (!numbers)
+ return NULL;
- charsets[bi][charset_ptr++] = new;
+ cs_serialized->numbers_offset = FcPtrToOffset (cs_serialized,
+ numbers_serialized);
- for (i = 0; i < c->num; i++)
+ for (i = 0; i < cs->num; i++)
{
- leaf_idx[bi][charset_leaf_idx_ptr++] = charset_leaf_ptr;
- memcpy (&leaves[bi][charset_leaf_ptr++],
- c->u.dyn.leaves[i], sizeof(FcCharLeaf));
- numbers[bi][charset_numbers_ptr++] = c->u.dyn.numbers[i];
+ leaf = FcCharSetLeaf (cs, i);
+ leaf_serialized = FcSerializePtr (serialize, leaf);
+ if (!leaf_serialized)
+ return NULL;
+ *leaf_serialized = *leaf;
+ leaves_serialized[i] = FcPtrToOffset (leaves_serialized, leaf);
+ numbers_serialized[i] = numbers[i];
}
-
- return &charsets[bi][cp];
-}
-
-void *
-FcCharSetUnserialize (FcCache *metadata, void *block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcCharSetEnsureBank(bi))
- return 0;
-
- block_ptr = ALIGN (block_ptr, FcCharSet);
- charsets[bi] = (FcCharSet *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcCharSet) * metadata->charset_count));
- block_ptr = ALIGN (block_ptr, FcChar16);
- numbers[bi] = (FcChar16 *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(FcChar16) * metadata->charset_numbers_count));
- block_ptr = ALIGN (block_ptr, FcCharLeaf);
- leaves[bi] = (FcCharLeaf *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(FcCharLeaf) * metadata->charset_leaf_count));
- block_ptr = ALIGN (block_ptr, int);
- leaf_idx[bi] = (int *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof(int) * metadata->charset_leaf_idx_count));
-
- return block_ptr;
-}
-
-FcCharLeaf *
-FcCharSetGetLeaf(const FcCharSet *c, int i)
-{
- int bi;
- if (c->bank == FC_BANK_DYNAMIC)
- return c->u.dyn.leaves[i];
- bi = FcCacheBankToIndex(c->bank);
-
- return &leaves[bi][leaf_idx[bi][c->u.stat.leafidx_offset+i]];
-}
-
-FcChar16 *
-FcCharSetGetNumbers(const FcCharSet *c)
-{
- int bi;
- if (c->bank == FC_BANK_DYNAMIC)
- return c->u.dyn.numbers;
- bi = FcCacheBankToIndex(c->bank);
-
- return &numbers[bi][c->u.stat.numbers_offset];
+
+ return cs_serialized;
}
-
diff --git a/src/fcdbg.c b/src/fcdbg.c
index 9b7e8f7..16b6bfd 100644
--- a/src/fcdbg.c
+++ b/src/fcdbg.c
@@ -49,7 +49,8 @@ FcValuePrint (const FcValue v)
printf (" (%f %f; %f %f)", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
break;
case FcTypeCharSet: /* XXX */
- printf (" set");
+ printf (" ");
+ FcCharSetPrint (v.u.c);
break;
case FcTypeLangSet:
printf (" ");
@@ -64,10 +65,10 @@ FcValuePrint (const FcValue v)
void
FcValueListPrint (FcValueListPtr l)
{
- for (; FcValueListPtrU(l); l = FcValueListPtrU(l)->next)
+ for (; l != NULL; l = FcValueListNext(l))
{
- FcValuePrint (FcValueCanonicalize(&FcValueListPtrU(l)->value));
- switch (FcValueListPtrU(l)->binding) {
+ FcValuePrint (FcValueCanonicalize(&l->value));
+ switch (l->binding) {
case FcValueBindingWeak:
printf ("(w)");
break;
@@ -96,6 +97,22 @@ FcLangSetPrint (const FcLangSet *ls)
}
void
+FcCharSetPrint (const FcCharSet *c)
+{
+ int i, j;
+
+ for (i = 0; i < c->num; i++)
+ {
+ FcCharLeaf *leaf = FcCharSetLeaf(c, i);
+
+ printf ("%04x:", FcCharSetNumbers(c)[i]);
+ for (j = 0; j < 256/32; j++)
+ printf (" %08x", leaf->map[j]);
+ printf ("\n");
+ }
+}
+
+void
FcPatternPrint (const FcPattern *p)
{
int i;
@@ -109,15 +126,15 @@ FcPatternPrint (const FcPattern *p)
printf ("Pattern has %d elts (size %d)\n", p->num, p->size);
for (i = 0; i < p->num; i++)
{
- e = FcPatternEltU(p->elts) + i;
- printf ("\t%s:", FcObjectPtrU(e->object));
+ e = &FcPatternElts(p)[i];
+ printf ("\t%s:", FcObjectName(e->object));
/* so that fc-match properly displays file: foo... */
- if (e->object == FcObjectToPtr(FC_FILE))
+ if (e->object == FC_FILE_OBJECT)
{
FcChar8 * s;
- FcPatternGetString (p, FC_FILE, 0, &s);
+ FcPatternObjectGetString (p, FC_FILE_OBJECT, 0, &s);
printf (" \"%s\"", s);
- switch (FcValueListPtrU(e->values)->binding) {
+ switch (FcPatternEltValues(e)->binding) {
case FcValueBindingWeak:
printf ("(w)");
break;
@@ -130,7 +147,7 @@ FcPatternPrint (const FcPattern *p)
}
}
else
- FcValueListPrint (e->values);
+ FcValueListPrint (FcPatternEltValues(e));
printf ("\n");
}
printf ("\n");
@@ -197,7 +214,7 @@ FcExprPrint (const FcExpr *expr)
case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
case FcOpCharSet: printf ("charset\n"); break;
case FcOpNil: printf ("nil\n"); break;
- case FcOpField: printf ("%s", expr->u.field); break;
+ case FcOpField: printf ("%s", FcObjectName(expr->u.object)); break;
case FcOpConst: printf ("%s", expr->u.constant); break;
case FcOpQuest:
FcExprPrint (expr->u.tree.left);
@@ -307,7 +324,7 @@ FcTestPrint (const FcTest *test)
printf ("not_first ");
break;
}
- printf ("%s ", test->field);
+ printf ("%s ", FcObjectName (test->object));
FcOpPrint (test->op);
printf (" ");
FcExprPrint (test->expr);
@@ -317,7 +334,7 @@ FcTestPrint (const FcTest *test)
void
FcEditPrint (const FcEdit *edit)
{
- printf ("Edit %s ", edit->field);
+ printf ("Edit %s ", FcObjectName (edit->object));
FcOpPrint (edit->op);
printf (" ");
FcExprPrint (edit->expr);
diff --git a/src/fcdefault.c b/src/fcdefault.c
index 4fd3ed8..b582310 100644
--- a/src/fcdefault.c
+++ b/src/fcdefault.c
@@ -26,14 +26,14 @@
#include <locale.h>
static const struct {
- const char *field;
+ FcObject field;
FcBool value;
} FcBoolDefaults[] = {
- { FC_HINTING, FcTrue }, /* !FT_LOAD_NO_HINTING */
- { FC_VERTICAL_LAYOUT, FcFalse }, /* FC_LOAD_VERTICAL_LAYOUT */
- { FC_AUTOHINT, FcFalse }, /* FC_LOAD_FORCE_AUTOHINT */
- { FC_GLOBAL_ADVANCE, FcTrue }, /* !FC_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH */
- { FC_EMBEDDED_BITMAP, FcTrue }, /* !FC_LOAD_NO_BITMAP */
+ { FC_HINTING_OBJECT, FcTrue }, /* !FT_LOAD_NO_HINTING */
+ { FC_VERTICAL_LAYOUT_OBJECT, FcFalse }, /* FC_LOAD_VERTICAL_LAYOUT */
+ { FC_AUTOHINT_OBJECT, FcFalse }, /* FC_LOAD_FORCE_AUTOHINT */
+ { FC_GLOBAL_ADVANCE_OBJECT, FcTrue }, /* !FC_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH */
+ { FC_EMBEDDED_BITMAP_OBJECT, FcTrue }, /* !FC_LOAD_NO_BITMAP */
};
#define NUM_FC_BOOL_DEFAULTS (int) (sizeof FcBoolDefaults / sizeof FcBoolDefaults[0])
@@ -105,63 +105,63 @@ FcDefaultSubstitute (FcPattern *pattern)
FcValue v;
int i;
- if (FcPatternGet (pattern, FC_STYLE, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
{
- if (FcPatternGet (pattern, FC_WEIGHT, 0, &v) == FcResultNoMatch )
+ if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
{
- FcPatternAddInteger (pattern, FC_WEIGHT, FC_WEIGHT_MEDIUM);
+ FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_MEDIUM);
}
- if (FcPatternGet (pattern, FC_SLANT, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_SLANT_OBJECT, 0, &v) == FcResultNoMatch)
{
- FcPatternAddInteger (pattern, FC_SLANT, FC_SLANT_ROMAN);
+ FcPatternObjectAddInteger (pattern, FC_SLANT_OBJECT, FC_SLANT_ROMAN);
}
}
- if (FcPatternGet (pattern, FC_WIDTH, 0, &v) == FcResultNoMatch)
- FcPatternAddInteger (pattern, FC_WIDTH, FC_WIDTH_NORMAL);
+ if (FcPatternObjectGet (pattern, FC_WIDTH_OBJECT, 0, &v) == FcResultNoMatch)
+ FcPatternObjectAddInteger (pattern, FC_WIDTH_OBJECT, FC_WIDTH_NORMAL);
for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++)
- if (FcPatternGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
- FcPatternAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
+ if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
+ FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
- if (FcPatternGet (pattern, FC_PIXEL_SIZE, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) == FcResultNoMatch)
{
double dpi, size, scale;
- if (FcPatternGetDouble (pattern, FC_SIZE, 0, &size) != FcResultMatch)
+ if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
{
size = 12.0;
- (void) FcPatternDel (pattern, FC_SIZE);
- FcPatternAddDouble (pattern, FC_SIZE, size);
+ (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
}
- if (FcPatternGetDouble (pattern, FC_SCALE, 0, &scale) != FcResultMatch)
+ if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
{
scale = 1.0;
- (void) FcPatternDel (pattern, FC_SCALE);
- FcPatternAddDouble (pattern, FC_SCALE, scale);
+ (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
}
size *= scale;
- if (FcPatternGetDouble (pattern, FC_DPI, 0, &dpi) != FcResultMatch)
+ if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
{
dpi = 75.0;
- (void) FcPatternDel (pattern, FC_DPI);
- FcPatternAddDouble (pattern, FC_DPI, dpi);
+ (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
}
size *= dpi / 72.0;
- FcPatternAddDouble (pattern, FC_PIXEL_SIZE, size);
+ FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, size);
}
- if (FcPatternGet (pattern, FC_LANG, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_LANG_OBJECT, 0, &v) == FcResultNoMatch)
{
- FcPatternAddString (pattern, FC_LANG, FcGetDefaultLang ());
+ FcPatternObjectAddString (pattern, FC_LANG_OBJECT, FcGetDefaultLang ());
}
- if (FcPatternGet (pattern, FC_FONTVERSION, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
{
- FcPatternAddInteger (pattern, FC_FONTVERSION, 0x7fffffff);
+ FcPatternObjectAddInteger (pattern, FC_FONTVERSION_OBJECT, 0x7fffffff);
}
- if (FcPatternGet (pattern, FC_HINT_STYLE, 0, &v) == FcResultNoMatch)
+ if (FcPatternObjectGet (pattern, FC_HINT_STYLE_OBJECT, 0, &v) == FcResultNoMatch)
{
- FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
+ FcPatternObjectAddInteger (pattern, FC_HINT_STYLE_OBJECT, FC_HINT_FULL);
}
}
diff --git a/src/fcfs.c b/src/fcfs.c
index fdc15d7..e9b2d07 100644
--- a/src/fcfs.c
+++ b/src/fcfs.c
@@ -81,117 +81,52 @@ FcFontSetAdd (FcFontSet *s, FcPattern *f
return FcTrue;
}
-static int * fcfs_pat_count;
-
-void
-FcFontSetNewBank (void)
-{
- FcPatternNewBank();
-}
-
-int
-FcFontSetNeededBytes (FcFontSet *s)
-{
- int i, c, cum = 0;
-
- for (i = 0; i < s->nfont; i++)
- {
- c = FcPatternNeededBytes(s->fonts[i]);
- if (c < 0)
- return c;
- cum += c;
- }
-
- if (cum > 0)
- return cum + sizeof(int) + FcObjectNeededBytes();
- else
- return 0;
-}
-
-/* Returns an overestimate of the number of bytes that
- * might later get eaten up by padding in the ALIGN macro. */
-int
-FcFontSetNeededBytesAlign (void)
-{
- return fc_alignof (int) +
- FcPatternNeededBytesAlign () + FcObjectNeededBytesAlign ();
-}
-
-void *
-FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr)
-{
- block_ptr = ALIGN (block_ptr, int);
- fcfs_pat_count = (int *)block_ptr;
- block_ptr = (int *)block_ptr + 1;
- /* we don't consume any bytes for the fontset itself, */
- /* since we don't allocate it statically. */
- block_ptr = FcPatternDistributeBytes (metadata, block_ptr);
-
- /* for good measure, write out the object ids used for */
- /* this bank to the file. */
- return FcObjectDistributeBytes (metadata, block_ptr);
-}
-
FcBool
-FcFontSetSerialize (int bank, FcFontSet * s)
+FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s)
{
int i;
- FcPattern * p;
- *fcfs_pat_count = s->nfont;
-
+
+ if (!FcSerializeAlloc (serialize, s, sizeof (FcFontSet)))
+ return FcFalse;
+ if (!FcSerializeAlloc (serialize, s->fonts, s->nfont * sizeof (FcPattern *)))
+ return FcFalse;
for (i = 0; i < s->nfont; i++)
{
- p = FcPatternSerialize (bank, s->fonts[i]);
- if (!p) return FcFalse;
+ if (!FcPatternSerializeAlloc (serialize, s->fonts[i]))
+ return FcFalse;
}
- FcObjectSerialize();
-
return FcTrue;
}
-FcBool
-FcFontSetUnserialize(FcCache * metadata, FcFontSet * s, void * block_ptr)
+FcFontSet *
+FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s)
{
- int nfont;
- int i, n;
-
- block_ptr = ALIGN (block_ptr, int);
- nfont = *(int *)block_ptr;
- block_ptr = (int *)block_ptr + 1;
+ int i;
+ FcFontSet *s_serialize;
+ FcPattern **fonts_serialize;
+ FcPattern *p_serialize;
+
+ s_serialize = FcSerializePtr (serialize, s);
+ if (!s_serialize)
+ return NULL;
+ *s_serialize = *s;
+ s_serialize->sfont = s_serialize->nfont;
+
+ fonts_serialize = FcSerializePtr (serialize, s->fonts);
+ if (!fonts_serialize)
+ return NULL;
+ s_serialize->fonts = FcPtrToEncodedOffset (s_serialize,
+ fonts_serialize, FcPattern *);
- /* comparing nfont and metadata.count is a bit like comparing
- apples and oranges. Its just for rejecting totally insane
- nfont values, and for that its good enough */
- if (nfont > 0 && nfont < metadata->count / sizeof(void*))
+ for (i = 0; i < s->nfont; i++)
{
- FcPattern * p = (FcPattern *)block_ptr;
-
- if (s->sfont < s->nfont + nfont)
- {
- int sfont = s->nfont + nfont;
- FcPattern ** pp;
- pp = realloc (s->fonts, sfont * sizeof (FcPattern));
- if (!pp)
- return FcFalse;
- s->fonts = pp;
- s->sfont = sfont;
- }
- n = s->nfont;
- s->nfont += nfont;
-
- /* The following line is a bit counterintuitive. The usual
- * convention is that FcPatternUnserialize is responsible for
- * aligning the FcPattern. However, the FontSet also stores
- * the FcPatterns in its own array, so we need to align here
- * too. */
- p = ALIGN(p, FcPattern);
- for (i = 0; i < nfont; i++)
- s->fonts[n + i] = p+i;
-
- block_ptr = FcPatternUnserialize (metadata, block_ptr);
- block_ptr = FcObjectUnserialize (metadata, block_ptr);
- return block_ptr != 0;
+ p_serialize = FcPatternSerialize (serialize, s->fonts[i]);
+ if (!p_serialize)
+ return NULL;
+ fonts_serialize[i] = FcPtrToEncodedOffset (s_serialize,
+ p_serialize,
+ FcPattern);
}
- return FcFalse;
+ return s_serialize;
}
diff --git a/src/fcint.h b/src/fcint.h
index fbbdf77..2f656cb 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -74,6 +74,7 @@
#define FC_DBG_SCANV 256
#define FC_DBG_MEMORY 512
#define FC_DBG_CONFIG 1024
+#define FC_DBG_LANGSET 2048
#define FC_MEM_CHARSET 0
#define FC_MEM_CHARLEAF 1
@@ -116,44 +117,94 @@ typedef enum _FcValueBinding {
FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
} FcValueBinding;
-typedef struct _FcValueListPtr {
- int bank;
- union {
- int stat;
- struct _FcValueList *dyn;
- } u;
-} FcValueListPtr;
+/*
+ * Serialized data structures use only offsets instead of pointers
+ * A low bit of 1 indicates an offset.
+ */
+
+/* Is the provided pointer actually an offset? */
+#define FcIsEncodedOffset(p) ((((intptr_t) (p)) & 1) != 0)
-typedef struct _FcValueList {
- FcValueListPtr next;
+/* Encode offset in a pointer of type t */
+#define FcOffsetEncode(o,t) ((t *) ((o) | 1))
+
+/* Decode a pointer into an offset */
+#define FcOffsetDecode(p) (((intptr_t) (p)) & ~1)
+
+/* Compute pointer offset */
+#define FcPtrToOffset(b,p) ((intptr_t) (p) - (intptr_t) (b))
+
+/* Given base address, offset and type, return a pointer */
+#define FcOffsetToPtr(b,o,t) ((t *) ((intptr_t) (b) + (o)))
+
+/* Given base address, encoded offset and type, return a pointer */
+#define FcEncodedOffsetToPtr(b,p,t) FcOffsetToPtr(b,FcOffsetDecode(p),t)
- FcValue value;
- FcValueBinding binding;
+/* Given base address, pointer and type, return an encoded offset */
+#define FcPtrToEncodedOffset(b,p,t) FcOffsetEncode(FcPtrToOffset(b,p),t)
+
+/* Given a structure, offset member and type, return pointer */
+#define FcOffsetMember(s,m,t) FcOffsetToPtr(s,(s)->m,t)
+
+/* Given a structure, encoded offset member and type, return pointer to member */
+#define FcEncodedOffsetMember(s,m,t) FcOffsetToPtr(s,FcOffsetDecode((s)->m), t)
+
+/* Given a structure, member and type, convert the member to a pointer */
+#define FcPointerMember(s,m,t) (FcIsEncodedOffset((s)->m) ? \
+ FcEncodedOffsetMember (s,m,t) : \
+ (s)->m)
+
+/*
+ * Serialized values may hold strings, charsets and langsets as pointers,
+ * unfortunately FcValue is an exposed type so we can't just always use
+ * offsets
+ */
+#define FcValueString(v) FcPointerMember(v,u.s,FcChar8)
+#define FcValueCharSet(v) FcPointerMember(v,u.c,const FcCharSet)
+#define FcValueLangSet(v) FcPointerMember(v,u.l,const FcLangSet)
+
+typedef struct _FcValueList *FcValueListPtr;
+
+typedef struct _FcValueList {
+ struct _FcValueList *next;
+ FcValue value;
+ FcValueBinding binding;
} FcValueList;
-typedef int FcObjectPtr;
+#define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
+
+typedef int FcObject;
-typedef struct _FcPatternEltPtr {
- int bank;
- union {
- int stat;
- struct _FcPatternElt *dyn;
- } u;
-} FcPatternEltPtr;
+typedef struct _FcPatternElt *FcPatternEltPtr;
+/*
+ * Pattern elts are stuck in a structure connected to the pattern,
+ * so they get moved around when the pattern is resized. Hence, the
+ * values field must be a pointer/offset instead of just an offset
+ */
typedef struct _FcPatternElt {
- FcObjectPtr object;
- FcValueListPtr values;
+ FcObject object;
+ FcValueList *values;
} FcPatternElt;
+#define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
+
struct _FcPattern {
int num;
int size;
- FcPatternEltPtr elts;
+ intptr_t elts_offset;
int ref;
- int bank;
};
+#define FcPatternElts(p) FcOffsetMember(p,elts_offset,FcPatternElt)
+
+#define FcFontSetFonts(fs) FcPointerMember(fs,fonts,FcPattern *)
+/*
+#define FcFontSetFont(fs,i) (FcIsEncodedOffset((fs)->fonts) ? \
+ FcOffsetToPtr(FcFontSetFonts(fs), \
+ FcFontSetFonts(fs)[i]) : \
+ fs->fonts[i])*/
+
typedef enum _FcOp {
FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
FcOpNil,
@@ -178,7 +229,7 @@ typedef struct _FcExpr {
FcMatrix *mval;
FcBool bval;
FcCharSet *cval;
- char *field;
+ FcObject object;
FcChar8 *constant;
struct {
struct _FcExpr *left, *right;
@@ -196,14 +247,14 @@ typedef struct _FcTest {
struct _FcTest *next;
FcMatchKind kind;
FcQual qual;
- const char *field;
+ FcObject object;
FcOp op;
FcExpr *expr;
} FcTest;
typedef struct _FcEdit {
struct _FcEdit *next;
- const char *field;
+ FcObject object;
FcOp op;
FcExpr *expr;
FcValueBinding binding;
@@ -224,19 +275,16 @@ typedef struct _FcCharLeaf {
struct _FcCharSet {
int ref; /* reference count */
int num; /* size of leaves and numbers arrays */
- int bank;
- union {
- struct {
- int leafidx_offset;
- int numbers_offset;
- } stat;
- struct {
- FcCharLeaf **leaves;
- FcChar16 *numbers;
- } dyn;
- } u;
+ intptr_t leaves_offset;
+ intptr_t numbers_offset;
};
+#define FcCharSetLeaves(c) FcOffsetMember(c,leaves_offset,intptr_t)
+#define FcCharSetLeaf(c,i) (FcOffsetToPtr(FcCharSetLeaves(c), \
+ FcCharSetLeaves(c)[i], \
+ FcCharLeaf))
+#define FcCharSetNumbers(c) FcOffsetMember(c,numbers_offset,FcChar16)
+
struct _FcStrSet {
int ref; /* reference count */
int num;
@@ -258,22 +306,36 @@ typedef struct _FcStrBuf {
} FcStrBuf;
typedef struct _FcCache {
- int magic; /* FC_CACHE_MAGIC */
- int subdirs; /* number of subdir strings */
- off_t pos; /* position of data block in file */
- off_t count; /* number of bytes of data in block */
- int bank; /* bank ID */
- int pattern_count; /* number of FcPatterns */
- int patternelt_count; /* number of FcPatternElts */
- int valuelist_count; /* number of FcValueLists */
- int str_count; /* size of strings appearing as FcValues */
- int langset_count; /* number of FcLangSets */
- int charset_count; /* number of FcCharSets */
- int charset_numbers_count;
- int charset_leaf_count;
- int charset_leaf_idx_count;
+ int magic; /* FC_CACHE_MAGIC */
+ off_t size; /* size of file */
+ intptr_t dir; /* offset to dir name */
+ intptr_t dirs; /* offset to subdirs */
+ int dirs_count; /* number of subdir strings */
+ intptr_t set; /* offset to font set */
} FcCache;
+#define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
+#define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
+#define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
+
+/*
+ * Used while constructing a directory cache object
+ */
+
+#define FC_SERIALIZE_HASH_SIZE 8191
+
+typedef struct _FcSerializeBucket {
+ struct _FcSerializeBucket *next;
+ const void *object;
+ intptr_t offset;
+} FcSerializeBucket;
+
+typedef struct _FcSerialize {
+ intptr_t size;
+ void *linear;
+ FcSerializeBucket *buckets[FC_SERIALIZE_HASH_SIZE];
+} FcSerialize;
+
/*
* To map adobe glyph names to unicode values, a precomputed hash
* table is used
@@ -317,15 +379,17 @@ typedef struct _FcCaseFold {
#define FC_MAX_FILE_LEN 4096
-#define FC_STORAGE_STATIC 0x80
-#define fc_value_string(v) (((v)->type & FC_STORAGE_STATIC) ? ((FcChar8 *) v) + (v)->u.s_off : (v) -> u.s)
-#define fc_value_charset(v) (((v)->type & FC_STORAGE_STATIC) ? (const FcCharSet *)(((char *) v) + (v)->u.c_off) : (v) -> u.c)
-#define fc_value_langset(v) (((v)->type & FC_STORAGE_STATIC) ? (const FcLangSet *)(((char *) v) + (v)->u.l_off) : (v) -> u.l)
-#define fc_storage_type(v) ((v)->type & ~FC_STORAGE_STATIC)
+/* XXX remove these when we're ready */
+
+#define fc_value_string(v) FcValueString(v)
+#define fc_value_charset(v) FcValueCharSet(v)
+#define fc_value_langset(v) FcValueLangSet(v)
+#define fc_storage_type(v) ((v)->type)
#define fc_alignof(type) offsetof (struct { char c; type member; }, member)
-#define FC_CACHE_MAGIC 0xFC02FC04
+#define FC_CACHE_MAGIC 0xFC02FC04
+#define FC_CACHE_MAGIC_COPY 0xFC02FC05
struct _FcAtomic {
FcChar8 *file; /* original file name */
@@ -428,19 +492,6 @@ FcDirCacheConsume (FILE *file, FcFontSet
FcBool
FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config);
-
-extern int *_fcBankId, *_fcBankIdx;
-int
-FcCacheBankToIndexMTF (int bank);
-
-static inline int
-FcCacheBankToIndex (int bank)
-{
- return (_fcBankId[*_fcBankIdx] == bank) ? *_fcBankIdx : FcCacheBankToIndexMTF(bank);
-}
-
-const char *
-FcCacheFindBankDir (int bank);
/* fccfg.c */
@@ -512,6 +563,33 @@ FcConfigAcceptFont (FcConfig *config
FcFileTime
FcConfigModifiedTime (FcConfig *config);
+intptr_t
+FcAlignSize (intptr_t size);
+
+FcSerialize *
+FcSerializeCreate (void);
+
+void
+FcSerializeDestroy (FcSerialize *serialize);
+
+FcBool
+FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
+
+intptr_t
+FcSerializeReserve (FcSerialize *serialize, int size);
+
+intptr_t
+FcSerializeOffset (FcSerialize *serialize, const void *object);
+
+void *
+FcSerializePtr (FcSerialize *serialize, const void *object);
+
+FcBool
+FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
+
+FcLangSet *
+FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
+
/* fccharset.c */
void
FcLangCharSetPopulate (void);
@@ -531,27 +609,11 @@ FcNameParseCharSet (FcChar8 *string);
FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
-void
-FcCharSetNewBank (void);
-
-int
-FcCharSetNeededBytes (const FcCharSet *c);
-
-int
-FcCharSetNeededBytesAlign (void);
-
-void *
-FcCharSetDistributeBytes (FcCache * metadata,
- void * block_ptr);
+FcBool
+FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
FcCharSet *
-FcCharSetSerialize(int bank, FcCharSet *c);
-
-void *
-FcCharSetUnserialize (FcCache * metadata, void *block_ptr);
-
-FcCharLeaf *
-FcCharSetGetLeaf(const FcCharSet *c, int i);
+FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
FcChar16 *
FcCharSetGetNumbers(const FcCharSet *c);
@@ -578,6 +640,9 @@ FcEditPrint (const FcEdit *edit);
void
FcSubstPrint (const FcSubst *subst);
+void
+FcCharSetPrint (const FcCharSet *c);
+
extern int FcDebugVal;
static inline int
@@ -633,24 +698,12 @@ FcFreeTypeGetPrivateMap (FT_Encoding enc
/* fcfs.c */
-void
-FcFontSetNewBank (void);
-
-int
-FcFontSetNeededBytes (FcFontSet *s);
-
-int
-FcFontSetNeededBytesAlign (void);
-
-void *
-FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr);
-
FcBool
-FcFontSetSerialize (int bank, FcFontSet * s);
-
-FcBool
-FcFontSetUnserialize(FcCache * metadata, FcFontSet * s, void * block_ptr);
+FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
+FcFontSet *
+FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
+
/* fcgram.y */
int
FcConfigparse (void);
@@ -731,25 +784,6 @@ FcNameParseLangSet (const FcChar8 *strin
FcBool
FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
-void
-FcLangSetNewBank (void);
-
-int
-FcLangSetNeededBytes (const FcLangSet *l);
-
-int
-FcLangSetNeededBytesAlign (void);
-
-void *
-FcLangSetDistributeBytes (FcCache * metadata,
- void * block_ptr);
-
-FcLangSet *
-FcLangSetSerialize (int bank, FcLangSet *l);
-
-void *
-FcLangSetUnserialize (FcCache * metadata, void *block_ptr);
-
/* fclist.c */
FcBool
@@ -760,36 +794,64 @@ FcListPatternMatchAny (const FcPattern *
/* fcname.c */
-FcBool
-FcNameBool (const FcChar8 *v, FcBool *result);
-
-void *
-FcObjectDistributeBytes (FcCache * metadata,
- void * block_ptr);
-
-FcObjectPtr
-FcObjectToPtr (const char * si);
+/*
+ * NOTE -- this ordering is part of the cache file format.
+ * It must also match the ordering in fcname.c
+ */
-int
-FcObjectNeededBytes (void);
+#define FC_FAMILY_OBJECT 1
+#define FC_FAMILYLANG_OBJECT 2
+#define FC_STYLE_OBJECT 3
+#define FC_STYLELANG_OBJECT 4
+#define FC_FULLNAME_OBJECT 5
+#define FC_FULLNAMELANG_OBJECT 6
+#define FC_SLANT_OBJECT 7
+#define FC_WEIGHT_OBJECT 8
+#define FC_WIDTH_OBJECT 9
+#define FC_SIZE_OBJECT 10
+#define FC_ASPECT_OBJECT 11
+#define FC_PIXEL_SIZE_OBJECT 12
+#define FC_SPACING_OBJECT 13
+#define FC_FOUNDRY_OBJECT 14
+#define FC_ANTIALIAS_OBJECT 15
+#define FC_HINT_STYLE_OBJECT 16
+#define FC_HINTING_OBJECT 17
+#define FC_VERTICAL_LAYOUT_OBJECT 18
+#define FC_AUTOHINT_OBJECT 19
+#define FC_GLOBAL_ADVANCE_OBJECT 20
+#define FC_FILE_OBJECT 21
+#define FC_INDEX_OBJECT 22
+#define FC_RASTERIZER_OBJECT 23
+#define FC_OUTLINE_OBJECT 24
+#define FC_SCALABLE_OBJECT 25
+#define FC_DPI_OBJECT 26
+#define FC_RGBA_OBJECT 27
+#define FC_SCALE_OBJECT 28
+#define FC_MINSPACE_OBJECT 29
+#define FC_CHAR_WIDTH_OBJECT 30
+#define FC_CHAR_HEIGHT_OBJECT 31
+#define FC_MATRIX_OBJECT 32
+#define FC_CHARSET_OBJECT 33
+#define FC_LANG_OBJECT 34
+#define FC_FONTVERSION_OBJECT 35
+#define FC_CAPABILITY_OBJECT 36
+#define FC_FONTFORMAT_OBJECT 37
+#define FC_EMBOLDEN_OBJECT 38
+#define FC_EMBEDDED_BITMAP_OBJECT 39
-int
-FcObjectNeededBytesAlign (void);
+FcBool
+FcNameBool (const FcChar8 *v, FcBool *result);
-void *
-FcObjectUnserialize (FcCache * metadata, void *block_ptr);
+FcBool
+FcObjectValidType (FcObject object, FcType type);
-void
-FcObjectSerialize (void);
+FcObject
+FcObjectFromName (const char * name);
const char *
-FcObjectPtrU (FcObjectPtr p);
+FcObjectName (FcObject object);
-static inline int
-FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b)
-{
- return a - b;
-}
+#define FcObjectCompare(a, b) ((int) a - (int) b)
void
FcObjectStaticNameFini (void);
@@ -803,17 +865,74 @@ void
FcValueListDestroy (FcValueListPtr l);
FcPatternElt *
-FcPatternFindElt (const FcPattern *p, const char *object);
+FcPatternObjectFindElt (const FcPattern *p, FcObject object);
FcPatternElt *
-FcPatternInsertElt (FcPattern *p, const char *object);
+FcPatternObjectInsertElt (FcPattern *p, FcObject object);
+
+FcBool
+FcPatternObjectAddWithBinding (FcPattern *p,
+ FcObject object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append);
+
+FcBool
+FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcBool
+FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcResult
+FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
+
+FcBool
+FcPatternObjectDel (FcPattern *p, FcObject object);
FcBool
-FcPatternAddWithBinding (FcPattern *p,
- const char *object,
- FcValue value,
- FcValueBinding binding,
- FcBool append);
+FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
+
+FcBool
+FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
+
+FcBool
+FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
+
+FcBool
+FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
+
+FcBool
+FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
+
+FcBool
+FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
+
+FcBool
+FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
+
+FcBool
+FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
+
+FcResult
+FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
+
+FcResult
+FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
+
+FcResult
+FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
+
+FcResult
+FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
+
+FcResult
+FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
+
+FcResult
+FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
+
+FcResult
+FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
void
FcPatternFini (void);
@@ -827,49 +946,17 @@ FcStrStaticName (const FcChar8 *name);
FcChar32
FcStringHash (const FcChar8 *s);
-void
-FcPatternNewBank (void);
-
-int
-FcPatternNeededBytes (FcPattern *p);
-
-int
-FcPatternNeededBytesAlign (void);
-
-void *
-FcPatternDistributeBytes (FcCache * metadata, void * block_ptr);
-
-/* please don't access these outside of fcpat.c! only visible so that
- * *PtrU can be inlined. */
-extern FcValueList ** _fcValueLists;
-extern FcPatternElt ** _fcPatternElts;
-
-static inline FcValueList *
-FcValueListPtrU (FcValueListPtr pi)
-{
- if (pi.bank == FC_BANK_DYNAMIC)
- return pi.u.dyn;
-
- return &_fcValueLists[FcCacheBankToIndex(pi.bank)][pi.u.stat];
-}
-
-static inline FcPatternElt *
-FcPatternEltU (FcPatternEltPtr pei)
-{
- if (pei.bank == FC_BANK_DYNAMIC)
- return pei.u.dyn;
-
- return &_fcPatternElts[FcCacheBankToIndex(pei.bank)][pei.u.stat];
-}
-
-FcValueListPtr
-FcValueListPtrCreateDynamic(FcValueList * p);
+FcBool
+FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
FcPattern *
-FcPatternSerialize (int bank, FcPattern * p);
+FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
-void *
-FcPatternUnserialize (FcCache * metadata, void *block_ptr);
+FcBool
+FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
+
+FcValueList *
+FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
/* fcrender.c */
@@ -929,4 +1016,10 @@ FcStrHashIgnoreCase (const FcChar8 *s);
FcChar8 *
FcStrCanonFilename (const FcChar8 *s);
+FcBool
+FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
+
+FcChar8 *
+FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
+
#endif /* _FC_INT_H_ */
diff --git a/src/fclang.c b/src/fclang.c
index 552253d..f8f6f0b 100644
--- a/src/fclang.c
+++ b/src/fclang.c
@@ -44,8 +44,6 @@ struct _FcLangSet {
#define FcLangSetBitSet(ls, id) ((ls)->map[(id)>>5] |= ((FcChar32) 1 << ((id) & 0x1f)))
#define FcLangSetBitGet(ls, id) (((ls)->map[(id)>>5] >> ((id) & 0x1f)) & 1)
-static FcBool langsets_populated = FcFalse;
-
FcLangSet *
FcFreeTypeLangSet (const FcCharSet *charset,
const FcChar8 *exclusiveLang)
@@ -55,19 +53,26 @@ FcFreeTypeLangSet (const FcCharSet *cha
const FcCharSet *exclusiveCharset = 0;
FcLangSet *ls;
- if (!langsets_populated)
- {
- FcLangCharSetPopulate ();
- langsets_populated = FcTrue;
- }
-
if (exclusiveLang)
exclusiveCharset = FcCharSetForLang (exclusiveLang);
ls = FcLangSetCreate ();
if (!ls)
return 0;
+ if (FcDebug() & FC_DBG_LANGSET)
+ {
+ printf ("font charset\n");
+ FcCharSetPrint (charset);
+ printf ("\n");
+ }
for (i = 0; i < NUM_LANG_CHAR_SET; i++)
{
+ if (FcDebug() & FC_DBG_LANGSET)
+ {
+ printf ("%s charset\n", fcLangCharSets[i].lang);
+ FcCharSetPrint (&fcLangCharSets[i].charset);
+ printf ("\n");
+ }
+
/*
* Check for Han charsets to make fonts
* which advertise support for a single language
@@ -80,8 +85,8 @@ FcFreeTypeLangSet (const FcCharSet *cha
continue;
for (j = 0; j < fcLangCharSets[i].charset.num; j++)
- if (FcCharSetGetLeaf(&fcLangCharSets[i].charset, j) !=
- FcCharSetGetLeaf(exclusiveCharset, j))
+ if (FcCharSetLeaf(&fcLangCharSets[i].charset, j) !=
+ FcCharSetLeaf(exclusiveCharset, j))
continue;
}
missing = FcCharSetSubtractCount (&fcLangCharSets[i].charset, charset);
@@ -196,12 +201,6 @@ FcCharSetForLang (const FcChar8 *lang)
int i;
int country = -1;
- if (!langsets_populated)
- {
- FcLangCharSetPopulate ();
- langsets_populated = FcTrue;
- }
-
for (i = 0; i < NUM_LANG_CHAR_SET; i++)
{
switch (FcLangCompare (lang, fcLangCharSets[i].lang)) {
@@ -710,90 +709,21 @@ FcLangSetContains (const FcLangSet *lsa,
return FcTrue;
}
-static FcLangSet ** langsets = 0;
-static int langset_bank_count = 0, langset_ptr = 0, langset_count = 0;
-
-void
-FcLangSetNewBank (void)
-{
- langset_count = 0;
-}
-
-/* ideally, should only write one copy of any particular FcLangSet */
-int
-FcLangSetNeededBytes (const FcLangSet *l)
-{
- langset_count++;
- return sizeof (FcLangSet);
-}
-
-int
-FcLangSetNeededBytesAlign (void)
-{
- return fc_alignof (FcLangSet);
-}
-
-static FcBool
-FcLangSetEnsureBank (int bi)
+FcBool
+FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l)
{
- if (!langsets || bi >= langset_bank_count)
- {
- int new_count = langset_bank_count + 2;
- int i;
- FcLangSet** tt;
- tt = realloc(langsets, new_count * sizeof(FcLangSet *));
- if (!tt)
- return FcFalse;
-
- langsets = tt;
- for (i = langset_bank_count; i < new_count; i++)
- langsets[i] = 0;
- langset_bank_count = new_count;
- }
-
+ if (!FcSerializeAlloc (serialize, l, sizeof (FcLangSet)))
+ return FcFalse;
return FcTrue;
}
-void *
-FcLangSetDistributeBytes (FcCache * metadata, void * block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcLangSetEnsureBank(bi))
- return 0;
-
- block_ptr = ALIGN(block_ptr, FcLangSet);
- langsets[bi] = block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- langset_count * sizeof(FcLangSet));
- langset_ptr = 0;
- metadata->langset_count = langset_count;
- return block_ptr;
-}
-
FcLangSet *
-FcLangSetSerialize(int bank, FcLangSet *l)
-{
- int p = langset_ptr, bi = FcCacheBankToIndex(bank);
-
- if (!l) return 0;
-
- langsets[bi][langset_ptr] = *l;
- langsets[bi][langset_ptr].extra = 0;
- langset_ptr++;
- return &langsets[bi][p];
-}
-
-void *
-FcLangSetUnserialize (FcCache * metadata, void *block_ptr)
+FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l)
{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcLangSetEnsureBank(bi))
- return 0;
+ FcLangSet *l_serialize = FcSerializePtr (serialize, l);
- FcMemAlloc (FC_MEM_LANGSET, metadata->langset_count * sizeof(FcLangSet));
- block_ptr = ALIGN(block_ptr, FcLangSet);
- langsets[bi] = (FcLangSet *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- metadata->langset_count * sizeof(FcLangSet));
- return block_ptr;
+ if (!l_serialize)
+ return NULL;
+ *l_serialize = *l;
+ return l_serialize;
}
diff --git a/src/fclist.c b/src/fclist.c
index 9aef842..c0b7fb0 100644
--- a/src/fclist.c
+++ b/src/fclist.c
@@ -130,23 +130,21 @@ FcListValueListMatchAny (FcValueListPtr
{
FcValueListPtr pat, fnt;
- for (pat = patOrig; FcValueListPtrU(pat);
- pat = FcValueListPtrU(pat)->next)
+ for (pat = patOrig; pat != NULL; pat = FcValueListNext(pat))
{
- for (fnt = fntOrig; FcValueListPtrU(fnt);
- fnt = FcValueListPtrU(fnt)->next)
+ for (fnt = fntOrig; fnt != NULL; fnt = FcValueListNext(fnt))
{
/*
* make sure the font 'contains' the pattern.
* (OpListing is OpContains except for strings
* where it requires an exact match)
*/
- if (FcConfigCompareValue (&FcValueListPtrU(fnt)->value,
+ if (FcConfigCompareValue (&fnt->value,
FcOpListing,
- &FcValueListPtrU(pat)->value))
+ &pat->value))
break;
}
- if (!FcValueListPtrU(fnt))
+ if (fnt == NULL)
return FcFalse;
}
return FcTrue;
@@ -158,26 +156,22 @@ FcListValueListEqual (FcValueListPtr v1o
{
FcValueListPtr v1, v2;
- for (v1 = v1orig; FcValueListPtrU(v1);
- v1 = FcValueListPtrU(v1)->next)
+ for (v1 = v1orig; v1 != NULL; v1 = FcValueListNext(v1))
{
- for (v2 = v2orig; FcValueListPtrU(v2);
- v2 = FcValueListPtrU(v2)->next)
- if (FcValueEqual (FcValueCanonicalize(&FcValueListPtrU(v1)->value),
- FcValueCanonicalize(&FcValueListPtrU(v2)->value)))
+ for (v2 = v2orig; v2 != NULL; v2 = FcValueListNext(v2))
+ if (FcValueEqual (FcValueCanonicalize(&(v1)->value),
+ FcValueCanonicalize(&(v2)->value)))
break;
- if (!FcValueListPtrU(v2))
+ if (v2 == NULL)
return FcFalse;
}
- for (v2 = v2orig; FcValueListPtrU(v2);
- v2 = FcValueListPtrU(v2)->next)
+ for (v2 = v2orig; v2 != NULL; v2 = FcValueListNext(v2))
{
- for (v1 = v1orig; FcValueListPtrU(v1);
- v1 = FcValueListPtrU(v1)->next)
- if (FcValueEqual (FcValueCanonicalize(&FcValueListPtrU(v1)->value),
- FcValueCanonicalize(&FcValueListPtrU(v2)->value)))
+ for (v1 = v1orig; v1 != NULL; v1 = FcValueListNext(v1))
+ if (FcValueEqual (FcValueCanonicalize(&v1->value),
+ FcValueCanonicalize(&v2->value)))
break;
- if (!FcValueListPtrU(v1))
+ if (v1 == NULL)
return FcFalse;
}
return FcTrue;
@@ -193,13 +187,14 @@ FcListPatternEqual (FcPattern *p1,
for (i = 0; i < os->nobject; i++)
{
- e1 = FcPatternFindElt (p1, os->objects[i]);
- e2 = FcPatternFindElt (p2, os->objects[i]);
+ e1 = FcPatternObjectFindElt (p1, FcObjectFromName (os->objects[i]));
+ e2 = FcPatternObjectFindElt (p2, FcObjectFromName (os->objects[i]));
if (!e1 && !e2)
continue;
if (!e1 || !e2)
return FcFalse;
- if (!FcListValueListEqual (e1->values, e2->values))
+ if (!FcListValueListEqual (FcPatternEltValues(e1),
+ FcPatternEltValues(e2)))
return FcFalse;
}
return FcTrue;
@@ -214,16 +209,15 @@ FcListPatternMatchAny (const FcPattern *
const FcPattern *font)
{
int i;
- FcPatternElt *e;
for (i = 0; i < p->num; i++)
{
- e = FcPatternFindElt (font,
- FcObjectPtrU((FcPatternEltU(p->elts)+i)->object));
- if (!e)
+ FcPatternElt *pe = &FcPatternElts(p)[i];
+ FcPatternElt *fe = FcPatternObjectFindElt (font, pe->object);
+ if (!fe)
return FcFalse;
- if (!FcListValueListMatchAny ((FcPatternEltU(p->elts)+i)->values, /* pat elts */
- e->values)) /* font elts */
+ if (!FcListValueListMatchAny (FcPatternEltValues(pe), /* pat elts */
+ FcPatternEltValues(fe))) /* font elts */
return FcFalse;
}
return FcTrue;
@@ -272,10 +266,10 @@ FcListValueListHash (FcValueListPtr list
{
FcChar32 h = 0;
- while (FcValueListPtrU(list))
+ while (list != NULL)
{
- h = h ^ FcListValueHash (&FcValueListPtrU(list)->value);
- list = FcValueListPtrU(list)->next;
+ h = h ^ FcListValueHash (&list->value);
+ list = FcValueListNext(list);
}
return h;
}
@@ -290,9 +284,9 @@ FcListPatternHash (FcPattern *font,
for (n = 0; n < os->nobject; n++)
{
- e = FcPatternFindElt (font, os->objects[n]);
+ e = FcPatternObjectFindElt (font, FcObjectFromName (os->objects[n]));
if (e)
- h = h ^ FcListValueListHash (e->values);
+ h = h ^ FcListValueListHash (FcPatternEltValues(e));
}
return h;
}
@@ -338,10 +332,10 @@ FcListHashTableCleanup (FcListHashTable
}
static int
-FcGetDefaultObjectLangIndex (FcPattern *font, const char *object)
+FcGetDefaultObjectLangIndex (FcPattern *font, FcObject object)
{
FcChar8 *lang = FcGetDefaultLang ();
- FcPatternElt *e = FcPatternFindElt (font, object);
+ FcPatternElt *e = FcPatternObjectFindElt (font, object);
FcValueListPtr v;
FcValue value;
int idx = -1;
@@ -349,9 +343,9 @@ FcGetDefaultObjectLangIndex (FcPattern *
if (e)
{
- for (v = e->values, i = 0; FcValueListPtrU(v); v = FcValueListPtrU(v)->next, ++i)
+ for (v = FcPatternEltValues(e), i = 0; v; v = FcValueListNext(v), ++i)
{
- value = FcValueCanonicalize (&FcValueListPtrU (v)->value);
+ value = FcValueCanonicalize (&v->value);
if (value.type == FcTypeString)
{
@@ -404,33 +398,33 @@ FcListAppend (FcListHashTable *table,
if (!strcmp (os->objects[o], FC_FAMILY) || !strcmp (os->objects[o], FC_FAMILYLANG))
{
if (familyidx < 0)
- familyidx = FcGetDefaultObjectLangIndex (font, FC_FAMILYLANG);
+ familyidx = FcGetDefaultObjectLangIndex (font, FC_FAMILYLANG_OBJECT);
defidx = familyidx;
}
else if (!strcmp (os->objects[o], FC_FULLNAME) || !strcmp (os->objects[o], FC_FULLNAMELANG))
{
if (fullnameidx < 0)
- fullnameidx = FcGetDefaultObjectLangIndex (font, FC_FULLNAMELANG);
+ fullnameidx = FcGetDefaultObjectLangIndex (font, FC_FULLNAMELANG_OBJECT);
defidx = fullnameidx;
}
else if (!strcmp (os->objects[o], FC_STYLE) || !strcmp (os->objects[o], FC_STYLELANG))
{
if (styleidx < 0)
- styleidx = FcGetDefaultObjectLangIndex (font, FC_STYLELANG);
+ styleidx = FcGetDefaultObjectLangIndex (font, FC_STYLELANG_OBJECT);
defidx = styleidx;
}
else
defidx = 0;
- e = FcPatternFindElt (font, os->objects[o]);
+ e = FcPatternObjectFindElt (font, FcObjectFromName (os->objects[o]));
if (e)
{
- for (v = e->values, idx = 0; FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next, ++idx)
+ for (v = FcPatternEltValues(e), idx = 0; v;
+ v = FcValueListNext(v), ++idx)
{
if (!FcPatternAdd (bucket->pattern,
os->objects[o],
- FcValueCanonicalize(&FcValueListPtrU(v)->value), defidx != idx))
+ FcValueCanonicalize(&v->value), defidx != idx))
goto bail2;
}
}
diff --git a/src/fcmatch.c b/src/fcmatch.c
index 739ef3e..7e3353b 100644
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -173,8 +173,7 @@ FcCompareSize (FcValue *value1, FcValue
}
typedef struct _FcMatcher {
- const char *object;
- FcObjectPtr objectPtr;
+ FcObject object;
double (*compare) (FcValue *value1, FcValue *value2);
int strong, weak;
} FcMatcher;
@@ -185,156 +184,111 @@ typedef struct _FcMatcher {
* later values
*/
static FcMatcher _FcMatchers [] = {
- { FC_FOUNDRY, 0, FcCompareString, 0, 0 },
+ { FC_FOUNDRY_OBJECT, FcCompareString, 0, 0 },
#define MATCH_FOUNDRY 0
#define MATCH_FOUNDRY_INDEX 0
- { FC_CHARSET, 0, FcCompareCharSet, 1, 1 },
+ { FC_CHARSET_OBJECT, FcCompareCharSet, 1, 1 },
#define MATCH_CHARSET 1
#define MATCH_CHARSET_INDEX 1
- { FC_FAMILY, 0, FcCompareFamily, 2, 4 },
+ { FC_FAMILY_OBJECT, FcCompareFamily, 2, 4 },
#define MATCH_FAMILY 2
#define MATCH_FAMILY_STRONG_INDEX 2
#define MATCH_FAMILY_WEAK_INDEX 4
- { FC_LANG, 0, FcCompareLang, 3, 3 },
+ { FC_LANG_OBJECT, FcCompareLang, 3, 3 },
#define MATCH_LANG 3
#define MATCH_LANG_INDEX 3
- { FC_SPACING, 0, FcCompareNumber, 5, 5 },
+ { FC_SPACING_OBJECT, FcCompareNumber, 5, 5 },
#define MATCH_SPACING 4
#define MATCH_SPACING_INDEX 5
- { FC_PIXEL_SIZE, 0, FcCompareSize, 6, 6 },
+ { FC_PIXEL_SIZE_OBJECT, FcCompareSize, 6, 6 },
#define MATCH_PIXEL_SIZE 5
#define MATCH_PIXEL_SIZE_INDEX 6
- { FC_STYLE, 0, FcCompareString, 7, 7 },
+ { FC_STYLE_OBJECT, FcCompareString, 7, 7 },
#define MATCH_STYLE 6
#define MATCH_STYLE_INDEX 7
- { FC_SLANT, 0, FcCompareNumber, 8, 8 },
+ { FC_SLANT_OBJECT, FcCompareNumber, 8, 8 },
#define MATCH_SLANT 7
#define MATCH_SLANT_INDEX 8
- { FC_WEIGHT, 0, FcCompareNumber, 9, 9 },
+ { FC_WEIGHT_OBJECT, FcCompareNumber, 9, 9 },
#define MATCH_WEIGHT 8
#define MATCH_WEIGHT_INDEX 9
- { FC_WIDTH, 0, FcCompareNumber, 10, 10 },
+ { FC_WIDTH_OBJECT, FcCompareNumber, 10, 10 },
#define MATCH_WIDTH 9
#define MATCH_WIDTH_INDEX 10
- { FC_ANTIALIAS, 0, FcCompareBool, 11, 11 },
+ { FC_ANTIALIAS_OBJECT, FcCompareBool, 11, 11 },
#define MATCH_ANTIALIAS 10
#define MATCH_ANTIALIAS_INDEX 11
- { FC_RASTERIZER, 0, FcCompareString, 12, 12 },
+ { FC_RASTERIZER_OBJECT, FcCompareString, 12, 12 },
#define MATCH_RASTERIZER 11
#define MATCH_RASTERIZER_INDEX 12
- { FC_OUTLINE, 0, FcCompareBool, 13, 13 },
+ { FC_OUTLINE_OBJECT, FcCompareBool, 13, 13 },
#define MATCH_OUTLINE 12
#define MATCH_OUTLINE_INDEX 13
- { FC_FONTVERSION, 0, FcCompareNumber, 14, 14 },
+ { FC_FONTVERSION_OBJECT, FcCompareNumber, 14, 14 },
#define MATCH_FONTVERSION 13
#define MATCH_FONTVERSION_INDEX 14
};
#define NUM_MATCH_VALUES 15
-static FcBool matchObjectPtrsInit = FcFalse;
-
-static void
-FcMatchObjectPtrsInit (void)
-{
- _FcMatchers[MATCH_FOUNDRY].objectPtr = FcObjectToPtr(FC_FOUNDRY);
- _FcMatchers[MATCH_CHARSET].objectPtr = FcObjectToPtr(FC_CHARSET);
- _FcMatchers[MATCH_FAMILY].objectPtr = FcObjectToPtr(FC_FAMILY);
- _FcMatchers[MATCH_LANG].objectPtr = FcObjectToPtr(FC_LANG);
- _FcMatchers[MATCH_SPACING].objectPtr = FcObjectToPtr(FC_SPACING);
- _FcMatchers[MATCH_PIXEL_SIZE].objectPtr = FcObjectToPtr(FC_PIXEL_SIZE);
- _FcMatchers[MATCH_STYLE].objectPtr = FcObjectToPtr(FC_STYLE);
- _FcMatchers[MATCH_SLANT].objectPtr = FcObjectToPtr(FC_SLANT);
- _FcMatchers[MATCH_WEIGHT].objectPtr = FcObjectToPtr(FC_WEIGHT);
- _FcMatchers[MATCH_WIDTH].objectPtr = FcObjectToPtr(FC_WIDTH);
- _FcMatchers[MATCH_ANTIALIAS].objectPtr = FcObjectToPtr(FC_ANTIALIAS);
- _FcMatchers[MATCH_RASTERIZER].objectPtr = FcObjectToPtr(FC_RASTERIZER);
- _FcMatchers[MATCH_OUTLINE].objectPtr = FcObjectToPtr(FC_OUTLINE);
- _FcMatchers[MATCH_FONTVERSION].objectPtr = FcObjectToPtr(FC_FONTVERSION);
- matchObjectPtrsInit = FcTrue;
-}
-
static FcMatcher*
-FcObjectPtrToMatcher (FcObjectPtr o)
+FcObjectToMatcher (FcObject object)
{
int i;
- const char *object = FcObjectPtrU(o);
i = -1;
- switch (object[0]) {
- case 'f':
- switch (object[1]) {
- case 'o':
- switch (object[2]) {
- case 'u':
- i = MATCH_FOUNDRY; break;
- case 'n':
- i = MATCH_FONTVERSION; break;
- }
- break;
- case 'a':
- i = MATCH_FAMILY; break;
- }
- break;
- case 'c':
+ switch (object) {
+ case FC_FOUNDRY_OBJECT:
+ i = MATCH_FOUNDRY; break;
+ case FC_FONTVERSION_OBJECT:
+ i = MATCH_FONTVERSION; break;
+ case FC_FAMILY_OBJECT:
+ i = MATCH_FAMILY; break;
+ case FC_CHARSET_OBJECT:
i = MATCH_CHARSET; break;
- case 'a':
+ case FC_ANTIALIAS_OBJECT:
i = MATCH_ANTIALIAS; break;
- case 'l':
+ case FC_LANG_OBJECT:
i = MATCH_LANG; break;
- case 's':
- switch (object[1]) {
- case 'p':
- i = MATCH_SPACING; break;
- case 't':
- i = MATCH_STYLE; break;
- case 'l':
- i = MATCH_SLANT; break;
- }
- break;
- case 'p':
+ case FC_SPACING_OBJECT:
+ i = MATCH_SPACING; break;
+ case FC_STYLE_OBJECT:
+ i = MATCH_STYLE; break;
+ case FC_SLANT_OBJECT:
+ i = MATCH_SLANT; break;
+ case FC_PIXEL_SIZE_OBJECT:
i = MATCH_PIXEL_SIZE; break;
- case 'w':
- switch (object[1]) {
- case 'i':
- i = MATCH_WIDTH; break;
- case 'e':
- i = MATCH_WEIGHT; break;
- }
- break;
- case 'r':
+ case FC_WIDTH_OBJECT:
+ i = MATCH_WIDTH; break;
+ case FC_WEIGHT_OBJECT:
+ i = MATCH_WEIGHT; break;
+ case FC_RASTERIZER_OBJECT:
i = MATCH_RASTERIZER; break;
- case 'o':
+ case FC_OUTLINE_OBJECT:
i = MATCH_OUTLINE; break;
}
if (i < 0)
- return 0;
-
- if (!matchObjectPtrsInit)
- FcMatchObjectPtrsInit();
-
- if (o != _FcMatchers[i].objectPtr)
- return 0;
+ return NULL;
return _FcMatchers+i;
}
static FcBool
-FcCompareValueList (FcObjectPtr o,
+FcCompareValueList (FcObject object,
FcValueListPtr v1orig, /* pattern */
FcValueListPtr v2orig, /* target */
FcValue *bestValue,
@@ -342,16 +296,14 @@ FcCompareValueList (FcObjectPtr o,
FcResult *result)
{
FcValueListPtr v1, v2;
- FcValueList *v1_ptrU, *v2_ptrU;
double v, best, bestStrong, bestWeak;
int j;
- const char *object = FcObjectPtrU(o);
- FcMatcher *match = FcObjectPtrToMatcher(o);
+ FcMatcher *match = FcObjectToMatcher(object);
if (!match)
{
if (bestValue)
- *bestValue = FcValueCanonicalize(&FcValueListPtrU(v2orig)->value);
+ *bestValue = FcValueCanonicalize(&v2orig->value);
return FcTrue;
}
@@ -359,13 +311,11 @@ FcCompareValueList (FcObjectPtr o,
bestStrong = 1e99;
bestWeak = 1e99;
j = 0;
- for (v1 = v1orig, v1_ptrU = FcValueListPtrU(v1); v1_ptrU;
- v1 = v1_ptrU->next, v1_ptrU = FcValueListPtrU(v1))
+ for (v1 = v1orig; v1; v1 = FcValueListNext(v1))
{
- for (v2 = v2orig, v2_ptrU = FcValueListPtrU(v2); v2_ptrU;
- v2 = v2_ptrU->next, v2_ptrU = FcValueListPtrU(v2))
+ for (v2 = v1orig; v2; v2 = FcValueListNext(v2))
{
- v = (match->compare) (&v1_ptrU->value, &v2_ptrU->value);
+ v = (match->compare) (&v1->value, &v2->value);
if (v < 0)
{
*result = FcResultTypeMismatch;
@@ -375,10 +325,10 @@ FcCompareValueList (FcObjectPtr o,
if (v < best)
{
if (bestValue)
- *bestValue = FcValueCanonicalize(&v2_ptrU->value);
+ *bestValue = FcValueCanonicalize(&v2->value);
best = v;
}
- if (v1_ptrU->binding == FcValueBindingStrong)
+ if (v1->binding == FcValueBindingStrong)
{
if (v < bestStrong)
bestStrong = v;
@@ -393,7 +343,7 @@ FcCompareValueList (FcObjectPtr o,
}
if (FcDebug () & FC_DBG_MATCHV)
{
- printf (" %s: %g ", object, best);
+ printf (" %s: %g ", FcObjectName (object), best);
FcValueListPrint (v1orig);
printf (", ");
FcValueListPrint (v2orig);
@@ -434,10 +384,10 @@ FcCompare (FcPattern *pat,
i2 = 0;
while (i1 < pat->num && i2 < fnt->num)
{
- FcPatternElt *elt_i1 = FcPatternEltU(pat->elts)+i1;
- FcPatternElt *elt_i2 = FcPatternEltU(fnt->elts)+i2;
+ FcPatternElt *elt_i1 = &FcPatternElts(pat)[i1];
+ FcPatternElt *elt_i2 = &FcPatternElts(fnt)[i2];
- i = FcObjectPtrCompare(elt_i1->object, elt_i2->object);
+ i = FcObjectCompare(elt_i1->object, elt_i2->object);
if (i > 0)
i2++;
else if (i < 0)
@@ -445,7 +395,8 @@ FcCompare (FcPattern *pat,
else
{
if (!FcCompareValueList (elt_i1->object,
- elt_i1->values, elt_i2->values,
+ FcPatternEltValues(elt_i1),
+ FcPatternEltValues(elt_i2),
0, value, result))
return FcFalse;
i1++;
@@ -471,28 +422,30 @@ FcFontRenderPrepare (FcConfig *confi
return 0;
for (i = 0; i < font->num; i++)
{
- fe = FcPatternEltU(font->elts)+i;
- pe = FcPatternFindElt (pat, FcObjectPtrU(fe->object));
+ fe = &FcPatternElts(font)[i];
+ pe = FcPatternObjectFindElt (pat, fe->object);
if (pe)
{
- if (!FcCompareValueList (pe->object, pe->values,
- fe->values, &v, 0, &result))
+ if (!FcCompareValueList (pe->object, FcPatternEltValues(pe),
+ FcPatternEltValues(fe), &v, 0, &result))
{
FcPatternDestroy (new);
return 0;
}
}
else
- v = FcValueCanonicalize(&FcValueListPtrU(fe->values)->value);
- FcPatternAdd (new, FcObjectPtrU(fe->object), v, FcFalse);
+ v = FcValueCanonicalize(&FcPatternEltValues (fe)->value);
+ FcPatternObjectAdd (new, fe->object, v, FcFalse);
}
for (i = 0; i < pat->num; i++)
{
- pe = FcPatternEltU(pat->elts)+i;
- fe = FcPatternFindElt (font, FcObjectPtrU(pe->object));
+ pe = &FcPatternElts(pat)[i];
+ fe = FcPatternObjectFindElt (font, pe->object);
if (!fe)
- FcPatternAdd (new, FcObjectPtrU(pe->object),
- FcValueCanonicalize(&FcValueListPtrU(pe->values)->value), FcTrue);
+ {
+ v = FcValueCanonicalize(&FcPatternEltValues(pe)->value);
+ FcPatternObjectAdd (new, pe->object, v, FcTrue);
+ }
}
FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
diff --git a/src/fcname.c b/src/fcname.c
index a5c8fee..96adc62 100644
--- a/src/fcname.c
+++ b/src/fcname.c
@@ -30,7 +30,7 @@
/* Please do not revoke any of these bindings. */
/* The __DUMMY__ object enables callers to distinguish the error return
- * of FcObjectToPtrLookup from FC_FAMILY's FcObjectPtr, which would
+ * of FcObjectToPtrLookup from FC_FAMILY's FcObject, which would
* otherwise be 0. */
static const FcObjectType _FcBaseObjectTypes[] = {
{ "__DUMMY__", FcTypeVoid, },
@@ -48,14 +48,12 @@ static const FcObjectType _FcBaseObjectT
{ FC_PIXEL_SIZE, FcTypeDouble, },
{ FC_SPACING, FcTypeInteger, },
{ FC_FOUNDRY, FcTypeString, },
-/* { FC_CORE, FcTypeBool, }, */
{ FC_ANTIALIAS, FcTypeBool, },
{ FC_HINT_STYLE, FcTypeInteger, },
{ FC_HINTING, FcTypeBool, },
{ FC_VERTICAL_LAYOUT, FcTypeBool, },
{ FC_AUTOHINT, FcTypeBool, },
{ FC_GLOBAL_ADVANCE, FcTypeBool, },
-/* { FC_XLFD, FcTypeString, }, */
{ FC_FILE, FcTypeString, },
{ FC_INDEX, FcTypeInteger, },
{ FC_RASTERIZER, FcTypeString, },
@@ -65,7 +63,6 @@ static const FcObjectType _FcBaseObjectT
{ FC_RGBA, FcTypeInteger, },
{ FC_SCALE, FcTypeDouble, },
{ FC_MINSPACE, FcTypeBool, },
-/* { FC_RENDER, FcTypeBool, },*/
{ FC_CHAR_WIDTH, FcTypeInteger },
{ FC_CHAR_HEIGHT, FcTypeInteger },
{ FC_MATRIX, FcTypeMatrix },
@@ -182,16 +179,13 @@ static struct objectBucket *FcObjectBuck
/* Design constraint: biggest_known_ntypes must never change
* after any call to FcNameRegisterObjectTypes. */
static const FcObjectType *biggest_known_types = _FcBaseObjectTypes;
-static FcBool allocated_biggest_known_types;
static int biggest_known_ntypes = NUM_OBJECT_TYPES;
-static int biggest_known_count = 0;
-static char * biggest_ptr;
-static FcObjectPtr
+static FcObject
FcObjectToPtrLookup (const char * object)
{
- FcObjectPtr i = 0, n;
+ FcObject i = 0, n;
const FcObjectTypeList *l;
FcObjectType *t = _FcUserObjectNames;
FcBool replace;
@@ -251,8 +245,16 @@ FcObjectToPtrLookup (const char * object
return -n;
}
-FcObjectPtr
-FcObjectToPtr (const char * name)
+FcBool
+FcObjectValidType (FcObject object, FcType type)
+{
+ if (object < NUM_OBJECT_TYPES && _FcBaseObjectTypes[object].type != type)
+ return FcFalse;
+ return FcTrue;
+}
+
+FcObject
+FcObjectFromName (const char * name)
{
FcChar32 hash = FcStringHash ((const FcChar8 *) name);
struct objectBucket **p;
@@ -299,112 +301,24 @@ FcObjectStaticNameFini (void)
}
const char *
-FcObjectPtrU (FcObjectPtr si)
+FcObjectName (FcObject object)
{
const FcObjectTypeList *l;
int i, j;
- if (si > 0)
+ if (object > 0)
{
- if (si < biggest_known_ntypes)
- return biggest_known_types[si].object;
+ if (object < biggest_known_ntypes)
+ return biggest_known_types[object].object;
j = 0;
for (l = _FcObjectTypes; l; l = l->next)
for (i = 0; i < l->ntypes; i++, j++)
- if (j == si)
+ if (j == object)
return l->types[i].object;
}
- return _FcUserObjectNames[-si].object;
-}
-
-int
-FcObjectNeededBytes ()
-{
- int num = 0, i;
- for (i = 0; i < biggest_known_ntypes; i++)
- {
- const char * t = biggest_known_types[i].object;
- num = num + strlen(t) + 1;
- }
- biggest_known_count = num;
- return num + sizeof(int);
-}
-
-int
-FcObjectNeededBytesAlign (void)
-{
- return fc_alignof (int) + fc_alignof (char);
-}
-
-void *
-FcObjectDistributeBytes (FcCache * metadata, void * block_ptr)
-{
- block_ptr = ALIGN (block_ptr, int);
- *(int *)block_ptr = biggest_known_ntypes;
- block_ptr = (int *) block_ptr + 1;
- block_ptr = ALIGN (block_ptr, char);
- biggest_ptr = block_ptr;
- block_ptr = (char *) block_ptr + biggest_known_count;
- return block_ptr;
-}
-
-void
-FcObjectSerialize (void)
-{
- int i;
- for (i = 0; i < biggest_known_ntypes; i++)
- {
- const char * t = biggest_known_types[i].object;
- strcpy (biggest_ptr, t);
- biggest_ptr = biggest_ptr + strlen(t) + 1;
- }
-}
-
-void *
-FcObjectUnserialize (FcCache * metadata, void *block_ptr)
-{
- int new_biggest;
- block_ptr = ALIGN (block_ptr, int);
- new_biggest = *(int *)block_ptr;
- block_ptr = (int *) block_ptr + 1;
- if (biggest_known_ntypes < new_biggest)
- {
- int i;
- char * bp = (char *)block_ptr;
- FcObjectType * bn;
-
- bn = malloc (sizeof (const FcObjectType) * (new_biggest + 1));
- if (!bn)
- return 0;
-
- for (i = 0; i < new_biggest; i++)
- {
- const FcObjectType * t = FcNameGetObjectType(bp);
- if (t)
- bn[i].type = t->type;
- else
- bn[i].type = FcTypeVoid;
- bn[i].object = bp;
- bp = bp + strlen(bp) + 1;
- }
-
- FcNameUnregisterObjectTypesFree (biggest_known_types, biggest_known_ntypes, FcFalse);
- if (allocated_biggest_known_types)
- {
- free ((FcObjectTypeList *)biggest_known_types);
- }
- else
- allocated_biggest_known_types = FcTrue;
-
- FcNameRegisterObjectTypes (bn, new_biggest);
- biggest_known_ntypes = new_biggest;
- biggest_known_types = (const FcObjectType *)bn;
- }
- block_ptr = ALIGN (block_ptr, char);
- block_ptr = (char *) block_ptr + biggest_known_count;
- return block_ptr;
+ return _FcUserObjectNames[-object].object;
}
static const FcConstant _FcBaseConstants[] = {
@@ -803,11 +717,11 @@ FcNameUnparseValueList (FcStrBuf *buf,
FcValueListPtr v,
FcChar8 *escape)
{
- while (FcValueListPtrU(v))
+ while (v)
{
- if (!FcNameUnparseValue (buf, &FcValueListPtrU(v)->value, escape))
+ if (!FcNameUnparseValue (buf, &v->value, escape))
return FcFalse;
- if (FcValueListPtrU(v = FcValueListPtrU(v)->next))
+ if ((v = FcValueListNext(v)) != NULL)
if (!FcNameUnparseString (buf, (FcChar8 *) ",", 0))
return FcFalse;
}
@@ -834,18 +748,18 @@ FcNameUnparseEscaped (FcPattern *pat, Fc
const FcObjectType *o;
FcStrBufInit (&buf, buf_static, sizeof (buf_static));
- e = FcPatternFindElt (pat, FC_FAMILY);
+ e = FcPatternObjectFindElt (pat, FC_FAMILY_OBJECT);
if (e)
{
- if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
+ if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
goto bail0;
}
- e = FcPatternFindElt (pat, FC_SIZE);
+ e = FcPatternObjectFindElt (pat, FC_SIZE_OBJECT);
if (e)
{
if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0))
goto bail0;
- if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
+ if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
goto bail0;
}
for (l = _FcObjectTypes; l; l = l->next)
@@ -858,7 +772,7 @@ FcNameUnparseEscaped (FcPattern *pat, Fc
!strcmp (o->object, FC_FILE))
continue;
- e = FcPatternFindElt (pat, o->object);
+ e = FcPatternObjectFindElt (pat, FcObjectFromName (o->object));
if (e)
{
if (!FcNameUnparseString (&buf, (FcChar8 *) ":", 0))
@@ -867,7 +781,7 @@ FcNameUnparseEscaped (FcPattern *pat, Fc
goto bail0;
if (!FcNameUnparseString (&buf, (FcChar8 *) "=", 0))
goto bail0;
- if (!FcNameUnparseValueList (&buf, e->values, escape ?
+ if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ?
(FcChar8 *) FC_ESCAPE_VARIABLE : 0))
goto bail0;
}
diff --git a/src/fcpat.c b/src/fcpat.c
index da1d490..7432745 100644
--- a/src/fcpat.c
+++ b/src/fcpat.c
@@ -1,6 +1,4 @@
/*
- * $RCSId: xc/lib/fontconfig/src/fcpat.c,v 1.18 2002/09/18 17:11:46 tsi Exp $
- *
* Copyright © 2000 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
@@ -27,15 +25,6 @@
#include <string.h>
#include <assert.h>
-static FcPattern ** _fcPatterns = 0;
-static int fcpattern_bank_count = 0, fcpattern_ptr, fcpattern_count;
-FcPatternElt ** _fcPatternElts = 0;
-static int fcpatternelt_ptr, fcpatternelt_count;
-FcValueList ** _fcValueLists = 0;
-static int fcvaluelist_bank_count = 0, fcvaluelist_ptr, fcvaluelist_count;
-
-static FcPatternEltPtr
-FcPatternEltPtrCreateDynamic (FcPatternElt * e);
static FcBool
FcStrHashed (const FcChar8 *name);
@@ -50,8 +39,7 @@ FcPatternCreate (void)
FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern));
p->num = 0;
p->size = 0;
- p->elts = FcPatternEltPtrCreateDynamic(0);
- p->bank = FC_BANK_DYNAMIC;
+ p->elts_offset = FcPtrToOffset (p, NULL);
p->ref = 1;
return p;
}
@@ -81,28 +69,27 @@ FcValueDestroy (FcValue v)
FcValue
FcValueCanonicalize (const FcValue *v)
{
- if (v->type & FC_STORAGE_STATIC)
- {
- FcValue new = *v;
+ FcValue new;
- switch (v->type & ~FC_STORAGE_STATIC)
- {
- case FcTypeString:
- new.u.s = fc_value_string(v);
- new.type = FcTypeString;
- break;
- case FcTypeCharSet:
- new.u.c = fc_value_charset(v);
- new.type = FcTypeCharSet;
- break;
- case FcTypeLangSet:
- new.u.l = fc_value_langset(v);
- new.type = FcTypeLangSet;
- break;
- }
- return new;
+ switch (v->type)
+ {
+ case FcTypeString:
+ new.u.s = fc_value_string(v);
+ new.type = FcTypeString;
+ break;
+ case FcTypeCharSet:
+ new.u.c = fc_value_charset(v);
+ new.type = FcTypeCharSet;
+ break;
+ case FcTypeLangSet:
+ new.u.l = fc_value_langset(v);
+ new.type = FcTypeLangSet;
+ break;
+ default:
+ new = *v;
+ break;
}
- return *v;
+ return new;
}
FcValue
@@ -139,31 +126,30 @@ void
FcValueListDestroy (FcValueListPtr l)
{
FcValueListPtr next;
- for (; FcValueListPtrU(l); l = next)
+ for (; l; l = next)
{
- switch (FcValueListPtrU(l)->value.type) {
+ switch (l->value.type) {
case FcTypeString:
- if (!FcStrHashed ((FcChar8 *)FcValueListPtrU(l)->value.u.s))
- FcStrFree ((FcChar8 *)FcValueListPtrU(l)->value.u.s);
+ if (!FcStrHashed ((FcChar8 *)l->value.u.s))
+ FcStrFree ((FcChar8 *)l->value.u.s);
break;
case FcTypeMatrix:
- FcMatrixFree ((FcMatrix *)FcValueListPtrU(l)->value.u.m);
+ FcMatrixFree ((FcMatrix *)l->value.u.m);
break;
case FcTypeCharSet:
FcCharSetDestroy
- ((FcCharSet *) (FcValueListPtrU(l)->value.u.c));
+ ((FcCharSet *) (l->value.u.c));
break;
case FcTypeLangSet:
FcLangSetDestroy
- ((FcLangSet *) (FcValueListPtrU(l)->value.u.l));
+ ((FcLangSet *) (l->value.u.l));
break;
default:
break;
}
- next = FcValueListPtrU(l)->next;
+ next = FcValueListNext(l);
FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
- if (l.bank == FC_BANK_DYNAMIC)
- free(l.u.dyn);
+ free(l);
}
}
@@ -263,18 +249,17 @@ FcValueHash (const FcValue *v)
static FcBool
FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)
{
- if (FcValueListPtrU(la) == FcValueListPtrU(lb))
+ if (la == lb)
return FcTrue;
- while (FcValueListPtrU(la) && FcValueListPtrU(lb))
+ while (la && lb)
{
- if (!FcValueEqual (FcValueListPtrU(la)->value,
- FcValueListPtrU(lb)->value))
+ if (!FcValueEqual (la->value, lb->value))
return FcFalse;
- la = FcValueListPtrU(la)->next;
- lb = FcValueListPtrU(lb)->next;
+ la = FcValueListNext(la);
+ lb = FcValueListNext(lb);
}
- if (FcValueListPtrU(la) || FcValueListPtrU(lb))
+ if (la || lb)
return FcFalse;
return FcTrue;
}
@@ -283,12 +268,10 @@ static FcChar32
FcValueListHash (FcValueListPtr l)
{
FcChar32 hash = 0;
- FcValueList *l_ptrU;
- for (l_ptrU = FcValueListPtrU(l); l_ptrU;
- l_ptrU = FcValueListPtrU(l_ptrU->next))
+ for (; l; l = FcValueListNext(l))
{
- hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l_ptrU->value);
+ hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);
}
return hash;
}
@@ -297,32 +280,27 @@ void
FcPatternDestroy (FcPattern *p)
{
int i;
+ FcPatternElt *elts;
if (p->ref == FC_REF_CONSTANT || --p->ref > 0)
return;
+ elts = FcPatternElts (p);
for (i = 0; i < p->num; i++)
- FcValueListDestroy ((FcPatternEltU(p->elts)+i)->values);
+ FcValueListDestroy (FcPatternEltValues(&elts[i]));
- p->num = 0;
- if (FcPatternEltU(p->elts) && p->elts.bank == FC_BANK_DYNAMIC)
- {
- FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
- free (FcPatternEltU(p->elts));
- p->elts = FcPatternEltPtrCreateDynamic(0);
- }
- p->size = 0;
+ FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
+ free (elts);
FcMemFree (FC_MEM_PATTERN, sizeof (FcPattern));
free (p);
}
static int
-FcPatternPosition (const FcPattern *p, const char *object)
+FcPatternObjectPosition (const FcPattern *p, FcObject object)
{
int low, high, mid, c;
- FcObjectPtr obj;
+ FcPatternElt *elts = FcPatternElts(p);
- obj = FcObjectToPtr(object);
low = 0;
high = p->num - 1;
c = 1;
@@ -330,7 +308,7 @@ FcPatternPosition (const FcPattern *p, c
while (low <= high)
{
mid = (low + high) >> 1;
- c = FcObjectPtrCompare((FcPatternEltU(p->elts)+mid)->object, obj);
+ c = elts[mid].object - object;
if (c == 0)
return mid;
if (c < 0)
@@ -344,21 +322,21 @@ FcPatternPosition (const FcPattern *p, c
}
FcPatternElt *
-FcPatternFindElt (const FcPattern *p, const char *object)
+FcPatternObjectFindElt (const FcPattern *p, FcObject object)
{
- int i = FcPatternPosition (p, object);
+ int i = FcPatternObjectPosition (p, object);
if (i < 0)
return 0;
- return FcPatternEltU(p->elts)+i;
+ return &FcPatternElts(p)[i];
}
FcPatternElt *
-FcPatternInsertElt (FcPattern *p, const char *object)
+FcPatternObjectInsertElt (FcPattern *p, FcObject object)
{
int i;
FcPatternElt *e;
- i = FcPatternPosition (p, object);
+ i = FcPatternObjectPosition (p, object);
if (i < 0)
{
i = -i - 1;
@@ -367,9 +345,9 @@ FcPatternInsertElt (FcPattern *p, const
if (p->num + 1 >= p->size)
{
int s = p->size + 16;
- if (FcPatternEltU(p->elts))
+ if (p->size)
{
- FcPatternElt *e0 = FcPatternEltU(p->elts);
+ FcPatternElt *e0 = FcPatternElts(p);
e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));
if (!e) /* maybe it was mmapped */
{
@@ -382,52 +360,54 @@ FcPatternInsertElt (FcPattern *p, const
e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));
if (!e)
return FcFalse;
- p->elts = FcPatternEltPtrCreateDynamic(e);
+ p->elts_offset = FcPtrToOffset (p, e);
if (p->size)
FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
FcMemAlloc (FC_MEM_PATELT, s * sizeof (FcPatternElt));
while (p->size < s)
{
- (FcPatternEltU(p->elts)+p->size)->object = 0;
- (FcPatternEltU(p->elts)+p->size)->values =
- FcValueListPtrCreateDynamic(0);
+ e[p->size].object = 0;
+ e[p->size].values = NULL;
p->size++;
}
}
+ e = FcPatternElts(p);
/* move elts up */
- memmove (FcPatternEltU(p->elts) + i + 1,
- FcPatternEltU(p->elts) + i,
+ memmove (e + i + 1,
+ e + i,
sizeof (FcPatternElt) *
(p->num - i));
/* bump count */
p->num++;
- (FcPatternEltU(p->elts)+i)->object = FcObjectToPtr (object);
- (FcPatternEltU(p->elts)+i)->values = FcValueListPtrCreateDynamic(0);
+ e[i].object = object;
+ e[i].values = NULL;
}
- return FcPatternEltU(p->elts)+i;
+ return FcPatternElts(p) + i;
}
FcBool
FcPatternEqual (const FcPattern *pa, const FcPattern *pb)
{
int i;
+ FcPatternElt *pae, *pbe;
if (pa == pb)
return FcTrue;
if (pa->num != pb->num)
return FcFalse;
+ pae = FcPatternElts(pa);
+ pbe = FcPatternElts(pb);
for (i = 0; i < pa->num; i++)
{
- if (FcObjectPtrCompare((FcPatternEltU(pa->elts)+i)->object,
- (FcPatternEltU(pb->elts)+i)->object) != 0)
+ if (pae[i].object != pbe[i].object)
return FcFalse;
- if (!FcValueListEqual ((FcPatternEltU(pa->elts)+i)->values,
- (FcPatternEltU(pb->elts)+i)->values))
+ if (!FcValueListEqual (FcPatternEltValues(&pae[i]),
+ FcPatternEltValues(&pbe[i])))
return FcFalse;
}
return FcTrue;
@@ -438,12 +418,13 @@ FcPatternHash (const FcPattern *p)
{
int i;
FcChar32 h = 0;
+ FcPatternElt *pe = FcPatternElts(p);
for (i = 0; i < p->num; i++)
{
h = (((h << 1) | (h >> 31)) ^
- FcStringHash ((FcChar8 *)FcObjectPtrU ((FcPatternEltU(p->elts)+i)->object)) ^
- FcValueListHash ((FcPatternEltU(p->elts)+i)->values));
+ pe[i].object ^
+ FcValueListHash (FcPatternEltValues(&pe[i])));
}
return h;
}
@@ -456,13 +437,14 @@ FcPatternEqualSubset (const FcPattern *p
for (i = 0; i < os->nobject; i++)
{
- ea = FcPatternFindElt (pai, os->objects[i]);
- eb = FcPatternFindElt (pbi, os->objects[i]);
+ FcObject object = FcObjectFromName (os->objects[i]);
+ ea = FcPatternObjectFindElt (pai, object);
+ eb = FcPatternObjectFindElt (pbi, object);
if (ea)
{
if (!eb)
return FcFalse;
- if (!FcValueListEqual (ea->values, eb->values))
+ if (!FcValueListEqual (FcPatternEltValues(ea), FcPatternEltValues(eb)))
return FcFalse;
}
else
@@ -475,26 +457,23 @@ FcPatternEqualSubset (const FcPattern *p
}
FcBool
-FcPatternAddWithBinding (FcPattern *p,
- const char *object,
- FcValue value,
- FcValueBinding binding,
- FcBool append)
+FcPatternObjectAddWithBinding (FcPattern *p,
+ FcObject object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append)
{
FcPatternElt *e;
FcValueListPtr new, *prev;
- FcValueList *newp;
- FcObjectPtr objectPtr;
if (p->ref == FC_REF_CONSTANT)
goto bail0;
- newp = malloc (sizeof (FcValueList));
- if (!newp)
+ new = malloc (sizeof (FcValueList));
+ if (!new)
goto bail0;
- memset(newp, 0, sizeof (FcValueList));
- new = FcValueListPtrCreateDynamic(newp);
+ memset(new, 0, sizeof (FcValueList));
FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
/* dup string */
if (value.type == FcTypeString)
@@ -508,88 +487,70 @@ FcPatternAddWithBinding (FcPattern
if (value.type == FcTypeVoid)
goto bail1;
- /* quick and dirty hack to enable FcCompareFamily/FcCompareString
- * speedup: only allow strings to be added under the FC_FAMILY,
- * FC_FOUNDRY, FC_STYLE, FC_RASTERIZER keys.
- * and charsets under FC_CHARSET key.
- * This is slightly semantically different from the old behaviour,
- * but fonts shouldn't be getting non-strings here anyway.
- * a better hack would use FcBaseObjectTypes to check all objects. */
- objectPtr = FcObjectToPtr(object);
- if ((objectPtr == FcObjectToPtr(FC_FAMILY)
- || objectPtr == FcObjectToPtr(FC_FOUNDRY)
- || objectPtr == FcObjectToPtr(FC_STYLE)
- || objectPtr == FcObjectToPtr(FC_RASTERIZER))
- && value.type != FcTypeString)
- goto bail1;
- if (objectPtr == FcObjectToPtr(FC_CHARSET)
- && value.type != FcTypeCharSet)
- goto bail1;
-
- FcValueListPtrU(new)->value = value;
- FcValueListPtrU(new)->binding = binding;
- FcValueListPtrU(new)->next = FcValueListPtrCreateDynamic(0);
+ /*
+ * Make sure the stored type is valid for built-in objects
+ */
+ if (!FcObjectValidType (object, value.type))
+ goto bail1;
+
+ new->value = value;
+ new->binding = binding;
+ new->next = NULL;
- e = FcPatternInsertElt (p, object);
+ e = FcPatternObjectInsertElt (p, object);
if (!e)
goto bail2;
if (append)
{
- for (prev = &e->values; FcValueListPtrU(*prev); prev = &FcValueListPtrU(*prev)->next)
+ for (prev = &e->values; *prev; prev = &(*prev)->next)
;
*prev = new;
}
else
{
- FcValueListPtrU(new)->next = e->values;
+ new->next = e->values;
e->values = new;
}
return FcTrue;
bail2:
- switch (value.type) {
- case FcTypeString:
- FcStrFree ((FcChar8 *) value.u.s);
- break;
- case FcTypeMatrix:
- FcMatrixFree ((FcMatrix *) value.u.m);
- break;
- case FcTypeCharSet:
- FcCharSetDestroy ((FcCharSet *) value.u.c);
- break;
- case FcTypeLangSet:
- FcLangSetDestroy ((FcLangSet *) value.u.l);
- break;
- default:
- break;
- }
+ FcValueDestroy (value);
bail1:
FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
- free (FcValueListPtrU(new));
+ free (new);
bail0:
return FcFalse;
}
FcBool
+FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)
+{
+ return FcPatternObjectAddWithBinding (p, object,
+ value, FcValueBindingStrong, append);
+}
+
+FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
{
- return FcPatternAddWithBinding (p, object, value, FcValueBindingStrong, append);
+ return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
+ value, FcValueBindingStrong, append);
}
FcBool
FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append)
{
- return FcPatternAddWithBinding (p, object, value, FcValueBindingWeak, append);
+ return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
+ value, FcValueBindingWeak, append);
}
FcBool
-FcPatternDel (FcPattern *p, const char *object)
+FcPatternObjectDel (FcPattern *p, FcObject object)
{
FcPatternElt *e;
- e = FcPatternFindElt (p, object);
+ e = FcPatternObjectFindElt (p, object);
if (!e)
return FcFalse;
@@ -598,33 +559,38 @@ FcPatternDel (FcPattern *p, const char *
/* shuffle existing ones down */
memmove (e, e+1,
- (FcPatternEltU(p->elts) + p->num - (e + 1)) *
+ (FcPatternElts(p) + p->num - (e + 1)) *
sizeof (FcPatternElt));
p->num--;
- (FcPatternEltU(p->elts)+p->num)->object = 0;
- (FcPatternEltU(p->elts)+p->num)->values = FcValueListPtrCreateDynamic(0);
+ e = FcPatternElts(p) + p->num;
+ e->object = 0;
+ e->values = NULL;
return FcTrue;
}
FcBool
+FcPatternDel (FcPattern *p, const char *object)
+{
+ return FcPatternObjectDel (p, FcObjectFromName (object));
+}
+
+FcBool
FcPatternRemove (FcPattern *p, const char *object, int id)
{
FcPatternElt *e;
FcValueListPtr *prev, l;
- e = FcPatternFindElt (p, object);
+ e = FcPatternObjectFindElt (p, FcObjectFromName (object));
if (!e)
return FcFalse;
- for (prev = &e->values;
- FcValueListPtrU(l = *prev);
- prev = &FcValueListPtrU(l)->next)
+ for (prev = &e->values; (l = *prev); prev = &l->next)
{
if (!id)
{
- *prev = FcValueListPtrU(l)->next;
- FcValueListPtrU(l)->next = FcValueListPtrCreateDynamic(0);
+ *prev = l->next;
+ l->next = NULL;
FcValueListDestroy (l);
- if (!FcValueListPtrU(e->values))
+ if (!e->values)
FcPatternDel (p, object);
return FcTrue;
}
@@ -634,28 +600,40 @@ FcPatternRemove (FcPattern *p, const cha
}
FcBool
-FcPatternAddInteger (FcPattern *p, const char *object, int i)
+FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)
{
FcValue v;
v.type = FcTypeInteger;
v.u.i = i;
- return FcPatternAdd (p, object, v, FcTrue);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
}
FcBool
-FcPatternAddDouble (FcPattern *p, const char *object, double d)
+FcPatternAddInteger (FcPattern *p, const char *object, int i)
+{
+ return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);
+}
+
+FcBool
+FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)
{
FcValue v;
v.type = FcTypeDouble;
v.u.d = d;
- return FcPatternAdd (p, object, v, FcTrue);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
}
FcBool
-FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
+FcPatternAddDouble (FcPattern *p, const char *object, double d)
+{
+ return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);
+}
+
+FcBool
+FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)
{
FcValue v;
@@ -663,12 +641,18 @@ FcPatternAddString (FcPattern *p, const
{
v.type = FcTypeVoid;
v.u.s = 0;
- return FcPatternAdd (p, object, v, FcTrue);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
}
v.type = FcTypeString;
v.u.s = FcStrStaticName(s);
- return FcPatternAdd (p, object, v, FcTrue);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
+{
+ return FcPatternObjectAddString (p, FcObjectFromName (object), s);
}
FcBool
@@ -683,13 +667,19 @@ FcPatternAddMatrix (FcPattern *p, const
FcBool
-FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
+FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b)
{
FcValue v;
v.type = FcTypeBool;
v.u.b = b;
- return FcPatternAdd (p, object, v, FcTrue);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
+{
+ return FcPatternObjectAddBool (p, FcObjectFromName (object), b);
}
FcBool
@@ -723,19 +713,19 @@ FcPatternAddLangSet (FcPattern *p, const
}
FcResult
-FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
+FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
{
FcPatternElt *e;
FcValueListPtr l;
- e = FcPatternFindElt (p, object);
+ e = FcPatternObjectFindElt (p, object);
if (!e)
return FcResultNoMatch;
- for (l = e->values; FcValueListPtrU(l); l = FcValueListPtrU(l)->next)
+ for (l = FcPatternEltValues(e); l; l = FcValueListNext(l))
{
if (!id)
{
- *v = FcValueCanonicalize(&FcValueListPtrU(l)->value);
+ *v = FcValueCanonicalize(&l->value);
return FcResultMatch;
}
id--;
@@ -744,12 +734,18 @@ FcPatternGet (const FcPattern *p, const
}
FcResult
-FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
+FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
+{
+ return FcPatternObjectGet (p, FcObjectFromName (object), id, v);
+}
+
+FcResult
+FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int id, int *i)
{
FcValue v;
FcResult r;
- r = FcPatternGet (p, object, id, &v);
+ r = FcPatternObjectGet (p, object, id, &v);
if (r != FcResultMatch)
return r;
switch (v.type) {
@@ -766,12 +762,19 @@ FcPatternGetInteger (const FcPattern *p,
}
FcResult
-FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
+FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
+{
+ return FcPatternObjectGetInteger (p, FcObjectFromName (object), id, i);
+}
+
+
+FcResult
+FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int id, double *d)
{
FcValue v;
FcResult r;
- r = FcPatternGet (p, object, id, &v);
+ r = FcPatternObjectGet (p, object, id, &v);
if (r != FcResultMatch)
return r;
switch (v.type) {
@@ -788,12 +791,18 @@ FcPatternGetDouble (const FcPattern *p,
}
FcResult
-FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
+FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
+{
+ return FcPatternObjectGetDouble (p, FcObjectFromName (object), id, d);
+}
+
+FcResult
+FcPatternObjectGetString (const FcPattern *p, FcObject object, int id, FcChar8 ** s)
{
FcValue v;
FcResult r;
- r = FcPatternGet (p, object, id, &v);
+ r = FcPatternObjectGet (p, object, id, &v);
if (r != FcResultMatch)
return r;
if (v.type != FcTypeString)
@@ -804,6 +813,12 @@ FcPatternGetString (const FcPattern *p,
}
FcResult
+FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
+{
+ return FcPatternObjectGetString (p, FcObjectFromName (object), id, s);
+}
+
+FcResult
FcPatternGetMatrix(const FcPattern *p, const char *object, int id, FcMatrix **m)
{
FcValue v;
@@ -891,16 +906,14 @@ FcPatternDuplicate (const FcPattern *ori
if (!new)
goto bail0;
- e = FcPatternEltU(orig->elts);
+ e = FcPatternElts(orig);
for (i = 0; i < orig->num; i++)
{
- for (l = (e + i)->values;
- FcValueListPtrU(l);
- l = FcValueListPtrU(l)->next)
- if (!FcPatternAdd (new, FcObjectPtrU((e + i)->object),
- FcValueCanonicalize(&FcValueListPtrU(l)->value),
- FcTrue))
+ for (l = FcPatternEltValues(e + i); l; l = FcValueListNext(l))
+ if (!FcPatternObjectAdd (new, e[i].object,
+ FcValueCanonicalize(&l->value),
+ FcTrue))
goto bail1;
}
@@ -951,13 +964,12 @@ FcPatternAppend (FcPattern *p, FcPattern
for (i = 0; i < s->num; i++)
{
- e = FcPatternEltU(s->elts)+i;
- for (v = e->values; FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next)
+ e = FcPatternElts(s)+i;
+ for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
{
- if (!FcPatternAddWithBinding (p, FcObjectPtrU(e->object),
- FcValueCanonicalize(&FcValueListPtrU(v)->value),
- FcValueListPtrU(v)->binding, FcTrue))
+ if (!FcPatternObjectAddWithBinding (p, e->object,
+ FcValueCanonicalize(&v->value),
+ v->binding, FcTrue))
return FcFalse;
}
}
@@ -1035,561 +1047,140 @@ FcPatternFini (void)
FcObjectStaticNameFini ();
}
-static FcPatternEltPtr
-FcPatternEltPtrCreateDynamic (FcPatternElt * e)
-{
- FcPatternEltPtr new;
- new.bank = FC_BANK_DYNAMIC;
- new.u.dyn = e;
- return new;
-}
-
-static FcPatternEltPtr
-FcPatternEltPtrCreateStatic (int bank, int i)
-{
- FcPatternEltPtr new;
- new.bank = bank;
- new.u.stat = i;
- return new;
-}
-
-static void
-FcStrNewBank (void);
-static int
-FcStrNeededBytes (const FcChar8 * s);
-static int
-FcStrNeededBytesAlign (void);
-static void *
-FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
-static const FcChar8 *
-FcStrSerialize (int bank, const FcChar8 * s);
-static void *
-FcStrUnserialize (FcCache * metadata, void *block_ptr);
-
-static void
-FcValueListNewBank (void);
-static int
-FcValueListNeededBytes (FcValueList * vl);
-static int
-FcValueListNeededBytesAlign (void);
-static void *
-FcValueListDistributeBytes (FcCache * metadata, void *block_ptr);
-static FcValueListPtr
-FcValueListSerialize(int bank, FcValueList *pi);
-static void *
-FcValueListUnserialize (FcCache * metadata, void *block_ptr);
-
-
-void
-FcPatternNewBank (void)
-{
- fcpattern_count = 0;
- fcpatternelt_count = 0;
-
- FcStrNewBank();
- FcValueListNewBank();
-}
-
-int
-FcPatternNeededBytes (FcPattern * p)
-{
- int i, cum = 0, c;
-
- fcpattern_count++;
- fcpatternelt_count += p->num;
-
- for (i = 0; i < p->num; i++)
- {
- c = FcValueListNeededBytes (FcValueListPtrU
- (((FcPatternEltU(p->elts)+i)->values)));
- if (c < 0)
- return c;
- cum += c;
- }
-
- return cum + sizeof (FcPattern) + sizeof(FcPatternElt)*p->num;
-}
-
-int
-FcPatternNeededBytesAlign (void)
-{
- return fc_alignof (FcPattern) + fc_alignof (FcPatternElt) +
- FcValueListNeededBytesAlign ();
-}
-
-static FcBool
-FcPatternEnsureBank (int bi)
+FcBool
+FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat)
{
- FcPattern **pp;
- FcPatternElt **ep;
- int i;
-
- if (!_fcPatterns || fcpattern_bank_count <= bi)
- {
- int new_count = bi + 4;
- pp = realloc (_fcPatterns, sizeof (FcPattern *) * new_count);
- if (!pp)
- return 0;
-
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern *) * new_count);
- _fcPatterns = pp;
-
- ep = realloc (_fcPatternElts, sizeof (FcPatternElt *) * new_count);
- if (!ep)
- return 0;
-
- FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt *) * new_count);
- _fcPatternElts = ep;
-
- for (i = fcpattern_bank_count; i < new_count; i++)
- {
- _fcPatterns[i] = 0;
- _fcPatternElts[i] = 0;
- }
-
- fcpattern_bank_count = new_count;
- }
-
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * fcpattern_count);
+ int i;
+ FcPatternElt *elts = FcPatternElts(pat);
+
+ if (!FcSerializeAlloc (serialize, pat, sizeof (FcPattern)))
+ return FcFalse;
+ if (!FcSerializeAlloc (serialize, elts, pat->num * sizeof (FcPatternElt)))
+ return FcFalse;
+ for (i = 0; i < pat->num; i++)
+ if (!FcValueListSerializeAlloc (serialize, FcPatternEltValues(elts+i)))
+ return FcFalse;
return FcTrue;
}
-void *
-FcPatternDistributeBytes (FcCache * metadata, void * block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
-
- if (!FcPatternEnsureBank(bi))
- return 0;
-
- fcpattern_ptr = 0;
- block_ptr = ALIGN(block_ptr, FcPattern);
- _fcPatterns[bi] = (FcPattern *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcPattern) * fcpattern_count));
-
- FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
- fcpatternelt_ptr = 0;
- block_ptr = ALIGN(block_ptr, FcPatternElt);
- _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcPatternElt) * fcpatternelt_count));
-
- metadata->pattern_count = fcpattern_count;
- metadata->patternelt_count = fcpatternelt_count;
-
- block_ptr = FcStrDistributeBytes (metadata, block_ptr);
- block_ptr = FcValueListDistributeBytes (metadata, block_ptr);
- return block_ptr;
-}
-
FcPattern *
-FcPatternSerialize (int bank, FcPattern *old)
+FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat)
{
- FcPattern *p;
- FcPatternElt *e, *nep;
- FcValueList * nv;
- FcValueListPtr v, nv_head, nvp;
- int i, elts, bi = FcCacheBankToIndex(bank);
-
- p = &_fcPatterns[bi][fcpattern_ptr++];
- p->bank = bank;
- elts = fcpatternelt_ptr;
- nep = &_fcPatternElts[bi][elts];
- if (!nep)
- return FcFalse;
+ FcPattern *pat_serialized;
+ FcPatternElt *elts = FcPatternElts (pat);
+ FcPatternElt *elts_serialized;
+ FcValueList *values_serialized;
+ int i;
- fcpatternelt_ptr += old->num;
+ pat_serialized = FcSerializePtr (serialize, pat);
+ if (!pat_serialized)
+ return NULL;
+ *pat_serialized = *pat;
+ pat_serialized->size = pat->num;
+ pat_serialized->ref = FC_REF_CONSTANT;
+
+ elts_serialized = FcSerializePtr (serialize, elts);
+ if (!elts_serialized)
+ return NULL;
+
+ pat_serialized->elts_offset = FcPtrToOffset (pat_serialized,
+ elts_serialized);
- for (e = FcPatternEltU(old->elts), i=0; i < old->num; i++, e++)
+ for (i = 0; i < pat->num; i++)
{
- v = e->values;
- nvp = nv_head = FcValueListSerialize(bank, FcValueListPtrU(v));
- if (!FcValueListPtrU(nv_head))
- return 0;
- nv = FcValueListPtrU(nvp);
-
- for (;
- FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next,
- nv = FcValueListPtrU(nv->next))
- {
-
- if (FcValueListPtrU(FcValueListPtrU(v)->next))
- {
- nvp = FcValueListSerialize
- (bank, FcValueListPtrU(FcValueListPtrU(v)->next));
- nv->next = nvp;
- }
- }
-
- nep[i].values = nv_head;
- nep[i].object = e->object;
+ values_serialized = FcValueListSerialize (serialize, FcPatternEltValues (elts+i));
+ if (!values_serialized)
+ return NULL;
+ elts_serialized[i].object = elts[i].object;
+ elts_serialized[i].values = FcPtrToEncodedOffset (&elts_serialized[i],
+ values_serialized,
+ FcValueList);
}
-
- p->elts = old->elts;
- p->elts = FcPatternEltPtrCreateStatic(bank, elts);
- p->size = old->num;
- p->num = old->num;
- p->ref = FC_REF_CONSTANT;
- return p;
-}
-
-void *
-FcPatternUnserialize (FcCache * metadata, void *block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcPatternEnsureBank(bi))
- return FcFalse;
-
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * metadata->pattern_count);
- block_ptr = ALIGN(block_ptr, FcPattern);
- _fcPatterns[bi] = (FcPattern *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcPattern) * metadata->pattern_count));
-
- FcMemAlloc (FC_MEM_PATELT,
- sizeof (FcPatternElt) * metadata->patternelt_count);
- block_ptr = ALIGN(block_ptr, FcPatternElt);
- _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcPatternElt) * metadata->patternelt_count));
-
- block_ptr = FcStrUnserialize (metadata, block_ptr);
- block_ptr = FcValueListUnserialize (metadata, block_ptr);
-
- return block_ptr;
-}
-
-static void
-FcValueListNewBank (void)
-{
- fcvaluelist_count = 0;
-
- FcCharSetNewBank();
- FcLangSetNewBank();
+ return pat_serialized;
}
-static int
-FcValueListNeededBytes (FcValueList *p)
+FcBool
+FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
{
- FcValueList *vl;
- int cum = 0;
-
- for (vl = p;
- vl;
- vl = FcValueListPtrU(vl->next))
+ while (vl)
{
- /* unserialize just in case */
- FcValue v = FcValueCanonicalize(&vl->value);
-
- switch (v.type)
- {
+ if (!FcSerializeAlloc (serialize, vl, sizeof (FcValueList)))
+ return FcFalse;
+ switch (vl->value.type) {
+ case FcTypeString:
+ if (!FcStrSerializeAlloc (serialize, vl->value.u.s))
+ return FcFalse;
+ break;
case FcTypeCharSet:
- cum += FcCharSetNeededBytes(v.u.c);
+ if (!FcCharSetSerializeAlloc (serialize, vl->value.u.c))
+ return FcFalse;
break;
case FcTypeLangSet:
- cum += FcLangSetNeededBytes(v.u.l);
+ if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
+ return FcFalse;
break;
- case FcTypeString:
- cum += FcStrNeededBytes(v.u.s);
default:
break;
}
- fcvaluelist_count++;
- cum += sizeof (FcValueList);
- }
-
- return cum;
-}
-
-static int
-FcValueListNeededBytesAlign (void)
-{
- return FcCharSetNeededBytesAlign() + FcLangSetNeededBytesAlign() +
- FcStrNeededBytesAlign() + fc_alignof (FcValueList);
-}
-
-static FcBool
-FcValueListEnsureBank (int bi)
-{
- FcValueList **pvl;
-
- if (!_fcValueLists || fcvaluelist_bank_count <= bi)
- {
- int new_count = bi + 2, i;
-
- pvl = realloc (_fcValueLists, sizeof (FcValueList *) * new_count);
- if (!pvl)
- return FcFalse;
-
- FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList *) * new_count);
-
- _fcValueLists = pvl;
- for (i = fcvaluelist_bank_count; i < new_count; i++)
- _fcValueLists[i] = 0;
-
- fcvaluelist_bank_count = new_count;
+ vl = vl->next;
}
return FcTrue;
}
-static void *
-FcValueListDistributeBytes (FcCache * metadata, void *block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
-
- if (!FcValueListEnsureBank(bi))
- return 0;
-
- FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList) * fcvaluelist_count);
- fcvaluelist_ptr = 0;
- block_ptr = ALIGN(block_ptr, FcValueList);
- _fcValueLists[bi] = (FcValueList *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcValueList) * fcvaluelist_count));
- metadata->valuelist_count = fcvaluelist_count;
-
- block_ptr = FcCharSetDistributeBytes(metadata, block_ptr);
- block_ptr = FcLangSetDistributeBytes(metadata, block_ptr);
-
- return block_ptr;
-}
-
-static FcValueListPtr
-FcValueListSerialize(int bank, FcValueList *pi)
-{
- FcValueListPtr new;
- FcValue * v;
- int bi = FcCacheBankToIndex(bank);
-
- if (!pi)
- {
- new.bank = FC_BANK_DYNAMIC;
- new.u.dyn = 0;
- return new;
- }
-
- _fcValueLists[bi][fcvaluelist_ptr] = *pi;
- new.bank = bank;
- new.u.stat = fcvaluelist_ptr++;
- _fcValueLists[bi][new.u.stat].value = FcValueCanonicalize (&pi->value);
- v = &_fcValueLists[bi][new.u.stat].value;
- switch (v->type)
- {
- case FcTypeString:
- if (v->u.s)
- {
- const FcChar8 * s = FcStrSerialize(bank, v->u.s);
- if (!s)
- return FcValueListPtrCreateDynamic(pi);
- v->u.s_off = s - (const FcChar8 *)v;
- v->type |= FC_STORAGE_STATIC;
- }
- break;
- case FcTypeMatrix:
- break;
- case FcTypeCharSet:
- if (v->u.c)
- {
- FcCharSet * c = FcCharSetSerialize(bank, (FcCharSet *)v->u.c);
- if (!c)
- return FcValueListPtrCreateDynamic(pi);
- v->u.c_off = (char *)c - (char *)v;
- v->type |= FC_STORAGE_STATIC;
- }
- break;
- case FcTypeLangSet:
- if (v->u.l)
- {
- FcLangSet * l = FcLangSetSerialize(bank, (FcLangSet *)v->u.l);
- if (!l)
- return FcValueListPtrCreateDynamic(pi);
- v->u.l_off = (char *)l - (char *)v;
- v->type |= FC_STORAGE_STATIC;
- }
- break;
- default:
- break;
- }
- return new;
-}
-
-static void *
-FcValueListUnserialize (FcCache * metadata, void *block_ptr)
+FcValueList *
+FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
{
- int bi = FcCacheBankToIndex(metadata->bank);
-
- if (!FcValueListEnsureBank(bi))
- return 0;
-
- FcMemAlloc (FC_MEM_VALLIST,
- sizeof (FcValueList) * metadata->valuelist_count);
- block_ptr = ALIGN(block_ptr, FcValueList);
- _fcValueLists[bi] = (FcValueList *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (FcValueList) * metadata->valuelist_count));
-
- block_ptr = FcCharSetUnserialize(metadata, block_ptr);
- block_ptr = FcLangSetUnserialize(metadata, block_ptr);
-
- return block_ptr;
-}
-
-FcValueListPtr
-FcValueListPtrCreateDynamic(FcValueList * p)
-{
- FcValueListPtr r;
-
- r.bank = FC_BANK_DYNAMIC;
- r.u.dyn = p;
- return r;
-}
-
-static FcChar8 ** static_strs;
-static int static_str_bank_count = 0, fcstr_ptr, fcstr_count;
-
-static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE];
-
-static void
-FcStrNewBank (void)
-{
- int i, size;
- struct objectBucket *b, *next;
- char *name;
-
- for (i = 0; i < OBJECT_HASH_SIZE; i++)
- {
- for (b = FcStrBuckets[i]; b; b = next)
- {
- next = b->next;
- name = (char *) (b + 1);
- size = sizeof (struct objectBucket) + strlen (name) + 1;
- FcMemFree (FC_MEM_STATICSTR, size);
- free (b);
+ FcValueList *vl_serialized;
+ FcChar8 *s_serialized;
+ FcCharSet *c_serialized;
+ FcLangSet *l_serialized;
+ FcValueList *head_serialized = NULL;
+ FcValueList *prev_serialized = NULL;
+
+ while (vl)
+ {
+ vl_serialized = FcSerializePtr (serialize, vl);
+ if (!vl_serialized)
+ return NULL;
+
+ if (prev_serialized)
+ prev_serialized->next = FcPtrToEncodedOffset (prev_serialized,
+ vl_serialized,
+ FcValueList);
+ else
+ head_serialized = vl_serialized;
+
+ vl_serialized->next = NULL;
+ vl_serialized->value = vl->value;
+ switch (vl->value.type) {
+ case FcTypeString:
+ s_serialized = FcStrSerialize (serialize, vl->value.u.s);
+ if (!s_serialized)
+ return NULL;
+ vl_serialized->value.u.s = FcPtrToEncodedOffset (&vl_serialized->value,
+ s_serialized,
+ FcChar8);
+ break;
+ case FcTypeCharSet:
+ c_serialized = FcCharSetSerialize (serialize, vl->value.u.c);
+ if (!c_serialized)
+ return NULL;
+ vl_serialized->value.u.c = FcPtrToEncodedOffset (&vl_serialized->value,
+ c_serialized,
+ FcCharSet);
+ break;
+ case FcTypeLangSet:
+ l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
+ if (!l_serialized)
+ return NULL;
+ vl_serialized->value.u.l = FcPtrToEncodedOffset (&vl_serialized->value,
+ l_serialized,
+ FcLangSet);
+ break;
+ default:
+ break;
}
- FcStrBuckets[i] = 0;
+ vl = vl->next;
}
-
- fcstr_count = 0;
-}
-
-static int
-FcStrNeededBytes (const FcChar8 * s)
-{
- FcChar32 hash = FcStringHash ((const FcChar8 *) s);
- struct objectBucket **p;
- struct objectBucket *b;
- int size;
- FcChar8 *const null = 0;
-
- for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
- if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
- return 0;
- size = sizeof (struct objectBucket) + strlen ((char *)s) + 1 + sizeof(char *);
- b = malloc (size);
- FcMemAlloc (FC_MEM_STATICSTR, size);
- if (!b)
- return -1;
- b->next = 0;
- b->hash = hash;
- strcpy ((char *) (b + 1), (char *)s);
-
- /* Yes, the following line is convoluted. However, it is
- * incorrect to replace the with a memset, because the C
- * specification doesn't guarantee that the null pointer is
- * the same as the zero bit pattern. */
- /* Misaligned pointers are not guaranteed to work, either! */
- memcpy (((char *) (b + 1) + strlen((char *)s) + 1), &null, sizeof (null));
- *p = b;
-
- fcstr_count += strlen((char *)s) + 1;
- return strlen((char *)s) + 1;
-}
-
-static int
-FcStrNeededBytesAlign (void)
-{
- return fc_alignof (char);
-}
-
-static FcBool
-FcStrEnsureBank (int bi)
-{
- FcChar8 ** ss;
-
- if (!static_strs || static_str_bank_count <= bi)
- {
- int new_count = bi + 4, i;
- ss = realloc (static_strs, sizeof (const char *) * new_count);
- if (!ss)
- return FcFalse;
-
- FcMemAlloc (FC_MEM_STRING, sizeof (const char *) * (new_count-static_str_bank_count));
- static_strs = ss;
-
- for (i = static_str_bank_count; i < new_count; i++)
- static_strs[i] = 0;
- static_str_bank_count = new_count;
- }
- return FcTrue;
-}
-
-static void *
-FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcStrEnsureBank(bi))
- return 0;
-
- FcMemAlloc (FC_MEM_STRING, sizeof (char) * fcstr_count);
- block_ptr = ALIGN (block_ptr, FcChar8);
- static_strs[bi] = (FcChar8 *)block_ptr;
- block_ptr = (void *)((char *)block_ptr + (sizeof (char) * fcstr_count));
- metadata->str_count = fcstr_count;
- fcstr_ptr = 0;
-
- return block_ptr;
-}
-
-static const FcChar8 *
-FcStrSerialize (int bank, const FcChar8 * s)
-{
- FcChar32 hash = FcStringHash ((const FcChar8 *) s);
- struct objectBucket **p;
- struct objectBucket *b;
- int bi = FcCacheBankToIndex(bank);
-
- for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
- if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
- {
- FcChar8 * t;
- memcpy (&t, ((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1, sizeof (FcChar8 *));
- if (!t)
- {
- strcpy((char *)(static_strs[bi] + fcstr_ptr), (char *)s);
- t = static_strs[bi] + fcstr_ptr;
- memcpy ((FcChar8 *) (b + 1) + strlen((char *)s) + 1, &t, sizeof (FcChar8 *));
- fcstr_ptr += strlen((char *)s) + 1;
- memcpy (&t, ((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1, sizeof (FcChar8 *));
- }
- return t;
- }
- return 0;
-}
-
-static void *
-FcStrUnserialize (FcCache * metadata, void *block_ptr)
-{
- int bi = FcCacheBankToIndex(metadata->bank);
- if (!FcStrEnsureBank(bi))
- return 0;
-
- FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata->str_count);
- block_ptr = ALIGN (block_ptr, FcChar8);
- static_strs[bi] = (FcChar8 *)block_ptr;
- block_ptr = (void *)((char *)block_ptr +
- (sizeof (char) * metadata->str_count));
-
- return block_ptr;
+ return head_serialized;
}
diff --git a/src/fcstr.c b/src/fcstr.c
index 37bad6b..b83a709 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -1052,3 +1052,4 @@ FcStrListDone (FcStrList *list)
FcMemFree (FC_MEM_STRLIST, sizeof (FcStrList));
free (list);
}
+
diff --git a/src/fcxml.c b/src/fcxml.c
index c5c9065..608f834 100644
--- a/src/fcxml.c
+++ b/src/fcxml.c
@@ -65,7 +65,6 @@ FcTestDestroy (FcTest *test)
if (test->next)
FcTestDestroy (test->next);
FcExprDestroy (test->expr);
- FcStrFree ((FcChar8 *) test->field);
FcMemFree (FC_MEM_TEST, sizeof (FcTest));
free (test);
}
@@ -162,7 +161,7 @@ FcExprCreateField (const char *field)
{
FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
e->op = FcOpField;
- e->u.field = (char *) FcStrCopy ((FcChar8 *) field);
+ e->u.object = FcObjectFromName (field);
}
return e;
}
@@ -218,7 +217,6 @@ FcExprDestroy (FcExpr *e)
case FcOpBool:
break;
case FcOpField:
- FcStrFree ((FcChar8 *) e->u.field);
break;
case FcOpConst:
FcStrFree (e->u.constant);
@@ -269,7 +267,6 @@ FcEditDestroy (FcEdit *e)
{
if (e->next)
FcEditDestroy (e->next);
- FcStrFree ((FcChar8 *) e->field);
if (e->expr)
FcExprDestroy (e->expr);
free (e);
@@ -579,7 +576,7 @@ FcTypecheckExpr (FcConfigParse *parse, F
case FcOpNil:
break;
case FcOpField:
- o = FcNameGetObjectType (expr->u.field);
+ o = FcNameGetObjectType (FcObjectName (expr->u.object));
if (o)
FcTypecheckValue (parse, o->type, type);
break;
@@ -659,10 +656,10 @@ FcTestCreate (FcConfigParse *parse,
test->next = 0;
test->kind = kind;
test->qual = qual;
- test->field = (char *) FcStrCopy (field);
+ test->object = FcObjectFromName ((const char *) field);
test->op = compare;
test->expr = expr;
- o = FcNameGetObjectType (test->field);
+ o = FcNameGetObjectType (FcObjectName (test->object));
if (o)
FcTypecheckExpr (parse, expr, o->type);
}
@@ -683,11 +680,11 @@ FcEditCreate (FcConfigParse *parse,
const FcObjectType *o;
e->next = 0;
- e->field = field; /* already saved in grammar */
+ e->object = FcObjectFromName (field);
e->op = op;
e->expr = expr;
e->binding = binding;
- o = FcNameGetObjectType (e->field);
+ o = FcNameGetObjectType (FcObjectName (e->object));
if (o)
FcTypecheckExpr (parse, expr, o->type);
}
_______________________________________________
Fontconfig mailing list
Fontconfig@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/fontconfig
