src/fcfreetype.c

   1 /*
   2  * $RCSId: xc/lib/fontconfig/src/fcfreetype.c,v 1.11 2002/08/31 22:17:32 keithp Exp $
   3  *
   4  * Copyright © 2001 Keith Packard
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of Keith Packard not be used in
  11  * advertising or publicity pertaining to distribution of the software without
  12  * specific, written prior permission.  Keith Packard makes no
  13  * representations about the suitability of this software for any purpose.  It
  14  * is provided "as is" without express or implied warranty.
  15  *
  16  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  18  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  22  * PERFORMANCE OF THIS SOFTWARE.
  23  */
  24
  25 /*
  26   Copyright © 2002-2003 by Juliusz Chroboczek
  27
  28   Permission is hereby granted, free of charge, to any person obtaining a copy
  29   of this software and associated documentation files (the "Software"), to deal
  30   in the Software without restriction, including without limitation the rights
  31   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  32   copies of the Software, and to permit persons to whom the Software is
  33   furnished to do so, subject to the following conditions:
  34
  35   The above copyright notice and this permission notice shall be included in
  36   all copies or substantial portions of the Software.
  37
  38   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  39   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  40   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  41   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  42   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  43   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  44   THE SOFTWARE.
  45 */
  46
  47 #include "fcint.h"
  48 #include <stdlib.h>
  49 #include <stdio.h>
  50 #include <string.h>
  51 #include <ft2build.h>
  52 #include FT_FREETYPE_H
  53 #include FT_TRUETYPE_TABLES_H
  54 #include FT_SFNT_NAMES_H
  55 #include FT_TRUETYPE_IDS_H
  56 #include FT_TYPE1_TABLES_H
  57 #if HAVE_FT_GET_X11_FONT_FORMAT
  58 #include FT_XFREE86_H
  59 #endif
  60 #if HAVE_FT_GET_BDF_PROPERTY
  61 #include FT_BDF_H
  62 #include FT_MODULE_H
  63 #endif
  64
  65 #include "ftglue.h"
  66
  67 #if HAVE_WARNING_CPP_DIRECTIVE
  68 #if !HAVE_FT_GET_BDF_PROPERTY
  69 #warning "No FT_Get_BDF_Property: Please install freetype 2.1.4 or later"
  70 #endif
  71
  72 #if !HAVE_FT_GET_PS_FONT_INFO
  73 #warning "No FT_Get_PS_Font_Info: Please install freetype 2.1.1 or later"
  74 #endif
  75 #endif
  76
  77 /*
  78  * Keep Han languages separated by eliminating languages
  79  * that the codePageRange bits says aren't supported
  80  */
  81
  82 static const struct {
  83     char            bit;
  84     const FcChar8   lang[6];
  85 } FcCodePageRange[] = {
  86     { 17,       "ja" },
  87     { 18,       "zh-cn" },
  88     { 19,       "ko" },
  89     { 20,       "zh-tw" },
  90 };
  91
  92 #define NUM_CODE_PAGE_RANGE (int) (sizeof FcCodePageRange / sizeof FcCodePageRange[0])
  93
  94 FcBool
  95 FcFreeTypeIsExclusiveLang (const FcChar8  *lang)
  96 {
  97     int     i;
  98
  99     for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
 100     {
 101         if (FcLangCompare (lang, FcCodePageRange[i].lang) == FcLangEqual)
 102             return FcTrue;
 103     }
 104     return FcFalse;
 105 }
 106
 107 typedef struct {
 108     const FT_UShort     platform_id;
 109     const FT_UShort     encoding_id;
 110     const char  fromcode[12];
 111 } FcFtEncoding;
 112
 113 #define TT_ENCODING_DONT_CARE   0xffff
 114 #define FC_ENCODING_MAC_ROMAN   "MACINTOSH"
 115
 116 static const FcFtEncoding   fcFtEncoding[] = {
 117  {  TT_PLATFORM_APPLE_UNICODE,  TT_ENCODING_DONT_CARE,  "UCS-2BE" },
 118  {  TT_PLATFORM_MACINTOSH,      TT_MAC_ID_ROMAN,        "MACINTOSH" },
 119  {  TT_PLATFORM_MACINTOSH,      TT_MAC_ID_JAPANESE,     "SJIS" },
 120  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_UNICODE_CS,    "UTF-16BE" },
 121  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_SJIS,          "SJIS-WIN" },
 122  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_GB2312,        "GB3212" },
 123  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_BIG_5,         "BIG-5" },
 124  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_WANSUNG,       "Wansung" },
 125  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_JOHAB,         "Johab" },
 126  {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_UCS_4,         "UCS4" },
 127  {  TT_PLATFORM_ISO,            TT_ISO_ID_7BIT_ASCII,   "ASCII" },
 128  {  TT_PLATFORM_ISO,            TT_ISO_ID_10646,        "UCS-2BE" },
 129  {  TT_PLATFORM_ISO,            TT_ISO_ID_8859_1,       "ISO-8859-1" },
 130 };
 131
 132 #define NUM_FC_FT_ENCODING  (int) (sizeof (fcFtEncoding) / sizeof (fcFtEncoding[0]))
 133
 134 typedef struct {
 135     const FT_UShort     platform_id;
 136     const FT_UShort     language_id;
 137     const char  lang[8];
 138 } FcFtLanguage;
 139
 140 #define TT_LANGUAGE_DONT_CARE   0xffff
 141
 142 static const FcFtLanguage   fcFtLanguage[] = {
 143  {  TT_PLATFORM_APPLE_UNICODE,  TT_LANGUAGE_DONT_CARE,              "" },
 144  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ENGLISH,              "en" },
 145  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FRENCH,               "fr" },
 146  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GERMAN,               "de" },
 147  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ITALIAN,              "it" },
 148  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DUTCH,                "nl" },
 149  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SWEDISH,              "sv" },
 150  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SPANISH,              "es" },
 151  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DANISH,               "da" },
 152  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PORTUGUESE,           "pt" },
 153  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_NORWEGIAN,            "no" },
 154  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HEBREW,               "he" },
 155  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_JAPANESE,             "ja" },
 156  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ARABIC,               "ar" },
 157  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FINNISH,              "fi" },
 158  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREEK,                "el" },
 159  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ICELANDIC,            "is" },
 160  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALTESE,              "mt" },
 161  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TURKISH,              "tr" },
 162  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CROATIAN,             "hr" },
 163  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHINESE_TRADITIONAL,  "zh-tw" },
 164  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_URDU,                 "ur" },
 165  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HINDI,                "hi" },
 166  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_THAI,                 "th" },
 167  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KOREAN,               "ko" },
 168  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LITHUANIAN,           "lt" },
 169  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_POLISH,               "pl" },
 170  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HUNGARIAN,            "hu" },
 171  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ESTONIAN,             "et" },
 172  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LETTISH,              "lv" },
 173 /* {  TT_PLATFORM_MACINTOSH,    TT_MAC_LANGID_SAAMISK, ??? */
 174  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FAEROESE,             "fo" },
 175  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FARSI,                "fa" },
 176  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUSSIAN,              "ru" },
 177  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHINESE_SIMPLIFIED,   "zh-cn" },
 178  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FLEMISH,              "nl" },
 179  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH,                "ga" },
 180  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ALBANIAN,             "sq" },
 181  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ROMANIAN,             "ro" },
 182  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CZECH,                "cs" },
 183  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SLOVAK,               "sk" },
 184  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SLOVENIAN,            "sl" },
 185  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_YIDDISH,              "yi" },
 186  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SERBIAN,              "sr" },
 187  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MACEDONIAN,           "mk" },
 188  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BULGARIAN,            "bg" },
 189  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UKRAINIAN,            "uk" },
 190  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BYELORUSSIAN,         "be" },
 191  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UZBEK,                "uz" },
 192  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KAZAKH,               "kk" },
 193  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI,          "az" },
 194  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT, "az" },
 195  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT,    "ar" },
 196  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ARMENIAN,             "hy" },
 197  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GEORGIAN,             "ka" },
 198  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MOLDAVIAN,            "mo" },
 199  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KIRGHIZ,              "ky" },
 200  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAJIKI,               "tg" },
 201  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TURKMEN,              "tk" },
 202  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN,            "mo" },
 203  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT,"mo" },
 204  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT, "mo" },
 205  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PASHTO,               "ps" },
 206  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KURDISH,              "ku" },
 207  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KASHMIRI,             "ks" },
 208  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SINDHI,               "sd" },
 209  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TIBETAN,              "bo" },
 210  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_NEPALI,               "ne" },
 211  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SANSKRIT,             "sa" },
 212  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MARATHI,              "mr" },
 213  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BENGALI,              "bn" },
 214  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ASSAMESE,             "as" },
 215  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GUJARATI,             "gu" },
 216  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PUNJABI,              "pa" },
 217  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ORIYA,                "or" },
 218  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAYALAM,            "ml" },
 219  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KANNADA,              "kn" },
 220  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAMIL,                "ta" },
 221  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TELUGU,               "te" },
 222  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SINHALESE,            "si" },
 223  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BURMESE,              "my" },
 224  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KHMER,                "km" },
 225  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LAO,                  "lo" },
 226  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_VIETNAMESE,           "vi" },
 227  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_INDONESIAN,           "id" },
 228  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAGALOG,              "tl" },
 229  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAY_ROMAN_SCRIPT,   "ms" },
 230  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAY_ARABIC_SCRIPT,  "ms" },
 231  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AMHARIC,              "am" },
 232  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TIGRINYA,             "ti" },
 233  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GALLA,                "om" },
 234  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SOMALI,               "so" },
 235  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SWAHILI,              "sw" },
 236  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUANDA,               "rw" },
 237  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUNDI,                "rn" },
 238  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHEWA,                "ny" },
 239  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAGASY,             "mg" },
 240  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ESPERANTO,            "eo" },
 241  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_WELSH,                "cy" },
 242  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BASQUE,               "eu" },
 243  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CATALAN,              "ca" },
 244  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LATIN,                "la" },
 245  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_QUECHUA,              "qu" },
 246  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GUARANI,              "gn" },
 247  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AYMARA,               "ay" },
 248  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TATAR,                "tt" },
 249  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UIGHUR,               "ug" },
 250  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DZONGKHA,             "dz" },
 251  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_JAVANESE,             "jw" },
 252  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SUNDANESE,            "su" },
 253
 254 #if 0  /* these seem to be errors that have been dropped */
 255
 256  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SCOTTISH_GAELIC },
 257  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH_GAELIC },
 258
 259 #endif
 260
 261   /* The following codes are new as of 2000-03-10 */
 262  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GALICIAN,             "gl" },
 263  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AFRIKAANS,            "af" },
 264  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BRETON,               "br" },
 265  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_INUKTITUT,            "iu" },
 266  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SCOTTISH_GAELIC,      "gd" },
 267  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MANX_GAELIC,          "gv" },
 268  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH_GAELIC,         "ga" },
 269  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TONGAN,               "to" },
 270  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREEK_POLYTONIC,      "el" },
 271  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREELANDIC,           "ik" },
 272  {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT,"az" },
 273
 274  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_SAUDI_ARABIA,       "ar" },
 275  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_IRAQ,               "ar" },
 276  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_EGYPT,              "ar" },
 277  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_LIBYA,              "ar" },
 278  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_ALGERIA,            "ar" },
 279  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_MOROCCO,            "ar" },
 280  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_TUNISIA,            "ar" },
 281  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_OMAN,               "ar" },
 282  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_YEMEN,              "ar" },
 283  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_SYRIA,              "ar" },
 284  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_JORDAN,             "ar" },
 285  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_LEBANON,            "ar" },
 286  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_KUWAIT,             "ar" },
 287  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_UAE,                "ar" },
 288  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_BAHRAIN,            "ar" },
 289  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_QATAR,              "ar" },
 290  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BULGARIAN_BULGARIA,        "bg" },
 291  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CATALAN_SPAIN,             "ca" },
 292  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_TAIWAN,            "zh-tw" },
 293  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_PRC,               "zh-cn" },
 294  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_HONG_KONG,         "zh-hk" },
 295  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_SINGAPORE,         "zh-sg" },
 296
 297  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_MACAU,             "zh-mo" },
 298
 299  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CZECH_CZECH_REPUBLIC,      "cs" },
 300  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DANISH_DENMARK,            "da" },
 301  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_GERMANY,            "de" },
 302  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_SWITZERLAND,        "de" },
 303  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_AUSTRIA,            "de" },
 304  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_LUXEMBOURG,         "de" },
 305  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_LIECHTENSTEI,       "de" },
 306  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GREEK_GREECE,              "el" },
 307  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_UNITED_STATES,     "en" },
 308  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_UNITED_KINGDOM,    "en" },
 309  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_AUSTRALIA,         "en" },
 310  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_CANADA,            "en" },
 311  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_NEW_ZEALAND,       "en" },
 312  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_IRELAND,           "en" },
 313  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_SOUTH_AFRICA,      "en" },
 314  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_JAMAICA,           "en" },
 315  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_CARIBBEAN,         "en" },
 316  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_BELIZE,            "en" },
 317  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_TRINIDAD,          "en" },
 318  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_ZIMBABWE,          "en" },
 319  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_PHILIPPINES,       "en" },
 320  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT,"es" },
 321  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_MEXICO,            "es" },
 322  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT,"es" },
 323  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_GUATEMALA,         "es" },
 324  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_COSTA_RICA,        "es" },
 325  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PANAMA,            "es" },
 326  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC,"es" },
 327  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_VENEZUELA,         "es" },
 328  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_COLOMBIA,          "es" },
 329  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PERU,              "es" },
 330  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_ARGENTINA,         "es" },
 331  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_ECUADOR,           "es" },
 332  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_CHILE,             "es" },
 333  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_URUGUAY,           "es" },
 334  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PARAGUAY,          "es" },
 335  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_BOLIVIA,           "es" },
 336  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_EL_SALVADOR,       "es" },
 337  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_HONDURAS,          "es" },
 338  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_NICARAGUA,         "es" },
 339  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PUERTO_RICO,       "es" },
 340  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FINNISH_FINLAND,           "fi" },
 341  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_FRANCE,             "fr" },
 342  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_BELGIUM,            "fr" },
 343  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CANADA,             "fr" },
 344  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_SWITZERLAND,        "fr" },
 345  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_LUXEMBOURG,         "fr" },
 346  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MONACO,             "fr" },
 347  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HEBREW_ISRAEL,             "he" },
 348  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HUNGARIAN_HUNGARY,         "hu" },
 349  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ICELANDIC_ICELAND,         "is" },
 350  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ITALIAN_ITALY,             "it" },
 351  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ITALIAN_SWITZERLAND,       "it" },
 352  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_JAPANESE_JAPAN,            "ja" },
 353  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA,"ko" },
 354  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KOREAN_JOHAB_KOREA,        "ko" },
 355  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DUTCH_NETHERLANDS,         "nl" },
 356  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DUTCH_BELGIUM,             "nl" },
 357  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL,   "no" },
 358  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK,  "nn" },
 359  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_POLISH_POLAND,             "pl" },
 360  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PORTUGUESE_BRAZIL,         "pt" },
 361  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PORTUGUESE_PORTUGAL,       "pt" },
 362  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND,"rm" },
 363  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ROMANIAN_ROMANIA,          "ro" },
 364  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MOLDAVIAN_MOLDAVIA,        "mo" },
 365  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RUSSIAN_RUSSIA,            "ru" },
 366  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RUSSIAN_MOLDAVIA,          "ru" },
 367  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CROATIAN_CROATIA,          "hr" },
 368  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SERBIAN_SERBIA_LATIN,      "sr" },
 369  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC,   "sr" },
 370  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SLOVAK_SLOVAKIA,           "sk" },
 371  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ALBANIAN_ALBANIA,          "sq" },
 372  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWEDISH_SWEDEN,            "sv" },
 373  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWEDISH_FINLAND,           "sv" },
 374  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_THAI_THAILAND,             "th" },
 375  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TURKISH_TURKEY,            "tr" },
 376  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_URDU_PAKISTAN,             "ur" },
 377  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_INDONESIAN_INDONESIA,      "id" },
 378  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UKRAINIAN_UKRAINE,         "uk" },
 379  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BELARUSIAN_BELARUS,        "be" },
 380  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SLOVENE_SLOVENIA,          "sl" },
 381  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ESTONIAN_ESTONIA,          "et" },
 382  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LATVIAN_LATVIA,            "lv" },
 383  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LITHUANIAN_LITHUANIA,      "lt" },
 384  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA,"lt" },
 385
 386 #ifdef TT_MS_LANGID_MAORI_NEW_ZELAND
 387     /* this seems to be an error that have been dropped */
 388  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MAORI_NEW_ZEALAND,         "mi" },
 389 #endif
 390
 391  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FARSI_IRAN,                "fa" },
 392  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_VIETNAMESE_VIET_NAM,       "vi" },
 393  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARMENIAN_ARMENIA,          "hy" },
 394  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN,    "az" },
 395  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC, "az" },
 396  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BASQUE_SPAIN,              "eu" },
 397  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SORBIAN_GERMANY,           "wen" },
 398  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MACEDONIAN_MACEDONIA,      "mk" },
 399  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SUTU_SOUTH_AFRICA,         "st" },
 400  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TSONGA_SOUTH_AFRICA,       "ts" },
 401  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TSWANA_SOUTH_AFRICA,       "tn" },
 402  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_VENDA_SOUTH_AFRICA,        "ven" },
 403  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_XHOSA_SOUTH_AFRICA,        "xh" },
 404  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ZULU_SOUTH_AFRICA,         "zu" },
 405  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA,    "af" },
 406  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GEORGIAN_GEORGIA,          "ka" },
 407  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS,   "fo" },
 408  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HINDI_INDIA,               "hi" },
 409  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALTESE_MALTA,             "mt" },
 410  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SAAMI_LAPONIA,             "se" },
 411
 412  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM,"gd" },
 413  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IRISH_GAELIC_IRELAND,      "ga" },
 414
 415  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAY_MALAYSIA,            "ms" },
 416  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM,   "ms" },
 417  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KAZAK_KAZAKSTAN,           "kk" },
 418  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWAHILI_KENYA,             "sw" },
 419  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN,    "uz" },
 420  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC, "uz" },
 421  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TATAR_TATARSTAN,           "tt" },
 422  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BENGALI_INDIA,             "bn" },
 423  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PUNJABI_INDIA,             "pa" },
 424  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GUJARATI_INDIA,            "gu" },
 425  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ORIYA_INDIA,               "or" },
 426  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMIL_INDIA,               "ta" },
 427  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TELUGU_INDIA,              "te" },
 428  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KANNADA_INDIA,             "kn" },
 429  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAYALAM_INDIA,           "ml" },
 430  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ASSAMESE_INDIA,            "as" },
 431  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MARATHI_INDIA,             "mr" },
 432  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SANSKRIT_INDIA,            "sa" },
 433  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KONKANI_INDIA,             "kok" },
 434
 435   /* new as of 2001-01-01 */
 436  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_GENERAL,            "ar" },
 437  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_GENERAL,           "zh" },
 438  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_GENERAL,           "en" },
 439  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_WEST_INDIES,        "fr" },
 440  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_REUNION,            "fr" },
 441  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CONGO,              "fr" },
 442
 443  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_SENEGAL,            "fr" },
 444  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CAMEROON,           "fr" },
 445  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_COTE_D_IVOIRE,      "fr" },
 446  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MALI,               "fr" },
 447  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA,"bs" },
 448  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_URDU_INDIA,                "ur" },
 449  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAJIK_TAJIKISTAN,          "tg" },
 450  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YIDDISH_GERMANY,           "yi" },
 451  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN,       "ky" },
 452
 453  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TURKMEN_TURKMENISTAN,      "tk" },
 454  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MONGOLIAN_MONGOLIA,        "mn" },
 455
 456   /* the following seems to be inconsistent;
 457      here is the current "official" way: */
 458  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIBETAN_BHUTAN,            "bo" },
 459   /* and here is what is used by Passport SDK */
 460  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIBETAN_CHINA,             "bo" },
 461  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DZONGHKA_BHUTAN,           "dz" },
 462   /* end of inconsistency */
 463
 464  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_WELSH_WALES,               "cy" },
 465  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KHMER_CAMBODIA,            "km" },
 466  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LAO_LAOS,                  "lo" },
 467  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BURMESE_MYANMAR,           "my" },
 468  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GALICIAN_SPAIN,            "gl" },
 469  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MANIPURI_INDIA,            "mni" },
 470  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SINDHI_INDIA,              "sd" },
 471   /* the following one is only encountered in Microsoft RTF specification */
 472  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KASHMIRI_PAKISTAN,         "ks" },
 473   /* the following one is not in the Passport list, looks like an omission */
 474  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KASHMIRI_INDIA,            "ks" },
 475  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NEPALI_NEPAL,              "ne" },
 476  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NEPALI_INDIA,              "ne" },
 477  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRISIAN_NETHERLANDS,       "fy" },
 478
 479   /* new as of 2001-03-01 (from Office Xp) */
 480  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_HONG_KONG,         "en" },
 481  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_INDIA,             "en" },
 482  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_MALAYSIA,          "en" },
 483  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_SINGAPORE,         "en" },
 484  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SYRIAC_SYRIA,              "syr" },
 485  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SINHALESE_SRI_LANKA,       "si" },
 486  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHEROKEE_UNITED_STATES,    "chr" },
 487  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_INUKTITUT_CANADA,          "iu" },
 488  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AMHARIC_ETHIOPIA,          "am" },
 489 #if 0
 490  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMAZIGHT_MOROCCO },
 491  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN },
 492 #endif
 493  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PASHTO_AFGHANISTAN,        "ps" },
 494  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FILIPINO_PHILIPPINES,      "phi" },
 495  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DHIVEHI_MALDIVES,          "div" },
 496
 497  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_OROMO_ETHIOPIA,            "om" },
 498  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIGRIGNA_ETHIOPIA,         "ti" },
 499  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIGRIGNA_ERYTHREA,         "ti" },
 500
 501   /* New additions from Windows Xp/Passport SDK 2001-11-10. */
 502
 503   /* don't ask what this one means... It is commented out currently. */
 504 #if 0
 505  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GREEK_GREECE2 },
 506 #endif
 507
 508  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_UNITED_STATES,     "es" },
 509   /* The following two IDs blatantly violate MS specs by using a */
 510   /* sublanguage >,.                                         */
 511  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_LATIN_AMERICA,     "es" },
 512  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_NORTH_AFRICA,       "fr" },
 513
 514  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MOROCCO,            "fr" },
 515  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_HAITI,              "fr" },
 516  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BENGALI_BANGLADESH,        "bn" },
 517  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN,   "ar" },
 518  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN,"mn" },
 519 #if 0
 520  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_EDO_NIGERIA },
 521  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FULFULDE_NIGERIA },
 522  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IBIBIO_NIGERIA },
 523 #endif
 524  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HAUSA_NIGERIA,             "ha" },
 525  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YORUBA_NIGERIA,            "yo" },
 526   /* language codes from, to, are (still) unknown. */
 527  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IGBO_NIGERIA,              "ibo" },
 528  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KANURI_NIGERIA,            "kau" },
 529  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GUARANI_PARAGUAY,          "gn" },
 530  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HAWAIIAN_UNITED_STATES,    "haw" },
 531  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LATIN,                     "la" },
 532  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SOMALI_SOMALIA,            "so" },
 533 #if 0
 534   /* Note: Yi does not have a (proper) ISO 639-2 code, since it is mostly */
 535   /*       not written (but OTOH the peculiar writing system is worth     */
 536   /*       studying).                                                     */
 537  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YI_CHINA },
 538 #endif
 539  {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES,"pap" },
 540 };
 541
 542 #define NUM_FC_FT_LANGUAGE  (int) (sizeof (fcFtLanguage) / sizeof (fcFtLanguage[0]))
 543
 544 typedef struct {
 545     FT_UShort   language_id;
 546     char        fromcode[12];
 547 } FcMacRomanFake;
 548
 549 static const FcMacRomanFake fcMacRomanFake[] = {
 550  {  TT_MS_LANGID_JAPANESE_JAPAN,        "SJIS-WIN" },
 551  {  TT_MS_LANGID_ENGLISH_UNITED_STATES, "ASCII" },
 552 };
 553
 554 static FcChar8 *
 555 FcFontCapabilities(FT_Face face);
 556
 557 #define NUM_FC_MAC_ROMAN_FAKE   (int) (sizeof (fcMacRomanFake) / sizeof (fcMacRomanFake[0]))
 558
 559 #if USE_ICONV
 560 #include <iconv.h>
 561 #endif
 562
 563 /*
 564  * A shift-JIS will have many high bits turned on
 565  */
 566 static FcBool
 567 FcLooksLikeSJIS (FcChar8 *string, int len)
 568 {
 569     int     nhigh = 0, nlow = 0;
 570
 571     while (len-- > 0)
 572     {
 573         if (*string++ & 0x80) nhigh++;
 574         else nlow++;
 575     }
 576     /*
 577      * Heuristic -- if more than 1/3 of the bytes have the high-bit set,
 578      * this is likely to be SJIS and not ROMAN
 579      */
 580     if (nhigh * 2 > nlow)
 581         return FcTrue;
 582     return FcFalse;
 583 }
 584
 585 static FcChar8 *
 586 FcSfntNameTranscode (FT_SfntName *sname)
 587 {
 588     int        i;
 589     const char *fromcode;
 590 #if USE_ICONV
 591     iconv_t cd;
 592 #endif
 593     FcChar8 *utf8;
 594
 595     for (i = 0; i < NUM_FC_FT_ENCODING; i++)
 596         if (fcFtEncoding[i].platform_id == sname->platform_id &&
 597             (fcFtEncoding[i].encoding_id == TT_ENCODING_DONT_CARE ||
 598              fcFtEncoding[i].encoding_id == sname->encoding_id))
 599             break;
 600     if (i == NUM_FC_FT_ENCODING)
 601         return 0;
 602     fromcode = fcFtEncoding[i].fromcode;
 603
 604     /*
 605      * Many names encoded for TT_PLATFORM_MACINTOSH are broken
 606      * in various ways. Kludge around them.
 607      */
 608     if (!strcmp (fromcode, FC_ENCODING_MAC_ROMAN))
 609     {
 610         if (sname->language_id == TT_MAC_LANGID_ENGLISH &&
 611             FcLooksLikeSJIS (sname->string, sname->string_len))
 612         {
 613             fromcode = "SJIS";
 614         }
 615         else if (sname->language_id >= 0x100)
 616         {
 617             /*
 618              * "real" Mac language IDs are all less than 150.
 619              * Names using one of the MS language IDs are assumed
 620              * to use an associated encoding (Yes, this is a kludge)
 621              */
 622             int f;
 623
 624             fromcode = NULL;
 625             for (f = 0; f < NUM_FC_MAC_ROMAN_FAKE; f++)
 626                 if (fcMacRomanFake[f].language_id == sname->language_id)
 627                 {
 628                     fromcode = fcMacRomanFake[f].fromcode;
 629                     break;
 630                 }
 631             if (!fromcode)
 632                 return 0;
 633         }
 634     }
 635     if (!strcmp (fromcode, "UCS-2BE") || !strcmp (fromcode, "UTF-16BE"))
 636     {
 637         FcChar8     *src = sname->string;
 638         int         src_len = sname->string_len;
 639         int         len;
 640         int         wchar;
 641         int         ilen, olen;
 642         FcChar8     *u8;
 643         FcChar32    ucs4;
 644
 645         /*
 646          * Convert Utf16 to Utf8
 647          */
 648
 649         if (!FcUtf16Len (src, FcEndianBig, src_len, &len, &wchar))
 650             return 0;
 651
 652         /*
 653          * Allocate plenty of space.  Freed below
 654          */
 655         utf8 = malloc (len * FC_UTF8_MAX_LEN + 1);
 656         if (!utf8)
 657             return 0;
 658
 659         u8 = utf8;
 660
 661         while ((ilen = FcUtf16ToUcs4 (src, FcEndianBig, &ucs4, src_len)) > 0)
 662         {
 663             src_len -= ilen;
 664             src += ilen;
 665             olen = FcUcs4ToUtf8 (ucs4, u8);
 666             u8 += olen;
 667         }
 668         *u8 = '\0';
 669         goto done;
 670     }
 671     if (!strcmp (fromcode, "ASCII") || !strcmp (fromcode, "ISO-8859-1"))
 672     {
 673         FcChar8     *src = sname->string;
 674         int         src_len = sname->string_len;
 675         int         olen;
 676         FcChar8     *u8;
 677         FcChar32    ucs4;
 678
 679         /*
 680          * Convert Latin1 to Utf8. Freed below
 681          */
 682         utf8 = malloc (src_len * 2 + 1);
 683         if (!utf8)
 684             return 0;
 685
 686         u8 = utf8;
 687         while (src_len > 0)
 688         {
 689             ucs4 = *src++;
 690             src_len--;
 691             olen = FcUcs4ToUtf8 (ucs4, u8);
 692             u8 += olen;
 693         }
 694         *u8 = '\0';
 695         goto done;
 696     }
 697     if (!strcmp (fromcode, FC_ENCODING_MAC_ROMAN))
 698     {
 699         FcChar8         *u8;
 700         const FcCharMap *map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
 701         FcChar8         *src = (FcChar8 *) sname->string;
 702         int             src_len = sname->string_len;
 703
 704         /*
 705          * Convert AppleRoman to Utf8
 706          */
 707         if (!map)
 708             return 0;
 709
 710         utf8 = malloc (sname->string_len * 3 + 1);
 711         if (!utf8)
 712             return 0;
 713
 714         u8 = utf8;
 715         while (src_len > 0)
 716         {
 717             FcChar32    ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
 718             int         olen = FcUcs4ToUtf8 (ucs4, u8);
 719             src_len--;
 720             u8 += olen;
 721         }
 722         *u8 = '\0';
 723         goto done;
 724     }
 725 #if USE_ICONV
 726     cd = iconv_open ("UTF-8", fromcode);
 727     if (cd && cd != (iconv_t) (-1))
 728     {
 729         size_t      in_bytes_left = sname->string_len;
 730         size_t      out_bytes_left = sname->string_len * FC_UTF8_MAX_LEN;
 731         char        *inbuf, *outbuf;
 732
 733         utf8 = malloc (out_bytes_left + 1);
 734         if (!utf8)
 735         {
 736             iconv_close (cd);
 737             return 0;
 738         }
 739
 740         outbuf = (char *) utf8;
 741         inbuf = (char *) sname->string;
 742
 743         while (in_bytes_left)
 744         {
 745             size_t      did = iconv (cd,
 746                                  &inbuf, &in_bytes_left,
 747                                  &outbuf, &out_bytes_left);
 748             if (did == (size_t) (-1))
 749             {
 750                 iconv_close (cd);
 751                 free (utf8);
 752                 return 0;
 753             }
 754         }
 755         iconv_close (cd);
 756         *outbuf = '\0';
 757         goto done;
 758     }
 759 #endif
 760     return 0;
 761 done:
 762     if (FcStrCmpIgnoreBlanksAndCase (utf8, (FcChar8 *) "") == 0)
 763     {
 764         free (utf8);
 765         return 0;
 766     }
 767     return utf8;
 768 }
 769
 770 static const FcChar8 *
 771 FcSfntNameLanguage (FT_SfntName *sname)
 772 {
 773     int i;
 774     FT_UShort   platform_id = sname->platform_id;
 775     FT_UShort   language_id = sname->language_id;
 776
 777     /*
 778      * Many names encoded for TT_PLATFORM_MACINTOSH are broken
 779      * in various ways. Kludge around them.
 780      */
 781     if (platform_id == TT_PLATFORM_MACINTOSH &&
 782         sname->encoding_id == TT_MAC_ID_ROMAN &&
 783         FcLooksLikeSJIS (sname->string, sname->string_len))
 784     {
 785         language_id = TT_MAC_LANGID_JAPANESE;
 786     }
 787
 788     for (i = 0; i < NUM_FC_FT_LANGUAGE; i++)
 789         if (fcFtLanguage[i].platform_id == platform_id &&
 790             (fcFtLanguage[i].language_id == TT_LANGUAGE_DONT_CARE ||
 791              fcFtLanguage[i].language_id == language_id))
 792         {
 793             if (fcFtLanguage[i].lang[0] == '\0')
 794               return NULL;
 795             else
 796               return (FcChar8 *) fcFtLanguage[i].lang;
 797         }
 798     return 0;
 799 }
 800
 801 /* Order is significant.  For example, some B&H fonts are hinted by
 802    URW++, and both strings appear in the notice. */
 803
 804 static const struct {
 805     const FT_String *notice;
 806     const FcChar8   *foundry;
 807 } FcNoticeFoundries[] = {
 808     { (const FT_String *) "Bigelow",    (const FcChar8 *) "b&h" },
 809     { (const FT_String *) "Adobe",      (const FcChar8 *) "adobe" },
 810     { (const FT_String *) "Bitstream",  (const FcChar8 *) "bitstream" },
 811     { (const FT_String *) "Monotype",   (const FcChar8 *) "monotype" },
 812     { (const FT_String *) "Linotype",   (const FcChar8 *) "linotype" },
 813     { (const FT_String *) "LINOTYPE-HELL",
 814                                         (const FcChar8 *) "linotype" },
 815     { (const FT_String *) "IBM",        (const FcChar8 *) "ibm" },
 816     { (const FT_String *) "URW",        (const FcChar8 *) "urw" },
 817     { (const FT_String *) "International Typeface Corporation",
 818                                         (const FcChar8 *) "itc" },
 819     { (const FT_String *) "Tiro Typeworks",
 820                                         (const FcChar8 *) "tiro" },
 821     { (const FT_String *) "XFree86",    (const FcChar8 *) "xfree86" },
 822     { (const FT_String *) "Microsoft",  (const FcChar8 *) "microsoft" },
 823     { (const FT_String *) "Omega",      (const FcChar8 *) "omega" },
 824     { (const FT_String *) "Font21",     (const FcChar8 *) "hwan" },
 825     { (const FT_String *) "HanYang System",
 826                                         (const FcChar8 *) "hanyang" }
 827 };
 828
 829 #define NUM_NOTICE_FOUNDRIES    (int) (sizeof (FcNoticeFoundries) / sizeof (FcNoticeFoundries[0]))
 830
 831 static const FcChar8 *
 832 FcNoticeFoundry(const FT_String *notice)
 833 {
 834     int i;
 835
 836     if (notice)
 837         for(i = 0; i < NUM_NOTICE_FOUNDRIES; i++)
 838             if (strstr ((const char *) notice, (const char *) FcNoticeFoundries[i].notice))
 839                 return FcNoticeFoundries[i].foundry;
 840     return 0;
 841 }
 842
 843 static FcBool
 844 FcVendorMatch(const FT_Char vendor[4], const FT_Char *vendor_string)
 845 {
 846     /* vendor is not necessarily NUL-terminated. */
 847     int i, len;
 848
 849     len = strlen((char *) vendor_string);
 850     if (memcmp(vendor, vendor_string, len) != 0)
 851         return FcFalse;
 852     for (i = len; i < 4; i++)
 853         if (vendor[i] != ' ' && vendor[i] != '\0')
 854             return FcFalse;
 855     return FcTrue;
 856 }
 857
 858 /* This table is partly taken from ttmkfdir by Joerg Pommnitz. */
 859
 860 /* It should not contain useless entries (such as UNKN) nor duplicate
 861    entries for padding both with spaces and NULs. */
 862
 863 static const struct {
 864     const FT_Char   *vendor;
 865     const FcChar8   *foundry;
 866 } FcVendorFoundries[] = {
 867     { (const FT_Char *) "ADBE", (const FcChar8 *) "adobe"},
 868     { (const FT_Char *) "AGFA", (const FcChar8 *) "agfa"},
 869     { (const FT_Char *) "ALTS", (const FcChar8 *) "altsys"},
 870     { (const FT_Char *) "APPL", (const FcChar8 *) "apple"},
 871     { (const FT_Char *) "ARPH", (const FcChar8 *) "arphic"},
 872     { (const FT_Char *) "ATEC", (const FcChar8 *) "alltype"},
 873     { (const FT_Char *) "B&H",  (const FcChar8 *) "b&h"},
 874     { (const FT_Char *) "BITS", (const FcChar8 *) "bitstream"},
 875     { (const FT_Char *) "CANO", (const FcChar8 *) "cannon"},
 876     { (const FT_Char *) "DYNA", (const FcChar8 *) "dynalab"},
 877     { (const FT_Char *) "EPSN", (const FcChar8 *) "epson"},
 878     { (const FT_Char *) "FJ",   (const FcChar8 *) "fujitsu"},
 879     { (const FT_Char *) "IBM",  (const FcChar8 *) "ibm"},
 880     { (const FT_Char *) "ITC",  (const FcChar8 *) "itc"},
 881     { (const FT_Char *) "IMPR", (const FcChar8 *) "impress"},
 882     { (const FT_Char *) "LARA", (const FcChar8 *) "larabiefonts"},
 883     { (const FT_Char *) "LEAF", (const FcChar8 *) "interleaf"},
 884     { (const FT_Char *) "LETR", (const FcChar8 *) "letraset"},
 885     { (const FT_Char *) "LINO", (const FcChar8 *) "linotype"},
 886     { (const FT_Char *) "MACR", (const FcChar8 *) "macromedia"},
 887     { (const FT_Char *) "MONO", (const FcChar8 *) "monotype"},
 888     { (const FT_Char *) "MS",   (const FcChar8 *) "microsoft"},
 889     { (const FT_Char *) "MT",   (const FcChar8 *) "monotype"},
 890     { (const FT_Char *) "NEC",  (const FcChar8 *) "nec"},
 891     { (const FT_Char *) "PARA", (const FcChar8 *) "paratype"},
 892     { (const FT_Char *) "QMSI", (const FcChar8 *) "qms"},
 893     { (const FT_Char *) "RICO", (const FcChar8 *) "ricoh"},
 894     { (const FT_Char *) "URW",  (const FcChar8 *) "urw"},
 895     { (const FT_Char *) "Y&Y",  (const FcChar8 *) "y&y"}
 896 };
 897
 898 #define NUM_VENDOR_FOUNDRIES    (int) (sizeof (FcVendorFoundries) / sizeof (FcVendorFoundries[0]))
 899
 900 static const FcChar8 *
 901 FcVendorFoundry(const FT_Char vendor[4])
 902 {
 903     int i;
 904
 905     if (vendor)
 906         for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++)
 907             if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor))
 908                 return FcVendorFoundries[i].foundry;
 909     return 0;
 910 }
 911
 912 typedef struct _FcStringConst {
 913     const FcChar8   *name;
 914     int             value;
 915 } FcStringConst;
 916
 917 static int
 918 FcStringIsConst (const FcChar8          *string,
 919                  const FcStringConst    *c,
 920                  int                    nc)
 921 {
 922     int i;
 923
 924     for (i = 0; i < nc; i++)
 925         if (FcStrCmpIgnoreBlanksAndCase (string, c[i].name) == 0)
 926             return c[i].value;
 927     return -1;
 928 }
 929
 930 static int
 931 FcStringContainsConst (const FcChar8        *string,
 932                        const FcStringConst  *c,
 933                        int                  nc)
 934 {
 935     int i;
 936
 937     for (i = 0; i < nc; i++)
 938         if (FcStrContainsIgnoreBlanksAndCase (string, c[i].name))
 939             return c[i].value;
 940     return -1;
 941 }
 942
 943 typedef FcChar8 *FC8;
 944
 945 static const FcStringConst  weightConsts[] = {
 946     { (FC8) "thin",             FC_WEIGHT_THIN },
 947     { (FC8) "extralight",       FC_WEIGHT_EXTRALIGHT },
 948     { (FC8) "ultralight",       FC_WEIGHT_ULTRALIGHT },
 949     { (FC8) "light",            FC_WEIGHT_LIGHT },
 950     { (FC8) "book",             FC_WEIGHT_BOOK },
 951     { (FC8) "regular",          FC_WEIGHT_REGULAR },
 952     { (FC8) "normal",           FC_WEIGHT_NORMAL },
 953     { (FC8) "medium",           FC_WEIGHT_MEDIUM },
 954     { (FC8) "demibold",         FC_WEIGHT_DEMIBOLD },
 955     { (FC8) "demi",             FC_WEIGHT_DEMIBOLD },
 956     { (FC8) "semibold",         FC_WEIGHT_SEMIBOLD },
 957     { (FC8) "extrabold",        FC_WEIGHT_EXTRABOLD },
 958     { (FC8) "superbold",        FC_WEIGHT_EXTRABOLD },
 959     { (FC8) "ultrabold",        FC_WEIGHT_ULTRABOLD },
 960     { (FC8) "bold",             FC_WEIGHT_BOLD },
 961     { (FC8) "black",            FC_WEIGHT_BLACK },
 962     { (FC8) "heavy",            FC_WEIGHT_HEAVY },
 963 };
 964
 965 #define NUM_WEIGHT_CONSTS  (int) (sizeof (weightConsts) / sizeof (weightConsts[0]))
 966
 967 #define FcIsWeight(s)       FcStringIsConst(s,weightConsts,NUM_WEIGHT_CONSTS)
 968 #define FcContainsWeight(s) FcStringContainsConst (s,weightConsts,NUM_WEIGHT_CONSTS)
 969
 970 static const FcStringConst  widthConsts[] = {
 971     { (FC8) "ultracondensed",   FC_WIDTH_ULTRACONDENSED },
 972     { (FC8) "extracondensed",   FC_WIDTH_EXTRACONDENSED },
 973     { (FC8) "semicondensed",    FC_WIDTH_SEMICONDENSED },
 974     { (FC8) "condensed",        FC_WIDTH_CONDENSED },   /* must be after *condensed */
 975     { (FC8) "normal",           FC_WIDTH_NORMAL },
 976     { (FC8) "semiexpanded",     FC_WIDTH_SEMIEXPANDED },
 977     { (FC8) "extraexpanded",    FC_WIDTH_EXTRAEXPANDED },
 978     { (FC8) "ultraexpanded",    FC_WIDTH_ULTRAEXPANDED },
 979     { (FC8) "expanded",         FC_WIDTH_EXPANDED },    /* must be after *expanded */
 980 };
 981
 982 #define NUM_WIDTH_CONSTS    (int) (sizeof (widthConsts) / sizeof (widthConsts[0]))
 983
 984 #define FcIsWidth(s)        FcStringIsConst(s,widthConsts,NUM_WIDTH_CONSTS)
 985 #define FcContainsWidth(s)  FcStringContainsConst (s,widthConsts,NUM_WIDTH_CONSTS)
 986
 987 static const FcStringConst  slantConsts[] = {
 988     { (FC8) "italic",           FC_SLANT_ITALIC },
 989     { (FC8) "kursiv",           FC_SLANT_ITALIC },
 990     { (FC8) "oblique",          FC_SLANT_OBLIQUE },
 991 };
 992
 993 #define NUM_SLANT_CONSTS    (int) (sizeof (slantConsts) / sizeof (slantConsts[0]))
 994
 995 #define FcIsSlant(s)        FcStringIsConst(s,slantConsts,NUM_SLANT_CONSTS)
 996 #define FcContainsSlant(s)  FcStringContainsConst (s,slantConsts,NUM_SLANT_CONSTS)
 997
 998 static const FcStringConst  decorativeConsts[] = {
 999     { (FC8) "shadow",           FcTrue },
1000     { (FC8) "smallcaps",        FcTrue },
1001     { (FC8) "antiqua",          FcTrue },
1002     { (FC8) "romansc",          FcTrue },
1003     { (FC8) "embosed",          FcTrue },
1004     { (FC8) "romansmallcaps",   FcTrue },
1005 };
1006
1007 #define NUM_DECORATIVE_CONSTS   (int) (sizeof (decorativeConsts) / sizeof (decorativeConsts[0]))
1008
1009 #define FcIsDecorative(s)   FcStringIsConst(s,decorativeConsts,NUM_DECORATIVE_CONSTS)
1010 #define FcContainsDecorative(s) FcStringContainsConst (s,decorativeConsts,NUM_DECORATIVE_CONSTS)
1011
1012 static double
1013 FcGetPixelSize (FT_Face face, int i)
1014 {
1015 #if HAVE_FT_GET_BDF_PROPERTY
1016     if (face->num_fixed_sizes == 1)
1017     {
1018         BDF_PropertyRec prop;
1019         int             rc;
1020
1021         rc = FT_Get_BDF_Property (face, "PIXEL_SIZE", &prop);
1022         if (rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1023             return (double) prop.u.integer;
1024     }
1025 #endif
1026 #if HAVE_FT_BITMAP_SIZE_Y_PPEM
1027     return (double) face->available_sizes[i].y_ppem / 64.0;
1028 #else
1029     return (double) face->available_sizes[i].height;
1030 #endif
1031 }
1032
1033 static FcBool
1034 FcStringInPatternElement (FcPattern *pat, const char *elt, FcChar8 *string)
1035 {
1036     int     e;
1037     FcChar8 *old;
1038     for (e = 0; FcPatternGetString (pat, elt, e, &old) == FcResultMatch; e++)
1039         if (!FcStrCmpIgnoreBlanksAndCase (old, string))
1040         {
1041             return FcTrue;
1042         }
1043     return FcFalse;
1044 }
1045
1046 static const FT_UShort platform_order[] = {
1047     TT_PLATFORM_MICROSOFT,
1048     TT_PLATFORM_APPLE_UNICODE,
1049     TT_PLATFORM_MACINTOSH,
1050 };
1051 #define NUM_PLATFORM_ORDER (sizeof (platform_order) / sizeof (platform_order[0]))
1052
1053 static const FT_UShort nameid_order[] = {
1054     TT_NAME_ID_PREFERRED_FAMILY,
1055     TT_NAME_ID_FONT_FAMILY,
1056     TT_NAME_ID_MAC_FULL_NAME,
1057     TT_NAME_ID_FULL_NAME,
1058     TT_NAME_ID_PREFERRED_SUBFAMILY,
1059     TT_NAME_ID_FONT_SUBFAMILY,
1060     TT_NAME_ID_TRADEMARK,
1061     TT_NAME_ID_MANUFACTURER,
1062 };
1063
1064 #define NUM_NAMEID_ORDER  (sizeof (nameid_order) / sizeof (nameid_order[0]))
1065 FcPattern *
1066 FcFreeTypeQueryFace (const FT_Face  face,
1067                      const FcChar8  *file,
1068                      int            id,
1069                      FcBlanks       *blanks)
1070 {
1071     FcPattern       *pat;
1072     int             slant = -1;
1073     int             weight = -1;
1074     int             width = -1;
1075     FcBool          decorative = FcFalse;
1076     int             i;
1077     FcCharSet       *cs;
1078     FcLangSet       *ls;
1079 #if 0
1080     FcChar8         *family = 0;
1081 #endif
1082     FcChar8         *complex;
1083     const FcChar8   *foundry = 0;
1084     int             spacing;
1085     TT_OS2          *os2;
1086 #if HAVE_FT_GET_PS_FONT_INFO
1087     PS_FontInfoRec  psfontinfo;
1088 #endif
1089 #if HAVE_FT_GET_BDF_PROPERTY
1090     BDF_PropertyRec prop;
1091 #endif
1092     TT_Header       *head;
1093     const FcChar8   *exclusiveLang = 0;
1094     FT_SfntName     sname;
1095     FT_UInt         snamei, snamec;
1096
1097     int             nfamily = 0;
1098     int             nfamily_lang = 0;
1099     int             nstyle = 0;
1100     int             nstyle_lang = 0;
1101     int             nfullname = 0;
1102     int             nfullname_lang = 0;
1103     int             p, platform;
1104     int             n, nameid;
1105
1106     FcChar8         *style = 0;
1107     int             st;
1108
1109     pat = FcPatternCreate ();
1110     if (!pat)
1111         goto bail0;
1112
1113     if (!FcPatternAddBool (pat, FC_OUTLINE,
1114                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
1115         goto bail1;
1116
1117     if (!FcPatternAddBool (pat, FC_SCALABLE,
1118                            (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
1119         goto bail1;
1120
1121
1122     /*
1123      * Get the OS/2 table
1124      */
1125     os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
1126
1127     /*
1128      * Look first in the OS/2 table for the foundry, if
1129      * not found here, the various notices will be searched for
1130      * that information, either from the sfnt name tables or
1131      * the Postscript FontInfo dictionary.  Finally, the
1132      * BDF properties will queried.
1133      */
1134
1135     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
1136         foundry = FcVendorFoundry(os2->achVendID);
1137
1138     if (FcDebug () & FC_DBG_SCANV)
1139         printf ("\n");
1140     /*
1141      * Grub through the name table looking for family
1142      * and style names.  FreeType makes quite a hash
1143      * of them
1144      */
1145     snamec = FT_Get_Sfnt_Name_Count (face);
1146     for (p = 0; p <= NUM_PLATFORM_ORDER; p++)
1147     {
1148         if (p < NUM_PLATFORM_ORDER)
1149             platform = platform_order[p];
1150         else
1151             platform = 0xffff;
1152
1153         /*
1154          * Order nameids so preferred names appear first
1155          * in the resulting list
1156          */
1157         for (n = 0; n < NUM_NAMEID_ORDER; n++)
1158         {
1159             nameid = nameid_order[n];
1160
1161             for (snamei = 0; snamei < snamec; snamei++)
1162             {
1163                 FcChar8         *utf8;
1164                 const FcChar8   *lang;
1165                 const char      *elt = 0, *eltlang = 0;
1166                 int             *np = 0, *nlangp = 0;
1167
1168                 if (FT_Get_Sfnt_Name (face, snamei, &sname) != 0)
1169                     continue;
1170                 if (sname.name_id != nameid)
1171                     continue;
1172
1173                 /*
1174                  * Sort platforms in preference order, accepting
1175                  * all other platforms last
1176                  */
1177                 if (p < NUM_PLATFORM_ORDER)
1178                 {
1179                     if (sname.platform_id != platform)
1180                         continue;
1181                 }
1182                 else
1183                 {
1184                     int     sp;
1185
1186                     for (sp = 0; sp < NUM_PLATFORM_ORDER; sp++)
1187                         if (sname.platform_id == platform_order[sp])
1188                             break;
1189                     if (sp != NUM_PLATFORM_ORDER)
1190                         continue;
1191                 }
1192                 utf8 = FcSfntNameTranscode (&sname);
1193                 lang = FcSfntNameLanguage (&sname);
1194
1195                 if (!utf8)
1196                     continue;
1197
1198                 switch (sname.name_id) {
1199                 case TT_NAME_ID_PREFERRED_FAMILY:
1200                 case TT_NAME_ID_FONT_FAMILY:
1201 #if 0
1202                 case TT_NAME_ID_PS_NAME:
1203                 case TT_NAME_ID_UNIQUE_ID:
1204 #endif
1205                     if (FcDebug () & FC_DBG_SCANV)
1206                         printf ("found family (n %2d p %d e %d l 0x%04x) %s\n",
1207                                 sname.name_id, sname.platform_id,
1208                                 sname.encoding_id, sname.language_id,
1209                                 utf8);
1210
1211                     elt = FC_FAMILY;
1212                     eltlang = FC_FAMILYLANG;
1213                     np = &nfamily;
1214                     nlangp = &nfamily_lang;
1215                     break;
1216                 case TT_NAME_ID_MAC_FULL_NAME:
1217                 case TT_NAME_ID_FULL_NAME:
1218                     if (FcDebug () & FC_DBG_SCANV)
1219                         printf ("found full   (n %2d p %d e %d l 0x%04x) %s\n",
1220                                 sname.name_id, sname.platform_id,
1221                                 sname.encoding_id, sname.language_id,
1222                                 utf8);
1223
1224                     elt = FC_FULLNAME;
1225                     eltlang = FC_FULLNAMELANG;
1226                     np = &nfullname;
1227                     nlangp = &nfullname_lang;
1228                     break;
1229                 case TT_NAME_ID_PREFERRED_SUBFAMILY:
1230                 case TT_NAME_ID_FONT_SUBFAMILY:
1231                     if (FcDebug () & FC_DBG_SCANV)
1232                         printf ("found style  (n %2d p %d e %d l 0x%04x) %s\n",
1233                                 sname.name_id, sname.platform_id,
1234                                 sname.encoding_id, sname.language_id,
1235                                 utf8);
1236
1237                     elt = FC_STYLE;
1238                     eltlang = FC_STYLELANG;
1239                     np = &nstyle;
1240                     nlangp = &nstyle_lang;
1241                     break;
1242                 case TT_NAME_ID_TRADEMARK:
1243                 case TT_NAME_ID_MANUFACTURER:
1244                     /* If the foundry wasn't found in the OS/2 table, look here */
1245                     if(!foundry)
1246                         foundry = FcNoticeFoundry((FT_String *) utf8);
1247                     break;
1248                 }
1249                 if (elt)
1250                 {
1251                     if (FcStringInPatternElement (pat, elt, utf8))
1252                     {
1253                         free (utf8);
1254                         continue;
1255                     }
1256
1257                     /* add new element */
1258                     if (!FcPatternAddString (pat, elt, utf8))
1259                     {
1260                         free (utf8);
1261                         goto bail1;
1262                     }
1263                     free (utf8);
1264                     if (lang)
1265                     {
1266                         /* pad lang list with 'xx' to line up with elt */
1267                         while (*nlangp < *np)
1268                         {
1269                             if (!FcPatternAddString (pat, eltlang, (FcChar8 *) "xx"))
1270                                 goto bail1;
1271                             ++*nlangp;
1272                         }
1273                         if (!FcPatternAddString (pat, eltlang, lang))
1274                             goto bail1;
1275                         ++*nlangp;
1276                     }
1277                     ++*np;
1278                 }
1279                 else
1280                     free (utf8);
1281             }
1282         }
1283     }
1284
1285     if (!nfamily && face->family_name &&
1286         FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->family_name, (FcChar8 *) "") != 0)
1287     {
1288         if (FcDebug () & FC_DBG_SCANV)
1289             printf ("using FreeType family \"%s\"\n", face->family_name);
1290         if (!FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) face->family_name))
1291             goto bail1;
1292         ++nfamily;
1293     }
1294
1295     if (!nstyle && face->style_name &&
1296         FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->style_name, (FcChar8 *) "") != 0)
1297     {
1298         if (FcDebug () & FC_DBG_SCANV)
1299             printf ("using FreeType style \"%s\"\n", face->style_name);
1300         if (!FcPatternAddString (pat, FC_STYLE, (FcChar8 *) face->style_name))
1301             goto bail1;
1302         ++nstyle;
1303     }
1304
1305     if (!nfamily)
1306     {
1307         FcChar8 *start, *end;
1308         FcChar8 *family;
1309
1310         start = (FcChar8 *) strrchr ((char *) file, '/');
1311         if (start)
1312             start++;
1313         else
1314             start = (FcChar8 *) file;
1315         end = (FcChar8 *) strrchr ((char *) start, '.');
1316         if (!end)
1317             end = start + strlen ((char *) start);
1318         /* freed below */
1319         family = malloc (end - start + 1);
1320         strncpy ((char *) family, (char *) start, end - start);
1321         family[end - start] = '\0';
1322         if (FcDebug () & FC_DBG_SCANV)
1323             printf ("using filename for family %s\n", family);
1324         if (!FcPatternAddString (pat, FC_FAMILY, family))
1325         {
1326             free (family);
1327             goto bail1;
1328         }
1329         free (family);
1330         ++nfamily;
1331     }
1332
1333     if (!FcPatternAddString (pat, FC_FILE, file))
1334         goto bail1;
1335
1336     if (!FcPatternAddInteger (pat, FC_INDEX, id))
1337         goto bail1;
1338
1339 #if 0
1340     /*
1341      * don't even try this -- CJK 'monospace' fonts are really
1342      * dual width, and most other fonts don't bother to set
1343      * the attribute.  Sigh.
1344      */
1345     if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
1346         if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
1347             goto bail1;
1348 #endif
1349
1350     /*
1351      * Find the font revision (if available)
1352      */
1353     head = (TT_Header *) FT_Get_Sfnt_Table (face, ft_sfnt_head);
1354     if (head)
1355     {
1356         if (!FcPatternAddInteger (pat, FC_FONTVERSION, head->Font_Revision))
1357             goto bail1;
1358     }
1359     else
1360     {
1361         if (!FcPatternAddInteger (pat, FC_FONTVERSION, 0))
1362             goto bail1;
1363     }
1364
1365     if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
1366     {
1367         for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
1368         {
1369             FT_ULong    bits;
1370             int         bit;
1371             if (FcCodePageRange[i].bit < 32)
1372             {
1373                 bits = os2->ulCodePageRange1;
1374                 bit = FcCodePageRange[i].bit;
1375             }
1376             else
1377             {
1378                 bits = os2->ulCodePageRange2;
1379                 bit = FcCodePageRange[i].bit - 32;
1380             }
1381             if (bits & (1 << bit))
1382             {
1383                 /*
1384                  * If the font advertises support for multiple
1385                  * "exclusive" languages, then include support
1386                  * for any language found to have coverage
1387                  */
1388                 if (exclusiveLang)
1389                 {
1390                     exclusiveLang = 0;
1391                     break;
1392                 }
1393                 exclusiveLang = FcCodePageRange[i].lang;
1394             }
1395         }
1396     }
1397
1398     if (os2 && os2->version != 0xffff)
1399     {
1400         if (os2->usWeightClass == 0)
1401             ;
1402         else if (os2->usWeightClass < 150)
1403             weight = FC_WEIGHT_THIN;
1404         else if (os2->usWeightClass < 250)
1405             weight = FC_WEIGHT_EXTRALIGHT;
1406         else if (os2->usWeightClass < 350)
1407             weight = FC_WEIGHT_LIGHT;
1408         else if (os2->usWeightClass < 450)
1409             weight = FC_WEIGHT_REGULAR;
1410         else if (os2->usWeightClass < 550)
1411             weight = FC_WEIGHT_MEDIUM;
1412         else if (os2->usWeightClass < 650)
1413             weight = FC_WEIGHT_SEMIBOLD;
1414         else if (os2->usWeightClass < 750)
1415             weight = FC_WEIGHT_BOLD;
1416         else if (os2->usWeightClass < 850)
1417             weight = FC_WEIGHT_EXTRABOLD;
1418         else if (os2->usWeightClass < 950)
1419             weight = FC_WEIGHT_BLACK;
1420         if ((FcDebug() & FC_DBG_SCANV) && weight != -1)
1421             printf ("\tos2 weight class %d maps to weight %d\n",
1422                     os2->usWeightClass, weight);
1423
1424         switch (os2->usWidthClass) {
1425         case 1: width = FC_WIDTH_ULTRACONDENSED; break;
1426         case 2: width = FC_WIDTH_EXTRACONDENSED; break;
1427         case 3: width = FC_WIDTH_CONDENSED; break;
1428         case 4: width = FC_WIDTH_SEMICONDENSED; break;
1429         case 5: width = FC_WIDTH_NORMAL; break;
1430         case 6: width = FC_WIDTH_SEMIEXPANDED; break;
1431         case 7: width = FC_WIDTH_EXPANDED; break;
1432         case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
1433         case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
1434         }
1435         if ((FcDebug() & FC_DBG_SCANV) && width != -1)
1436             printf ("\tos2 width class %d maps to width %d\n",
1437                     os2->usWidthClass, width);
1438     }
1439     if (os2 && (complex = FcFontCapabilities(face)))
1440     {
1441         if (!FcPatternAddString (pat, FC_CAPABILITY, complex))
1442         {
1443             free (complex);
1444             goto bail1;
1445         }
1446         free (complex);
1447     }
1448
1449     /*
1450      * Type 1: Check for FontInfo dictionary information
1451      * Code from g2@magestudios.net (Gerard Escalante)
1452      */
1453
1454 #if HAVE_FT_GET_PS_FONT_INFO
1455     if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
1456     {
1457         if (weight == -1 && psfontinfo.weight)
1458         {
1459             weight = FcIsWeight ((FcChar8 *) psfontinfo.weight);
1460             if (FcDebug() & FC_DBG_SCANV)
1461                 printf ("\tType1 weight %s maps to %d\n",
1462                         psfontinfo.weight, weight);
1463         }
1464
1465 #if 0
1466         /*
1467          * Don't bother with italic_angle; FreeType already extracts that
1468          * information for us and sticks it into style_flags
1469          */
1470         if (psfontinfo.italic_angle)
1471             slant = FC_SLANT_ITALIC;
1472         else
1473             slant = FC_SLANT_ROMAN;
1474 #endif
1475
1476         if(!foundry)
1477             foundry = FcNoticeFoundry(psfontinfo.notice);
1478     }
1479 #endif /* HAVE_FT_GET_PS_FONT_INFO */
1480
1481 #if HAVE_FT_GET_BDF_PROPERTY
1482     /*
1483      * Finally, look for a FOUNDRY BDF property if no other
1484      * mechanism has managed to locate a foundry
1485      */
1486
1487     if (!foundry)
1488     {
1489         int             rc;
1490         rc = FT_Get_BDF_Property(face, "FOUNDRY", &prop);
1491         if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM)
1492             foundry = (FcChar8 *) prop.u.atom;
1493     }
1494
1495     if (width == -1)
1496     {
1497         if (FT_Get_BDF_Property(face, "RELATIVE_SETWIDTH", &prop) == 0 &&
1498             (prop.type == BDF_PROPERTY_TYPE_INTEGER ||
1499              prop.type == BDF_PROPERTY_TYPE_CARDINAL))
1500         {
1501             FT_Int32    value;
1502
1503             if (prop.type == BDF_PROPERTY_TYPE_INTEGER)
1504                 value = prop.u.integer;
1505             else
1506                 value = (FT_Int32) prop.u.cardinal;
1507             switch ((value + 5) / 10) {
1508             case 1: width = FC_WIDTH_ULTRACONDENSED; break;
1509             case 2: width = FC_WIDTH_EXTRACONDENSED; break;
1510             case 3: width = FC_WIDTH_CONDENSED; break;
1511             case 4: width = FC_WIDTH_SEMICONDENSED; break;
1512             case 5: width = FC_WIDTH_NORMAL; break;
1513             case 6: width = FC_WIDTH_SEMIEXPANDED; break;
1514             case 7: width = FC_WIDTH_EXPANDED; break;
1515             case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
1516             case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
1517             }
1518         }
1519         if (width == -1 &&
1520             FT_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
1521             prop.type == BDF_PROPERTY_TYPE_ATOM)
1522         {
1523             width = FcIsWidth ((FcChar8 *) prop.u.atom);
1524             if (FcDebug () & FC_DBG_SCANV)
1525                 printf ("\tsetwidth %s maps to %d\n", prop.u.atom, width);
1526         }
1527     }
1528 #endif
1529
1530     /*
1531      * Look for weight, width and slant names in the style value
1532      */
1533     for (st = 0; FcPatternGetString (pat, FC_STYLE, st, &style) == FcResultMatch; st++)
1534     {
1535         if (weight == -1)
1536         {
1537             weight = FcContainsWeight (style);
1538             if (FcDebug() & FC_DBG_SCANV)
1539                 printf ("\tStyle %s maps to weight %d\n", style, weight);
1540         }
1541         if (width == -1)
1542         {
1543             width = FcContainsWidth (style);
1544             if (FcDebug() & FC_DBG_SCANV)
1545                 printf ("\tStyle %s maps to width %d\n", style, width);
1546         }
1547         if (slant == -1)
1548         {
1549             slant = FcContainsSlant (style);
1550             if (FcDebug() & FC_DBG_SCANV)
1551                 printf ("\tStyle %s maps to slant %d\n", style, slant);
1552         }
1553         if (decorative == FcFalse)
1554         {
1555             decorative = FcContainsDecorative (style) > 0;
1556             if (FcDebug() & FC_DBG_SCANV)
1557                 printf ("\tStyle %s maps to decorative %d\n", style, decorative);
1558         }
1559     }
1560     /*
1561      * Pull default values from the FreeType flags if more
1562      * specific values not found above
1563      */
1564     if (slant == -1)
1565     {
1566         slant = FC_SLANT_ROMAN;
1567         if (face->style_flags & FT_STYLE_FLAG_ITALIC)
1568             slant = FC_SLANT_ITALIC;
1569     }
1570
1571     if (weight == -1)
1572     {
1573         weight = FC_WEIGHT_MEDIUM;
1574         if (face->style_flags & FT_STYLE_FLAG_BOLD)
1575             weight = FC_WEIGHT_BOLD;
1576     }
1577
1578     if (width == -1)
1579         width = FC_WIDTH_NORMAL;
1580
1581     if (foundry == 0)
1582         foundry = (FcChar8 *) "unknown";
1583
1584     if (!FcPatternAddInteger (pat, FC_SLANT, slant))
1585         goto bail1;
1586
1587     if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
1588         goto bail1;
1589
1590     if (!FcPatternAddInteger (pat, FC_WIDTH, width))
1591         goto bail1;
1592
1593     if (!FcPatternAddString (pat, FC_FOUNDRY, foundry))
1594         goto bail1;
1595
1596     if (!FcPatternAddBool (pat, FC_DECORATIVE, decorative))
1597         goto bail1;
1598
1599     /*
1600      * Compute the unicode coverage for the font
1601      */
1602     cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
1603     if (!cs)
1604         goto bail1;
1605
1606 #if HAVE_FT_GET_BDF_PROPERTY
1607     /* For PCF fonts, override the computed spacing with the one from
1608        the property */
1609     if(FT_Get_BDF_Property(face, "SPACING", &prop) == 0 &&
1610        prop.type == BDF_PROPERTY_TYPE_ATOM) {
1611         if(!strcmp(prop.u.atom, "c") || !strcmp(prop.u.atom, "C"))
1612             spacing = FC_CHARCELL;
1613         else if(!strcmp(prop.u.atom, "m") || !strcmp(prop.u.atom, "M"))
1614             spacing = FC_MONO;
1615         else if(!strcmp(prop.u.atom, "p") || !strcmp(prop.u.atom, "P"))
1616             spacing = FC_PROPORTIONAL;
1617     }
1618 #endif
1619
1620     /*
1621      * Skip over PCF fonts that have no encoded characters; they're
1622      * usually just Unicode fonts transcoded to some legacy encoding
1623      * ftglue.c forces us to approximate whether a font is a PCF font
1624      * or not by whether it has any BDF properties.  Try PIXEL_SIZE;
1625      * I don't know how to get a list of BDF properties on the font. -PL
1626      */
1627     if (FcCharSetCount (cs) == 0)
1628     {
1629 #if HAVE_FT_GET_BDF_PROPERTY
1630         if(FT_Get_BDF_Property(face, "PIXEL_SIZE", &prop) == 0)
1631             goto bail2;
1632 #endif
1633     }
1634
1635     if (!FcPatternAddCharSet (pat, FC_CHARSET, cs))
1636         goto bail2;
1637
1638     ls = FcFreeTypeLangSet (cs, exclusiveLang);
1639     if (!ls)
1640         goto bail2;
1641
1642     if (!FcPatternAddLangSet (pat, FC_LANG, ls))
1643     {
1644         FcLangSetDestroy (ls);
1645         goto bail2;
1646     }
1647
1648     FcLangSetDestroy (ls);
1649
1650     if (spacing != FC_PROPORTIONAL)
1651         if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
1652             goto bail2;
1653
1654     if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
1655     {
1656         for (i = 0; i < face->num_fixed_sizes; i++)
1657             if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE,
1658                                      FcGetPixelSize (face, i)))
1659                 goto bail2;
1660         if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
1661             goto bail2;
1662 #if HAVE_FT_GET_BDF_PROPERTY
1663         if(face->num_fixed_sizes == 1) {
1664             int rc;
1665             int value;
1666
1667             /* skip bitmap fonts which do not even have a family name */
1668             rc =  FT_Get_BDF_Property(face, "FAMILY_NAME", &prop);
1669             if (rc != 0 || prop.type != BDF_PROPERTY_TYPE_ATOM)
1670                 goto bail2;
1671
1672             rc = FT_Get_BDF_Property(face, "POINT_SIZE", &prop);
1673             if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1674                 value = prop.u.integer;
1675             else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1676                 value = prop.u.cardinal;
1677             else
1678                 goto nevermind;
1679             if(!FcPatternAddDouble(pat, FC_SIZE, value / 10.0))
1680                 goto nevermind;
1681
1682             rc = FT_Get_BDF_Property(face, "RESOLUTION_Y", &prop);
1683             if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1684                 value = prop.u.integer;
1685             else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1686                 value = prop.u.cardinal;
1687             else
1688                 goto nevermind;
1689             if(!FcPatternAddDouble(pat, FC_DPI, (double)value))
1690                 goto nevermind;
1691
1692         }
1693     nevermind:
1694         ;
1695 #endif
1696     }
1697 #if HAVE_FT_GET_X11_FONT_FORMAT
1698     /*
1699      * Use the (not well documented or supported) X-specific function
1700      * from FreeType to figure out the font format
1701      */
1702     {
1703         const char *font_format = FT_Get_X11_Font_Format (face);
1704         if (font_format)
1705             FcPatternAddString (pat, FC_FONTFORMAT, (FcChar8 *) font_format);
1706     }
1707 #endif
1708
1709     /*
1710      * Drop our reference to the charset
1711      */
1712     FcCharSetDestroy (cs);
1713
1714     return pat;
1715
1716 bail2:
1717     FcCharSetDestroy (cs);
1718 bail1:
1719     FcPatternDestroy (pat);
1720 bail0:
1721     return NULL;
1722 }
1723
1724 FcPattern *
1725 FcFreeTypeQuery(const FcChar8   *file,
1726                 int             id,
1727                 FcBlanks        *blanks,
1728                 int             *count)
1729 {
1730     FT_Face         face;
1731     FT_Library      ftLibrary;
1732     FcPattern       *pat = NULL;
1733
1734     if (FT_Init_FreeType (&ftLibrary))
1735         return NULL;
1736
1737     if (FT_New_Face (ftLibrary, (char *) file, id, &face))
1738         goto bail;
1739
1740     *count = face->num_faces;
1741
1742     pat = FcFreeTypeQueryFace (face, file, id, blanks);
1743
1744     FT_Done_Face (face);
1745 bail:
1746     FT_Done_FreeType (ftLibrary);
1747     return pat;
1748 }
1749
1750 /*
1751  * For our purposes, this approximation is sufficient
1752  */
1753 #if !HAVE_FT_GET_NEXT_CHAR
1754 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
1755                                           (*(gi) = 0), 0 : \
1756                                           (*(gi) = 1), (ucs4) + 1)
1757 #warning "No FT_Get_Next_Char: Please install freetype version 2.1.0 or newer"
1758 #endif
1759
1760 typedef struct _FcCharEnt {
1761     FcChar16        bmp;
1762     unsigned char   encode;
1763 } FcCharEnt;
1764
1765 struct _FcCharMap {
1766     const FcCharEnt *ent;
1767     int             nent;
1768 };
1769
1770 typedef struct _FcFontDecode {
1771     FT_Encoding     encoding;
1772     const FcCharMap *map;
1773     FcChar32        max;
1774 } FcFontDecode;
1775
1776 static const FcCharEnt AppleRomanEnt[] = {
1777     { 0x0020, 0x20 }, /* SPACE */
1778     { 0x0021, 0x21 }, /* EXCLAMATION MARK */
1779     { 0x0022, 0x22 }, /* QUOTATION MARK */
1780     { 0x0023, 0x23 }, /* NUMBER SIGN */
1781     { 0x0024, 0x24 }, /* DOLLAR SIGN */
1782     { 0x0025, 0x25 }, /* PERCENT SIGN */
1783     { 0x0026, 0x26 }, /* AMPERSAND */
1784     { 0x0027, 0x27 }, /* APOSTROPHE */
1785     { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
1786     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
1787     { 0x002A, 0x2A }, /* ASTERISK */
1788     { 0x002B, 0x2B }, /* PLUS SIGN */
1789     { 0x002C, 0x2C }, /* COMMA */
1790     { 0x002D, 0x2D }, /* HYPHEN-MINUS */
1791     { 0x002E, 0x2E }, /* FULL STOP */
1792     { 0x002F, 0x2F }, /* SOLIDUS */
1793     { 0x0030, 0x30 }, /* DIGIT ZERO */
1794     { 0x0031, 0x31 }, /* DIGIT ONE */
1795     { 0x0032, 0x32 }, /* DIGIT TWO */
1796     { 0x0033, 0x33 }, /* DIGIT THREE */
1797     { 0x0034, 0x34 }, /* DIGIT FOUR */
1798     { 0x0035, 0x35 }, /* DIGIT FIVE */
1799     { 0x0036, 0x36 }, /* DIGIT SIX */
1800     { 0x0037, 0x37 }, /* DIGIT SEVEN */
1801     { 0x0038, 0x38 }, /* DIGIT EIGHT */
1802     { 0x0039, 0x39 }, /* DIGIT NINE */
1803     { 0x003A, 0x3A }, /* COLON */
1804     { 0x003B, 0x3B }, /* SEMICOLON */
1805     { 0x003C, 0x3C }, /* LESS-THAN SIGN */
1806     { 0x003D, 0x3D }, /* EQUALS SIGN */
1807     { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
1808     { 0x003F, 0x3F }, /* QUESTION MARK */
1809     { 0x0040, 0x40 }, /* COMMERCIAL AT */
1810     { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
1811     { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
1812     { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
1813     { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
1814     { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
1815     { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
1816     { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
1817     { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
1818     { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
1819     { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
1820     { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
1821     { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
1822     { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
1823     { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
1824     { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
1825     { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
1826     { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
1827     { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
1828     { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
1829     { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
1830     { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
1831     { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
1832     { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
1833     { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
1834     { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
1835     { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
1836     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
1837     { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
1838     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
1839     { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
1840     { 0x005F, 0x5F }, /* LOW LINE */
1841     { 0x0060, 0x60 }, /* GRAVE ACCENT */
1842     { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
1843     { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
1844     { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
1845     { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
1846     { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
1847     { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
1848     { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
1849     { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
1850     { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
1851     { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
1852     { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
1853     { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
1854     { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
1855     { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
1856     { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
1857     { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
1858     { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
1859     { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
1860     { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
1861     { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
1862     { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
1863     { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
1864     { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
1865     { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
1866     { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
1867     { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
1868     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
1869     { 0x007C, 0x7C }, /* VERTICAL LINE */
1870     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
1871     { 0x007E, 0x7E }, /* TILDE */
1872     { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
1873     { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
1874     { 0x00A2, 0xA2 }, /* CENT SIGN */
1875     { 0x00A3, 0xA3 }, /* POUND SIGN */
1876     { 0x00A5, 0xB4 }, /* YEN SIGN */
1877     { 0x00A7, 0xA4 }, /* SECTION SIGN */
1878     { 0x00A8, 0xAC }, /* DIAERESIS */
1879     { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
1880     { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
1881     { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
1882     { 0x00AC, 0xC2 }, /* NOT SIGN */
1883     { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
1884     { 0x00AF, 0xF8 }, /* MACRON */
1885     { 0x00B0, 0xA1 }, /* DEGREE SIGN */
1886     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
1887     { 0x00B4, 0xAB }, /* ACUTE ACCENT */
1888     { 0x00B5, 0xB5 }, /* MICRO SIGN */
1889     { 0x00B6, 0xA6 }, /* PILCROW SIGN */
1890     { 0x00B7, 0xE1 }, /* MIDDLE DOT */
1891     { 0x00B8, 0xFC }, /* CEDILLA */
1892     { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
1893     { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
1894     { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
1895     { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
1896     { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
1897     { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
1898     { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
1899     { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
1900     { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
1901     { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
1902     { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
1903     { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
1904     { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
1905     { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
1906     { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
1907     { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
1908     { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
1909     { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
1910     { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
1911     { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
1912     { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
1913     { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
1914     { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
1915     { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
1916     { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
1917     { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
1918     { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
1919     { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
1920     { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
1921     { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
1922     { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
1923     { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
1924     { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
1925     { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
1926     { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
1927     { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
1928     { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
1929     { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
1930     { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
1931     { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
1932     { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
1933     { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
1934     { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
1935     { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
1936     { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
1937     { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
1938     { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
1939     { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
1940     { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
1941     { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
1942     { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
1943     { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
1944     { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
1945     { 0x00F7, 0xD6 }, /* DIVISION SIGN */
1946     { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
1947     { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
1948     { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
1949     { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
1950     { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
1951     { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
1952     { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
1953     { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
1954     { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
1955     { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
1956     { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
1957     { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
1958     { 0x02C7, 0xFF }, /* CARON */
1959     { 0x02D8, 0xF9 }, /* BREVE */
1960     { 0x02D9, 0xFA }, /* DOT ABOVE */
1961     { 0x02DA, 0xFB }, /* RING ABOVE */
1962     { 0x02DB, 0xFE }, /* OGONEK */
1963     { 0x02DC, 0xF7 }, /* SMALL TILDE */
1964     { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
1965     { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
1966     { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
1967     { 0x2013, 0xD0 }, /* EN DASH */
1968     { 0x2014, 0xD1 }, /* EM DASH */
1969     { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
1970     { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
1971     { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
1972     { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
1973     { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
1974     { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
1975     { 0x2020, 0xA0 }, /* DAGGER */
1976     { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
1977     { 0x2022, 0xA5 }, /* BULLET */
1978     { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
1979     { 0x2030, 0xE4 }, /* PER MILLE SIGN */
1980     { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
1981     { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
1982     { 0x2044, 0xDA }, /* FRACTION SLASH */
1983     { 0x20AC, 0xDB }, /* EURO SIGN */
1984     { 0x2122, 0xAA }, /* TRADE MARK SIGN */
1985     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
1986     { 0x2206, 0xC6 }, /* INCREMENT */
1987     { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
1988     { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
1989     { 0x221A, 0xC3 }, /* SQUARE ROOT */
1990     { 0x221E, 0xB0 }, /* INFINITY */
1991     { 0x222B, 0xBA }, /* INTEGRAL */
1992     { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
1993     { 0x2260, 0xAD }, /* NOT EQUAL TO */
1994     { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
1995     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
1996     { 0x25CA, 0xD7 }, /* LOZENGE */
1997     { 0xF8FF, 0xF0 }, /* Apple logo */
1998     { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
1999     { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
2000 };
2001
2002 static const FcCharMap AppleRoman = {
2003     AppleRomanEnt,
2004     sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
2005 };
2006
2007 static const FcCharEnt AdobeSymbolEnt[] = {
2008     { 0x0020, 0x20 }, /* SPACE  # space */
2009     { 0x0021, 0x21 }, /* EXCLAMATION MARK       # exclam */
2010     { 0x0023, 0x23 }, /* NUMBER SIGN    # numbersign */
2011     { 0x0025, 0x25 }, /* PERCENT SIGN   # percent */
2012     { 0x0026, 0x26 }, /* AMPERSAND      # ampersand */
2013     { 0x0028, 0x28 }, /* LEFT PARENTHESIS       # parenleft */
2014     { 0x0029, 0x29 }, /* RIGHT PARENTHESIS      # parenright */
2015     { 0x002B, 0x2B }, /* PLUS SIGN      # plus */
2016     { 0x002C, 0x2C }, /* COMMA  # comma */
2017     { 0x002E, 0x2E }, /* FULL STOP      # period */
2018     { 0x002F, 0x2F }, /* SOLIDUS        # slash */
2019     { 0x0030, 0x30 }, /* DIGIT ZERO     # zero */
2020     { 0x0031, 0x31 }, /* DIGIT ONE      # one */
2021     { 0x0032, 0x32 }, /* DIGIT TWO      # two */
2022     { 0x0033, 0x33 }, /* DIGIT THREE    # three */
2023     { 0x0034, 0x34 }, /* DIGIT FOUR     # four */
2024     { 0x0035, 0x35 }, /* DIGIT FIVE     # five */
2025     { 0x0036, 0x36 }, /* DIGIT SIX      # six */
2026     { 0x0037, 0x37 }, /* DIGIT SEVEN    # seven */
2027     { 0x0038, 0x38 }, /* DIGIT EIGHT    # eight */
2028     { 0x0039, 0x39 }, /* DIGIT NINE     # nine */
2029     { 0x003A, 0x3A }, /* COLON  # colon */
2030     { 0x003B, 0x3B }, /* SEMICOLON      # semicolon */
2031     { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
2032     { 0x003D, 0x3D }, /* EQUALS SIGN    # equal */
2033     { 0x003E, 0x3E }, /* GREATER-THAN SIGN      # greater */
2034     { 0x003F, 0x3F }, /* QUESTION MARK  # question */
2035     { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET    # bracketleft */
2036     { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET   # bracketright */
2037     { 0x005F, 0x5F }, /* LOW LINE       # underscore */
2038     { 0x007B, 0x7B }, /* LEFT CURLY BRACKET     # braceleft */
2039     { 0x007C, 0x7C }, /* VERTICAL LINE  # bar */
2040     { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET    # braceright */
2041     { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
2042     { 0x00AC, 0xD8 }, /* NOT SIGN       # logicalnot */
2043     { 0x00B0, 0xB0 }, /* DEGREE SIGN    # degree */
2044     { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN        # plusminus */
2045     { 0x00B5, 0x6D }, /* MICRO SIGN     # mu */
2046     { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN    # multiply */
2047     { 0x00F7, 0xB8 }, /* DIVISION SIGN  # divide */
2048     { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
2049     { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA     # Alpha */
2050     { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA      # Beta */
2051     { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA     # Gamma */
2052     { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA     # Delta */
2053     { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON   # Epsilon */
2054     { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA      # Zeta */
2055     { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA       # Eta */
2056     { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA     # Theta */
2057     { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA      # Iota */
2058     { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA     # Kappa */
2059     { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA     # Lambda */
2060     { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU        # Mu */
2061     { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU        # Nu */
2062     { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI        # Xi */
2063     { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON   # Omicron */
2064     { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI        # Pi */
2065     { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO       # Rho */
2066     { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA     # Sigma */
2067     { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU       # Tau */
2068     { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON   # Upsilon */
2069     { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI       # Phi */
2070     { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI       # Chi */
2071     { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI       # Psi */
2072     { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA     # Omega */
2073     { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA       # alpha */
2074     { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA        # beta */
2075     { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA       # gamma */
2076     { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA       # delta */
2077     { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON     # epsilon */
2078     { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA        # zeta */
2079     { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
2080     { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA       # theta */
2081     { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA        # iota */
2082     { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA       # kappa */
2083     { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA       # lambda */
2084     { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU  # mu */
2085     { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU  # nu */
2086     { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI  # xi */
2087     { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON     # omicron */
2088     { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI  # pi */
2089     { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
2090     { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
2091     { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA       # sigma */
2092     { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
2093     { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON     # upsilon */
2094     { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
2095     { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
2096     { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
2097     { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA       # omega */
2098     { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL     # theta1 */
2099     { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
2100     { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL       # phi1 */
2101     { 0x03D6, 0x76 }, /* GREEK PI SYMBOL        # omega1 */
2102     { 0x2022, 0xB7 }, /* BULLET # bullet */
2103     { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS    # ellipsis */
2104     { 0x2032, 0xA2 }, /* PRIME  # minute */
2105     { 0x2033, 0xB2 }, /* DOUBLE PRIME   # second */
2106     { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
2107     { 0x20AC, 0xA0 }, /* EURO SIGN      # Euro */
2108     { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
2109     { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P       # weierstrass */
2110     { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
2111     { 0x2126, 0x57 }, /* OHM SIGN       # Omega */
2112     { 0x2135, 0xC0 }, /* ALEF SYMBOL    # aleph */
2113     { 0x2190, 0xAC }, /* LEFTWARDS ARROW        # arrowleft */
2114     { 0x2191, 0xAD }, /* UPWARDS ARROW  # arrowup */
2115     { 0x2192, 0xAE }, /* RIGHTWARDS ARROW       # arrowright */
2116     { 0x2193, 0xAF }, /* DOWNWARDS ARROW        # arrowdown */
2117     { 0x2194, 0xAB }, /* LEFT RIGHT ARROW       # arrowboth */
2118     { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS  # carriagereturn */
2119     { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
2120     { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW   # arrowdblup */
2121     { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW        # arrowdblright */
2122     { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
2123     { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW        # arrowdblboth */
2124     { 0x2200, 0x22 }, /* FOR ALL        # universal */
2125     { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL   # partialdiff */
2126     { 0x2203, 0x24 }, /* THERE EXISTS   # existential */
2127     { 0x2205, 0xC6 }, /* EMPTY SET      # emptyset */
2128     { 0x2206, 0x44 }, /* INCREMENT      # Delta */
2129     { 0x2207, 0xD1 }, /* NABLA  # gradient */
2130     { 0x2208, 0xCE }, /* ELEMENT OF     # element */
2131     { 0x2209, 0xCF }, /* NOT AN ELEMENT OF      # notelement */
2132     { 0x220B, 0x27 }, /* CONTAINS AS MEMBER     # suchthat */
2133     { 0x220F, 0xD5 }, /* N-ARY PRODUCT  # product */
2134     { 0x2211, 0xE5 }, /* N-ARY SUMMATION        # summation */
2135     { 0x2212, 0x2D }, /* MINUS SIGN     # minus */
2136     { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
2137     { 0x2217, 0x2A }, /* ASTERISK OPERATOR      # asteriskmath */
2138     { 0x221A, 0xD6 }, /* SQUARE ROOT    # radical */
2139     { 0x221D, 0xB5 }, /* PROPORTIONAL TO        # proportional */
2140     { 0x221E, 0xA5 }, /* INFINITY       # infinity */
2141     { 0x2220, 0xD0 }, /* ANGLE  # angle */
2142     { 0x2227, 0xD9 }, /* LOGICAL AND    # logicaland */
2143     { 0x2228, 0xDA }, /* LOGICAL OR     # logicalor */
2144     { 0x2229, 0xC7 }, /* INTERSECTION   # intersection */
2145     { 0x222A, 0xC8 }, /* UNION  # union */
2146     { 0x222B, 0xF2 }, /* INTEGRAL       # integral */
2147     { 0x2234, 0x5C }, /* THEREFORE      # therefore */
2148     { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
2149     { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
2150     { 0x2248, 0xBB }, /* ALMOST EQUAL TO        # approxequal */
2151     { 0x2260, 0xB9 }, /* NOT EQUAL TO   # notequal */
2152     { 0x2261, 0xBA }, /* IDENTICAL TO   # equivalence */
2153     { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO  # lessequal */
2154     { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO       # greaterequal */
2155     { 0x2282, 0xCC }, /* SUBSET OF      # propersubset */
2156     { 0x2283, 0xC9 }, /* SUPERSET OF    # propersuperset */
2157     { 0x2284, 0xCB }, /* NOT A SUBSET OF        # notsubset */
2158     { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO  # reflexsubset */
2159     { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO        # reflexsuperset */
2160     { 0x2295, 0xC5 }, /* CIRCLED PLUS   # circleplus */
2161     { 0x2297, 0xC4 }, /* CIRCLED TIMES  # circlemultiply */
2162     { 0x22A5, 0x5E }, /* UP TACK        # perpendicular */
2163     { 0x22C5, 0xD7 }, /* DOT OPERATOR   # dotmath */
2164     { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL      # integraltp */
2165     { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL   # integralbt */
2166     { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET    # angleleft */
2167     { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET   # angleright */
2168     { 0x25CA, 0xE0 }, /* LOZENGE        # lozenge */
2169     { 0x2660, 0xAA }, /* BLACK SPADE SUIT       # spade */
2170     { 0x2663, 0xA7 }, /* BLACK CLUB SUIT        # club */
2171     { 0x2665, 0xA9 }, /* BLACK HEART SUIT       # heart */
2172     { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT     # diamond */
2173     { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF   # copyrightserif (CUS) */
2174     { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF  # registerserif (CUS) */
2175     { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF  # trademarkserif (CUS) */
2176     { 0xF8E5, 0x60 }, /* RADICAL EXTENDER       # radicalex (CUS) */
2177     { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER        # arrowvertex (CUS) */
2178     { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER      # arrowhorizex (CUS) */
2179     { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF     # registersans (CUS) */
2180     { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF      # copyrightsans (CUS) */
2181     { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF     # trademarksans (CUS) */
2182     { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
2183     { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER    # parenleftex (CUS) */
2184     { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM      # parenleftbt (CUS) */
2185     { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP        # bracketlefttp (CUS) */
2186     { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER   # bracketleftex (CUS) */
2187     { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM     # bracketleftbt (CUS) */
2188     { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
2189     { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
2190     { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM      # braceleftbt (CUS) */
2191     { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
2192     { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER      # integralex (CUS) */
2193     { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP        # parenrighttp (CUS) */
2194     { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER   # parenrightex (CUS) */
2195     { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM     # parenrightbt (CUS) */
2196     { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP       # bracketrighttp (CUS) */
2197     { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER  # bracketrightex (CUS) */
2198     { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM    # bracketrightbt (CUS) */
2199     { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP        # bracerighttp (CUS) */
2200     { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID        # bracerightmid (CUS) */
2201     { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM     # bracerightbt (CUS) */
2202 };
2203
2204 static const FcCharMap AdobeSymbol = {
2205     AdobeSymbolEnt,
2206     sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
2207 };
2208
2209 static const FcFontDecode fcFontDecoders[] = {
2210     { ft_encoding_unicode,      0,              (1 << 21) - 1 },
2211     { ft_encoding_symbol,       &AdobeSymbol,   (1 << 16) - 1 },
2212     { ft_encoding_apple_roman,  &AppleRoman,    (1 << 16) - 1 },
2213 };
2214
2215 #define NUM_DECODE  (int) (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
2216
2217 static const FcChar32   prefer_unicode[] = {
2218     0x20ac,     /* EURO SIGN */
2219 };
2220
2221 #define NUM_PREFER_UNICODE  (int) (sizeof (prefer_unicode) / sizeof (prefer_unicode[0]))
2222
2223 FcChar32
2224 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
2225 {
2226     int         low, high, mid;
2227     FcChar16    bmp;
2228
2229     low = 0;
2230     high = map->nent - 1;
2231     if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
2232         return ~0;
2233     while (low <= high)
2234     {
2235         mid = (high + low) >> 1;
2236         bmp = map->ent[mid].bmp;
2237         if (ucs4 == bmp)
2238             return (FT_ULong) map->ent[mid].encode;
2239         if (ucs4 < bmp)
2240             high = mid - 1;
2241         else
2242             low = mid + 1;
2243     }
2244     return ~0;
2245 }
2246
2247 FcChar32
2248 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
2249 {
2250     int     i;
2251
2252     for (i = 0; i < map->nent; i++)
2253         if (map->ent[i].encode == private)
2254             return (FcChar32) map->ent[i].bmp;
2255     return ~0;
2256 }
2257
2258 const FcCharMap *
2259 FcFreeTypeGetPrivateMap (FT_Encoding encoding)
2260 {
2261     int i;
2262
2263     for (i = 0; i < NUM_DECODE; i++)
2264         if (fcFontDecoders[i].encoding == encoding)
2265             return fcFontDecoders[i].map;
2266     return 0;
2267 }
2268
2269 #include "../fc-glyphname/fcglyphname.h"
2270
2271 static FcChar32
2272 FcHashGlyphName (const FcChar8 *name)
2273 {
2274     FcChar32    h = 0;
2275     FcChar8     c;
2276
2277     while ((c = *name++))
2278     {
2279         h = ((h << 1) | (h >> 31)) ^ c;
2280     }
2281     return h;
2282 }
2283
2284 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2285 /*
2286  * Use Type1 glyph names for fonts which have reliable names
2287  * and which export an Adobe Custom mapping
2288  */
2289 static FcBool
2290 FcFreeTypeUseNames (FT_Face face)
2291 {
2292     FT_Int  map;
2293
2294     if (!FT_Has_PS_Glyph_Names (face))
2295         return FcFalse;
2296     for (map = 0; map < face->num_charmaps; map++)
2297         if (face->charmaps[map]->encoding == ft_encoding_adobe_custom)
2298             return FcTrue;
2299     return FcFalse;
2300 }
2301
2302 static const FcChar8 *
2303 FcUcs4ToGlyphName (FcChar32 ucs4)
2304 {
2305     int         i = (int) (ucs4 % FC_GLYPHNAME_HASH);
2306     int         r = 0;
2307     FcGlyphId   gn;
2308
2309     while ((gn = ucs_to_name[i]) != -1)
2310     {
2311         if (glyphs[gn].ucs == ucs4)
2312             return glyphs[gn].name;
2313         if (!r)
2314         {
2315             r = (int) (ucs4 % FC_GLYPHNAME_REHASH);
2316             if (!r)
2317                 r = 1;
2318         }
2319         i += r;
2320         if (i >= FC_GLYPHNAME_HASH)
2321             i -= FC_GLYPHNAME_HASH;
2322     }
2323     return 0;
2324 }
2325
2326 static FcChar32
2327 FcGlyphNameToUcs4 (FcChar8 *name)
2328 {
2329     FcChar32    h = FcHashGlyphName (name);
2330     int         i = (int) (h % FC_GLYPHNAME_HASH);
2331     int         r = 0;
2332     FcGlyphId   gn;
2333
2334     while ((gn = name_to_ucs[i]) != -1)
2335     {
2336         if (!strcmp ((char *) name, (char *) glyphs[gn].name))
2337             return glyphs[gn].ucs;
2338         if (!r)
2339         {
2340             r = (int) (h % FC_GLYPHNAME_REHASH);
2341             if (!r)
2342                 r = 1;
2343         }
2344         i += r;
2345         if (i >= FC_GLYPHNAME_HASH)
2346             i -= FC_GLYPHNAME_HASH;
2347     }
2348     return 0xffff;
2349 }
2350
2351 /*
2352  * Work around a bug in some FreeType versions which fail
2353  * to correctly bounds check glyph name buffers and overwrite
2354  * the stack. As Postscript names have a limit of 127 characters,
2355  * this should be sufficient.
2356  */
2357
2358 #if FC_GLYPHNAME_MAXLEN < 127
2359 # define FC_GLYPHNAME_BUFLEN 127
2360 #else
2361 # define FC_GLYPHNAME_BUFLEN FC_GLYPHNAME_MAXLEN
2362 #endif
2363
2364 /*
2365  * Search through a font for a glyph by name.  This is
2366  * currently a linear search as there doesn't appear to be
2367  * any defined order within the font
2368  */
2369 static FT_UInt
2370 FcFreeTypeGlyphNameIndex (FT_Face face, const FcChar8 *name)
2371 {
2372     FT_UInt gindex;
2373     FcChar8 name_buf[FC_GLYPHNAME_BUFLEN + 2];
2374
2375     for (gindex = 0; gindex < (FT_UInt) face->num_glyphs; gindex++)
2376     {
2377         if (FT_Get_Glyph_Name (face, gindex, name_buf, FC_GLYPHNAME_BUFLEN+1) == 0)
2378             if (!strcmp ((char *) name, (char *) name_buf))
2379                 return gindex;
2380     }
2381     return 0;
2382 }
2383 #endif
2384
2385 /*
2386  * Map a UCS4 glyph to a glyph index.  Use all available encoding
2387  * tables to try and find one that works.  This information is expected
2388  * to be cached by higher levels, so performance isn't critical
2389  */
2390
2391 FT_UInt
2392 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
2393 {
2394     int             initial, offset, decode;
2395     FT_UInt         glyphindex;
2396     FcChar32        charcode;
2397     int             p;
2398
2399     initial = 0;
2400
2401     if (!face)
2402         return 0;
2403
2404     /*
2405      * Find the current encoding
2406      */
2407     if (face->charmap)
2408     {
2409         for (; initial < NUM_DECODE; initial++)
2410             if (fcFontDecoders[initial].encoding == face->charmap->encoding)
2411                 break;
2412         if (initial == NUM_DECODE)
2413             initial = 0;
2414     }
2415     for (p = 0; p < NUM_PREFER_UNICODE; p++)
2416         if (ucs4 == prefer_unicode[p])
2417         {
2418             initial = 0;
2419             break;
2420         }
2421     /*
2422      * Check each encoding for the glyph, starting with the current one
2423      */
2424     for (offset = 0; offset < NUM_DECODE; offset++)
2425     {
2426         decode = (initial + offset) % NUM_DECODE;
2427         if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
2428             if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
2429                 continue;
2430         if (fcFontDecoders[decode].map)
2431         {
2432             charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
2433             if (charcode == ~0U)
2434                 continue;
2435         }
2436         else
2437             charcode = ucs4;
2438         glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
2439         if (glyphindex)
2440             return glyphindex;
2441     }
2442 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2443     /*
2444      * Check postscript name table if present
2445      */
2446     if (FcFreeTypeUseNames (face))
2447     {
2448         const FcChar8   *name = FcUcs4ToGlyphName (ucs4);
2449         if (name)
2450         {
2451             glyphindex = FcFreeTypeGlyphNameIndex (face, name);
2452             if (glyphindex)
2453                 return glyphindex;
2454         }
2455     }
2456 #endif
2457     return 0;
2458 }
2459
2460 static FcBool
2461 FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
2462                       FT_UInt glyph, FcBlanks *blanks,
2463                       FT_Pos *advance)
2464 {
2465     FT_Int          load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
2466     FT_GlyphSlot    slot;
2467
2468     /*
2469      * When using scalable fonts, only report those glyphs
2470      * which can be scaled; otherwise those fonts will
2471      * only be available at some sizes, and never when
2472      * transformed.  Avoid this by simply reporting bitmap-only
2473      * glyphs as missing
2474      */
2475     if (face->face_flags & FT_FACE_FLAG_SCALABLE)
2476         load_flags |= FT_LOAD_NO_BITMAP;
2477
2478     if (FT_Load_Glyph (face, glyph, load_flags))
2479         return FcFalse;
2480
2481     slot = face->glyph;
2482     if (!glyph)
2483         return FcFalse;
2484
2485     *advance = slot->metrics.horiAdvance;
2486
2487     switch (slot->format) {
2488     case ft_glyph_format_bitmap:
2489         /*
2490          * Bitmaps are assumed to be reasonable; if
2491          * this proves to be a rash assumption, this
2492          * code can be easily modified
2493          */
2494         return FcTrue;
2495     case ft_glyph_format_outline:
2496         /*
2497          * Glyphs with contours are always OK
2498          */
2499         if (slot->outline.n_contours != 0)
2500             return FcTrue;
2501         /*
2502          * Glyphs with no contours are only OK if
2503          * they're members of the Blanks set specified
2504          * in the configuration.  If blanks isn't set,
2505          * then allow any glyph to be blank
2506          */
2507         if (!blanks || FcBlanksIsMember (blanks, ucs4))
2508             return FcTrue;
2509         /* fall through ... */
2510     default:
2511         break;
2512     }
2513     return FcFalse;
2514 }
2515
2516 #define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
2517 #define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
2518 #define FC_ABS(a)   ((a) < 0 ? -(a) : (a))
2519 #define APPROXIMATELY_EQUAL(x,y) (FC_ABS ((x) - (y)) <= FC_MAX (FC_ABS (x), FC_ABS (y)) / 33)
2520
2521 FcCharSet *
2522 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
2523 {
2524     FcChar32        page, off, ucs4;
2525 #ifdef CHECK
2526     FcChar32        font_max = 0;
2527 #endif
2528     FcCharSet       *fcs;
2529     FcCharLeaf      *leaf;
2530     const FcCharMap *map;
2531     int             o;
2532     int             i;
2533     FT_UInt         glyph;
2534     FT_Pos          advance, advance_one = 0, advance_two = 0;
2535     FcBool          has_advance = FcFalse, fixed_advance = FcTrue, dual_advance = FcFalse;
2536
2537     fcs = FcCharSetCreate ();
2538     if (!fcs)
2539         goto bail0;
2540
2541 #ifdef CHECK
2542     printf ("Family %s style %s\n", face->family_name, face->style_name);
2543 #endif
2544     for (o = 0; o < NUM_DECODE; o++)
2545     {
2546         if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
2547             continue;
2548         map = fcFontDecoders[o].map;
2549         if (map)
2550         {
2551             /*
2552              * Non-Unicode tables are easy; there's a list of all possible
2553              * characters
2554              */
2555             for (i = 0; i < map->nent; i++)
2556             {
2557                 ucs4 = map->ent[i].bmp;
2558                 glyph = FT_Get_Char_Index (face, map->ent[i].encode);
2559                 if (glyph &&
2560                     FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2561                 {
2562                     /*
2563                      * ignore glyphs with zero advance. They’re
2564                      * combining characters, and while their behaviour
2565                      * isn’t well defined for monospaced applications in
2566                      * Unicode, there are many fonts which include
2567                      * zero-width combining characters in otherwise
2568                      * monospaced fonts.
2569                      */
2570                     if (advance)
2571                     {
2572                         if (!has_advance)
2573                         {
2574                             has_advance = FcTrue;
2575                             advance_one = advance;
2576                         }
2577                         else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2578                         {
2579                             if (fixed_advance)
2580                             {
2581                                 dual_advance = FcTrue;
2582                                 fixed_advance = FcFalse;
2583                                 advance_two = advance;
2584                             }
2585                             else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2586                                 dual_advance = FcFalse;
2587                         }
2588                     }
2589
2590                     leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2591                     if (!leaf)
2592                         goto bail1;
2593                     leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
2594 #ifdef CHECK
2595                     if (ucs4 > font_max)
2596                         font_max = ucs4;
2597 #endif
2598                 }
2599             }
2600         }
2601         else
2602         {
2603             page = ~0;
2604             leaf = NULL;
2605             ucs4 = FT_Get_First_Char (face, &glyph);
2606             while (glyph != 0)
2607             {
2608                 if (FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2609                 {
2610                     if (advance)
2611                     {
2612                         if (!has_advance)
2613                         {
2614                             has_advance = FcTrue;
2615                             advance_one = advance;
2616                         }
2617                         else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2618                         {
2619                             if (fixed_advance)
2620                             {
2621                                 dual_advance = FcTrue;
2622                                 fixed_advance = FcFalse;
2623                                 advance_two = advance;
2624                             }
2625                             else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2626                                 dual_advance = FcFalse;
2627                         }
2628                     }
2629
2630                     if ((ucs4 >> 8) != page)
2631                     {
2632                         page = (ucs4 >> 8);
2633                         leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2634                         if (!leaf)
2635                             goto bail1;
2636                     }
2637                     off = ucs4 & 0xff;
2638                     leaf->map[off >> 5] |= (1 << (off & 0x1f));
2639 #ifdef CHECK
2640                     if (ucs4 > font_max)
2641                         font_max = ucs4;
2642 #endif
2643                 }
2644                 ucs4 = FT_Get_Next_Char (face, ucs4, &glyph);
2645             }
2646 #ifdef CHECK
2647             for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
2648             {
2649                 FcBool      FT_Has, FC_Has;
2650
2651                 FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
2652                 FC_Has = FcCharSetHasChar (fcs, ucs4);
2653                 if (FT_Has != FC_Has)
2654                 {
2655                     printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
2656                 }
2657             }
2658 #endif
2659         }
2660     }
2661 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2662     /*
2663      * Add mapping from PS glyph names if available
2664      */
2665     if (FcFreeTypeUseNames (face))
2666     {
2667         FcChar8 name_buf[FC_GLYPHNAME_BUFLEN + 2];
2668
2669         for (glyph = 0; glyph < (FT_UInt) face->num_glyphs; glyph++)
2670         {
2671             if (FT_Get_Glyph_Name (face, glyph, name_buf, FC_GLYPHNAME_BUFLEN+1) == 0)
2672             {
2673                 ucs4 = FcGlyphNameToUcs4 (name_buf);
2674                 if (ucs4 != 0xffff &&
2675                     FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2676                 {
2677                     if (advance)
2678                     {
2679                         if (!has_advance)
2680                         {
2681                             has_advance = FcTrue;
2682                             advance_one = advance;
2683                         }
2684                         else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2685                         {
2686                             if (fixed_advance)
2687                             {
2688                                 dual_advance = FcTrue;
2689                                 fixed_advance = FcFalse;
2690                                 advance_two = advance;
2691                             }
2692                             else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2693                                 dual_advance = FcFalse;
2694                         }
2695                     }
2696                     leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2697                     if (!leaf)
2698                         goto bail1;
2699                     leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
2700 #ifdef CHECK
2701                     if (ucs4 > font_max)
2702                         font_max = ucs4;
2703 #endif
2704                 }
2705             }
2706         }
2707     }
2708 #endif
2709 #ifdef CHECK
2710     printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
2711     for (ucs4 = 0; ucs4 <= font_max; ucs4++)
2712     {
2713         FcBool  has_char = (glyph = FcFreeTypeCharIndex (face, ucs4)) != 0;
2714         FcBool  has_bit = FcCharSetHasChar (fcs, ucs4);
2715
2716         if (has_char && !has_bit)
2717         {
2718             if (!FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2719                 printf ("Bitmap missing broken char 0x%x\n", ucs4);
2720             else
2721                 printf ("Bitmap missing char 0x%x\n", ucs4);
2722         }
2723         else if (!has_char && has_bit)
2724             printf ("Bitmap extra char 0x%x\n", ucs4);
2725     }
2726 #endif
2727     if (fixed_advance)
2728         *spacing = FC_MONO;
2729     else if (dual_advance && APPROXIMATELY_EQUAL (2 * FC_MIN (advance_one, advance_two), FC_MAX (advance_one, advance_two)))
2730         *spacing = FC_DUAL;
2731     else
2732         *spacing = FC_PROPORTIONAL;
2733     return fcs;
2734 bail1:
2735     FcCharSetDestroy (fcs);
2736 bail0:
2737     return 0;
2738 }
2739
2740 FcCharSet *
2741 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
2742 {
2743     int spacing;
2744
2745     return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
2746 }
2747
2748
2749 #define TTAG_GPOS  FT_MAKE_TAG( 'G', 'P', 'O', 'S' )
2750 #define TTAG_GSUB  FT_MAKE_TAG( 'G', 'S', 'U', 'B' )
2751 #define TTAG_SILF  FT_MAKE_TAG( 'S', 'i', 'l', 'f')
2752 #define TT_Err_Ok FT_Err_Ok
2753 #define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle
2754 #define TTO_Err_Empty_Script              0x1005
2755 #define TTO_Err_Invalid_SubTable          0x1001
2756
2757 #define OTLAYOUT_HEAD       "otlayout:"
2758 #define OTLAYOUT_HEAD_LEN   9
2759 #define OTLAYOUT_ID_LEN     4
2760 /* space + head + id */
2761 #define OTLAYOUT_LEN        (1 + OTLAYOUT_HEAD_LEN + OTLAYOUT_ID_LEN)
2762
2763 /*
2764  * This is a bit generous; the registry has only lower case and space
2765  * except for 'DFLT'.
2766  */
2767 #define FcIsSpace(x)        (040 == (x))
2768 #define FcIsValidScript(x)  (FcIsLower(x) || FcIsUpper (x) || FcIsSpace(x))
2769
2770 static void
2771 addtag(FcChar8 *complex, FT_ULong tag)
2772 {
2773     FcChar8 tagstring[OTLAYOUT_ID_LEN + 1];
2774
2775     tagstring[0] = (FcChar8)(tag >> 24),
2776     tagstring[1] = (FcChar8)(tag >> 16),
2777     tagstring[2] = (FcChar8)(tag >> 8),
2778     tagstring[3] = (FcChar8)(tag);
2779     tagstring[4] = '\0';
2780
2781     /* skip tags which aren't alphabetic, under the assumption that
2782      * they're probably broken
2783      */
2784     if (!FcIsValidScript(tagstring[0]) ||
2785         !FcIsValidScript(tagstring[1]) ||
2786         !FcIsValidScript(tagstring[2]) ||
2787         !FcIsValidScript(tagstring[3]))
2788         return;
2789
2790     if (*complex != '\0')
2791         strcat ((char *) complex, " ");
2792     strcat ((char *) complex, "otlayout:");
2793     strcat ((char *) complex, (char *) tagstring);
2794 }
2795
2796 static int
2797 compareulong (const void *a, const void *b)
2798 {
2799     const FT_ULong *ua = (const FT_ULong *) a;
2800     const FT_ULong *ub = (const FT_ULong *) b;
2801     return *ua - *ub;
2802 }
2803
2804
2805 static FT_Error
2806 GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *script_count)
2807 {
2808     FT_ULong         cur_offset, new_offset, base_offset;
2809     FT_Stream  stream = face->stream;
2810     FT_Error   error;
2811     FT_UShort          n, p;
2812     FT_Memory  memory;
2813
2814     if ( !stream )
2815         return TT_Err_Invalid_Face_Handle;
2816
2817     memory = stream->memory;
2818
2819     if (( error = ftglue_face_goto_table( face, tabletag, stream ) ))
2820         return error;
2821
2822     base_offset = ftglue_stream_pos ( stream );
2823
2824     /* skip version */
2825
2826     if ( ftglue_stream_seek ( stream, base_offset + 4L ) || ftglue_stream_frame_enter( stream, 2L ) )
2827         return error;
2828
2829     new_offset = GET_UShort() + base_offset;
2830
2831     ftglue_stream_frame_exit( stream );
2832
2833     cur_offset = ftglue_stream_pos( stream );
2834
2835     if ( ftglue_stream_seek( stream, new_offset ) != TT_Err_Ok )
2836         return error;
2837
2838     base_offset = ftglue_stream_pos( stream );
2839
2840     if ( ftglue_stream_frame_enter( stream, 2L ) )
2841         return error;
2842
2843     *script_count = GET_UShort ();
2844
2845     ftglue_stream_frame_exit( stream );
2846
2847     *stags = ftglue_alloc(memory, *script_count * sizeof( FT_ULong ), &error);
2848
2849     if (error)
2850         return error;
2851
2852     p = 0;
2853     for ( n = 0; n < *script_count; n++ )
2854     {
2855         if ( ftglue_stream_frame_enter( stream, 6L ) )
2856             goto Fail;
2857
2858         (*stags)[p] = GET_ULong ();
2859         new_offset = GET_UShort () + base_offset;
2860
2861         ftglue_stream_frame_exit( stream );
2862
2863         cur_offset = ftglue_stream_pos( stream );
2864
2865         error = ftglue_stream_seek( stream, new_offset );
2866
2867         if ( error == TT_Err_Ok )
2868             p++;
2869
2870         (void)ftglue_stream_seek( stream, cur_offset );
2871     }
2872
2873     if (!p)
2874     {
2875         error = TTO_Err_Invalid_SubTable;
2876         goto Fail;
2877     }
2878
2879     /* sort the tag list before returning it */
2880     qsort(*stags, *script_count, sizeof(FT_ULong), compareulong);
2881
2882     return TT_Err_Ok;
2883
2884 Fail:
2885     *script_count = 0;
2886     ftglue_free( memory, *stags );
2887     *stags = NULL;
2888     return error;
2889 }
2890
2891 static FcChar8 *
2892 FcFontCapabilities(FT_Face face)
2893 {
2894     FcBool issilgraphitefont = 0;
2895     FT_Error err;
2896     FT_ULong len = 0;
2897     FT_ULong *gsubtags=NULL, *gpostags=NULL;
2898     FT_UShort gsub_count=0, gpos_count=0;
2899     FT_ULong maxsize;
2900     FT_Memory  memory = face->stream->memory;
2901     FcChar8 *complex = NULL;
2902     int indx1 = 0, indx2 = 0;
2903
2904     err = FT_Load_Sfnt_Table(face, TTAG_SILF, 0, 0, &len);
2905     issilgraphitefont = ( err == FT_Err_Ok);
2906
2907     if (GetScriptTags(face, TTAG_GPOS, &gpostags, &gpos_count) != FT_Err_Ok)
2908         gpos_count = 0;
2909     if (GetScriptTags(face, TTAG_GSUB, &gsubtags, &gsub_count) != FT_Err_Ok)
2910         gsub_count = 0;
2911
2912     if (!issilgraphitefont && !gsub_count && !gpos_count)
2913         goto bail;
2914
2915     maxsize = (((FT_ULong) gpos_count + (FT_ULong) gsub_count) * OTLAYOUT_LEN +
2916                (issilgraphitefont ? 13 : 0));
2917     complex = malloc (sizeof (FcChar8) * maxsize);
2918     if (!complex)
2919         goto bail;
2920
2921     complex[0] = '\0';
2922     if (issilgraphitefont)
2923         strcpy((char *) complex, "ttable:Silf ");
2924
2925     while ((indx1 < gsub_count) || (indx2 < gpos_count)) {
2926         if (indx1 == gsub_count) {
2927             addtag(complex, gpostags[indx2]);
2928             indx2++;
2929         } else if ((indx2 == gpos_count) || (gsubtags[indx1] < gpostags[indx2])) {
2930             addtag(complex, gsubtags[indx1]);
2931             indx1++;
2932         } else if (gsubtags[indx1] == gpostags[indx2]) {
2933             addtag(complex, gsubtags[indx1]);
2934             indx1++;
2935             indx2++;
2936         } else {
2937             addtag(complex, gpostags[indx2]);
2938             indx2++;
2939         }
2940     }
2941     if (FcDebug () & FC_DBG_SCANV)
2942         printf("complex features in this font: %s\n", complex);
2943 bail:
2944     ftglue_free(memory, gsubtags);
2945     ftglue_free(memory, gpostags);
2946     return complex;
2947 }
2948
2949 #define __fcfreetype__
2950 #include "fcaliastail.h"
2951 #undef __fcfreetype__