X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/ac3232837188f7e1c4ffe34b76edede0ccb54f5e..114f9c96795aff3b51b9060d7c9c1b77debcc99a:/src/ftfont.c

diff --git a/src/ftfont.c b/src/ftfont.c
index 73d7ae48f5..492d03bb8b 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1,6 +1,6 @@
 /* ftfont.c -- FreeType font driver.
-   Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
-   Copyright (C) 2006, 2007, 2008
+   Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2006, 2007, 2008, 2009, 2010
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
 
@@ -21,6 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 #include <stdio.h>
+#include <setjmp.h>
 
 #include <fontconfig/fontconfig.h>
 #include <fontconfig/fcfreetype.h>
@@ -32,6 +33,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "character.h"
 #include "charset.h"
 #include "coding.h"
+#include "composite.h"
 #include "fontset.h"
 #include "font.h"
 #include "ftfont.h"
@@ -61,21 +63,32 @@ struct ftfont_info
 {
   struct font font;
 #ifdef HAVE_LIBOTF
-  /* The following three members must be here in this order to be
+  /* The following four members must be here in this order to be
      compatible with struct xftfont_info (in xftfont.c).  */
   int maybe_otf;	/* Flag to tell if this may be OTF or not.  */
   OTF *otf;
 #endif	/* HAVE_LIBOTF */
   FT_Size ft_size;
   int index;
+  FT_Matrix matrix;
 };
 
+enum ftfont_cache_for
+  {
+    FTFONT_CACHE_FOR_FACE,
+    FTFONT_CACHE_FOR_CHARSET,
+    FTFONT_CACHE_FOR_ENTITY
+  };
+
 static Lisp_Object ftfont_pattern_entity P_ ((FcPattern *, Lisp_Object));
 
 static Lisp_Object ftfont_resolve_generic_family P_ ((Lisp_Object,
 						      FcPattern *));
-static Lisp_Object ftfont_lookup_cache P_ ((Lisp_Object, int));
+static Lisp_Object ftfont_lookup_cache P_ ((Lisp_Object,
+					    enum ftfont_cache_for));
 
+static void ftfont_filter_properties P_ ((Lisp_Object font, Lisp_Object alist));
+                                                
 Lisp_Object ftfont_font_format P_ ((FcPattern *, Lisp_Object));
 
 #define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))
@@ -127,17 +140,59 @@ static struct
     { "windows-1251", { 0x0401, 0x0490 }, "ru"},
     { "koi8-r", { 0x0401, 0x2219 }, "ru"},
     { "mulelao-1", { 0x0E81 }, "lo"},
+    { "unicode-sip", { 0x20000 }},
     { NULL }
   };
 
 extern Lisp_Object Qc, Qm, Qp, Qd;
 
+/* 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)
+{
+  char *str, *end;
+  Lisp_Object adstyle;
+
+  if (FcPatternGetString (p, FC_STYLE, 0, (FcChar8 **) &str) != FcResultMatch)
+    return Qnil;
+  for (end = str; *end && *end != ' '; end++);
+  if (*end)
+    {
+      char *p = alloca (end - str + 1);
+      memcpy (p, str, end - str);
+      p[end - str] = '\0';
+      end = p + (end - str);
+      str = p;
+    }
+  if (xstrcasecmp (str, "Regular") == 0
+      || xstrcasecmp (str, "Bold") == 0
+      || xstrcasecmp (str, "Oblique") == 0
+      || xstrcasecmp (str, "Italic") == 0)
+    return Qnil;
+  adstyle = font_intern_prop (str, end - str, 1);
+  if (font_style_to_value (FONT_WIDTH_INDEX, adstyle, 0) >= 0)
+    return Qnil;
+  return adstyle;
+}
+
 static Lisp_Object
 ftfont_pattern_entity (p, extra)
      FcPattern *p;
      Lisp_Object extra;
 {
-  Lisp_Object entity;
+  Lisp_Object key, cache, entity;
   char *file, *str;
   int index;
   int numeric;
@@ -149,7 +204,21 @@ ftfont_pattern_entity (p, extra)
   if (FcPatternGetInteger (p, FC_INDEX, 0, &index) != FcResultMatch)
     return Qnil;
 
+  key = Fcons (make_unibyte_string ((char *) file, strlen ((char *) file)),
+	       make_number (index));
+  cache = ftfont_lookup_cache (key, FTFONT_CACHE_FOR_ENTITY);
+  entity = XCAR (cache);
+  if (! NILP (entity))
+    {
+      Lisp_Object val = font_make_entity ();
+      int i;
+
+      for (i = 0; i < FONT_OBJLIST_INDEX; i++)
+	ASET (val, i, AREF (entity, i));
+      return val;
+    }
   entity = font_make_entity ();
+  XSETCAR (cache, entity);
 
   ASET (entity, FONT_TYPE_INDEX, Qfreetype);
   ASET (entity, FONT_REGISTRY_INDEX, Qiso10646_1);
@@ -174,7 +243,9 @@ ftfont_pattern_entity (p, extra)
       FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_number (numeric));
     }
   if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
-    ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
+    {
+      ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
+    }
   else
     ASET (entity, FONT_SIZE_INDEX, make_number (0));
   if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) == FcResultMatch)
@@ -186,13 +257,31 @@ ftfont_pattern_entity (p, extra)
     }
   if (FcPatternGetBool (p, FC_SCALABLE, 0, &b) == FcResultMatch
       && b == FcTrue)
-    ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
+    {
+      ASET (entity, FONT_SIZE_INDEX, make_number (0));
+      ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
+    }
+  else
+    {
+      /* As this font is not scalable, parhaps this is a BDF or PCF
+	 font. */ 
+      FT_Face ft_face;
+
+      ASET (entity, FONT_ADSTYLE_INDEX, get_adstyle_property (p));
+      if ((ft_library || FT_Init_FreeType (&ft_library) == 0)
+	  && FT_New_Face (ft_library, file, index, &ft_face) == 0)
+	{
+	  BDF_PropertyRec rec;
+
+	  if (FT_Get_BDF_Property (ft_face, "AVERAGE_WIDTH", &rec) == 0
+	      && rec.type == BDF_PROPERTY_TYPE_INTEGER)
+	    ASET (entity, FONT_AVGWIDTH_INDEX, make_number (rec.u.integer));
+	  FT_Done_Face (ft_face);
+	}
+    }
 
   ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
-  font_put_extra (entity, QCfont_entity,
-		  Fcons (make_unibyte_string ((char *) file,
-					      strlen ((char *) file)),
-			 make_number (index)));
+  font_put_extra (entity, QCfont_entity, key);
   return entity;
 }
 
@@ -207,6 +296,7 @@ ftfont_resolve_generic_family (family, pattern)
   Lisp_Object slot;
   FcPattern *match;
   FcResult result;
+  FcLangSet *langset;
 
   family = Fintern (Fdowncase (SYMBOL_NAME (family)), Qnil);
   if (EQ (family, Qmono))
@@ -224,6 +314,14 @@ ftfont_resolve_generic_family (family, pattern)
   FcPatternDel (pattern, FC_FOUNDRY);
   FcPatternDel (pattern, FC_FAMILY);
   FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (family));
+  if (FcPatternGetLangSet (pattern, FC_LANG, 0, &langset) != FcResultMatch)
+    {
+      /* This is to avoid the effect of locale.  */
+      langset = FcLangSetCreate ();
+      FcLangSetAdd (langset, "en");
+      FcPatternAddLangSet (pattern, FC_LANG, langset);
+      FcLangSetDestroy (langset);
+    }
   FcConfigSubstitute (NULL, pattern, FcMatchPattern);
   FcDefaultSubstitute (pattern);
   match = FcFontMatch (NULL, pattern, &result);
@@ -237,8 +335,8 @@ ftfont_resolve_generic_family (family, pattern)
   else
     family = Qnil;
   XSETCDR (slot, family);
- err:
   if (match) FcPatternDestroy (match);
+ err:
   if (pattern) FcPatternDestroy (pattern);
   return family;
 }
@@ -250,36 +348,62 @@ struct ftfont_cache_data
 };
 
 static Lisp_Object
-ftfont_lookup_cache (key, for_face)
+ftfont_lookup_cache (key, cache_for)
      Lisp_Object key;
-     int for_face;
+     enum ftfont_cache_for cache_for;
 {
-  Lisp_Object cache, val;
+  Lisp_Object cache, val, entity;
   struct ftfont_cache_data *cache_data;
 
-  cache = assoc_no_quit (key, ft_face_cache);
+  if (FONT_ENTITY_P (key))
+    {
+      entity = key;
+      val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
+      xassert (CONSP (val));
+      key = XCDR (val);
+    }
+  else
+    entity = Qnil;
+
+  if (NILP (ft_face_cache))
+    cache = Qnil;
+  else
+    cache = Fgethash (key, ft_face_cache, Qnil);
   if (NILP (cache))
     {
+      if (NILP (ft_face_cache))
+	{
+	  Lisp_Object args[2];
+
+	  args[0] = QCtest;
+	  args[1] = Qequal;
+	  ft_face_cache = Fmake_hash_table (2, args);
+	}
       cache_data = xmalloc (sizeof (struct ftfont_cache_data));
       cache_data->ft_face = NULL;
       cache_data->fc_charset = NULL;
       val = make_save_value (NULL, 0);
       XSAVE_VALUE (val)->integer = 0;
       XSAVE_VALUE (val)->pointer = cache_data;
-      cache = Fcons (key, val);
-      ft_face_cache = Fcons (cache, ft_face_cache);
+      cache = Fcons (Qnil, val);
+      Fputhash (key, cache, ft_face_cache);
     }
   else
     {
       val = XCDR (cache);
       cache_data = XSAVE_VALUE (val)->pointer;
     }
-  if (for_face ? ! cache_data->ft_face : ! cache_data->fc_charset)
+
+  if (cache_for == FTFONT_CACHE_FOR_ENTITY)
+    return cache;
+
+  if (cache_for == FTFONT_CACHE_FOR_FACE
+      ? ! cache_data->ft_face : ! cache_data->fc_charset)
     {
       char *filename = (char *) SDATA (XCAR (key));
       int index = XINT (XCDR (key));
 
-      if (for_face)
+      if (cache_for == FTFONT_CACHE_FOR_FACE)
 	{
 	  if (! ft_library
 	      && FT_Init_FreeType (&ft_library) != 0)
@@ -290,24 +414,36 @@ ftfont_lookup_cache (key, for_face)
 	}
       else
 	{
-	  FcPattern *pat;
-	  FcFontSet *fontset;
-	  FcObjectSet *objset;
-	  FcCharSet *charset;
+	  FcPattern *pat = NULL;
+	  FcFontSet *fontset = NULL;
+	  FcObjectSet *objset = NULL;
+	  FcCharSet *charset = NULL;
 
 	  pat = FcPatternBuild (0, FC_FILE, FcTypeString, (FcChar8 *) filename,
 				FC_INDEX, FcTypeInteger, index, NULL);
-	  objset = FcObjectSetBuild (FC_CHARSET, NULL);
+	  if (! pat)
+	    goto finish;
+	  objset = FcObjectSetBuild (FC_CHARSET, FC_STYLE, NULL);
+	  if (! objset)
+	    goto finish;
 	  fontset = FcFontList (NULL, pat, objset);
-	  xassert (fontset && fontset->nfont > 0);
-	  if (FcPatternGetCharSet (fontset->fonts[0], FC_CHARSET, 0, &charset)
-	      == FcResultMatch)
+	  if (! fontset)
+	    goto finish;
+	  if (fontset && fontset->nfont > 0
+	      && (FcPatternGetCharSet (fontset->fonts[0], FC_CHARSET, 0,
+				       &charset)
+		  == FcResultMatch))
 	    cache_data->fc_charset = FcCharSetCopy (charset);
 	  else
 	    cache_data->fc_charset = FcCharSetCreate ();
-	  FcFontSetDestroy (fontset);
-	  FcObjectSetDestroy (objset);
-	  FcPatternDestroy (pat);
+
+	finish:
+	  if (fontset)
+	    FcFontSetDestroy (fontset);
+	  if (objset)
+	    FcObjectSetDestroy (objset);
+	  if (pat)
+	    FcPatternDestroy (pat);
 	}
     }
   return cache;
@@ -320,10 +456,7 @@ ftfont_get_fc_charset (entity)
   Lisp_Object val, cache;
   struct ftfont_cache_data *cache_data;
 
-  val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
-  xassert (CONSP (val));
-  val = XCDR (val);
-  cache = ftfont_lookup_cache (val, 0);
+  cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
   val = XCDR (cache);
   cache_data = XSAVE_VALUE (val)->pointer;
   return cache_data->fc_charset;
@@ -370,6 +503,11 @@ static int ftfont_anchor_point P_ ((struct font *, unsigned, int,
 static Lisp_Object ftfont_otf_capability P_ ((struct font *));
 static Lisp_Object ftfont_shape P_ ((Lisp_Object));
 
+#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
+static int ftfont_variation_glyphs P_ ((struct font *, int c,
+					unsigned variations[256]));
+#endif /* HAVE_OTF_GET_VARIATION_GLYPHS */
+
 struct font_driver ftfont_driver =
   {
     0,				/* Qfreetype */
@@ -378,35 +516,44 @@ struct font_driver ftfont_driver =
     ftfont_list,
     ftfont_match,
     ftfont_list_family,
-    NULL,
+    NULL,			/* free_entity */
     ftfont_open,
     ftfont_close,
     /* We can't draw a text without device dependent functions.  */
-    NULL,
-    NULL,
+    NULL,			/* prepare_face */
+    NULL,			/* done_face */
     ftfont_has_char,
     ftfont_encode_char,
     ftfont_text_extents,
     /* We can't draw a text without device dependent functions.  */
-    NULL,
+    NULL,			/* draw */
     ftfont_get_bitmap,
-    NULL,
-    NULL,
-    NULL,
+    NULL,			/* get_bitmap */
+    NULL,			/* free_bitmap */
+    NULL,			/* get_outline */
     ftfont_anchor_point,
 #ifdef HAVE_LIBOTF
     ftfont_otf_capability,
 #else  /* not HAVE_LIBOTF */
     NULL,
 #endif	/* not HAVE_LIBOTF */
-    NULL,
-    NULL,
-    NULL,
+    NULL,			/* otf_drive */
+    NULL,			/* start_for_frame */
+    NULL,			/* end_for_frame */
 #if defined (HAVE_M17N_FLT) && defined (HAVE_LIBOTF)
-    ftfont_shape
+    ftfont_shape,
 #else  /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
-    NULL
+    NULL,
 #endif	/* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
+    NULL,			/* check */
+
+#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
+    ftfont_variation_glyphs,
+#else
+    NULL,
+#endif
+
+    ftfont_filter_properties, /* filter_properties */
   };
 
 extern Lisp_Object QCname;
@@ -559,13 +706,15 @@ ftfont_get_open_type_spec (Lisp_Object otf_spec)
 }
 
 static FcPattern *ftfont_spec_pattern P_ ((Lisp_Object, char *,
-					   struct OpenTypeSpec **));
+					   struct OpenTypeSpec **,
+					   char **langname));
 
 static FcPattern *
-ftfont_spec_pattern (spec, otlayout, otspec)
+ftfont_spec_pattern (spec, otlayout, otspec, langname)
      Lisp_Object spec;
      char *otlayout;
      struct OpenTypeSpec **otspec;
+     char **langname;
 {
   Lisp_Object tmp, extra;
   FcPattern *pattern = NULL;
@@ -578,10 +727,6 @@ ftfont_spec_pattern (spec, otlayout, otspec)
   Lisp_Object registry;
   int fc_charset_idx;
 
-  if (! NILP (AREF (spec, FONT_ADSTYLE_INDEX))
-      && SBYTES (SYMBOL_NAME (AREF (spec, FONT_ADSTYLE_INDEX))) > 0)
-    /* Fontconfig doesn't support adstyle property.  */
-    return NULL;
   if ((n = FONT_SLANT_NUMERIC (spec)) >= 0
       && n < 100)
     /* Fontconfig doesn't support reverse-italic/obligue.  */
@@ -597,8 +742,7 @@ ftfont_spec_pattern (spec, otlayout, otspec)
   if (NILP (registry)
       || EQ (registry, Qascii_0)
       || EQ (registry, Qiso10646_1)
-      || EQ (registry, Qunicode_bmp)
-      || EQ (registry, Qunicode_sip))
+      || EQ (registry, Qunicode_bmp))
     fc_charset_idx = -1;
   else
     {
@@ -608,7 +752,8 @@ ftfont_spec_pattern (spec, otlayout, otspec)
       if (fc_charset_idx < 0)
 	return NULL;
       charset = fc_charset_table[fc_charset_idx].fc_charset;
-      lang = (FcChar8 *) fc_charset_table[fc_charset_idx].lang;
+      *langname = fc_charset_table[fc_charset_idx].lang;
+      lang = (FcChar8 *) *langname;
       if (lang)
 	{
 	  langset = FcLangSetCreate ();
@@ -663,7 +808,7 @@ ftfont_spec_pattern (spec, otlayout, otspec)
     {
       Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
 
-      if (CONSP (chars))
+      if (CONSP (chars) && CONSP (CDR (chars)))
 	{
 	  charset = FcCharSetCreate ();
 	  if (! charset)
@@ -729,14 +874,18 @@ static Lisp_Object
 ftfont_list (frame, spec)
      Lisp_Object frame, spec;
 {
-  Lisp_Object val = Qnil, family;
+  Lisp_Object val = Qnil, family, adstyle;
   int i;
   FcPattern *pattern;
   FcFontSet *fontset = NULL;
   FcObjectSet *objset = NULL;
+  FcCharSet *charset;
+  Lisp_Object chars = Qnil;
+  FcResult result;
   char otlayout[15];		/* For "otlayout:XXXX" */
   struct OpenTypeSpec *otspec = NULL;
   int spacing = -1;
+  char *langname = NULL;
 
   if (! fc_initialized)
     {
@@ -744,9 +893,20 @@ ftfont_list (frame, spec)
       fc_initialized = 1;
     }
 
-  pattern = ftfont_spec_pattern (spec, otlayout, &otspec);
+  pattern = ftfont_spec_pattern (spec, otlayout, &otspec, &langname);
   if (! pattern)
     return Qnil;
+  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;
+    }
   if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
     spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
   family = AREF (spec, FONT_FAMILY_INDEX);
@@ -763,10 +923,12 @@ ftfont_list (frame, spec)
 	    goto err;
 	}
     }
-
+  adstyle = AREF (spec, FONT_ADSTYLE_INDEX);
+  if (! NILP (adstyle) && SBYTES (SYMBOL_NAME (adstyle)) == 0)
+    adstyle = Qnil;
   objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
 			     FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING, FC_SCALABLE,
-			     FC_FILE, FC_INDEX,
+			     FC_STYLE, FC_FILE, FC_INDEX,
 #ifdef FC_CAPABILITY
 			     FC_CAPABILITY,
 #endif	/* FC_CAPABILITY */
@@ -776,10 +938,12 @@ ftfont_list (frame, spec)
 			     NULL);
   if (! objset)
     goto err;
+  if (! NILP (chars))
+    FcObjectSetAdd (objset, FC_CHARSET);
 
   fontset = FcFontList (NULL, pattern, objset);
-  if (! fontset)
-    goto err;
+  if (! fontset || fontset->nfont == 0)
+    goto finish;
 #if 0
   /* Need fix because this finds any fonts.  */
   if (fontset->nfont == 0 && ! NILP (family))
@@ -801,7 +965,7 @@ ftfont_list (frame, spec)
 	      FcPatternAddString (pattern, FC_FAMILY, fam);
 	      FcFontSetDestroy (fontset);
 	      fontset = FcFontList (NULL, pattern, objset);
-	      if (fontset->nfont > 0)
+	      if (fontset && fontset->nfont > 0)
 		break;
 	    }
 	}
@@ -826,8 +990,8 @@ ftfont_list (frame, spec)
 	{
 	  FcChar8 *this;
 
-	  if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0,
-				  &this) != FcResultMatch
+	  if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0, &this)
+	      != FcResultMatch
 	      || ! strstr ((char *) this, otlayout))
 	    continue;
 	}
@@ -855,12 +1019,40 @@ ftfont_list (frame, spec)
 	    continue;
 	}
 #endif	/* HAVE_LIBOTF */
+      if (VECTORP (chars))
+	{
+	  int j;
+
+	  if (FcPatternGetCharSet (fontset->fonts[i], FC_CHARSET, 0, &charset)
+	      != FcResultMatch)
+	    continue;
+	  for (j = 0; j < ASIZE (chars); j++)
+	    if (NATNUMP (AREF (chars, j))
+		&& FcCharSetHasChar (charset, XFASTINT (AREF (chars, j))))
+	      break;
+	  if (j == ASIZE (chars))
+	    continue;
+	}
+      if (! NILP (adstyle) || langname)
+	{
+	  Lisp_Object this_adstyle = get_adstyle_property (fontset->fonts[i]);
+
+	  if (! NILP (adstyle)
+	      && (NILP (this_adstyle)
+		  || xstrcasecmp (SDATA (SYMBOL_NAME (adstyle)),
+				  SDATA (SYMBOL_NAME (this_adstyle))) != 0))
+	    continue;
+	  if (langname
+	      && ! NILP (this_adstyle)
+	      && xstrcasecmp (langname, SDATA (SYMBOL_NAME (this_adstyle))))
+	    continue;
+	}
       entity = ftfont_pattern_entity (fontset->fonts[i],
 				      AREF (spec, FONT_EXTRA_INDEX));
       if (! NILP (entity))
 	val = Fcons (entity, val);
     }
-  font_add_log ("ftfont-list", spec, val);
+  val = Fnreverse (val);
   goto finish;
 
  err:
@@ -869,6 +1061,7 @@ ftfont_list (frame, spec)
   val = Qnil;
 
  finish:
+  FONT_ADD_LOG ("ftfont-list", spec, val);
   if (objset) FcObjectSetDestroy (objset);
   if (fontset) FcFontSetDestroy (fontset);
   if (pattern) FcPatternDestroy (pattern);
@@ -879,11 +1072,12 @@ static Lisp_Object
 ftfont_match (frame, spec)
      Lisp_Object frame, spec;
 {
-  Lisp_Object entity;
+  Lisp_Object entity = Qnil;
   FcPattern *pattern, *match = NULL;
   FcResult result;
   char otlayout[15];		/* For "otlayout:XXXX" */
   struct OpenTypeSpec *otspec = NULL;
+  char *langname = NULL;
 
   if (! fc_initialized)
     {
@@ -891,7 +1085,7 @@ ftfont_match (frame, spec)
       fc_initialized = 1;
     }
 
-  pattern = ftfont_spec_pattern (spec, otlayout, &otspec);
+  pattern = ftfont_spec_pattern (spec, otlayout, &otspec, &langname);
   if (! pattern)
     return Qnil;
 
@@ -921,7 +1115,7 @@ ftfont_match (frame, spec)
     }
   FcPatternDestroy (pattern);
 
-  font_add_log ("ftfont-match", spec, entity);
+  FONT_ADD_LOG ("ftfont-match", spec, entity);
   return entity;
 }
 
@@ -929,7 +1123,7 @@ static Lisp_Object
 ftfont_list_family (frame)
      Lisp_Object frame;
 {
-  Lisp_Object list;
+  Lisp_Object list = Qnil;
   FcPattern *pattern = NULL;
   FcFontSet *fontset = NULL;
   FcObjectSet *objset = NULL;
@@ -951,7 +1145,6 @@ ftfont_list_family (frame)
   if (! fontset)
     goto finish;
 
-  list = Qnil;
   for (i = 0; i < fontset->nfont; i++)
     {
       FcPattern *pat = fontset->fonts[i];
@@ -993,7 +1186,7 @@ ftfont_open (f, entity, pixel_size)
   if (! CONSP (val))
     return Qnil;
   val = XCDR (val);
-  cache = ftfont_lookup_cache (val, 1);
+  cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_FACE);
   if (NILP (cache))
     return Qnil;
   filename = XCAR (val);
@@ -1027,10 +1220,10 @@ ftfont_open (f, entity, pixel_size)
   ASET (font_object, FONT_TYPE_INDEX, Qfreetype);
   len = font_unparse_xlfd (entity, size, name, 256);
   if (len > 0)
-    ASET (font_object, FONT_NAME_INDEX, make_unibyte_string (name, len));
+    ASET (font_object, FONT_NAME_INDEX, make_string (name, len));
   len = font_unparse_fcname (entity, size, name, 256);
   if (len > 0)
-    ASET (font_object, FONT_FULLNAME_INDEX, make_unibyte_string (name, len));
+    ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len));
   else
     ASET (font_object, FONT_FULLNAME_INDEX,
 	  AREF (font_object, FONT_NAME_INDEX));
@@ -1044,6 +1237,8 @@ ftfont_open (f, entity, pixel_size)
   ftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
   ftfont_info->otf = NULL;
 #endif	/* HAVE_LIBOTF */
+  /* This means that there's no need of transformation.  */
+  ftfont_info->matrix.xx = 0;
   font->pixel_size = size;
   font->driver = &ftfont_driver;
   font->encoding_charset = font->repertory_charset = -1;
@@ -1077,7 +1272,7 @@ ftfont_open (f, entity, pixel_size)
 
       font->min_width = font->average_width = font->space_width = 0;
       for (i = 32, n = 0; i < 127; i++)
-	if (FT_Load_Char (ft_face, i, FT_LOAD_DEFAULT) != 0)
+	if (FT_Load_Char (ft_face, i, FT_LOAD_DEFAULT) == 0)
 	  {
 	    int this_width = ft_face->glyph->metrics.horiAdvance >> 6;
 
@@ -1100,7 +1295,7 @@ ftfont_open (f, entity, pixel_size)
   if (scalable)
     {
       font->underline_position = -ft_face->underline_position * size / upEM;
-      font->underline_thickness = -ft_face->underline_thickness * size / upEM;
+      font->underline_thickness = ft_face->underline_thickness * size / upEM;
     }
   else
     {
@@ -1120,7 +1315,7 @@ ftfont_close (f, font)
   Lisp_Object val, cache;
 
   val = Fcons (font->props[FONT_FILE_INDEX], make_number (ftfont_info->index));
-  cache = ftfont_lookup_cache (val, 1);
+  cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
   xassert (CONSP (cache));
   val = XCDR (cache);
   (XSAVE_VALUE (val)->integer)--;
@@ -1140,13 +1335,35 @@ ftfont_close (f, font)
 }
 
 static int
-ftfont_has_char (entity, c)
-     Lisp_Object entity;
+ftfont_has_char (font, c)
+     Lisp_Object font;
      int c;
 {
-  FcCharSet *charset = ftfont_get_fc_charset (entity);
+  struct charset *cs = NULL;
+
+  if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qja)
+      && charset_jisx0208 >= 0)
+    cs = CHARSET_FROM_ID (charset_jisx0208);
+  else if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qko)
+      && charset_ksc5601 >= 0)
+    cs = CHARSET_FROM_ID (charset_ksc5601);
+  if (cs)
+    return (ENCODE_CHAR (cs, c) != CHARSET_INVALID_CODE (cs));
+
+  if (FONT_ENTITY_P (font))
+    {
+      FcCharSet *charset = ftfont_get_fc_charset (font);
 
-  return (FcCharSetHasChar (charset, c) == FcTrue);
+      return (FcCharSetHasChar (charset, c) == FcTrue);
+    }
+  else
+    {
+      struct ftfont_info *ftfont_info;
+
+      ftfont_info = (struct ftfont_info *) XFONT_OBJECT (font);
+      return (FT_Get_Char_Index (ftfont_info->ft_size->face, (FT_ULong) c)
+	      != 0);
+    }
 }
 
 static unsigned
@@ -1191,7 +1408,7 @@ ftfont_text_extents (font, code, nglyphs, metrics)
 		  metrics->lbearing = m->horiBearingX >> 6;
 		  metrics->rbearing = (m->horiBearingX + m->width) >> 6;
 		  metrics->ascent = m->horiBearingY >> 6;
-		  metrics->descent = (m->horiBearingY + m->height) >> 6;
+		  metrics->descent = (m->height - m->horiBearingY) >> 6;
 		}
 	      first = 0;
 	    }
@@ -1205,8 +1422,8 @@ ftfont_text_extents (font, code, nglyphs, metrics)
 		  = width + ((m->horiBearingX + m->width) >> 6);
 	      if (metrics->ascent < (m->horiBearingY >> 6))
 		metrics->ascent = m->horiBearingY >> 6;
-	      if (metrics->descent > ((m->horiBearingY + m->height) >> 6))
-		metrics->descent = (m->horiBearingY + m->height) >> 6;
+	      if (metrics->descent > ((m->height - m->horiBearingY) >> 6))
+		metrics->descent = (m->height - m->horiBearingY) >> 6;
 	    }
 	  width += m->horiAdvance >> 6;
 	}
@@ -1299,7 +1516,7 @@ ftfont_otf_features (gsub_gpos)
      OTF_GSUB_GPOS *gsub_gpos;
 {
   Lisp_Object scripts, langsyses, features, sym;
-  int i, j, k;
+  int i, j, k, l;
 
   for (scripts = Qnil, i = gsub_gpos->ScriptList.ScriptCount - 1; i >= 0; i--)
     {
@@ -1318,7 +1535,10 @@ ftfont_otf_features (gsub_gpos)
 
 	  for (features = Qnil, k = otf_langsys->FeatureCount - 1; k >= 0; k--)
 	    {
-	      OTF_TAG_SYM (sym, gsub_gpos->FeatureList.Feature[k].FeatureTag);
+	      l = otf_langsys->FeatureIndex[k];
+	      if (l >= gsub_gpos->FeatureList.FeatureCount)
+		continue;
+	      OTF_TAG_SYM (sym, gsub_gpos->FeatureList.Feature[l].FeatureTag);
 	      features = Fcons (sym, features);
 	    }
 	  if (j >= 0)
@@ -1327,7 +1547,7 @@ ftfont_otf_features (gsub_gpos)
 	    sym = Qnil;
 	  langsyses = Fcons (Fcons (sym, features), langsyses);
 	}
-      
+
       OTF_TAG_SYM (sym, gsub_gpos->ScriptList.Script[i].ScriptTag);
       scripts = Fcons (Fcons (sym, langsyses), scripts);
     }
@@ -1347,9 +1567,11 @@ ftfont_otf_capability (font)
   if (! otf)
     return Qnil;
   gsub_gpos = Fcons (Qnil, Qnil);
-  if (OTF_get_table (otf, "GSUB") == 0)
+  if (OTF_get_table (otf, "GSUB") == 0
+      && otf->gsub->FeatureList.FeatureCount > 0)
     XSETCAR (gsub_gpos, ftfont_otf_features (otf->gsub));
-  if (OTF_get_table (otf, "GPOS") == 0)
+  if (OTF_get_table (otf, "GPOS") == 0
+      && otf->gpos->FeatureList.FeatureCount > 0)
     XSETCDR (gsub_gpos, ftfont_otf_features (otf->gpos));
   return gsub_gpos;
 }
@@ -1362,6 +1584,7 @@ struct MFLTFontFT
   struct font *font;
   FT_Face ft_face;
   OTF *otf;
+  FT_Matrix *matrix;
 };
 
 static int
@@ -1385,6 +1608,12 @@ ftfont_get_glyph_id (font, gstring, from, to)
   return 0;
 }
 
+/* Operators for 26.6 fixed fractional pixel format */
+
+#define FLOOR(x)    ((x) & -64)
+#define CEIL(x)	    (((x)+63) & -64)
+#define ROUND(x)    (((x)+32) & -64)
+
 static int
 ftfont_get_metrics (font, gstring, from, to)
      MFLTFont *font;
@@ -1401,16 +1630,35 @@ ftfont_get_metrics (font, gstring, from, to)
 	if (g->code != FONT_INVALID_CODE)
 	  {
 	    FT_Glyph_Metrics *m;
+	    int lbearing, rbearing, ascent, descent, xadv;
 
 	    if (FT_Load_Glyph (ft_face, g->code, FT_LOAD_DEFAULT) != 0)
 	      abort ();
 	    m = &ft_face->glyph->metrics;
-
-	    g->lbearing = m->horiBearingX;
-	    g->rbearing = m->horiBearingX + m->width;
-	    g->ascent = m->horiBearingY;
-	    g->descent = m->height - m->horiBearingY;
-	    g->xadv = m->horiAdvance;
+	    if (flt_font_ft->matrix)
+	      {
+		FT_Vector v[4];
+		int i;
+
+		v[0].x = v[1].x = m->horiBearingX;
+		v[2].x = v[3].x = m->horiBearingX + m->width;
+		v[0].y = v[2].y = m->horiBearingY;
+		v[1].y = v[3].y = m->horiBearingY - m->height;
+		for (i = 0; i < 4; i++)
+		  FT_Vector_Transform (v + i, flt_font_ft->matrix);
+		g->lbearing = v[0].x < v[1].x ? FLOOR (v[0].x) : FLOOR (v[1].x);
+		g->rbearing = v[2].x > v[3].x ? CEIL (v[2].x) : CEIL (v[3].x);
+		g->ascent = v[0].y > v[2].y ? CEIL (v[0].y) : CEIL (v[2].y);
+		g->descent = v[1].y < v[3].y ? - FLOOR (v[1].y) : - FLOOR (v[3].y);
+	      }
+	    else
+	      {
+		g->lbearing = FLOOR (m->horiBearingX);
+		g->rbearing = CEIL (m->horiBearingX + m->width);
+		g->ascent = CEIL (m->horiBearingY);
+		g->descent = - FLOOR (m->horiBearingY - m->height);
+	      }
+	    g->xadv = ROUND (ft_face->glyph->advance.x);
 	  }
 	else
 	  {
@@ -1491,6 +1739,25 @@ adjust_anchor (FT_Face ft_face, OTF_Anchor *anchor,
 
 static OTF_GlyphString otf_gstring;
 
+static void
+setup_otf_gstring (int size)
+{
+  if (otf_gstring.size == 0)
+    {
+      otf_gstring.glyphs = (OTF_Glyph *) xmalloc (sizeof (OTF_Glyph) * size);
+      otf_gstring.size = size;
+    }
+  else if (otf_gstring.size < size)
+    {
+      otf_gstring.glyphs = xrealloc (otf_gstring.glyphs,
+				     sizeof (OTF_Glyph) * size);
+      otf_gstring.size = size;
+    }
+  otf_gstring.used = size;
+  memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * size);
+}
+
+
 static int
 ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
      MFLTFont *font;
@@ -1543,19 +1810,7 @@ ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
 	}
     }
 
-  if (otf_gstring.size == 0)
-    {
-      otf_gstring.glyphs = (OTF_Glyph *) malloc (sizeof (OTF_Glyph) * len);
-      otf_gstring.size = len;
-    }
-  else if (otf_gstring.size < len)
-    {
-      otf_gstring.glyphs = (OTF_Glyph *) realloc (otf_gstring.glyphs,
-						  sizeof (OTF_Glyph) * len);
-      otf_gstring.size = len;
-    }
-  otf_gstring.used = len;
-  memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * len);
+  setup_otf_gstring (len);
   for (i = 0; i < len; i++)
     {
       otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
@@ -1706,7 +1961,7 @@ ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
 		base_x = otfg->f.f4.base_anchor->XCoordinate * x_scale / 0x10000;
 		base_y = otfg->f.f4.base_anchor->YCoordinate * y_scale / 0x10000;
 		mark_x = otfg->f.f4.mark_anchor->XCoordinate * x_scale / 0x10000;
-		mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;;
+		mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;
 
 		if (otfg->f.f4.base_anchor->AnchorFormat != 1)
 		  adjust_anchor (ft_face, otfg->f.f4.base_anchor,
@@ -1762,16 +2017,19 @@ static int m17n_flt_initialized;
 
 extern Lisp_Object QCfamily;
 
-Lisp_Object
-ftfont_shape_by_flt (lgstring, font, ft_face, otf)
+static Lisp_Object
+ftfont_shape_by_flt (lgstring, font, ft_face, otf, matrix)
      Lisp_Object lgstring;
      struct font *font;
      FT_Face ft_face;
      OTF *otf;
+     FT_Matrix *matrix;
 {
-  EMACS_UINT len = LGSTRING_LENGTH (lgstring);
+  EMACS_UINT len = LGSTRING_GLYPH_LEN (lgstring);
   EMACS_UINT i;
   struct MFLTFontFT flt_font_ft;
+  MFLT *flt = NULL;
+  int with_variation_selector = 0;
 
   if (! m17n_flt_initialized)
     {
@@ -1780,24 +2038,71 @@ ftfont_shape_by_flt (lgstring, font, ft_face, otf)
     }
 
   for (i = 0; i < len; i++)
-    if (NILP (LGSTRING_GLYPH (lgstring, i)))
-      break;
+    {
+      Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
+      int c;
+
+      if (NILP (g))
+	break;
+      c = LGLYPH_CHAR (g);
+      if (CHAR_VARIATION_SELECTOR_P (c))
+	with_variation_selector++;
+    }
   len = i;
+  if (with_variation_selector)
+    {
+      setup_otf_gstring (len);
+      for (i = 0; i < len; i++)
+	{
+	  Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
+
+	  otf_gstring.glyphs[i].c = LGLYPH_CHAR (g);
+	  otf_gstring.glyphs[i].f.index.from = LGLYPH_FROM (g);
+	  otf_gstring.glyphs[i].f.index.to = LGLYPH_TO (g);
+	}
+      OTF_drive_cmap (otf, &otf_gstring);
+      for (i = 0; i < otf_gstring.used; i++)
+	{
+	  OTF_Glyph *otfg = otf_gstring.glyphs + i;
+	  Lisp_Object g0 = LGSTRING_GLYPH (lgstring, otfg->f.index.from);
+	  Lisp_Object g1 = LGSTRING_GLYPH (lgstring, otfg->f.index.to);
+
+	  LGLYPH_SET_CODE (g0, otfg->glyph_id);
+	  LGLYPH_SET_TO (g0, LGLYPH_TO (g1));
+	  LGSTRING_SET_GLYPH (lgstring, i, g0);
+	}
+      if (len > otf_gstring.used)
+	{
+	  len = otf_gstring.used;
+	  LGSTRING_SET_GLYPH (lgstring, len, Qnil);
+	}
+    }
 
   if (gstring.allocated == 0)
     {
       gstring.allocated = len * 2;
       gstring.glyph_size = sizeof (MFLTGlyph);
-      gstring.glyphs = malloc (sizeof (MFLTGlyph) * gstring.allocated);
+      gstring.glyphs = xmalloc (sizeof (MFLTGlyph) * gstring.allocated);
     }
   else if (gstring.allocated < len * 2)
     {
       gstring.allocated = len * 2;
-      gstring.glyphs = realloc (gstring.glyphs,
-				sizeof (MFLTGlyph) * gstring.allocated);
+      gstring.glyphs = xrealloc (gstring.glyphs,
+				 sizeof (MFLTGlyph) * gstring.allocated);
     }
+  memset (gstring.glyphs, 0, sizeof (MFLTGlyph) * len);
   for (i = 0; i < len; i++)
-    gstring.glyphs[i].c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
+    {
+      Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
+
+      gstring.glyphs[i].c = LGLYPH_CHAR (g);
+      if (with_variation_selector)
+	{
+	  gstring.glyphs[i].code = LGLYPH_CODE (g);
+	  gstring.glyphs[i].encoded = 1;
+	}
+    }
+
   gstring.used = len;
   gstring.r2l = 0;
 
@@ -1808,7 +2113,7 @@ ftfont_shape_by_flt (lgstring, font, ft_face, otf)
       flt_font_ft.flt_font.family = Mnil;
     else
       flt_font_ft.flt_font.family
-	= msymbol ((char *) SDATA (SYMBOL_NAME (family)));
+	= msymbol ((char *) SDATA (Fdowncase (SYMBOL_NAME (family))));
   }
   flt_font_ft.flt_font.x_ppem = ft_face->size->metrics.x_ppem;
   flt_font_ft.flt_font.y_ppem = ft_face->size->metrics.y_ppem;
@@ -1820,16 +2125,23 @@ ftfont_shape_by_flt (lgstring, font, ft_face, otf)
   flt_font_ft.font = font;
   flt_font_ft.ft_face = ft_face;
   flt_font_ft.otf = otf;
+  flt_font_ft.matrix = matrix->xx != 0 ? matrix : 0;
+  if (len > 1
+      && gstring.glyphs[1].c >= 0x300 && gstring.glyphs[1].c <= 0x36F)
+    /* A little bit ad hoc.  Perhaps, shaper must get script and
+       language information, and select a proper flt for them
+       here.  */
+    flt = mflt_get (msymbol ("combining"));
   for (i = 0; i < 3; i++)
     {
-      int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, NULL);
+      int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, flt);
       if (result != -2)
 	break;
       gstring.allocated += gstring.allocated;
-      gstring.glyphs = realloc (gstring.glyphs,
-				sizeof (MFLTGlyph) * gstring.allocated);
+      gstring.glyphs = xrealloc (gstring.glyphs,
+				 sizeof (MFLTGlyph) * gstring.allocated);
     }
-  if (gstring.used > LGSTRING_LENGTH (lgstring))
+  if (gstring.used > LGSTRING_GLYPH_LEN (lgstring))
     return Qnil;
   for (i = 0; i < gstring.used; i++)
     {
@@ -1885,10 +2197,29 @@ ftfont_shape (lgstring)
   otf = ftfont_get_otf (ftfont_info);
   if (! otf)
     return make_number (0);
-  return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face, otf);
+  return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face, otf,
+			      &ftfont_info->matrix);
 }
 
 #endif	/* HAVE_M17N_FLT */
+
+#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
+
+static int
+ftfont_variation_glyphs (font, c, variations)
+     struct font *font;
+     int c;
+     unsigned variations[256];
+{
+  struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
+  OTF *otf = ftfont_get_otf (ftfont_info);
+
+  if (! otf)
+    return 0;
+  return OTF_get_variation_glyphs (otf, c, variations);
+}
+
+#endif	/* HAVE_OTF_GET_VARIATION_GLYPHS */
 #endif	/* HAVE_LIBOTF */
 
 Lisp_Object
@@ -1931,7 +2262,94 @@ ftfont_font_format (FcPattern *pattern, Lisp_Object filename)
   return intern ("unknown");
 }
 
-
+static const char *ftfont_booleans [] = {
+  ":antialias",
+  ":hinting",
+  ":verticallayout",
+  ":autohint",
+  ":globaladvance",
+  ":outline",
+  ":scalable",
+  ":minspace",
+  ":embolden",
+  NULL,
+};
+
+static const char *ftfont_non_booleans [] = {
+  ":family",
+  ":familylang",
+  ":style",
+  ":stylelang",
+  ":fullname",
+  ":fullnamelang",
+  ":slant",
+  ":weight",
+  ":size",
+  ":width",
+  ":aspect",
+  ":pixelsize",
+  ":spacing",
+  ":foundry",
+  ":hintstyle",
+  ":file",
+  ":index",
+  ":ftface",
+  ":rasterizer",
+  ":scale",
+  ":dpi",
+  ":rgba",
+  ":lcdfilter",
+  ":charset",
+  ":lang",
+  ":fontversion",
+  ":capability",
+  NULL,
+};
+
+static void
+ftfont_filter_properties (font, alist)
+     Lisp_Object font;
+     Lisp_Object alist;
+{
+  Lisp_Object it;
+  int i;
+
+  /* Set boolean values to Qt or Qnil */
+  for (i = 0; ftfont_booleans[i] != NULL; ++i)
+    for (it = alist; ! NILP (it); it = XCDR (it))
+      {
+        Lisp_Object key = XCAR (XCAR (it));
+        Lisp_Object val = XCDR (XCAR (it));
+        char *keystr = SDATA (SYMBOL_NAME (key));
+
+        if (strcmp (ftfont_booleans[i], keystr) == 0)
+          {
+            char *str = SYMBOLP (val) ? SDATA (SYMBOL_NAME (val)) : NULL;
+            if (INTEGERP (val)) str = XINT (val) != 0 ? "true" : "false";
+            if (str == NULL) str = "true";
+
+            val = Qt;
+            if (strcmp ("false", str) == 0 || strcmp ("False", str) == 0
+                || strcmp ("FALSE", str) == 0 || strcmp ("FcFalse", str) == 0
+                || strcmp ("off", str) == 0 || strcmp ("OFF", str) == 0
+                || strcmp ("Off", str) == 0)
+              val = Qnil;
+            Ffont_put (font, key, val);
+          }
+      }
+
+  for (i = 0; ftfont_non_booleans[i] != NULL; ++i)
+    for (it = alist; ! NILP (it); it = XCDR (it))
+      {
+        Lisp_Object key = XCAR (XCAR (it));
+        Lisp_Object val = XCDR (XCAR (it));
+        char *keystr = SDATA (SYMBOL_NAME (key));
+        if (strcmp (ftfont_non_booleans[i], keystr) == 0)
+          Ffont_put (font, key, val);
+      }
+}
+
+
 void
 syms_of_ftfont ()
 {