2 * $XFree86: xc/lib/fontconfig/src/fccharset.c,v 1.18 2002/08/22 07:36:44 keithp Exp $
4 * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of Keith Packard not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. Keith Packard makes no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
16 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
33 FcCharSetCreate (void)
37 fcs
= (FcCharSet
*) malloc (sizeof (FcCharSet
));
40 FcMemAlloc (FC_MEM_CHARSET
, sizeof (FcCharSet
));
54 return FcCharSetCreate ();
59 FcCharSetDestroy (FcCharSet
*fcs
)
62 if (fcs
->ref
== FC_REF_CONSTANT
)
66 for (i
= 0; i
< fcs
->num
; i
++)
68 FcMemFree (FC_MEM_CHARLEAF
, sizeof (FcCharLeaf
));
69 free (fcs
->leaves
[i
]);
73 FcMemFree (FC_MEM_CHARSET
, fcs
->num
* sizeof (FcCharLeaf
*));
78 FcMemFree (FC_MEM_CHARSET
, fcs
->num
* sizeof (FcChar16
));
81 FcMemFree (FC_MEM_CHARSET
, sizeof (FcCharSet
));
86 * Locate the leaf containing the specified char, return
87 * its index if it exists, otherwise return negative of
88 * the (position + 1) where it should be inserted
92 FcCharSetFindLeafPos (const FcCharSet
*fcs
, FcChar32 ucs4
)
94 FcChar16
*numbers
= fcs
->numbers
;
97 int high
= fcs
->num
- 1;
104 int mid
= (low
+ high
) >> 1;
113 if (high
< 0 || (high
< fcs
->num
&& numbers
[high
] < ucs4
))
119 FcCharSetFindLeaf (const FcCharSet
*fcs
, FcChar32 ucs4
)
121 int pos
= FcCharSetFindLeafPos (fcs
, ucs4
);
123 return fcs
->leaves
[pos
];
128 FcCharSetPutLeaf (FcCharSet
*fcs
,
140 leaves
= malloc (sizeof (FcCharLeaf
*));
142 leaves
= realloc (fcs
->leaves
, (fcs
->num
+ 1) * sizeof (FcCharLeaf
*));
146 FcMemFree (FC_MEM_CHARSET
, fcs
->num
* sizeof (FcCharLeaf
*));
147 FcMemAlloc (FC_MEM_CHARSET
, (fcs
->num
+ 1) * sizeof (FcCharLeaf
*));
148 fcs
->leaves
= leaves
;
150 numbers
= malloc (sizeof (FcChar16
));
152 numbers
= realloc (fcs
->numbers
, (fcs
->num
+ 1) * sizeof (FcChar16
));
156 FcMemFree (FC_MEM_CHARSET
, fcs
->num
* sizeof (FcChar16
));
157 FcMemAlloc (FC_MEM_CHARSET
, (fcs
->num
+ 1) * sizeof (FcChar16
));
158 fcs
->numbers
= numbers
;
160 memmove (fcs
->leaves
+ pos
+ 1, fcs
->leaves
+ pos
,
161 (fcs
->num
- pos
) * sizeof (FcCharLeaf
*));
162 memmove (fcs
->numbers
+ pos
+ 1, fcs
->numbers
+ pos
,
163 (fcs
->num
- pos
) * sizeof (FcChar16
));
164 fcs
->numbers
[pos
] = (FcChar16
) ucs4
;
165 fcs
->leaves
[pos
] = leaf
;
171 * Locate the leaf containing the specified char, creating it
176 FcCharSetFindLeafCreate (FcCharSet
*fcs
, FcChar32 ucs4
)
181 pos
= FcCharSetFindLeafPos (fcs
, ucs4
);
183 return fcs
->leaves
[pos
];
185 leaf
= calloc (1, sizeof (FcCharLeaf
));
190 if (!FcCharSetPutLeaf (fcs
, ucs4
, leaf
, pos
))
195 FcMemAlloc (FC_MEM_CHARLEAF
, sizeof (FcCharLeaf
));
200 FcCharSetInsertLeaf (FcCharSet
*fcs
, FcChar32 ucs4
, FcCharLeaf
*leaf
)
204 pos
= FcCharSetFindLeafPos (fcs
, ucs4
);
207 FcMemFree (FC_MEM_CHARLEAF
, sizeof (FcCharLeaf
));
208 free (fcs
->leaves
[pos
]);
209 fcs
->leaves
[pos
] = leaf
;
213 return FcCharSetPutLeaf (fcs
, ucs4
, leaf
, pos
);
217 FcCharSetAddChar (FcCharSet
*fcs
, FcChar32 ucs4
)
222 if (fcs
->ref
== FC_REF_CONSTANT
)
224 leaf
= FcCharSetFindLeafCreate (fcs
, ucs4
);
227 b
= &leaf
->map
[(ucs4
& 0xff) >> 5];
228 *b
|= (1 << (ucs4
& 0x1f));
233 * An iterator for the leaves of a charset
236 typedef struct _fcCharSetIter
{
243 * Set iter->leaf to the leaf containing iter->ucs4 or higher
247 FcCharSetIterSet (const FcCharSet
*fcs
, FcCharSetIter
*iter
)
249 int pos
= FcCharSetFindLeafPos (fcs
, iter
->ucs4
);
260 iter
->ucs4
= (FcChar32
) fcs
->numbers
[pos
] << 8;
262 iter
->leaf
= fcs
->leaves
[pos
];
265 printf ("set %08x: %08x\n", iter
->ucs4
, (FcChar32
) iter
->leaf
);
270 FcCharSetIterNext (const FcCharSet
*fcs
, FcCharSetIter
*iter
)
272 int pos
= iter
->pos
+ 1;
280 iter
->ucs4
= (FcChar32
) fcs
->numbers
[pos
] << 8;
281 iter
->leaf
= fcs
->leaves
[pos
];
288 FcCharSetDump (const FcCharSet
*fcs
)
292 printf ("fcs %08x:\n", (FcChar32
) fcs
);
293 for (pos
= 0; pos
< fcs
->num
; pos
++)
295 FcCharLeaf
*leaf
= fcs
->leaves
[pos
];
296 FcChar32 ucs4
= (FcChar32
) fcs
->numbers
[pos
] << 8;
298 printf (" %08x: %08x\n", ucs4
, (FcChar32
) leaf
);
304 FcCharSetIterStart (const FcCharSet
*fcs
, FcCharSetIter
*iter
)
310 FcCharSetIterSet (fcs
, iter
);
314 FcCharSetCopy (FcCharSet
*src
)
316 if (src
->ref
!= FC_REF_CONSTANT
)
322 FcCharSetEqual (const FcCharSet
*a
, const FcCharSet
*b
)
324 FcCharSetIter ai
, bi
;
329 for (FcCharSetIterStart (a
, &ai
), FcCharSetIterStart (b
, &bi
);
331 FcCharSetIterNext (a
, &ai
), FcCharSetIterNext (b
, &bi
))
333 if (ai
.ucs4
!= bi
.ucs4
)
335 for (i
= 0; i
< 256/32; i
++)
336 if (ai
.leaf
->map
[i
] != bi
.leaf
->map
[i
])
339 return ai
.leaf
== bi
.leaf
;
343 FcCharSetAddLeaf (FcCharSet
*fcs
,
347 FcCharLeaf
*new = FcCharSetFindLeafCreate (fcs
, ucs4
);
355 FcCharSetOperate (const FcCharSet
*a
,
357 FcBool (*overlap
) (FcCharLeaf
*result
,
358 const FcCharLeaf
*al
,
359 const FcCharLeaf
*bl
),
364 FcCharSetIter ai
, bi
;
366 fcs
= FcCharSetCreate ();
369 FcCharSetIterStart (a
, &ai
);
370 FcCharSetIterStart (b
, &bi
);
371 while ((ai
.leaf
|| (bonly
&& bi
.leaf
)) && (bi
.leaf
|| (aonly
&& ai
.leaf
)))
373 if (ai
.ucs4
< bi
.ucs4
)
377 if (!FcCharSetAddLeaf (fcs
, ai
.ucs4
, ai
.leaf
))
379 FcCharSetIterNext (a
, &ai
);
384 FcCharSetIterSet (a
, &ai
);
387 else if (bi
.ucs4
< ai
.ucs4
)
391 if (!FcCharSetAddLeaf (fcs
, bi
.ucs4
, bi
.leaf
))
393 FcCharSetIterNext (b
, &bi
);
398 FcCharSetIterSet (b
, &bi
);
405 if ((*overlap
) (&leaf
, ai
.leaf
, bi
.leaf
))
407 if (!FcCharSetAddLeaf (fcs
, ai
.ucs4
, &leaf
))
410 FcCharSetIterNext (a
, &ai
);
411 FcCharSetIterNext (b
, &bi
);
416 FcCharSetDestroy (fcs
);
422 FcCharSetIntersectLeaf (FcCharLeaf
*result
,
423 const FcCharLeaf
*al
,
424 const FcCharLeaf
*bl
)
427 FcBool nonempty
= FcFalse
;
429 for (i
= 0; i
< 256/32; i
++)
430 if ((result
->map
[i
] = al
->map
[i
] & bl
->map
[i
]))
436 FcCharSetIntersect (const FcCharSet
*a
, const FcCharSet
*b
)
438 return FcCharSetOperate (a
, b
, FcCharSetIntersectLeaf
, FcFalse
, FcFalse
);
442 FcCharSetUnionLeaf (FcCharLeaf
*result
,
443 const FcCharLeaf
*al
,
444 const FcCharLeaf
*bl
)
448 for (i
= 0; i
< 256/32; i
++)
449 result
->map
[i
] = al
->map
[i
] | bl
->map
[i
];
454 FcCharSetUnion (const FcCharSet
*a
, const FcCharSet
*b
)
456 return FcCharSetOperate (a
, b
, FcCharSetUnionLeaf
, FcTrue
, FcTrue
);
460 FcCharSetSubtractLeaf (FcCharLeaf
*result
,
461 const FcCharLeaf
*al
,
462 const FcCharLeaf
*bl
)
465 FcBool nonempty
= FcFalse
;
467 for (i
= 0; i
< 256/32; i
++)
468 if ((result
->map
[i
] = al
->map
[i
] & ~bl
->map
[i
]))
474 FcCharSetSubtract (const FcCharSet
*a
, const FcCharSet
*b
)
476 return FcCharSetOperate (a
, b
, FcCharSetSubtractLeaf
, FcTrue
, FcFalse
);
480 FcCharSetHasChar (const FcCharSet
*fcs
, FcChar32 ucs4
)
482 FcCharLeaf
*leaf
= FcCharSetFindLeaf (fcs
, ucs4
);
485 return (leaf
->map
[(ucs4
& 0xff) >> 5] & (1 << (ucs4
& 0x1f))) != 0;
489 FcCharSetPopCount (FcChar32 c1
)
492 FcChar32 c2
= (c1
>> 1) & 033333333333;
493 c2
= c1
- c2
- ((c2
>> 1) & 033333333333);
494 return (((c2
+ (c2
>> 3)) & 030707070707) % 077);
498 FcCharSetIntersectCount (const FcCharSet
*a
, const FcCharSet
*b
)
500 FcCharSetIter ai
, bi
;
503 FcCharSetIterStart (a
, &ai
);
504 FcCharSetIterStart (b
, &bi
);
505 while (ai
.leaf
&& bi
.leaf
)
507 if (ai
.ucs4
== bi
.ucs4
)
509 FcChar32
*am
= ai
.leaf
->map
;
510 FcChar32
*bm
= bi
.leaf
->map
;
513 count
+= FcCharSetPopCount (*am
++ & *bm
++);
514 FcCharSetIterNext (a
, &ai
);
516 else if (ai
.ucs4
< bi
.ucs4
)
519 FcCharSetIterSet (a
, &ai
);
521 if (bi
.ucs4
< ai
.ucs4
)
524 FcCharSetIterSet (b
, &bi
);
531 FcCharSetCount (const FcCharSet
*a
)
536 for (FcCharSetIterStart (a
, &ai
); ai
.leaf
; FcCharSetIterNext (a
, &ai
))
539 FcChar32
*am
= ai
.leaf
->map
;
542 count
+= FcCharSetPopCount (*am
++);
548 FcCharSetSubtractCount (const FcCharSet
*a
, const FcCharSet
*b
)
550 FcCharSetIter ai
, bi
;
553 FcCharSetIterStart (a
, &ai
);
554 FcCharSetIterStart (b
, &bi
);
557 if (ai
.ucs4
<= bi
.ucs4
)
559 FcChar32
*am
= ai
.leaf
->map
;
561 if (ai
.ucs4
== bi
.ucs4
)
563 FcChar32
*bm
= bi
.leaf
->map
;;
565 count
+= FcCharSetPopCount (*am
++ & ~*bm
++);
570 count
+= FcCharSetPopCount (*am
++);
572 FcCharSetIterNext (a
, &ai
);
577 FcCharSetIterSet (b
, &bi
);
584 * return FcTrue iff a is a subset of b
587 FcCharSetIsSubset (const FcCharSet
*a
, const FcCharSet
*b
)
592 if (a
== b
) return FcTrue
;
595 while (ai
< a
->num
&& bi
< b
->num
)
601 FcChar32
*am
= a
->leaves
[ai
]->map
;
602 FcChar32
*bm
= b
->leaves
[bi
]->map
;
619 int high
= b
->num
- 1;
623 int mid
= (low
+ high
) >> 1;
624 bn
= b
->numbers
[mid
];
636 while (bi
< b
->num
&& b
->numbers
[bi
] < an
)
644 * These two functions efficiently walk the entire charmap for
645 * other software (like pango) that want their own copy
649 FcCharSetNextPage (const FcCharSet
*a
,
650 FcChar32 map
[FC_CHARSET_MAP_SIZE
],
657 FcCharSetIterSet (a
, &ai
);
659 return FC_CHARSET_DONE
;
662 * Save current information
665 memcpy (map
, ai
.leaf
->map
, sizeof (ai
.leaf
->map
));
669 FcCharSetIterNext (a
, &ai
);
676 FcCharSetFirstPage (const FcCharSet
*a
,
677 FcChar32 map
[FC_CHARSET_MAP_SIZE
],
681 return FcCharSetNextPage (a
, map
, next
);
685 * old coverage API, rather hard to use correctly
688 FcCharSetCoverage (const FcCharSet
*a
, FcChar32 page
, FcChar32
*result
);
691 FcCharSetCoverage (const FcCharSet
*a
, FcChar32 page
, FcChar32
*result
)
696 FcCharSetIterSet (a
, &ai
);
699 memset (result
, '\0', 256 / 8);
704 memcpy (result
, ai
.leaf
->map
, sizeof (ai
.leaf
->map
));
705 FcCharSetIterNext (a
, &ai
);
712 * ASCII representation of charsets.
714 * Each leaf is represented as 9 32-bit values, the code of the first character followed
715 * by 8 32 bit values for the leaf itself. Each value is encoded as 5 ASCII characters,
716 * only 85 different values are used to avoid control characters as well as the other
717 * characters used to encode font names. 85**5 > 2^32 so things work out, but
718 * it's not exactly human readable output. As a special case, 0 is encoded as a space
721 static const unsigned char charToValue
[256] = {
722 /* "" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
723 /* "\b" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
724 /* "\020" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
725 /* "\030" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
726 /* " " */ 0xff, 0x00, 0xff, 0x01, 0x02, 0x03, 0x04, 0xff,
727 /* "(" */ 0x05, 0x06, 0x07, 0x08, 0xff, 0xff, 0x09, 0x0a,
728 /* "0" */ 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
729 /* "8" */ 0x13, 0x14, 0xff, 0x15, 0x16, 0xff, 0x17, 0x18,
730 /* "@" */ 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
731 /* "H" */ 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
732 /* "P" */ 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
733 /* "X" */ 0x31, 0x32, 0x33, 0x34, 0xff, 0x35, 0x36, 0xff,
734 /* "`" */ 0xff, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d,
735 /* "h" */ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
736 /* "p" */ 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
737 /* "x" */ 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0xff,
738 /* "\200" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
739 /* "\210" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
740 /* "\220" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
741 /* "\230" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
742 /* "\240" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
743 /* "\250" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
744 /* "\260" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
745 /* "\270" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
746 /* "\300" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
747 /* "\310" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
748 /* "\320" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
749 /* "\330" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
750 /* "\340" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
751 /* "\350" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
752 /* "\360" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
753 /* "\370" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
756 static const FcChar8 valueToChar
[0x55] = {
757 /* 0x00 */ '!', '#', '$', '%', '&', '(', ')', '*',
758 /* 0x08 */ '+', '.', '/', '0', '1', '2', '3', '4',
759 /* 0x10 */ '5', '6', '7', '8', '9', ';', '<', '>',
760 /* 0x18 */ '?', '@', 'A', 'B', 'C', 'D', 'E', 'F',
761 /* 0x20 */ 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
762 /* 0x28 */ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
763 /* 0x30 */ 'W', 'X', 'Y', 'Z', '[', ']', '^', 'a',
764 /* 0x38 */ 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
765 /* 0x40 */ 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
766 /* 0x48 */ 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
767 /* 0x50 */ 'z', '{', '|', '}', '~',
771 FcCharSetParseValue (FcChar8
*string
, FcChar32
*value
)
785 for (i
= 0; i
< 5; i
++)
787 if (!(c
= (FcChar32
) (unsigned char) *string
++))
800 FcCharSetUnparseValue (FcStrBuf
*buf
, FcChar32 value
)
805 return FcStrBufChar (buf
, ' ');
810 FcChar8
*s
= string
+ 5;
812 for (i
= 0; i
< 5; i
++)
814 *--s
= valueToChar
[value
% 85];
817 for (i
= 0; i
< 5; i
++)
818 if (!FcStrBufChar (buf
, *s
++))
824 typedef struct _FcCharLeafEnt FcCharLeafEnt
;
826 struct _FcCharLeafEnt
{
832 #define FC_CHAR_LEAF_BLOCK (4096 / sizeof (FcCharLeafEnt))
834 static FcCharLeafEnt
*
835 FcCharLeafEntCreate (void)
837 static FcCharLeafEnt
*block
;
842 block
= malloc (FC_CHAR_LEAF_BLOCK
* sizeof (FcCharLeafEnt
));
845 FcMemAlloc (FC_MEM_CHARLEAF
, FC_CHAR_LEAF_BLOCK
* sizeof (FcCharLeafEnt
));
846 remain
= FC_CHAR_LEAF_BLOCK
;
852 #define FC_CHAR_LEAF_HASH_SIZE 257
855 FcCharLeafHash (FcCharLeaf
*leaf
)
860 for (i
= 0; i
< 256/32; i
++)
861 hash
= ((hash
<< 1) | (hash
>> 31)) ^ leaf
->map
[i
];
865 static int FcCharLeafTotal
;
866 static int FcCharLeafUsed
;
869 FcCharSetFreezeLeaf (FcCharLeaf
*leaf
)
871 static FcCharLeafEnt
*hashTable
[FC_CHAR_LEAF_HASH_SIZE
];
872 FcChar32 hash
= FcCharLeafHash (leaf
);
873 FcCharLeafEnt
**bucket
= &hashTable
[hash
% FC_CHAR_LEAF_HASH_SIZE
];
877 for (ent
= *bucket
; ent
; ent
= ent
->next
)
879 if (ent
->hash
== hash
&& !memcmp (&ent
->leaf
, leaf
, sizeof (FcCharLeaf
)))
883 ent
= FcCharLeafEntCreate();
894 typedef struct _FcCharSetEnt FcCharSetEnt
;
896 struct _FcCharSetEnt
{
902 #define FC_CHAR_SET_HASH_SIZE 67
905 FcCharSetHash (FcCharSet
*fcs
)
912 p
= (FcChar32
*) fcs
->leaves
;
913 for (i
= 0; i
< fcs
->num
* sizeof (FcCharLeaf
*) / sizeof (FcChar32
); i
++)
914 hash
= ((hash
<< 1) | (hash
>> 31)) ^ *p
++;
915 /* hash in numbers */
916 for (i
= 0; i
< fcs
->num
; i
++)
917 hash
= ((hash
<< 1) | (hash
>> 31)) ^ fcs
->numbers
[i
];
921 static int FcCharSetTotal
;
922 static int FcCharSetUsed
;
923 static int FcCharSetTotalEnts
, FcCharSetUsedEnts
;
926 FcCharSetFreezeBase (FcCharSet
*fcs
)
928 static FcCharSetEnt
*hashTable
[FC_CHAR_SET_HASH_SIZE
];
929 FcChar32 hash
= FcCharSetHash (fcs
);
930 FcCharSetEnt
**bucket
= &hashTable
[hash
% FC_CHAR_SET_HASH_SIZE
];
935 FcCharSetTotalEnts
+= fcs
->num
;
936 for (ent
= *bucket
; ent
; ent
= ent
->next
)
938 if (ent
->hash
== hash
&&
939 ent
->set
.num
== fcs
->num
&&
940 !memcmp (ent
->set
.leaves
, fcs
->leaves
,
941 fcs
->num
* sizeof (FcCharLeaf
*)) &&
942 !memcmp (ent
->set
.numbers
, fcs
->numbers
,
943 fcs
->num
* sizeof (FcChar16
)))
949 size
= (sizeof (FcCharSetEnt
) +
950 fcs
->num
* sizeof (FcCharLeaf
*) +
951 fcs
->num
* sizeof (FcChar16
));
955 FcMemAlloc (FC_MEM_CHARSET
, size
);
957 FcCharSetUsedEnts
+= fcs
->num
;
959 ent
->set
.ref
= FC_REF_CONSTANT
;
960 ent
->set
.num
= fcs
->num
;
963 ent
->set
.leaves
= (FcCharLeaf
**) (ent
+ 1);
964 ent
->set
.numbers
= (FcChar16
*) (ent
->set
.leaves
+ fcs
->num
);
965 memcpy (ent
->set
.leaves
, fcs
->leaves
, fcs
->num
* sizeof (FcCharLeaf
*));
966 memcpy (ent
->set
.numbers
, fcs
->numbers
, fcs
->num
* sizeof (FcChar16
));
971 ent
->set
.numbers
= 0;
981 FcCharSetFreeze (FcCharSet
*fcs
)
988 b
= FcCharSetCreate ();
991 for (i
= 0; i
< fcs
->num
; i
++)
993 l
= FcCharSetFreezeLeaf (fcs
->leaves
[i
]);
996 if (!FcCharSetInsertLeaf (b
, fcs
->numbers
[i
] << 8, l
))
999 n
= FcCharSetFreezeBase (b
);
1003 FcMemFree (FC_MEM_CHARSET
, b
->num
* sizeof (FcCharLeaf
*));
1008 FcMemFree (FC_MEM_CHARSET
, b
->num
* sizeof (FcChar16
));
1011 FcMemFree (FC_MEM_CHARSET
, sizeof (FcCharSet
));
1018 FcNameParseCharSet (FcChar8
*string
)
1020 FcCharSet
*c
, *n
= 0;
1027 c
= FcCharSetCreate ();
1032 string
= FcCharSetParseValue (string
, &ucs4
);
1036 for (i
= 0; i
< 256/32; i
++)
1038 string
= FcCharSetParseValue (string
, &temp
.map
[i
]);
1041 bits
|= temp
.map
[i
];
1045 leaf
= FcCharSetFreezeLeaf (&temp
);
1048 if (!FcCharSetInsertLeaf (c
, ucs4
, leaf
))
1053 printf (" %8s %8s %8s %8s\n", "total", "totalmem", "new", "newmem");
1054 printf ("Leaves: %8d %8d %8d %8d\n",
1055 FcCharLeafTotal
, sizeof (FcCharLeaf
) * FcCharLeafTotal
,
1056 FcCharLeafUsed
, sizeof (FcCharLeaf
) * FcCharLeafUsed
);
1057 printf ("Charsets: %8d %8d %8d %8d\n",
1058 FcCharSetTotal
, sizeof (FcCharSet
) * FcCharSetTotal
,
1059 FcCharSetUsed
, sizeof (FcCharSet
) * FcCharSetUsed
);
1060 printf ("Tables: %8d %8d %8d %8d\n",
1061 FcCharSetTotalEnts
, FcCharSetTotalEnts
* (sizeof (FcCharLeaf
*) + sizeof (FcChar16
)),
1062 FcCharSetUsedEnts
, FcCharSetUsedEnts
* (sizeof (FcCharLeaf
*) + sizeof (FcChar16
)));
1063 printf ("Total: %8s %8d %8s %8d\n",
1065 sizeof (FcCharLeaf
) * FcCharLeafTotal
+
1066 sizeof (FcCharSet
) * FcCharSetTotal
+
1067 FcCharSetTotalEnts
* (sizeof (FcCharLeaf
*) + sizeof (FcChar16
)),
1069 sizeof (FcCharLeaf
) * FcCharLeafUsed
+
1070 sizeof (FcCharSet
) * FcCharSetUsed
+
1071 FcCharSetUsedEnts
* (sizeof (FcCharLeaf
*) + sizeof (FcChar16
)));
1073 n
= FcCharSetFreezeBase (c
);
1077 FcMemFree (FC_MEM_CHARSET
, c
->num
* sizeof (FcCharLeaf
*));
1082 FcMemFree (FC_MEM_CHARSET
, c
->num
* sizeof (FcChar16
));
1085 FcMemFree (FC_MEM_CHARSET
, sizeof (FcCharSet
));
1092 FcNameUnparseCharSet (FcStrBuf
*buf
, const FcCharSet
*c
)
1100 for (FcCharSetIterStart (c
, &ci
);
1102 FcCharSetIterNext (c
, &ci
))
1104 if (!FcCharSetUnparseValue (buf
, ci
.ucs4
))
1106 for (i
= 0; i
< 256/32; i
++)
1107 if (!FcCharSetUnparseValue (buf
, ci
.leaf
->map
[i
]))
1114 FcCharSetIter ci
, checki
;
1116 /* null terminate for parser */
1117 FcStrBufChar (buf
, '\0');
1118 /* step back over null for life after test */
1120 check
= FcNameParseCharSet (buf
->buf
+ len
);
1121 FcCharSetIterStart (c
, &ci
);
1122 FcCharSetIterStart (check
, &checki
);
1123 while (ci
.leaf
|| checki
.leaf
)
1125 if (ci
.ucs4
< checki
.ucs4
)
1127 printf ("Missing leaf node at 0x%x\n", ci
.ucs4
);
1128 FcCharSetIterNext (c
, &ci
);
1130 else if (checki
.ucs4
< ci
.ucs4
)
1132 printf ("Extra leaf node at 0x%x\n", checki
.ucs4
);
1133 FcCharSetIterNext (check
, &checki
);
1138 FcChar32
*cm
= ci
.leaf
->map
;
1139 FcChar32
*checkm
= checki
.leaf
->map
;
1141 for (i
= 0; i
< 256; i
+= 32)
1144 printf ("Mismatching sets at 0x%08x: 0x%08x != 0x%08x\n",
1145 ci
.ucs4
+ i
, *cm
, *checkm
);
1149 FcCharSetIterNext (c
, &ci
);
1150 FcCharSetIterNext (check
, &checki
);
1153 if ((missing
= FcCharSetSubtractCount (c
, check
)))
1154 printf ("%d missing in reparsed result\n", missing
);
1155 if ((missing
= FcCharSetSubtractCount (check
, c
)))
1156 printf ("%d extra in reparsed result\n", missing
);
1157 FcCharSetDestroy (check
);
1165 * Figure out whether the available freetype has FT_Get_Next_Char
1168 #if FREETYPE_MAJOR > 2
1169 # define HAS_NEXT_CHAR
1171 # if FREETYPE_MAJOR == 2
1172 # if FREETYPE_MINOR > 0
1173 # define HAS_NEXT_CHAR
1175 # if FREETYPE_MINOR == 0
1176 # if FREETYPE_PATCH >= 9
1177 # define HAS_NEXT_CHAR
1185 * For our purposes, this approximation is sufficient
1187 #ifndef HAS_NEXT_CHAR
1188 #define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
1189 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
1191 (*(gi) = 1), (ucs4) + 1)
1192 #warning "No FT_Get_Next_Char"
1195 typedef struct _FcCharEnt
{
1197 unsigned char encode
;
1201 const FcCharEnt
*ent
;
1205 typedef struct _FcFontDecode
{
1206 FT_Encoding encoding
;
1207 const FcCharMap
*map
;
1211 static const FcCharEnt AppleRomanEnt
[] = {
1212 { 0x0020, 0x20 }, /* SPACE */
1213 { 0x0021, 0x21 }, /* EXCLAMATION MARK */
1214 { 0x0022, 0x22 }, /* QUOTATION MARK */
1215 { 0x0023, 0x23 }, /* NUMBER SIGN */
1216 { 0x0024, 0x24 }, /* DOLLAR SIGN */
1217 { 0x0025, 0x25 }, /* PERCENT SIGN */
1218 { 0x0026, 0x26 }, /* AMPERSAND */
1219 { 0x0027, 0x27 }, /* APOSTROPHE */
1220 { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
1221 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
1222 { 0x002A, 0x2A }, /* ASTERISK */
1223 { 0x002B, 0x2B }, /* PLUS SIGN */
1224 { 0x002C, 0x2C }, /* COMMA */
1225 { 0x002D, 0x2D }, /* HYPHEN-MINUS */
1226 { 0x002E, 0x2E }, /* FULL STOP */
1227 { 0x002F, 0x2F }, /* SOLIDUS */
1228 { 0x0030, 0x30 }, /* DIGIT ZERO */
1229 { 0x0031, 0x31 }, /* DIGIT ONE */
1230 { 0x0032, 0x32 }, /* DIGIT TWO */
1231 { 0x0033, 0x33 }, /* DIGIT THREE */
1232 { 0x0034, 0x34 }, /* DIGIT FOUR */
1233 { 0x0035, 0x35 }, /* DIGIT FIVE */
1234 { 0x0036, 0x36 }, /* DIGIT SIX */
1235 { 0x0037, 0x37 }, /* DIGIT SEVEN */
1236 { 0x0038, 0x38 }, /* DIGIT EIGHT */
1237 { 0x0039, 0x39 }, /* DIGIT NINE */
1238 { 0x003A, 0x3A }, /* COLON */
1239 { 0x003B, 0x3B }, /* SEMICOLON */
1240 { 0x003C, 0x3C }, /* LESS-THAN SIGN */
1241 { 0x003D, 0x3D }, /* EQUALS SIGN */
1242 { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
1243 { 0x003F, 0x3F }, /* QUESTION MARK */
1244 { 0x0040, 0x40 }, /* COMMERCIAL AT */
1245 { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
1246 { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
1247 { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
1248 { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
1249 { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
1250 { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
1251 { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
1252 { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
1253 { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
1254 { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
1255 { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
1256 { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
1257 { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
1258 { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
1259 { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
1260 { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
1261 { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
1262 { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
1263 { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
1264 { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
1265 { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
1266 { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
1267 { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
1268 { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
1269 { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
1270 { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
1271 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
1272 { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
1273 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
1274 { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
1275 { 0x005F, 0x5F }, /* LOW LINE */
1276 { 0x0060, 0x60 }, /* GRAVE ACCENT */
1277 { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
1278 { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
1279 { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
1280 { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
1281 { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
1282 { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
1283 { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
1284 { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
1285 { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
1286 { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
1287 { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
1288 { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
1289 { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
1290 { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
1291 { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
1292 { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
1293 { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
1294 { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
1295 { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
1296 { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
1297 { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
1298 { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
1299 { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
1300 { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
1301 { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
1302 { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
1303 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
1304 { 0x007C, 0x7C }, /* VERTICAL LINE */
1305 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
1306 { 0x007E, 0x7E }, /* TILDE */
1307 { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
1308 { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
1309 { 0x00A2, 0xA2 }, /* CENT SIGN */
1310 { 0x00A3, 0xA3 }, /* POUND SIGN */
1311 { 0x00A5, 0xB4 }, /* YEN SIGN */
1312 { 0x00A7, 0xA4 }, /* SECTION SIGN */
1313 { 0x00A8, 0xAC }, /* DIAERESIS */
1314 { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
1315 { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
1316 { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
1317 { 0x00AC, 0xC2 }, /* NOT SIGN */
1318 { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
1319 { 0x00AF, 0xF8 }, /* MACRON */
1320 { 0x00B0, 0xA1 }, /* DEGREE SIGN */
1321 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
1322 { 0x00B4, 0xAB }, /* ACUTE ACCENT */
1323 { 0x00B5, 0xB5 }, /* MICRO SIGN */
1324 { 0x00B6, 0xA6 }, /* PILCROW SIGN */
1325 { 0x00B7, 0xE1 }, /* MIDDLE DOT */
1326 { 0x00B8, 0xFC }, /* CEDILLA */
1327 { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
1328 { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
1329 { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
1330 { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
1331 { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
1332 { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
1333 { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
1334 { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
1335 { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
1336 { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
1337 { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
1338 { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
1339 { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
1340 { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
1341 { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
1342 { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
1343 { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
1344 { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
1345 { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
1346 { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
1347 { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
1348 { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
1349 { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
1350 { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
1351 { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
1352 { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
1353 { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
1354 { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
1355 { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
1356 { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
1357 { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
1358 { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
1359 { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
1360 { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
1361 { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
1362 { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
1363 { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
1364 { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
1365 { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
1366 { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
1367 { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
1368 { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
1369 { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
1370 { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
1371 { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
1372 { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
1373 { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
1374 { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
1375 { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
1376 { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
1377 { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
1378 { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
1379 { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
1380 { 0x00F7, 0xD6 }, /* DIVISION SIGN */
1381 { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
1382 { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
1383 { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
1384 { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
1385 { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
1386 { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
1387 { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
1388 { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
1389 { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
1390 { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
1391 { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
1392 { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
1393 { 0x02C7, 0xFF }, /* CARON */
1394 { 0x02D8, 0xF9 }, /* BREVE */
1395 { 0x02D9, 0xFA }, /* DOT ABOVE */
1396 { 0x02DA, 0xFB }, /* RING ABOVE */
1397 { 0x02DB, 0xFE }, /* OGONEK */
1398 { 0x02DC, 0xF7 }, /* SMALL TILDE */
1399 { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
1400 { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
1401 { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
1402 { 0x2013, 0xD0 }, /* EN DASH */
1403 { 0x2014, 0xD1 }, /* EM DASH */
1404 { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
1405 { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
1406 { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
1407 { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
1408 { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
1409 { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
1410 { 0x2020, 0xA0 }, /* DAGGER */
1411 { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
1412 { 0x2022, 0xA5 }, /* BULLET */
1413 { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
1414 { 0x2030, 0xE4 }, /* PER MILLE SIGN */
1415 { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
1416 { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
1417 { 0x2044, 0xDA }, /* FRACTION SLASH */
1418 { 0x20AC, 0xDB }, /* EURO SIGN */
1419 { 0x2122, 0xAA }, /* TRADE MARK SIGN */
1420 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
1421 { 0x2206, 0xC6 }, /* INCREMENT */
1422 { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
1423 { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
1424 { 0x221A, 0xC3 }, /* SQUARE ROOT */
1425 { 0x221E, 0xB0 }, /* INFINITY */
1426 { 0x222B, 0xBA }, /* INTEGRAL */
1427 { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
1428 { 0x2260, 0xAD }, /* NOT EQUAL TO */
1429 { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
1430 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
1431 { 0x25CA, 0xD7 }, /* LOZENGE */
1432 { 0xF8FF, 0xF0 }, /* Apple logo */
1433 { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
1434 { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
1437 static const FcCharMap AppleRoman
= {
1439 sizeof (AppleRomanEnt
) / sizeof (AppleRomanEnt
[0])
1442 static const FcCharEnt AdobeSymbolEnt
[] = {
1443 { 0x0020, 0x20 }, /* SPACE # space */
1444 { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */
1445 { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */
1446 { 0x0025, 0x25 }, /* PERCENT SIGN # percent */
1447 { 0x0026, 0x26 }, /* AMPERSAND # ampersand */
1448 { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */
1449 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */
1450 { 0x002B, 0x2B }, /* PLUS SIGN # plus */
1451 { 0x002C, 0x2C }, /* COMMA # comma */
1452 { 0x002E, 0x2E }, /* FULL STOP # period */
1453 { 0x002F, 0x2F }, /* SOLIDUS # slash */
1454 { 0x0030, 0x30 }, /* DIGIT ZERO # zero */
1455 { 0x0031, 0x31 }, /* DIGIT ONE # one */
1456 { 0x0032, 0x32 }, /* DIGIT TWO # two */
1457 { 0x0033, 0x33 }, /* DIGIT THREE # three */
1458 { 0x0034, 0x34 }, /* DIGIT FOUR # four */
1459 { 0x0035, 0x35 }, /* DIGIT FIVE # five */
1460 { 0x0036, 0x36 }, /* DIGIT SIX # six */
1461 { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */
1462 { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */
1463 { 0x0039, 0x39 }, /* DIGIT NINE # nine */
1464 { 0x003A, 0x3A }, /* COLON # colon */
1465 { 0x003B, 0x3B }, /* SEMICOLON # semicolon */
1466 { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
1467 { 0x003D, 0x3D }, /* EQUALS SIGN # equal */
1468 { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */
1469 { 0x003F, 0x3F }, /* QUESTION MARK # question */
1470 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */
1471 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */
1472 { 0x005F, 0x5F }, /* LOW LINE # underscore */
1473 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */
1474 { 0x007C, 0x7C }, /* VERTICAL LINE # bar */
1475 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */
1476 { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
1477 { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */
1478 { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */
1479 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */
1480 { 0x00B5, 0x6D }, /* MICRO SIGN # mu */
1481 { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */
1482 { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */
1483 { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
1484 { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */
1485 { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */
1486 { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */
1487 { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */
1488 { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */
1489 { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */
1490 { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */
1491 { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */
1492 { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */
1493 { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */
1494 { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */
1495 { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */
1496 { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */
1497 { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */
1498 { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */
1499 { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */
1500 { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */
1501 { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */
1502 { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */
1503 { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */
1504 { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */
1505 { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */
1506 { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */
1507 { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */
1508 { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */
1509 { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */
1510 { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */
1511 { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */
1512 { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */
1513 { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */
1514 { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
1515 { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */
1516 { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */
1517 { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */
1518 { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */
1519 { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */
1520 { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */
1521 { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */
1522 { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */
1523 { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */
1524 { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
1525 { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
1526 { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */
1527 { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
1528 { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */
1529 { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
1530 { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
1531 { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
1532 { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */
1533 { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */
1534 { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
1535 { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */
1536 { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */
1537 { 0x2022, 0xB7 }, /* BULLET # bullet */
1538 { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */
1539 { 0x2032, 0xA2 }, /* PRIME # minute */
1540 { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */
1541 { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
1542 { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */
1543 { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
1544 { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */
1545 { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
1546 { 0x2126, 0x57 }, /* OHM SIGN # Omega */
1547 { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */
1548 { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */
1549 { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */
1550 { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */
1551 { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */
1552 { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */
1553 { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */
1554 { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
1555 { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */
1556 { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */
1557 { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
1558 { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */
1559 { 0x2200, 0x22 }, /* FOR ALL # universal */
1560 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */
1561 { 0x2203, 0x24 }, /* THERE EXISTS # existential */
1562 { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */
1563 { 0x2206, 0x44 }, /* INCREMENT # Delta */
1564 { 0x2207, 0xD1 }, /* NABLA # gradient */
1565 { 0x2208, 0xCE }, /* ELEMENT OF # element */
1566 { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */
1567 { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */
1568 { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */
1569 { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */
1570 { 0x2212, 0x2D }, /* MINUS SIGN # minus */
1571 { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
1572 { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */
1573 { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */
1574 { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */
1575 { 0x221E, 0xA5 }, /* INFINITY # infinity */
1576 { 0x2220, 0xD0 }, /* ANGLE # angle */
1577 { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */
1578 { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */
1579 { 0x2229, 0xC7 }, /* INTERSECTION # intersection */
1580 { 0x222A, 0xC8 }, /* UNION # union */
1581 { 0x222B, 0xF2 }, /* INTEGRAL # integral */
1582 { 0x2234, 0x5C }, /* THEREFORE # therefore */
1583 { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
1584 { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
1585 { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */
1586 { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */
1587 { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */
1588 { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */
1589 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */
1590 { 0x2282, 0xCC }, /* SUBSET OF # propersubset */
1591 { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */
1592 { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */
1593 { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */
1594 { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */
1595 { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */
1596 { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */
1597 { 0x22A5, 0x5E }, /* UP TACK # perpendicular */
1598 { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */
1599 { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */
1600 { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */
1601 { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */
1602 { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */
1603 { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */
1604 { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */
1605 { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */
1606 { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */
1607 { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */
1608 { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */
1609 { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */
1610 { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */
1611 { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */
1612 { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */
1613 { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */
1614 { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */
1615 { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */
1616 { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */
1617 { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
1618 { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */
1619 { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */
1620 { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */
1621 { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */
1622 { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */
1623 { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
1624 { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
1625 { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */
1626 { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
1627 { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */
1628 { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */
1629 { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */
1630 { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */
1631 { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */
1632 { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */
1633 { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */
1634 { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */
1635 { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */
1636 { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */
1639 static const FcCharMap AdobeSymbol
= {
1641 sizeof (AdobeSymbolEnt
) / sizeof (AdobeSymbolEnt
[0]),
1644 static const FcFontDecode fcFontDecoders
[] = {
1645 { ft_encoding_unicode
, 0, (1 << 21) - 1 },
1646 { ft_encoding_symbol
, &AdobeSymbol
, (1 << 16) - 1 },
1647 { ft_encoding_apple_roman
, &AppleRoman
, (1 << 16) - 1 },
1650 #define NUM_DECODE (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
1653 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4
, const FcCharMap
*map
)
1659 high
= map
->nent
- 1;
1660 if (ucs4
< map
->ent
[low
].bmp
|| map
->ent
[high
].bmp
< ucs4
)
1664 mid
= (high
+ low
) >> 1;
1665 bmp
= map
->ent
[mid
].bmp
;
1667 return (FT_ULong
) map
->ent
[mid
].encode
;
1677 FcFreeTypePrivateToUcs4 (FcChar32
private, const FcCharMap
*map
)
1681 for (i
= 0; i
< map
->nent
; i
++)
1682 if (map
->ent
[i
].encode
== private)
1683 return (FcChar32
) map
->ent
[i
].bmp
;
1688 FcFreeTypeGetPrivateMap (FT_Encoding encoding
)
1692 for (i
= 0; i
< NUM_DECODE
; i
++)
1693 if (fcFontDecoders
[i
].encoding
== encoding
)
1694 return fcFontDecoders
[i
].map
;
1699 * Map a UCS4 glyph to a glyph index. Use all available encoding
1700 * tables to try and find one that works. This information is expected
1701 * to be cached by higher levels, so performance isn't critical
1705 FcFreeTypeCharIndex (FT_Face face
, FcChar32 ucs4
)
1707 int initial
, offset
, decode
;
1713 * Find the current encoding
1717 for (; initial
< NUM_DECODE
; initial
++)
1718 if (fcFontDecoders
[initial
].encoding
== face
->charmap
->encoding
)
1720 if (initial
== NUM_DECODE
)
1724 * Check each encoding for the glyph, starting with the current one
1726 for (offset
= 0; offset
< NUM_DECODE
; offset
++)
1728 decode
= (initial
+ offset
) % NUM_DECODE
;
1729 if (!face
->charmap
|| face
->charmap
->encoding
!= fcFontDecoders
[decode
].encoding
)
1730 if (FT_Select_Charmap (face
, fcFontDecoders
[decode
].encoding
) != 0)
1732 if (fcFontDecoders
[decode
].map
)
1734 charcode
= FcFreeTypeUcs4ToPrivate (ucs4
, fcFontDecoders
[decode
].map
);
1740 glyphindex
= FT_Get_Char_Index (face
, (FT_ULong
) charcode
);
1748 FcFreeTypeCheckGlyph (FT_Face face
, FcChar32 ucs4
,
1749 FT_UInt glyph
, FcBlanks
*blanks
)
1751 FT_Int load_flags
= FT_LOAD_NO_SCALE
| FT_LOAD_NO_HINTING
;
1755 * When using scalable fonts, only report those glyphs
1756 * which can be scaled; otherwise those fonts will
1757 * only be available at some sizes, and never when
1758 * transformed. Avoid this by simply reporting bitmap-only
1761 if (face
->face_flags
& FT_FACE_FLAG_SCALABLE
)
1762 load_flags
|= FT_LOAD_NO_BITMAP
;
1764 if (FT_Load_Glyph (face
, glyph
, load_flags
))
1771 switch (slot
->format
) {
1772 case ft_glyph_format_bitmap
:
1774 * Bitmaps are assumed to be reasonable; if
1775 * this proves to be a rash assumption, this
1776 * code can be easily modified
1779 case ft_glyph_format_outline
:
1781 * Glyphs with contours are always OK
1783 if (slot
->outline
.n_contours
!= 0)
1786 * Glyphs with no contours are only OK if
1787 * they're members of the Blanks set specified
1788 * in the configuration. If blanks isn't set,
1789 * then allow any glyph to be blank
1791 if (!blanks
|| FcBlanksIsMember (blanks
, ucs4
))
1793 /* fall through ... */
1801 FcFreeTypeCharSet (FT_Face face
, FcBlanks
*blanks
)
1803 FcChar32 page
, off
, max
, ucs4
;
1805 FcChar32 font_max
= 0;
1809 const FcCharMap
*map
;
1814 fcs
= FcCharSetCreate ();
1818 for (o
= 0; o
< NUM_DECODE
; o
++)
1820 if (FT_Select_Charmap (face
, fcFontDecoders
[o
].encoding
) != 0)
1822 map
= fcFontDecoders
[o
].map
;
1826 * Non-Unicode tables are easy; there's a list of all possible
1829 for (i
= 0; i
< map
->nent
; i
++)
1831 ucs4
= map
->ent
[i
].bmp
;
1832 glyph
= FT_Get_Char_Index (face
, map
->ent
[i
].encode
);
1833 if (glyph
&& FcFreeTypeCheckGlyph (face
, ucs4
, glyph
, blanks
))
1835 leaf
= FcCharSetFindLeafCreate (fcs
, ucs4
);
1838 leaf
->map
[(ucs4
& 0xff) >> 5] |= (1 << (ucs4
& 0x1f));
1840 if (ucs4
> font_max
)
1850 max
= fcFontDecoders
[o
].max
;
1852 * Find the first encoded character in the font
1854 if (FT_Get_Char_Index (face
, 0))
1861 ucs4
= FT_Get_Next_Char (face
, 0, &gindex
);
1870 while ((ucs4
>> 8) == page
)
1872 glyph
= FT_Get_Char_Index (face
, ucs4
);
1873 if (glyph
&& FcFreeTypeCheckGlyph (face
, ucs4
,
1878 leaf
= FcCharSetFindLeafCreate (fcs
, ucs4
);
1883 leaf
->map
[off
>> 5] |= (1 << (off
& 0x1f));
1885 if (ucs4
> font_max
)
1891 ucs4
= FT_Get_Next_Char (face
, ucs4
- 1, &gindex
);
1896 for (ucs4
= 0; ucs4
< 0x10000; ucs4
++)
1898 FcBool FT_Has
, FC_Has
;
1900 FT_Has
= FT_Get_Char_Index (face
, ucs4
) != 0;
1901 FC_Has
= FcCharSetHasChar (fcs
, ucs4
);
1902 if (FT_Has
!= FC_Has
)
1904 printf ("0x%08x FT says %d FC says %d\n", ucs4
, FT_Has
, FC_Has
);
1911 printf ("%d glyphs %d encoded\n", (int) face
->num_glyphs
, FcCharSetCount (fcs
));
1912 for (ucs4
= 0; ucs4
<= font_max
; ucs4
++)
1914 FcBool has_char
= FcFreeTypeCharIndex (face
, ucs4
) != 0;
1915 FcBool has_bit
= FcCharSetHasChar (fcs
, ucs4
);
1917 if (has_char
&& !has_bit
)
1918 printf ("Bitmap missing char 0x%x\n", ucs4
);
1919 else if (!has_char
&& has_bit
)
1920 printf ("Bitmap extra char 0x%x\n", ucs4
);
1925 FcCharSetDestroy (fcs
);