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 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include "fcint.h"
  29 #include <freetype/freetype.h>
  30 #include <freetype/internal/ftobjs.h>
  31 #include <freetype/tttables.h>
  32 #include <freetype/ftsnames.h>
  33 #include <freetype/ttnameid.h>
  34
  35 /*
  36  * Keep Han languages separated by eliminating languages
  37  * that the codePageRange bits says aren't supported
  38  */
  39
  40 static const struct {
  41     int             bit;
  42     const FcChar8   *lang;
  43 } FcCodePageRange[] = {
  44     { 17,       (const FcChar8 *) "ja" },
  45     { 18,       (const FcChar8 *) "zh-cn" },
  46     { 19,       (const FcChar8 *) "ko" },
  47     { 20,       (const FcChar8 *) "zh-tw" },
  48 };
  49
  50 #define NUM_CODE_PAGE_RANGE (sizeof FcCodePageRange / sizeof FcCodePageRange[0])
  51
  52 FcBool
  53 FcFreeTypeIsExclusiveLang (const FcChar8  *lang)
  54 {
  55     int     i;
  56
  57     for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
  58     {
  59         if (FcLangCompare (lang, FcCodePageRange[i].lang) != FcLangDifferentLang)
  60             return FcTrue;
  61     }
  62     return FcFalse;
  63 }
  64
  65 #define FC_NAME_PRIO_LANG           0x0f00
  66 #define FC_NAME_PRIO_LANG_ENGLISH   0x0200
  67 #define FC_NAME_PRIO_LANG_LATIN     0x0100
  68 #define FC_NAME_PRIO_LANG_NONE      0x0000
  69
  70 #define FC_NAME_PRIO_ENC            0x00f0
  71 #define FC_NAME_PRIO_ENC_UNICODE    0x0010
  72 #define FC_NAME_PRIO_ENC_NONE       0x0000
  73
  74 #define FC_NAME_PRIO_NAME           0x000f
  75 #define FC_NAME_PRIO_NAME_FAMILY    0x0002
  76 #define FC_NAME_PRIO_NAME_PS        0x0001
  77 #define FC_NAME_PRIO_NAME_NONE      0x0000
  78
  79 static FcBool
  80 FcUcs4IsLatin (FcChar32 ucs4)
  81 {
  82     FcChar32    page = ucs4 >> 8;
  83
  84     if (page <= 2)
  85         return FcTrue;
  86     if (page == 0x1e)
  87         return FcTrue;
  88     if (0x20 <= page && page <= 0x23)
  89         return FcTrue;
  90     if (page == 0xfb)
  91         return FcTrue;
  92     if (page == 0xff)
  93         return FcTrue;
  94     return FcFalse;
  95 }
  96
  97 static FcBool
  98 FcUtf8IsLatin (FcChar8 *str, int len)
  99 {
 100     while (len)
 101     {
 102         FcChar32    ucs4;
 103         int         clen = FcUtf8ToUcs4 (str, &ucs4, len);
 104         if (clen <= 0)
 105             return FcFalse;
 106         if (!FcUcs4IsLatin (ucs4))
 107             return FcFalse;
 108         len -= clen;
 109         str += clen;
 110     }
 111     return FcTrue;
 112 }
 113
 114 FcPattern *
 115 FcFreeTypeQuery (const FcChar8  *file,
 116                  int            id,
 117                  FcBlanks       *blanks,
 118                  int            *count)
 119 {
 120     FT_Face         face;
 121     FcPattern       *pat;
 122     int             slant;
 123     int             weight;
 124     int             i;
 125     FcCharSet       *cs;
 126     FcLangSet       *ls;
 127     FT_Library      ftLibrary;
 128     FcChar8         *family;
 129     FcChar8         *style;
 130     TT_OS2          *os2;
 131     TT_Header       *head;
 132     const FcChar8   *exclusiveLang = 0;
 133     FT_SfntName     sname;
 134     FT_UInt         snamei, snamec;
 135     FcBool          family_allocated = FcFalse;
 136     FcBool          style_allocated = FcFalse;
 137     int             family_prio = 0;
 138     int             style_prio = 0;
 139
 140     if (FT_Init_FreeType (&ftLibrary))
 141         return 0;
 142
 143     if (FT_New_Face (ftLibrary, (char *) file, id, &face))
 144         goto bail;
 145
 146     *count = face->num_faces;
 147
 148     pat = FcPatternCreate ();
 149     if (!pat)
 150         goto bail0;
 151
 152     if (!FcPatternAddBool (pat, FC_OUTLINE,
 153                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
 154         goto bail1;
 155
 156     if (!FcPatternAddBool (pat, FC_SCALABLE,
 157                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
 158         goto bail1;
 159
 160
 161     slant = FC_SLANT_ROMAN;
 162     if (face->style_flags & FT_STYLE_FLAG_ITALIC)
 163         slant = FC_SLANT_ITALIC;
 164
 165     if (!FcPatternAddInteger (pat, FC_SLANT, slant))
 166         goto bail1;
 167
 168     weight = FC_WEIGHT_MEDIUM;
 169     if (face->style_flags & FT_STYLE_FLAG_BOLD)
 170         weight = FC_WEIGHT_BOLD;
 171
 172     if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
 173         goto bail1;
 174
 175     /*
 176      * Grub through the name table looking for family
 177      * and style names.  FreeType makes quite a hash
 178      * of them
 179      */
 180     family = 0;
 181     style = 0;
 182     snamec = FT_Get_Sfnt_Name_Count (face);
 183     for (snamei = 0; snamei < snamec; snamei++)
 184     {
 185         FcChar8         *utf8;
 186         int             len;
 187         int             wchar;
 188         FcChar8         *src;
 189         int             src_len;
 190         FcChar8         *u8;
 191         FcChar32        ucs4;
 192         int             ilen, olen;
 193         int             prio = 0;
 194
 195         const FcCharMap *map;
 196         enum {
 197             FcNameEncodingUtf16,
 198             FcNameEncodingAppleRoman,
 199             FcNameEncodingLatin1
 200         } encoding;
 201
 202
 203         if (FT_Get_Sfnt_Name (face, snamei, &sname) != 0)
 204             break;
 205
 206         /*
 207          * Look for Unicode strings
 208          */
 209         switch (sname.platform_id) {
 210         case TT_PLATFORM_APPLE_UNICODE:
 211             /*
 212              * All APPLE_UNICODE encodings are Utf16 BE
 213              *
 214              * Because there's no language id for Unicode,
 215              * assume it's English
 216              */
 217             prio |= FC_NAME_PRIO_LANG_ENGLISH;
 218             prio |= FC_NAME_PRIO_ENC_UNICODE;
 219             encoding = FcNameEncodingUtf16;
 220             break;
 221         case TT_PLATFORM_MACINTOSH:
 222             switch (sname.encoding_id) {
 223             case TT_MAC_ID_ROMAN:
 224                 encoding = FcNameEncodingAppleRoman;
 225                 break;
 226             default:
 227                 continue;
 228             }
 229             switch (sname.language_id) {
 230             case TT_MAC_LANGID_ENGLISH:
 231                 prio |= FC_NAME_PRIO_LANG_ENGLISH;
 232                 break;
 233             default:
 234                 /*
 235                  * Sometimes Microsoft language ids
 236                  * end up in the macintosh table.  This
 237                  * is often accompanied by data in
 238                  * some mystic encoding.  Ignore these names
 239                  */
 240                 if (sname.language_id >= 0x100)
 241                     continue;
 242                 break;
 243             }
 244             break;
 245         case TT_PLATFORM_MICROSOFT:
 246             switch (sname.encoding_id) {
 247             case TT_MS_ID_UNICODE_CS:
 248                 encoding = FcNameEncodingUtf16;
 249                 prio |= FC_NAME_PRIO_ENC_UNICODE;
 250                 break;
 251             default:
 252                 continue;
 253             }
 254             switch (sname.language_id & 0xff) {
 255             case 0x09:
 256                 prio |= FC_NAME_PRIO_LANG_ENGLISH;
 257                 break;
 258             default:
 259                 break;
 260             }
 261             break;
 262         case TT_PLATFORM_ISO:
 263             switch (sname.encoding_id) {
 264             case TT_ISO_ID_10646:
 265                 encoding = FcNameEncodingUtf16;
 266                 prio |= FC_NAME_PRIO_ENC_UNICODE;
 267                 break;
 268             case TT_ISO_ID_7BIT_ASCII:
 269             case TT_ISO_ID_8859_1:
 270                 encoding = FcNameEncodingLatin1;
 271                 break;
 272             default:
 273                 continue;
 274             }
 275             break;
 276         default:
 277             continue;
 278         }
 279
 280         /*
 281          * Look for family and style names
 282          */
 283         switch (sname.name_id) {
 284         case TT_NAME_ID_FONT_FAMILY:
 285             prio |= FC_NAME_PRIO_NAME_FAMILY;
 286             break;
 287         case TT_NAME_ID_PS_NAME:
 288             prio |= FC_NAME_PRIO_NAME_PS;
 289             break;
 290         case TT_NAME_ID_FONT_SUBFAMILY:
 291             break;
 292         default:
 293             continue;
 294         }
 295
 296         src = (FcChar8 *) sname.string;
 297         src_len = sname.string_len;
 298
 299         switch (encoding) {
 300         case FcNameEncodingUtf16:
 301             /*
 302              * Convert Utf16 to Utf8
 303              */
 304
 305             if (!FcUtf16Len (src, FcEndianBig, src_len, &len, &wchar))
 306                 continue;
 307
 308             /*
 309              * Allocate plenty of space.  Freed below
 310              */
 311             utf8 = malloc (len * FC_UTF8_MAX_LEN + 1);
 312             if (!utf8)
 313                 continue;
 314
 315             u8 = utf8;
 316
 317             while ((ilen = FcUtf16ToUcs4 (src, FcEndianBig, &ucs4, src_len)) > 0)
 318             {
 319                 src_len -= ilen;
 320                 src += ilen;
 321                 olen = FcUcs4ToUtf8 (ucs4, u8);
 322                 u8 += olen;
 323             }
 324             *u8 = '\0';
 325             break;
 326         case FcNameEncodingLatin1:
 327             /*
 328              * Convert Latin1 to Utf8. Freed below
 329              */
 330             utf8 = malloc (src_len * 2 + 1);
 331             if (!utf8)
 332                 continue;
 333
 334             u8 = utf8;
 335             while (src_len > 0)
 336             {
 337                 ucs4 = *src++;
 338                 src_len--;
 339                 olen = FcUcs4ToUtf8 (ucs4, u8);
 340                 u8 += olen;
 341             }
 342             *u8 = '\0';
 343             break;
 344         case FcNameEncodingAppleRoman:
 345             /*
 346              * Convert AppleRoman to Utf8
 347              */
 348             map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
 349             if (!map)
 350                 continue;
 351
 352             /* freed below */
 353             utf8 = malloc (src_len * 3 + 1);
 354             if (!utf8)
 355                 continue;
 356
 357             u8 = utf8;
 358             while (src_len > 0)
 359             {
 360                 ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
 361                 src_len--;
 362                 olen = FcUcs4ToUtf8 (ucs4, u8);
 363                 u8 += olen;
 364             }
 365             *u8 = '\0';
 366             break;
 367         default:
 368             continue;
 369         }
 370         if ((prio & FC_NAME_PRIO_LANG) == FC_NAME_PRIO_LANG_NONE)
 371             if (FcUtf8IsLatin (utf8, strlen ((char *) utf8)))
 372                 prio |= FC_NAME_PRIO_LANG_LATIN;
 373
 374         if (FcDebug () & FC_DBG_SCANV)
 375             printf ("\nfound name (name %d platform %d encoding %d language 0x%x prio 0x%x) %s\n",
 376                     sname.name_id, sname.platform_id,
 377                     sname.encoding_id, sname.language_id,
 378                     prio, utf8);
 379
 380         switch (sname.name_id) {
 381         case TT_NAME_ID_FONT_FAMILY:
 382         case TT_NAME_ID_PS_NAME:
 383             if (!family || prio > family_prio)
 384             {
 385                 if (family)
 386                     free (family);
 387                 family = utf8;
 388                 utf8 = 0;
 389                 family_allocated = FcTrue;
 390                 family_prio = prio;
 391             }
 392             break;
 393         case TT_NAME_ID_FONT_SUBFAMILY:
 394             if (!style || prio > style_prio)
 395             {
 396                 if (style)
 397                     free (style);
 398                 style = utf8;
 399                 utf8 = 0;
 400                 style_allocated = FcTrue;
 401                 style_prio = prio;
 402             }
 403             break;
 404         }
 405         if (utf8)
 406             free (utf8);
 407     }
 408
 409     if (!family)
 410         family = (FcChar8 *) face->family_name;
 411
 412     if (!style)
 413         style = (FcChar8 *) face->style_name;
 414
 415     if (!family)
 416     {
 417         FcChar8 *start, *end;
 418
 419         start = (FcChar8 *) strrchr ((char *) file, '/');
 420         if (start)
 421             start++;
 422         else
 423             start = (FcChar8 *) file;
 424         end = (FcChar8 *) strrchr ((char *) start, '.');
 425         if (!end)
 426             end = start + strlen ((char *) start);
 427         /* freed below */
 428         family = malloc (end - start + 1);
 429         strncpy ((char *) family, (char *) start, end - start);
 430         family[end - start] = '\0';
 431         family_allocated = FcTrue;
 432     }
 433
 434     if (FcDebug() & FC_DBG_SCAN)
 435         printf ("\"%s\" \"%s\" ", family, style ? style : (FcChar8 *) "<none>");
 436
 437     if (!FcPatternAddString (pat, FC_FAMILY, family))
 438     {
 439         if (family_allocated)
 440             free (family);
 441         if (style_allocated)
 442             free (style);
 443         goto bail1;
 444     }
 445
 446     if (family_allocated)
 447         free (family);
 448
 449     if (style)
 450     {
 451         if (!FcPatternAddString (pat, FC_STYLE, style))
 452         {
 453             if (style_allocated)
 454                 free (style);
 455             goto bail1;
 456         }
 457         if (style_allocated)
 458             free (style);
 459     }
 460
 461     if (!FcPatternAddString (pat, FC_FILE, file))
 462         goto bail1;
 463
 464     if (!FcPatternAddInteger (pat, FC_INDEX, id))
 465         goto bail1;
 466
 467     if (!FcPatternAddString (pat, FC_SOURCE, (FcChar8 *) "FreeType"))
 468         goto bail1;
 469
 470 #if 0
 471     /*
 472      * don't even try this -- CJK 'monospace' fonts are really
 473      * dual width, and most other fonts don't bother to set
 474      * the attribute.  Sigh.
 475      */
 476     if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
 477         if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
 478             goto bail1;
 479 #endif
 480
 481     /*
 482      * Find the font revision (if available)
 483      */
 484     head = (TT_Header *) FT_Get_Sfnt_Table (face, ft_sfnt_head);
 485     if (head)
 486     {
 487         if (!FcPatternAddInteger (pat, FC_FONTVERSION, head->Font_Revision))
 488             goto bail1;
 489     }
 490     else
 491     {
 492         if (!FcPatternAddInteger (pat, FC_FONTVERSION, 0))
 493             goto bail1;
 494     }
 495
 496     /*
 497      * Get the OS/2 table and poke about
 498      */
 499     os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
 500     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
 501     {
 502         for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
 503         {
 504             FT_ULong    bits;
 505             int         bit;
 506             if (FcCodePageRange[i].bit < 32)
 507             {
 508                 bits = os2->ulCodePageRange1;
 509                 bit = FcCodePageRange[i].bit;
 510             }
 511             else
 512             {
 513                 bits = os2->ulCodePageRange2;
 514                 bit = FcCodePageRange[i].bit - 32;
 515             }
 516             if (bits & (1 << bit))
 517             {
 518                 /*
 519                  * If the font advertises support for multiple
 520                  * "exclusive" languages, then include support
 521                  * for any language found to have coverage
 522                  */
 523                 if (exclusiveLang)
 524                 {
 525                     exclusiveLang = 0;
 526                     break;
 527                 }
 528                 exclusiveLang = FcCodePageRange[i].lang;
 529             }
 530         }
 531     }
 532
 533     /*
 534      * Compute the unicode coverage for the font
 535      */
 536     cs = FcFreeTypeCharSet (face, blanks);
 537     if (!cs)
 538         goto bail1;
 539
 540     /*
 541      * Skip over PCF fonts that have no encoded characters; they're
 542      * usually just Unicode fonts transcoded to some legacy encoding
 543      */
 544     if (FcCharSetCount (cs) == 0)
 545     {
 546         if (!strcmp(FT_MODULE_CLASS(&face->driver->root)->module_name, "pcf"))
 547             goto bail2;
 548     }
 549
 550     if (!FcPatternAddCharSet (pat, FC_CHARSET, cs))
 551         goto bail2;
 552
 553     ls = FcFreeTypeLangSet (cs, exclusiveLang);
 554     if (!ls)
 555         goto bail2;
 556
 557     if (!FcPatternAddLangSet (pat, FC_LANG, ls))
 558         goto bail2;
 559
 560     /*
 561      * Drop our reference to the charset
 562      */
 563     FcCharSetDestroy (cs);
 564
 565     if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
 566     {
 567         for (i = 0; i < face->num_fixed_sizes; i++)
 568             if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE,
 569                                      (double) face->available_sizes[i].height))
 570                 goto bail1;
 571         if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
 572             goto bail1;
 573     }
 574
 575     FT_Done_Face (face);
 576     FT_Done_FreeType (ftLibrary);
 577     return pat;
 578
 579 bail2:
 580     FcCharSetDestroy (cs);
 581 bail1:
 582     FcPatternDestroy (pat);
 583 bail0:
 584     FT_Done_Face (face);
 585 bail:
 586     FT_Done_FreeType (ftLibrary);
 587     return 0;
 588 }
 589
 590
 591 /*
 592  * Figure out whether the available freetype has FT_Get_Next_Char
 593  */
 594
 595 #if FREETYPE_MAJOR > 2
 596 # define HAS_NEXT_CHAR
 597 #else
 598 # if FREETYPE_MAJOR == 2
 599 #  if FREETYPE_MINOR > 0
 600 #   define HAS_NEXT_CHAR
 601 #  else
 602 #   if FREETYPE_MINOR == 0
 603 #    if FREETYPE_PATCH >= 9
 604 #     define HAS_NEXT_CHAR
 605 #    endif
 606 #   endif
 607 #  endif
 608 # endif
 609 #endif
 610
 611 /*
 612  * For our purposes, this approximation is sufficient
 613  */
 614 #ifndef HAS_NEXT_CHAR
 615 #define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
 616 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
 617                                           (*(gi) = 0), 0 : \
 618                                           (*(gi) = 1), (ucs4) + 1)
 619 #warning "No FT_Get_Next_Char"
 620 #endif
 621
 622 typedef struct _FcCharEnt {
 623     FcChar16        bmp;
 624     unsigned char   encode;
 625 } FcCharEnt;
 626
 627 struct _FcCharMap {
 628     const FcCharEnt *ent;
 629     int             nent;
 630 };
 631
 632 typedef struct _FcFontDecode {
 633     FT_Encoding     encoding;
 634     const FcCharMap *map;
 635     FcChar32        max;
 636 } FcFontDecode;
 637
 638 static const FcCharEnt AppleRomanEnt[] = {
 639     { 0x0020, 0x20 }, /* SPACE */
 640     { 0x0021, 0x21 }, /* EXCLAMATION MARK */
 641     { 0x0022, 0x22 }, /* QUOTATION MARK */
 642     { 0x0023, 0x23 }, /* NUMBER SIGN */
 643     { 0x0024, 0x24 }, /* DOLLAR SIGN */
 644     { 0x0025, 0x25 }, /* PERCENT SIGN */
 645     { 0x0026, 0x26 }, /* AMPERSAND */
 646     { 0x0027, 0x27 }, /* APOSTROPHE */
 647     { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
 648     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
 649     { 0x002A, 0x2A }, /* ASTERISK */
 650     { 0x002B, 0x2B }, /* PLUS SIGN */
 651     { 0x002C, 0x2C }, /* COMMA */
 652     { 0x002D, 0x2D }, /* HYPHEN-MINUS */
 653     { 0x002E, 0x2E }, /* FULL STOP */
 654     { 0x002F, 0x2F }, /* SOLIDUS */
 655     { 0x0030, 0x30 }, /* DIGIT ZERO */
 656     { 0x0031, 0x31 }, /* DIGIT ONE */
 657     { 0x0032, 0x32 }, /* DIGIT TWO */
 658     { 0x0033, 0x33 }, /* DIGIT THREE */
 659     { 0x0034, 0x34 }, /* DIGIT FOUR */
 660     { 0x0035, 0x35 }, /* DIGIT FIVE */
 661     { 0x0036, 0x36 }, /* DIGIT SIX */
 662     { 0x0037, 0x37 }, /* DIGIT SEVEN */
 663     { 0x0038, 0x38 }, /* DIGIT EIGHT */
 664     { 0x0039, 0x39 }, /* DIGIT NINE */
 665     { 0x003A, 0x3A }, /* COLON */
 666     { 0x003B, 0x3B }, /* SEMICOLON */
 667     { 0x003C, 0x3C }, /* LESS-THAN SIGN */
 668     { 0x003D, 0x3D }, /* EQUALS SIGN */
 669     { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
 670     { 0x003F, 0x3F }, /* QUESTION MARK */
 671     { 0x0040, 0x40 }, /* COMMERCIAL AT */
 672     { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
 673     { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
 674     { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
 675     { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
 676     { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
 677     { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
 678     { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
 679     { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
 680     { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
 681     { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
 682     { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
 683     { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
 684     { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
 685     { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
 686     { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
 687     { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
 688     { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
 689     { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
 690     { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
 691     { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
 692     { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
 693     { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
 694     { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
 695     { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
 696     { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
 697     { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
 698     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
 699     { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
 700     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
 701     { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
 702     { 0x005F, 0x5F }, /* LOW LINE */
 703     { 0x0060, 0x60 }, /* GRAVE ACCENT */
 704     { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
 705     { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
 706     { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
 707     { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
 708     { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
 709     { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
 710     { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
 711     { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
 712     { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
 713     { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
 714     { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
 715     { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
 716     { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
 717     { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
 718     { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
 719     { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
 720     { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
 721     { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
 722     { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
 723     { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
 724     { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
 725     { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
 726     { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
 727     { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
 728     { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
 729     { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
 730     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
 731     { 0x007C, 0x7C }, /* VERTICAL LINE */
 732     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
 733     { 0x007E, 0x7E }, /* TILDE */
 734     { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
 735     { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
 736     { 0x00A2, 0xA2 }, /* CENT SIGN */
 737     { 0x00A3, 0xA3 }, /* POUND SIGN */
 738     { 0x00A5, 0xB4 }, /* YEN SIGN */
 739     { 0x00A7, 0xA4 }, /* SECTION SIGN */
 740     { 0x00A8, 0xAC }, /* DIAERESIS */
 741     { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
 742     { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
 743     { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
 744     { 0x00AC, 0xC2 }, /* NOT SIGN */
 745     { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
 746     { 0x00AF, 0xF8 }, /* MACRON */
 747     { 0x00B0, 0xA1 }, /* DEGREE SIGN */
 748     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
 749     { 0x00B4, 0xAB }, /* ACUTE ACCENT */
 750     { 0x00B5, 0xB5 }, /* MICRO SIGN */
 751     { 0x00B6, 0xA6 }, /* PILCROW SIGN */
 752     { 0x00B7, 0xE1 }, /* MIDDLE DOT */
 753     { 0x00B8, 0xFC }, /* CEDILLA */
 754     { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
 755     { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
 756     { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
 757     { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
 758     { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
 759     { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
 760     { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
 761     { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
 762     { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
 763     { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
 764     { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
 765     { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
 766     { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
 767     { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
 768     { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
 769     { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
 770     { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
 771     { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
 772     { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
 773     { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
 774     { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
 775     { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
 776     { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
 777     { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
 778     { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
 779     { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
 780     { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
 781     { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
 782     { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
 783     { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
 784     { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
 785     { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
 786     { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
 787     { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
 788     { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
 789     { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
 790     { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
 791     { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
 792     { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
 793     { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
 794     { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
 795     { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
 796     { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
 797     { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
 798     { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
 799     { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
 800     { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
 801     { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
 802     { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
 803     { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
 804     { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
 805     { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
 806     { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
 807     { 0x00F7, 0xD6 }, /* DIVISION SIGN */
 808     { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
 809     { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
 810     { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
 811     { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
 812     { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
 813     { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
 814     { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
 815     { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
 816     { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
 817     { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
 818     { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
 819     { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
 820     { 0x02C7, 0xFF }, /* CARON */
 821     { 0x02D8, 0xF9 }, /* BREVE */
 822     { 0x02D9, 0xFA }, /* DOT ABOVE */
 823     { 0x02DA, 0xFB }, /* RING ABOVE */
 824     { 0x02DB, 0xFE }, /* OGONEK */
 825     { 0x02DC, 0xF7 }, /* SMALL TILDE */
 826     { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
 827     { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
 828     { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
 829     { 0x2013, 0xD0 }, /* EN DASH */
 830     { 0x2014, 0xD1 }, /* EM DASH */
 831     { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
 832     { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
 833     { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
 834     { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
 835     { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
 836     { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
 837     { 0x2020, 0xA0 }, /* DAGGER */
 838     { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
 839     { 0x2022, 0xA5 }, /* BULLET */
 840     { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
 841     { 0x2030, 0xE4 }, /* PER MILLE SIGN */
 842     { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
 843     { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
 844     { 0x2044, 0xDA }, /* FRACTION SLASH */
 845     { 0x20AC, 0xDB }, /* EURO SIGN */
 846     { 0x2122, 0xAA }, /* TRADE MARK SIGN */
 847     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
 848     { 0x2206, 0xC6 }, /* INCREMENT */
 849     { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
 850     { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
 851     { 0x221A, 0xC3 }, /* SQUARE ROOT */
 852     { 0x221E, 0xB0 }, /* INFINITY */
 853     { 0x222B, 0xBA }, /* INTEGRAL */
 854     { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
 855     { 0x2260, 0xAD }, /* NOT EQUAL TO */
 856     { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
 857     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
 858     { 0x25CA, 0xD7 }, /* LOZENGE */
 859     { 0xF8FF, 0xF0 }, /* Apple logo */
 860     { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
 861     { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
 862 };
 863
 864 static const FcCharMap AppleRoman = {
 865     AppleRomanEnt,
 866     sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
 867 };
 868
 869 static const FcCharEnt AdobeSymbolEnt[] = {
 870     { 0x0020, 0x20 }, /* SPACE  # space */
 871     { 0x0021, 0x21 }, /* EXCLAMATION MARK       # exclam */
 872     { 0x0023, 0x23 }, /* NUMBER SIGN    # numbersign */
 873     { 0x0025, 0x25 }, /* PERCENT SIGN   # percent */
 874     { 0x0026, 0x26 }, /* AMPERSAND      # ampersand */
 875     { 0x0028, 0x28 }, /* LEFT PARENTHESIS       # parenleft */
 876     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS      # parenright */
 877     { 0x002B, 0x2B }, /* PLUS SIGN      # plus */
 878     { 0x002C, 0x2C }, /* COMMA  # comma */
 879     { 0x002E, 0x2E }, /* FULL STOP      # period */
 880     { 0x002F, 0x2F }, /* SOLIDUS        # slash */
 881     { 0x0030, 0x30 }, /* DIGIT ZERO     # zero */
 882     { 0x0031, 0x31 }, /* DIGIT ONE      # one */
 883     { 0x0032, 0x32 }, /* DIGIT TWO      # two */
 884     { 0x0033, 0x33 }, /* DIGIT THREE    # three */
 885     { 0x0034, 0x34 }, /* DIGIT FOUR     # four */
 886     { 0x0035, 0x35 }, /* DIGIT FIVE     # five */
 887     { 0x0036, 0x36 }, /* DIGIT SIX      # six */
 888     { 0x0037, 0x37 }, /* DIGIT SEVEN    # seven */
 889     { 0x0038, 0x38 }, /* DIGIT EIGHT    # eight */
 890     { 0x0039, 0x39 }, /* DIGIT NINE     # nine */
 891     { 0x003A, 0x3A }, /* COLON  # colon */
 892     { 0x003B, 0x3B }, /* SEMICOLON      # semicolon */
 893     { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
 894     { 0x003D, 0x3D }, /* EQUALS SIGN    # equal */
 895     { 0x003E, 0x3E }, /* GREATER-THAN SIGN      # greater */
 896     { 0x003F, 0x3F }, /* QUESTION MARK  # question */
 897     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET    # bracketleft */
 898     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET   # bracketright */
 899     { 0x005F, 0x5F }, /* LOW LINE       # underscore */
 900     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET     # braceleft */
 901     { 0x007C, 0x7C }, /* VERTICAL LINE  # bar */
 902     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET    # braceright */
 903     { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
 904     { 0x00AC, 0xD8 }, /* NOT SIGN       # logicalnot */
 905     { 0x00B0, 0xB0 }, /* DEGREE SIGN    # degree */
 906     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN        # plusminus */
 907     { 0x00B5, 0x6D }, /* MICRO SIGN     # mu */
 908     { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN    # multiply */
 909     { 0x00F7, 0xB8 }, /* DIVISION SIGN  # divide */
 910     { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
 911     { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA     # Alpha */
 912     { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA      # Beta */
 913     { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA     # Gamma */
 914     { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA     # Delta */
 915     { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON   # Epsilon */
 916     { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA      # Zeta */
 917     { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA       # Eta */
 918     { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA     # Theta */
 919     { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA      # Iota */
 920     { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA     # Kappa */
 921     { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA     # Lambda */
 922     { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU        # Mu */
 923     { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU        # Nu */
 924     { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI        # Xi */
 925     { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON   # Omicron */
 926     { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI        # Pi */
 927     { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO       # Rho */
 928     { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA     # Sigma */
 929     { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU       # Tau */
 930     { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON   # Upsilon */
 931     { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI       # Phi */
 932     { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI       # Chi */
 933     { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI       # Psi */
 934     { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA     # Omega */
 935     { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA       # alpha */
 936     { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA        # beta */
 937     { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA       # gamma */
 938     { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA       # delta */
 939     { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON     # epsilon */
 940     { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA        # zeta */
 941     { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
 942     { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA       # theta */
 943     { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA        # iota */
 944     { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA       # kappa */
 945     { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA       # lambda */
 946     { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU  # mu */
 947     { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU  # nu */
 948     { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI  # xi */
 949     { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON     # omicron */
 950     { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI  # pi */
 951     { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
 952     { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
 953     { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA       # sigma */
 954     { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
 955     { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON     # upsilon */
 956     { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
 957     { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
 958     { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
 959     { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA       # omega */
 960     { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL     # theta1 */
 961     { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
 962     { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL       # phi1 */
 963     { 0x03D6, 0x76 }, /* GREEK PI SYMBOL        # omega1 */
 964     { 0x2022, 0xB7 }, /* BULLET # bullet */
 965     { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS    # ellipsis */
 966     { 0x2032, 0xA2 }, /* PRIME  # minute */
 967     { 0x2033, 0xB2 }, /* DOUBLE PRIME   # second */
 968     { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
 969     { 0x20AC, 0xA0 }, /* EURO SIGN      # Euro */
 970     { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
 971     { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P       # weierstrass */
 972     { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
 973     { 0x2126, 0x57 }, /* OHM SIGN       # Omega */
 974     { 0x2135, 0xC0 }, /* ALEF SYMBOL    # aleph */
 975     { 0x2190, 0xAC }, /* LEFTWARDS ARROW        # arrowleft */
 976     { 0x2191, 0xAD }, /* UPWARDS ARROW  # arrowup */
 977     { 0x2192, 0xAE }, /* RIGHTWARDS ARROW       # arrowright */
 978     { 0x2193, 0xAF }, /* DOWNWARDS ARROW        # arrowdown */
 979     { 0x2194, 0xAB }, /* LEFT RIGHT ARROW       # arrowboth */
 980     { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS  # carriagereturn */
 981     { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
 982     { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW   # arrowdblup */
 983     { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW        # arrowdblright */
 984     { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
 985     { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW        # arrowdblboth */
 986     { 0x2200, 0x22 }, /* FOR ALL        # universal */
 987     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL   # partialdiff */
 988     { 0x2203, 0x24 }, /* THERE EXISTS   # existential */
 989     { 0x2205, 0xC6 }, /* EMPTY SET      # emptyset */
 990     { 0x2206, 0x44 }, /* INCREMENT      # Delta */
 991     { 0x2207, 0xD1 }, /* NABLA  # gradient */
 992     { 0x2208, 0xCE }, /* ELEMENT OF     # element */
 993     { 0x2209, 0xCF }, /* NOT AN ELEMENT OF      # notelement */
 994     { 0x220B, 0x27 }, /* CONTAINS AS MEMBER     # suchthat */
 995     { 0x220F, 0xD5 }, /* N-ARY PRODUCT  # product */
 996     { 0x2211, 0xE5 }, /* N-ARY SUMMATION        # summation */
 997     { 0x2212, 0x2D }, /* MINUS SIGN     # minus */
 998     { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
 999     { 0x2217, 0x2A }, /* ASTERISK OPERATOR      # asteriskmath */
1000     { 0x221A, 0xD6 }, /* SQUARE ROOT    # radical */
1001     { 0x221D, 0xB5 }, /* PROPORTIONAL TO        # proportional */
1002     { 0x221E, 0xA5 }, /* INFINITY       # infinity */
1003     { 0x2220, 0xD0 }, /* ANGLE  # angle */
1004     { 0x2227, 0xD9 }, /* LOGICAL AND    # logicaland */
1005     { 0x2228, 0xDA }, /* LOGICAL OR     # logicalor */
1006     { 0x2229, 0xC7 }, /* INTERSECTION   # intersection */
1007     { 0x222A, 0xC8 }, /* UNION  # union */
1008     { 0x222B, 0xF2 }, /* INTEGRAL       # integral */
1009     { 0x2234, 0x5C }, /* THEREFORE      # therefore */
1010     { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
1011     { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
1012     { 0x2248, 0xBB }, /* ALMOST EQUAL TO        # approxequal */
1013     { 0x2260, 0xB9 }, /* NOT EQUAL TO   # notequal */
1014     { 0x2261, 0xBA }, /* IDENTICAL TO   # equivalence */
1015     { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO  # lessequal */
1016     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO       # greaterequal */
1017     { 0x2282, 0xCC }, /* SUBSET OF      # propersubset */
1018     { 0x2283, 0xC9 }, /* SUPERSET OF    # propersuperset */
1019     { 0x2284, 0xCB }, /* NOT A SUBSET OF        # notsubset */
1020     { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO  # reflexsubset */
1021     { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO        # reflexsuperset */
1022     { 0x2295, 0xC5 }, /* CIRCLED PLUS   # circleplus */
1023     { 0x2297, 0xC4 }, /* CIRCLED TIMES  # circlemultiply */
1024     { 0x22A5, 0x5E }, /* UP TACK        # perpendicular */
1025     { 0x22C5, 0xD7 }, /* DOT OPERATOR   # dotmath */
1026     { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL      # integraltp */
1027     { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL   # integralbt */
1028     { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET    # angleleft */
1029     { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET   # angleright */
1030     { 0x25CA, 0xE0 }, /* LOZENGE        # lozenge */
1031     { 0x2660, 0xAA }, /* BLACK SPADE SUIT       # spade */
1032     { 0x2663, 0xA7 }, /* BLACK CLUB SUIT        # club */
1033     { 0x2665, 0xA9 }, /* BLACK HEART SUIT       # heart */
1034     { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT     # diamond */
1035     { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF   # copyrightserif (CUS) */
1036     { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF  # registerserif (CUS) */
1037     { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF  # trademarkserif (CUS) */
1038     { 0xF8E5, 0x60 }, /* RADICAL EXTENDER       # radicalex (CUS) */
1039     { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER        # arrowvertex (CUS) */
1040     { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER      # arrowhorizex (CUS) */
1041     { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF     # registersans (CUS) */
1042     { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF      # copyrightsans (CUS) */
1043     { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF     # trademarksans (CUS) */
1044     { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
1045     { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER    # parenleftex (CUS) */
1046     { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM      # parenleftbt (CUS) */
1047     { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP        # bracketlefttp (CUS) */
1048     { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER   # bracketleftex (CUS) */
1049     { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM     # bracketleftbt (CUS) */
1050     { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
1051     { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
1052     { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM      # braceleftbt (CUS) */
1053     { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
1054     { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER      # integralex (CUS) */
1055     { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP        # parenrighttp (CUS) */
1056     { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER   # parenrightex (CUS) */
1057     { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM     # parenrightbt (CUS) */
1058     { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP       # bracketrighttp (CUS) */
1059     { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER  # bracketrightex (CUS) */
1060     { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM    # bracketrightbt (CUS) */
1061     { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP        # bracerighttp (CUS) */
1062     { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID        # bracerightmid (CUS) */
1063     { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM     # bracerightbt (CUS) */
1064 };
1065
1066 static const FcCharMap AdobeSymbol = {
1067     AdobeSymbolEnt,
1068     sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
1069 };
1070
1071 static const FcFontDecode fcFontDecoders[] = {
1072     { ft_encoding_unicode,      0,              (1 << 21) - 1 },
1073     { ft_encoding_symbol,       &AdobeSymbol,   (1 << 16) - 1 },
1074     { ft_encoding_apple_roman,  &AppleRoman,    (1 << 16) - 1 },
1075 };
1076
1077 #define NUM_DECODE  (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
1078
1079 FcChar32
1080 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
1081 {
1082     int         low, high, mid;
1083     FcChar16    bmp;
1084
1085     low = 0;
1086     high = map->nent - 1;
1087     if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
1088         return ~0;
1089     while (low <= high)
1090     {
1091         mid = (high + low) >> 1;
1092         bmp = map->ent[mid].bmp;
1093         if (ucs4 == bmp)
1094             return (FT_ULong) map->ent[mid].encode;
1095         if (ucs4 < bmp)
1096             high = mid - 1;
1097         else
1098             low = mid + 1;
1099     }
1100     return ~0;
1101 }
1102
1103 FcChar32
1104 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
1105 {
1106     int     i;
1107
1108     for (i = 0; i < map->nent; i++)
1109         if (map->ent[i].encode == private)
1110             return (FcChar32) map->ent[i].bmp;
1111     return ~0;
1112 }
1113
1114 const FcCharMap *
1115 FcFreeTypeGetPrivateMap (FT_Encoding encoding)
1116 {
1117     int i;
1118
1119     for (i = 0; i < NUM_DECODE; i++)
1120         if (fcFontDecoders[i].encoding == encoding)
1121             return fcFontDecoders[i].map;
1122     return 0;
1123 }
1124
1125 /*
1126  * Map a UCS4 glyph to a glyph index.  Use all available encoding
1127  * tables to try and find one that works.  This information is expected
1128  * to be cached by higher levels, so performance isn't critical
1129  */
1130
1131 FT_UInt
1132 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
1133 {
1134     int             initial, offset, decode;
1135     FT_UInt         glyphindex;
1136     FcChar32        charcode;
1137
1138     initial = 0;
1139     /*
1140      * Find the current encoding
1141      */
1142     if (face->charmap)
1143     {
1144         for (; initial < NUM_DECODE; initial++)
1145             if (fcFontDecoders[initial].encoding == face->charmap->encoding)
1146                 break;
1147         if (initial == NUM_DECODE)
1148             initial = 0;
1149     }
1150     /*
1151      * Check each encoding for the glyph, starting with the current one
1152      */
1153     for (offset = 0; offset < NUM_DECODE; offset++)
1154     {
1155         decode = (initial + offset) % NUM_DECODE;
1156         if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
1157             if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
1158                 continue;
1159         if (fcFontDecoders[decode].map)
1160         {
1161             charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
1162             if (charcode == ~0)
1163                 continue;
1164         }
1165         else
1166             charcode = ucs4;
1167         glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
1168         if (glyphindex)
1169             return glyphindex;
1170     }
1171     return 0;
1172 }
1173
1174 static FcBool
1175 FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
1176                       FT_UInt glyph, FcBlanks *blanks)
1177 {
1178     FT_Int          load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
1179     FT_GlyphSlot    slot;
1180
1181     /*
1182      * When using scalable fonts, only report those glyphs
1183      * which can be scaled; otherwise those fonts will
1184      * only be available at some sizes, and never when
1185      * transformed.  Avoid this by simply reporting bitmap-only
1186      * glyphs as missing
1187      */
1188     if (face->face_flags & FT_FACE_FLAG_SCALABLE)
1189         load_flags |= FT_LOAD_NO_BITMAP;
1190
1191     if (FT_Load_Glyph (face, glyph, load_flags))
1192         return FcFalse;
1193
1194     slot = face->glyph;
1195     if (!glyph)
1196         return FcFalse;
1197
1198     switch (slot->format) {
1199     case ft_glyph_format_bitmap:
1200         /*
1201          * Bitmaps are assumed to be reasonable; if
1202          * this proves to be a rash assumption, this
1203          * code can be easily modified
1204          */
1205         return FcTrue;
1206     case ft_glyph_format_outline:
1207         /*
1208          * Glyphs with contours are always OK
1209          */
1210         if (slot->outline.n_contours != 0)
1211             return FcTrue;
1212         /*
1213          * Glyphs with no contours are only OK if
1214          * they're members of the Blanks set specified
1215          * in the configuration.  If blanks isn't set,
1216          * then allow any glyph to be blank
1217          */
1218         if (!blanks || FcBlanksIsMember (blanks, ucs4))
1219             return FcTrue;
1220         /* fall through ... */
1221     default:
1222         break;
1223     }
1224     return FcFalse;
1225 }
1226
1227 FcCharSet *
1228 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
1229 {
1230     FcChar32        page, off, max, ucs4;
1231 #ifdef CHECK
1232     FcChar32        font_max = 0;
1233 #endif
1234     FcCharSet       *fcs;
1235     FcCharLeaf      *leaf;
1236     const FcCharMap *map;
1237     int             o;
1238     int             i;
1239     FT_UInt         glyph;
1240
1241     fcs = FcCharSetCreate ();
1242     if (!fcs)
1243         goto bail0;
1244
1245     for (o = 0; o < NUM_DECODE; o++)
1246     {
1247         if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
1248             continue;
1249         map = fcFontDecoders[o].map;
1250         if (map)
1251         {
1252             /*
1253              * Non-Unicode tables are easy; there's a list of all possible
1254              * characters
1255              */
1256             for (i = 0; i < map->nent; i++)
1257             {
1258                 ucs4 = map->ent[i].bmp;
1259                 glyph = FT_Get_Char_Index (face, map->ent[i].encode);
1260                 if (glyph && FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks))
1261                 {
1262                     leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1263                     if (!leaf)
1264                         goto bail1;
1265                     leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
1266 #ifdef CHECK
1267                     if (ucs4 > font_max)
1268                         font_max = ucs4;
1269 #endif
1270                 }
1271             }
1272         }
1273         else
1274         {
1275             FT_UInt gindex;
1276
1277             max = fcFontDecoders[o].max;
1278             /*
1279              * Find the first encoded character in the font
1280              */
1281             if (FT_Get_Char_Index (face, 0))
1282             {
1283                 ucs4 = 0;
1284                 gindex = 1;
1285             }
1286             else
1287             {
1288                 ucs4 = FT_Get_Next_Char (face, 0, &gindex);
1289                 if (!ucs4)
1290                     gindex = 0;
1291             }
1292
1293             while (gindex)
1294             {
1295                 page = ucs4 >> 8;
1296                 leaf = 0;
1297                 while ((ucs4 >> 8) == page)
1298                 {
1299                     glyph = FT_Get_Char_Index (face, ucs4);
1300                     if (glyph && FcFreeTypeCheckGlyph (face, ucs4,
1301                                                        glyph, blanks))
1302                     {
1303                         if (!leaf)
1304                         {
1305                             leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1306                             if (!leaf)
1307                                 goto bail1;
1308                         }
1309                         off = ucs4 & 0xff;
1310                         leaf->map[off >> 5] |= (1 << (off & 0x1f));
1311 #ifdef CHECK
1312                         if (ucs4 > font_max)
1313                             font_max = ucs4;
1314 #endif
1315                     }
1316                     ucs4++;
1317                 }
1318                 ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
1319                 if (!ucs4)
1320                     gindex = 0;
1321             }
1322 #ifdef CHECK
1323             for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
1324             {
1325                 FcBool      FT_Has, FC_Has;
1326
1327                 FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
1328                 FC_Has = FcCharSetHasChar (fcs, ucs4);
1329                 if (FT_Has != FC_Has)
1330                 {
1331                     printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
1332                 }
1333             }
1334 #endif
1335         }
1336     }
1337 #ifdef CHECK
1338     printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
1339     for (ucs4 = 0; ucs4 <= font_max; ucs4++)
1340     {
1341         FcBool  has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
1342         FcBool  has_bit = FcCharSetHasChar (fcs, ucs4);
1343
1344         if (has_char && !has_bit)
1345             printf ("Bitmap missing char 0x%x\n", ucs4);
1346         else if (!has_char && has_bit)
1347             printf ("Bitmap extra char 0x%x\n", ucs4);
1348     }
1349 #endif
1350     return fcs;
1351 bail1:
1352     FcCharSetDestroy (fcs);
1353 bail0:
1354     return 0;
1355 }
1356