3 Copyright (C) 2001-2015 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5 2005, 2006, 2007, 2008, 2009, 2010, 2011
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H14PRO021
8 Copyright (C) 2003, 2006
9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
12 This file is part of GNU Emacs.
14 GNU Emacs is free software: you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation, either version 3 of the License, or
17 (at your option) any later version.
19 GNU Emacs is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
31 #include "blockinput.h"
32 #include "character.h"
38 #include "dispextern.h"
39 #include "intervals.h"
42 #ifdef HAVE_WINDOW_SYSTEM
44 #endif /* HAVE_WINDOW_SYSTEM */
45 #include "termhooks.h"
50 A fontset is a collection of font related information to give
51 similar appearance (style, etc) of characters. A fontset has two
52 roles. One is to use for the frame parameter `font' as if it is an
53 ASCII font. In that case, Emacs uses the font specified for
54 `ascii' script for the frame's default font.
56 Another role, the more important one, is to provide information
57 about which font to use for each non-ASCII character.
59 There are two kinds of fontsets; base and realized. A base fontset
60 is created by `new-fontset' from Emacs Lisp explicitly. A realized
61 fontset is created implicitly when a face is realized for ASCII
62 characters. A face is also realized for non-ASCII characters based
63 on an ASCII face. All of non-ASCII faces based on the same ASCII
64 face share the same realized fontset.
66 A fontset object is implemented by a char-table whose default value
67 and parent are always nil.
69 An element of a base fontset is a vector of FONT-DEFs which itself
70 is a vector [ FONT-SPEC ENCODING REPERTORY ].
72 An element of a realized fontset is nil, t, 0, or a vector of this
75 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
76 RFONT-DEF0 RFONT-DEF1 ... ]
78 RFONT-DEFn (i.e. Realized FONT-DEF) has this form:
80 [ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]
82 RFONT-DEFn are automatically reordered by the current charset
85 The value nil means that we have not yet generated the above vector
86 from the base of the fontset.
88 The value t means that no font is available for the corresponding
91 The value 0 means that no font is available for the corresponding
92 range of characters in this fontset, but may be available in the
95 A fontset has 8 extra slots.
98 base: the ID number of the fontset
102 base: the name of the fontset
106 base: the font name for ASCII characters
111 realized: the base fontset
115 realized: the frame that the fontset belongs to
119 realized: the ID number of a face to use for characters that
120 has no font in a realized fontset.
124 realized: If the base is not the default fontset, a fontset
125 realized from the default fontset, else nil.
128 base: Same as element value (but for fallback fonts).
131 All fontsets are recorded in the vector Vfontset_table.
136 There's a special base fontset named `default fontset' which
137 defines the default font specifications. When a base fontset
138 doesn't specify a font for a specific character, the corresponding
139 value in the default fontset is used.
141 The parent of a realized fontset created for such a face that has
142 no fontset is the default fontset.
145 These structures are hidden from the other codes than this file.
146 The other codes handle fontsets only by their ID numbers. They
147 usually use the variable name `fontset' for IDs. But, in this
148 file, we always use variable name `id' for IDs, and name `fontset'
149 for an actual fontset object, i.e., char-table.
153 /********** VARIABLES and FUNCTION PROTOTYPES **********/
155 /* Vector containing all fontsets. */
156 static Lisp_Object Vfontset_table
;
158 /* Next possibly free fontset ID. Usually this keeps the minimum
159 fontset ID not yet used. */
160 static int next_fontset_id
;
162 /* The default fontset. This gives default FAMILY and REGISTRY of
163 font for each character. */
164 static Lisp_Object Vdefault_fontset
;
166 /* Prototype declarations for static functions. */
167 static Lisp_Object
make_fontset (Lisp_Object
, Lisp_Object
, Lisp_Object
);
169 /* Return true if ID is a valid fontset id.
170 Optimized away if ENABLE_CHECKING is not defined. */
173 fontset_id_valid_p (int id
)
175 return (id
>= 0 && id
< ASIZE (Vfontset_table
) - 1);
180 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
182 /* Return the fontset with ID. No check of ID's validness. */
183 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
185 /* Access special values of FONTSET. */
187 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
189 set_fontset_id (Lisp_Object fontset
, Lisp_Object id
)
191 set_char_table_extras (fontset
, 0, id
);
194 /* Access special values of (base) FONTSET. */
196 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
198 set_fontset_name (Lisp_Object fontset
, Lisp_Object name
)
200 set_char_table_extras (fontset
, 1, name
);
203 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->extras[2]
205 set_fontset_ascii (Lisp_Object fontset
, Lisp_Object ascii
)
207 set_char_table_extras (fontset
, 2, ascii
);
210 /* Access special values of (realized) FONTSET. */
212 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->extras[3]
214 set_fontset_base (Lisp_Object fontset
, Lisp_Object base
)
216 set_char_table_extras (fontset
, 3, base
);
219 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[4]
221 set_fontset_frame (Lisp_Object fontset
, Lisp_Object frame
)
223 set_char_table_extras (fontset
, 4, frame
);
226 #define FONTSET_NOFONT_FACE(fontset) XCHAR_TABLE (fontset)->extras[5]
228 set_fontset_nofont_face (Lisp_Object fontset
, Lisp_Object face
)
230 set_char_table_extras (fontset
, 5, face
);
233 #define FONTSET_DEFAULT(fontset) XCHAR_TABLE (fontset)->extras[6]
235 set_fontset_default (Lisp_Object fontset
, Lisp_Object def
)
237 set_char_table_extras (fontset
, 6, def
);
240 /* For both base and realized fontset. */
242 #define FONTSET_FALLBACK(fontset) XCHAR_TABLE (fontset)->extras[7]
244 set_fontset_fallback (Lisp_Object fontset
, Lisp_Object fallback
)
246 set_char_table_extras (fontset
, 7, fallback
);
249 #define BASE_FONTSET_P(fontset) (NILP (FONTSET_BASE (fontset)))
251 /* Macros for FONT-DEF and RFONT-DEF of fontset. */
252 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory) \
254 (font_def) = make_uninit_vector (3); \
255 ASET ((font_def), 0, font_spec); \
256 ASET ((font_def), 1, encoding); \
257 ASET ((font_def), 2, repertory); \
260 #define FONT_DEF_SPEC(font_def) AREF (font_def, 0)
261 #define FONT_DEF_ENCODING(font_def) AREF (font_def, 1)
262 #define FONT_DEF_REPERTORY(font_def) AREF (font_def, 2)
264 #define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
265 #define RFONT_DEF_SET_FACE(rfont_def, face_id) \
266 ASET ((rfont_def), 0, make_number (face_id))
267 #define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
268 #define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
269 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
270 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
271 ASET ((rfont_def), 2, (object))
272 /* Score of RFONT_DEF is an integer value; the lowest 8 bits represent
273 the order of listing by font backends, the higher bits represents
274 the order given by charset priority list. The smaller value is
276 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
277 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
278 ASET ((rfont_def), 3, make_number (score))
279 #define RFONT_DEF_NEW(rfont_def, font_def) \
281 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
282 ASET ((rfont_def), 1, (font_def)); \
283 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
287 /* Return the element of FONTSET for the character C. If FONTSET is a
288 base fontset other then the default fontset and FONTSET doesn't
289 contain information for C, return the information in the default
292 #define FONTSET_REF(fontset, c) \
293 (EQ (fontset, Vdefault_fontset) \
294 ? CHAR_TABLE_REF (fontset, c) \
295 : fontset_ref ((fontset), (c)))
298 fontset_ref (Lisp_Object fontset
, int c
)
302 elt
= CHAR_TABLE_REF (fontset
, c
);
303 if (NILP (elt
) && ! EQ (fontset
, Vdefault_fontset
)
304 /* Don't check Vdefault_fontset for a realized fontset. */
305 && NILP (FONTSET_BASE (fontset
)))
306 elt
= CHAR_TABLE_REF (Vdefault_fontset
, c
);
310 /* Set elements of FONTSET for characters in RANGE to the value ELT.
311 RANGE is a cons (FROM . TO), where FROM and TO are character codes
312 specifying a range. */
314 #define FONTSET_SET(fontset, range, elt) \
315 Fset_char_table_range ((fontset), (range), (elt))
318 /* Modify the elements of FONTSET for characters in RANGE by replacing
319 with ELT or adding ELT. RANGE is a cons (FROM . TO), where FROM
320 and TO are character codes specifying a range. If ADD is nil,
321 replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
324 #define FONTSET_ADD(fontset, range, elt, add) \
327 ? (set_fontset_fallback \
328 (fontset, Fmake_vector (make_number (1), (elt)))) \
330 Fset_char_table_range (fontset, range, \
331 Fmake_vector (make_number (1), elt)))) \
332 : fontset_add ((fontset), (range), (elt), (add)))
335 fontset_add (Lisp_Object fontset
, Lisp_Object range
, Lisp_Object elt
, Lisp_Object add
)
338 int idx
= (EQ (add
, Qappend
) ? 0 : 1);
340 args
[1 - idx
] = Fmake_vector (make_number (1), elt
);
344 int from
= XINT (XCAR (range
));
345 int to
= XINT (XCDR (range
));
349 from1
= from
, to1
= to
;
350 args
[idx
] = char_table_ref_and_range (fontset
, from
, &from1
, &to1
);
351 char_table_set_range (fontset
, from
, to1
,
352 (NILP (args
[idx
]) ? args
[1 - idx
]
353 : CALLMANY (Fvconcat
, args
)));
359 args
[idx
] = FONTSET_FALLBACK (fontset
);
360 set_fontset_fallback (fontset
,
361 (NILP (args
[idx
]) ? args
[1 - idx
]
362 : CALLMANY (Fvconcat
, args
)));
367 fontset_compare_rfontdef (const void *val1
, const void *val2
)
369 return (RFONT_DEF_SCORE (*(Lisp_Object
*) val1
)
370 - RFONT_DEF_SCORE (*(Lisp_Object
*) val2
));
373 /* Update FONT-GROUP which has this form:
374 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
375 RFONT-DEF0 RFONT-DEF1 ... ]
376 Reorder RFONT-DEFs according to the current language, and update
377 CHARSET-ORDERED-LIST-TICK.
379 If PREFERRED_FAMILY is not nil, that family has the higher priority
380 if the encoding charsets or languages in font-specs are the same. */
383 reorder_font_vector (Lisp_Object font_group
, struct font
*font
)
385 Lisp_Object vec
, font_object
;
388 bool score_changed
= false;
391 XSETFONT (font_object
, font
);
395 vec
= XCDR (font_group
);
397 /* Exclude the tailing nil element from the reordering. */
398 if (NILP (AREF (vec
, size
- 1)))
401 for (i
= 0; i
< size
; i
++)
403 Lisp_Object rfont_def
= AREF (vec
, i
);
404 Lisp_Object font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
405 Lisp_Object font_spec
= FONT_DEF_SPEC (font_def
);
406 int score
= RFONT_DEF_SCORE (rfont_def
) & 0xFF;
407 Lisp_Object otf_spec
= Ffont_get (font_spec
, QCotf
);
409 if (! NILP (otf_spec
))
410 /* A font-spec with :otf is preferable regardless of encoding
413 else if (! font_match_p (font_spec
, font_object
))
415 Lisp_Object encoding
= FONT_DEF_ENCODING (font_def
);
417 if (! NILP (encoding
))
421 for (tail
= Vcharset_ordered_list
;
422 ! EQ (tail
, Vcharset_non_preferred_head
) && CONSP (tail
);
424 if (EQ (encoding
, XCAR (tail
)))
426 else if (score
<= min (INT_MAX
, MOST_POSITIVE_FIXNUM
) - 0x100)
431 Lisp_Object lang
= Ffont_get (font_spec
, QClang
);
434 && ! EQ (lang
, Vcurrent_iso639_language
)
435 && (! CONSP (Vcurrent_iso639_language
)
436 || NILP (Fmemq (lang
, Vcurrent_iso639_language
))))
440 if (RFONT_DEF_SCORE (rfont_def
) != score
)
442 RFONT_DEF_SET_SCORE (rfont_def
, score
);
443 score_changed
= true;
448 qsort (XVECTOR (vec
)->contents
, size
, word_size
,
449 fontset_compare_rfontdef
);
450 EMACS_INT low_tick_bits
= charset_ordered_list_tick
& MOST_POSITIVE_FIXNUM
;
451 XSETCAR (font_group
, make_number (low_tick_bits
));
454 /* Return a font-group (actually a cons (-1 . FONT-GROUP-VECTOR)) for
455 character C in FONTSET. If C is -1, return a fallback font-group.
456 If C is not -1, the value may be Qt (FONTSET doesn't have a font
457 for C even in the fallback group), or 0 (a font for C may be found
458 only in the fallback group). */
461 fontset_get_font_group (Lisp_Object fontset
, int c
)
463 Lisp_Object font_group
;
464 Lisp_Object base_fontset
;
465 int from
= 0, to
= MAX_CHAR
, i
;
467 eassert (! BASE_FONTSET_P (fontset
));
469 font_group
= CHAR_TABLE_REF (fontset
, c
);
471 font_group
= FONTSET_FALLBACK (fontset
);
472 if (! NILP (font_group
))
474 base_fontset
= FONTSET_BASE (fontset
);
475 if (NILP (base_fontset
))
478 font_group
= char_table_ref_and_range (base_fontset
, c
, &from
, &to
);
480 font_group
= FONTSET_FALLBACK (base_fontset
);
481 if (NILP (font_group
))
483 font_group
= make_number (0);
485 char_table_set_range (fontset
, from
, to
, font_group
);
488 if (!VECTORP (font_group
))
490 font_group
= Fcopy_sequence (font_group
);
491 for (i
= 0; i
< ASIZE (font_group
); i
++)
492 if (! NILP (AREF (font_group
, i
)))
494 Lisp_Object rfont_def
;
496 RFONT_DEF_NEW (rfont_def
, AREF (font_group
, i
));
497 /* Remember the original order. */
498 RFONT_DEF_SET_SCORE (rfont_def
, i
);
499 ASET (font_group
, i
, rfont_def
);
501 font_group
= Fcons (make_number (-1), font_group
);
503 char_table_set_range (fontset
, from
, to
, font_group
);
505 set_fontset_fallback (fontset
, font_group
);
509 /* Return RFONT-DEF (vector) in the realized fontset FONTSET for the
510 character C. If no font is found, return Qnil if there's a
511 possibility that the default fontset or the fallback font groups
512 have a proper font, and return Qt if not.
514 If a font is found but is not yet opened, open it (if FACE is not
515 NULL) or return Qnil (if FACE is NULL).
517 ID is a charset-id that must be preferred, or -1 meaning no
520 If FALLBACK, search only fallback fonts. */
523 fontset_find_font (Lisp_Object fontset
, int c
, struct face
*face
, int id
,
526 Lisp_Object vec
, font_group
;
527 int i
, charset_matched
= 0, found_index
;
528 struct frame
*f
= (FRAMEP (FONTSET_FRAME (fontset
))
529 ? XFRAME (FONTSET_FRAME (fontset
))
530 : XFRAME (selected_frame
));
531 Lisp_Object rfont_def
;
533 font_group
= fontset_get_font_group (fontset
, fallback
? -1 : c
);
534 if (! CONSP (font_group
))
536 vec
= XCDR (font_group
);
537 if (ASIZE (vec
) == 0)
542 if (XINT (XCAR (font_group
)) != charset_ordered_list_tick
)
543 /* We have just created the font-group,
544 or the charset priorities were changed. */
545 reorder_font_vector (font_group
, face
->ascii_face
->font
);
547 /* Find a spec matching with the charset ID to try at
549 for (i
= 0; i
< ASIZE (vec
); i
++)
551 Lisp_Object repertory
;
553 rfont_def
= AREF (vec
, i
);
554 if (NILP (rfont_def
))
556 repertory
= FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def
));
558 if (XINT (repertory
) == id
)
566 /* Find the first available font in the vector of RFONT-DEF. */
567 for (i
= 0; i
< ASIZE (vec
); i
++)
569 Lisp_Object font_def
;
570 Lisp_Object font_entity
, font_object
;
575 if (charset_matched
> 0)
577 /* Try the element matching with the charset ID at first. */
578 found_index
= charset_matched
;
579 /* Make this negative so that we don't come here in the
581 charset_matched
= - charset_matched
;
582 /* We must try the first element in the next loop. */
586 else if (i
== - charset_matched
)
588 /* We have already tried this element and the followings
589 that have the same font specifications in the first
590 iteration. So, skip them all. */
591 rfont_def
= AREF (vec
, i
);
592 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
593 for (; i
+ 1 < ASIZE (vec
); i
++)
595 rfont_def
= AREF (vec
, i
+ 1);
596 if (NILP (rfont_def
))
598 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def
), font_def
))
604 rfont_def
= AREF (vec
, found_index
);
605 if (NILP (rfont_def
))
609 /* This is a sign of not to try the other fonts. */
612 if (INTEGERP (RFONT_DEF_FACE (rfont_def
))
613 && XINT (RFONT_DEF_FACE (rfont_def
)) < 0)
614 /* We couldn't open this font last time. */
617 font_object
= RFONT_DEF_OBJECT (rfont_def
);
618 if (NILP (font_object
))
620 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
623 /* We have not yet opened the font. */
625 /* Find a font best-matching with the spec without checking
626 the support of the character C. That checking is costly,
627 and even without the checking, the found font supports C
628 in high possibility. */
629 font_entity
= font_find_for_lface (f
, face
->lface
,
630 FONT_DEF_SPEC (font_def
), -1);
631 if (NILP (font_entity
))
633 /* Record that no font matches the spec. */
634 RFONT_DEF_SET_FACE (rfont_def
, -1);
637 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
638 FONT_DEF_SPEC (font_def
));
639 if (NILP (font_object
))
641 /* Something strange happened, perhaps because of a
642 Font-backend problem. Too avoid crashing, record
643 that this spec is unusable. It may be better to find
644 another font of the same spec, but currently we don't
646 RFONT_DEF_SET_FACE (rfont_def
, -1);
649 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
652 if (font_has_char (f
, font_object
, c
))
655 /* Find a font already opened, matching with the current spec,
657 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
658 for (; found_index
+ 1 < ASIZE (vec
); found_index
++)
660 rfont_def
= AREF (vec
, found_index
+ 1);
661 if (NILP (rfont_def
))
663 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def
), font_def
))
665 font_object
= RFONT_DEF_OBJECT (rfont_def
);
666 if (! NILP (font_object
) && font_has_char (f
, font_object
, c
))
673 /* Find a font-entity with the current spec and supporting C. */
674 font_entity
= font_find_for_lface (f
, face
->lface
,
675 FONT_DEF_SPEC (font_def
), c
);
676 if (! NILP (font_entity
))
678 /* We found a font. Open it and insert a new element for
683 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
685 if (NILP (font_object
))
687 RFONT_DEF_NEW (rfont_def
, font_def
);
688 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
689 RFONT_DEF_SET_SCORE (rfont_def
, RFONT_DEF_SCORE (rfont_def
));
690 new_vec
= Fmake_vector (make_number (ASIZE (vec
) + 1), Qnil
);
692 for (j
= 0; j
< found_index
; j
++)
693 ASET (new_vec
, j
, AREF (vec
, j
));
694 ASET (new_vec
, j
, rfont_def
);
695 for (j
++; j
< ASIZE (new_vec
); j
++)
696 ASET (new_vec
, j
, AREF (vec
, j
- 1));
697 XSETCDR (font_group
, new_vec
);
705 FONTSET_SET (fontset
, make_number (c
), make_number (0));
709 if (fallback
&& found_index
> 0)
711 /* The order of fonts in the fallback font-group is not that
712 important, and it is better to move the found font to the
713 first of the group so that the next try will find it
715 for (i
= found_index
; i
> 0; i
--)
716 ASET (vec
, i
, AREF (vec
, i
- 1));
717 ASET (vec
, 0, rfont_def
);
724 fontset_font (Lisp_Object fontset
, int c
, struct face
*face
, int id
)
726 Lisp_Object rfont_def
, default_rfont_def
IF_LINT (= Qnil
);
727 Lisp_Object base_fontset
;
729 /* Try a font-group of FONTSET. */
730 FONT_DEFERRED_LOG ("current fontset: font for", make_number (c
), Qnil
);
731 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 0);
732 if (VECTORP (rfont_def
))
734 if (NILP (rfont_def
))
735 FONTSET_SET (fontset
, make_number (c
), make_number (0));
737 /* Try a font-group of the default fontset. */
738 base_fontset
= FONTSET_BASE (fontset
);
739 if (! EQ (base_fontset
, Vdefault_fontset
))
741 if (NILP (FONTSET_DEFAULT (fontset
)))
744 make_fontset (FONTSET_FRAME (fontset
), Qnil
, Vdefault_fontset
));
745 FONT_DEFERRED_LOG ("default fontset: font for", make_number (c
), Qnil
);
747 = fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 0);
748 if (VECTORP (default_rfont_def
))
749 return default_rfont_def
;
750 if (NILP (default_rfont_def
))
751 FONTSET_SET (FONTSET_DEFAULT (fontset
), make_number (c
),
755 /* Try a fallback font-group of FONTSET. */
756 if (! EQ (rfont_def
, Qt
))
758 FONT_DEFERRED_LOG ("current fallback: font for", make_number (c
), Qnil
);
759 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 1);
760 if (VECTORP (rfont_def
))
762 /* Remember that FONTSET has no font for C. */
763 FONTSET_SET (fontset
, make_number (c
), Qt
);
766 /* Try a fallback font-group of the default fontset. */
767 if (! EQ (base_fontset
, Vdefault_fontset
)
768 && ! EQ (default_rfont_def
, Qt
))
770 FONT_DEFERRED_LOG ("default fallback: font for", make_number (c
), Qnil
);
771 rfont_def
= fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 1);
772 if (VECTORP (rfont_def
))
774 /* Remember that the default fontset has no font for C. */
775 FONTSET_SET (FONTSET_DEFAULT (fontset
), make_number (c
), Qt
);
781 /* Return a newly created fontset with NAME. If BASE is nil, make a
782 base fontset. Otherwise make a realized fontset whose base is
786 make_fontset (Lisp_Object frame
, Lisp_Object name
, Lisp_Object base
)
789 int size
= ASIZE (Vfontset_table
);
790 int id
= next_fontset_id
;
792 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
793 the next available fontset ID. So it is expected that this loop
794 terminates quickly. In addition, as the last element of
795 Vfontset_table is always nil, we don't have to check the range of
797 while (!NILP (AREF (Vfontset_table
, id
))) id
++;
800 Vfontset_table
= larger_vector (Vfontset_table
, 1, -1);
802 fontset
= Fmake_char_table (Qfontset
, Qnil
);
804 set_fontset_id (fontset
, make_number (id
));
806 set_fontset_name (fontset
, name
);
809 set_fontset_name (fontset
, Qnil
);
810 set_fontset_frame (fontset
, frame
);
811 set_fontset_base (fontset
, base
);
814 ASET (Vfontset_table
, id
, fontset
);
815 next_fontset_id
= id
+ 1;
820 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
822 /* Return the name of the fontset who has ID. */
825 fontset_name (int id
)
829 fontset
= FONTSET_FROM_ID (id
);
830 return FONTSET_NAME (fontset
);
834 /* Return the ASCII font name of the fontset who has ID. */
837 fontset_ascii (int id
)
839 Lisp_Object fontset
, elt
;
841 fontset
= FONTSET_FROM_ID (id
);
842 elt
= FONTSET_ASCII (fontset
);
848 /* Free fontset of FACE defined on frame F. Called from
849 free_realized_face. */
852 free_face_fontset (struct frame
*f
, struct face
*face
)
856 fontset
= FONTSET_FROM_ID (face
->fontset
);
859 eassert (! BASE_FONTSET_P (fontset
));
860 eassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
861 ASET (Vfontset_table
, face
->fontset
, Qnil
);
862 if (face
->fontset
< next_fontset_id
)
863 next_fontset_id
= face
->fontset
;
864 if (! NILP (FONTSET_DEFAULT (fontset
)))
866 int id
= XINT (FONTSET_ID (FONTSET_DEFAULT (fontset
)));
868 fontset
= AREF (Vfontset_table
, id
);
869 eassert (!NILP (fontset
) && ! BASE_FONTSET_P (fontset
));
870 eassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
871 ASET (Vfontset_table
, id
, Qnil
);
872 if (id
< next_fontset_id
)
873 next_fontset_id
= face
->fontset
;
878 /* Return ID of face suitable for displaying character C at buffer position
879 POS on frame F. FACE must be realized for ASCII characters in advance.
880 Called from the macro FACE_FOR_CHAR. */
883 face_for_char (struct frame
*f
, struct face
*face
, int c
,
884 ptrdiff_t pos
, Lisp_Object object
)
886 Lisp_Object fontset
, rfont_def
, charset
;
890 eassert (fontset_id_valid_p (face
->fontset
));
892 if (ASCII_CHAR_P (c
) || CHAR_BYTE8_P (c
))
893 return face
->ascii_face
->id
;
895 if (c
> 0 && EQ (CHAR_TABLE_REF (Vchar_script_table
, c
), Qsymbol
))
897 /* Fonts often have characters for punctuation and other
898 symbols, even if they don't match the 'symbol' script. So
899 check if the character is present in the current ASCII face
900 first, and if so, use the same font as used by that face.
901 This avoids unnecessarily switching to another font when the
902 frame's default font will do. We only do this for symbols so
903 that users could still setup fontsets to force Emacs to use
904 specific fonts for characters from other scripts, because
905 choice of fonts is frequently affected by cultural
906 preferences and font features, not by font coverage.
907 However, these considerations are unlikely to be relevant to
908 punctuation and other symbols, since the latter generally
909 aren't specific to any culture, and don't require
910 sophisticated OTF features. */
911 Lisp_Object font_object
;
913 if (face
->ascii_face
->font
)
915 XSETFONT (font_object
, face
->ascii_face
->font
);
916 if (font_has_char (f
, font_object
, c
))
917 return face
->ascii_face
->id
;
921 /* Try the current face. Disabled because it can cause
922 counter-intuitive results, whereby the font used for some
923 character depends on the characters that precede it on
924 display. See the discussion of bug #15138. Note that the
925 original bug reported in #15138 was in a situation where face
926 == face->ascii_face, so the above code solves that situation
927 without risking the undesirable consequences. */
930 XSETFONT (font_object
, face
->font
);
931 if (font_has_char (f
, font_object
, c
)) return face
->id
;
936 fontset
= FONTSET_FROM_ID (face
->fontset
);
937 eassert (!BASE_FONTSET_P (fontset
));
946 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
947 if (CHARSETP (charset
))
951 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
952 if (CONSP (val
) && CHARSETP (XCDR (val
)))
953 charset
= XCDR (val
);
954 id
= XINT (CHARSET_SYMBOL_ID (charset
));
960 rfont_def
= fontset_font (fontset
, c
, face
, id
);
961 if (VECTORP (rfont_def
))
963 if (INTEGERP (RFONT_DEF_FACE (rfont_def
)))
964 face_id
= XINT (RFONT_DEF_FACE (rfont_def
));
967 Lisp_Object font_object
;
969 font_object
= RFONT_DEF_OBJECT (rfont_def
);
970 face_id
= face_for_font (f
, font_object
, face
);
971 RFONT_DEF_SET_FACE (rfont_def
, face_id
);
976 if (INTEGERP (FONTSET_NOFONT_FACE (fontset
)))
977 face_id
= XINT (FONTSET_NOFONT_FACE (fontset
));
980 face_id
= face_for_font (f
, Qnil
, face
);
981 set_fontset_nofont_face (fontset
, make_number (face_id
));
984 eassert (face_id
>= 0);
990 font_for_char (struct face
*face
, int c
, ptrdiff_t pos
, Lisp_Object object
)
992 Lisp_Object fontset
, rfont_def
, charset
;
995 if (ASCII_CHAR_P (c
))
997 Lisp_Object font_object
;
999 XSETFONT (font_object
, face
->ascii_face
->font
);
1003 eassert (fontset_id_valid_p (face
->fontset
));
1004 fontset
= FONTSET_FROM_ID (face
->fontset
);
1005 eassert (!BASE_FONTSET_P (fontset
));
1013 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
1014 if (CHARSETP (charset
))
1018 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
1019 if (CONSP (val
) && CHARSETP (XCDR (val
)))
1020 charset
= XCDR (val
);
1021 id
= XINT (CHARSET_SYMBOL_ID (charset
));
1027 rfont_def
= fontset_font (fontset
, c
, face
, id
);
1028 return (VECTORP (rfont_def
)
1029 ? RFONT_DEF_OBJECT (rfont_def
)
1034 /* Make a realized fontset for ASCII face FACE on frame F from the
1035 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1036 default fontset as the base. Value is the id of the new fontset.
1037 Called from realize_x_face. */
1040 make_fontset_for_ascii_face (struct frame
*f
, int base_fontset_id
, struct face
*face
)
1042 Lisp_Object base_fontset
, fontset
, frame
;
1044 XSETFRAME (frame
, f
);
1045 if (base_fontset_id
>= 0)
1047 base_fontset
= FONTSET_FROM_ID (base_fontset_id
);
1048 if (!BASE_FONTSET_P (base_fontset
))
1049 base_fontset
= FONTSET_BASE (base_fontset
);
1050 eassert (BASE_FONTSET_P (base_fontset
));
1053 base_fontset
= Vdefault_fontset
;
1055 fontset
= make_fontset (frame
, Qnil
, base_fontset
);
1056 return XINT (FONTSET_ID (fontset
));
1061 /* Cache data used by fontset_pattern_regexp. The car part is a
1062 pattern string containing at least one wild card, the cdr part is
1063 the corresponding regular expression. */
1064 static Lisp_Object Vcached_fontset_data
;
1066 #define CACHED_FONTSET_NAME SSDATA (XCAR (Vcached_fontset_data))
1067 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1069 /* If fontset name PATTERN contains any wild card, return regular
1070 expression corresponding to PATTERN. */
1073 fontset_pattern_regexp (Lisp_Object pattern
)
1075 if (!strchr (SSDATA (pattern
), '*')
1076 && !strchr (SSDATA (pattern
), '?'))
1077 /* PATTERN does not contain any wild cards. */
1080 if (!CONSP (Vcached_fontset_data
)
1081 || strcmp (SSDATA (pattern
), CACHED_FONTSET_NAME
))
1083 /* We must at first update the cached data. */
1084 unsigned char *regex
, *p0
, *p1
;
1085 int ndashes
= 0, nstars
= 0, nescs
= 0;
1087 for (p0
= SDATA (pattern
); *p0
; p0
++)
1091 else if (*p0
== '*')
1094 || *p0
== '.' || *p0
== '\\'
1095 || *p0
== '+' || *p0
== '^'
1100 /* If PATTERN is not full XLFD we convert "*" to ".*". Otherwise
1101 we convert "*" to "[^-]*" which is much faster in regular
1102 expression matching. */
1103 ptrdiff_t regexsize
= (SBYTES (pattern
)
1104 + (ndashes
< 14 ? 2 : 5) * nstars
1107 p1
= regex
= SAFE_ALLOCA (regexsize
);
1110 for (p0
= SDATA (pattern
); *p0
; p0
++)
1117 *p1
++ = '[', *p1
++ = '^', *p1
++ = '-', *p1
++ = ']';
1120 else if (*p0
== '?')
1123 || *p0
== '.' || *p0
== '\\'
1124 || *p0
== '+' || *p0
== '^'
1126 *p1
++ = '\\', *p1
++ = *p0
;
1133 Vcached_fontset_data
= Fcons (build_string (SSDATA (pattern
)),
1134 build_string ((char *) regex
));
1138 return CACHED_FONTSET_REGEX
;
1141 /* Return ID of the base fontset named NAME. If there's no such
1142 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1143 0: pattern containing '*' and '?' as wildcards
1144 1: regular expression
1145 2: literal fontset name
1149 fs_query_fontset (Lisp_Object name
, int name_pattern
)
1154 name
= Fdowncase (name
);
1155 if (name_pattern
!= 1)
1157 tem
= Frassoc (name
, Vfontset_alias_alist
);
1159 tem
= Fassoc (name
, Vfontset_alias_alist
);
1160 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1162 else if (name_pattern
== 0)
1164 tem
= fontset_pattern_regexp (name
);
1173 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1175 Lisp_Object fontset
, this_name
;
1177 fontset
= FONTSET_FROM_ID (i
);
1179 || !BASE_FONTSET_P (fontset
))
1182 this_name
= FONTSET_NAME (fontset
);
1183 if (name_pattern
== 1
1184 ? fast_string_match_ignore_case (name
, this_name
) >= 0
1185 : !xstrcasecmp (SSDATA (name
), SSDATA (this_name
)))
1192 DEFUN ("query-fontset", Fquery_fontset
, Squery_fontset
, 1, 2, 0,
1193 doc
: /* Return the name of a fontset that matches PATTERN.
1194 The value is nil if there is no matching fontset.
1195 PATTERN can contain `*' or `?' as a wildcard
1196 just as X font name matching algorithm allows.
1197 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1198 (Lisp_Object pattern
, Lisp_Object regexpp
)
1200 Lisp_Object fontset
;
1203 check_window_system (NULL
);
1205 CHECK_STRING (pattern
);
1207 if (SCHARS (pattern
) == 0)
1210 id
= fs_query_fontset (pattern
, !NILP (regexpp
));
1214 fontset
= FONTSET_FROM_ID (id
);
1215 return FONTSET_NAME (fontset
);
1218 /* Return a list of base fontset names matching PATTERN on frame F. */
1221 list_fontsets (struct frame
*f
, Lisp_Object pattern
, int size
)
1223 Lisp_Object frame
, regexp
, val
;
1226 XSETFRAME (frame
, f
);
1228 regexp
= fontset_pattern_regexp (pattern
);
1231 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1233 Lisp_Object fontset
, name
;
1235 fontset
= FONTSET_FROM_ID (id
);
1237 || !BASE_FONTSET_P (fontset
)
1238 || !EQ (frame
, FONTSET_FRAME (fontset
)))
1240 name
= FONTSET_NAME (fontset
);
1242 if (STRINGP (regexp
)
1243 ? (fast_string_match (regexp
, name
) < 0)
1244 : strcmp (SSDATA (pattern
), SSDATA (name
)))
1247 val
= Fcons (Fcopy_sequence (FONTSET_NAME (fontset
)), val
);
1254 /* Free all realized fontsets whose base fontset is BASE. */
1257 free_realized_fontsets (Lisp_Object base
)
1262 /* For the moment, this doesn't work because free_realized_face
1263 doesn't remove FACE from a cache. Until we find a solution, we
1264 suppress this code, and simply use Fclear_face_cache even though
1265 that is not efficient. */
1267 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1269 Lisp_Object
this = AREF (Vfontset_table
, id
);
1271 if (EQ (FONTSET_BASE (this), base
))
1275 for (tail
= FONTSET_FACE_ALIST (this); CONSP (tail
);
1278 struct frame
*f
= XFRAME (FONTSET_FRAME (this));
1279 int face_id
= XINT (XCDR (XCAR (tail
)));
1280 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1282 /* Face THIS itself is also freed by the following call. */
1283 free_realized_face (f
, face
);
1289 /* But, we don't have to call Fclear_face_cache if no fontset has
1290 been realized from BASE. */
1291 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1293 Lisp_Object
this = AREF (Vfontset_table
, id
);
1295 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base
))
1297 Fclear_face_cache (Qt
);
1305 /* Check validity of NAME as a fontset name and return the
1306 corresponding fontset. If not valid, signal an error.
1308 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1311 Set *FRAME to the actual frame. */
1314 check_fontset_name (Lisp_Object name
, Lisp_Object
*frame
)
1317 struct frame
*f
= decode_live_frame (*frame
);
1319 XSETFRAME (*frame
, f
);
1322 return Vdefault_fontset
;
1324 id
= FRAME_FONTSET (f
);
1327 CHECK_STRING (name
);
1328 /* First try NAME as literal. */
1329 id
= fs_query_fontset (name
, 2);
1331 /* For backward compatibility, try again NAME as pattern. */
1332 id
= fs_query_fontset (name
, 0);
1334 error ("Fontset `%s' does not exist", SDATA (name
));
1336 return FONTSET_FROM_ID (id
);
1340 accumulate_script_ranges (Lisp_Object arg
, Lisp_Object range
, Lisp_Object val
)
1342 if (EQ (XCAR (arg
), val
))
1345 XSETCDR (arg
, Fcons (Fcons (XCAR (range
), XCDR (range
)), XCDR (arg
)));
1347 XSETCDR (arg
, Fcons (Fcons (range
, range
), XCDR (arg
)));
1352 /* Callback function for map_charset_chars in Fset_fontset_font.
1353 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1355 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1356 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1357 The consumed ranges are popped up from SCRIPT_RANGE_LIST, and the
1358 new SCRIPT_RANGE_LIST is stored in ARG.
1360 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1361 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1365 set_fontset_font (Lisp_Object arg
, Lisp_Object range
)
1367 Lisp_Object fontset
, font_def
, add
, ascii
, script_range_list
;
1368 int from
= XINT (XCAR (range
)), to
= XINT (XCDR (range
));
1370 fontset
= AREF (arg
, 0);
1371 font_def
= AREF (arg
, 1);
1372 add
= AREF (arg
, 2);
1373 ascii
= AREF (arg
, 3);
1374 script_range_list
= AREF (arg
, 4);
1376 if (NILP (ascii
) && from
< 0x80)
1381 range
= Fcons (make_number (0x80), XCDR (range
));
1384 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1385 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1386 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1388 for (; CONSP (script_range_list
) && SCRIPT_TO
< from
; POP_SCRIPT_RANGE ())
1389 FONTSET_ADD (fontset
, XCAR (script_range_list
), font_def
, add
);
1390 if (CONSP (script_range_list
))
1392 if (SCRIPT_FROM
< from
)
1393 range
= Fcons (make_number (SCRIPT_FROM
), XCDR (range
));
1394 while (CONSP (script_range_list
) && SCRIPT_TO
<= to
)
1395 POP_SCRIPT_RANGE ();
1396 if (CONSP (script_range_list
) && SCRIPT_FROM
<= to
)
1397 XSETCAR (XCAR (script_range_list
), make_number (to
+ 1));
1400 FONTSET_ADD (fontset
, range
, font_def
, add
);
1401 ASET (arg
, 4, script_range_list
);
1404 static void update_auto_fontset_alist (Lisp_Object
, Lisp_Object
);
1407 DEFUN ("set-fontset-font", Fset_fontset_font
, Sset_fontset_font
, 3, 5, 0,
1409 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1411 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1412 the default fontset.
1414 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1415 In that case, use FONT-SPEC for all characters in the range FROM and
1418 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1419 all characters that belong to the script.
1421 TARGET may be a charset. In that case, use FONT-SPEC for all
1422 characters in the charset.
1424 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1425 that no FONT-SPEC is specified.
1427 FONT-SPEC may one of these:
1428 * A font-spec object made by the function `font-spec' (which see).
1429 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1430 REGISTRY is a font registry name. FAMILY may contain foundry
1431 name, and REGISTRY may contain encoding name.
1432 * A font name string.
1433 * nil, which explicitly specifies that there's no font for TARGET.
1435 Optional 4th argument FRAME is a frame or nil for the selected frame
1436 that is concerned in the case that NAME is nil.
1438 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1439 to the font specifications for TARGET previously set. If it is
1440 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1441 appended. By default, FONT-SPEC overrides the previous settings. */)
1442 (Lisp_Object name
, Lisp_Object target
, Lisp_Object font_spec
, Lisp_Object frame
, Lisp_Object add
)
1444 Lisp_Object fontset
;
1445 Lisp_Object font_def
, registry
, family
;
1446 Lisp_Object range_list
;
1447 struct charset
*charset
= NULL
;
1448 Lisp_Object fontname
;
1449 bool ascii_changed
= 0;
1451 fontset
= check_fontset_name (name
, &frame
);
1454 if (CONSP (font_spec
))
1456 Lisp_Object spec
= Ffont_spec (0, NULL
);
1458 font_parse_family_registry (XCAR (font_spec
), XCDR (font_spec
), spec
);
1460 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1462 else if (STRINGP (font_spec
))
1464 fontname
= font_spec
;
1465 font_spec
= CALLN (Ffont_spec
, QCname
, fontname
);
1467 else if (FONT_SPEC_P (font_spec
))
1468 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1469 else if (! NILP (font_spec
))
1470 Fsignal (Qfont
, list2 (build_string ("Invalid font-spec"), font_spec
));
1472 if (! NILP (font_spec
))
1474 Lisp_Object encoding
, repertory
;
1476 family
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1477 if (! NILP (family
) )
1478 family
= SYMBOL_NAME (family
);
1479 registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1480 if (! NILP (registry
))
1481 registry
= Fdowncase (SYMBOL_NAME (registry
));
1482 AUTO_STRING (dash
, "-");
1483 encoding
= find_font_encoding (concat3 (family
, dash
, registry
));
1484 if (NILP (encoding
))
1487 if (SYMBOLP (encoding
))
1489 CHECK_CHARSET (encoding
);
1490 encoding
= repertory
= CHARSET_SYMBOL_ID (encoding
);
1494 repertory
= XCDR (encoding
);
1495 encoding
= XCAR (encoding
);
1496 CHECK_CHARSET (encoding
);
1497 encoding
= CHARSET_SYMBOL_ID (encoding
);
1498 if (! NILP (repertory
) && SYMBOLP (repertory
))
1500 CHECK_CHARSET (repertory
);
1501 repertory
= CHARSET_SYMBOL_ID (repertory
);
1504 FONT_DEF_NEW (font_def
, font_spec
, encoding
, repertory
);
1509 if (CHARACTERP (target
))
1511 if (XFASTINT (target
) < 0x80)
1512 error ("Can't set a font for partial ASCII range");
1513 range_list
= list1 (Fcons (target
, target
));
1515 else if (CONSP (target
))
1517 Lisp_Object from
, to
;
1519 from
= Fcar (target
);
1521 CHECK_CHARACTER (from
);
1522 CHECK_CHARACTER (to
);
1523 if (XFASTINT (from
) < 0x80)
1525 if (XFASTINT (from
) != 0 || XFASTINT (to
) < 0x7F)
1526 error ("Can't set a font for partial ASCII range");
1529 range_list
= list1 (target
);
1531 else if (SYMBOLP (target
) && !NILP (target
))
1533 Lisp_Object script_list
;
1537 script_list
= XCHAR_TABLE (Vchar_script_table
)->extras
[0];
1538 if (! NILP (Fmemq (target
, script_list
)))
1540 if (EQ (target
, Qlatin
))
1542 val
= list1 (target
);
1543 map_char_table (accumulate_script_ranges
, Qnil
, Vchar_script_table
,
1545 range_list
= Fnreverse (XCDR (val
));
1547 if (CHARSETP (target
))
1549 CHECK_CHARSET_GET_CHARSET (target
, charset
);
1550 if (charset
->ascii_compatible_p
)
1553 else if (NILP (range_list
))
1554 error ("Invalid script or charset name: %s",
1555 SDATA (SYMBOL_NAME (target
)));
1557 else if (NILP (target
))
1558 range_list
= list1 (Qnil
);
1560 error ("Invalid target for setting a font");
1566 if (NILP (font_spec
))
1567 error ("Can't set ASCII font to nil");
1568 val
= CHAR_TABLE_REF (fontset
, 0);
1569 if (! NILP (val
) && EQ (add
, Qappend
))
1570 /* We are going to change just an additional font for ASCII. */
1578 arg
= make_uninit_vector (5);
1579 ASET (arg
, 0, fontset
);
1580 ASET (arg
, 1, font_def
);
1582 ASET (arg
, 3, ascii_changed
? Qt
: Qnil
);
1583 ASET (arg
, 4, range_list
);
1585 map_charset_chars (set_fontset_font
, Qnil
, arg
, charset
,
1586 CHARSET_MIN_CODE (charset
),
1587 CHARSET_MAX_CODE (charset
));
1588 range_list
= AREF (arg
, 4);
1590 for (; CONSP (range_list
); range_list
= XCDR (range_list
))
1591 FONTSET_ADD (fontset
, XCAR (range_list
), font_def
, add
);
1595 Lisp_Object tail
, fr
;
1596 int fontset_id
= XINT (FONTSET_ID (fontset
));
1598 set_fontset_ascii (fontset
, fontname
);
1599 name
= FONTSET_NAME (fontset
);
1600 FOR_EACH_FRAME (tail
, fr
)
1602 struct frame
*f
= XFRAME (fr
);
1603 Lisp_Object font_object
;
1606 if (FRAME_INITIAL_P (f
) || FRAME_TERMCAP_P (f
))
1608 if (fontset_id
!= FRAME_FONTSET (f
))
1610 face
= FACE_FROM_ID (f
, DEFAULT_FACE_ID
);
1612 font_object
= font_load_for_lface (f
, face
->lface
, font_spec
);
1614 font_object
= font_open_by_spec (f
, font_spec
);
1615 if (! NILP (font_object
))
1617 update_auto_fontset_alist (font_object
, fontset
);
1618 AUTO_FRAME_ARG (arg
, Qfont
, Fcons (name
, font_object
));
1619 Fmodify_frame_parameters (fr
, arg
);
1624 /* Free all realized fontsets whose base is FONTSET. This way, the
1625 specified character(s) are surely redisplayed by a correct
1627 free_realized_fontsets (fontset
);
1633 DEFUN ("new-fontset", Fnew_fontset
, Snew_fontset
, 2, 2, 0,
1634 doc
: /* Create a new fontset NAME from font information in FONTLIST.
1636 FONTLIST is an alist of scripts vs the corresponding font specification list.
1637 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1638 character of SCRIPT is displayed by a font that matches one of
1641 SCRIPT is a symbol that appears in the first extra slot of the
1642 char-table `char-script-table'.
1644 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1645 `set-fontset-font' for the meaning. */)
1646 (Lisp_Object name
, Lisp_Object fontlist
)
1648 Lisp_Object fontset
;
1651 CHECK_STRING (name
);
1652 CHECK_LIST (fontlist
);
1654 name
= Fdowncase (name
);
1655 id
= fs_query_fontset (name
, 0);
1658 Lisp_Object font_spec
= Ffont_spec (0, NULL
);
1659 Lisp_Object short_name
;
1663 if (font_parse_xlfd (SSDATA (name
), SBYTES (name
), font_spec
) < 0)
1664 error ("Fontset name must be in XLFD format");
1665 short_name
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1666 if (strncmp (SSDATA (SYMBOL_NAME (short_name
)), "fontset-", 8)
1667 || SBYTES (SYMBOL_NAME (short_name
)) < 9)
1668 error ("Registry field of fontset name must be \"fontset-*\"");
1669 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (short_name
)),
1670 Vfontset_alias_alist
);
1671 ASET (font_spec
, FONT_REGISTRY_INDEX
, Qiso8859_1
);
1672 fontset
= make_fontset (Qnil
, name
, Qnil
);
1673 len
= font_unparse_xlfd (font_spec
, 0, xlfd
, 256);
1675 error ("Invalid fontset name (perhaps too long): %s", SDATA (name
));
1676 set_fontset_ascii (fontset
, make_unibyte_string (xlfd
, len
));
1680 fontset
= FONTSET_FROM_ID (id
);
1681 free_realized_fontsets (fontset
);
1682 Fset_char_table_range (fontset
, Qt
, Qnil
);
1685 for (; CONSP (fontlist
); fontlist
= XCDR (fontlist
))
1687 Lisp_Object elt
, script
;
1689 elt
= XCAR (fontlist
);
1690 script
= Fcar (elt
);
1692 if (CONSP (elt
) && (NILP (XCDR (elt
)) || CONSP (XCDR (elt
))))
1693 for (; CONSP (elt
); elt
= XCDR (elt
))
1694 Fset_fontset_font (name
, script
, XCAR (elt
), Qnil
, Qappend
);
1696 Fset_fontset_font (name
, script
, elt
, Qnil
, Qappend
);
1702 /* Alist of automatically created fontsets. Each element is a cons
1703 (FONT-SPEC . FONTSET-ID). */
1704 static Lisp_Object auto_fontset_alist
;
1706 /* Number of automatically created fontsets. */
1707 static ptrdiff_t num_auto_fontsets
;
1709 /* Return a fontset synthesized from FONT-OBJECT. This is called from
1710 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1711 frame, and the returned fontset is used for the default fontset of
1712 that frame. The fontset specifies a font of the same registry as
1713 FONT-OBJECT for all characters in the repertory of the registry
1714 (see Vfont_encoding_alist). If the repertory is not known, the
1715 fontset specifies the font for all Latin characters assuming that a
1716 user intends to use FONT-OBJECT for Latin characters. */
1719 fontset_from_font (Lisp_Object font_object
)
1721 Lisp_Object font_name
= font_get_name (font_object
);
1722 Lisp_Object font_spec
= copy_font_spec (font_object
);
1723 Lisp_Object registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1724 Lisp_Object fontset_spec
, alias
, name
, fontset
;
1727 val
= assoc_no_quit (font_spec
, auto_fontset_alist
);
1729 return XINT (FONTSET_ID (XCDR (val
)));
1730 if (num_auto_fontsets
++ == 0)
1731 alias
= intern ("fontset-startup");
1734 char temp
[sizeof "fontset-auto" + INT_STRLEN_BOUND (ptrdiff_t)];
1736 sprintf (temp
, "fontset-auto%"pD
"d", num_auto_fontsets
- 1);
1737 alias
= intern (temp
);
1739 fontset_spec
= copy_font_spec (font_spec
);
1740 ASET (fontset_spec
, FONT_REGISTRY_INDEX
, alias
);
1741 name
= Ffont_xlfd_name (fontset_spec
, Qnil
);
1742 eassert (!NILP (name
));
1743 fontset
= make_fontset (Qnil
, name
, Qnil
);
1744 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (alias
)),
1745 Vfontset_alias_alist
);
1746 alias
= Fdowncase (AREF (font_object
, FONT_NAME_INDEX
));
1747 Vfontset_alias_alist
= Fcons (Fcons (name
, alias
), Vfontset_alias_alist
);
1748 auto_fontset_alist
= Fcons (Fcons (font_spec
, fontset
), auto_fontset_alist
);
1749 font_spec
= Ffont_spec (0, NULL
);
1750 ASET (font_spec
, FONT_REGISTRY_INDEX
, registry
);
1752 Lisp_Object target
= find_font_encoding (SYMBOL_NAME (registry
));
1755 target
= XCDR (target
);
1756 if (! CHARSETP (target
))
1758 Fset_fontset_font (name
, target
, font_spec
, Qnil
, Qnil
);
1759 Fset_fontset_font (name
, Qnil
, font_spec
, Qnil
, Qnil
);
1762 set_fontset_ascii (fontset
, font_name
);
1764 return XINT (FONTSET_ID (fontset
));
1768 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1769 FONTSET is changed, we delete an entry of FONTSET if any from
1770 auto_fontset_alist so that FONTSET is not re-used by
1771 fontset_from_font. */
1774 update_auto_fontset_alist (Lisp_Object font_object
, Lisp_Object fontset
)
1776 Lisp_Object prev
, tail
;
1778 for (prev
= Qnil
, tail
= auto_fontset_alist
; CONSP (tail
);
1779 prev
= tail
, tail
= XCDR (tail
))
1780 if (EQ (fontset
, XCDR (XCAR (tail
))))
1783 auto_fontset_alist
= XCDR (tail
);
1785 XSETCDR (prev
, XCDR (tail
));
1791 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1792 FONT-OBJECT is the font for the character at POSITION in the current
1793 buffer. This is computed from all the text properties and overlays
1794 that apply to POSITION. POSITION may be nil, in which case,
1795 FONT-SPEC is the font for displaying the character CH with the
1798 GLYPH-CODE is the glyph code in the font to use for the character.
1800 If the 2nd optional arg CH is non-nil, it is a character to check
1801 the font instead of the character at POSITION.
1803 It returns nil in the following cases:
1805 (1) The window system doesn't have a font for the character (thus
1806 it is displayed by an empty box).
1808 (2) The character code is invalid.
1810 (3) If POSITION is not nil, and the current buffer is not displayed
1813 In addition, the returned font name may not take into account of
1814 such redisplay engine hooks as what used in jit-lock-mode if
1815 POSITION is currently not visible. */
1818 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1819 doc
: /* For internal use only. */)
1820 (Lisp_Object position
, Lisp_Object ch
)
1822 ptrdiff_t pos
, pos_byte
, dummy
;
1828 if (NILP (position
))
1830 CHECK_CHARACTER (ch
);
1832 f
= XFRAME (selected_frame
);
1833 face_id
= lookup_basic_face (f
, DEFAULT_FACE_ID
);
1841 CHECK_NUMBER_COERCE_MARKER (position
);
1842 if (! (BEGV
<= XINT (position
) && XINT (position
) < ZV
))
1843 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1844 pos
= XINT (position
);
1845 pos_byte
= CHAR_TO_BYTE (pos
);
1847 c
= FETCH_CHAR (pos_byte
);
1853 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1856 w
= XWINDOW (window
);
1857 f
= XFRAME (w
->frame
);
1858 face_id
= face_at_buffer_position (w
, pos
, &dummy
,
1859 pos
+ 100, false, -1);
1861 if (! CHAR_VALID_P (c
))
1863 if (!FRAME_WINDOW_P (f
))
1865 /* We need the basic faces to be valid below, so recompute them if
1866 some code just happened to clear the face cache. */
1867 if (FRAME_FACE_CACHE (f
)->used
== 0)
1868 recompute_basic_faces (f
);
1869 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
, pos
, Qnil
);
1870 face
= FACE_FROM_ID (f
, face_id
);
1873 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
1874 Lisp_Object font_object
;
1876 if (code
== FONT_INVALID_CODE
)
1878 XSETFONT (font_object
, face
->font
);
1879 return Fcons (font_object
, INTEGER_TO_CONS (code
));
1885 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1886 doc
: /* Return information about a fontset FONTSET on frame FRAME.
1888 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1889 for the default fontset. FRAME nil means the selected frame.
1891 The value is a char-table whose elements have this form:
1893 ((FONT OPENED-FONT ...) ...)
1895 FONT is a name of font specified for a range of characters.
1897 OPENED-FONT is a name of a font actually opened.
1899 The char-table has one extra slot. If FONTSET is not the default
1900 fontset, the value the extra slot is a char-table containing the
1901 information about the derived fonts from the default fontset. The
1902 format is the same as above. */)
1903 (Lisp_Object fontset
, Lisp_Object frame
)
1905 Lisp_Object
*realized
[2], fontsets
[2], tables
[2];
1906 Lisp_Object val
, elt
;
1909 check_window_system (NULL
);
1910 fontset
= check_fontset_name (fontset
, &frame
);
1912 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1913 in the table `realized'. */
1915 SAFE_ALLOCA_LISP (realized
[0], 2 * ASIZE (Vfontset_table
));
1916 realized
[1] = realized
[0] + ASIZE (Vfontset_table
);
1917 for (i
= j
= 0; i
< ASIZE (Vfontset_table
); i
++)
1919 elt
= FONTSET_FROM_ID (i
);
1921 && EQ (FONTSET_BASE (elt
), fontset
)
1922 && EQ (FONTSET_FRAME (elt
), frame
))
1923 realized
[0][j
++] = elt
;
1925 realized
[0][j
] = Qnil
;
1927 for (i
= j
= 0; ! NILP (realized
[0][i
]); i
++)
1929 elt
= FONTSET_DEFAULT (realized
[0][i
]);
1931 realized
[1][j
++] = elt
;
1933 realized
[1][j
] = Qnil
;
1935 tables
[0] = Fmake_char_table (Qfontset_info
, Qnil
);
1936 fontsets
[0] = fontset
;
1937 if (!EQ (fontset
, Vdefault_fontset
))
1939 tables
[1] = Fmake_char_table (Qnil
, Qnil
);
1940 set_char_table_extras (tables
[0], 0, tables
[1]);
1941 fontsets
[1] = Vdefault_fontset
;
1944 /* Accumulate information of the fontset in TABLE. The format of
1945 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1946 for (k
= 0; k
<= 1; k
++)
1948 for (c
= 0; c
<= MAX_CHAR
; )
1950 int from
= c
, to
= MAX_5_BYTE_CHAR
;
1952 if (c
<= MAX_5_BYTE_CHAR
)
1954 val
= char_table_ref_and_range (fontsets
[k
], c
, &from
, &to
);
1958 val
= FONTSET_FALLBACK (fontsets
[k
]);
1965 /* At first, set ALIST to ((FONT-SPEC) ...). */
1966 for (alist
= Qnil
, i
= 0; i
< ASIZE (val
); i
++)
1967 if (! NILP (AREF (val
, i
)))
1968 alist
= Fcons (Fcons (FONT_DEF_SPEC (AREF (val
, i
)), Qnil
),
1970 alist
= Fnreverse (alist
);
1972 /* Then store opened font names to cdr of each elements. */
1973 for (i
= 0; ! NILP (realized
[k
][i
]); i
++)
1975 if (c
<= MAX_5_BYTE_CHAR
)
1976 val
= FONTSET_REF (realized
[k
][i
], c
);
1978 val
= FONTSET_FALLBACK (realized
[k
][i
]);
1979 if (! CONSP (val
) || ! VECTORP (XCDR (val
)))
1981 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
1983 for (j
= 0; j
< ASIZE (val
); j
++)
1985 elt
= AREF (val
, j
);
1986 if (!NILP (elt
) && FONT_OBJECT_P (RFONT_DEF_OBJECT (elt
)))
1988 Lisp_Object font_object
= RFONT_DEF_OBJECT (elt
);
1989 Lisp_Object slot
, name
;
1991 slot
= Fassq (RFONT_DEF_SPEC (elt
), alist
);
1992 name
= AREF (font_object
, FONT_NAME_INDEX
);
1993 if (NILP (Fmember (name
, XCDR (slot
))))
1994 nconc2 (slot
, list1 (name
));
1999 /* Store ALIST in TBL for characters C..TO. */
2000 if (c
<= MAX_5_BYTE_CHAR
)
2001 char_table_set_range (tables
[k
], c
, to
, alist
);
2003 set_char_table_defalt (tables
[k
], alist
);
2005 /* At last, change each elements to font names. */
2006 for (; CONSP (alist
); alist
= XCDR (alist
))
2009 XSETCAR (elt
, Ffont_xlfd_name (XCAR (elt
), Qnil
));
2014 if (EQ (fontset
, Vdefault_fontset
))
2023 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 3, 0,
2024 doc
: /* Return a font name pattern for character CH in fontset NAME.
2025 If NAME is t, find a pattern in the default fontset.
2026 If NAME is nil, find a pattern in the fontset of the selected frame.
2028 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2029 family name and REGISTRY is a font registry name. This is actually
2030 the first font name pattern for CH in the fontset or in the default
2033 If the 2nd optional arg ALL is non-nil, return a list of all font name
2035 (Lisp_Object name
, Lisp_Object ch
, Lisp_Object all
)
2038 Lisp_Object fontset
, elt
, list
, repertory
, val
;
2043 fontset
= check_fontset_name (name
, &frame
);
2045 CHECK_CHARACTER (ch
);
2050 for (i
= 0, elt
= FONTSET_REF (fontset
, c
); i
< 2;
2051 i
++, elt
= FONTSET_FALLBACK (fontset
))
2053 for (j
= 0; j
< ASIZE (elt
); j
++)
2055 Lisp_Object family
, registry
;
2057 val
= AREF (elt
, j
);
2060 repertory
= AREF (val
, 1);
2061 if (INTEGERP (repertory
))
2063 struct charset
*charset
= CHARSET_FROM_ID (XINT (repertory
));
2065 if (! CHAR_CHARSET_P (c
, charset
))
2068 else if (CHAR_TABLE_P (repertory
))
2070 if (NILP (CHAR_TABLE_REF (repertory
, c
)))
2073 val
= AREF (val
, 0);
2074 /* VAL is a FONT-SPEC */
2075 family
= AREF (val
, FONT_FAMILY_INDEX
);
2076 if (! NILP (family
))
2077 family
= SYMBOL_NAME (family
);
2078 registry
= AREF (val
, FONT_REGISTRY_INDEX
);
2079 if (! NILP (registry
))
2080 registry
= SYMBOL_NAME (registry
);
2081 val
= Fcons (family
, registry
);
2084 list
= Fcons (val
, list
);
2086 if (EQ (fontset
, Vdefault_fontset
))
2088 fontset
= Vdefault_fontset
;
2090 return (Fnreverse (list
));
2093 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
2094 doc
: /* Return a list of all defined fontset names. */)
2097 Lisp_Object fontset
, list
;
2101 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
2103 fontset
= FONTSET_FROM_ID (i
);
2105 && BASE_FONTSET_P (fontset
))
2106 list
= Fcons (FONTSET_NAME (fontset
), list
);
2113 #ifdef ENABLE_CHECKING
2115 Lisp_Object
dump_fontset (Lisp_Object
) EXTERNALLY_VISIBLE
;
2118 dump_fontset (Lisp_Object fontset
)
2122 vec
= Fmake_vector (make_number (3), Qnil
);
2123 ASET (vec
, 0, FONTSET_ID (fontset
));
2125 if (BASE_FONTSET_P (fontset
))
2127 ASET (vec
, 1, FONTSET_NAME (fontset
));
2133 frame
= FONTSET_FRAME (fontset
);
2136 struct frame
*f
= XFRAME (frame
);
2138 if (FRAME_LIVE_P (f
))
2140 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)),
2144 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), Qnil
));
2146 if (!NILP (FONTSET_DEFAULT (fontset
)))
2147 ASET (vec
, 2, FONTSET_ID (FONTSET_DEFAULT (fontset
)));
2152 DEFUN ("fontset-list-all", Ffontset_list_all
, Sfontset_list_all
, 0, 0, 0,
2153 doc
: /* Return a brief summary of all fontsets for debug use. */)
2159 for (i
= 0, val
= Qnil
; i
< ASIZE (Vfontset_table
); i
++)
2160 if (! NILP (AREF (Vfontset_table
, i
)))
2161 val
= Fcons (dump_fontset (AREF (Vfontset_table
, i
)), val
);
2162 return (Fnreverse (val
));
2164 #endif /* ENABLE_CHECKING */
2167 syms_of_fontset (void)
2169 DEFSYM (Qfontset
, "fontset");
2170 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (8));
2171 DEFSYM (Qfontset_info
, "fontset-info");
2172 Fput (Qfontset_info
, Qchar_table_extra_slots
, make_number (1));
2174 DEFSYM (Qappend
, "append");
2175 DEFSYM (Qlatin
, "latin");
2177 Vcached_fontset_data
= Qnil
;
2178 staticpro (&Vcached_fontset_data
);
2180 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
2181 staticpro (&Vfontset_table
);
2183 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
2184 staticpro (&Vdefault_fontset
);
2185 set_fontset_id (Vdefault_fontset
, make_number (0));
2188 build_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));
2189 ASET (Vfontset_table
, 0, Vdefault_fontset
);
2190 next_fontset_id
= 1;
2192 auto_fontset_alist
= Qnil
;
2193 staticpro (&auto_fontset_alist
);
2195 DEFVAR_LISP ("font-encoding-charset-alist", Vfont_encoding_charset_alist
,
2197 Alist of charsets vs the charsets to determine the preferred font encoding.
2198 Each element looks like (CHARSET . ENCODING-CHARSET),
2199 where ENCODING-CHARSET is a charset registered in the variable
2200 `font-encoding-alist' as ENCODING.
2202 When a text has a property `charset' and the value is CHARSET, a font
2203 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2204 Vfont_encoding_charset_alist
= Qnil
;
2206 DEFVAR_LISP ("use-default-ascent", Vuse_default_ascent
,
2208 Char table of characters whose ascent values should be ignored.
2209 If an entry for a character is non-nil, the ascent value of the glyph
2210 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2212 This affects how a composite character which contains
2213 such a character is displayed on screen. */);
2214 Vuse_default_ascent
= Qnil
;
2216 DEFVAR_LISP ("ignore-relative-composition", Vignore_relative_composition
,
2218 Char table of characters which are not composed relatively.
2219 If an entry for a character is non-nil, a composition sequence
2220 which contains that character is displayed so that
2221 the glyph of that character is put without considering
2222 an ascent and descent value of a previous character. */);
2223 Vignore_relative_composition
= Qnil
;
2225 DEFVAR_LISP ("alternate-fontname-alist", Valternate_fontname_alist
,
2226 doc
: /* Alist of fontname vs list of the alternate fontnames.
2227 When a specified font name is not found, the corresponding
2228 alternate fontnames (if any) are tried instead. */);
2229 Valternate_fontname_alist
= Qnil
;
2231 DEFVAR_LISP ("fontset-alias-alist", Vfontset_alias_alist
,
2232 doc
: /* Alist of fontset names vs the aliases. */);
2233 Vfontset_alias_alist
2234 = list1 (Fcons (FONTSET_NAME (Vdefault_fontset
),
2235 build_pure_c_string ("fontset-default")));
2237 DEFVAR_LISP ("vertical-centering-font-regexp",
2238 Vvertical_centering_font_regexp
,
2239 doc
: /* Regexp matching font names that require vertical centering on display.
2240 When a character is displayed with such fonts, the character is displayed
2241 at the vertical center of lines. */);
2242 Vvertical_centering_font_regexp
= Qnil
;
2244 DEFVAR_LISP ("otf-script-alist", Votf_script_alist
,
2245 doc
: /* Alist of OpenType script tags vs the corresponding script names. */);
2246 Votf_script_alist
= Qnil
;
2248 defsubr (&Squery_fontset
);
2249 defsubr (&Snew_fontset
);
2250 defsubr (&Sset_fontset_font
);
2251 defsubr (&Sinternal_char_font
);
2252 defsubr (&Sfontset_info
);
2253 defsubr (&Sfontset_font
);
2254 defsubr (&Sfontset_list
);
2255 #ifdef ENABLE_CHECKING
2256 defsubr (&Sfontset_list_all
);