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