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