2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5 2005, 2006, 2007, 2008, 2009
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/>. */
27 /* #define FONTSET_DEBUG */
33 #include "blockinput.h"
35 #include "character.h"
40 #include "dispextern.h"
41 #include "intervals.h"
53 #include "termhooks.h"
59 #define xassert(X) do {if (!(X)) abort ();} while (0)
62 #else /* not FONTSET_DEBUG */
63 #define xassert(X) (void) 0
64 #endif /* not FONTSET_DEBUG */
66 EXFUN (Fclear_face_cache
, 1);
70 A fontset is a collection of font related information to give
71 similar appearance (style, etc) of characters. A fontset has two
72 roles. One is to use for the frame parameter `font' as if it is an
73 ASCII font. In that case, Emacs uses the font specified for
74 `ascii' script for the frame's default font.
76 Another role, the more important one, is to provide information
77 about which font to use for each non-ASCII character.
79 There are two kinds of fontsets; base and realized. A base fontset
80 is created by `new-fontset' from Emacs Lisp explicitly. A realized
81 fontset is created implicitly when a face is realized for ASCII
82 characters. A face is also realized for non-ASCII characters based
83 on an ASCII face. All of non-ASCII faces based on the same ASCII
84 face share the same realized fontset.
86 A fontset object is implemented by a char-table whose default value
87 and parent are always nil.
89 An element of a base fontset is a vector of FONT-DEFs which itself
90 is a vector [ FONT-SPEC ENCODING REPERTORY ].
92 An element of a realized fontset is nil, t, 0, or a vector of this
95 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
96 RFONT-DEF0 RFONT-DEF1 ... ]
98 RFONT-DEFn (i.e. Realized FONT-DEF) has this form:
100 [ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]
102 RFONT-DEFn are automatically reordered by the current charset
105 The value nil means that we have not yet generated the above vector
106 from the base of the fontset.
108 The value t means that no font is available for the corresponding
111 The value 0 means that no font is available for the corresponding
112 range of characters in this fontset, but may be available in the
116 A fontset has 9 extra slots.
118 The 1st slot: the ID number of the fontset
121 base: the name of the fontset
126 realized: the base fontset
130 realized: the frame that the fontset belongs to
133 base: the font name for ASCII characters
138 realized: the ID number of a face to use for characters that
139 has no font in a realized fontset.
143 realized: Alist of font index vs the corresponding repertory
148 realized: If the base is not the default fontset, a fontset
149 realized from the default fontset, else nil.
152 base: Same as element value (but for fallback fonts).
155 All fontsets are recorded in the vector Vfontset_table.
160 There's a special base fontset named `default fontset' which
161 defines the default font specifications. When a base fontset
162 doesn't specify a font for a specific character, the corresponding
163 value in the default fontset is used.
165 The parent of a realized fontset created for such a face that has
166 no fontset is the default fontset.
169 These structures are hidden from the other codes than this file.
170 The other codes handle fontsets only by their ID numbers. They
171 usually use the variable name `fontset' for IDs. But, in this
172 file, we always use varialbe name `id' for IDs, and name `fontset'
173 for an actual fontset object, i.e., char-table.
177 /********** VARIABLES and FUNCTION PROTOTYPES **********/
179 extern Lisp_Object Qfont
;
180 static Lisp_Object Qfontset
;
181 static Lisp_Object Qfontset_info
;
182 static Lisp_Object Qprepend
, Qappend
;
183 static Lisp_Object Qlatin
;
185 /* Vector containing all fontsets. */
186 static Lisp_Object Vfontset_table
;
188 /* Next possibly free fontset ID. Usually this keeps the minimum
189 fontset ID not yet used. */
190 static int next_fontset_id
;
192 /* The default fontset. This gives default FAMILY and REGISTRY of
193 font for each character. */
194 static Lisp_Object Vdefault_fontset
;
196 Lisp_Object Vfont_encoding_charset_alist
;
197 Lisp_Object Vuse_default_ascent
;
198 Lisp_Object Vignore_relative_composition
;
199 Lisp_Object Valternate_fontname_alist
;
200 Lisp_Object Vfontset_alias_alist
;
201 Lisp_Object Vvertical_centering_font_regexp
;
202 Lisp_Object Votf_script_alist
;
204 /* Check if any window system is used now. */
205 void (*check_window_system_func
) P_ ((void));
208 /* Prototype declarations for static functions. */
209 static Lisp_Object fontset_add
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
211 static Lisp_Object fontset_find_font
P_ ((Lisp_Object
, int, struct face
*,
213 static void reorder_font_vector
P_ ((Lisp_Object
, struct font
*));
214 static Lisp_Object fontset_font
P_ ((Lisp_Object
, int, struct face
*, int));
215 static Lisp_Object make_fontset
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
216 static Lisp_Object fontset_pattern_regexp
P_ ((Lisp_Object
));
217 static void accumulate_script_ranges
P_ ((Lisp_Object
, Lisp_Object
,
219 Lisp_Object find_font_encoding
P_ ((Lisp_Object
));
221 static void set_fontset_font
P_ ((Lisp_Object
, Lisp_Object
));
225 /* Return 1 if ID is a valid fontset id, else return 0. */
228 fontset_id_valid_p (id
)
231 return (id
>= 0 && id
< ASIZE (Vfontset_table
) - 1);
238 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
240 /* Return the fontset with ID. No check of ID's validness. */
241 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
243 /* Macros to access special values of FONTSET. */
244 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
246 /* Macros to access special values of (base) FONTSET. */
247 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
248 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->extras[4]
249 #define FONTSET_SPEC(fontset) XCHAR_TABLE (fontset)->extras[5]
251 /* Macros to access special values of (realized) FONTSET. */
252 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->extras[2]
253 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[3]
254 #define FONTSET_OBJLIST(fontset) XCHAR_TABLE (fontset)->extras[4]
255 #define FONTSET_NOFONT_FACE(fontset) XCHAR_TABLE (fontset)->extras[5]
256 #define FONTSET_REPERTORY(fontset) XCHAR_TABLE (fontset)->extras[6]
257 #define FONTSET_DEFAULT(fontset) XCHAR_TABLE (fontset)->extras[7]
259 /* For both base and realized fontset. */
260 #define FONTSET_FALLBACK(fontset) XCHAR_TABLE (fontset)->extras[8]
262 #define BASE_FONTSET_P(fontset) (NILP (FONTSET_BASE (fontset)))
265 /* Macros for FONT-DEF and RFONT-DEF of fontset. */
266 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory) \
268 (font_def) = Fmake_vector (make_number (3), (font_spec)); \
269 ASET ((font_def), 1, encoding); \
270 ASET ((font_def), 2, repertory); \
273 #define FONT_DEF_SPEC(font_def) AREF (font_def, 0)
274 #define FONT_DEF_ENCODING(font_def) AREF (font_def, 1)
275 #define FONT_DEF_REPERTORY(font_def) AREF (font_def, 2)
277 #define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
278 #define RFONT_DEF_SET_FACE(rfont_def, face_id) \
279 ASET ((rfont_def), 0, make_number (face_id))
280 #define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
281 #define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
282 #define RFONT_DEF_REPERTORY(rfont_def) FONT_DEF_REPERTORY (AREF (rfont_def, 1))
283 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
284 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
285 ASET ((rfont_def), 2, (object))
286 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
287 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
288 ASET ((rfont_def), 3, make_number (score))
289 #define RFONT_DEF_NEW(rfont_def, font_def) \
291 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
292 ASET ((rfont_def), 1, (font_def)); \
293 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
297 /* Return the element of FONTSET for the character C. If FONTSET is a
298 base fontset other then the default fontset and FONTSET doesn't
299 contain information for C, return the information in the default
302 #define FONTSET_REF(fontset, c) \
303 (EQ (fontset, Vdefault_fontset) \
304 ? CHAR_TABLE_REF (fontset, c) \
305 : fontset_ref ((fontset), (c)))
308 fontset_ref (fontset
, c
)
314 elt
= CHAR_TABLE_REF (fontset
, c
);
315 if (NILP (elt
) && ! EQ (fontset
, Vdefault_fontset
)
316 /* Don't check Vdefault_fontset for a realized fontset. */
317 && NILP (FONTSET_BASE (fontset
)))
318 elt
= CHAR_TABLE_REF (Vdefault_fontset
, c
);
322 /* Set elements of FONTSET for characters in RANGE to the value ELT.
323 RANGE is a cons (FROM . TO), where FROM and TO are character codes
324 specifying a range. */
326 #define FONTSET_SET(fontset, range, elt) \
327 Fset_char_table_range ((fontset), (range), (elt))
330 /* Modify the elements of FONTSET for characters in RANGE by replacing
331 with ELT or adding ELT. RANGE is a cons (FROM . TO), where FROM
332 and TO are character codes specifying a range. If ADD is nil,
333 replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
336 #define FONTSET_ADD(fontset, range, elt, add) \
339 ? (FONTSET_FALLBACK (fontset) = Fmake_vector (make_number (1), (elt))) \
340 : Fset_char_table_range ((fontset), (range), \
341 Fmake_vector (make_number (1), (elt)))) \
342 : fontset_add ((fontset), (range), (elt), (add)))
345 fontset_add (fontset
, range
, elt
, add
)
346 Lisp_Object fontset
, range
, elt
, add
;
349 int idx
= (EQ (add
, Qappend
) ? 0 : 1);
351 args
[1 - idx
] = Fmake_vector (make_number (1), elt
);
355 int from
= XINT (XCAR (range
));
356 int to
= XINT (XCDR (range
));
360 from1
= from
, to1
= to
;
361 args
[idx
] = char_table_ref_and_range (fontset
, from
, &from1
, &to1
);
362 char_table_set_range (fontset
, from
, to1
,
363 NILP (args
[idx
]) ? args
[1 - idx
]
364 : Fvconcat (2, args
));
370 args
[idx
] = FONTSET_FALLBACK (fontset
);
371 FONTSET_FALLBACK (fontset
)
372 = NILP (args
[idx
]) ? args
[1 - idx
] : Fvconcat (2, args
);
378 fontset_compare_rfontdef (val1
, val2
)
379 const void *val1
, *val2
;
381 return (RFONT_DEF_SCORE (*(Lisp_Object
*) val1
)
382 - RFONT_DEF_SCORE (*(Lisp_Object
*) val2
));
385 /* Update FONT-GROUP which has this form:
386 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
387 RFONT-DEF0 RFONT-DEF1 ... ]
388 Reorder RFONT-DEFs according to the current language, and update
389 CHARSET-ORDERED-LIST-TICK.
391 If PREFERRED_FAMILY is not nil, that family has the higher priority
392 if the encoding charsets or languages in font-specs are the same. */
394 extern Lisp_Object
Fassoc_string ();
397 reorder_font_vector (font_group
, font
)
398 Lisp_Object font_group
;
401 Lisp_Object vec
, font_object
;
404 int score_changed
= 0;
407 XSETFONT (font_object
, font
);
411 vec
= XCDR (font_group
);
413 /* Exclude the tailing nil element from the reordering. */
414 if (NILP (AREF (vec
, size
- 1)))
417 for (i
= 0; i
< size
; i
++)
419 Lisp_Object rfont_def
= AREF (vec
, i
);
420 Lisp_Object font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
421 Lisp_Object font_spec
= FONT_DEF_SPEC (font_def
);
422 int score
= RFONT_DEF_SCORE (rfont_def
) & 0xFF;
424 if (! font_match_p (font_spec
, font_object
))
426 Lisp_Object encoding
= FONT_DEF_ENCODING (font_def
);
428 if (! NILP (encoding
))
432 for (tail
= Vcharset_ordered_list
;
433 ! EQ (tail
, Vcharset_non_preferred_head
) && CONSP (tail
);
434 score
+= 0x100, tail
= XCDR (tail
))
435 if (EQ (encoding
, XCAR (tail
)))
440 Lisp_Object lang
= Ffont_get (font_spec
, QClang
);
443 && ! EQ (lang
, Vcurrent_iso639_language
)
444 && (! CONSP (Vcurrent_iso639_language
)
445 || NILP (Fmemq (lang
, Vcurrent_iso639_language
))))
449 if (RFONT_DEF_SCORE (rfont_def
) != score
)
451 RFONT_DEF_SET_SCORE (rfont_def
, score
);
457 qsort (XVECTOR (vec
)->contents
, size
, sizeof (Lisp_Object
),
458 fontset_compare_rfontdef
);
459 XSETCAR (font_group
, make_number (charset_ordered_list_tick
));
463 fontset_get_font_group (Lisp_Object fontset
, int c
)
465 Lisp_Object font_group
;
466 Lisp_Object base_fontset
;
467 int from
= 0, to
= MAX_CHAR
, i
;
469 xassert (! BASE_FONTSET_P (fontset
));
471 font_group
= CHAR_TABLE_REF (fontset
, c
);
473 font_group
= FONTSET_FALLBACK (fontset
);
474 if (! NILP (font_group
))
476 base_fontset
= FONTSET_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
))
484 char_table_set_range (fontset
, from
, to
, make_number (0));
487 font_group
= Fcopy_sequence (font_group
);
488 for (i
= 0; i
< ASIZE (font_group
); i
++)
489 if (! NILP (AREF (font_group
, i
)))
491 Lisp_Object rfont_def
;
493 RFONT_DEF_NEW (rfont_def
, AREF (font_group
, i
));
494 /* Remember the original order. */
495 RFONT_DEF_SET_SCORE (rfont_def
, i
);
496 ASET (font_group
, i
, rfont_def
);
498 font_group
= Fcons (make_number (-1), font_group
);
500 char_table_set_range (fontset
, from
, to
, font_group
);
502 FONTSET_FALLBACK (fontset
) = font_group
;
506 /* Return RFONT-DEF (vector) in the realized fontset FONTSET for the
507 character C. If no font is found, return Qnil if there's a
508 possibility that the default fontset or the fallback font groups
509 have a proper font, and return Qt if not.
511 If a font is found but is not yet opened, open it (if FACE is not
512 NULL) or return Qnil (if FACE is NULL).
514 ID is a charset-id that must be preferred, or -1 meaning no
517 If FALLBACK is nonzero, search only fallback fonts. */
520 fontset_find_font (fontset
, c
, face
, id
, fallback
)
526 Lisp_Object vec
, font_group
;
527 int i
, charset_matched
= -1;
528 FRAME_PTR f
= (FRAMEP (FONTSET_FRAME (fontset
)))
529 ? XFRAME (selected_frame
) : XFRAME (FONTSET_FRAME (fontset
));
531 font_group
= fontset_get_font_group (fontset
, fallback
? -1 : c
);
532 if (! CONSP (font_group
))
534 vec
= XCDR (font_group
);
535 if (ASIZE (vec
) == 0)
540 if (XINT (XCAR (font_group
)) != charset_ordered_list_tick
)
541 /* We have just created the font-group,
542 or the charset priorities were changed. */
543 reorder_font_vector (font_group
, face
->ascii_face
->font
);
545 /* Find a spec matching with the charset ID to try at
547 for (i
= 0; i
< ASIZE (vec
); i
++)
549 Lisp_Object rfont_def
= AREF (vec
, i
);
550 Lisp_Object repertory
;
552 if (NILP (rfont_def
))
554 repertory
= FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def
));
556 if (XINT (repertory
) == id
)
564 /* Find the first available font in the vector of RFONT-DEF. */
565 for (i
= 0; i
< ASIZE (vec
); i
++)
567 Lisp_Object rfont_def
, font_def
;
568 Lisp_Object font_entity
, font_object
;
570 if (i
== 0 && charset_matched
>= 0)
572 /* Try the element matching with the charset ID at first. */
573 rfont_def
= AREF (vec
, charset_matched
);
574 charset_matched
= -1;
577 else if (i
!= charset_matched
)
578 rfont_def
= AREF (vec
, i
);
582 if (NILP (rfont_def
))
583 /* This is a sign of not to try the other fonts. */
585 if (INTEGERP (RFONT_DEF_FACE (rfont_def
))
586 && XINT (RFONT_DEF_FACE (rfont_def
)) < 0)
587 /* We couldn't open this font last time. */
590 font_object
= RFONT_DEF_OBJECT (rfont_def
);
591 if (NILP (font_object
))
593 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
596 /* We have not yet opened the font. */
598 /* Find a font best-matching with the spec without checking
599 the support of the character C. That checking is costly,
600 and even without the checking, the found font supports C
601 in high possibility. */
602 font_entity
= font_find_for_lface (f
, face
->lface
,
603 FONT_DEF_SPEC (font_def
), -1);
604 if (NILP (font_entity
))
606 /* Record that no font matches the spec. */
607 RFONT_DEF_SET_FACE (rfont_def
, -1);
610 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
611 FONT_DEF_SPEC (font_def
));
612 if (NILP (font_object
))
614 /* Something strange happened, perhaps because of a
615 Font-backend problem. Too avoid crashing, record
616 that this spec is unsable. It may be better to find
617 another font of the same spec, but currently we don't
619 RFONT_DEF_SET_FACE (rfont_def
, -1);
622 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
625 if (font_has_char (f
, font_object
, c
))
628 /* Find a font already opened, maching with the current spec,
630 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
631 for (i
++; i
< ASIZE (vec
); i
++)
633 rfont_def
= AREF (vec
, i
);
634 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def
), font_def
))
636 font_object
= RFONT_DEF_OBJECT (AREF (vec
, i
));
637 if (! NILP (font_object
) && font_has_char (f
, font_object
, c
))
641 /* Find a font-entity with the current spec and supporting C. */
642 font_entity
= font_find_for_lface (f
, face
->lface
,
643 FONT_DEF_SPEC (font_def
), c
);
644 if (! NILP (font_entity
))
646 /* We found a font. Open it and insert a new element for
651 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
653 if (NILP (font_object
))
655 RFONT_DEF_NEW (rfont_def
, font_def
);
656 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
657 RFONT_DEF_SET_SCORE (rfont_def
, RFONT_DEF_SCORE (rfont_def
));
658 new_vec
= Fmake_vector (make_number (ASIZE (vec
) + 1), Qnil
);
659 for (j
= 0; j
< i
; j
++)
660 ASET (new_vec
, j
, AREF (vec
, j
));
661 ASET (new_vec
, j
, rfont_def
);
662 for (j
++; j
< ASIZE (new_vec
); j
++)
663 ASET (new_vec
, j
, AREF (vec
, j
- 1));
664 XSETCDR (font_group
, new_vec
);
668 /* No font of the current spec for C. Try the next spec. */
672 FONTSET_SET (fontset
, make_number (c
), make_number (0));
678 fontset_font (fontset
, c
, face
, id
)
684 Lisp_Object rfont_def
;
685 Lisp_Object base_fontset
;
687 /* Try a font-group of FONTSET. */
688 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 0);
689 if (VECTORP (rfont_def
))
691 if (EQ (rfont_def
, Qt
))
694 /* Try a font-group of the default fontset. */
695 base_fontset
= FONTSET_BASE (fontset
);
696 if (! EQ (base_fontset
, Vdefault_fontset
))
698 if (NILP (FONTSET_DEFAULT (fontset
)))
699 FONTSET_DEFAULT (fontset
)
700 = make_fontset (FONTSET_FRAME (fontset
), Qnil
, Vdefault_fontset
);
701 rfont_def
= fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 0);
702 if (VECTORP (rfont_def
))
704 if (EQ (rfont_def
, Qt
))
708 /* Try a fallback font-group of FONTSET. */
709 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 1);
710 if (VECTORP (rfont_def
))
712 if (EQ (rfont_def
, Qt
))
715 /* Try a fallback font-group of the default fontset . */
716 if (! EQ (base_fontset
, Vdefault_fontset
))
718 rfont_def
= fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 1);
719 if (VECTORP (rfont_def
))
724 /* Remember that we have no font for C. */
725 FONTSET_SET (fontset
, make_number (c
), Qt
);
730 /* Return a newly created fontset with NAME. If BASE is nil, make a
731 base fontset. Otherwise make a realized fontset whose base is
735 make_fontset (frame
, name
, base
)
736 Lisp_Object frame
, name
, base
;
739 int size
= ASIZE (Vfontset_table
);
740 int id
= next_fontset_id
;
742 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
743 the next available fontset ID. So it is expected that this loop
744 terminates quickly. In addition, as the last element of
745 Vfontset_table is always nil, we don't have to check the range of
747 while (!NILP (AREF (Vfontset_table
, id
))) id
++;
750 Vfontset_table
= larger_vector (Vfontset_table
, size
+ 32, Qnil
);
752 fontset
= Fmake_char_table (Qfontset
, Qnil
);
754 FONTSET_ID (fontset
) = make_number (id
);
757 FONTSET_NAME (fontset
) = name
;
761 FONTSET_NAME (fontset
) = Qnil
;
762 FONTSET_FRAME (fontset
) = frame
;
763 FONTSET_BASE (fontset
) = base
;
766 ASET (Vfontset_table
, id
, fontset
);
767 next_fontset_id
= id
+ 1;
772 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
774 /* Return the name of the fontset who has ID. */
782 fontset
= FONTSET_FROM_ID (id
);
783 return FONTSET_NAME (fontset
);
787 /* Return the ASCII font name of the fontset who has ID. */
793 Lisp_Object fontset
, elt
;
795 fontset
= FONTSET_FROM_ID (id
);
796 elt
= FONTSET_ASCII (fontset
);
803 free_realized_fontset (f
, fontset
)
810 for (tail
= FONTSET_OBJLIST (fontset
); CONSP (tail
); tail
= XCDR (tail
))
812 xassert (FONT_OBJECT_P (XCAR (tail
)));
813 font_close_object (f
, XCAR (tail
));
817 /* Free fontset of FACE defined on frame F. Called from
818 free_realized_face. */
821 free_face_fontset (f
, face
)
827 fontset
= FONTSET_FROM_ID (face
->fontset
);
830 xassert (! BASE_FONTSET_P (fontset
));
831 xassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
832 free_realized_fontset (f
, fontset
);
833 ASET (Vfontset_table
, face
->fontset
, Qnil
);
834 if (face
->fontset
< next_fontset_id
)
835 next_fontset_id
= face
->fontset
;
836 if (! NILP (FONTSET_DEFAULT (fontset
)))
838 int id
= XINT (FONTSET_ID (FONTSET_DEFAULT (fontset
)));
840 fontset
= AREF (Vfontset_table
, id
);
841 xassert (!NILP (fontset
) && ! BASE_FONTSET_P (fontset
));
842 xassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
843 free_realized_fontset (f
, fontset
);
844 ASET (Vfontset_table
, id
, Qnil
);
845 if (id
< next_fontset_id
)
846 next_fontset_id
= face
->fontset
;
852 /* Return 1 if FACE is suitable for displaying character C.
853 Otherwise return 0. Called from the macro FACE_SUITABLE_FOR_CHAR_P
854 when C is not an ASCII character. */
857 face_suitable_for_char_p (face
, c
)
861 Lisp_Object fontset
, rfont_def
;
863 fontset
= FONTSET_FROM_ID (face
->fontset
);
864 rfont_def
= fontset_font (fontset
, c
, NULL
, -1);
865 return (VECTORP (rfont_def
)
866 && INTEGERP (RFONT_DEF_FACE (rfont_def
))
867 && face
->id
== XINT (RFONT_DEF_FACE (rfont_def
)));
871 /* Return ID of face suitable for displaying character C on frame F.
872 FACE must be reazlied for ASCII characters in advance. Called from
873 the macro FACE_FOR_CHAR. */
876 face_for_char (f
, face
, c
, pos
, object
)
882 Lisp_Object fontset
, rfont_def
, charset
;
886 /* If face->fontset is negative (that happens when no font is found
887 for face), just return face->ascii_face because we can't do
888 anything. Perhaps, we should fix the callers to assure
889 that face->fontset is always valid. */
890 if (ASCII_CHAR_P (c
) || face
->fontset
< 0)
891 return face
->ascii_face
->id
;
893 xassert (fontset_id_valid_p (face
->fontset
));
894 fontset
= FONTSET_FROM_ID (face
->fontset
);
895 xassert (!BASE_FONTSET_P (fontset
));
904 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
905 if (CHARSETP (charset
))
909 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
910 if (CONSP (val
) && CHARSETP (XCDR (val
)))
911 charset
= XCDR (val
);
912 id
= XINT (CHARSET_SYMBOL_ID (charset
));
918 font_deferred_log ("font for", Fcons (make_number (c
), charset
), Qnil
);
919 rfont_def
= fontset_font (fontset
, c
, face
, id
);
920 if (VECTORP (rfont_def
))
922 if (INTEGERP (RFONT_DEF_FACE (rfont_def
)))
923 face_id
= XINT (RFONT_DEF_FACE (rfont_def
));
926 Lisp_Object font_object
;
928 font_object
= RFONT_DEF_OBJECT (rfont_def
);
929 face_id
= face_for_font (f
, font_object
, face
);
930 RFONT_DEF_SET_FACE (rfont_def
, face_id
);
935 if (INTEGERP (FONTSET_NOFONT_FACE (fontset
)))
936 face_id
= XINT (FONTSET_NOFONT_FACE (fontset
));
939 face_id
= face_for_font (f
, Qnil
, face
);
940 FONTSET_NOFONT_FACE (fontset
) = make_number (face_id
);
943 xassert (face_id
>= 0);
949 font_for_char (face
, c
, pos
, object
)
954 Lisp_Object fontset
, rfont_def
, charset
;
958 if (ASCII_CHAR_P (c
))
960 Lisp_Object font_object
;
962 XSETFONT (font_object
, face
->ascii_face
->font
);
966 xassert (fontset_id_valid_p (face
->fontset
));
967 fontset
= FONTSET_FROM_ID (face
->fontset
);
968 xassert (!BASE_FONTSET_P (fontset
));
976 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
977 if (CHARSETP (charset
))
981 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
982 if (CONSP (val
) && CHARSETP (XCDR (val
)))
983 charset
= XCDR (val
);
984 id
= XINT (CHARSET_SYMBOL_ID (charset
));
990 font_deferred_log ("font for", Fcons (make_number (c
), charset
), Qnil
);
991 rfont_def
= fontset_font (fontset
, c
, face
, id
);
992 return (VECTORP (rfont_def
)
993 ? RFONT_DEF_OBJECT (rfont_def
)
998 /* Make a realized fontset for ASCII face FACE on frame F from the
999 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1000 default fontset as the base. Value is the id of the new fontset.
1001 Called from realize_x_face. */
1004 make_fontset_for_ascii_face (f
, base_fontset_id
, face
)
1006 int base_fontset_id
;
1009 Lisp_Object base_fontset
, fontset
, frame
;
1011 XSETFRAME (frame
, f
);
1012 if (base_fontset_id
>= 0)
1014 base_fontset
= FONTSET_FROM_ID (base_fontset_id
);
1015 if (!BASE_FONTSET_P (base_fontset
))
1016 base_fontset
= FONTSET_BASE (base_fontset
);
1017 if (! BASE_FONTSET_P (base_fontset
))
1021 base_fontset
= Vdefault_fontset
;
1023 fontset
= make_fontset (frame
, Qnil
, base_fontset
);
1024 return XINT (FONTSET_ID (fontset
));
1029 /* Cache data used by fontset_pattern_regexp. The car part is a
1030 pattern string containing at least one wild card, the cdr part is
1031 the corresponding regular expression. */
1032 static Lisp_Object Vcached_fontset_data
;
1034 #define CACHED_FONTSET_NAME ((char *) SDATA (XCAR (Vcached_fontset_data)))
1035 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1037 /* If fontset name PATTERN contains any wild card, return regular
1038 expression corresponding to PATTERN. */
1041 fontset_pattern_regexp (pattern
)
1042 Lisp_Object pattern
;
1044 if (!index ((char *) SDATA (pattern
), '*')
1045 && !index ((char *) SDATA (pattern
), '?'))
1046 /* PATTERN does not contain any wild cards. */
1049 if (!CONSP (Vcached_fontset_data
)
1050 || strcmp ((char *) SDATA (pattern
), CACHED_FONTSET_NAME
))
1052 /* We must at first update the cached data. */
1053 unsigned char *regex
, *p0
, *p1
;
1054 int ndashes
= 0, nstars
= 0, nescs
= 0;
1056 for (p0
= SDATA (pattern
); *p0
; p0
++)
1060 else if (*p0
== '*')
1063 || *p0
== '.' || *p0
== '\\'
1064 || *p0
== '+' || *p0
== '^'
1069 /* If PATTERN is not full XLFD we conert "*" to ".*". Otherwise
1070 we convert "*" to "[^-]*" which is much faster in regular
1071 expression matching. */
1073 p1
= regex
= (unsigned char *) alloca (SBYTES (pattern
) + 2 * nstars
+ 2 * nescs
+ 1);
1075 p1
= regex
= (unsigned char *) alloca (SBYTES (pattern
) + 5 * nstars
+ 2 * nescs
+ 1);
1078 for (p0
= SDATA (pattern
); *p0
; p0
++)
1085 *p1
++ = '[', *p1
++ = '^', *p1
++ = '-', *p1
++ = ']';
1088 else if (*p0
== '?')
1091 || *p0
== '.' || *p0
== '\\'
1092 || *p0
== '+' || *p0
== '^'
1094 *p1
++ = '\\', *p1
++ = *p0
;
1101 Vcached_fontset_data
= Fcons (build_string ((char *) SDATA (pattern
)),
1102 build_string ((char *) regex
));
1105 return CACHED_FONTSET_REGEX
;
1108 /* Return ID of the base fontset named NAME. If there's no such
1109 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1110 0: pattern containing '*' and '?' as wildcards
1111 1: regular expression
1112 2: literal fontset name
1116 fs_query_fontset (name
, name_pattern
)
1123 name
= Fdowncase (name
);
1124 if (name_pattern
!= 1)
1126 tem
= Frassoc (name
, Vfontset_alias_alist
);
1128 tem
= Fassoc (name
, Vfontset_alias_alist
);
1129 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1131 else if (name_pattern
== 0)
1133 tem
= fontset_pattern_regexp (name
);
1142 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1144 Lisp_Object fontset
, this_name
;
1146 fontset
= FONTSET_FROM_ID (i
);
1148 || !BASE_FONTSET_P (fontset
))
1151 this_name
= FONTSET_NAME (fontset
);
1152 if (name_pattern
== 1
1153 ? fast_string_match_ignore_case (name
, this_name
) >= 0
1154 : !xstrcasecmp (SDATA (name
), SDATA (this_name
)))
1161 DEFUN ("query-fontset", Fquery_fontset
, Squery_fontset
, 1, 2, 0,
1162 doc
: /* Return the name of a fontset that matches PATTERN.
1163 The value is nil if there is no matching fontset.
1164 PATTERN can contain `*' or `?' as a wildcard
1165 just as X font name matching algorithm allows.
1166 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1168 Lisp_Object pattern
, regexpp
;
1170 Lisp_Object fontset
;
1173 (*check_window_system_func
) ();
1175 CHECK_STRING (pattern
);
1177 if (SCHARS (pattern
) == 0)
1180 id
= fs_query_fontset (pattern
, !NILP (regexpp
));
1184 fontset
= FONTSET_FROM_ID (id
);
1185 return FONTSET_NAME (fontset
);
1188 /* Return a list of base fontset names matching PATTERN on frame F. */
1191 list_fontsets (f
, pattern
, size
)
1193 Lisp_Object pattern
;
1196 Lisp_Object frame
, regexp
, val
;
1199 XSETFRAME (frame
, f
);
1201 regexp
= fontset_pattern_regexp (pattern
);
1204 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1206 Lisp_Object fontset
, name
;
1208 fontset
= FONTSET_FROM_ID (id
);
1210 || !BASE_FONTSET_P (fontset
)
1211 || !EQ (frame
, FONTSET_FRAME (fontset
)))
1213 name
= FONTSET_NAME (fontset
);
1215 if (STRINGP (regexp
)
1216 ? (fast_string_match (regexp
, name
) < 0)
1217 : strcmp ((char *) SDATA (pattern
), (char *) SDATA (name
)))
1220 val
= Fcons (Fcopy_sequence (FONTSET_NAME (fontset
)), val
);
1227 /* Free all realized fontsets whose base fontset is BASE. */
1230 free_realized_fontsets (base
)
1236 /* For the moment, this doesn't work because free_realized_face
1237 doesn't remove FACE from a cache. Until we find a solution, we
1238 suppress this code, and simply use Fclear_face_cache even though
1239 that is not efficient. */
1241 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1243 Lisp_Object
this = AREF (Vfontset_table
, id
);
1245 if (EQ (FONTSET_BASE (this), base
))
1249 for (tail
= FONTSET_FACE_ALIST (this); CONSP (tail
);
1252 FRAME_PTR f
= XFRAME (FONTSET_FRAME (this));
1253 int face_id
= XINT (XCDR (XCAR (tail
)));
1254 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1256 /* Face THIS itself is also freed by the following call. */
1257 free_realized_face (f
, face
);
1263 /* But, we don't have to call Fclear_face_cache if no fontset has
1264 been realized from BASE. */
1265 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1267 Lisp_Object
this = AREF (Vfontset_table
, id
);
1269 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base
))
1271 Fclear_face_cache (Qt
);
1279 /* Check validity of NAME as a fontset name and return the
1280 corresponding fontset. If not valid, signal an error.
1282 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1285 Set *FRAME to the actual frame. */
1288 check_fontset_name (name
, frame
)
1289 Lisp_Object name
, *frame
;
1294 *frame
= selected_frame
;
1295 CHECK_LIVE_FRAME (*frame
);
1298 return Vdefault_fontset
;
1301 id
= FRAME_FONTSET (XFRAME (*frame
));
1305 CHECK_STRING (name
);
1306 /* First try NAME as literal. */
1307 id
= fs_query_fontset (name
, 2);
1309 /* For backward compatibility, try again NAME as pattern. */
1310 id
= fs_query_fontset (name
, 0);
1312 error ("Fontset `%s' does not exist", SDATA (name
));
1314 return FONTSET_FROM_ID (id
);
1318 accumulate_script_ranges (arg
, range
, val
)
1319 Lisp_Object arg
, range
, val
;
1321 if (EQ (XCAR (arg
), val
))
1324 XSETCDR (arg
, Fcons (Fcons (XCAR (range
), XCDR (range
)), XCDR (arg
)));
1326 XSETCDR (arg
, Fcons (Fcons (range
, range
), XCDR (arg
)));
1331 /* Return an ASCII font name generated from fontset name NAME and
1332 font-spec ASCII_SPEC. NAME is a string conforming to XLFD. */
1334 static INLINE Lisp_Object
1335 generate_ascii_font_name (name
, ascii_spec
)
1336 Lisp_Object name
, ascii_spec
;
1338 Lisp_Object font_spec
= Ffont_spec (0, NULL
);
1342 if (font_parse_xlfd ((char *) SDATA (name
), font_spec
) < 0)
1343 error ("Not an XLFD font name: %s", SDATA (name
));
1344 for (i
= FONT_FOUNDRY_INDEX
; i
< FONT_EXTRA_INDEX
; i
++)
1345 if (! NILP (AREF (ascii_spec
, i
)))
1346 ASET (font_spec
, i
, AREF (ascii_spec
, i
));
1347 i
= font_unparse_xlfd (font_spec
, 0, xlfd
, 256);
1349 error ("Not an XLFD font name: %s", SDATA (name
));
1350 return make_unibyte_string (xlfd
, i
);
1353 /* Callback function for map_charset_chars in Fset_fontset_font.
1354 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1356 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1357 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1358 The consumed ranges are poped up from SCRIPT_RANGE_LIST, and the
1359 new SCRIPT_RANGE_LIST is stored in ARG.
1361 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1362 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1366 set_fontset_font (arg
, range
)
1367 Lisp_Object arg
, range
;
1369 Lisp_Object fontset
, font_def
, add
, ascii
, script_range_list
;
1370 int from
= XINT (XCAR (range
)), to
= XINT (XCDR (range
));
1372 fontset
= AREF (arg
, 0);
1373 font_def
= AREF (arg
, 1);
1374 add
= AREF (arg
, 2);
1375 ascii
= AREF (arg
, 3);
1376 script_range_list
= AREF (arg
, 4);
1378 if (NILP (ascii
) && from
< 0x80)
1383 range
= Fcons (make_number (0x80), XCDR (range
));
1386 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1387 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1388 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1390 for (; CONSP (script_range_list
) && SCRIPT_TO
< from
; POP_SCRIPT_RANGE ())
1391 FONTSET_ADD (fontset
, XCAR (script_range_list
), font_def
, add
);
1392 if (CONSP (script_range_list
))
1394 if (SCRIPT_FROM
< from
)
1395 range
= Fcons (make_number (SCRIPT_FROM
), XCDR (range
));
1396 while (CONSP (script_range_list
) && SCRIPT_TO
<= to
)
1397 POP_SCRIPT_RANGE ();
1398 if (CONSP (script_range_list
) && SCRIPT_FROM
<= to
)
1399 XSETCAR (XCAR (script_range_list
), make_number (to
+ 1));
1402 FONTSET_ADD (fontset
, range
, font_def
, add
);
1403 ASET (arg
, 4, script_range_list
);
1406 extern Lisp_Object QCfamily
, QCregistry
;
1407 static void update_auto_fontset_alist
P_ ((Lisp_Object
, Lisp_Object
));
1410 DEFUN ("set-fontset-font", Fset_fontset_font
, Sset_fontset_font
, 3, 5, 0,
1412 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1414 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1415 the default fontset.
1417 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1418 In that case, use FONT-SPEC for all characters in the range FROM and
1421 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1422 all characters that belong to the script.
1424 TARGET may be a charset. In that case, use FONT-SPEC for all
1425 characters in the charset.
1427 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1428 that no FONT-SPEC is specified.
1430 FONT-SPEC may one of these:
1431 * A font-spec object made by the function `font-spec' (which see).
1432 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1433 REGISTRY is a font registry name. FAMILY may contain foundry
1434 name, and REGISTRY may contain encoding name.
1435 * A font name string.
1436 * nil, which explicitly specifies that there's no font for TARGET.
1438 Optional 4th argument FRAME is a frame or nil for the selected frame
1439 that is concerned in the case that NAME is nil.
1441 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1442 to the font specifications for TARGET previously set. If it is
1443 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1444 appended. By default, FONT-SPEC overrides the previous settings. */)
1445 (name
, target
, font_spec
, frame
, add
)
1446 Lisp_Object name
, target
, font_spec
, frame
, add
;
1448 Lisp_Object fontset
;
1449 Lisp_Object font_def
, registry
, family
;
1450 Lisp_Object range_list
;
1451 struct charset
*charset
= NULL
;
1452 Lisp_Object fontname
;
1453 int ascii_changed
= 0;
1455 fontset
= check_fontset_name (name
, &frame
);
1458 if (CONSP (font_spec
))
1460 Lisp_Object spec
= Ffont_spec (0, NULL
);
1462 font_parse_family_registry (XCAR (font_spec
), XCDR (font_spec
), spec
);
1464 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1466 else if (STRINGP (font_spec
))
1468 Lisp_Object args
[2];
1469 extern Lisp_Object QCname
;
1471 fontname
= font_spec
;
1473 args
[1] = font_spec
;
1474 font_spec
= Ffont_spec (2, args
);
1476 else if (FONT_SPEC_P (font_spec
))
1477 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1478 else if (! NILP (font_spec
))
1479 Fsignal (Qfont
, list2 (build_string ("Invalid font-spec"), font_spec
));
1481 if (! NILP (font_spec
))
1483 Lisp_Object encoding
, repertory
;
1485 family
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1486 if (! NILP (family
) )
1487 family
= SYMBOL_NAME (family
);
1488 registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1489 if (! NILP (registry
))
1490 registry
= Fdowncase (SYMBOL_NAME (registry
));
1491 encoding
= find_font_encoding (concat3 (family
, build_string ("-"),
1493 if (NILP (encoding
))
1496 if (SYMBOLP (encoding
))
1498 CHECK_CHARSET (encoding
);
1499 encoding
= repertory
= CHARSET_SYMBOL_ID (encoding
);
1503 repertory
= XCDR (encoding
);
1504 encoding
= XCAR (encoding
);
1505 CHECK_CHARSET (encoding
);
1506 encoding
= CHARSET_SYMBOL_ID (encoding
);
1507 if (! NILP (repertory
) && SYMBOLP (repertory
))
1509 CHECK_CHARSET (repertory
);
1510 repertory
= CHARSET_SYMBOL_ID (repertory
);
1513 FONT_DEF_NEW (font_def
, font_spec
, encoding
, repertory
);
1518 if (CHARACTERP (target
))
1520 if (XFASTINT (target
) < 0x80)
1521 error ("Can't set a font for partial ASCII range.");
1522 range_list
= Fcons (Fcons (target
, target
), Qnil
);
1524 else if (CONSP (target
))
1526 Lisp_Object from
, to
;
1528 from
= Fcar (target
);
1530 CHECK_CHARACTER (from
);
1531 CHECK_CHARACTER (to
);
1532 if (XFASTINT (from
) < 0x80)
1534 if (XFASTINT (from
) != 0 || XFASTINT (to
) < 0x7F)
1535 error ("Can't set a font for partial ASCII range.");
1538 range_list
= Fcons (target
, Qnil
);
1540 else if (SYMBOLP (target
) && !NILP (target
))
1542 Lisp_Object script_list
;
1546 script_list
= XCHAR_TABLE (Vchar_script_table
)->extras
[0];
1547 if (! NILP (Fmemq (target
, script_list
)))
1549 if (EQ (target
, Qlatin
))
1551 val
= Fcons (target
, Qnil
);
1552 map_char_table (accumulate_script_ranges
, Qnil
, Vchar_script_table
,
1554 range_list
= Fnreverse (XCDR (val
));
1556 if (CHARSETP (target
))
1558 CHECK_CHARSET_GET_CHARSET (target
, charset
);
1559 if (charset
->ascii_compatible_p
)
1562 else if (NILP (range_list
))
1563 error ("Invalid script or charset name: %s",
1564 SDATA (SYMBOL_NAME (target
)));
1566 else if (NILP (target
))
1567 range_list
= Fcons (Qnil
, Qnil
);
1569 error ("Invalid target for setting a font");
1575 if (NILP (font_spec
))
1576 error ("Can't set ASCII font to nil");
1577 val
= CHAR_TABLE_REF (fontset
, 0);
1578 if (! NILP (val
) && EQ (add
, Qappend
))
1579 /* We are going to change just an additional font for ASCII. */
1587 arg
= Fmake_vector (make_number (5), Qnil
);
1588 ASET (arg
, 0, fontset
);
1589 ASET (arg
, 1, font_def
);
1591 ASET (arg
, 3, ascii_changed
? Qt
: Qnil
);
1592 ASET (arg
, 4, range_list
);
1594 map_charset_chars (set_fontset_font
, Qnil
, arg
, charset
,
1595 CHARSET_MIN_CODE (charset
),
1596 CHARSET_MAX_CODE (charset
));
1597 range_list
= AREF (arg
, 4);
1599 for (; CONSP (range_list
); range_list
= XCDR (range_list
))
1600 FONTSET_ADD (fontset
, XCAR (range_list
), font_def
, add
);
1604 Lisp_Object tail
, frame
, alist
;
1605 int fontset_id
= XINT (FONTSET_ID (fontset
));
1607 FONTSET_ASCII (fontset
) = fontname
;
1608 name
= FONTSET_NAME (fontset
);
1609 FOR_EACH_FRAME (tail
, frame
)
1611 FRAME_PTR f
= XFRAME (frame
);
1612 Lisp_Object font_object
;
1615 if (FRAME_INITIAL_P (f
) || FRAME_TERMCAP_P (f
))
1617 if (fontset_id
!= FRAME_FONTSET (f
))
1619 face
= FACE_FROM_ID (f
, DEFAULT_FACE_ID
);
1621 font_object
= font_load_for_lface (f
, face
->lface
, font_spec
);
1623 font_object
= font_open_by_spec (f
, font_spec
);
1624 if (! NILP (font_object
))
1626 update_auto_fontset_alist (font_object
, fontset
);
1627 alist
= Fcons (Fcons (Qfont
, Fcons (name
, font_object
)), Qnil
);
1628 Fmodify_frame_parameters (frame
, alist
);
1633 /* Free all realized fontsets whose base is FONTSET. This way, the
1634 specified character(s) are surely redisplayed by a correct
1636 free_realized_fontsets (fontset
);
1642 DEFUN ("new-fontset", Fnew_fontset
, Snew_fontset
, 2, 2, 0,
1643 doc
: /* Create a new fontset NAME from font information in FONTLIST.
1645 FONTLIST is an alist of scripts vs the corresponding font specification list.
1646 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1647 character of SCRIPT is displayed by a font that matches one of
1650 SCRIPT is a symbol that appears in the first extra slot of the
1651 char-table `char-script-table'.
1653 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1654 `set-fontset-font' for the meaning. */)
1656 Lisp_Object name
, fontlist
;
1658 Lisp_Object fontset
;
1661 CHECK_STRING (name
);
1662 CHECK_LIST (fontlist
);
1664 name
= Fdowncase (name
);
1665 id
= fs_query_fontset (name
, 0);
1668 Lisp_Object font_spec
= Ffont_spec (0, NULL
);
1669 Lisp_Object short_name
;
1673 if (font_parse_xlfd ((char *) SDATA (name
), font_spec
) < 0)
1674 error ("Fontset name must be in XLFD format");
1675 short_name
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1676 if (strncmp ((char *) SDATA (SYMBOL_NAME (short_name
)), "fontset-", 8)
1677 || SBYTES (SYMBOL_NAME (short_name
)) < 9)
1678 error ("Registry field of fontset name must be \"fontset-*\"");
1679 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (short_name
)),
1680 Vfontset_alias_alist
);
1681 ASET (font_spec
, FONT_REGISTRY_INDEX
, Qiso8859_1
);
1682 fontset
= make_fontset (Qnil
, name
, Qnil
);
1683 len
= font_unparse_xlfd (font_spec
, 0, xlfd
, 256);
1685 error ("Invalid fontset name (perhaps too long): %s", SDATA (name
));
1686 FONTSET_ASCII (fontset
) = make_unibyte_string (xlfd
, len
);
1690 fontset
= FONTSET_FROM_ID (id
);
1691 free_realized_fontsets (fontset
);
1692 Fset_char_table_range (fontset
, Qt
, Qnil
);
1695 for (; ! NILP (fontlist
); fontlist
= Fcdr (fontlist
))
1697 Lisp_Object elt
, script
;
1699 elt
= Fcar (fontlist
);
1700 script
= Fcar (elt
);
1702 if (CONSP (elt
) && (NILP (XCDR (elt
)) || CONSP (XCDR (elt
))))
1703 for (; CONSP (elt
); elt
= XCDR (elt
))
1704 Fset_fontset_font (name
, script
, XCAR (elt
), Qnil
, Qappend
);
1706 Fset_fontset_font (name
, script
, elt
, Qnil
, Qappend
);
1712 /* Alist of automatically created fontsets. Each element is a cons
1713 (FONT-SPEC . FONTSET-ID). */
1714 static Lisp_Object auto_fontset_alist
;
1716 /* Number of automatically created fontsets. */
1717 static int num_auto_fontsets
;
1719 /* Retun a fontset synthesized from FONT-OBJECT. This is called from
1720 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1721 frame, and the returned fontset is used for the default fontset of
1722 that frame. The fontset specifies a font of the same registry as
1723 FONT-OBJECT for all characters in the repertory of the registry
1724 (see Vfont_encoding_alist). If the repertory is not known, the
1725 fontset specifies the font for all Latin characters assuming that a
1726 user intends to use FONT-OBJECT for Latin characters. */
1729 fontset_from_font (font_object
)
1730 Lisp_Object font_object
;
1732 Lisp_Object font_name
= font_get_name (font_object
);
1733 Lisp_Object font_spec
= Fcopy_font_spec (font_object
);
1734 Lisp_Object registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1735 Lisp_Object fontset_spec
, alias
, name
, fontset
;
1739 val
= assoc_no_quit (font_spec
, auto_fontset_alist
);
1741 return XINT (FONTSET_ID (XCDR (val
)));
1742 if (num_auto_fontsets
++ == 0)
1743 alias
= intern ("fontset-startup");
1748 sprintf (temp
, "fontset-auto%d", num_auto_fontsets
- 1);
1749 alias
= intern (temp
);
1751 fontset_spec
= Fcopy_font_spec (font_spec
);
1752 ASET (fontset_spec
, FONT_REGISTRY_INDEX
, alias
);
1753 name
= Ffont_xlfd_name (fontset_spec
, Qnil
);
1756 fontset
= make_fontset (Qnil
, name
, Qnil
);
1757 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (alias
)),
1758 Vfontset_alias_alist
);
1759 alias
= Fdowncase (AREF (font_object
, FONT_NAME_INDEX
));
1760 Vfontset_alias_alist
= Fcons (Fcons (name
, alias
), Vfontset_alias_alist
);
1761 auto_fontset_alist
= Fcons (Fcons (font_spec
, fontset
), auto_fontset_alist
);
1762 font_spec
= Ffont_spec (0, NULL
);
1763 ASET (font_spec
, FONT_REGISTRY_INDEX
, registry
);
1765 Lisp_Object target
= find_font_encoding (SYMBOL_NAME (registry
));
1768 target
= XCDR (target
);
1769 if (! CHARSETP (target
))
1771 Fset_fontset_font (name
, target
, font_spec
, Qnil
, Qnil
);
1772 Fset_fontset_font (name
, Qnil
, font_spec
, Qnil
, Qnil
);
1775 FONTSET_ASCII (fontset
) = font_name
;
1778 nsfont_make_fontset_for_font(name
, font_object
);
1781 return XINT (FONTSET_ID (fontset
));
1785 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1786 FONTSET is changed, we delete an entry of FONTSET if any from
1787 auto_fontset_alist so that FONTSET is not re-used by
1788 fontset_from_font. */
1791 update_auto_fontset_alist (font_object
, fontset
)
1792 Lisp_Object font_object
, fontset
;
1794 Lisp_Object prev
, tail
;
1796 for (prev
= Qnil
, tail
= auto_fontset_alist
; CONSP (tail
);
1797 prev
= tail
, tail
= XCDR (tail
))
1798 if (EQ (fontset
, XCDR (XCAR (tail
))))
1801 auto_fontset_alist
= XCDR (tail
);
1803 XSETCDR (prev
, XCDR (tail
));
1809 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1810 FONT-OBJECT is the font for the character at POSITION in the current
1811 buffer. This is computed from all the text properties and overlays
1812 that apply to POSITION. POSTION may be nil, in which case,
1813 FONT-SPEC is the font for displaying the character CH with the
1816 GLYPH-CODE is the glyph code in the font to use for the character.
1818 If the 2nd optional arg CH is non-nil, it is a character to check
1819 the font instead of the character at POSITION.
1821 It returns nil in the following cases:
1823 (1) The window system doesn't have a font for the character (thus
1824 it is displayed by an empty box).
1826 (2) The character code is invalid.
1828 (3) If POSITION is not nil, and the current buffer is not displayed
1831 In addition, the returned font name may not take into account of
1832 such redisplay engine hooks as what used in jit-lock-mode if
1833 POSITION is currently not visible. */
1836 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1837 doc
: /* For internal use only. */)
1839 Lisp_Object position
, ch
;
1841 EMACS_INT pos
, pos_byte
, dummy
;
1848 if (NILP (position
))
1850 CHECK_CHARACTER (ch
);
1852 f
= XFRAME (selected_frame
);
1853 face_id
= lookup_basic_face (f
, DEFAULT_FACE_ID
);
1859 Lisp_Object window
, charset
;
1862 CHECK_NUMBER_COERCE_MARKER (position
);
1863 pos
= XINT (position
);
1864 if (pos
< BEGV
|| pos
>= ZV
)
1865 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1866 pos_byte
= CHAR_TO_BYTE (pos
);
1868 c
= FETCH_CHAR (pos_byte
);
1874 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1877 w
= XWINDOW (window
);
1878 f
= XFRAME (w
->frame
);
1879 face_id
= face_at_buffer_position (w
, pos
, -1, -1, &dummy
,
1881 charset
= Fget_char_property (position
, Qcharset
, Qnil
);
1882 if (CHARSETP (charset
))
1883 cs_id
= XINT (CHARSET_SYMBOL_ID (charset
));
1887 if (! CHAR_VALID_P (c
, 0))
1889 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
, pos
, Qnil
);
1890 face
= FACE_FROM_ID (f
, face_id
);
1893 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
1894 Lisp_Object font_object
;
1895 /* Assignment to EMACS_INT stops GCC whining about limited range
1897 EMACS_INT cod
= code
;
1899 if (code
== FONT_INVALID_CODE
)
1901 XSETFONT (font_object
, face
->font
);
1902 if (cod
<= MOST_POSITIVE_FIXNUM
)
1903 return Fcons (font_object
, make_number (code
));
1904 return Fcons (font_object
, Fcons (make_number (code
>> 16),
1905 make_number (code
& 0xFFFF)));
1911 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1912 doc
: /* Return information about a fontset FONTSET on frame FRAME.
1914 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1915 for the default fontset. FRAME nil means the selected frame.
1917 The value is a char-table whose elements have this form:
1919 ((FONT OPENED-FONT ...) ...)
1921 FONT is a name of font specified for a range of characters.
1923 OPENED-FONT is a name of a font actually opened.
1925 The char-table has one extra slot. If FONTSET is not the default
1926 fontset, the value the extra slot is a char-table containing the
1927 information about the derived fonts from the default fontset. The
1928 format is the same as above. */)
1930 Lisp_Object fontset
, frame
;
1933 Lisp_Object
*realized
[2], fontsets
[2], tables
[2];
1934 Lisp_Object val
, elt
;
1937 (*check_window_system_func
) ();
1939 fontset
= check_fontset_name (fontset
, &frame
);
1942 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1943 in the table `realized'. */
1944 realized
[0] = (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1945 * ASIZE (Vfontset_table
));
1946 for (i
= j
= 0; i
< ASIZE (Vfontset_table
); i
++)
1948 elt
= FONTSET_FROM_ID (i
);
1950 && EQ (FONTSET_BASE (elt
), fontset
)
1951 && EQ (FONTSET_FRAME (elt
), frame
))
1952 realized
[0][j
++] = elt
;
1954 realized
[0][j
] = Qnil
;
1956 realized
[1] = (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1957 * ASIZE (Vfontset_table
));
1958 for (i
= j
= 0; ! NILP (realized
[0][i
]); i
++)
1960 elt
= FONTSET_DEFAULT (realized
[0][i
]);
1962 realized
[1][j
++] = elt
;
1964 realized
[1][j
] = Qnil
;
1966 tables
[0] = Fmake_char_table (Qfontset_info
, Qnil
);
1967 fontsets
[0] = fontset
;
1968 if (!EQ (fontset
, Vdefault_fontset
))
1970 tables
[1] = Fmake_char_table (Qnil
, Qnil
);
1971 XCHAR_TABLE (tables
[0])->extras
[0] = tables
[1];
1972 fontsets
[1] = Vdefault_fontset
;
1975 /* Accumulate information of the fontset in TABLE. The format of
1976 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1977 for (k
= 0; k
<= 1; k
++)
1979 for (c
= 0; c
<= MAX_CHAR
; )
1981 int from
= c
, to
= MAX_5_BYTE_CHAR
;
1983 if (c
<= MAX_5_BYTE_CHAR
)
1985 val
= char_table_ref_and_range (fontsets
[k
], c
, &from
, &to
);
1989 val
= FONTSET_FALLBACK (fontsets
[k
]);
1996 /* At first, set ALIST to ((FONT-SPEC) ...). */
1997 for (alist
= Qnil
, i
= 0; i
< ASIZE (val
); i
++)
1998 if (! NILP (AREF (val
, i
)))
1999 alist
= Fcons (Fcons (FONT_DEF_SPEC (AREF (val
, i
)), Qnil
),
2001 alist
= Fnreverse (alist
);
2003 /* Then store opened font names to cdr of each elements. */
2004 for (i
= 0; ! NILP (realized
[k
][i
]); i
++)
2006 if (c
<= MAX_5_BYTE_CHAR
)
2007 val
= FONTSET_REF (realized
[k
][i
], c
);
2009 val
= FONTSET_FALLBACK (realized
[k
][i
]);
2010 if (! CONSP (val
) || ! VECTORP (XCDR (val
)))
2012 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
2014 for (j
= 0; j
< ASIZE (val
); j
++)
2016 elt
= AREF (val
, j
);
2017 if (FONT_OBJECT_P (RFONT_DEF_OBJECT (elt
)))
2019 Lisp_Object font_object
= RFONT_DEF_OBJECT (elt
);
2020 Lisp_Object slot
, name
;
2022 slot
= Fassq (RFONT_DEF_SPEC (elt
), alist
);
2023 name
= AREF (font_object
, FONT_NAME_INDEX
);
2024 if (NILP (Fmember (name
, XCDR (slot
))))
2025 nconc2 (slot
, Fcons (name
, Qnil
));
2030 /* Store ALIST in TBL for characters C..TO. */
2031 if (c
<= MAX_5_BYTE_CHAR
)
2032 char_table_set_range (tables
[k
], c
, to
, alist
);
2034 XCHAR_TABLE (tables
[k
])->defalt
= alist
;
2036 /* At last, change each elements to font names. */
2037 for (; CONSP (alist
); alist
= XCDR (alist
))
2040 XSETCAR (elt
, Ffont_xlfd_name (XCAR (elt
), Qnil
));
2045 if (EQ (fontset
, Vdefault_fontset
))
2053 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 3, 0,
2054 doc
: /* Return a font name pattern for character CH in fontset NAME.
2055 If NAME is t, find a pattern in the default fontset.
2057 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2058 family name and REGISTRY is a font registry name. This is actually
2059 the first font name pattern for CH in the fontset or in the default
2062 If the 2nd optional arg ALL is non-nil, return a list of all font name
2065 Lisp_Object name
, ch
, all
;
2068 Lisp_Object fontset
, elt
, list
, repertory
, val
;
2073 fontset
= check_fontset_name (name
, &frame
);
2075 CHECK_CHARACTER (ch
);
2080 for (i
= 0, elt
= FONTSET_REF (fontset
, c
); i
< 2;
2081 i
++, elt
= FONTSET_FALLBACK (fontset
))
2083 for (j
= 0; j
< ASIZE (elt
); j
++)
2085 Lisp_Object family
, registry
;
2087 val
= AREF (elt
, j
);
2088 repertory
= AREF (val
, 1);
2089 if (INTEGERP (repertory
))
2091 struct charset
*charset
= CHARSET_FROM_ID (XINT (repertory
));
2093 if (! CHAR_CHARSET_P (c
, charset
))
2096 else if (CHAR_TABLE_P (repertory
))
2098 if (NILP (CHAR_TABLE_REF (repertory
, c
)))
2101 val
= AREF (val
, 0);
2102 /* VAL is a FONT-SPEC */
2103 family
= AREF (val
, FONT_FAMILY_INDEX
);
2104 if (! NILP (family
))
2105 family
= SYMBOL_NAME (family
);
2106 registry
= AREF (val
, FONT_REGISTRY_INDEX
);
2107 if (! NILP (registry
))
2108 registry
= SYMBOL_NAME (registry
);
2109 val
= Fcons (family
, registry
);
2112 list
= Fcons (val
, list
);
2114 if (EQ (fontset
, Vdefault_fontset
))
2116 fontset
= Vdefault_fontset
;
2118 return (Fnreverse (list
));
2121 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
2122 doc
: /* Return a list of all defined fontset names. */)
2125 Lisp_Object fontset
, list
;
2129 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
2131 fontset
= FONTSET_FROM_ID (i
);
2133 && BASE_FONTSET_P (fontset
))
2134 list
= Fcons (FONTSET_NAME (fontset
), list
);
2141 #ifdef FONTSET_DEBUG
2144 dump_fontset (fontset
)
2145 Lisp_Object fontset
;
2149 vec
= Fmake_vector (make_number (3), Qnil
);
2150 ASET (vec
, 0, FONTSET_ID (fontset
));
2152 if (BASE_FONTSET_P (fontset
))
2154 ASET (vec
, 1, FONTSET_NAME (fontset
));
2160 frame
= FONTSET_FRAME (fontset
);
2163 FRAME_PTR f
= XFRAME (frame
);
2165 if (FRAME_LIVE_P (f
))
2167 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), f
->name
));
2170 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), Qnil
));
2172 if (!NILP (FONTSET_DEFAULT (fontset
)))
2173 ASET (vec
, 2, FONTSET_ID (FONTSET_DEFAULT (fontset
)));
2178 DEFUN ("fontset-list-all", Ffontset_list_all
, Sfontset_list_all
, 0, 0, 0,
2179 doc
: /* Return a brief summary of all fontsets for debug use. */)
2185 for (i
= 0, val
= Qnil
; i
< ASIZE (Vfontset_table
); i
++)
2186 if (! NILP (AREF (Vfontset_table
, i
)))
2187 val
= Fcons (dump_fontset (AREF (Vfontset_table
, i
)), val
);
2188 return (Fnreverse (val
));
2190 #endif /* FONTSET_DEBUG */
2195 DEFSYM (Qfontset
, "fontset");
2196 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (9));
2197 DEFSYM (Qfontset_info
, "fontset-info");
2198 Fput (Qfontset_info
, Qchar_table_extra_slots
, make_number (1));
2200 DEFSYM (Qprepend
, "prepend");
2201 DEFSYM (Qappend
, "append");
2202 DEFSYM (Qlatin
, "latin");
2204 Vcached_fontset_data
= Qnil
;
2205 staticpro (&Vcached_fontset_data
);
2207 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
2208 staticpro (&Vfontset_table
);
2210 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
2211 staticpro (&Vdefault_fontset
);
2212 FONTSET_ID (Vdefault_fontset
) = make_number (0);
2213 FONTSET_NAME (Vdefault_fontset
)
2214 = build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
2215 ASET (Vfontset_table
, 0, Vdefault_fontset
);
2216 next_fontset_id
= 1;
2218 auto_fontset_alist
= Qnil
;
2219 staticpro (&auto_fontset_alist
);
2221 DEFVAR_LISP ("font-encoding-charset-alist", &Vfont_encoding_charset_alist
,
2223 Alist of charsets vs the charsets to determine the preferred font encoding.
2224 Each element looks like (CHARSET . ENCODING-CHARSET),
2225 where ENCODING-CHARSET is a charset registered in the variable
2226 `font-encoding-alist' as ENCODING.
2228 When a text has a property `charset' and the value is CHARSET, a font
2229 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2230 Vfont_encoding_charset_alist
= Qnil
;
2232 DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent
,
2234 Char table of characters whose ascent values should be ignored.
2235 If an entry for a character is non-nil, the ascent value of the glyph
2236 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2238 This affects how a composite character which contains
2239 such a character is displayed on screen. */);
2240 Vuse_default_ascent
= Qnil
;
2242 DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition
,
2244 Char table of characters which are not composed relatively.
2245 If an entry for a character is non-nil, a composition sequence
2246 which contains that character is displayed so that
2247 the glyph of that character is put without considering
2248 an ascent and descent value of a previous character. */);
2249 Vignore_relative_composition
= Qnil
;
2251 DEFVAR_LISP ("alternate-fontname-alist", &Valternate_fontname_alist
,
2252 doc
: /* Alist of fontname vs list of the alternate fontnames.
2253 When a specified font name is not found, the corresponding
2254 alternate fontnames (if any) are tried instead. */);
2255 Valternate_fontname_alist
= Qnil
;
2257 DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist
,
2258 doc
: /* Alist of fontset names vs the aliases. */);
2259 Vfontset_alias_alist
= Fcons (Fcons (FONTSET_NAME (Vdefault_fontset
),
2260 build_string ("fontset-default")),
2263 DEFVAR_LISP ("vertical-centering-font-regexp",
2264 &Vvertical_centering_font_regexp
,
2265 doc
: /* *Regexp matching font names that require vertical centering on display.
2266 When a character is displayed with such fonts, the character is displayed
2267 at the vertical center of lines. */);
2268 Vvertical_centering_font_regexp
= Qnil
;
2270 DEFVAR_LISP ("otf-script-alist", &Votf_script_alist
,
2271 doc
: /* Alist of OpenType script tags vs the corresponding script names. */);
2272 Votf_script_alist
= Qnil
;
2274 defsubr (&Squery_fontset
);
2275 defsubr (&Snew_fontset
);
2276 defsubr (&Sset_fontset_font
);
2277 defsubr (&Sinternal_char_font
);
2278 defsubr (&Sfontset_info
);
2279 defsubr (&Sfontset_font
);
2280 defsubr (&Sfontset_list
);
2281 #ifdef FONTSET_DEBUG
2282 defsubr (&Sfontset_list_all
);
2286 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
2287 (do not change this comment) */