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