src/fcfreetype.c

   1 /*
   2  * $RCSId: xc/lib/fontconfig/src/fcfreetype.c,v 1.11 2002/08/31 22:17:32 keithp Exp $
   3  *
   4  * Copyright © 2001 Keith Packard
   5  *
   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.
  15  *
  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.
  23  */
  24
  25 /*
  26   Copyright © 2002-2003 by Juliusz Chroboczek
  27
  28   Permission is hereby granted, free of charge, to any person obtaining a copy
  29   of this software and associated documentation files (the "Software"), to deal
  30   in the Software without restriction, including without limitation the rights
  31   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  32   copies of the Software, and to permit persons to whom the Software is
  33   furnished to do so, subject to the following conditions:
  34
  35   The above copyright notice and this permission notice shall be included in
  36   all copies or substantial portions of the Software.
  37
  38   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  39   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  40   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  41   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  42   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  43   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  44   THE SOFTWARE.
  45 */
  46
  47 #include <stdlib.h>
  48 #include <stdio.h>
  49 #include <string.h>
  50 #include "fcint.h"
  51 #include <ft2build.h>
  52 #include FT_FREETYPE_H
  53 #include FT_INTERNAL_OBJECTS_H
  54 #include FT_TRUETYPE_TABLES_H
  55 #include FT_SFNT_NAMES_H
  56 #include FT_TRUETYPE_IDS_H
  57 #include FT_TYPE1_TABLES_H
  58
  59 #if HAVE_FT_GET_BDF_PROPERTY
  60 #include FT_BDF_H
  61 #include FT_MODULE_H
  62 #define HAS_BDF_PROPERTY(f) ((f) && (f)->driver && \
  63                              (f)->driver->root.clazz->get_interface)
  64 #define MY_Get_BDF_Property(f,n,p) (HAS_BDF_PROPERTY(f) ? \
  65                                     FT_Get_BDF_Property(f,n,p) : \
  66                                     FT_Err_Invalid_Argument)
  67 #endif
  68
  69 #if !HAVE_FT_GET_BDF_PROPERTY
  70 #warning "No FT_Get_BDF_Property"
  71 #endif
  72
  73 #if !HAVE_FT_GET_PS_FONT_INFO
  74 #warning "No FT_Get_Font_Info"
  75 #endif
  76
  77 /*
  78  * Keep Han languages separated by eliminating languages
  79  * that the codePageRange bits says aren't supported
  80  */
  81
  82 static const struct {
  83     int             bit;
  84     const FcChar8   *lang;
  85 } FcCodePageRange[] = {
  86     { 17,       (const FcChar8 *) "ja" },
  87     { 18,       (const FcChar8 *) "zh-cn" },
  88     { 19,       (const FcChar8 *) "ko" },
  89     { 20,       (const FcChar8 *) "zh-tw" },
  90 };
  91
  92 #define NUM_CODE_PAGE_RANGE (sizeof FcCodePageRange / sizeof FcCodePageRange[0])
  93
  94 FcBool
  95 FcFreeTypeIsExclusiveLang (const FcChar8  *lang)
  96 {
  97     int     i;
  98
  99     for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
 100     {
 101         if (FcLangCompare (lang, FcCodePageRange[i].lang) != FcLangDifferentLang)
 102             return FcTrue;
 103     }
 104     return FcFalse;
 105 }
 106
 107 #define FC_NAME_PRIO_LANG           0x0f00
 108 #define FC_NAME_PRIO_LANG_ENGLISH   0x0200
 109 #define FC_NAME_PRIO_LANG_LATIN     0x0100
 110 #define FC_NAME_PRIO_LANG_NONE      0x0000
 111
 112 #define FC_NAME_PRIO_ENC            0x00f0
 113 #define FC_NAME_PRIO_ENC_UNICODE    0x0010
 114 #define FC_NAME_PRIO_ENC_NONE       0x0000
 115
 116 #define FC_NAME_PRIO_NAME           0x000f
 117 #define FC_NAME_PRIO_NAME_FAMILY    0x0002
 118 #define FC_NAME_PRIO_NAME_PS        0x0001
 119 #define FC_NAME_PRIO_NAME_NONE      0x0000
 120
 121 static FcBool
 122 FcUcs4IsLatin (FcChar32 ucs4)
 123 {
 124     FcChar32    page = ucs4 >> 8;
 125
 126     if (page <= 2)
 127         return FcTrue;
 128     if (page == 0x1e)
 129         return FcTrue;
 130     if (0x20 <= page && page <= 0x23)
 131         return FcTrue;
 132     if (page == 0xfb)
 133         return FcTrue;
 134     /* halfwidth forms, don't include kana or white parens */
 135     if (0xff01 <= ucs4 && ucs4 <= 0xff5e)
 136         return FcTrue;
 137     return FcFalse;
 138 }
 139
 140 static FcBool
 141 FcUtf8IsLatin (FcChar8 *str, int len)
 142 {
 143     while (len)
 144     {
 145         FcChar32    ucs4;
 146         int         clen = FcUtf8ToUcs4 (str, &ucs4, len);
 147         if (clen <= 0)
 148             return FcFalse;
 149         if (!FcUcs4IsLatin (ucs4))
 150             return FcFalse;
 151         len -= clen;
 152         str += clen;
 153     }
 154     return FcTrue;
 155 }
 156
 157 /* Order is significant.  For example, some B&H fonts are hinted by
 158    URW++, and both strings appear in the notice. */
 159
 160 static const struct {
 161     const FcChar8   *notice;
 162     const FcChar8   *foundry;
 163 } FcNoticeFoundries[] = {
 164     { (const FcChar8*) "Bigelow",       (const FcChar8 *) "b&h" },
 165     { (const FcChar8*) "Adobe",         (const FcChar8 *) "adobe" },
 166     { (const FcChar8*) "Bitstream",     (const FcChar8 *) "bitstream" },
 167     { (const FcChar8*) "Monotype",      (const FcChar8 *) "monotype" },
 168     { (const FcChar8*) "Linotype",      (const FcChar8 *) "linotype" },
 169     { (const FcChar8*) "LINOTYPE-HELL", (const FcChar8 *) "linotype" },
 170     { (const FcChar8*) "IBM",           (const FcChar8 *) "ibm" },
 171     { (const FcChar8*) "URW",           (const FcChar8 *) "urw" },
 172     { (const FcChar8*) "International Typeface Corporation",
 173                                         (const FcChar8 *) "itc" },
 174     { (const FcChar8*) "Tiro Typeworks",(const FcChar8 *) "tiro" },
 175     { (const FcChar8*) "XFree86",       (const FcChar8 *) "xfree86" },
 176     { (const FcChar8*) "Microsoft",     (const FcChar8 *) "microsoft" },
 177     { (const FcChar8*) "Omega",         (const FcChar8 *) "omega" },
 178     { (const FcChar8*) "Font21",        (const FcChar8 *) "hwan" },
 179     { (const FcChar8*) "HanYang System",(const FcChar8 *) "hanyang" }
 180 };
 181
 182 #define NUM_NOTICE_FOUNDRIES    (sizeof (FcNoticeFoundries) / sizeof (FcNoticeFoundries[0]))
 183
 184 static const FcChar8 *
 185 FcNoticeFoundry(const char *notice)
 186 {
 187     int i;
 188
 189     if (notice)
 190         for(i = 0; i < NUM_NOTICE_FOUNDRIES; i++)
 191             if (strstr ((const char *) notice, (const char *) FcNoticeFoundries[i].notice))
 192                 return FcNoticeFoundries[i].foundry;
 193     return 0;
 194 }
 195
 196 static FcBool
 197 FcVendorMatch(const char *vendor, const char *vendor_string)
 198 {
 199     /* vendor is not necessarily NUL-terminated. */
 200     int i, len;
 201
 202     len = strlen(vendor_string);
 203     if (memcmp(vendor, vendor_string, len) != 0)
 204         return FcFalse;
 205     for (i = len; i < 4; i++)
 206         if (vendor[i] != ' ' && vendor[i] != '\0')
 207             return FcFalse;
 208     return FcTrue;
 209 }
 210
 211 /* This table is partly taken from ttmkfdir by Joerg Pommnitz. */
 212
 213 /* It should not contain useless entries (such as UNKN) nor duplicate
 214    entries for padding both with spaces and NULs. */
 215
 216 static const struct {
 217     const FcChar8   *vendor;
 218     const FcChar8   *foundry;
 219 } FcVendorFoundries[] = {
 220     { (const FcChar8*) "ADBE", (const FcChar8 *) "adobe"},
 221     { (const FcChar8*) "AGFA", (const FcChar8 *) "agfa"},
 222     { (const FcChar8*) "ALTS", (const FcChar8 *) "altsys"},
 223     { (const FcChar8*) "APPL", (const FcChar8 *) "apple"},
 224     { (const FcChar8*) "ARPH", (const FcChar8 *) "arphic"},
 225     { (const FcChar8*) "ATEC", (const FcChar8 *) "alltype"},
 226     { (const FcChar8*) "B&H",  (const FcChar8 *) "b&h"},
 227     { (const FcChar8*) "BITS", (const FcChar8 *) "bitstream"},
 228     { (const FcChar8*) "CANO", (const FcChar8 *) "cannon"},
 229     { (const FcChar8*) "DYNA", (const FcChar8 *) "dynalab"},
 230     { (const FcChar8*) "EPSN", (const FcChar8 *) "epson"},
 231     { (const FcChar8*) "FJ",   (const FcChar8 *) "fujitsu"},
 232     { (const FcChar8*) "IBM",  (const FcChar8 *) "ibm"},
 233     { (const FcChar8*) "ITC",  (const FcChar8 *) "itc"},
 234     { (const FcChar8*) "IMPR", (const FcChar8 *) "impress"},
 235     { (const FcChar8*) "LARA", (const FcChar8 *) "larabiefonts"},
 236     { (const FcChar8*) "LEAF", (const FcChar8 *) "interleaf"},
 237     { (const FcChar8*) "LETR", (const FcChar8 *) "letraset"},
 238     { (const FcChar8*) "LINO", (const FcChar8 *) "linotype"},
 239     { (const FcChar8*) "MACR", (const FcChar8 *) "macromedia"},
 240     { (const FcChar8*) "MONO", (const FcChar8 *) "monotype"},
 241     { (const FcChar8*) "MS",   (const FcChar8 *) "microsoft"},
 242     { (const FcChar8*) "MT",   (const FcChar8 *) "monotype"},
 243     { (const FcChar8*) "NEC",  (const FcChar8 *) "nec"},
 244     { (const FcChar8*) "PARA", (const FcChar8 *) "paratype"},
 245     { (const FcChar8*) "QMSI", (const FcChar8 *) "qms"},
 246     { (const FcChar8*) "RICO", (const FcChar8 *) "ricoh"},
 247     { (const FcChar8*) "URW",  (const FcChar8 *) "urw"},
 248     { (const FcChar8*) "Y&Y",  (const FcChar8 *) "y&y"}
 249 };
 250
 251 #define NUM_VENDOR_FOUNDRIES    (sizeof (FcVendorFoundries) / sizeof (FcVendorFoundries[0]))
 252
 253 static const FcChar8 *
 254 FcVendorFoundry(const char *vendor)
 255 {
 256     int i;
 257
 258     if (vendor)
 259         for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++)
 260             if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor))
 261                 return FcVendorFoundries[i].foundry;
 262     return 0;
 263 }
 264
 265 typedef struct _FcStringConst {
 266     const char  *name;
 267     int         value;
 268 } FcStringConst;
 269
 270 static int
 271 FcStringIsConst (const FcChar8          *string,
 272                  const FcStringConst    *c,
 273                  int                    nc)
 274 {
 275     int i;
 276
 277     for (i = 0; i < nc; i++)
 278         if (FcStrCmpIgnoreBlanksAndCase (string, c[i].name) == 0)
 279             return c[i].value;
 280     return -1;
 281 }
 282
 283 static int
 284 FcStringContainsConst (const FcChar8        *string,
 285                        const FcStringConst  *c,
 286                        int                  nc)
 287 {
 288     int i;
 289
 290     for (i = 0; i < nc; i++)
 291         if (FcStrContainsIgnoreBlanksAndCase (string, c[i].name))
 292             return c[i].value;
 293     return -1;
 294 }
 295
 296 static const FcStringConst  weightConsts[] = {
 297     { "thin",           FC_WEIGHT_THIN },
 298     { "extralight",     FC_WEIGHT_EXTRALIGHT },
 299     { "ultralight",     FC_WEIGHT_ULTRALIGHT },
 300     { "light",          FC_WEIGHT_LIGHT },
 301     { "book",           FC_WEIGHT_BOOK },
 302     { "regular",        FC_WEIGHT_REGULAR },
 303     { "normal",         FC_WEIGHT_NORMAL },
 304     { "medium",         FC_WEIGHT_MEDIUM },
 305     { "demibold",       FC_WEIGHT_DEMIBOLD },
 306     { "demi",           FC_WEIGHT_DEMIBOLD },
 307     { "semibold",       FC_WEIGHT_SEMIBOLD },
 308     { "bold",           FC_WEIGHT_BOLD },
 309     { "extrabold",      FC_WEIGHT_EXTRABOLD },
 310     { "ultrabold",      FC_WEIGHT_ULTRABOLD },
 311     { "black",          FC_WEIGHT_BLACK },
 312     { "heavy",          FC_WEIGHT_HEAVY },
 313 };
 314
 315 #define NUM_WEIGHT_CONSTS  (sizeof (weightConsts) / sizeof (weightConsts[0]))
 316
 317 #define FcIsWeight(s)       FcStringIsConst(s,weightConsts,NUM_WEIGHT_CONSTS)
 318 #define FcContainsWeight(s) FcStringContainsConst (s,weightConsts,NUM_WEIGHT_CONSTS)
 319
 320 static const FcStringConst  widthConsts[] = {
 321     { "ultracondensed", FC_WIDTH_ULTRACONDENSED },
 322     { "extracondensed", FC_WIDTH_EXTRACONDENSED },
 323     { "semicondensed",  FC_WIDTH_SEMICONDENSED },
 324     { "condensed",      FC_WIDTH_CONDENSED },   /* must be after *condensed */
 325     { "normal",         FC_WIDTH_NORMAL },
 326     { "semiexpanded",   FC_WIDTH_SEMIEXPANDED },
 327     { "extraexpanded",  FC_WIDTH_EXTRAEXPANDED },
 328     { "ultraexpanded",  FC_WIDTH_ULTRAEXPANDED },
 329     { "expanded",       FC_WIDTH_EXPANDED },    /* must be after *expanded */
 330 };
 331
 332 #define NUM_WIDTH_CONSTS    (sizeof (widthConsts) / sizeof (widthConsts[0]))
 333
 334 #define FcIsWidth(s)        FcStringIsConst(s,widthConsts,NUM_WIDTH_CONSTS)
 335 #define FcContainsWidth(s)  FcStringContainsConst (s,widthConsts,NUM_WIDTH_CONSTS)
 336
 337 static const FcStringConst  slantConsts[] = {
 338     { "italic",         FC_SLANT_ITALIC },
 339     { "oblique",        FC_SLANT_OBLIQUE },
 340 };
 341
 342 #define NUM_SLANT_CONSTS    (sizeof (slantConsts) / sizeof (slantConsts[0]))
 343
 344 #define FcIsSlant(s)        FcStringIsConst(s,slantConsts,NUM_SLANT_CONSTS)
 345 #define FcContainsSlant(s)  FcStringContainsConst (s,slantConsts,NUM_SLANT_CONSTS)
 346
 347 static double
 348 FcGetPixelSize (FT_Face face, int i)
 349 {
 350 #if HAVE_FT_GET_BDF_PROPERTY
 351     if (face->num_fixed_sizes == 1)
 352     {
 353         BDF_PropertyRec prop;
 354         int             rc;
 355
 356         rc = MY_Get_BDF_Property (face, "PIXEL_SIZE", &prop);
 357         if (rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
 358             return (double) prop.u.integer;
 359     }
 360 #endif
 361 #if HAVE_FT_BITMAP_SIZE_Y_PPEM
 362     return (double) face->available_sizes[i].y_ppem / 64.0;
 363 #else
 364     return (double) face->available_sizes[i].height / 64.0;
 365 #endif
 366 }
 367
 368 FcPattern *
 369 FcFreeTypeQuery (const FcChar8  *file,
 370                  int            id,
 371                  FcBlanks       *blanks,
 372                  int            *count)
 373 {
 374     FT_Face         face;
 375     FcPattern       *pat;
 376     int             slant = -1;
 377     int             weight = -1;
 378     int             width = -1;
 379     int             i;
 380     FcCharSet       *cs;
 381     FcLangSet       *ls;
 382     FT_Library      ftLibrary;
 383     FcChar8         *family = 0;
 384     FcChar8         *style = 0;
 385     const FcChar8   *foundry = 0;
 386     int             spacing;
 387     TT_OS2          *os2;
 388 #if HAVE_FT_GET_PS_FONT_INFO
 389     PS_FontInfoRec  psfontinfo;
 390 #endif
 391 #if HAVE_FT_GET_BDF_PROPERTY
 392     BDF_PropertyRec prop;
 393 #endif
 394     TT_Header       *head;
 395     const FcChar8   *exclusiveLang = 0;
 396     FT_SfntName     sname;
 397     FT_UInt         snamei, snamec;
 398     FcBool          family_allocated = FcFalse;
 399     FcBool          style_allocated = FcFalse;
 400     int             family_prio = 0;
 401     int             style_prio = 0;
 402
 403     if (FT_Init_FreeType (&ftLibrary))
 404         return 0;
 405
 406     if (FT_New_Face (ftLibrary, (char *) file, id, &face))
 407         goto bail;
 408
 409     *count = face->num_faces;
 410
 411     pat = FcPatternCreate ();
 412     if (!pat)
 413         goto bail0;
 414
 415     if (!FcPatternAddBool (pat, FC_OUTLINE,
 416                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
 417         goto bail1;
 418
 419     if (!FcPatternAddBool (pat, FC_SCALABLE,
 420                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
 421         goto bail1;
 422
 423
 424     /*
 425      * Get the OS/2 table
 426      */
 427     os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
 428
 429     /*
 430      * Look first in the OS/2 table for the foundry, if
 431      * not found here, the various notices will be searched for
 432      * that information, either from the sfnt name tables or
 433      * the Postscript FontInfo dictionary.  Finally, the
 434      * BDF properties will queried.
 435      */
 436
 437     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
 438         foundry = FcVendorFoundry(os2->achVendID);
 439
 440     /*
 441      * Grub through the name table looking for family
 442      * and style names.  FreeType makes quite a hash
 443      * of them
 444      */
 445     snamec = FT_Get_Sfnt_Name_Count (face);
 446     for (snamei = 0; snamei < snamec; snamei++)
 447     {
 448         FcChar8         *utf8;
 449         int             len;
 450         int             wchar;
 451         FcChar8         *src;
 452         int             src_len;
 453         FcChar8         *u8;
 454         FcChar32        ucs4;
 455         int             ilen, olen;
 456         int             prio = 0;
 457
 458         const FcCharMap *map;
 459         enum {
 460             FcNameEncodingUtf16,
 461             FcNameEncodingAppleRoman,
 462             FcNameEncodingLatin1
 463         } encoding;
 464
 465
 466         if (FT_Get_Sfnt_Name (face, snamei, &sname) != 0)
 467             break;
 468
 469         /*
 470          * Look for Unicode strings
 471          */
 472         switch (sname.platform_id) {
 473         case TT_PLATFORM_APPLE_UNICODE:
 474             /*
 475              * All APPLE_UNICODE encodings are Utf16 BE
 476              *
 477              * Because there's no language id for Unicode,
 478              * assume it's English
 479              */
 480             prio |= FC_NAME_PRIO_LANG_ENGLISH;
 481             prio |= FC_NAME_PRIO_ENC_UNICODE;
 482             encoding = FcNameEncodingUtf16;
 483             break;
 484         case TT_PLATFORM_MACINTOSH:
 485             switch (sname.encoding_id) {
 486             case TT_MAC_ID_ROMAN:
 487                 encoding = FcNameEncodingAppleRoman;
 488                 break;
 489             default:
 490                 continue;
 491             }
 492             switch (sname.language_id) {
 493             case TT_MAC_LANGID_ENGLISH:
 494                 prio |= FC_NAME_PRIO_LANG_ENGLISH;
 495                 break;
 496             default:
 497                 /*
 498                  * Sometimes Microsoft language ids
 499                  * end up in the macintosh table.  This
 500                  * is often accompanied by data in
 501                  * some mystic encoding.  Ignore these names
 502                  */
 503                 if (sname.language_id >= 0x100)
 504                     continue;
 505                 break;
 506             }
 507             break;
 508         case TT_PLATFORM_MICROSOFT:
 509             switch (sname.encoding_id) {
 510             case TT_MS_ID_UNICODE_CS:
 511                 encoding = FcNameEncodingUtf16;
 512                 prio |= FC_NAME_PRIO_ENC_UNICODE;
 513                 break;
 514             default:
 515                 continue;
 516             }
 517             switch (sname.language_id & 0xff) {
 518             case 0x09:
 519                 prio |= FC_NAME_PRIO_LANG_ENGLISH;
 520                 break;
 521             default:
 522                 break;
 523             }
 524             break;
 525         case TT_PLATFORM_ISO:
 526             switch (sname.encoding_id) {
 527             case TT_ISO_ID_10646:
 528                 encoding = FcNameEncodingUtf16;
 529                 prio |= FC_NAME_PRIO_ENC_UNICODE;
 530                 break;
 531             case TT_ISO_ID_7BIT_ASCII:
 532             case TT_ISO_ID_8859_1:
 533                 encoding = FcNameEncodingLatin1;
 534                 break;
 535             default:
 536                 continue;
 537             }
 538             break;
 539         default:
 540             continue;
 541         }
 542
 543         /*
 544          * Look for family and style names
 545          */
 546         switch (sname.name_id) {
 547         case TT_NAME_ID_FONT_FAMILY:
 548             prio |= FC_NAME_PRIO_NAME_FAMILY;
 549             break;
 550         case TT_NAME_ID_PS_NAME:
 551             prio |= FC_NAME_PRIO_NAME_PS;
 552             break;
 553         case TT_NAME_ID_FONT_SUBFAMILY:
 554         case TT_NAME_ID_TRADEMARK:
 555         case TT_NAME_ID_MANUFACTURER:
 556             break;
 557         default:
 558             continue;
 559         }
 560
 561         src = (FcChar8 *) sname.string;
 562         src_len = sname.string_len;
 563
 564         switch (encoding) {
 565         case FcNameEncodingUtf16:
 566             /*
 567              * Convert Utf16 to Utf8
 568              */
 569
 570             if (!FcUtf16Len (src, FcEndianBig, src_len, &len, &wchar))
 571                 continue;
 572
 573             /*
 574              * Allocate plenty of space.  Freed below
 575              */
 576             utf8 = malloc (len * FC_UTF8_MAX_LEN + 1);
 577             if (!utf8)
 578                 continue;
 579
 580             u8 = utf8;
 581
 582             while ((ilen = FcUtf16ToUcs4 (src, FcEndianBig, &ucs4, src_len)) > 0)
 583             {
 584                 src_len -= ilen;
 585                 src += ilen;
 586                 olen = FcUcs4ToUtf8 (ucs4, u8);
 587                 u8 += olen;
 588             }
 589             *u8 = '\0';
 590             break;
 591         case FcNameEncodingLatin1:
 592             /*
 593              * Convert Latin1 to Utf8. Freed below
 594              */
 595             utf8 = malloc (src_len * 2 + 1);
 596             if (!utf8)
 597                 continue;
 598
 599             u8 = utf8;
 600             while (src_len > 0)
 601             {
 602                 ucs4 = *src++;
 603                 src_len--;
 604                 olen = FcUcs4ToUtf8 (ucs4, u8);
 605                 u8 += olen;
 606             }
 607             *u8 = '\0';
 608             break;
 609         case FcNameEncodingAppleRoman:
 610             /*
 611              * Convert AppleRoman to Utf8
 612              */
 613             map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
 614             if (!map)
 615                 continue;
 616
 617             /* freed below */
 618             utf8 = malloc (src_len * 3 + 1);
 619             if (!utf8)
 620                 continue;
 621
 622             u8 = utf8;
 623             while (src_len > 0)
 624             {
 625                 ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
 626                 src_len--;
 627                 olen = FcUcs4ToUtf8 (ucs4, u8);
 628                 u8 += olen;
 629             }
 630             *u8 = '\0';
 631             break;
 632         default:
 633             continue;
 634         }
 635         if ((prio & FC_NAME_PRIO_LANG) == FC_NAME_PRIO_LANG_NONE)
 636             if (FcUtf8IsLatin (utf8, strlen ((char *) utf8)))
 637                 prio |= FC_NAME_PRIO_LANG_LATIN;
 638
 639         if (FcDebug () & FC_DBG_SCANV)
 640             printf ("\nfound name (name %d platform %d encoding %d language 0x%x prio 0x%x) %s\n",
 641                     sname.name_id, sname.platform_id,
 642                     sname.encoding_id, sname.language_id,
 643                     prio, utf8);
 644
 645         switch (sname.name_id) {
 646         case TT_NAME_ID_FONT_FAMILY:
 647         case TT_NAME_ID_PS_NAME:
 648             if (!family || prio > family_prio)
 649             {
 650                 if (family)
 651                     free (family);
 652                 family = utf8;
 653                 utf8 = 0;
 654                 family_allocated = FcTrue;
 655                 family_prio = prio;
 656             }
 657             break;
 658         case TT_NAME_ID_FONT_SUBFAMILY:
 659             if (!style || prio > style_prio)
 660             {
 661                 if (style)
 662                     free (style);
 663                 style = utf8;
 664                 utf8 = 0;
 665                 style_allocated = FcTrue;
 666                 style_prio = prio;
 667             }
 668             break;
 669         case TT_NAME_ID_TRADEMARK:
 670         case TT_NAME_ID_MANUFACTURER:
 671             /* If the foundry wasn't found in the OS/2 table, look here */
 672             if(!foundry)
 673                 foundry = FcNoticeFoundry(utf8);
 674             break;
 675         }
 676         if (utf8)
 677             free (utf8);
 678     }
 679
 680     if (!family)
 681         family = (FcChar8 *) face->family_name;
 682
 683     if (!style)
 684         style = (FcChar8 *) face->style_name;
 685
 686     if (!family)
 687     {
 688         FcChar8 *start, *end;
 689
 690         start = (FcChar8 *) strrchr ((char *) file, '/');
 691         if (start)
 692             start++;
 693         else
 694             start = (FcChar8 *) file;
 695         end = (FcChar8 *) strrchr ((char *) start, '.');
 696         if (!end)
 697             end = start + strlen ((char *) start);
 698         /* freed below */
 699         family = malloc (end - start + 1);
 700         strncpy ((char *) family, (char *) start, end - start);
 701         family[end - start] = '\0';
 702         family_allocated = FcTrue;
 703     }
 704
 705     if (FcDebug() & FC_DBG_SCAN)
 706         printf ("\n\"%s\" \"%s\"\n", family, style ? style : (FcChar8 *) "<none>");
 707
 708     if (!FcPatternAddString (pat, FC_FAMILY, family))
 709         goto bail1;
 710
 711     if (style)
 712     {
 713         if (!FcPatternAddString (pat, FC_STYLE, style))
 714             goto bail1;
 715     }
 716
 717     if (!FcPatternAddString (pat, FC_FILE, file))
 718         goto bail1;
 719
 720     if (!FcPatternAddInteger (pat, FC_INDEX, id))
 721         goto bail1;
 722
 723     if (!FcPatternAddString (pat, FC_SOURCE, (FcChar8 *) "FreeType"))
 724         goto bail1;
 725
 726 #if 0
 727     /*
 728      * don't even try this -- CJK 'monospace' fonts are really
 729      * dual width, and most other fonts don't bother to set
 730      * the attribute.  Sigh.
 731      */
 732     if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
 733         if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
 734             goto bail1;
 735 #endif
 736
 737     /*
 738      * Find the font revision (if available)
 739      */
 740     head = (TT_Header *) FT_Get_Sfnt_Table (face, ft_sfnt_head);
 741     if (head)
 742     {
 743         if (!FcPatternAddInteger (pat, FC_FONTVERSION, head->Font_Revision))
 744             goto bail1;
 745     }
 746     else
 747     {
 748         if (!FcPatternAddInteger (pat, FC_FONTVERSION, 0))
 749             goto bail1;
 750     }
 751
 752     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
 753     {
 754         for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
 755         {
 756             FT_ULong    bits;
 757             int         bit;
 758             if (FcCodePageRange[i].bit < 32)
 759             {
 760                 bits = os2->ulCodePageRange1;
 761                 bit = FcCodePageRange[i].bit;
 762             }
 763             else
 764             {
 765                 bits = os2->ulCodePageRange2;
 766                 bit = FcCodePageRange[i].bit - 32;
 767             }
 768             if (bits & (1 << bit))
 769             {
 770                 /*
 771                  * If the font advertises support for multiple
 772                  * "exclusive" languages, then include support
 773                  * for any language found to have coverage
 774                  */
 775                 if (exclusiveLang)
 776                 {
 777                     exclusiveLang = 0;
 778                     break;
 779                 }
 780                 exclusiveLang = FcCodePageRange[i].lang;
 781             }
 782         }
 783     }
 784
 785     if (os2 && os2->version != 0xffff)
 786     {
 787         if (os2->usWeightClass == 0)
 788             ;
 789         else if (os2->usWeightClass < 150)
 790             weight = FC_WEIGHT_THIN;
 791         else if (os2->usWeightClass < 250)
 792             weight = FC_WEIGHT_EXTRALIGHT;
 793         else if (os2->usWeightClass < 350)
 794             weight = FC_WEIGHT_LIGHT;
 795         else if (os2->usWeightClass < 450)
 796             weight = FC_WEIGHT_REGULAR;
 797         else if (os2->usWeightClass < 550)
 798             weight = FC_WEIGHT_MEDIUM;
 799         else if (os2->usWeightClass < 650)
 800             weight = FC_WEIGHT_SEMIBOLD;
 801         else if (os2->usWeightClass < 750)
 802             weight = FC_WEIGHT_BOLD;
 803         else if (os2->usWeightClass < 850)
 804             weight = FC_WEIGHT_EXTRABOLD;
 805         else if (os2->usWeightClass < 950)
 806             weight = FC_WEIGHT_BLACK;
 807
 808         switch (os2->usWidthClass) {
 809         case 1: width = FC_WIDTH_ULTRACONDENSED; break;
 810         case 2: width = FC_WIDTH_EXTRACONDENSED; break;
 811         case 3: width = FC_WIDTH_CONDENSED; break;
 812         case 4: width = FC_WIDTH_SEMICONDENSED; break;
 813         case 5: width = FC_WIDTH_NORMAL; break;
 814         case 6: width = FC_WIDTH_SEMIEXPANDED; break;
 815         case 7: width = FC_WIDTH_EXPANDED; break;
 816         case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
 817         case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
 818         }
 819     }
 820
 821     /*
 822      * Type 1: Check for FontInfo dictionary information
 823      * Code from g2@magestudios.net (Gerard Escalante)
 824      */
 825
 826 #if HAVE_FT_GET_PS_FONT_INFO
 827     if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
 828     {
 829         if (weight == -1 && psfontinfo.weight)
 830         {
 831             weight = FcIsWeight (psfontinfo.weight);
 832             if (FcDebug() & FC_DBG_SCANV)
 833                 printf ("\tType1 weight %s maps to %d\n",
 834                         psfontinfo.weight, weight);
 835         }
 836
 837 #if 0
 838         /*
 839          * Don't bother with italic_angle; FreeType already extracts that
 840          * information for us and sticks it into style_flags
 841          */
 842         if (psfontinfo.italic_angle)
 843             slant = FC_SLANT_ITALIC;
 844         else
 845             slant = FC_SLANT_ROMAN;
 846 #endif
 847
 848         if(!foundry)
 849             foundry = FcNoticeFoundry(psfontinfo.notice);
 850     }
 851 #endif /* HAVE_FT_GET_PS_FONT_INFO */
 852
 853 #if HAVE_FT_GET_BDF_PROPERTY
 854     /*
 855      * Finally, look for a FOUNDRY BDF property if no other
 856      * mechanism has managed to locate a foundry
 857      */
 858
 859     if (!foundry)
 860     {
 861         int             rc;
 862         BDF_PropertyRec prop;
 863         rc = MY_Get_BDF_Property(face, "FOUNDRY", &prop);
 864         if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM)
 865             foundry = prop.u.atom;
 866     }
 867
 868     if (width == -1)
 869     {
 870         if (MY_Get_BDF_Property(face, "RELATIVE_SETWIDTH", &prop) == 0 &&
 871             (prop.type == BDF_PROPERTY_TYPE_INTEGER ||
 872              prop.type == BDF_PROPERTY_TYPE_CARDINAL))
 873         {
 874             FT_Int32    value;
 875
 876             if (prop.type == BDF_PROPERTY_TYPE_INTEGER)
 877                 value = prop.u.integer;
 878             else
 879                 value = (FT_Int32) prop.u.cardinal;
 880             switch ((value + 5) / 10) {
 881             case 1: width = FC_WIDTH_ULTRACONDENSED; break;
 882             case 2: width = FC_WIDTH_EXTRACONDENSED; break;
 883             case 3: width = FC_WIDTH_CONDENSED; break;
 884             case 4: width = FC_WIDTH_SEMICONDENSED; break;
 885             case 5: width = FC_WIDTH_NORMAL; break;
 886             case 6: width = FC_WIDTH_SEMIEXPANDED; break;
 887             case 7: width = FC_WIDTH_EXPANDED; break;
 888             case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
 889             case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
 890             }
 891         }
 892         if (width == -1 &&
 893             MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
 894             prop.type == BDF_PROPERTY_TYPE_ATOM)
 895         {
 896             width = FcIsWidth (prop.u.atom);
 897             if (FcDebug () & FC_DBG_SCANV)
 898                 printf ("\tsetwidth %s maps to %d\n", prop.u.atom, width);
 899         }
 900     }
 901 #endif
 902
 903     /*
 904      * Look for weight, width and slant names in the style value
 905      */
 906     if (style)
 907     {
 908         if (weight == -1)
 909         {
 910             weight = FcContainsWeight (style);
 911             if (FcDebug() & FC_DBG_SCANV)
 912                 printf ("\tStyle %s maps to weight %d\n", style, weight);
 913         }
 914         if (width == -1)
 915         {
 916             width = FcContainsWidth (style);
 917             if (FcDebug() & FC_DBG_SCANV)
 918                 printf ("\tStyle %s maps to width %d\n", style, width);
 919         }
 920         if (slant == -1)
 921         {
 922             slant = FcContainsSlant (style);
 923             if (FcDebug() & FC_DBG_SCANV)
 924                 printf ("\tStyle %s maps to slant %d\n", style, slant);
 925         }
 926     }
 927     /*
 928      * Pull default values from the FreeType flags if more
 929      * specific values not found above
 930      */
 931     if (slant == -1)
 932     {
 933         slant = FC_SLANT_ROMAN;
 934         if (face->style_flags & FT_STYLE_FLAG_ITALIC)
 935             slant = FC_SLANT_ITALIC;
 936     }
 937
 938     if (weight == -1)
 939     {
 940         weight = FC_WEIGHT_MEDIUM;
 941         if (face->style_flags & FT_STYLE_FLAG_BOLD)
 942             weight = FC_WEIGHT_BOLD;
 943     }
 944
 945     if (!FcPatternAddInteger (pat, FC_SLANT, slant))
 946         goto bail1;
 947
 948     if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
 949         goto bail1;
 950
 951     if (width != -1)
 952         if (!FcPatternAddInteger (pat, FC_WIDTH, width))
 953             goto bail1;
 954
 955     if(foundry)
 956     {
 957         if(!FcPatternAddString (pat, FC_FOUNDRY, foundry))
 958             goto bail1;
 959     }
 960
 961     /*
 962      * Compute the unicode coverage for the font
 963      */
 964     cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
 965     if (!cs)
 966         goto bail1;
 967
 968 #if HAVE_FT_GET_BDF_PROPERTY
 969     /* For PCF fonts, override the computed spacing with the one from
 970        the property */
 971     if(MY_Get_BDF_Property(face, "SPACING", &prop) == 0 &&
 972        prop.type == BDF_PROPERTY_TYPE_ATOM) {
 973         if(!strcmp(prop.u.atom, "c") || !strcmp(prop.u.atom, "C"))
 974             spacing = FC_CHARCELL;
 975         else if(!strcmp(prop.u.atom, "m") || !strcmp(prop.u.atom, "M"))
 976             spacing = FC_MONO;
 977         else if(!strcmp(prop.u.atom, "p") || !strcmp(prop.u.atom, "P"))
 978             spacing = FC_PROPORTIONAL;
 979     }
 980 #endif
 981
 982     /*
 983      * Skip over PCF fonts that have no encoded characters; they're
 984      * usually just Unicode fonts transcoded to some legacy encoding
 985      */
 986     if (FcCharSetCount (cs) == 0)
 987     {
 988         if (!strcmp(FT_MODULE_CLASS(&face->driver->root)->module_name, "pcf"))
 989             goto bail2;
 990     }
 991
 992     if (!FcPatternAddCharSet (pat, FC_CHARSET, cs))
 993         goto bail2;
 994
 995     ls = FcFreeTypeLangSet (cs, exclusiveLang);
 996     if (!ls)
 997         goto bail2;
 998
 999     if (!FcPatternAddLangSet (pat, FC_LANG, ls))
1000     {
1001         FcLangSetDestroy (ls);
1002         goto bail2;
1003     }
1004
1005     FcLangSetDestroy (ls);
1006
1007     if (spacing != FC_PROPORTIONAL)
1008         if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
1009             goto bail2;
1010
1011     if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
1012     {
1013         for (i = 0; i < face->num_fixed_sizes; i++)
1014             if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE,
1015                                      FcGetPixelSize (face, i)))
1016                 goto bail1;
1017         if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
1018             goto bail1;
1019 #if HAVE_FT_GET_BDF_PROPERTY
1020         if(face->num_fixed_sizes == 1) {
1021             int rc;
1022             int value;
1023             BDF_PropertyRec prop;
1024
1025             rc = MY_Get_BDF_Property(face, "POINT_SIZE", &prop);
1026             if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1027                 value = prop.u.integer;
1028             else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1029                 value = prop.u.cardinal;
1030             else
1031                 goto nevermind;
1032             if(!FcPatternAddDouble(pat, FC_SIZE, value / 10.0))
1033                 goto nevermind;
1034
1035             rc = MY_Get_BDF_Property(face, "RESOLUTION_Y", &prop);
1036             if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1037                 value = prop.u.integer;
1038             else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1039                 value = prop.u.cardinal;
1040             else
1041                 goto nevermind;
1042             if(!FcPatternAddDouble(pat, FC_DPI, (double)value))
1043                 goto nevermind;
1044
1045         }
1046     nevermind:
1047         ;
1048 #endif
1049     }
1050
1051     /*
1052      * Drop our reference to the charset
1053      */
1054     FcCharSetDestroy (cs);
1055
1056     /*
1057      * Deallocate family/style values
1058      */
1059
1060     if (family_allocated)
1061         free (family);
1062     if (style_allocated)
1063         free (style);
1064
1065     FT_Done_Face (face);
1066     FT_Done_FreeType (ftLibrary);
1067     return pat;
1068
1069 bail2:
1070     FcCharSetDestroy (cs);
1071 bail1:
1072     FcPatternDestroy (pat);
1073     if (family_allocated)
1074         free (family);
1075     if (style_allocated)
1076         free (style);
1077 bail0:
1078     FT_Done_Face (face);
1079 bail:
1080     FT_Done_FreeType (ftLibrary);
1081     return 0;
1082 }
1083
1084
1085 /*
1086  * For our purposes, this approximation is sufficient
1087  */
1088 #if !HAVE_FT_GET_NEXT_CHAR
1089 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
1090                                           (*(gi) = 0), 0 : \
1091                                           (*(gi) = 1), (ucs4) + 1)
1092 #warning "No FT_Get_Next_Char"
1093 #endif
1094
1095 typedef struct _FcCharEnt {
1096     FcChar16        bmp;
1097     unsigned char   encode;
1098 } FcCharEnt;
1099
1100 struct _FcCharMap {
1101     const FcCharEnt *ent;
1102     int             nent;
1103 };
1104
1105 typedef struct _FcFontDecode {
1106     FT_Encoding     encoding;
1107     const FcCharMap *map;
1108     FcChar32        max;
1109 } FcFontDecode;
1110
1111 static const FcCharEnt AppleRomanEnt[] = {
1112     { 0x0020, 0x20 }, /* SPACE */
1113     { 0x0021, 0x21 }, /* EXCLAMATION MARK */
1114     { 0x0022, 0x22 }, /* QUOTATION MARK */
1115     { 0x0023, 0x23 }, /* NUMBER SIGN */
1116     { 0x0024, 0x24 }, /* DOLLAR SIGN */
1117     { 0x0025, 0x25 }, /* PERCENT SIGN */
1118     { 0x0026, 0x26 }, /* AMPERSAND */
1119     { 0x0027, 0x27 }, /* APOSTROPHE */
1120     { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
1121     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
1122     { 0x002A, 0x2A }, /* ASTERISK */
1123     { 0x002B, 0x2B }, /* PLUS SIGN */
1124     { 0x002C, 0x2C }, /* COMMA */
1125     { 0x002D, 0x2D }, /* HYPHEN-MINUS */
1126     { 0x002E, 0x2E }, /* FULL STOP */
1127     { 0x002F, 0x2F }, /* SOLIDUS */
1128     { 0x0030, 0x30 }, /* DIGIT ZERO */
1129     { 0x0031, 0x31 }, /* DIGIT ONE */
1130     { 0x0032, 0x32 }, /* DIGIT TWO */
1131     { 0x0033, 0x33 }, /* DIGIT THREE */
1132     { 0x0034, 0x34 }, /* DIGIT FOUR */
1133     { 0x0035, 0x35 }, /* DIGIT FIVE */
1134     { 0x0036, 0x36 }, /* DIGIT SIX */
1135     { 0x0037, 0x37 }, /* DIGIT SEVEN */
1136     { 0x0038, 0x38 }, /* DIGIT EIGHT */
1137     { 0x0039, 0x39 }, /* DIGIT NINE */
1138     { 0x003A, 0x3A }, /* COLON */
1139     { 0x003B, 0x3B }, /* SEMICOLON */
1140     { 0x003C, 0x3C }, /* LESS-THAN SIGN */
1141     { 0x003D, 0x3D }, /* EQUALS SIGN */
1142     { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
1143     { 0x003F, 0x3F }, /* QUESTION MARK */
1144     { 0x0040, 0x40 }, /* COMMERCIAL AT */
1145     { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
1146     { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
1147     { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
1148     { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
1149     { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
1150     { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
1151     { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
1152     { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
1153     { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
1154     { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
1155     { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
1156     { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
1157     { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
1158     { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
1159     { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
1160     { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
1161     { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
1162     { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
1163     { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
1164     { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
1165     { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
1166     { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
1167     { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
1168     { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
1169     { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
1170     { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
1171     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
1172     { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
1173     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
1174     { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
1175     { 0x005F, 0x5F }, /* LOW LINE */
1176     { 0x0060, 0x60 }, /* GRAVE ACCENT */
1177     { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
1178     { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
1179     { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
1180     { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
1181     { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
1182     { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
1183     { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
1184     { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
1185     { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
1186     { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
1187     { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
1188     { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
1189     { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
1190     { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
1191     { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
1192     { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
1193     { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
1194     { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
1195     { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
1196     { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
1197     { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
1198     { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
1199     { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
1200     { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
1201     { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
1202     { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
1203     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
1204     { 0x007C, 0x7C }, /* VERTICAL LINE */
1205     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
1206     { 0x007E, 0x7E }, /* TILDE */
1207     { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
1208     { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
1209     { 0x00A2, 0xA2 }, /* CENT SIGN */
1210     { 0x00A3, 0xA3 }, /* POUND SIGN */
1211     { 0x00A5, 0xB4 }, /* YEN SIGN */
1212     { 0x00A7, 0xA4 }, /* SECTION SIGN */
1213     { 0x00A8, 0xAC }, /* DIAERESIS */
1214     { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
1215     { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
1216     { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
1217     { 0x00AC, 0xC2 }, /* NOT SIGN */
1218     { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
1219     { 0x00AF, 0xF8 }, /* MACRON */
1220     { 0x00B0, 0xA1 }, /* DEGREE SIGN */
1221     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
1222     { 0x00B4, 0xAB }, /* ACUTE ACCENT */
1223     { 0x00B5, 0xB5 }, /* MICRO SIGN */
1224     { 0x00B6, 0xA6 }, /* PILCROW SIGN */
1225     { 0x00B7, 0xE1 }, /* MIDDLE DOT */
1226     { 0x00B8, 0xFC }, /* CEDILLA */
1227     { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
1228     { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
1229     { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
1230     { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
1231     { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
1232     { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
1233     { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
1234     { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
1235     { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
1236     { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
1237     { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
1238     { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
1239     { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
1240     { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
1241     { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
1242     { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
1243     { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
1244     { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
1245     { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
1246     { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
1247     { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
1248     { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
1249     { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
1250     { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
1251     { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
1252     { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
1253     { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
1254     { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
1255     { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
1256     { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
1257     { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
1258     { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
1259     { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
1260     { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
1261     { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
1262     { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
1263     { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
1264     { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
1265     { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
1266     { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
1267     { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
1268     { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
1269     { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
1270     { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
1271     { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
1272     { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
1273     { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
1274     { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
1275     { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
1276     { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
1277     { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
1278     { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
1279     { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
1280     { 0x00F7, 0xD6 }, /* DIVISION SIGN */
1281     { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
1282     { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
1283     { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
1284     { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
1285     { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
1286     { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
1287     { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
1288     { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
1289     { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
1290     { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
1291     { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
1292     { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
1293     { 0x02C7, 0xFF }, /* CARON */
1294     { 0x02D8, 0xF9 }, /* BREVE */
1295     { 0x02D9, 0xFA }, /* DOT ABOVE */
1296     { 0x02DA, 0xFB }, /* RING ABOVE */
1297     { 0x02DB, 0xFE }, /* OGONEK */
1298     { 0x02DC, 0xF7 }, /* SMALL TILDE */
1299     { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
1300     { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
1301     { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
1302     { 0x2013, 0xD0 }, /* EN DASH */
1303     { 0x2014, 0xD1 }, /* EM DASH */
1304     { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
1305     { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
1306     { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
1307     { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
1308     { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
1309     { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
1310     { 0x2020, 0xA0 }, /* DAGGER */
1311     { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
1312     { 0x2022, 0xA5 }, /* BULLET */
1313     { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
1314     { 0x2030, 0xE4 }, /* PER MILLE SIGN */
1315     { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
1316     { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
1317     { 0x2044, 0xDA }, /* FRACTION SLASH */
1318     { 0x20AC, 0xDB }, /* EURO SIGN */
1319     { 0x2122, 0xAA }, /* TRADE MARK SIGN */
1320     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
1321     { 0x2206, 0xC6 }, /* INCREMENT */
1322     { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
1323     { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
1324     { 0x221A, 0xC3 }, /* SQUARE ROOT */
1325     { 0x221E, 0xB0 }, /* INFINITY */
1326     { 0x222B, 0xBA }, /* INTEGRAL */
1327     { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
1328     { 0x2260, 0xAD }, /* NOT EQUAL TO */
1329     { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
1330     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
1331     { 0x25CA, 0xD7 }, /* LOZENGE */
1332     { 0xF8FF, 0xF0 }, /* Apple logo */
1333     { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
1334     { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
1335 };
1336
1337 static const FcCharMap AppleRoman = {
1338     AppleRomanEnt,
1339     sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
1340 };
1341
1342 static const FcCharEnt AdobeSymbolEnt[] = {
1343     { 0x0020, 0x20 }, /* SPACE  # space */
1344     { 0x0021, 0x21 }, /* EXCLAMATION MARK       # exclam */
1345     { 0x0023, 0x23 }, /* NUMBER SIGN    # numbersign */
1346     { 0x0025, 0x25 }, /* PERCENT SIGN   # percent */
1347     { 0x0026, 0x26 }, /* AMPERSAND      # ampersand */
1348     { 0x0028, 0x28 }, /* LEFT PARENTHESIS       # parenleft */
1349     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS      # parenright */
1350     { 0x002B, 0x2B }, /* PLUS SIGN      # plus */
1351     { 0x002C, 0x2C }, /* COMMA  # comma */
1352     { 0x002E, 0x2E }, /* FULL STOP      # period */
1353     { 0x002F, 0x2F }, /* SOLIDUS        # slash */
1354     { 0x0030, 0x30 }, /* DIGIT ZERO     # zero */
1355     { 0x0031, 0x31 }, /* DIGIT ONE      # one */
1356     { 0x0032, 0x32 }, /* DIGIT TWO      # two */
1357     { 0x0033, 0x33 }, /* DIGIT THREE    # three */
1358     { 0x0034, 0x34 }, /* DIGIT FOUR     # four */
1359     { 0x0035, 0x35 }, /* DIGIT FIVE     # five */
1360     { 0x0036, 0x36 }, /* DIGIT SIX      # six */
1361     { 0x0037, 0x37 }, /* DIGIT SEVEN    # seven */
1362     { 0x0038, 0x38 }, /* DIGIT EIGHT    # eight */
1363     { 0x0039, 0x39 }, /* DIGIT NINE     # nine */
1364     { 0x003A, 0x3A }, /* COLON  # colon */
1365     { 0x003B, 0x3B }, /* SEMICOLON      # semicolon */
1366     { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
1367     { 0x003D, 0x3D }, /* EQUALS SIGN    # equal */
1368     { 0x003E, 0x3E }, /* GREATER-THAN SIGN      # greater */
1369     { 0x003F, 0x3F }, /* QUESTION MARK  # question */
1370     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET    # bracketleft */
1371     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET   # bracketright */
1372     { 0x005F, 0x5F }, /* LOW LINE       # underscore */
1373     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET     # braceleft */
1374     { 0x007C, 0x7C }, /* VERTICAL LINE  # bar */
1375     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET    # braceright */
1376     { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
1377     { 0x00AC, 0xD8 }, /* NOT SIGN       # logicalnot */
1378     { 0x00B0, 0xB0 }, /* DEGREE SIGN    # degree */
1379     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN        # plusminus */
1380     { 0x00B5, 0x6D }, /* MICRO SIGN     # mu */
1381     { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN    # multiply */
1382     { 0x00F7, 0xB8 }, /* DIVISION SIGN  # divide */
1383     { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
1384     { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA     # Alpha */
1385     { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA      # Beta */
1386     { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA     # Gamma */
1387     { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA     # Delta */
1388     { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON   # Epsilon */
1389     { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA      # Zeta */
1390     { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA       # Eta */
1391     { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA     # Theta */
1392     { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA      # Iota */
1393     { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA     # Kappa */
1394     { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA     # Lambda */
1395     { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU        # Mu */
1396     { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU        # Nu */
1397     { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI        # Xi */
1398     { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON   # Omicron */
1399     { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI        # Pi */
1400     { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO       # Rho */
1401     { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA     # Sigma */
1402     { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU       # Tau */
1403     { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON   # Upsilon */
1404     { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI       # Phi */
1405     { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI       # Chi */
1406     { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI       # Psi */
1407     { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA     # Omega */
1408     { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA       # alpha */
1409     { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA        # beta */
1410     { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA       # gamma */
1411     { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA       # delta */
1412     { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON     # epsilon */
1413     { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA        # zeta */
1414     { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
1415     { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA       # theta */
1416     { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA        # iota */
1417     { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA       # kappa */
1418     { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA       # lambda */
1419     { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU  # mu */
1420     { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU  # nu */
1421     { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI  # xi */
1422     { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON     # omicron */
1423     { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI  # pi */
1424     { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
1425     { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
1426     { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA       # sigma */
1427     { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
1428     { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON     # upsilon */
1429     { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
1430     { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
1431     { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
1432     { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA       # omega */
1433     { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL     # theta1 */
1434     { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
1435     { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL       # phi1 */
1436     { 0x03D6, 0x76 }, /* GREEK PI SYMBOL        # omega1 */
1437     { 0x2022, 0xB7 }, /* BULLET # bullet */
1438     { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS    # ellipsis */
1439     { 0x2032, 0xA2 }, /* PRIME  # minute */
1440     { 0x2033, 0xB2 }, /* DOUBLE PRIME   # second */
1441     { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
1442     { 0x20AC, 0xA0 }, /* EURO SIGN      # Euro */
1443     { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
1444     { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P       # weierstrass */
1445     { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
1446     { 0x2126, 0x57 }, /* OHM SIGN       # Omega */
1447     { 0x2135, 0xC0 }, /* ALEF SYMBOL    # aleph */
1448     { 0x2190, 0xAC }, /* LEFTWARDS ARROW        # arrowleft */
1449     { 0x2191, 0xAD }, /* UPWARDS ARROW  # arrowup */
1450     { 0x2192, 0xAE }, /* RIGHTWARDS ARROW       # arrowright */
1451     { 0x2193, 0xAF }, /* DOWNWARDS ARROW        # arrowdown */
1452     { 0x2194, 0xAB }, /* LEFT RIGHT ARROW       # arrowboth */
1453     { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS  # carriagereturn */
1454     { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
1455     { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW   # arrowdblup */
1456     { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW        # arrowdblright */
1457     { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
1458     { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW        # arrowdblboth */
1459     { 0x2200, 0x22 }, /* FOR ALL        # universal */
1460     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL   # partialdiff */
1461     { 0x2203, 0x24 }, /* THERE EXISTS   # existential */
1462     { 0x2205, 0xC6 }, /* EMPTY SET      # emptyset */
1463     { 0x2206, 0x44 }, /* INCREMENT      # Delta */
1464     { 0x2207, 0xD1 }, /* NABLA  # gradient */
1465     { 0x2208, 0xCE }, /* ELEMENT OF     # element */
1466     { 0x2209, 0xCF }, /* NOT AN ELEMENT OF      # notelement */
1467     { 0x220B, 0x27 }, /* CONTAINS AS MEMBER     # suchthat */
1468     { 0x220F, 0xD5 }, /* N-ARY PRODUCT  # product */
1469     { 0x2211, 0xE5 }, /* N-ARY SUMMATION        # summation */
1470     { 0x2212, 0x2D }, /* MINUS SIGN     # minus */
1471     { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
1472     { 0x2217, 0x2A }, /* ASTERISK OPERATOR      # asteriskmath */
1473     { 0x221A, 0xD6 }, /* SQUARE ROOT    # radical */
1474     { 0x221D, 0xB5 }, /* PROPORTIONAL TO        # proportional */
1475     { 0x221E, 0xA5 }, /* INFINITY       # infinity */
1476     { 0x2220, 0xD0 }, /* ANGLE  # angle */
1477     { 0x2227, 0xD9 }, /* LOGICAL AND    # logicaland */
1478     { 0x2228, 0xDA }, /* LOGICAL OR     # logicalor */
1479     { 0x2229, 0xC7 }, /* INTERSECTION   # intersection */
1480     { 0x222A, 0xC8 }, /* UNION  # union */
1481     { 0x222B, 0xF2 }, /* INTEGRAL       # integral */
1482     { 0x2234, 0x5C }, /* THEREFORE      # therefore */
1483     { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
1484     { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
1485     { 0x2248, 0xBB }, /* ALMOST EQUAL TO        # approxequal */
1486     { 0x2260, 0xB9 }, /* NOT EQUAL TO   # notequal */
1487     { 0x2261, 0xBA }, /* IDENTICAL TO   # equivalence */
1488     { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO  # lessequal */
1489     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO       # greaterequal */
1490     { 0x2282, 0xCC }, /* SUBSET OF      # propersubset */
1491     { 0x2283, 0xC9 }, /* SUPERSET OF    # propersuperset */
1492     { 0x2284, 0xCB }, /* NOT A SUBSET OF        # notsubset */
1493     { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO  # reflexsubset */
1494     { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO        # reflexsuperset */
1495     { 0x2295, 0xC5 }, /* CIRCLED PLUS   # circleplus */
1496     { 0x2297, 0xC4 }, /* CIRCLED TIMES  # circlemultiply */
1497     { 0x22A5, 0x5E }, /* UP TACK        # perpendicular */
1498     { 0x22C5, 0xD7 }, /* DOT OPERATOR   # dotmath */
1499     { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL      # integraltp */
1500     { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL   # integralbt */
1501     { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET    # angleleft */
1502     { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET   # angleright */
1503     { 0x25CA, 0xE0 }, /* LOZENGE        # lozenge */
1504     { 0x2660, 0xAA }, /* BLACK SPADE SUIT       # spade */
1505     { 0x2663, 0xA7 }, /* BLACK CLUB SUIT        # club */
1506     { 0x2665, 0xA9 }, /* BLACK HEART SUIT       # heart */
1507     { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT     # diamond */
1508     { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF   # copyrightserif (CUS) */
1509     { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF  # registerserif (CUS) */
1510     { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF  # trademarkserif (CUS) */
1511     { 0xF8E5, 0x60 }, /* RADICAL EXTENDER       # radicalex (CUS) */
1512     { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER        # arrowvertex (CUS) */
1513     { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER      # arrowhorizex (CUS) */
1514     { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF     # registersans (CUS) */
1515     { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF      # copyrightsans (CUS) */
1516     { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF     # trademarksans (CUS) */
1517     { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
1518     { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER    # parenleftex (CUS) */
1519     { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM      # parenleftbt (CUS) */
1520     { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP        # bracketlefttp (CUS) */
1521     { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER   # bracketleftex (CUS) */
1522     { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM     # bracketleftbt (CUS) */
1523     { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
1524     { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
1525     { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM      # braceleftbt (CUS) */
1526     { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
1527     { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER      # integralex (CUS) */
1528     { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP        # parenrighttp (CUS) */
1529     { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER   # parenrightex (CUS) */
1530     { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM     # parenrightbt (CUS) */
1531     { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP       # bracketrighttp (CUS) */
1532     { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER  # bracketrightex (CUS) */
1533     { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM    # bracketrightbt (CUS) */
1534     { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP        # bracerighttp (CUS) */
1535     { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID        # bracerightmid (CUS) */
1536     { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM     # bracerightbt (CUS) */
1537 };
1538
1539 static const FcCharMap AdobeSymbol = {
1540     AdobeSymbolEnt,
1541     sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
1542 };
1543
1544 static const FcFontDecode fcFontDecoders[] = {
1545     { ft_encoding_unicode,      0,              (1 << 21) - 1 },
1546     { ft_encoding_symbol,       &AdobeSymbol,   (1 << 16) - 1 },
1547     { ft_encoding_apple_roman,  &AppleRoman,    (1 << 16) - 1 },
1548 };
1549
1550 #define NUM_DECODE  (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
1551
1552 FcChar32
1553 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
1554 {
1555     int         low, high, mid;
1556     FcChar16    bmp;
1557
1558     low = 0;
1559     high = map->nent - 1;
1560     if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
1561         return ~0;
1562     while (low <= high)
1563     {
1564         mid = (high + low) >> 1;
1565         bmp = map->ent[mid].bmp;
1566         if (ucs4 == bmp)
1567             return (FT_ULong) map->ent[mid].encode;
1568         if (ucs4 < bmp)
1569             high = mid - 1;
1570         else
1571             low = mid + 1;
1572     }
1573     return ~0;
1574 }
1575
1576 FcChar32
1577 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
1578 {
1579     int     i;
1580
1581     for (i = 0; i < map->nent; i++)
1582         if (map->ent[i].encode == private)
1583             return (FcChar32) map->ent[i].bmp;
1584     return ~0;
1585 }
1586
1587 const FcCharMap *
1588 FcFreeTypeGetPrivateMap (FT_Encoding encoding)
1589 {
1590     int i;
1591
1592     for (i = 0; i < NUM_DECODE; i++)
1593         if (fcFontDecoders[i].encoding == encoding)
1594             return fcFontDecoders[i].map;
1595     return 0;
1596 }
1597
1598 #include "../fc-glyphname/fcglyphname.h"
1599
1600 static FcChar32
1601 FcHashGlyphName (const FcChar8 *name)
1602 {
1603     FcChar32    h = 0;
1604     FcChar8     c;
1605
1606     while ((c = *name++))
1607     {
1608         h = ((h << 1) | (h >> 31)) ^ c;
1609     }
1610     return h;
1611 }
1612
1613 #if HAVE_FT_HAS_PS_GLYPH_NAMES
1614 /*
1615  * Use Type1 glyph names for fonts which have reliable names
1616  * and which export an Adobe Custom mapping
1617  */
1618 static FcBool
1619 FcFreeTypeUseNames (FT_Face face)
1620 {
1621     FT_Int  map;
1622
1623     if (!FT_Has_PS_Glyph_Names (face))
1624         return FcFalse;
1625     for (map = 0; map < face->num_charmaps; map++)
1626         if (face->charmaps[map]->encoding == ft_encoding_adobe_custom)
1627             return FcTrue;
1628     return FcFalse;
1629 }
1630
1631 static FcChar8 *
1632 FcUcs4ToGlyphName (FcChar32 ucs4)
1633 {
1634     int         i = (int) (ucs4 % FC_GLYPHNAME_HASH);
1635     int         r = 0;
1636     FcGlyphName *gn;
1637
1638     while ((gn = ucs_to_name[i]))
1639     {
1640         if (gn->ucs == ucs4)
1641             return gn->name;
1642         if (!r)
1643         {
1644             r = (int) (ucs4 % FC_GLYPHNAME_REHASH);
1645             if (!r)
1646                 r = 1;
1647         }
1648         i += r;
1649         if (i >= FC_GLYPHNAME_HASH)
1650             i -= FC_GLYPHNAME_HASH;
1651     }
1652     return 0;
1653 }
1654
1655 static FcChar32
1656 FcGlyphNameToUcs4 (FcChar8 *name)
1657 {
1658     FcChar32    h = FcHashGlyphName (name);
1659     int         i = (int) (h % FC_GLYPHNAME_HASH);
1660     int         r = 0;
1661     FcGlyphName *gn;
1662
1663     while ((gn = name_to_ucs[i]))
1664     {
1665         if (!strcmp ((char *) name, (char *) gn->name))
1666             return gn->ucs;
1667         if (!r)
1668         {
1669             r = (int) (h % FC_GLYPHNAME_REHASH);
1670             if (!r)
1671                 r = 1;
1672         }
1673         i += r;
1674         if (i >= FC_GLYPHNAME_HASH)
1675             i -= FC_GLYPHNAME_HASH;
1676     }
1677     return 0xffff;
1678 }
1679
1680 /*
1681  * Search through a font for a glyph by name.  This is
1682  * currently a linear search as there doesn't appear to be
1683  * any defined order within the font
1684  */
1685 static FT_UInt
1686 FcFreeTypeGlyphNameIndex (FT_Face face, FcChar8 *name)
1687 {
1688     FT_UInt gindex;
1689     FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
1690
1691     for (gindex = 0; gindex < face->num_glyphs; gindex++)
1692     {
1693         if (FT_Get_Glyph_Name (face, gindex, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
1694             if (!strcmp ((char *) name, (char *) name_buf))
1695                 return gindex;
1696     }
1697     return 0;
1698 }
1699 #endif
1700
1701 /*
1702  * Map a UCS4 glyph to a glyph index.  Use all available encoding
1703  * tables to try and find one that works.  This information is expected
1704  * to be cached by higher levels, so performance isn't critical
1705  */
1706
1707 FT_UInt
1708 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
1709 {
1710     int             initial, offset, decode;
1711     FT_UInt         glyphindex;
1712     FcChar32        charcode;
1713
1714     initial = 0;
1715     /*
1716      * Find the current encoding
1717      */
1718     if (face->charmap)
1719     {
1720         for (; initial < NUM_DECODE; initial++)
1721             if (fcFontDecoders[initial].encoding == face->charmap->encoding)
1722                 break;
1723         if (initial == NUM_DECODE)
1724             initial = 0;
1725     }
1726     /*
1727      * Check each encoding for the glyph, starting with the current one
1728      */
1729     for (offset = 0; offset < NUM_DECODE; offset++)
1730     {
1731         decode = (initial + offset) % NUM_DECODE;
1732         if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
1733             if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
1734                 continue;
1735         if (fcFontDecoders[decode].map)
1736         {
1737             charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
1738             if (charcode == ~0)
1739                 continue;
1740         }
1741         else
1742             charcode = ucs4;
1743         glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
1744         if (glyphindex)
1745             return glyphindex;
1746     }
1747 #if HAVE_FT_HAS_PS_GLYPH_NAMES
1748     /*
1749      * Check postscript name table if present
1750      */
1751     if (FcFreeTypeUseNames (face))
1752     {
1753         FcChar8 *name = FcUcs4ToGlyphName (ucs4);
1754         if (name)
1755         {
1756             glyphindex = FcFreeTypeGlyphNameIndex (face, name);
1757             if (glyphindex)
1758                 return glyphindex;
1759         }
1760     }
1761 #endif
1762     return 0;
1763 }
1764
1765 static FcBool
1766 FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
1767                       FT_UInt glyph, FcBlanks *blanks,
1768                       FT_Pos *advance)
1769 {
1770     FT_Int          load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
1771     FT_GlyphSlot    slot;
1772
1773     /*
1774      * For bitmap-only fonts, assume that they're OK.
1775      */
1776     if ((face->face_flags & FT_FACE_FLAG_SCALABLE) == 0)
1777         return FcTrue;
1778
1779     /*
1780      * When using scalable fonts, only report those glyphs
1781      * which can be scaled; otherwise those fonts will
1782      * only be available at some sizes, and never when
1783      * transformed.  Avoid this by simply reporting bitmap-only
1784      * glyphs as missing
1785      */
1786     if (face->face_flags & FT_FACE_FLAG_SCALABLE)
1787         load_flags |= FT_LOAD_NO_BITMAP;
1788
1789     if (FT_Load_Glyph (face, glyph, load_flags))
1790         return FcFalse;
1791
1792     slot = face->glyph;
1793     if (!glyph)
1794         return FcFalse;
1795
1796     *advance = slot->metrics.horiAdvance;
1797
1798     switch (slot->format) {
1799     case ft_glyph_format_bitmap:
1800         /*
1801          * Bitmaps are assumed to be reasonable; if
1802          * this proves to be a rash assumption, this
1803          * code can be easily modified
1804          */
1805         return FcTrue;
1806     case ft_glyph_format_outline:
1807         /*
1808          * Glyphs with contours are always OK
1809          */
1810         if (slot->outline.n_contours != 0)
1811             return FcTrue;
1812         /*
1813          * Glyphs with no contours are only OK if
1814          * they're members of the Blanks set specified
1815          * in the configuration.  If blanks isn't set,
1816          * then allow any glyph to be blank
1817          */
1818         if (!blanks || FcBlanksIsMember (blanks, ucs4))
1819             return FcTrue;
1820         /* fall through ... */
1821     default:
1822         break;
1823     }
1824     return FcFalse;
1825 }
1826
1827 #define APPROXIMATELY_EQUAL(x,y) (ABS ((x) - (y)) <= MAX (ABS (x), ABS (y)) / 33)
1828
1829 FcCharSet *
1830 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
1831 {
1832     FcChar32        page, off, max, ucs4;
1833 #ifdef CHECK
1834     FcChar32        font_max = 0;
1835 #endif
1836     FcCharSet       *fcs;
1837     FcCharLeaf      *leaf;
1838     const FcCharMap *map;
1839     int             o;
1840     int             i;
1841     FT_UInt         glyph;
1842     FT_Pos          advance, advance_one = 0, advance_two = 0;
1843     FcBool          has_advance = FcFalse, fixed_advance = FcTrue, dual_advance = FcFalse;
1844
1845     fcs = FcCharSetCreate ();
1846     if (!fcs)
1847         goto bail0;
1848
1849 #ifdef CHECK
1850     printf ("Family %s style %s\n", face->family_name, face->style_name);
1851 #endif
1852     for (o = 0; o < NUM_DECODE; o++)
1853     {
1854         if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
1855             continue;
1856         map = fcFontDecoders[o].map;
1857         if (map)
1858         {
1859             /*
1860              * Non-Unicode tables are easy; there's a list of all possible
1861              * characters
1862              */
1863             for (i = 0; i < map->nent; i++)
1864             {
1865                 ucs4 = map->ent[i].bmp;
1866                 glyph = FT_Get_Char_Index (face, map->ent[i].encode);
1867                 if (glyph &&
1868                     FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
1869                 {
1870                     if (!has_advance)
1871                     {
1872                         has_advance = FcTrue;
1873                         advance_one = advance;
1874                     }
1875                     else if (!APPROXIMATELY_EQUAL (advance, advance_one))
1876                     {
1877                         if (fixed_advance)
1878                         {
1879                             dual_advance = FcTrue;
1880                             fixed_advance = FcFalse;
1881                             advance_two = advance;
1882                         }
1883                         else if (!APPROXIMATELY_EQUAL (advance, advance_two))
1884                             dual_advance = FcFalse;
1885                     }
1886
1887                     leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1888                     if (!leaf)
1889                         goto bail1;
1890                     leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
1891 #ifdef CHECK
1892                     if (ucs4 > font_max)
1893                         font_max = ucs4;
1894 #endif
1895                 }
1896             }
1897         }
1898         else
1899         {
1900             FT_UInt gindex;
1901
1902             max = fcFontDecoders[o].max;
1903             /*
1904              * Find the first encoded character in the font
1905              */
1906             if (FT_Get_Char_Index (face, 0))
1907             {
1908                 ucs4 = 0;
1909                 gindex = 1;
1910             }
1911             else
1912             {
1913                 ucs4 = FT_Get_Next_Char (face, 0, &gindex);
1914                 if (!ucs4)
1915                     gindex = 0;
1916             }
1917
1918             while (gindex)
1919             {
1920                 page = ucs4 >> 8;
1921                 leaf = 0;
1922                 while ((ucs4 >> 8) == page)
1923                 {
1924                     glyph = FT_Get_Char_Index (face, ucs4);
1925                     if (glyph && FcFreeTypeCheckGlyph (face, ucs4,
1926                                                        glyph, blanks, &advance))
1927                     {
1928                         if (!has_advance)
1929                         {
1930                             has_advance = FcTrue;
1931                             advance_one = advance;
1932                         }
1933                         else if (!APPROXIMATELY_EQUAL (advance, advance_one))
1934                         {
1935                             if (fixed_advance)
1936                             {
1937                                 dual_advance = FcTrue;
1938                                 fixed_advance = FcFalse;
1939                                 advance_two = advance;
1940                             }
1941                             else if (!APPROXIMATELY_EQUAL (advance, advance_two))
1942                                 dual_advance = FcFalse;
1943                         }
1944
1945                         if (!leaf)
1946                         {
1947                             leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1948                             if (!leaf)
1949                                 goto bail1;
1950                         }
1951                         off = ucs4 & 0xff;
1952                         leaf->map[off >> 5] |= (1 << (off & 0x1f));
1953 #ifdef CHECK
1954                         if (ucs4 > font_max)
1955                             font_max = ucs4;
1956 #endif
1957                     }
1958                     ucs4++;
1959                 }
1960                 ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
1961                 if (!ucs4)
1962                     gindex = 0;
1963             }
1964 #ifdef CHECK
1965             for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
1966             {
1967                 FcBool      FT_Has, FC_Has;
1968
1969                 FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
1970                 FC_Has = FcCharSetHasChar (fcs, ucs4);
1971                 if (FT_Has != FC_Has)
1972                 {
1973                     printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
1974                 }
1975             }
1976 #endif
1977         }
1978     }
1979 #if HAVE_FT_HAS_PS_GLYPH_NAMES
1980     /*
1981      * Add mapping from PS glyph names if available
1982      */
1983     if (FcFreeTypeUseNames (face))
1984     {
1985         FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
1986
1987         for (glyph = 0; glyph < face->num_glyphs; glyph++)
1988         {
1989             if (FT_Get_Glyph_Name (face, glyph, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
1990             {
1991                 ucs4 = FcGlyphNameToUcs4 (name_buf);
1992                 if (ucs4 != 0xffff &&
1993                     FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
1994                 {
1995                     if (!has_advance)
1996                     {
1997                         has_advance = FcTrue;
1998                         advance_one = advance;
1999                     }
2000                     else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2001                     {
2002                         if (fixed_advance)
2003                         {
2004                             dual_advance = FcTrue;
2005                             fixed_advance = FcFalse;
2006                             advance_two = advance;
2007                         }
2008                         else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2009                             dual_advance = FcFalse;
2010                     }
2011                     leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2012                     if (!leaf)
2013                         goto bail1;
2014                     leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
2015 #ifdef CHECK
2016                     if (ucs4 > font_max)
2017                         font_max = ucs4;
2018 #endif
2019                 }
2020             }
2021         }
2022     }
2023 #endif
2024 #ifdef CHECK
2025     printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
2026     for (ucs4 = 0; ucs4 <= font_max; ucs4++)
2027     {
2028         FcBool  has_char = (glyph = FcFreeTypeCharIndex (face, ucs4)) != 0;
2029         FcBool  has_bit = FcCharSetHasChar (fcs, ucs4);
2030
2031         if (has_char && !has_bit)
2032         {
2033             if (!FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2034                 printf ("Bitmap missing broken char 0x%x\n", ucs4);
2035             else
2036                 printf ("Bitmap missing char 0x%x\n", ucs4);
2037         }
2038         else if (!has_char && has_bit)
2039             printf ("Bitmap extra char 0x%x\n", ucs4);
2040     }
2041 #endif
2042     if (fixed_advance)
2043         *spacing = FC_MONO;
2044     else if (dual_advance && APPROXIMATELY_EQUAL (2 * MIN (advance_one, advance_two), MAX (advance_one, advance_two)))
2045         *spacing = FC_DUAL;
2046     else
2047         *spacing = FC_PROPORTIONAL;
2048     return fcs;
2049 bail1:
2050     FcCharSetDestroy (fcs);
2051 bail0:
2052     return 0;
2053 }
2054
2055 FcCharSet *
2056 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
2057 {
2058     int spacing;
2059
2060     return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
2061 }