/* font.c -- "Font" primitives.
- 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
+
+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
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
-#include <stdlib.h>
#include <ctype.h>
#include <setjmp.h>
#include "nsterm.h"
#endif /* HAVE_NS */
-#ifdef HAVE_NS
-extern Lisp_Object Qfontsize;
-#endif
-
Lisp_Object Qopentype;
/* Important character set strings. */
{ 200, { "ultra-expanded", "ultraexpanded", "wide" }}
};
-extern Lisp_Object Qnormal;
-
-/* Symbols representing keys of normal font properties. */
-extern Lisp_Object QCtype, QCfamily, QCweight, QCslant, QCwidth;
-extern Lisp_Object QCheight, QCsize, QCname;
-
-Lisp_Object QCfoundry, QCadstyle, QCregistry;
+Lisp_Object QCfoundry;
+static Lisp_Object QCadstyle, QCregistry;
/* Symbols representing keys of font extra info. */
Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript, QCavgwidth;
Lisp_Object QCantialias, QCfont_entity, QCfc_unknown_spec;
/* Creaters of font-related Lisp object. */
-Lisp_Object
+static Lisp_Object
font_make_spec (void)
{
Lisp_Object font_spec;
static Lisp_Object font_open_entity (FRAME_PTR, Lisp_Object, int);
static Lisp_Object font_matching_entity (FRAME_PTR, Lisp_Object *,
Lisp_Object);
+static unsigned font_encode_char (Lisp_Object, int);
/* Number of registered font drivers. */
static int num_font_drivers;
STR. */
Lisp_Object
-font_intern_prop (char *str, int len, int force_symbol)
+font_intern_prop (const char *str, int len, int force_symbol)
{
int i;
Lisp_Object tem;
Lisp_Object obarray;
- int nbytes, nchars;
+ EMACS_INT nbytes, nchars;
if (len == 1 && *str == '*')
return Qnil;
return (for_face ? AREF (elt, 1) : AREF (elt, (i & 0xF) + 1));
}
-extern Lisp_Object Vface_alternative_font_family_alist;
-
-extern Lisp_Object find_font_encoding (Lisp_Object);
-
-
/* Return ENCODING or a cons of ENCODING and REPERTORY of the font
FONTNAME. ENCODING is a charset symbol that specifies the encoding
of the font. REPERTORY is a charset symbol or nil. */
/* Structure of known font property keys and validater of the
values. */
-struct
+static const struct
{
/* Pointer to the key symbol. */
Lisp_Object *key;
\f
/* Font name parser and unparser */
-static int parse_matrix (char *);
+static int parse_matrix (const char *);
static int font_expand_wildcards (Lisp_Object *, int);
static int font_parse_name (char *, Lisp_Object);
-1. */
static int
-parse_matrix (char *p)
+parse_matrix (const char *p)
{
double matrix[4];
char *end;
}
-#ifdef ENABLE_CHECKING
-/* Match a 14-field XLFD pattern against a full XLFD font name. */
-static int
-font_match_xlfd (char *pattern, char *name)
-{
- while (*pattern && *name)
- {
- if (*pattern == *name)
- pattern++;
- else if (*pattern == '*')
- if (*name == pattern[1])
- pattern += 2;
- else
- ;
- else
- return 0;
- name++;
- }
- return 1;
-}
-
-/* Make sure the font object matches the XLFD font name. */
-static int
-font_check_xlfd_parse (Lisp_Object font, char *name)
-{
- char name_check[256];
- font_unparse_xlfd (font, 0, name_check, 255);
- return font_match_xlfd (name_check, name);
-}
-
-#endif
-
-
/* Parse NAME (null terminated) as XLFD and store information in FONT
(font-spec or font-entity). Size property of FONT is set as
follows:
This function tries to guess which format it is. */
-int
+static int
font_parse_fcname (char *name, Lisp_Object font)
{
char *p, *q;
int i, len = 1;
char *p;
Lisp_Object styles[3];
- char *style_names[3] = { "weight", "slant", "width" };
+ const char *style_names[3] = { "weight", "slant", "width" };
char work[256];
family = AREF (font, FONT_FAMILY_INDEX);
return (p - name);
}
-/* Store GTK-style font name of FONT (font-spec or font-entity) in
- NAME (NBYTES length), and return the name length. F is the frame
- on which the font is displayed; it is used to calculate the point
- size. */
-
-int
-font_unparse_gtkname (Lisp_Object font, struct frame *f, char *name, int nbytes)
-{
- char *p;
- int len = 1;
- Lisp_Object family, weight, slant, size;
- int point_size = -1;
-
- family = AREF (font, FONT_FAMILY_INDEX);
- if (! NILP (family))
- {
- if (! SYMBOLP (family))
- return -1;
- family = SYMBOL_NAME (family);
- len += SBYTES (family);
- }
-
- weight = font_style_symbolic (font, FONT_WEIGHT_INDEX, 0);
- if (EQ (weight, Qnormal))
- weight = Qnil;
- else if (! NILP (weight))
- {
- weight = SYMBOL_NAME (weight);
- len += SBYTES (weight);
- }
-
- slant = font_style_symbolic (font, FONT_SLANT_INDEX, 0);
- if (EQ (slant, Qnormal))
- slant = Qnil;
- else if (! NILP (slant))
- {
- slant = SYMBOL_NAME (slant);
- len += SBYTES (slant);
- }
-
- size = AREF (font, FONT_SIZE_INDEX);
- /* Convert pixel size to point size. */
- if (INTEGERP (size))
- {
- Lisp_Object font_dpi = AREF (font, FONT_DPI_INDEX);
- int dpi = 75;
- if (INTEGERP (font_dpi))
- dpi = XINT (font_dpi);
- else if (f)
- dpi = f->resy;
- point_size = PIXEL_TO_POINT (XINT (size), dpi);
- len += 11;
- }
- else if (FLOATP (size))
- {
- point_size = (int) XFLOAT_DATA (size);
- len += 11;
- }
-
- if (len > nbytes)
- return -1;
-
- p = name + sprintf (name, "%s", SDATA (family));
-
- if (! NILP (weight))
- {
- char *q = p;
- p += sprintf (p, " %s", SDATA (weight));
- q[1] = toupper (q[1]);
- }
-
- if (! NILP (slant))
- {
- char *q = p;
- p += sprintf (p, " %s", SDATA (slant));
- q[1] = toupper (q[1]);
- }
-
- if (point_size > 0)
- p += sprintf (p, " %d", point_size);
-
- return (p - name);
-}
-
/* Parse NAME (null terminated) and store information in FONT
(font-spec or font-entity). If NAME is successfully parsed, return
0. Otherwise return -1. */
static int
font_parse_name (char *name, Lisp_Object font)
{
- if (name[0] == '-' || index (name, '*') || index (name, '?'))
+ if (name[0] == '-' || strchr (name, '*') || strchr (name, '?'))
return font_parse_xlfd (name, font);
return font_parse_fcname (name, font);
}
CHECK_STRING (family);
len = SBYTES (family);
p0 = (char *) SDATA (family);
- p1 = index (p0, '-');
+ p1 = strchr (p0, '-');
if (p1)
{
if ((*p0 != '*' && p1 - p0 > 0)
CHECK_STRING (registry);
len = SBYTES (registry);
p0 = (char *) SDATA (registry);
- p1 = index (p0, '-');
+ p1 = strchr (p0, '-');
if (! p1)
{
if (SDATA (registry)[len - 1] == '*')
static Lisp_Object font_sort_entities (Lisp_Object, Lisp_Object,
Lisp_Object, int);
-/* Return a rescaling ratio of FONT_ENTITY. */
-extern Lisp_Object Vface_font_rescale_alist;
-
static double
font_rescale_ratio (Lisp_Object font_entity)
{
(2) doesn't match with any regexps in Vface_ignored_fonts (if non-nil).
*/
-extern Lisp_Object Vface_ignored_fonts;
-
Lisp_Object
font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
{
return Qnil;
ASET (entity, FONT_OBJLIST_INDEX,
Fcons (font_object, AREF (entity, FONT_OBJLIST_INDEX)));
- ASET (font_object, FONT_OBJLIST_INDEX, Qnil);
num_fonts++;
font = XFONT_OBJECT (font_object);
/* Return the glyph ID of FONT_OBJECT for character C. */
-unsigned
+static unsigned
font_encode_char (Lisp_Object font_object, int c)
{
struct font *font;
attrs[LFACE_FONT_INDEX] = font;
}
-void
-font_update_lface (FRAME_PTR f, Lisp_Object *attrs)
-{
- Lisp_Object spec;
-
- spec = attrs[LFACE_FONT_INDEX];
- if (! FONT_SPEC_P (spec))
- return;
-
- if (! NILP (AREF (spec, FONT_FOUNDRY_INDEX)))
- attrs[LFACE_FOUNDRY_INDEX] = SYMBOL_NAME (AREF (spec, FONT_FOUNDRY_INDEX));
- if (! NILP (AREF (spec, FONT_FAMILY_INDEX)))
- attrs[LFACE_FAMILY_INDEX] = SYMBOL_NAME (AREF (spec, FONT_FAMILY_INDEX));
- if (! NILP (AREF (spec, FONT_WEIGHT_INDEX)))
- attrs[LFACE_WEIGHT_INDEX] = FONT_WEIGHT_FOR_FACE (spec);
- if (! NILP (AREF (spec, FONT_SLANT_INDEX)))
- attrs[LFACE_SLANT_INDEX] = FONT_SLANT_FOR_FACE (spec);
- if (! NILP (AREF (spec, FONT_WIDTH_INDEX)))
- attrs[LFACE_SWIDTH_INDEX] = FONT_WIDTH_FOR_FACE (spec);
- if (! NILP (AREF (spec, FONT_SIZE_INDEX)))
- {
- int point;
-
- if (INTEGERP (AREF (spec, FONT_SIZE_INDEX)))
- {
- Lisp_Object val;
- int dpi = f->resy;
-
- val = Ffont_get (spec, QCdpi);
- if (! NILP (val))
- dpi = XINT (val);
- point = PIXEL_TO_POINT (XINT (AREF (spec, FONT_SIZE_INDEX)) * 10,
- dpi);
- attrs[LFACE_HEIGHT_INDEX] = make_number (point);
- }
- else if (FLOATP (AREF (spec, FONT_SIZE_INDEX)))
- {
- point = XFLOAT_DATA (AREF (spec, FONT_SIZE_INDEX)) * 10;
- attrs[LFACE_HEIGHT_INDEX] = make_number (point);
- }
- }
-}
-
-
/* Selecte a font from ENTITIES (list of font-entity vectors) that
supports C and matches best with ATTRS and PIXEL_SIZE. */
if (NILP (entity))
return Qnil;
}
- /* Don't loose the original name that was put in initially. We need
+ /* Don't lose the original name that was put in initially. We need
it to re-apply the font when font parameters (like hinting or dpi) have
changed. */
entity = font_open_for_lface (f, entity, attrs, spec);
found, return Qnil. */
Lisp_Object
-font_open_by_name (FRAME_PTR f, char *name)
+font_open_by_name (FRAME_PTR f, const char *name)
{
Lisp_Object args[2];
Lisp_Object spec, ret;
args[1] = make_unibyte_string (name, strlen (name));
spec = Ffont_spec (2, args);
ret = font_open_by_spec (f, spec);
- /* Do not loose name originally put in. */
+ /* Do not lose name originally put in. */
if (!NILP (ret))
font_put_extra (ret, QCuser_spec, args[1]);
}
+/* Sets attributes on a font. Any properties that appear in ALIST and
+ BOOLEAN_PROPERTIES or NON_BOOLEAN_PROPERTIES are set on the font.
+ BOOLEAN_PROPERTIES and NON_BOOLEAN_PROPERTIES are NULL-terminated
+ arrays of strings. This function is intended for use by the font
+ drivers to implement their specific font_filter_properties. */
+void
+font_filter_properties (Lisp_Object font,
+ Lisp_Object alist,
+ const char *const boolean_properties[],
+ const char *const non_boolean_properties[])
+{
+ Lisp_Object it;
+ int i;
+
+ /* Set boolean values to Qt or Qnil */
+ for (i = 0; boolean_properties[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 (boolean_properties[i], keystr) == 0)
+ {
+ const char *str = INTEGERP (val) ? (XINT (val) ? "true" : "false")
+ : SYMBOLP (val) ? (const char *) SDATA (SYMBOL_NAME (val))
+ : "true";
+
+ 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;
+ else
+ val = Qt;
+
+ Ffont_put (font, key, val);
+ }
+ }
+
+ for (i = 0; non_boolean_properties[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 (non_boolean_properties[i], keystr) == 0)
+ Ffont_put (font, key, val);
+ }
+}
+
+
/* Return the font used to draw character C by FACE at buffer position
POS in window W. If STRING is non-nil, it is a string containing C
at index POS. If C is negative, get C from the current buffer or
STRING. */
-Lisp_Object
-font_at (int c, EMACS_INT pos, struct face *face, struct window *w, Lisp_Object string)
+static Lisp_Object
+font_at (int c, EMACS_INT pos, struct face *face, struct window *w,
+ Lisp_Object string)
{
FRAME_PTR f;
int multibyte;
DEFUN ("font-get", Ffont_get, Sfont_get, 2, 2, 0,
doc: /* Return the value of FONT's property KEY.
FONT is a font-spec, a font-entity, or a font-object.
-KEY must be one of these symbols:
+KEY is any symbol, but these are reserved for specific meanings:
:family, :weight, :slant, :width, :foundry, :adstyle, :registry,
- :size, :name, :script
+ :size, :name, :script, :otf
See the documentation of `font-spec' for their meanings.
-If FONT is a font-entity or font-object, the value of :script may be
-a list of scripts that are supported by the font. */)
+In addition, if FONT is a font-entity or a font-object, values of
+:script and :otf are different from those of a font-spec as below:
+
+The value of :script may be a list of scripts that are supported by the font.
+
+The value of :otf is a cons (GSUB . GPOS) where GSUB and GPOS are lists
+representing the OpenType features supported by the font by this form:
+ ((SCRIPT (LANGSYS FEATURE ...) ...) ...)
+SCRIPT, LANGSYS, and FEATURE are all symbols representing OpenType
+Layout tags. */)
(Lisp_Object font, Lisp_Object key)
{
int idx;
+ Lisp_Object val;
CHECK_FONT (font);
CHECK_SYMBOL (key);
return font_style_symbolic (font, idx, 0);
if (idx >= 0 && idx < FONT_EXTRA_INDEX)
return AREF (font, idx);
- return Fcdr (Fassq (key, AREF (font, FONT_EXTRA_INDEX)));
+ val = Fassq (key, AREF (font, FONT_EXTRA_INDEX));
+ if (NILP (val) && EQ (key, QCotf) && FONT_OBJECT_P (font))
+ {
+ struct font *fontp = XFONT_OBJECT (font);
+
+ if (fontp->driver->otf_capability)
+ val = fontp->driver->otf_capability (fontp);
+ else
+ val = Fcons (Qnil, Qnil);
+ font_put_extra (font, QCotf, val);
+ }
+ else
+ val = Fcdr (val);
+ return val;
}
#ifdef HAVE_WINDOW_SYSTEM
#endif
DEFUN ("font-put", Ffont_put, Sfont_put, 3, 3, 0,
- doc: /* Set one property of FONT-SPEC: give property PROP value VAL. */)
- (Lisp_Object font_spec, Lisp_Object prop, Lisp_Object val)
+ doc: /* Set one property of FONT: give property KEY value VAL.
+FONT is a font-spec, a font-entity, or a font-object.
+
+If FONT is a font-spec, KEY can be any symbol. But if KEY is the one
+accepted by the function `font-spec' (which see), VAL must be what
+allowed in `font-spec'.
+
+If FONT is a font-entity or a font-object, KEY must not be the one
+accepted by `font-spec'. */)
+ (Lisp_Object font, Lisp_Object prop, Lisp_Object val)
{
int idx;
- CHECK_FONT_SPEC (font_spec);
idx = get_font_prop_index (prop);
if (idx >= 0 && idx < FONT_EXTRA_INDEX)
- ASET (font_spec, idx, font_prop_validate (idx, Qnil, val));
+ {
+ CHECK_FONT_SPEC (font);
+ ASET (font, idx, font_prop_validate (idx, Qnil, val));
+ }
else
- font_put_extra (font_spec, prop, font_prop_validate (0, prop, val));
+ {
+ if (EQ (prop, QCname)
+ || EQ (prop, QCscript)
+ || EQ (prop, QClang)
+ || EQ (prop, QCotf))
+ CHECK_FONT_SPEC (font);
+ else
+ CHECK_FONT (font);
+ font_put_extra (font, prop, font_prop_validate (0, prop, val));
+ }
return val;
}
}
if (i == 3 || XINT (n) == 0)
return Qnil;
+ if (XINT (n) < LGSTRING_GLYPH_LEN (gstring))
+ LGSTRING_SET_GLYPH (gstring, XINT (n), Qnil);
glyph = LGSTRING_GLYPH (gstring, 0);
from = LGLYPH_FROM (glyph);
doc: /* Return a list of variation glyphs for CHAR in FONT-OBJECT.
Each element of the value is a cons (VARIATION-SELECTOR . GLYPH-ID),
where
- VARIATION-SELECTOR is a chracter code of variation selection
+ VARIATION-SELECTOR is a character code of variation selection
(#xFE00..#xFE0F or #xE0100..#xE01EF)
GLYPH-ID is a glyph code of the corresponding variation glyph. */)
(Lisp_Object font_object, Lisp_Object character)
return val;
}
-DEFUN ("get-font-glyphs", Fget_font_glyphs, Sget_font_glyphs, 2, 2, 0,
- doc: /* Return a vector of glyphs of FONT-OBJECT for drawing STRING.
-Each element is a vector [GLYPH-CODE LBEARING RBEARING WIDTH ASCENT DESCENT]. */)
- (Lisp_Object font_object, Lisp_Object string)
+DEFUN ("font-get-glyphs", Ffont_get_glyphs, Sfont_get_glyphs, 3, 4, 0,
+ doc:
+ /* Return a vector of FONT-OBJECT's glyphs for the specified characters.
+FROM and TO are positions (integers or markers) specifying a region
+of the current buffer.
+If the optional fourth arg OBJECT is not nil, it is a string or a
+vector containing the target characters.
+
+Each element is a vector containing information of a glyph in this format:
+ [FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT ADJUSTMENT]
+where
+ FROM is an index numbers of a character the glyph corresponds to.
+ TO is the same as FROM.
+ C is the character of the glyph.
+ CODE is the glyph-code of C in FONT-OBJECT.
+ WIDTH thru DESCENT are the metrics (in pixels) of the glyph.
+ ADJUSTMENT is always nil.
+If FONT-OBJECT doesn't have a glyph for a character,
+the corresponding element is nil. */)
+ (Lisp_Object font_object, Lisp_Object from, Lisp_Object to,
+ Lisp_Object object)
{
struct font *font;
- int i, len;
- Lisp_Object vec;
+ int i, len, c;
+ Lisp_Object *chars, vec;
+ USE_SAFE_ALLOCA;
CHECK_FONT_GET_OBJECT (font_object, font);
- CHECK_STRING (string);
- len = SCHARS (string);
+ if (NILP (object))
+ {
+ EMACS_INT charpos, bytepos;
+
+ validate_region (&from, &to);
+ if (EQ (from, to))
+ return Qnil;
+ len = XFASTINT (to) - XFASTINT (from);
+ SAFE_ALLOCA_LISP (chars, len);
+ charpos = XFASTINT (from);
+ bytepos = CHAR_TO_BYTE (charpos);
+ for (i = 0; charpos < XFASTINT (to); i++)
+ {
+ FETCH_CHAR_ADVANCE (c, charpos, bytepos);
+ chars[i] = make_number (c);
+ }
+ }
+ else if (STRINGP (object))
+ {
+ const unsigned char *p;
+
+ CHECK_NUMBER (from);
+ CHECK_NUMBER (to);
+ if (XINT (from) < 0 || XINT (from) > XINT (to)
+ || XINT (to) > SCHARS (object))
+ args_out_of_range_3 (object, from, to);
+ if (EQ (from, to))
+ return Qnil;
+ len = XFASTINT (to) - XFASTINT (from);
+ SAFE_ALLOCA_LISP (chars, len);
+ p = SDATA (object);
+ if (STRING_MULTIBYTE (object))
+ for (i = 0; i < len; i++)
+ {
+ c = STRING_CHAR_ADVANCE (p);
+ chars[i] = make_number (c);
+ }
+ else
+ for (i = 0; i < len; i++)
+ chars[i] = make_number (p[i]);
+ }
+ else
+ {
+ CHECK_VECTOR (object);
+ CHECK_NUMBER (from);
+ CHECK_NUMBER (to);
+ if (XINT (from) < 0 || XINT (from) > XINT (to)
+ || XINT (to) > ASIZE (object))
+ args_out_of_range_3 (object, from, to);
+ if (EQ (from, to))
+ return Qnil;
+ len = XFASTINT (to) - XFASTINT (from);
+ for (i = 0; i < len; i++)
+ {
+ Lisp_Object elt = AREF (object, XFASTINT (from) + i);
+ CHECK_CHARACTER (elt);
+ }
+ chars = &(AREF (object, XFASTINT (from)));
+ }
+
vec = Fmake_vector (make_number (len), Qnil);
for (i = 0; i < len; i++)
{
- Lisp_Object ch = Faref (string, make_number (i));
- Lisp_Object val;
- int c = XINT (ch);
+ Lisp_Object g;
+ int c = XFASTINT (chars[i]);
unsigned code;
EMACS_INT cod;
struct font_metrics metrics;
cod = code = font->driver->encode_char (font, c);
if (code == FONT_INVALID_CODE)
continue;
- val = Fmake_vector (make_number (6), Qnil);
- if (cod <= MOST_POSITIVE_FIXNUM)
- ASET (val, 0, make_number (code));
- else
- ASET (val, 0, Fcons (make_number (code >> 16),
- make_number (code & 0xFFFF)));
+ g = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
+ LGLYPH_SET_FROM (g, i);
+ LGLYPH_SET_TO (g, i);
+ LGLYPH_SET_CHAR (g, c);
+ LGLYPH_SET_CODE (g, code);
font->driver->text_extents (font, &code, 1, &metrics);
- ASET (val, 1, make_number (metrics.lbearing));
- ASET (val, 2, make_number (metrics.rbearing));
- ASET (val, 3, make_number (metrics.width));
- ASET (val, 4, make_number (metrics.ascent));
- ASET (val, 5, make_number (metrics.descent));
- ASET (vec, i, val);
- }
+ LGLYPH_SET_WIDTH (g, metrics.width);
+ LGLYPH_SET_LBEARING (g, metrics.lbearing);
+ LGLYPH_SET_RBEARING (g, metrics.rbearing);
+ LGLYPH_SET_ASCENT (g, metrics.ascent);
+ LGLYPH_SET_DESCENT (g, metrics.descent);
+ ASET (vec, i, g);
+ }
+ if (! VECTORP (object))
+ SAFE_FREE ();
return vec;
}
opening), ARG is the argument for the action, and RESULT is the
result of the action. */
void
-font_add_log (char *action, Lisp_Object arg, Lisp_Object result)
+font_add_log (const char *action, Lisp_Object arg, Lisp_Object result)
{
Lisp_Object tail, val;
int i;
as font_add_log. */
void
-font_deferred_log (char *action, Lisp_Object arg, Lisp_Object result)
+font_deferred_log (const char *action, Lisp_Object arg, Lisp_Object result)
{
if (EQ (Vfont_log, Qt))
return;
ASET (Vfont_log_deferred, 2, result);
}
-extern void syms_of_ftfont (void);
-extern void syms_of_xfont (void);
-extern void syms_of_xftfont (void);
-extern void syms_of_ftxfont (void);
-extern void syms_of_bdffont (void);
-extern void syms_of_w32font (void);
-extern void syms_of_atmfont (void);
-extern void syms_of_nsfont (void);
-
void
syms_of_font (void)
{
defsubr (&Sopen_font);
defsubr (&Sclose_font);
defsubr (&Squery_font);
- defsubr (&Sget_font_glyphs);
+ defsubr (&Sfont_get_glyphs);
defsubr (&Sfont_match_p);
defsubr (&Sfont_at);
#if 0
Vfont_log = egetenv ("EMACS_FONT_LOG") ? Qnil : Qt;
}
-/* arch-tag: 74c9475d-5976-4c93-a327-942ae3072846
- (do not change this comment) */