Mercurial > emacs

--- a/src/font.h	Wed May 14 01:24:12 2008 +0000
+++ b/src/font.h	Wed May 14 01:25:20 2008 +0000
@@ -30,31 +30,32 @@

    FONT-SPEC

-	Vector (length FONT_SPEC_MAX) of font properties.  Some
+	Pseudo vector (length FONT_SPEC_MAX) of font properties.  Some
 	properties can be left unspecified (i.e. nil).  Emacs asks
 	font-drivers to find a font by FONT-SPEC.  A fontset entry
 	specifies requisite properties whereas a face specifies just
-	preferable properties.  This object is fully modifiable by
-	Lisp.
+	preferable properties.

    FONT-ENTITY

-	Vector (length FONT_ENTITY_MAX) of fully specified font
-	properties that a font-driver returns upon a request of
+	Pseudo vector (length FONT_ENTITY_MAX) of fully instanciated
+	font properties that a font-driver returns upon a request of
 	FONT-SPEC.

-	Note: Only the method `list' of a font-driver can create this
-	object, and should never be modified by Lisp.  In that sense,
-	it may be cleaner to implement it as a Lisp object of a new
-	type (e.g. struct Lisp_Font).
+	Note: Only the method `list' and `match' of a font-driver can
+	create this object, and should never be modified by Lisp.

    FONT-OBJECT

-	Lisp object of type Lisp_Misc_Save_Value encapsulating a
-	pointer to "struct font".  This corresponds to an opened font.
+	Pseudo vector (length FONT_OBJECT_MAX) of a opend font.
+
+	Lisp object encapsulating "struct font".  This corresponds to
+	an opened font.

-	Note: The note for FONT-ENTITY also applies to this.
-*/
+	Note: Only the method `open' of a font-driver can create this
+	object, and should never be modified by Lisp.  */
+
+extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;


 struct font_driver;
@@ -68,8 +69,8 @@
 enum font_property_index
   {
     /* FONT-TYPE is a symbol indicating a font backend; currently `x',
-       `xft', `ftx', `freetype' are available on X and gdi on Windows.
-       For Windows, we `bdf' and `uniscribe' backends are in progress.
+       `xft', `ftx' are available on X and gdi on Windows.
+       For Windows, `bdf' and `uniscribe' backends are in progress.
        For Mac OS X, we need `atm'.  */
     FONT_TYPE_INDEX,

@@ -83,34 +84,78 @@
     FONT_ADSTYLE_INDEX,

     /* FONT-REGISTRY is a combination of a charset-registry and
-       charset0encoding name (symbol).  */
+       charset-encoding name (symbol).  */
     FONT_REGISTRY_INDEX,

     /* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of
-       the font.  The value is what defined by FC_WEIGHT_* in
-       fontconfig. */
+       the font.  The lowest 8-bit is an index determining the
+       symbolic name, and the higher bits is the actual numeric value
+       defined in `font-weight-table'. */
     FONT_WEIGHT_INDEX,

     /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
-       font.  The value is what defined by FC_SLANT_* in
-       fontconfig plus 100. */
+       font.  The lowest 8-bit is an index determining the symbolic
+       name, and the higher bits is the actual numeric value defined
+       in `font-slant-table'.  */
     FONT_SLANT_INDEX,

-    /* FONT-WIDTH is a numeric value of setwidth (e.g. normal,
-       condensed) of the font.  The value is what defined by
-       FC_WIDTH_* in fontconfig. */
+    /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the
+       font.  The lowest 8-bit is an index determining the symbolic
+       name, and the higher bits is the actual numeric value defined
+       `font-width-table'.  */
     FONT_WIDTH_INDEX,

     /* FONT-SIZE is a size of the font.  If integer, it is a pixel
        size.  For a font-spec, the value can be float specifying a
-       point size.  For a font-entity, the value can be zero meaning
-       that the font is scalable.  */
+       point size.  The value zero means that the font is
+       scalable.  */
     FONT_SIZE_INDEX,

+    /* FONT-DPI is a resolution (dot per inch) for which the font is
+       designed. */
+    FONT_DPI_INDEX,
+
+    /* FONT-SPACING is a spacing (mono, proportional, charcell) of the
+       font (integer; one of enum font_spacing).  */
+    FONT_SPACING_INDEX,
+
+    /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the
+       font.  */
+    FONT_AVGWIDTH_INDEX,
+
+#if 0
+    /* The following two members are to substitute for the above 6
+       members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding
+       FONT_SIZE_INDEX) if it is found that font-entities consumes too
+       much memory.  */
+
+    /* FONT-STYLE is a 24-bit integer containing indices for
+       style-related properties WEIGHT, SLANT, and WIDTH.  The lowest
+       8-bit is an indice to the weight table AREF (font_style_table,
+       0), the next 8-bit is an indice to the slant table AREF
+       (font_style_table, 1), the highest 8-bit is an indice to the
+       slant table AREF (font_style_table, 2).  The indice 0 indicates
+       that the corresponding style is not specified.  This way, we
+       can represent at most 255 different names for each style, which
+       is surely sufficient.  */
+    FONT_STYLE_INDEX,
+
+    /* FONT-METRICS is a 27-bit integer containing metrics-related
+       properties DPI, AVGWIDTH, SPACING.  The lowest 12-bit is for
+       DPI, the next 12-bit is for AVGWIDTH, the highest 3-bit is for
+       SPACING.  In each bit field, the highest bit indicates that the
+       corresponding value is set or not.  This way, we can represent
+       DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047),
+       SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3
+       for charcell), which is surely sufficient.  */
+    FONT_METRICS_INDEX,
+#endif
+
     /* In a font-spec, the value is an alist of extra information of a
        font such as name, OpenType features, and language coverage.
-       In a font-entity, the value is an extra infomation for
-       identifying a font (font-driver dependent).  */
+       In addition, in a font-entity, the value may contain a pair
+       (font-entity . INFO) where INFO is an extra infomation to
+       identify a font (font-driver dependent).  */
     FONT_EXTRA_INDEX,		/* alist		alist */

     /* This value is the length of font-spec vector.  */
@@ -118,49 +163,225 @@

     /* The followings are used only for a font-entity.  */

-    /* Frame on which the font is found.  The value is nil if the font
-       can be opend on any frame.  */
-    FONT_FRAME_INDEX = FONT_SPEC_MAX,
-
-    /* List of font-objects opened from the font-entity.  The value is
-       nil if no font can be opened for this font-entity.  */
-    FONT_OBJLIST_INDEX,
+    /* List of font-objects opened from the font-entity.  */
+    FONT_OBJLIST_INDEX = FONT_SPEC_MAX,

     /* This value is the length of font-entity vector.  */
-    FONT_ENTITY_MAX
+    FONT_ENTITY_MAX,
+
+    /* XLFD name of the font (string). */
+    FONT_NAME_INDEX = FONT_ENTITY_MAX,
+
+    /* Full name of the font (string).  It is the name extracted from
+       the opend font, and may be different from the above.  It may be
+       nil if the opened font doesn't give a name.  */
+    FONT_FULLNAME_INDEX,
+
+    /* File name of the font or nil if a file associated with the font
+       is not available.  */
+    FONT_FILE_INDEX,
+
+    /* Format of the font (symbol).  */
+    FONT_FORMAT_INDEX,
+
+    /* This value is the length of font-object vector.  */
+    FONT_OBJECT_MAX
   };

-extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClanguage, QCscript;
+/* Return the numeric weight value of FONT.  */
+#define FONT_WEIGHT_NUMERIC(font)		\
+  (INTEGERP (AREF ((font), FONT_WEIGHT_INDEX))	\
+   ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
+/* Return the numeric slant value of FONT.  */
+#define FONT_SLANT_NUMERIC(font)		\
+  (INTEGERP (AREF ((font), FONT_SLANT_INDEX))	\
+   ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
+/* Return the numeric width value of FONT.  */
+#define FONT_WIDTH_NUMERIC(font)		\
+  (INTEGERP (AREF ((font), FONT_WIDTH_INDEX))	\
+   ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
+/* Return the symbolic weight value of FONT.  */
+#define FONT_WEIGHT_SYMBOLIC(font)	\
+  font_style_symbolic (font, FONT_WEIGHT_INDEX, 0)
+/* Return the symbolic slant value of FONT.  */
+#define FONT_SLANT_SYMBOLIC(font)	\
+  font_style_symbolic (font, FONT_SLANT_INDEX, 0)
+/* Return the symbolic width value of FONT.  */
+#define FONT_WIDTH_SYMBOLIC(font)	\
+  font_style_symbolic (font, FONT_WIDTH_INDEX, 0)
+/* Return the face-weight corresponding to the weight of FONT.  */
+#define FONT_WEIGHT_FOR_FACE(font)	\
+  font_style_symbolic (font, FONT_WEIGHT_INDEX, 1)
+/* Return the face-slant corresponding to the slant of FONT.  */
+#define FONT_SLANT_FOR_FACE(font)	\
+  font_style_symbolic (font, FONT_SLANT_INDEX, 1)
+/* Return the face-swidth corresponding to the slant of FONT.  */
+#define FONT_WIDTH_FOR_FACE(font)	\
+  font_style_symbolic (font, FONT_WIDTH_INDEX, 1)
+
+/* Return the numeric weight value corresponding ot the symbol NAME.  */
+#define FONT_WEIGHT_NAME_NUMERIC(name)	\
+  (font_style_to_value (FONT_WEIGHT_INDEX, (name), 0) >> 8)
+/* Return the numeric slant value corresponding ot the symbol NAME.  */
+#define FONT_SLANT_NAME_NUMERIC(name)	\
+  (font_style_to_value (FONT_SLANT_INDEX, (name), 0) >> 8)
+/* Return the numeric width value corresponding ot the symbol NAME.  */
+#define FONT_WIDTH_NAME_NUMERIC(name)	\
+  (font_style_to_value (FONT_WIDTH_INDEX, (name), 0) >> 8)
+
+/* Set the font property PROP of FONT to VAL.  PROP is one of
+   style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX).
+   VAL (integer or symbol) is the numeric or symbolic style value.  */
+#define FONT_SET_STYLE(font, prop, val)	\
+  ASET ((font), prop, make_number (font_style_to_value (prop, val, 1)))
+
+extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript;
+extern Lisp_Object QCavgwidth, QCfont_entity, QCfc_unknown_spec;

 /* Important character set symbols.  */
 extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;

-extern Lisp_Object null_string;
-extern Lisp_Object null_vector;
+/* Structure for a font-spec.  */
+
+struct font_spec
+{
+  EMACS_UINT size;
+  struct Lisp_Vector *next;
+  Lisp_Object props[FONT_SPEC_MAX];
+};
+
+/* Structure for a font-entity.  */

-/* Structure for an opened font.  We can safely cast this structure to
-   "struct font_info".  */
+struct font_entity
+{
+  EMACS_UINT size;
+  struct Lisp_Vector *next;
+  Lisp_Object props[FONT_ENTITY_MAX];
+};
+
+/* A value which may appear in the member `encoding' of struct font
+   indicating that a font itself doesn't tell which encoding to be
+   used.  */
+#define FONT_ENCODING_NOT_DECIDED 255
+
+/* Structure for a font-object.  */

 struct font
 {
-  struct font_info font;
+  EMACS_UINT size;
+  struct Lisp_Vector *next;
+
+  /* All Lisp_Object components must come first.
+     That ensures they are all aligned normally.  */

-  /* From which font-entity the font is opened.  */
-  Lisp_Object entity;
+  Lisp_Object props[FONT_OBJECT_MAX];
+
+  /* Beyond here, there should be no more Lisp_Object components.  */
+
+  /* Maximum bound width over all existing characters of the font.  On
+     X window, this is same as (font->max_bounds.width).  */
+  int max_width;

   /* By which pixel size the font is opened.  */
   int pixel_size;

+  /* Height of the font.  On X window, this is the same as
+     (font->ascent + font->descent).  */
+  int height;
+
+  /* Width of the space glyph of the font.  If the font doesn't have a
+     SPACE glyph, the value is 0.  */
+  int space_width;
+
+  /* Average width of glyphs in the font.  If the font itself doesn't
+     have that information but has glyphs of ASCII character, the
+     value is the average with of those glyphs.  Otherwise, the value
+     is 0.  */
+  int average_width;
+
+  /* Minimum glyph width (in pixels).  */
+  int min_width;
+
+  /* Ascent and descent of the font (in pixels).  */
+  int ascent, descent;
+
+  /* Vertical pixel width of the underline.  If is zero if that
+     information is not in the font.  */
+  int underline_thickness;
+
+  /* Vertical pixel position (relative to the baseline) of the
+     underline.  If it is positive, it is below the baseline.  It is
+     negative if that information is not in the font.  */
+  int underline_position;
+
+  /* 1 if `vertical-centering-font-regexp' matches this font name.
+     In this case, we render characters at vartical center positions
+     of lines.  */
+  int vertical_centering;
+
+  /* Encoding type of the font.  The value is one of
+     0, 1, 2, or 3:
+	0: code points 0x20..0x7F or 0x2020..0x7F7F are used
+	1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used
+	2: code points 0x20A0..0x7FFF are used
+	3: code points 0xA020..0xFF7F are used
+     If the member `font_encoder' is not NULL, this member is ignored.  */
+  unsigned char encoding_type;
+
+  /* The baseline position of a font is normally `ascent' value of the
+     font.  However, there exists many fonts which don't set `ascent'
+     an appropriate value to be used as baseline position.  This is
+     typical in such ASCII fonts which are designed to be used with
+     Chinese, Japanese, Korean characters.  When we use mixture of
+     such fonts and normal fonts (having correct `ascent' value), a
+     display line gets very ugly.  Since we have no way to fix it
+     automatically, it is users responsibility to supply well designed
+     fonts or correct `ascent' value of fonts.  But, the latter
+     requires heavy work (modifying all bitmap data in BDF files).
+     So, Emacs accepts a private font property
+     `_MULE_BASELINE_OFFSET'.  If a font has this property, we
+     calculate the baseline position by subtracting the value from
+     `ascent'.  In other words, the value indicates how many bits
+     higher we should draw a character of the font than normal ASCII
+     text for a better looking.
+
+     We also have to consider the fact that the concept of `baseline'
+     differs among scripts to which each character belongs.  For
+     instance, baseline should be at the bottom most position of all
+     glyphs for Chinese, Japanese, and Korean.  But, many of existing
+     fonts for those characters doesn't have correct `ascent' values
+     because they are designed to be used with ASCII fonts.  To
+     display characters of different language on the same line, the
+     best way will be to arrange them in the middle of the line.  So,
+     in such a case, again, we utilize the font property
+     `_MULE_BASELINE_OFFSET'.  If the value is larger than `ascent' we
+     calculate baseline so that a character is arranged in the middle
+     of a line.  */
+  int baseline_offset;
+
+  /* Non zero means a character should be composed at a position
+     relative to the height (or depth) of previous glyphs in the
+     following cases:
+	(1) The bottom of the character is higher than this value.  In
+	this case, the character is drawn above the previous glyphs.
+	(2) The top of the character is lower than 0 (i.e. baseline
+	height).  In this case, the character is drawn beneath the
+	previous glyphs.
+
+     This value is taken from a private font property
+     `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs.  */
+  int relative_compose;
+
+  /* Non zero means an ascent value to be used for a character
+     registered in char-table `use-default-ascent'.  */
+  int default_ascent;
+
+  /* CCL program to calculate code points of the font.  */
+  struct ccl_program *font_encoder;
+
   /* Font-driver for the font.  */
   struct font_driver *driver;

-  /* Symbol of font font; x, ttf, pcf, etc,   */
-  Lisp_Object format;
-
-  /* File name of the font, or NULL if the font is not associated with
-     a file.  */
-  char *file_name;
-
   /* Charset to encode a character code into a glyph code of the font.
      -1 means that the font doesn't require this information to encode
      a character.  */
@@ -171,15 +392,6 @@
      determine it.  */
   int repertory_charset;

-  /* Minimum glyph width (in pixels).  */
-  int min_width;
-
-  /* Ascent and descent of the font (in pixels).  */
-  int ascent, descent;
-
-  /* 1 iff the font is scalable.  */
-  int scalable;
-
   /* There will be more to this structure, but they are private to a
      font-driver.  */
 };
@@ -212,20 +424,23 @@

 /* Predicates to check various font-related objects.  */

+/* 1 iff X is one of font-spec, font-entity, and font-object.  */
+#define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
+/* 1 iff X is font-spec.  */
 #define FONT_SPEC_P(x)	\
-  (VECTORP (x) && ASIZE (x) == FONT_SPEC_MAX)
+  (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
+/* 1 iff X is font-entity.  */
 #define FONT_ENTITY_P(x)	\
-  (VECTORP (x) && ASIZE (x) == FONT_ENTITY_MAX)
+  (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
+/* 1 iff X is font-object.  */
 #define FONT_OBJECT_P(x)	\
-  (XTYPE (x) == Lisp_Misc && XMISCTYPE (x) == Lisp_Misc_Save_Value)
-#define FONTP(x)					\
-  ((VECTORP (x) && (ASIZE (x) == FONT_SPEC_MAX		\
-		    || ASIZE (x) == FONT_ENTITY_MAX))	\
-   || FONT_OBJECT_P (x))
+  (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)

+/* 1 iff ENTITY can't be loaded.  */
 #define FONT_ENTITY_NOT_LOADABLE(entity)	\
   EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)

+/* Flag ENTITY not loadable.  */
 #define FONT_ENTITY_SET_NOT_LOADABLE(entity)	\
   ASET (entity, FONT_OBJLIST_INDEX, Qt)

@@ -235,18 +450,36 @@
 #define CHECK_FONT(x)	\
   do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (0)
 #define CHECK_FONT_SPEC(x)	\
-  do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont, x); } while (0)
+  do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } while (0)
 #define CHECK_FONT_ENTITY(x)	\
-  do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont, x); } while (0)
+  do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } while (0)
 #define CHECK_FONT_OBJECT(x)	\
-  do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont, x); } while (0)
+  do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } while (0)
+
+#define CHECK_FONT_GET_OBJECT(x, font)	\
+  do {					\
+    CHECK_FONT_OBJECT (x);		\
+    font = XFONT_OBJECT (x);		\
+  } while (0)

-#define CHECK_FONT_GET_OBJECT(x, font)					\
-  do {									\
-    if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont, x);	\
-    if (! XSAVE_VALUE (x)->pointer) error ("Font already closed");	\
-    font = XSAVE_VALUE (x)->pointer;					\
-  } while (0)
+#define XFONT_SPEC(p)	\
+  (eassert (FONT_SPEC_P(p)), (struct font_spec *) XPNTR (p))
+#define XFONT_ENTITY(p)	\
+  (eassert (FONT_ENTITY_P(p)), (struct font_entity *) XPNTR (p))
+#define XFONT_OBJECT(p)	\
+  (eassert (FONT_OBJECT_P(p)), (struct font *) XPNTR (p))
+#define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
+
+/* Number of pt per inch (from the TeXbook).  */
+#define PT_PER_INCH 72.27
+
+/* Return a pixel size (integer) corresponding to POINT size (double)
+   on resolution DPI.  */
+#define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
+
+/* Return a point size (double) corresponding to POINT size (integer)
+   on resolution DPI.  */
+#define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)

 /* Ignore the difference of font pixel sizes less than or equal to
    this value.  */
@@ -334,13 +567,19 @@
   /* Symbol indicating the type of the font-driver.  */
   Lisp_Object type;

+  /* 1 iff the font's foundary, family, and adstyle names are case
+     sensitve.  */
+  int case_sensitive;
+
   /* Return a cache of font-entities on frame F.  The cache must be a
      cons whose cdr part is the actual cache area.  */
   Lisp_Object (*get_cache) P_ ((FRAME_PTR F));

   /* List fonts exactly matching with FONT_SPEC on FRAME.  The value
-     is a vector of font-entities.  This is the sole API that
-     allocates font-entities.  */
+     is a list of font-entities.  It is assured that the properties
+     WEIGHT to AVGWIDTH are all nil (i.e. not specified) in FONT_SPEC.
+     This and the following `match' are the only APIs that allocate
+     font-entities.  */
   Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));

   /* Return a font entity most closely maching with FONT_SPEC on
@@ -359,8 +598,8 @@

   /* Open a font specified by FONT_ENTITY on frame F.  If the font is
      scalable, open it with PIXEL_SIZE.  */
-  struct font *(*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
-			    int pixel_size));
+  Lisp_Object (*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
+			   int pixel_size));

   /* Close FONT on frame F.  */
   void (*close) P_ ((FRAME_PTR f, struct font *font));
@@ -477,6 +716,12 @@
      than the length of LGSTRING, nil should be return.  In that case,
      this function is called again with the larger LGSTRING.  */
   Lisp_Object (*shape) P_ ((Lisp_Object lgstring));
+
+  /* Optional.
+
+     If FONT is usable on frame F, return 0.  Otherwise return -1.
+   */
+  int (*check) P_ ((FRAME_PTR F, struct font *font));
 };


@@ -509,49 +754,62 @@
   struct font_data_list *next;
 };

-extern int enable_font_backend;
-
 EXFUN (Ffont_spec, MANY);
+EXFUN (Fcopy_font_spec, 1);
+EXFUN (Fmerge_font_spec, 2);
 EXFUN (Ffont_get, 2);
+EXFUN (Ffont_put, 3);
 EXFUN (Flist_fonts, 4);
+EXFUN (Ffont_family_list, 1);
 EXFUN (Fclear_font_cache, 0);
 EXFUN (Ffont_xlfd_name, 1);

+extern Lisp_Object font_make_spec P_ ((void));
+extern Lisp_Object font_make_entity P_ ((void));
+extern Lisp_Object font_make_object P_ ((int));
+
 extern int font_registry_charsets P_ ((Lisp_Object, struct charset **,
 				       struct charset **));
-extern Lisp_Object font_symbolic_weight P_ ((Lisp_Object font));
-extern Lisp_Object font_symbolic_slant P_ ((Lisp_Object font));
-extern Lisp_Object font_symbolic_width P_ ((Lisp_Object font));
+extern int font_style_to_value P_ ((enum font_property_index prop,
+				    Lisp_Object name, int noerror));
+extern Lisp_Object font_style_symbolic P_ ((Lisp_Object font,
+					    enum font_property_index prop,
+					    int for_face));

 extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object entity));
+extern Lisp_Object font_list_entities P_ ((Lisp_Object frame,
+					   Lisp_Object spec));

-extern Lisp_Object font_find_object P_ ((struct font *font));
 extern Lisp_Object font_get_name P_ ((Lisp_Object font_object));
-extern Lisp_Object font_get_spec P_ ((Lisp_Object font_object));
+extern Lisp_Object font_spec_from_name P_ ((Lisp_Object font_name));
 extern Lisp_Object font_get_frame P_ ((Lisp_Object font_object));
 extern int font_has_char P_ ((FRAME_PTR, Lisp_Object, int));
 extern unsigned font_encode_char P_ ((Lisp_Object, int));

-extern int font_set_lface_from_name P_ ((FRAME_PTR f,
-					 Lisp_Object lface,
-					 Lisp_Object fontname,
-					 int force_p, int may_fail_p));
+extern void font_clear_prop P_ ((Lisp_Object *attrs,
+				 enum font_property_index prop));
+extern void font_update_lface P_ ((FRAME_PTR f, Lisp_Object *attrs));
 extern Lisp_Object font_find_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
 					    Lisp_Object spec, int c));
 extern Lisp_Object font_open_for_lface P_ ((FRAME_PTR f, Lisp_Object entity,
 					    Lisp_Object *lface,
 					    Lisp_Object spec));
-extern void font_load_for_face P_ ((FRAME_PTR f, struct face *face));
+extern Lisp_Object font_load_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
+					    Lisp_Object spec));
 extern void font_prepare_for_face P_ ((FRAME_PTR f, struct face *face));
+extern void font_done_for_face P_ ((FRAME_PTR f, struct face *face));
+
 extern Lisp_Object font_open_by_name P_ ((FRAME_PTR f, char *name));
 extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);

-extern Lisp_Object intern_downcase P_ ((char *str, int len));
+extern Lisp_Object font_intern_prop P_ ((char *str, int len));
 extern void font_update_sort_order P_ ((int *order));

-extern void font_merge_old_spec P_ ((Lisp_Object name, Lisp_Object family,
-				     Lisp_Object registry, Lisp_Object spec));
-
+extern void font_parse_family_registry P_ ((Lisp_Object family,
+					    Lisp_Object registry,
+					    Lisp_Object spec));
+extern Lisp_Object font_spec_from_family_registry P_ ((Lisp_Object family,
+						       Lisp_Object registry));

 extern int font_parse_xlfd P_ ((char *name, Lisp_Object font));
 extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
@@ -564,6 +822,9 @@
 extern Lisp_Object font_update_drivers P_ ((FRAME_PTR f, Lisp_Object list));
 extern Lisp_Object font_at P_ ((int c, EMACS_INT pos, struct face *face,
 				struct window *w, Lisp_Object object));
+extern EMACS_INT font_range P_ ((EMACS_INT pos, EMACS_INT limit,
+				 struct face *face, FRAME_PTR f,
+				 Lisp_Object object));

 extern struct font *font_prepare_composition P_ ((struct composition *cmp,
 						  FRAME_PTR f));