[Emacs-diffs] Changes to src/font.h

[Miles Bader]

CVSROOT:        /cvsroot/emacs
Module name:    emacs
Changes by:     Miles Bader <miles>     08/02/01 16:01:31

Index: src/font.h
===================================================================
RCS file: src/font.h
diff -N src/font.h
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ src/font.h  1 Feb 2008 16:00:53 -0000       1.2
@@ -0,0 +1,584 @@
+/* font.h -- Interface definition for font handling.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   Copyright (C) 2006
+     National Institute of Advanced Industrial Science and Technology (AIST)
+     Registration Number H13PRO009
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+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
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+#ifndef EMACS_FONT_H
+#define EMACS_FONT_H
+
+#include "ccl.h"
+
+/* We have three types of Lisp objects related to font.
+
+   FONT-SPEC
+
+       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.
+
+   FONT-ENTITY
+
+       Vector (length FONT_ENTITY_MAX) of fully specified 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).
+
+   FONT-OBJECT
+
+       Lisp object of type Lisp_Misc_Save_Value encapsulating a
+       pointer to "struct font".  This corresponds to an opened font.
+
+       Note: The note for FONT-ENTITY also applies to this.
+*/
+
+
+struct font_driver;
+struct font;
+
+/* An enumerator for each font property.  This is used as an index to
+   the vector of FONT-SPEC and FONT-ENTITY.
+
+   Note: The order is important and should not be changed.  */
+
+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.
+       For Mac OS X, we need `atm'.  */
+    FONT_TYPE_INDEX,
+
+    /* FONT-FOUNDRY is a foundry name (symbol).  */
+    FONT_FOUNDRY_INDEX,
+
+    /* FONT-FAMILY is a family name (symbol).  */
+    FONT_FAMILY_INDEX,
+
+    /* FONT-ADSTYLE is an additional style name (symbol).  */
+    FONT_ADSTYLE_INDEX,
+
+    /* FONT-REGISTRY is a combination of a charset-registry and
+       charset0encoding 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. */
+    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_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_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.  */
+    FONT_SIZE_INDEX,
+
+    /* 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).  */
+    FONT_EXTRA_INDEX,          /* alist                alist */
+
+    /* This value is the length of font-spec vector.  */
+    FONT_SPEC_MAX,
+
+    /* 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,
+
+    /* This value is the length of font-entity vector.  */
+    FONT_ENTITY_MAX
+  };
+
+extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClanguage, QCscript;
+
+/* 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 an opened font.  We can safely cast this structure to
+   "struct font_info".  */
+
+struct font
+{
+  struct font_info font;
+
+  /* From which font-entity the font is opened.  */
+  Lisp_Object entity;
+
+  /* By which pixel size the font is opened.  */
+  int pixel_size;
+
+  /* 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.  */
+  int encoding_charset;
+
+  /* Charset to check if a character code is supported by the font.
+     -1 means that the contents of the font must be looked up to
+     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.  */
+};
+
+enum font_spacing
+  {
+    FONT_SPACING_PROPORTIONAL = 0,
+    FONT_SPACING_DUAL = 90,
+    FONT_SPACING_MONO = 100,
+    FONT_SPACING_CHARCELL = 110
+  };
+
+struct font_metrics
+{
+  short lbearing, rbearing, width, ascent, descent;
+};
+
+struct font_bitmap
+{
+  int bits_per_pixel;
+  int rows;
+  int width;
+  int pitch;
+  unsigned char *buffer;
+  int left;
+  int top;
+  int advance;
+  void *extra;
+};
+
+/* Predicates to check various font-related objects.  */
+
+#define FONT_SPEC_P(x) \
+  (VECTORP (x) && ASIZE (x) == FONT_SPEC_MAX)
+#define FONT_ENTITY_P(x)       \
+  (VECTORP (x) && ASIZE (x) == FONT_ENTITY_MAX)
+#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))
+
+#define FONT_ENTITY_NOT_LOADABLE(entity)       \
+  EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)
+
+#define FONT_ENTITY_SET_NOT_LOADABLE(entity)   \
+  ASET (entity, FONT_OBJLIST_INDEX, Qt)
+
+
+/* Check macros for various font-related objects.  */
+
+#define CHECK_FONT(x)  \
+  do { if (! FONTP (x)) x = wrong_type_argument (Qfont, x); } while (0)
+#define CHECK_FONT_SPEC(x)     \
+  do { if (! FONT_SPEC_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+#define CHECK_FONT_ENTITY(x)   \
+  do { if (! FONT_ENTITY_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+#define CHECK_FONT_OBJECT(x)   \
+  do { if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+
+#define CHECK_FONT_GET_OBJECT(x, font)                                 \
+  do {                                                                 \
+    if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x);       \
+    if (! XSAVE_VALUE (x)->pointer) error ("Font already closed");     \
+    font = XSAVE_VALUE (x)->pointer;                                   \
+  } while (0)
+
+/* Ignore the difference of font pixel sizes less than or equal to
+   this value.  */
+#define FONT_PIXEL_SIZE_QUANTUM 1
+
+struct face;
+struct composition;
+
+/* Macros for lispy glyph-string.  */
+#define LGSTRING_FONT(lgs) AREF (AREF ((lgs), 0), 0)
+#define LGSTRING_WIDTH(lgs) XINT (AREF (AREF ((lgs), 0), 1))
+#define LGSTRING_LBEARING(lgs) XINT (AREF (AREF ((lgs), 0), 2))
+#define LGSTRING_RBEARING(lgs) XINT (AREF (AREF ((lgs), 0), 3))
+#define LGSTRING_ASCENT(lgs) XINT (AREF (AREF ((lgs), 0), 4))
+#define LGSTRING_DESCENT(lgs) XINT (AREF (AREF ((lgs), 0), 5))
+#define LGSTRING_SET_FONT(lgs, val)    \
+  ASET (AREF ((lgs), 0), 0, (val))
+#define LGSTRING_SET_WIDTH(lgs, val)   \
+  ASET (AREF ((lgs), 0), 1, make_number (val))
+#define LGSTRING_SET_LBEARING(lgs, val) \
+  ASET (AREF ((lgs), 0), 2, make_number (val))
+#define LGSTRING_SET_RBEARING(lgs, val)        \
+  ASET (AREF ((lgs), 0), 3, make_number (val))
+#define LGSTRING_SET_ASCENT(lgs, val)  \
+  ASET (AREF ((lgs), 0), 4, make_number (val))
+#define LGSTRING_SET_DESCENT(lgs, val) \
+  ASET (AREF ((lgs), 0), 5, make_number (val))
+
+#define LGSTRING_LENGTH(lgs) (ASIZE ((lgs)) - 1)
+#define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 1)
+#define LGSTRING_SET_GLYPH(lgs, idx, val) ASET ((lgs), (idx) + 1, (val))
+
+/* Vector size of Lispy glyph.  */
+#define LGLYPH_SIZE 10
+#define LGLYPH_FROM(g) XINT (AREF ((g), 0))
+#define LGLYPH_TO(g) XINT (AREF ((g), 1))
+#define LGLYPH_CHAR(g) XINT (AREF ((g), 2))
+#define LGLYPH_CODE(g) XINT (AREF ((g), 3))
+#define LGLYPH_WIDTH(g) XINT (AREF ((g), 4))
+#define LGLYPH_LBEARING(g) XINT (AREF ((g), 5))
+#define LGLYPH_RBEARING(g) XINT (AREF ((g), 6))
+#define LGLYPH_ASCENT(g) XINT (AREF ((g), 7))
+#define LGLYPH_DESCENT(g) XINT (AREF ((g), 8))
+#define LGLYPH_ADJUSTMENT(g) AREF ((g), 9)
+#define LGLYPH_SET_FROM(g, val) ASET ((g), 0, make_number (val))
+#define LGLYPH_SET_TO(g, val) ASET ((g), 1, make_number (val))
+#define LGLYPH_SET_CHAR(g, val) ASET ((g), 2, make_number (val))
+#define LGLYPH_SET_CODE(g, val) ASET ((g), 3, make_number (val))
+#define LGLYPH_SET_WIDTH(g, val) ASET ((g), 4, make_number (val))
+#define LGLYPH_SET_LBEARING(g, val) ASET ((g), 5, make_number (val))
+#define LGLYPH_SET_RBEARING(g, val) ASET ((g), 6, make_number (val))
+#define LGLYPH_SET_ASCENT(g, val) ASET ((g), 7, make_number (val))
+#define LGLYPH_SET_DESCENT(g, val) ASET ((g), 8, make_number (val))
+#define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), 9, (val))
+
+#define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
+                       ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
+#define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
+                       ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
+#define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
+                          ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
+
+#define FONT_INVALID_CODE 0xFFFFFFFF
+
+/* Font driver.  Members specified as "optional" can be NULL.  */
+
+struct font_driver
+{
+  /* Symbol indicating the type of the font-driver.  */
+  Lisp_Object type;
+
+  /* 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.  */
+  Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));
+
+  /* Return a font entity most closely maching with FONT_SPEC on
+     FRAME.  The closeness is detemined by the font backend, thus
+     `face-font-selection-order' is ignored here.  */
+  Lisp_Object (*match) P_ ((Lisp_Object frame, Lisp_Object font_spec));
+
+  /* Optional.
+     List available families.  The value is a list of family names
+     (symbols).  */
+  Lisp_Object (*list_family) P_ ((Lisp_Object frame));
+
+  /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
+     Free FONT_EXTRA_INDEX field of FONT_ENTITY.  */
+  void (*free_entity) P_ ((Lisp_Object font_entity));
+
+  /* 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));
+
+  /* Close FONT on frame F.  */
+  void (*close) P_ ((FRAME_PTR f, struct font *font));
+
+  /* Optional (if FACE->extra is not used).
+     Prepare FACE for displaying characters by FONT on frame F by
+     storing some data in FACE->extra.  If successful, return 0.
+     Otherwise, return -1.  */
+  int (*prepare_face) P_ ((FRAME_PTR f, struct face *face));
+
+  /* Optional.
+     Done FACE for displaying characters by FACE->font on frame F.  */
+  void (*done_face) P_ ((FRAME_PTR f, struct face *face));
+
+  /* Optional.
+     If FONT_ENTITY has a glyph for character C (Unicode code point),
+     return 1.  If not, return 0.  If a font must be opened to check
+     it, return -1.  */
+  int (*has_char) P_ ((Lisp_Object entity, int c));
+
+  /* Return a glyph code of FONT for characer C (Unicode code point).
+     If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
+  unsigned (*encode_char) P_ ((struct font *font, int c));
+
+  /* Computate the total metrics of the NGLYPHS glyphs specified by
+     the font FONT and the sequence of glyph codes CODE, and store the
+     result in METRICS.  */
+  int (*text_extents) P_ ((struct font *font,
+                          unsigned *code, int nglyphs,
+                          struct font_metrics *metrics));
+
+  /* Optional.
+     Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
+     position of frame F with S->FACE and S->GC.  If WITH_BACKGROUND
+     is nonzero, fill the background in advance.  It is assured that
+     WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).  */
+  int (*draw) P_ ((struct glyph_string *s, int from, int to,
+                  int x, int y, int with_background));
+
+  /* Optional.
+     Store bitmap data for glyph-code CODE of FONT in BITMAP.  It is
+     intended that this method is callled from the other font-driver
+     for actual drawing.  */
+  int (*get_bitmap) P_ ((struct font *font, unsigned code,
+                        struct font_bitmap *bitmap,
+                        int bits_per_pixel));
+
+  /* Optional.
+     Free bitmap data in BITMAP.  */
+  void (*free_bitmap) P_ ((struct font *font, struct font_bitmap *bitmap));
+
+  /* Optional.
+     Return an outline data for glyph-code CODE of FONT.  The format
+     of the outline data depends on the font-driver.  */
+  void *(*get_outline) P_ ((struct font *font, unsigned code));
+
+  /* Optional.
+     Free OUTLINE (that is obtained by the above method).  */
+  void (*free_outline) P_ ((struct font *font, void *outline));
+
+  /* Optional.
+     Get coordinates of the INDEXth anchor point of the glyph whose
+     code is CODE.  Store the coordinates in *X and *Y.  Return 0 if
+     the operations was successfull.  Otherwise return -1.  */
+  int (*anchor_point) P_ ((struct font *font, unsigned code, int index,
+                          int *x, int *y));
+
+  /* Optional.
+     Return a list describing which scripts/languages FONT
+     supports by which GSUB/GPOS features of OpenType tables.  */
+  Lisp_Object (*otf_capability) P_ ((struct font *font));
+
+  /* Optional.
+     Apply FONT's OTF-FEATURES to the glyph string.
+
+     FEATURES specifies which OTF features to apply in this format:
+       (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
+     See the documentation of `font-drive-otf' for the detail.
+
+     This method applies the specified features to the codes in the
+     elements of GSTRING-IN (between FROMth and TOth).  The output
+     codes are stored in GSTRING-OUT at the IDXth element and the
+     following elements.
+
+     Return the number of output codes.  If none of the features are
+     applicable to the input data, return 0.  If GSTRING-OUT is too
+     short, return -1.  */
+  int (*otf_drive) P_ ((struct font *font, Lisp_Object features,
+                      Lisp_Object gstring_in, int from, int to,
+                      Lisp_Object gstring_out, int idx, int alternate_subst));
+
+  /* Optional.
+     Make the font driver ready for frame F.  Usually this function
+     makes some data specific to F and store it in F by calling
+     font_put_frame_data ().  */
+  int (*start_for_frame) P_ ((FRAME_PTR f));
+  
+  /* Optional.
+     End using the driver for frame F.  Usually this function free
+     some data stored for F.  */
+  int (*end_for_frame) P_ ((FRAME_PTR f));
+
+  /* Optional.
+
+     Shape text in LGSTRING.  See the docstring of `font-make-gstring'
+     for the format of LGSTRING.  If the (N+1)th element of LGSTRING
+     is nil, input of shaping is from the 1st to (N)th elements.  In
+     each input glyph, FROM, TO, CHAR, and CODE are already set.
+
+     This function updates all fields of the input glyphs.  If the
+     output glyphs (M) are more than the input glyphs (N), (N+1)th
+     through (M)th elements of LGSTRING are updated possibly by making
+     a new glyph object and storing it in LGSTRING.  If (M) is greater
+     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));
+};
+
+
+/* Chain of font drivers.  There's one global font driver list
+   (font_driver_list in font.c).  In addition, each frame has it's own
+   font driver list at FRAME_PTR->font_driver_list.  */
+
+struct font_driver_list
+{
+  /* 1 iff this driver is currently used.  It is igonred in the global
+     font driver list.*/
+  int on;
+  /* Pointer to the font driver.  */
+  struct font_driver *driver;
+  /* Pointer to the next element of the chain.  */
+  struct font_driver_list *next;
+};
+
+
+/* Chain of arbitrary data specific to each font driver.  Each frame
+   has it's own font data list at FRAME_PTR->font_data_list.  */
+
+struct font_data_list
+{
+  /* Pointer to the font driver.  */
+  struct font_driver *driver;
+  /* Data specific to the font driver.  */
+  void *data;
+  /* Pointer to the next element of the chain.  */
+  struct font_data_list *next;
+};
+
+extern int enable_font_backend;
+
+EXFUN (Ffont_spec, MANY);
+EXFUN (Ffont_get, 2);
+EXFUN (Flist_fonts, 4);
+EXFUN (Fclear_font_cache, 0);
+EXFUN (Ffont_xlfd_name, 1);
+
+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_match_p P_ ((Lisp_Object spec, Lisp_Object entity));
+
+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_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 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 void font_prepare_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 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 int font_parse_xlfd P_ ((char *name, Lisp_Object font));
+extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
+                                 char *name, int bytes));
+extern int font_parse_fcname P_ ((char *name, Lisp_Object font));
+extern int font_unparse_fcname P_ ((Lisp_Object font, int pixel_size,
+                                 char *name, int bytes));
+extern void register_font_driver P_ ((struct font_driver *driver, FRAME_PTR 
f));
+extern void free_font_driver_list P_ ((FRAME_PTR f));
+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 struct font *font_prepare_composition P_ ((struct composition *cmp,
+                                                 FRAME_PTR f));
+
+extern Lisp_Object font_put_extra P_ ((Lisp_Object font, Lisp_Object prop,
+                                       Lisp_Object val));
+
+extern int font_put_frame_data P_ ((FRAME_PTR f,
+                                   struct font_driver *driver,
+                                   void *data));
+extern void *font_get_frame_data P_ ((FRAME_PTR f,
+                                     struct font_driver *driver));
+
+#ifdef HAVE_FREETYPE
+extern struct font_driver ftfont_driver;
+#endif /* HAVE_FREETYPE */
+#ifdef HAVE_X_WINDOWS
+extern struct font_driver xfont_driver;
+extern struct font_driver ftxfont_driver;
+#ifdef HAVE_XFT
+extern struct font_driver xftfont_driver;
+#endif /* HAVE_XFT */
+#endif /* HAVE_X_WINDOWS */
+#ifdef WINDOWSNT
+extern struct font_driver w32font_driver;
+#endif /* WINDOWSNT */
+#ifdef MAC_OS
+extern struct font_driver atmfont_driver;
+#endif /* MAC_OS */
+
+#endif /* not EMACS_FONT_H */
+
+/* arch-tag: 3b7260c3-5bec-4d6b-a0db-95c1b431b1a2
+   (do not change this comment) */