/* font.c -- "Font" primitives.
-Copyright (C) 2006-2015 Free Software Foundation, Inc.
+Copyright (C) 2006-2016 Free Software Foundation, Inc.
Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H13PRO009
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 3 of the License, or
-(at your option) any later version.
+the Free Software Foundation, either version 3 of the License, 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
#include "composite.h"
#include "fontset.h"
#include "font.h"
+#include "termhooks.h"
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
-Lisp_Object Qopentype;
-
-/* Important character set strings. */
-Lisp_Object Qascii_0, Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;
-
#define DEFAULT_ENCODING Qiso8859_1
-/* Unicode category `Cf'. */
-static Lisp_Object QCf;
-
/* Vector of Vfont_weight_table, Vfont_slant_table, and Vfont_width_table. */
static Lisp_Object font_style_table;
{ 200, { "ultra-expanded", "ultraexpanded", "wide" }}
};
-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;
-static Lisp_Object QCfc_unknown_spec;
-/* Symbols representing values of font spacing property. */
-static Lisp_Object Qc, Qm, Qd;
-Lisp_Object Qp;
-/* Special ADSTYLE properties to avoid fonts used for Latin
- characters; used in xfont.c and ftfont.c. */
-Lisp_Object Qja, Qko;
-
-static Lisp_Object QCuser_spec;
-
/* Alist of font registry symbols and the corresponding charset
information. The information is retrieved from
Vfont_encoding_alist on demand.
struct font_spec *spec
= ((struct font_spec *)
allocate_pseudovector (VECSIZE (struct font_spec),
- FONT_SPEC_MAX, PVEC_FONT));
+ FONT_SPEC_MAX, FONT_SPEC_MAX, PVEC_FONT));
XSETFONT (font_spec, spec);
return font_spec;
}
struct font_entity *entity
= ((struct font_entity *)
allocate_pseudovector (VECSIZE (struct font_entity),
- FONT_ENTITY_MAX, PVEC_FONT));
+ FONT_ENTITY_MAX, FONT_ENTITY_MAX, PVEC_FONT));
XSETFONT (font_entity, entity);
return font_entity;
}
{
Lisp_Object font_object;
struct font *font
- = (struct font *) allocate_pseudovector (size, FONT_OBJECT_MAX, PVEC_FONT);
+ = (struct font *) allocate_pseudovector (size, FONT_OBJECT_MAX,
+ FONT_OBJECT_MAX, PVEC_FONT);
int i;
/* GC can happen before the driver is set up,
return tem;
name = make_specified_string (str, nchars, len,
len != nchars && len == nbytes);
- return intern_driver (name, obarray, XINT (tem));
+ return intern_driver (name, obarray, tem);
}
/* Return a pixel size of font-spec SPEC on frame F. */
elt = Fmake_vector (make_number (2), make_number (100));
ASET (elt, 1, val);
ASET (font_style_table, prop - FONT_WEIGHT_INDEX,
- Fvconcat (2, ((Lisp_Object [])
- { table, Fmake_vector (make_number (1), elt) })));
+ CALLN (Fvconcat, table, Fmake_vector (make_number (1), elt)));
return (100 << 8) | (i << 4);
}
else
values. */
static const struct
{
- /* Pointer to the key symbol. */
- Lisp_Object *key;
+ /* Index of the key symbol. */
+ int key;
/* Function to validate PROP's value VAL, or NULL if any value is
ok. The value is VAL or its regularized value if VAL is valid,
and Qerror if not. */
Lisp_Object (*validator) (Lisp_Object prop, Lisp_Object val);
} font_property_table[] =
- { { &QCtype, font_prop_validate_symbol },
- { &QCfoundry, font_prop_validate_symbol },
- { &QCfamily, font_prop_validate_symbol },
- { &QCadstyle, font_prop_validate_symbol },
- { &QCregistry, font_prop_validate_symbol },
- { &QCweight, font_prop_validate_style },
- { &QCslant, font_prop_validate_style },
- { &QCwidth, font_prop_validate_style },
- { &QCsize, font_prop_validate_non_neg },
- { &QCdpi, font_prop_validate_non_neg },
- { &QCspacing, font_prop_validate_spacing },
- { &QCavgwidth, font_prop_validate_non_neg },
+ { { SYMBOL_INDEX (QCtype), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCfoundry), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCfamily), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCadstyle), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCregistry), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCweight), font_prop_validate_style },
+ { SYMBOL_INDEX (QCslant), font_prop_validate_style },
+ { SYMBOL_INDEX (QCwidth), font_prop_validate_style },
+ { SYMBOL_INDEX (QCsize), font_prop_validate_non_neg },
+ { SYMBOL_INDEX (QCdpi), font_prop_validate_non_neg },
+ { SYMBOL_INDEX (QCspacing), font_prop_validate_spacing },
+ { SYMBOL_INDEX (QCavgwidth), font_prop_validate_non_neg },
/* The order of the above entries must match with enum
font_property_index. */
- { &QClang, font_prop_validate_symbol },
- { &QCscript, font_prop_validate_symbol },
- { &QCotf, font_prop_validate_otf }
+ { SYMBOL_INDEX (QClang), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCscript), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCotf), font_prop_validate_otf }
};
/* Return an index number of font property KEY or -1 if KEY is not an
int i;
for (i = 0; i < ARRAYELTS (font_property_table); i++)
- if (EQ (key, *font_property_table[i].key))
+ if (EQ (key, builtin_lisp_symbol (font_property_table[i].key)))
return i;
return -1;
}
if (NILP (val))
return val;
if (NILP (prop))
- prop = *font_property_table[idx].key;
+ prop = builtin_lisp_symbol (font_property_table[idx].key);
else
{
idx = get_font_prop_index (prop);
if (i == 0 || ! NILP (tmp[i - 1]))
/* None of TMP[X] corresponds to Jth field. */
return -1;
- for (; j < range[i].from; j++)
- field[j] = Qnil;
+ memclear (field + j, (range[i].from - j) * word_size);
+ j = range[i].from;
}
field[j++] = tmp[i];
}
if (! NILP (tmp[n - 1]) && j < XLFD_REGISTRY_INDEX)
return -1;
- for (; j < XLFD_LAST_INDEX; j++)
- field[j] = Qnil;
+ memclear (field + j, (XLFD_LAST_INDEX - j) * word_size);
if (INTEGERP (field[XLFD_ENCODING_INDEX]))
field[XLFD_ENCODING_INDEX]
= Fintern (Fnumber_to_string (field[XLFD_ENCODING_INDEX]), Qnil);
p1 = strchr (p0, '-');
if (! p1)
{
- AUTO_STRING (extra, ("*-*" + (len && p0[len - 1] == '*')));
+ bool asterisk = len && p0[len - 1] == '*';
+ AUTO_STRING_WITH_LEN (extra, &"*-*"[asterisk], 3 - asterisk);
registry = concat2 (registry, extra);
}
registry = Fdowncase (registry);
}
/* Score the size. Maximum difference is 127. */
- i = FONT_SIZE_INDEX;
if (! NILP (spec_prop[FONT_SIZE_INDEX])
&& XINT (AREF (entity, FONT_SIZE_INDEX)) > 0)
{
struct font_sort_data *data;
unsigned best_score;
Lisp_Object best_entity;
- Lisp_Object tail, vec IF_LINT (= Qnil);
+ Lisp_Object tail;
+ Lisp_Object vec UNINIT;
USE_SAFE_ALLOCA;
for (i = FONT_WEIGHT_INDEX; i <= FONT_AVGWIDTH_INDEX; i++)
struct font_driver_list *driver_list;
Lisp_Object objlist, size, val, font_object;
struct font *font;
- int min_width, height, psize;
+ int height, psize;
eassert (FONT_ENTITY_P (entity));
size = AREF (entity, FONT_SIZE_INDEX);
Fcons (font_object, AREF (entity, FONT_OBJLIST_INDEX)));
font = XFONT_OBJECT (font_object);
- min_width = (font->min_width ? font->min_width
- : font->average_width ? font->average_width
- : font->space_width ? font->space_width
- : 1);
- height = (font->height ? font->height : 1);
+#ifdef HAVE_WINDOW_SYSTEM
+ int min_width = (font->min_width ? font->min_width
+ : font->average_width ? font->average_width
+ : font->space_width ? font->space_width
+ : 1);
+#endif
+
+ int font_ascent, font_descent;
+ get_font_ascent_descent (font, &font_ascent, &font_descent);
+ height = font_ascent + font_descent;
+ if (height <= 0)
+ height = 1;
#ifdef HAVE_WINDOW_SYSTEM
FRAME_DISPLAY_INFO (f)->n_fonts++;
if (FRAME_DISPLAY_INFO (f)->n_fonts == 1)
/* No font is listed for SPEC, but each font-backend may have
different criteria about "font matching". So, try it. */
entity = font_matching_entity (f, attrs, spec);
+ /* Perhaps the user asked for a font "Foobar-123", and we
+ interpreted "-123" as the size, whereas it really is part of
+ the name. So we reset the size to nil and the family name to
+ the entire "Foobar-123" thing, and try again with that. */
+ if (NILP (entity))
+ {
+ name = Ffont_get (spec, QCuser_spec);
+ if (STRINGP (name))
+ {
+ char *p = SSDATA (name), *q = strrchr (p, '-');
+
+ if (q != NULL && c_isdigit (q[1]))
+ {
+ char *tail;
+ double font_size = strtod (q + 1, &tail);
+
+ if (font_size > 0 && tail != q + 1)
+ {
+ Lisp_Object lsize = Ffont_get (spec, QCsize);
+
+ if ((FLOATP (lsize) && XFLOAT_DATA (lsize) == font_size)
+ || (INTEGERP (lsize) && XINT (lsize) == font_size))
+ {
+ ASET (spec, FONT_FAMILY_INDEX,
+ font_intern_prop (p, tail - p, 1));
+ ASET (spec, FONT_SIZE_INDEX, Qnil);
+ entity = font_matching_entity (f, attrs, spec);
+ }
+ }
+ }
+ }
+ }
if (NILP (entity))
return Qnil;
}
Lisp_Object
font_open_by_name (struct frame *f, Lisp_Object name)
{
- Lisp_Object args[2];
- Lisp_Object spec, ret;
-
- args[0] = QCname;
- args[1] = name;
- spec = Ffont_spec (2, args);
- ret = font_open_by_spec (f, spec);
+ Lisp_Object spec = CALLN (Ffont_spec, QCname, name);
+ Lisp_Object ret = font_open_by_spec (f, spec);
/* Do not lose name originally put in. */
if (!NILP (ret))
- font_put_extra (ret, QCuser_spec, args[1]);
+ font_put_extra (ret, QCuser_spec, name);
return ret;
}
if (STRINGP (string))
face_id = face_at_string_position (w, string, pos, 0, &endptr,
- DEFAULT_FACE_ID, 0);
+ DEFAULT_FACE_ID, false);
else
face_id = face_at_buffer_position (w, pos, &endptr,
- pos + 100, 0, -1);
+ pos + 100, false, -1);
face = FACE_FROM_ID (f, face_id);
}
if (multibyte)
int face_id;
face_id = face_at_buffer_position (w, pos, &ignore,
- *limit, 0, -1);
+ *limit, false, -1);
face = FACE_FROM_ID (XFRAME (w->frame), face_id);
}
}
`:foundry'
-VALUE must be a string or a symbol specifying the font foundry, e.g. ``misc''.
+VALUE must be a string or a symbol specifying the font foundry, e.g. `misc'.
`:adstyle'
VALUE must be a string or a symbol specifying the additional
-typographic style information of a font, e.g. ``sans''.
+typographic style information of a font, e.g. `sans'.
`:registry'
VALUE must be a string or a symbol specifying the charset registry and
-encoding of a font, e.g. ``iso8859-1''.
+encoding of a font, e.g. `iso8859-1'.
`:size'
`:lang'
-VALUE must be a symbol of two-letter ISO-639 language names,
-e.g. `ja'.
+VALUE must be a symbol whose name is a two-letter ISO-639 language
+name, e.g. `ja'. The value is matched against the "Additional Style"
+field of the XLFD spec of a font, if it's non-empty, on X, and
+against the codepages supported by the font on w32.
`:otf'
GSUB: List of OpenType GSUB feature tag symbols, or nil if none required.
GPOS: List of OpenType GPOS feature tag symbols, or nil if none required.
-GSUB and GPOS may contain `nil' element. In such a case, the font
+GSUB and GPOS may contain nil elements. In such a case, the font
must not have any of the remaining elements.
For instance, if the VALUE is `(thai nil nil (mark))', the font must
pcdr = spec->props + FONT_EXTRA_INDEX;
for (tail = AREF (font, FONT_EXTRA_INDEX); CONSP (tail); tail = XCDR (tail))
if (!EQ (XCAR (XCAR (tail)), QCfont_entity))
- *pcdr = Fcons (XCAR (tail), Qnil), pcdr = xcdr_addr (*pcdr);
+ {
+ *pcdr = Fcons (Fcons (XCAR (XCAR (tail)), CDR (XCAR (tail))), Qnil);
+ pcdr = xcdr_addr (*pcdr);
+ }
XSETFONT (new_spec, spec);
return new_spec;
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. */)
+Layout tags.
+
+In addition to the keys listed abobe, the following keys are reserved
+for the specific meanings as below:
+
+The value of :combining-capability is non-nil if the font-backend of
+FONT supports rendering of combining characters for non-OTF fonts. */)
(Lisp_Object font, Lisp_Object key)
{
int idx;
if (idx >= 0 && idx < FONT_EXTRA_INDEX)
return AREF (font, idx);
val = Fassq (key, AREF (font, FONT_EXTRA_INDEX));
- if (NILP (val) && EQ (key, QCotf) && FONT_OBJECT_P (font))
+ if (NILP (val) && 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);
+ if (EQ (key, QCotf))
+ {
+ if (fontp->driver->otf_capability)
+ val = fontp->driver->otf_capability (fontp);
+ else
+ val = Fcons (Qnil, Qnil);
+ }
+ else if (EQ (key, QCcombining_capability))
+ {
+ if (fontp->driver->combining_capability)
+ val = fontp->driver->combining_capability (fontp);
+ }
}
else
val = Fcdr (val);
else
vec = font_vconcat_entity_vectors (list);
if (n == 0 || n >= ASIZE (vec))
- {
- Lisp_Object args[2];
-
- args[0] = vec;
- args[1] = Qnil;
- list = Fappend (2, args);
- }
+ list = CALLN (Fappend, vec, Qnil);
else
{
for (list = Qnil, n--; n >= 0; n--)
return val;
}
+/* Return a description of the font at POSITION in the current buffer.
+ If the 2nd optional arg CH is non-nil, it is a character to check
+ the font instead of the character at POSITION.
+
+ For a graphical display, return a cons (FONT-OBJECT . GLYPH-CODE).
+ FONT-OBJECT is the font for the character at POSITION in the current
+ buffer. This is computed from all the text properties and overlays
+ that apply to POSITION. POSITION may be nil, in which case,
+ FONT-SPEC is the font for displaying the character CH with the
+ default face. GLYPH-CODE is the glyph code in the font to use for
+ the character.
+
+ For a text terminal, return a nonnegative integer glyph code for
+ the character, or a negative integer if the character is not
+ displayable. Terminal glyph codes are system-dependent integers
+ that represent displayable characters: for example, on a Linux x86
+ console they represent VGA code points.
+
+ It returns nil in the following cases:
+
+ (1) The window system doesn't have a font for the character (thus
+ it is displayed by an empty box).
+
+ (2) The character code is invalid.
+
+ (3) If POSITION is not nil, and the current buffer is not displayed
+ in any window.
+
+ (4) For a text terminal, the terminal does not report glyph codes.
+
+ In addition, the returned font name may not take into account of
+ such redisplay engine hooks as what used in jit-lock-mode if
+ POSITION is currently not visible. */
+
+
+DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
+ doc: /* For internal use only. */)
+ (Lisp_Object position, Lisp_Object ch)
+{
+ ptrdiff_t pos, pos_byte, dummy;
+ int face_id;
+ int c;
+ struct frame *f;
+
+ if (NILP (position))
+ {
+ CHECK_CHARACTER (ch);
+ c = XINT (ch);
+ f = XFRAME (selected_frame);
+ face_id = lookup_basic_face (f, DEFAULT_FACE_ID);
+ pos = -1;
+ }
+ else
+ {
+ Lisp_Object window;
+ struct window *w;
+
+ CHECK_NUMBER_COERCE_MARKER (position);
+ if (! (BEGV <= XINT (position) && XINT (position) < ZV))
+ args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
+ pos = XINT (position);
+ pos_byte = CHAR_TO_BYTE (pos);
+ if (NILP (ch))
+ c = FETCH_CHAR (pos_byte);
+ else
+ {
+ CHECK_NATNUM (ch);
+ c = XINT (ch);
+ }
+ window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
+ if (NILP (window))
+ return Qnil;
+ w = XWINDOW (window);
+ f = XFRAME (w->frame);
+ face_id = face_at_buffer_position (w, pos, &dummy,
+ pos + 100, false, -1);
+ }
+ if (! CHAR_VALID_P (c))
+ return Qnil;
+
+ if (! FRAME_WINDOW_P (f))
+ return terminal_glyph_code (FRAME_TERMINAL (f), c);
+
+ /* We need the basic faces to be valid below, so recompute them if
+ some code just happened to clear the face cache. */
+ if (FRAME_FACE_CACHE (f)->used == 0)
+ recompute_basic_faces (f);
+
+ face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
+ struct face *face = FACE_FROM_ID (f, face_id);
+ if (! face->font)
+ return Qnil;
+ unsigned code = face->font->driver->encode_char (face->font, c);
+ if (code == FONT_INVALID_CODE)
+ return Qnil;
+ Lisp_Object font_object;
+ XSETFONT (font_object, face->font);
+ return Fcons (font_object, INTEGER_TO_CONS (code));
+}
+
#if 0
DEFUN ("font-drive-otf", Ffont_drive_otf, Sfont_drive_otf, 6, 6, 0,
corresponding character. */)
(Lisp_Object font_object, Lisp_Object character, Lisp_Object otf_features)
{
- struct font *font;
+ struct font *font = CHECK_FONT_GET_OBJECT (font_object);
Lisp_Object gstring_in, gstring_out, g;
Lisp_Object alternates;
int i, num;
- CHECK_FONT_GET_OBJECT (font_object, font);
if (! font->driver->otf_drive)
error ("Font backend %s can't drive OpenType GSUB table",
SDATA (SYMBOL_NAME (font->driver->type)));
pixels.
CAPABILITY is a list whose first element is a symbol representing the
-font format \(x, opentype, truetype, type1, pcf, or bdf) and the
+font format (x, opentype, truetype, type1, pcf, or bdf) and the
remaining elements describe the details of the font capability.
If the font is OpenType font, the form of the list is
- \(opentype GSUB GPOS)
+ (opentype GSUB GPOS)
where GSUB shows which "GSUB" features the font supports, and GPOS
shows which "GPOS" features the font supports. Both GSUB and GPOS are
lists of the format:
- \((SCRIPT (LANGSYS FEATURE ...) ...) ...)
+ ((SCRIPT (LANGSYS FEATURE ...) ...) ...)
If the font is not OpenType font, currently the length of the form is
one.
If the font is not OpenType font, CAPABILITY is nil. */)
(Lisp_Object font_object)
{
- struct font *font;
- Lisp_Object val;
-
- CHECK_FONT_GET_OBJECT (font_object, font);
+ struct font *font = CHECK_FONT_GET_OBJECT (font_object);
+ Lisp_Object val = make_uninit_vector (9);
- val = make_uninit_vector (9);
ASET (val, 0, AREF (font_object, FONT_NAME_INDEX));
ASET (val, 1, AREF (font_object, FONT_FILE_INDEX));
ASET (val, 2, make_number (font->pixel_size));
(Lisp_Object font_object, Lisp_Object from, Lisp_Object to,
Lisp_Object object)
{
- struct font *font;
+ struct font *font = CHECK_FONT_GET_OBJECT (font_object);
ptrdiff_t i, len;
Lisp_Object *chars, vec;
USE_SAFE_ALLOCA;
- CHECK_FONT_GET_OBJECT (font_object, font);
if (NILP (object))
{
ptrdiff_t charpos, bytepos;
as follows:
If the font is OpenType font, the form of the list is
- \(opentype GSUB GPOS)
+ (opentype GSUB GPOS)
where GSUB shows which "GSUB" features the font supports, and GPOS
shows which "GPOS" features the font supports. Both GSUB and GPOS are
lists of the form:
- \((SCRIPT (LANGSYS FEATURE ...) ...) ...)
+ ((SCRIPT (LANGSYS FEATURE ...) ...) ...)
where
SCRIPT is a symbol representing OpenType script tag.
static Lisp_Object Vfont_log_deferred;
/* Prepend the font-related logging data in Vfont_log if it is not
- `t'. ACTION describes a kind of font-related action (e.g. listing,
+ t. ACTION describes a kind of font-related action (e.g. listing,
opening), ARG is the argument for the action, and RESULT is the
result of the action. */
void
DEFSYM (Qopentype, "opentype");
+ /* Important character set symbols. */
DEFSYM (Qascii_0, "ascii-0");
DEFSYM (Qiso8859_1, "iso8859-1");
DEFSYM (Qiso10646_1, "iso10646-1");
DEFSYM (Qunicode_bmp, "unicode-bmp");
- DEFSYM (Qunicode_sip, "unicode-sip");
-
- DEFSYM (QCf, "Cf");
+ /* Symbols representing keys of font extra info. */
DEFSYM (QCotf, ":otf");
DEFSYM (QClang, ":lang");
DEFSYM (QCscript, ":script");
DEFSYM (QCantialias, ":antialias");
-
DEFSYM (QCfoundry, ":foundry");
DEFSYM (QCadstyle, ":adstyle");
DEFSYM (QCregistry, ":registry");
DEFSYM (QCscalable, ":scalable");
DEFSYM (QCavgwidth, ":avgwidth");
DEFSYM (QCfont_entity, ":font-entity");
- DEFSYM (QCfc_unknown_spec, ":fc-unknown-spec");
+ DEFSYM (QCcombining_capability, ":combining-capability");
+ /* Symbols representing values of font spacing property. */
DEFSYM (Qc, "c");
DEFSYM (Qm, "m");
DEFSYM (Qp, "p");
DEFSYM (Qd, "d");
+ /* Special ADSTYLE properties to avoid fonts used for Latin
+ characters; used in xfont.c and ftfont.c. */
DEFSYM (Qja, "ja");
DEFSYM (Qko, "ko");
- DEFSYM (QCuser_spec, "user-spec");
+ DEFSYM (QCuser_spec, ":user-spec");
staticpro (&scratch_font_spec);
scratch_font_spec = Ffont_spec (0, NULL);
defsubr (&Sclear_font_cache);
defsubr (&Sfont_shape_gstring);
defsubr (&Sfont_variation_glyphs);
+ defsubr (&Sinternal_char_font);
#if 0
defsubr (&Sfont_drive_otf);
defsubr (&Sfont_otf_alternates);
ASET (font_style_table, 2, Vfont_width_table);
DEFVAR_LISP ("font-log", Vfont_log, doc: /*
-*Logging list of font related actions and results.
-The value t means to suppress the logging.
-The initial value is set to nil if the environment variable
-EMACS_FONT_LOG is set. Otherwise, it is set to t. */);
+A list that logs font-related actions and results, for debugging.
+The default value is t, which means to suppress logging.
+Set it to nil to enable logging. If the environment variable
+EMACS_FONT_LOG is set at startup, it defaults to nil. */);
Vfont_log = Qnil;
#ifdef HAVE_WINDOW_SYSTEM
#ifdef HAVE_FREETYPE
syms_of_ftfont ();
#ifdef HAVE_X_WINDOWS
+#ifdef USE_CAIRO
+ syms_of_ftcrfont ();
+#else
syms_of_xfont ();
syms_of_ftxfont ();
#ifdef HAVE_XFT
syms_of_xftfont ();
#endif /* HAVE_XFT */
+#endif /* not USE_CAIRO */
#endif /* HAVE_X_WINDOWS */
#else /* not HAVE_FREETYPE */
#ifdef HAVE_X_WINDOWS