ftfont.c 74.2 KB
Newer Older
Kenichi Handa's avatar
Kenichi Handa committed
1
/* ftfont.c -- FreeType font driver.
Paul Eggert's avatar
Paul Eggert committed
2
   Copyright (C) 2006-2019 Free Software Foundation, Inc.
3
   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
Kenichi Handa's avatar
Kenichi Handa committed
4 5 6 7 8
     National Institute of Advanced Industrial Science and Technology (AIST)
     Registration Number H13PRO009

This file is part of GNU Emacs.

9
GNU Emacs is free software: you can redistribute it and/or modify
Kenichi Handa's avatar
Kenichi Handa committed
10
it under the terms of the GNU General Public License as published by
11 12
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
Kenichi Handa's avatar
Kenichi Handa committed
13 14 15 16 17 18 19

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
20
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
Kenichi Handa's avatar
Kenichi Handa committed
21 22 23 24 25 26

#include <config.h>
#include <stdio.h>
#include <fontconfig/fontconfig.h>
#include <fontconfig/fcfreetype.h>

27 28 29 30 31 32 33 34 35 36 37
/* These two blocks are here because this file is built when using XFT
   and when using Cairo, so struct font_info in ftfont.h needs access
   to the appropriate types.  */
#ifdef HAVE_XFT
# include <X11/Xlib.h>
# include <X11/Xft/Xft.h>
#endif
#ifdef USE_CAIRO
# include <cairo-ft.h>
#endif

38 39
#include <c-strcase.h>

Kenichi Handa's avatar
Kenichi Handa committed
40 41 42 43
#include "lisp.h"
#include "dispextern.h"
#include "character.h"
#include "charset.h"
44
#include "category.h"
Kenichi Handa's avatar
Kenichi Handa committed
45
#include "composite.h"
Kenichi Handa's avatar
Kenichi Handa committed
46
#include "font.h"
47
#include "ftfont.h"
Daniel Colascione's avatar
Daniel Colascione committed
48
#include "pdumper.h"
Kenichi Handa's avatar
Kenichi Handa committed
49

50 51
static struct font_driver const ftfont_driver;

Juanma Barranquero's avatar
Juanma Barranquero committed
52
/* Flag to tell if FcInit is already called or not.  */
53
static bool fc_initialized;
54 55

/* Handle to a FreeType library instance.  */
Kenichi Handa's avatar
Kenichi Handa committed
56 57
static FT_Library ft_library;

58
/* Cache for FreeType fonts.  */
Kenichi Handa's avatar
Kenichi Handa committed
59 60
static Lisp_Object freetype_font_cache;

61
/* Cache for FT_Face and FcCharSet. */
Kenichi Handa's avatar
Kenichi Handa committed
62
static Lisp_Object ft_face_cache;
Kenichi Handa's avatar
Kenichi Handa committed
63

64 65 66 67 68 69 70
enum ftfont_cache_for
  {
    FTFONT_CACHE_FOR_FACE,
    FTFONT_CACHE_FOR_CHARSET,
    FTFONT_CACHE_FOR_ENTITY
  };

71 72
static Lisp_Object ftfont_lookup_cache (Lisp_Object,
                                        enum ftfont_cache_for);
73

74 75
#define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))

Kenichi Handa's avatar
Kenichi Handa committed
76
static struct
Kenichi Handa's avatar
Kenichi Handa committed
77
{
78
  /* registry name */
79
  const char *name;
Kenichi Handa's avatar
Kenichi Handa committed
80 81
  /* characters to distinguish the charset from the others */
  int uniquifier[6];
82
  /* additional constraint by language */
83
  const char *lang;
Kenichi Handa's avatar
Kenichi Handa committed
84 85 86
  /* set on demand */
  FcCharSet *fc_charset;
} fc_charset_table[] =
87
  { { "iso8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 } },
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
    { "iso8859-2", { 0x00A0, 0x010E }},
    { "iso8859-3", { 0x00A0, 0x0108 }},
    { "iso8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }},
    { "iso8859-5", { 0x00A0, 0x0401 }},
    { "iso8859-6", { 0x00A0, 0x060C }},
    { "iso8859-7", { 0x00A0, 0x0384 }},
    { "iso8859-8", { 0x00A0, 0x05D0 }},
    { "iso8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }},
    { "iso8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }},
    { "iso8859-11", { 0x00A0, 0x0E01 }},
    { "iso8859-13", { 0x00A0, 0x201C }},
    { "iso8859-14", { 0x00A0, 0x0174 }},
    { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
    { "iso8859-16", { 0x00A0, 0x0218}},
    { "gb2312.1980-0", { 0x4E13 }, "zh-cn"},
    { "big5-0", { 0xF6B1 }, "zh-tw" },
    { "jisx0208.1983-0", { 0x4E55 }, "ja"},
    { "ksc5601.1985-0", { 0xAC00 }, "ko"},
    { "cns11643.1992-1", { 0xFE32 }, "zh-tw"},
    { "cns11643.1992-2", { 0x4E33, 0x7934 }},
    { "cns11643.1992-3", { 0x201A9 }},
    { "cns11643.1992-4", { 0x20057 }},
    { "cns11643.1992-5", { 0x20000 }},
    { "cns11643.1992-6", { 0x20003 }},
    { "cns11643.1992-7", { 0x20055 }},
    { "gbk-0", { 0x4E06 }, "zh-cn"},
    { "jisx0212.1990-0", { 0x4E44 }},
    { "jisx0213.2000-1", { 0xFA10 }, "ja"},
    { "jisx0213.2000-2", { 0xFA49 }},
    { "jisx0213.2004-1", { 0x20B9F }},
    { "viscii1.1-1", { 0x1EA0, 0x1EAE, 0x1ED2 }, "vi"},
    { "tis620.2529-1", { 0x0E01 }, "th"},
120 121
    { "windows-1251", { 0x0401, 0x0490 }, "ru"},
    { "koi8-r", { 0x0401, 0x2219 }, "ru"},
122
    { "mulelao-1", { 0x0E81 }, "lo"},
123
    { "unicode-sip", { 0x20000 }},
Kenichi Handa's avatar
Kenichi Handa committed
124 125
    { NULL }
  };
Kenichi Handa's avatar
Kenichi Handa committed
126

127 128 129 130 131 132
static bool
matching_prefix (char const *str, ptrdiff_t len, char const *pat)
{
  return len == strlen (pat) && c_strncasecmp (str, pat, len) == 0;
}

Kenichi Handa's avatar
Kenichi Handa committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
/* Dirty hack for handing ADSTYLE property.

   Fontconfig (actually the underlying FreeType) gives such ADSTYLE
   font property of PCF/BDF fonts in FC_STYLE.  And, "Bold",
   "Oblique", "Italic", or any non-normal SWIDTH property names
   (e.g. SemiCondensed) are appended.  In addition, if there's no
   ADSTYLE property nor non-normal WEIGHT/SLANT/SWIDTH properties,
   "Regular" is used for FC_STYLE (see the function
   pcf_interpret_style in src/pcf/pcfread.c of FreeType).

   Unfortunately this behavior is not documented, so the following
   code may fail if FreeType changes the behavior in the future.  */

static Lisp_Object
get_adstyle_property (FcPattern *p)
{
149 150
  FcChar8 *fcstr;
  char *str, *end;
Kenichi Handa's avatar
Kenichi Handa committed
151 152
  Lisp_Object adstyle;

153 154
#ifdef FC_FONTFORMAT
  if ((FcPatternGetString (p, FC_FONTFORMAT, 0, &fcstr) == FcResultMatch)
155 156
      && xstrcasecmp ((char *) fcstr, "bdf") != 0
      && xstrcasecmp ((char *) fcstr, "pcf") != 0)
157 158 159
    /* Not a BDF nor PCF font.  */
    return Qnil;
#endif
160
  if (FcPatternGetString (p, FC_STYLE, 0, &fcstr) != FcResultMatch)
Kenichi Handa's avatar
Kenichi Handa committed
161
    return Qnil;
162
  str = (char *) fcstr;
Kenichi Handa's avatar
Kenichi Handa committed
163
  for (end = str; *end && *end != ' '; end++);
164 165 166 167
  if (matching_prefix (str, end - str, "Regular")
      || matching_prefix (str, end - str, "Bold")
      || matching_prefix (str, end - str, "Oblique")
      || matching_prefix (str, end - str, "Italic"))
Kenichi Handa's avatar
Kenichi Handa committed
168
    return Qnil;
169
  adstyle = font_intern_prop (str, end - str, 1);
Kenichi Handa's avatar
Kenichi Handa committed
170 171 172 173 174
  if (font_style_to_value (FONT_WIDTH_INDEX, adstyle, 0) >= 0)
    return Qnil;
  return adstyle;
}

175
static Lisp_Object
176
ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
177
{
178
  Lisp_Object key, cache, entity;
179 180
  FcChar8 *str;
  char *file;
181
  int idx;
182 183
  int numeric;
  double dbl;
184
  FcBool b;
185

186
  if (FcPatternGetString (p, FC_FILE, 0, &str) != FcResultMatch)
187
    return Qnil;
188
  if (FcPatternGetInteger (p, FC_INDEX, 0, &idx) != FcResultMatch)
189
    return Qnil;
190

191
  file = (char *) str;
192
  key = Fcons (build_unibyte_string (file), make_fixnum (idx));
193 194 195
  cache = ftfont_lookup_cache (key, FTFONT_CACHE_FOR_ENTITY);
  entity = XCAR (cache);
  if (! NILP (entity))
196 197 198 199 200 201
    {
      Lisp_Object val = font_make_entity ();
      int i;

      for (i = 0; i < FONT_OBJLIST_INDEX; i++)
	ASET (val, i, AREF (entity, i));
202 203 204 205

      ASET (val, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
      font_put_extra (val, QCfont_entity, key);

206 207
      return val;
    }
208
  entity = font_make_entity ();
209
  XSETCAR (cache, entity);
210 211

  ASET (entity, FONT_TYPE_INDEX, Qfreetype);
212
  ASET (entity, FONT_REGISTRY_INDEX, Qiso10646_1);
213

214 215 216 217 218 219 220 221 222 223
  if (FcPatternGetString (p, FC_FOUNDRY, 0, &str) == FcResultMatch)
    {
      char *s = (char *) str;
      ASET (entity, FONT_FOUNDRY_INDEX, font_intern_prop (s, strlen (s), 1));
    }
  if (FcPatternGetString (p, FC_FAMILY, 0, &str) == FcResultMatch)
    {
      char *s = (char *) str;
      ASET (entity, FONT_FAMILY_INDEX, font_intern_prop (s, strlen (s), 1));
    }
224
  if (FcPatternGetInteger (p, FC_WEIGHT, 0, &numeric) == FcResultMatch)
225
    {
226 227
      if (numeric >= FC_WEIGHT_REGULAR && numeric < FC_WEIGHT_MEDIUM)
	numeric = FC_WEIGHT_MEDIUM;
228
      FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, make_fixnum (numeric));
229
    }
230
  if (FcPatternGetInteger (p, FC_SLANT, 0, &numeric) == FcResultMatch)
231 232
    {
      numeric += 100;
233
      FONT_SET_STYLE (entity, FONT_SLANT_INDEX, make_fixnum (numeric));
234
    }
235
  if (FcPatternGetInteger (p, FC_WIDTH, 0, &numeric) == FcResultMatch)
236
    {
237
      FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_fixnum (numeric));
238
    }
239
  if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
Kenichi Handa's avatar
Kenichi Handa committed
240
    {
241
      ASET (entity, FONT_SIZE_INDEX, make_fixnum (dbl));
Kenichi Handa's avatar
Kenichi Handa committed
242
    }
243
  else
244
    ASET (entity, FONT_SIZE_INDEX, make_fixnum (0));
245
  if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) == FcResultMatch)
246
    ASET (entity, FONT_SPACING_INDEX, make_fixnum (numeric));
247 248 249
  if (FcPatternGetDouble (p, FC_DPI, 0, &dbl) == FcResultMatch)
    {
      int dpi = dbl;
250
      ASET (entity, FONT_DPI_INDEX, make_fixnum (dpi));
251 252 253
    }
  if (FcPatternGetBool (p, FC_SCALABLE, 0, &b) == FcResultMatch
      && b == FcTrue)
254
    {
255 256
      ASET (entity, FONT_SIZE_INDEX, make_fixnum (0));
      ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (0));
257 258 259
    }
  else
    {
Paul Eggert's avatar
Paul Eggert committed
260
      /* As this font is not scalable, perhaps this is a BDF or PCF
261
	 font. */
262 263 264 265
      FT_Face ft_face;

      ASET (entity, FONT_ADSTYLE_INDEX, get_adstyle_property (p));
      if ((ft_library || FT_Init_FreeType (&ft_library) == 0)
266
	  && FT_New_Face (ft_library, file, idx, &ft_face) == 0)
267 268 269 270 271
	{
	  BDF_PropertyRec rec;

	  if (FT_Get_BDF_Property (ft_face, "AVERAGE_WIDTH", &rec) == 0
	      && rec.type == BDF_PROPERTY_TYPE_INTEGER)
272
	    ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (rec.u.integer));
273 274 275
	  FT_Done_Face (ft_face);
	}
    }
276

277
  ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
278
  font_put_extra (entity, QCfont_entity, key);
279 280 281
  return entity;
}

282

283 284 285
static Lisp_Object ftfont_generic_family_list;

static Lisp_Object
286
ftfont_resolve_generic_family (Lisp_Object family, FcPattern *pattern)
287
{
288
  Lisp_Object slot;
289
  FcPattern *match;
290
  FcResult result;
Kenichi Handa's avatar
Kenichi Handa committed
291
  FcLangSet *langset;
292

293
  family = Fintern (Fdowncase (SYMBOL_NAME (family)), Qnil);
294 295 296 297 298 299
  if (EQ (family, Qmono))
    family = Qmonospace;
  else if (EQ (family, Qsans) || EQ (family, Qsans__serif))
    family = Qsans_serif;
  slot = assq_no_quit (family, ftfont_generic_family_list);
  if (! CONSP (slot))
300
    return Qnil;
301 302
  if (! EQ (XCDR (slot), Qt))
    return XCDR (slot);
303
  pattern = FcPatternDuplicate (pattern);
304 305
  if (! pattern)
    goto err;
306
  FcPatternDel (pattern, FC_FOUNDRY);
307 308
  FcPatternDel (pattern, FC_FAMILY);
  FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (family));
Kenichi Handa's avatar
Kenichi Handa committed
309 310 311
  if (FcPatternGetLangSet (pattern, FC_LANG, 0, &langset) != FcResultMatch)
    {
      /* This is to avoid the effect of locale.  */
312
      static const FcChar8 lang[] = "en";
Kenichi Handa's avatar
Kenichi Handa committed
313
      langset = FcLangSetCreate ();
314
      FcLangSetAdd (langset, lang);
Kenichi Handa's avatar
Kenichi Handa committed
315 316 317
      FcPatternAddLangSet (pattern, FC_LANG, langset);
      FcLangSetDestroy (langset);
    }
318
  FcConfigSubstitute (NULL, pattern, FcMatchPattern);
319 320 321
  FcDefaultSubstitute (pattern);
  match = FcFontMatch (NULL, pattern, &result);
  if (match)
322
    {
323 324 325 326
      FcChar8 *fam;

      if (FcPatternGetString (match, FC_FAMILY, 0, &fam) == FcResultMatch)
	family = intern ((char *) fam);
327
    }
328 329 330 331
  else
    family = Qnil;
  XSETCDR (slot, family);
  if (match) FcPatternDestroy (match);
332
 err:
333
  if (pattern) FcPatternDestroy (pattern);
334
  return family;
335 336
}

337 338 339 340
struct ftfont_cache_data
{
  FT_Face ft_face;
  FcCharSet *fc_charset;
341
  intptr_t face_refcount;
342 343 344
};

static Lisp_Object
345
ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
Kenichi Handa's avatar
Kenichi Handa committed
346
{
Kenichi Handa's avatar
Kenichi Handa committed
347
  Lisp_Object cache, val, entity;
348
  struct ftfont_cache_data *cache_data;
Kenichi Handa's avatar
Kenichi Handa committed
349

Kenichi Handa's avatar
Kenichi Handa committed
350 351 352 353
  if (FONT_ENTITY_P (key))
    {
      entity = key;
      val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
354
      eassert (CONSP (val));
Kenichi Handa's avatar
Kenichi Handa committed
355 356 357 358 359
      key = XCDR (val);
    }
  else
    entity = Qnil;

360 361 362 363
  if (NILP (ft_face_cache))
    cache = Qnil;
  else
    cache = Fgethash (key, ft_face_cache, Qnil);
Kenichi Handa's avatar
Kenichi Handa committed
364 365
  if (NILP (cache))
    {
366
      if (NILP (ft_face_cache))
367
	ft_face_cache = CALLN (Fmake_hash_table, QCtest, Qequal);
368 369
      cache_data = xzalloc (sizeof *cache_data);
      val = make_mint_ptr (cache_data);
370 371
      cache = Fcons (Qnil, val);
      Fputhash (key, cache, ft_face_cache);
Kenichi Handa's avatar
Kenichi Handa committed
372 373 374
    }
  else
    {
375
      val = XCDR (cache);
376
      cache_data = xmint_pointer (val);
377
    }
378 379 380 381 382 383

  if (cache_for == FTFONT_CACHE_FOR_ENTITY)
    return cache;

  if (cache_for == FTFONT_CACHE_FOR_FACE
      ? ! cache_data->ft_face : ! cache_data->fc_charset)
384
    {
385
      char *filename = SSDATA (XCAR (key));
Tom Tromey's avatar
Tom Tromey committed
386
      int idx = XFIXNUM (XCDR (key));
Kenichi Handa's avatar
Kenichi Handa committed
387

388
      if (cache_for == FTFONT_CACHE_FOR_FACE)
389 390 391 392
	{
	  if (! ft_library
	      && FT_Init_FreeType (&ft_library) != 0)
	    return Qnil;
393
	  if (FT_New_Face (ft_library, filename, idx, &cache_data->ft_face)
394 395 396 397 398
	      != 0)
	    return Qnil;
	}
      else
	{
Kenichi Handa's avatar
Kenichi Handa committed
399 400 401 402
	  FcPattern *pat = NULL;
	  FcFontSet *fontset = NULL;
	  FcObjectSet *objset = NULL;
	  FcCharSet *charset = NULL;
403 404

	  pat = FcPatternBuild (0, FC_FILE, FcTypeString, (FcChar8 *) filename,
405
				FC_INDEX, FcTypeInteger, idx, NULL);
Kenichi Handa's avatar
Kenichi Handa committed
406 407 408 409 410
	  if (! pat)
	    goto finish;
	  objset = FcObjectSetBuild (FC_CHARSET, FC_STYLE, NULL);
	  if (! objset)
	    goto finish;
411
	  fontset = FcFontList (NULL, pat, objset);
Kenichi Handa's avatar
Kenichi Handa committed
412 413
	  if (! fontset)
	    goto finish;
414 415
	  if (fontset && fontset->nfont > 0
	      && (FcPatternGetCharSet (fontset->fonts[0], FC_CHARSET, 0,
416
				       &charset)
417 418
		  == FcResultMatch))
	    cache_data->fc_charset = FcCharSetCopy (charset);
419 420
	  else
	    cache_data->fc_charset = FcCharSetCreate ();
Kenichi Handa's avatar
Kenichi Handa committed
421 422 423 424 425 426 427 428

	finish:
	  if (fontset)
	    FcFontSetDestroy (fontset);
	  if (objset)
	    FcObjectSetDestroy (objset);
	  if (pat)
	    FcPatternDestroy (pat);
429
	}
Kenichi Handa's avatar
Kenichi Handa committed
430 431 432 433
    }
  return cache;
}

434
FcCharSet *
435
ftfont_get_fc_charset (Lisp_Object entity)
436 437 438 439
{
  Lisp_Object val, cache;
  struct ftfont_cache_data *cache_data;

440
  cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
441
  val = XCDR (cache);
442
  cache_data = xmint_pointer (val);
443 444 445 446 447
  return cache_data->fc_charset;
}

#ifdef HAVE_LIBOTF
static OTF *
448
ftfont_get_otf (struct font_info *ftfont_info)
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
{
  OTF *otf;

  if (ftfont_info->otf)
    return ftfont_info->otf;
  if (! ftfont_info->maybe_otf)
    return NULL;
  otf = OTF_open_ft_face (ftfont_info->ft_size->face);
  if (! otf || OTF_get_table (otf, "head") < 0)
    {
      if (otf)
	OTF_close (otf);
      ftfont_info->maybe_otf = 0;
      return NULL;
    }
  ftfont_info->otf = otf;
  return otf;
}
#endif	/* HAVE_LIBOTF */

469
Lisp_Object
Dmitry Antipov's avatar
Dmitry Antipov committed
470
ftfont_get_cache (struct frame *f)
Kenichi Handa's avatar
Kenichi Handa committed
471 472 473 474
{
  return freetype_font_cache;
}

Kenichi Handa's avatar
Kenichi Handa committed
475
static int
476
ftfont_get_charset (Lisp_Object registry)
Kenichi Handa's avatar
Kenichi Handa committed
477
{
478
  char *str = SSDATA (SYMBOL_NAME (registry));
479 480
  USE_SAFE_ALLOCA;
  char *re = SAFE_ALLOCA (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
Kenichi Handa's avatar
Kenichi Handa committed
481 482
  int i, j;

483 484 485 486 487 488 489 490 491 492 493
  for (i = j = 0; i < SBYTES (SYMBOL_NAME (registry)); i++, j++)
    {
      if (str[i] == '.')
	re[j++] = '\\';
      else if (str[i] == '*')
	re[j++] = '.';
      re[j] = str[i];
      if (re[j] == '?')
	re[j] = '.';
    }
  re[j] = '\0';
Paul Eggert's avatar
Paul Eggert committed
494
  AUTO_STRING_WITH_LEN (regexp, re, j);
Kenichi Handa's avatar
Kenichi Handa committed
495
  for (i = 0; fc_charset_table[i].name; i++)
496 497 498
    if (fast_c_string_match_ignore_case
	(regexp, fc_charset_table[i].name,
	 strlen (fc_charset_table[i].name)) >= 0)
Kenichi Handa's avatar
Kenichi Handa committed
499
      break;
Paul Eggert's avatar
Paul Eggert committed
500
  SAFE_FREE ();
Kenichi Handa's avatar
Kenichi Handa committed
501 502 503 504
  if (! fc_charset_table[i].name)
    return -1;
  if (! fc_charset_table[i].fc_charset)
    {
505 506
      FcCharSet *charset = FcCharSetCreate ();
      int *uniquifier = fc_charset_table[i].uniquifier;
Kenichi Handa's avatar
Kenichi Handa committed
507

508 509 510 511 512 513
      if (! charset)
	return -1;
      for (j = 0; uniquifier[j]; j++)
	if (! FcCharSetAddChar (charset, uniquifier[j]))
	  {
	    FcCharSetDestroy (charset);
Kenichi Handa's avatar
Kenichi Handa committed
514
	    return -1;
515 516
	  }
      fc_charset_table[i].fc_charset = charset;
Kenichi Handa's avatar
Kenichi Handa committed
517 518 519 520
    }
  return i;
}

521 522
struct OpenTypeSpec
{
523 524
  Lisp_Object script;
  unsigned int script_tag, langsys_tag;
525 526 527 528
  int nfeatures[2];
  unsigned int *features[2];
};

529
#define OTF_SYM_TAG(SYM, TAG)					\
530
  do {								\
531 532
    unsigned char *p = SDATA (SYMBOL_NAME (SYM));		\
    TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];	\
533 534
  } while (0)

535
#define OTF_TAG_STR(TAG, P)			\
536
  do {						\
537 538 539 540
    (P)[0] = (char) (TAG >> 24);		\
    (P)[1] = (char) ((TAG >> 16) & 0xFF);	\
    (P)[2] = (char) ((TAG >> 8) & 0xFF);	\
    (P)[3] = (char) (TAG & 0xFF);		\
541
    (P)[4] = '\0';				\
542 543
  } while (0)

544
#ifdef HAVE_LIBOTF
545 546 547 548 549 550 551
#define OTF_TAG_SYM(SYM, TAG)			\
  do {						\
    char str[5];				\
    						\
    OTF_TAG_STR (TAG, str);			\
    (SYM) = font_intern_prop (str, 4, 1);	\
  } while (0)
552
#endif
553 554


555 556 557
static struct OpenTypeSpec *
ftfont_get_open_type_spec (Lisp_Object otf_spec)
{
558
  struct OpenTypeSpec *spec = malloc (sizeof *spec);
559
  Lisp_Object val;
560 561
  int i, j;
  bool negative;
562 563 564

  if (! spec)
    return NULL;
565
  spec->script = XCAR (otf_spec);
566
  if (! NILP (spec->script))
567 568 569 570 571 572 573 574
    {
      OTF_SYM_TAG (spec->script, spec->script_tag);
      val = assq_no_quit (spec->script, Votf_script_alist);
      if (CONSP (val) && SYMBOLP (XCDR (val)))
	spec->script = XCDR (val);
      else
	spec->script = Qnil;
    }
575
  else
576
    spec->script_tag = 0x44464C54; 	/* "DFLT" */
577
  otf_spec = XCDR (otf_spec);
Kenichi Handa's avatar
Kenichi Handa committed
578 579 580 581 582 583 584 585
  spec->langsys_tag = 0;
  if (! NILP (otf_spec))
    {
      val = XCAR (otf_spec);
      if (! NILP (val))
	OTF_SYM_TAG (val, spec->langsys_tag);
      otf_spec = XCDR (otf_spec);
    }
586
  spec->nfeatures[0] = spec->nfeatures[1] = 0;
Kenichi Handa's avatar
Kenichi Handa committed
587
  for (i = 0; i < 2 && ! NILP (otf_spec); i++, otf_spec = XCDR (otf_spec))
588 589 590 591
    {
      val = XCAR (otf_spec);
      if (NILP (val))
	continue;
Paul Eggert's avatar
Paul Eggert committed
592
      ptrdiff_t len = list_length (val);
593
      spec->features[i] =
Paul Eggert's avatar
Paul Eggert committed
594
	(min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < len
595
	 ? 0
Paul Eggert's avatar
Paul Eggert committed
596
	 : malloc (len * sizeof *spec->features[i]));
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
      if (! spec->features[i])
	{
	  if (i > 0 && spec->features[0])
	    free (spec->features[0]);
	  free (spec);
	  return NULL;
	}
      for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
	{
	  if (NILP (XCAR (val)))
	    negative = 1;
	  else
	    {
	      unsigned int tag;

	      OTF_SYM_TAG (XCAR (val), tag);
	      spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
	    }
	}
      spec->nfeatures[i] = j;
    }
  return spec;
}

621
static FcPattern *
622
ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **otspec, const char **langname)
Kenichi Handa's avatar
Kenichi Handa committed
623
{
Kenichi Handa's avatar
Kenichi Handa committed
624
  Lisp_Object tmp, extra;
Kenichi Handa's avatar
Kenichi Handa committed
625 626 627
  FcPattern *pattern = NULL;
  FcCharSet *charset = NULL;
  FcLangSet *langset = NULL;
628 629
  int n;
  int dpi = -1;
630
  int scalable = -1;
631
  Lisp_Object script = Qnil;
Kenichi Handa's avatar
Kenichi Handa committed
632
  Lisp_Object registry;
633
  int fc_charset_idx;
Kenichi Handa's avatar
Kenichi Handa committed
634

635 636
  if ((n = FONT_SLANT_NUMERIC (spec)) >= 0
      && n < 100)
Paul Eggert's avatar
Paul Eggert committed
637
    /* Fontconfig doesn't support reverse-italic/oblique.  */
638 639
    return NULL;

640
  if (FIXNUMP (AREF (spec, FONT_DPI_INDEX)))
Tom Tromey's avatar
Tom Tromey committed
641
    dpi = XFIXNUM (AREF (spec, FONT_DPI_INDEX));
642
  if (FIXNUMP (AREF (spec, FONT_AVGWIDTH_INDEX))
Tom Tromey's avatar
Tom Tromey committed
643
      && XFIXNUM (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
644
    scalable = 1;
645

Kenichi Handa's avatar
Kenichi Handa committed
646 647
  registry = AREF (spec, FONT_REGISTRY_INDEX);
  if (NILP (registry)
648
      || EQ (registry, Qascii_0)
Kenichi Handa's avatar
Kenichi Handa committed
649
      || EQ (registry, Qiso10646_1)
650
      || EQ (registry, Qunicode_bmp))
651
    fc_charset_idx = -1;
Kenichi Handa's avatar
Kenichi Handa committed
652
  else
Kenichi Handa's avatar
Kenichi Handa committed
653
    {
654 655
      FcChar8 *lang;

656 657
      fc_charset_idx = ftfont_get_charset (registry);
      if (fc_charset_idx < 0)
658
	return NULL;
659
      charset = fc_charset_table[fc_charset_idx].fc_charset;
660 661
      *langname = fc_charset_table[fc_charset_idx].lang;
      lang = (FcChar8 *) *langname;
662 663 664 665 666 667 668
      if (lang)
	{
	  langset = FcLangSetCreate ();
	  if (! langset)
	    goto err;
	  FcLangSetAdd (langset, lang);
	}
Kenichi Handa's avatar
Kenichi Handa committed
669 670
    }

671
  otlayout[0] = '\0';
672 673
  for (extra = AREF (spec, FONT_EXTRA_INDEX);
       CONSP (extra); extra = XCDR (extra))
Kenichi Handa's avatar
Kenichi Handa committed
674
    {
675 676
      Lisp_Object key, val;

677 678
      key = XCAR (XCAR (extra)), val = XCDR (XCAR (extra));
      if (EQ (key, QCdpi))
679
	{
680
	  if (FIXNUMP (val))
Tom Tromey's avatar
Tom Tromey committed
681
	    dpi = XFIXNUM (val);
682
	}
683
      else if (EQ (key, QClang))
Kenichi Handa's avatar
Kenichi Handa committed
684
	{
685 686
	  if (! langset)
	    langset = FcLangSetCreate ();
Kenichi Handa's avatar
Kenichi Handa committed
687 688
	  if (! langset)
	    goto err;
689
	  if (SYMBOLP (val))
Kenichi Handa's avatar
Kenichi Handa committed
690
	    {
691
	      if (! FcLangSetAdd (langset, SYMBOL_FcChar8 (val)))
Kenichi Handa's avatar
Kenichi Handa committed
692 693 694
		goto err;
	    }
	  else
695 696 697 698
	    for (; CONSP (val); val = XCDR (val))
	      if (SYMBOLP (XCAR (val))
		  && ! FcLangSetAdd (langset, SYMBOL_FcChar8 (XCAR (val))))
		goto err;
Kenichi Handa's avatar
Kenichi Handa committed
699
	}
700 701
      else if (EQ (key, QCotf))
	{
702 703 704 705 706
	  if (CONSP (val))
	    {
	      *otspec = ftfont_get_open_type_spec (val);
	      if (! *otspec)
		return NULL;
707
	      strcpy (otlayout, "otlayout:");
708 709 710
	      OTF_TAG_STR ((*otspec)->script_tag, otlayout + 9);
	      script = (*otspec)->script;
	    }
711
	}
712 713 714 715 716
      else if (EQ (key, QCscript))
	script = val;
      else if (EQ (key, QCscalable))
	scalable = ! NILP (val);
    }
Kenichi Handa's avatar
Kenichi Handa committed
717

718 719 720 721
  if (! NILP (script) && ! charset)
    {
      Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);

722
      if (CONSP (chars) && CONSP (CDR (chars)))
723 724 725 726 727 728
	{
	  charset = FcCharSetCreate ();
	  if (! charset)
	    goto err;
	  for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
	    if (CHARACTERP (XCAR (chars))
Tom Tromey's avatar
Tom Tromey committed
729
		&& ! FcCharSetAddChar (charset, XFIXNAT (XCAR (chars))))
730
	      goto err;
Kenichi Handa's avatar
Kenichi Handa committed
731 732 733
	}
    }

734
  pattern = FcPatternCreate ();
735 736 737
  if (! pattern)
    goto err;
  tmp = AREF (spec, FONT_FOUNDRY_INDEX);
738
  if (! NILP (tmp)
739 740
      && ! FcPatternAddString (pattern, FC_FOUNDRY, SYMBOL_FcChar8 (tmp)))
    goto err;
741 742 743 744
  tmp = AREF (spec, FONT_FAMILY_INDEX);
  if (! NILP (tmp)
      && ! FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (tmp)))
    goto err;
Kenichi Handa's avatar
Kenichi Handa committed
745 746 747 748 749 750
  if (charset
      && ! FcPatternAddCharSet (pattern, FC_CHARSET, charset))
    goto err;
  if (langset
      && ! FcPatternAddLangSet (pattern, FC_LANG, langset))
    goto err;
751 752 753 754
  if (dpi >= 0
      && ! FcPatternAddDouble (pattern, FC_DPI, dpi))
    goto err;
  if (scalable >= 0
Kenichi Handa's avatar
Kenichi Handa committed
755
      && ! FcPatternAddBool (pattern, FC_SCALABLE, scalable ? FcTrue : FcFalse))
756
    goto err;
757
#if defined HAVE_XFT && defined FC_COLOR
758 759 760
  /* We really don't like color fonts, they cause Xft crashes.  See
     Bug#30874.  */
  if (Vxft_ignore_color_fonts
761
      && ! FcPatternAddBool (pattern, FC_COLOR, FcFalse))
762 763
    goto err;
#endif
764

765
  goto finish;
Kenichi Handa's avatar
Kenichi Handa committed
766

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
 err:
  /* We come here because of unexpected error in fontconfig API call
     (usually insufficient memory).  */
  if (pattern)
    {
      FcPatternDestroy (pattern);
      pattern = NULL;
    }
  if (*otspec)
    {
      if ((*otspec)->nfeatures[0] > 0)
	free ((*otspec)->features[0]);
      if ((*otspec)->nfeatures[1] > 0)
	free ((*otspec)->features[1]);
      free (*otspec);
      *otspec = NULL;
    }

 finish:
  if (langset) FcLangSetDestroy (langset);
787
  if (charset && fc_charset_idx < 0) FcCharSetDestroy (charset);
788 789 790
  return pattern;
}

791
Lisp_Object
792
ftfont_list (struct frame *f, Lisp_Object spec)
793
{
Kenichi Handa's avatar
Kenichi Handa committed
794
  Lisp_Object val = Qnil, family, adstyle;
795 796 797 798
  int i;
  FcPattern *pattern;
  FcFontSet *fontset = NULL;
  FcObjectSet *objset = NULL;
799 800
  FcCharSet *charset;
  Lisp_Object chars = Qnil;
801 802
  char otlayout[15];		/* For "otlayout:XXXX" */
  struct OpenTypeSpec *otspec = NULL;
803
  int spacing = -1;
804
  const char *langname = NULL;
Juanma Barranquero's avatar
Juanma Barranquero committed
805

806 807 808 809 810 811
  if (! fc_initialized)
    {
      FcInit ();
      fc_initialized = 1;
    }

812
  pattern = ftfont_spec_pattern (spec, otlayout, &otspec, &langname);
813 814
  if (! pattern)
    return Qnil;
815 816 817 818 819 820 821 822 823 824 825
  if (FcPatternGetCharSet (pattern, FC_CHARSET, 0, &charset) != FcResultMatch)
    {
      val = assq_no_quit (QCscript, AREF (spec, FONT_EXTRA_INDEX));
      if (! NILP (val))
	{
	  val = assq_no_quit (XCDR (val), Vscript_representative_chars);
	  if (CONSP (val) && VECTORP (XCDR (val)))
	    chars = XCDR (val);
	}
      val = Qnil;
    }
826
  if (FIXNUMP (AREF (spec, FONT_SPACING_INDEX)))
Tom Tromey's avatar
Tom Tromey committed
827
    spacing = XFIXNUM (AREF (spec, FONT_SPACING_INDEX));
828 829 830 831 832
  family = AREF (spec, FONT_FAMILY_INDEX);
  if (! NILP (family))
    {
      Lisp_Object resolved;

833
      resolved = ftfont_resolve_generic_family (family, pattern);
834 835 836 837 838 839 840 841
      if (! NILP (resolved))
	{
	  FcPatternDel (pattern, FC_FAMILY);
	  if (! FcPatternAddString (pattern, FC_FAMILY,
				    SYMBOL_FcChar8 (resolved)))
	    goto err;
	}
    }
Kenichi Handa's avatar
Kenichi Handa committed
842 843 844
  adstyle = AREF (spec, FONT_ADSTYLE_INDEX);
  if (! NILP (adstyle) && SBYTES (SYMBOL_NAME (adstyle)) == 0)
    adstyle = Qnil;
845
  objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
846
			     FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING, FC_SCALABLE,
Kenichi Handa's avatar
Kenichi Handa committed
847
			     FC_STYLE, FC_FILE, FC_INDEX,
848 849 850
#ifdef FC_CAPABILITY
			     FC_CAPABILITY,
#endif	/* FC_CAPABILITY */
851 852 853
#ifdef FC_FONTFORMAT
			     FC_FONTFORMAT,
#endif
854
			     NULL);
855 856
  if (! objset)
    goto err;
857 858
  if (! NILP (chars))
    FcObjectSetAdd (objset, FC_CHARSET);
859

860
  fontset = FcFontList (NULL, pattern, objset);
861 862
  if (! fontset || fontset->nfont == 0)
    goto finish;
863 864 865 866
#if 0
  /* Need fix because this finds any fonts.  */
  if (fontset->nfont == 0 && ! NILP (family))
    {
Paul Eggert's avatar
Paul Eggert committed
867
      /* Try matching with configuration.  For instance, the
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
	 configuration may specify "Nimbus Mono L" as an alias of
	 "Courier".  */
      FcPattern *pat = FcPatternBuild (0, FC_FAMILY, FcTypeString,
				       SYMBOL_FcChar8 (family), NULL);
      FcChar8 *fam;

      if (FcConfigSubstitute (NULL, pat, FcMatchPattern) == FcTrue)
	{
	  for (i = 0;
	       FcPatternGetString (pat, FC_FAMILY, i, &fam) == FcResultMatch;
	       i++)
	    {
	      FcPatternDel (pattern, FC_FAMILY);
	      FcPatternAddString (pattern, FC_FAMILY, fam);
	      FcFontSetDestroy (fontset);
	      fontset = FcFontList (NULL, pattern, objset);
884
	      if (fontset && fontset->nfont > 0)
885 886 887 888 889
		break;
	    }
	}
    }
#endif
890
  for (i = 0; i < fontset->nfont; i++)
891
    {
892
      Lisp_Object entity;
893

894 895 896 897 898 899 900 901 902 903
      if (spacing >= 0)
	{
	  int this;

	  if ((FcPatternGetInteger (fontset->fonts[i], FC_SPACING, 0, &this)
	       == FcResultMatch)
	      && spacing != this)
	    continue;
	}

904
#ifdef FC_CAPABILITY
905 906 907
      if (otlayout[0])
	{
	  FcChar8 *this;
908

909 910
	  if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0, &this)
	      != FcResultMatch
911 912 913
	      || ! strstr ((char *) this, otlayout))
	    continue;
	}
914
#endif	/* FC_CAPABILITY */
915
#ifdef HAVE_LIBOTF
916 917 918
      if (otspec)
	{
	  FcChar8 *file;
919
	  bool passed;
920 921 922 923 924 925 926 927
	  OTF *otf;

	  if (FcPatternGetString (fontset->fonts[i], FC_FILE, 0, &file)
	      != FcResultMatch)
	    continue;
	  otf = OTF_open ((char *) file);
	  if (! otf)
	    continue;
928 929 930 931 932 933 934 935 936 937
	  passed = (OTF_check_features (otf, 1, otspec->script_tag,
					otspec->langsys_tag,
					otspec->features[0],
					otspec->nfeatures[0]) == 1
		    && OTF_check_features (otf, 0, otspec->script_tag,
					   otspec->langsys_tag,
					   otspec->features[1],
					   otspec->nfeatures[1]) == 1);
	  OTF_close (otf);
	  if (!passed)
938
	    continue;
Kenichi Handa's avatar
Kenichi Handa committed
939
	}
940
#endif	/* HAVE_LIBOTF */
941 942
      if (VECTORP (chars))
	{
943
	  ptrdiff_t j;
944 945 946 947 948

	  if (FcPatternGetCharSet (fontset->fonts[i], FC_CHARSET, 0, &charset)
	      != FcResultMatch)
	    continue;
	  for (j = 0; j < ASIZE (chars); j++)
949
	    if (TYPE_RANGED_FIXNUMP (FcChar32, AREF (chars, j))
Tom Tromey's avatar
Tom Tromey committed
950
		&& FcCharSetHasChar (charset, XFIXNAT (AREF (chars, j))))
951 952 953 954
	      break;
	  if (j == ASIZE (chars))
	    continue;
	}
955
      if (! NILP (adstyle) || langname)
Kenichi Handa's avatar
Kenichi Handa committed
956 957 958
	{
	  Lisp_Object this_adstyle = get_adstyle_property (fontset->fonts[i]);

959 960
	  if (! NILP (adstyle)
	      && (NILP (this_adstyle)
961 962
		  || xstrcasecmp (SSDATA (SYMBOL_NAME (adstyle)),
				  SSDATA (SYMBOL_NAME (this_adstyle))) != 0))
963 964 965
	    continue;
	  if (langname
	      && ! NILP (this_adstyle)
966
	      && xstrcasecmp (langname, SSDATA (SYMBOL_NAME (this_adstyle))))
Kenichi Handa's avatar
Kenichi Handa committed
967 968
	    continue;
	}
969 970
      entity = ftfont_pattern_entity (fontset->fonts[i],
				      AREF (spec, FONT_EXTRA_INDEX));
971 972
      if (! NILP (entity))
	val = Fcons (entity, val);
Kenichi Handa's avatar
Kenichi Handa committed
973
    }
974
  val = Fnreverse (val);
Kenichi Handa's avatar
Kenichi Handa committed
975 976 977 978
  goto finish;

 err:
  /* We come here because of unexpected error in fontconfig API call
979
     (usually insufficient memory).  */
Kenichi Handa's avatar
Kenichi Handa committed
980 981 982
  val = Qnil;

 finish:
983
  FONT_ADD_LOG ("ftfont-list", spec, val);
Kenichi Handa's avatar
Kenichi Handa committed
984 985 986 987 988 989
  if (objset) FcObjectSetDestroy (objset);
  if (fontset) FcFontSetDestroy (fontset);
  if (pattern) FcPatternDestroy (pattern);
  return val;
}

990
Lisp_Object
991
ftfont_match (struct frame *f, Lisp_Object spec)
992
{
993
  Lisp_Object entity = Qnil;
994
  FcPattern *pattern, *match = NULL;
995
  FcResult result;
996 997
  char otlayout[15];		/* For "otlayout:XXXX" */
  struct OpenTypeSpec *otspec = NULL;
998
  const char *langname = NULL;
999 1000 1001 1002 1003 1004 1005

  if (! fc_initialized)
    {
      FcInit ();
      fc_initialized = 1;
    }

1006
  pattern = ftfont_spec_pattern (spec, otlayout, &otspec, &langname);
1007
  if (! pattern)
1008 1009
    return Qnil;

1010
  if (FIXNUMP (AREF (spec, FONT_SIZE_INDEX)))
1011
    {
1012
      FcValue value;
1013

1014
      value.type = FcTypeDouble;
Tom Tromey's avatar
Tom Tromey committed
1015
      value.u.d = XFIXNUM (AREF (spec, FONT_SIZE_INDEX));
1016 1017 1018 1019 1020 1021 1022
      FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse);
    }
  if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
    {
      FcDefaultSubstitute (pattern);
      match = FcFontMatch (NULL, pattern, &result);
      if (match)
1023
	{
1024
	  entity = ftfont_pattern_entity (match, AREF (spec, FONT_EXTRA_INDEX));
1025 1026 1027 1028 1029 1030 1031
	  FcPatternDestroy (match);
	  if (! NILP (AREF (spec, FONT_FAMILY_INDEX))
	      && NILP (assq_no_quit (AREF (spec, FONT_FAMILY_INDEX),
				     ftfont_generic_family_list))
	      && NILP (Fstring_equal (AREF (spec, FONT_FAMILY_INDEX),
				      AREF (entity, FONT_FAMILY_INDEX))))
	    entity = Qnil;
1032 1033
	}
    }
1034
  FcPatternDestroy (pattern);
1035

1036
  FONT_ADD_LOG ("ftfont-match", spec, entity);
1037 1038 1039
  return entity;
}

1040
Lisp_Object
1041
ftfont_list_family (struct frame *f)
Kenichi Handa's avatar
Kenichi Handa committed
1042
{
1043
  Lisp_Object list = Qnil;
Kenichi Handa's avatar
Kenichi Handa committed
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
  FcPattern *pattern = NULL;
  FcFontSet *fontset = NULL;
  FcObjectSet *objset = NULL;
  int i;

  if (! fc_initialized)
    {
      FcInit ();
      fc_initialized = 1;
    }

  pattern = FcPatternCreate ();
  if (! pattern)
    goto finish;
1058
  objset = FcObjectSetBuild (FC_FAMILY, NULL);