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 single character to use FONT-SPEC for.
1416 Target may be a cons (FROM . TO), where FROM and TO are characters.
1417 In that case, use FONT-SPEC for all characters in the range FROM
1420 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1421 all characters that belong to the script.
1423 TARGET may be a charset. In that case, use FONT-SPEC for all
1424 characters in the charset.
1426 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1427 that no FONT-SPEC is specified.
1429 FONT-SPEC may one of these:
1430 * A font-spec object made by the function `font-spec' (which see).
1431 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1432 REGISTRY is a font registry name. FAMILY may contain foundry
1433 name, and REGISTRY may contain encoding name.
1434 * A font name string.
1435 * nil, which explicitly specifies that there's no font for TARGET.
1437 Optional 4th argument FRAME is a frame or nil for the selected frame
1438 that is concerned in the case that NAME is nil.
1440 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1441 to the font specifications for TARGET previously set. If it is
1442 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1443 appended. By default, FONT-SPEC overrides the previous settings. */)
1444 (Lisp_Object name
, Lisp_Object target
, Lisp_Object font_spec
, Lisp_Object frame
, Lisp_Object add
)
1446 Lisp_Object fontset
;
1447 Lisp_Object font_def
, registry
, family
;
1448 Lisp_Object range_list
;
1449 struct charset
*charset
= NULL
;
1450 Lisp_Object fontname
;
1451 bool ascii_changed
= 0;
1453 fontset
= check_fontset_name (name
, &frame
);
1456 if (CONSP (font_spec
))
1458 Lisp_Object spec
= Ffont_spec (0, NULL
);
1460 font_parse_family_registry (XCAR (font_spec
), XCDR (font_spec
), spec
);
1462 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1464 else if (STRINGP (font_spec
))
1466 fontname
= font_spec
;
1467 font_spec
= CALLN (Ffont_spec
, QCname
, fontname
);
1469 else if (FONT_SPEC_P (font_spec
))
1470 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1471 else if (! NILP (font_spec
))
1472 Fsignal (Qfont
, list2 (build_string ("Invalid font-spec"), font_spec
));
1474 if (! NILP (font_spec
))
1476 Lisp_Object encoding
, repertory
;
1478 family
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1479 if (! NILP (family
) )
1480 family
= SYMBOL_NAME (family
);
1481 registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1482 if (! NILP (registry
))
1483 registry
= Fdowncase (SYMBOL_NAME (registry
));
1484 AUTO_STRING (dash
, "-");
1485 encoding
= find_font_encoding (concat3 (family
, dash
, registry
));
1486 if (NILP (encoding
))
1489 if (SYMBOLP (encoding
))
1491 CHECK_CHARSET (encoding
);
1492 encoding
= repertory
= CHARSET_SYMBOL_ID (encoding
);
1496 repertory
= XCDR (encoding
);
1497 encoding
= XCAR (encoding
);
1498 CHECK_CHARSET (encoding
);
1499 encoding
= CHARSET_SYMBOL_ID (encoding
);
1500 if (! NILP (repertory
) && SYMBOLP (repertory
))
1502 CHECK_CHARSET (repertory
);
1503 repertory
= CHARSET_SYMBOL_ID (repertory
);
1506 FONT_DEF_NEW (font_def
, font_spec
, encoding
, repertory
);
1511 if (CHARACTERP (target
))
1513 if (XFASTINT (target
) < 0x80)
1514 error ("Can't set a font for partial ASCII range");
1515 range_list
= list1 (Fcons (target
, target
));
1517 else if (CONSP (target
))
1519 Lisp_Object from
, to
;
1521 from
= Fcar (target
);
1523 CHECK_CHARACTER (from
);
1524 CHECK_CHARACTER (to
);
1525 if (XFASTINT (from
) < 0x80)
1527 if (XFASTINT (from
) != 0 || XFASTINT (to
) < 0x7F)
1528 error ("Can't set a font for partial ASCII range");
1531 range_list
= list1 (target
);
1533 else if (SYMBOLP (target
) && !NILP (target
))
1535 Lisp_Object script_list
;
1539 script_list
= XCHAR_TABLE (Vchar_script_table
)->extras
[0];
1540 if (! NILP (Fmemq (target
, script_list
)))
1542 if (EQ (target
, Qlatin
))
1544 val
= list1 (target
);
1545 map_char_table (accumulate_script_ranges
, Qnil
, Vchar_script_table
,
1547 range_list
= Fnreverse (XCDR (val
));
1549 if (CHARSETP (target
))
1551 CHECK_CHARSET_GET_CHARSET (target
, charset
);
1552 if (charset
->ascii_compatible_p
)
1555 else if (NILP (range_list
))
1556 error ("Invalid script or charset name: %s",
1557 SDATA (SYMBOL_NAME (target
)));
1559 else if (NILP (target
))
1560 range_list
= list1 (Qnil
);
1562 error ("Invalid target for setting a font");
1568 if (NILP (font_spec
))
1569 error ("Can't set ASCII font to nil");
1570 val
= CHAR_TABLE_REF (fontset
, 0);
1571 if (! NILP (val
) && EQ (add
, Qappend
))
1572 /* We are going to change just an additional font for ASCII. */
1580 arg
= make_uninit_vector (5);
1581 ASET (arg
, 0, fontset
);
1582 ASET (arg
, 1, font_def
);
1584 ASET (arg
, 3, ascii_changed
? Qt
: Qnil
);
1585 ASET (arg
, 4, range_list
);
1587 map_charset_chars (set_fontset_font
, Qnil
, arg
, charset
,
1588 CHARSET_MIN_CODE (charset
),
1589 CHARSET_MAX_CODE (charset
));
1590 range_list
= AREF (arg
, 4);
1592 for (; CONSP (range_list
); range_list
= XCDR (range_list
))
1593 FONTSET_ADD (fontset
, XCAR (range_list
), font_def
, add
);
1597 Lisp_Object tail
, fr
;
1598 int fontset_id
= XINT (FONTSET_ID (fontset
));
1600 set_fontset_ascii (fontset
, fontname
);
1601 name
= FONTSET_NAME (fontset
);
1602 FOR_EACH_FRAME (tail
, fr
)
1604 struct frame
*f
= XFRAME (fr
);
1605 Lisp_Object font_object
;
1608 if (FRAME_INITIAL_P (f
) || FRAME_TERMCAP_P (f
))
1610 if (fontset_id
!= FRAME_FONTSET (f
))
1612 face
= FACE_FROM_ID (f
, DEFAULT_FACE_ID
);
1614 font_object
= font_load_for_lface (f
, face
->lface
, font_spec
);
1616 font_object
= font_open_by_spec (f
, font_spec
);
1617 if (! NILP (font_object
))
1619 update_auto_fontset_alist (font_object
, fontset
);
1620 AUTO_FRAME_ARG (arg
, Qfont
, Fcons (name
, font_object
));
1621 Fmodify_frame_parameters (fr
, arg
);
1626 /* Free all realized fontsets whose base is FONTSET. This way, the
1627 specified character(s) are surely redisplayed by a correct
1629 free_realized_fontsets (fontset
);
1635 DEFUN ("new-fontset", Fnew_fontset
, Snew_fontset
, 2, 2, 0,
1636 doc
: /* Create a new fontset NAME from font information in FONTLIST.
1638 FONTLIST is an alist of scripts vs the corresponding font specification list.
1639 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1640 character of SCRIPT is displayed by a font that matches one of
1643 SCRIPT is a symbol that appears in the first extra slot of the
1644 char-table `char-script-table'.
1646 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1647 `set-fontset-font' for the meaning. */)
1648 (Lisp_Object name
, Lisp_Object fontlist
)
1650 Lisp_Object fontset
;
1653 CHECK_STRING (name
);
1654 CHECK_LIST (fontlist
);
1656 name
= Fdowncase (name
);
1657 id
= fs_query_fontset (name
, 0);
1660 Lisp_Object font_spec
= Ffont_spec (0, NULL
);
1661 Lisp_Object short_name
;
1665 if (font_parse_xlfd (SSDATA (name
), SBYTES (name
), font_spec
) < 0)
1666 error ("Fontset name must be in XLFD format");
1667 short_name
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1668 if (strncmp (SSDATA (SYMBOL_NAME (short_name
)), "fontset-", 8)
1669 || SBYTES (SYMBOL_NAME (short_name
)) < 9)
1670 error ("Registry field of fontset name must be \"fontset-*\"");
1671 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (short_name
)),
1672 Vfontset_alias_alist
);
1673 ASET (font_spec
, FONT_REGISTRY_INDEX
, Qiso8859_1
);
1674 fontset
= make_fontset (Qnil
, name
, Qnil
);
1675 len
= font_unparse_xlfd (font_spec
, 0, xlfd
, 256);
1677 error ("Invalid fontset name (perhaps too long): %s", SDATA (name
));
1678 set_fontset_ascii (fontset
, make_unibyte_string (xlfd
, len
));
1682 fontset
= FONTSET_FROM_ID (id
);
1683 free_realized_fontsets (fontset
);
1684 Fset_char_table_range (fontset
, Qt
, Qnil
);
1687 for (; CONSP (fontlist
); fontlist
= XCDR (fontlist
))
1689 Lisp_Object elt
, script
;
1691 elt
= XCAR (fontlist
);
1692 script
= Fcar (elt
);
1694 if (CONSP (elt
) && (NILP (XCDR (elt
)) || CONSP (XCDR (elt
))))
1695 for (; CONSP (elt
); elt
= XCDR (elt
))
1696 Fset_fontset_font (name
, script
, XCAR (elt
), Qnil
, Qappend
);
1698 Fset_fontset_font (name
, script
, elt
, Qnil
, Qappend
);
1704 /* Alist of automatically created fontsets. Each element is a cons
1705 (FONT-SPEC . FONTSET-ID). */
1706 static Lisp_Object auto_fontset_alist
;
1708 /* Number of automatically created fontsets. */
1709 static ptrdiff_t num_auto_fontsets
;
1711 /* Return a fontset synthesized from FONT-OBJECT. This is called from
1712 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1713 frame, and the returned fontset is used for the default fontset of
1714 that frame. The fontset specifies a font of the same registry as
1715 FONT-OBJECT for all characters in the repertory of the registry
1716 (see Vfont_encoding_alist). If the repertory is not known, the
1717 fontset specifies the font for all Latin characters assuming that a
1718 user intends to use FONT-OBJECT for Latin characters. */
1721 fontset_from_font (Lisp_Object font_object
)
1723 Lisp_Object font_name
= font_get_name (font_object
);
1724 Lisp_Object font_spec
= copy_font_spec (font_object
);
1725 Lisp_Object registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1726 Lisp_Object fontset_spec
, alias
, name
, fontset
;
1729 val
= assoc_no_quit (font_spec
, auto_fontset_alist
);
1731 return XINT (FONTSET_ID (XCDR (val
)));
1732 if (num_auto_fontsets
++ == 0)
1733 alias
= intern ("fontset-startup");
1736 char temp
[sizeof "fontset-auto" + INT_STRLEN_BOUND (ptrdiff_t)];
1738 sprintf (temp
, "fontset-auto%"pD
"d", num_auto_fontsets
- 1);
1739 alias
= intern (temp
);
1741 fontset_spec
= copy_font_spec (font_spec
);
1742 ASET (fontset_spec
, FONT_REGISTRY_INDEX
, alias
);
1743 name
= Ffont_xlfd_name (fontset_spec
, Qnil
);
1744 eassert (!NILP (name
));
1745 fontset
= make_fontset (Qnil
, name
, Qnil
);
1746 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (alias
)),
1747 Vfontset_alias_alist
);
1748 alias
= Fdowncase (AREF (font_object
, FONT_NAME_INDEX
));
1749 Vfontset_alias_alist
= Fcons (Fcons (name
, alias
), Vfontset_alias_alist
);
1750 auto_fontset_alist
= Fcons (Fcons (font_spec
, fontset
), auto_fontset_alist
);
1751 font_spec
= Ffont_spec (0, NULL
);
1752 ASET (font_spec
, FONT_REGISTRY_INDEX
, registry
);
1754 Lisp_Object target
= find_font_encoding (SYMBOL_NAME (registry
));
1757 target
= XCDR (target
);
1758 if (! CHARSETP (target
))
1760 Fset_fontset_font (name
, target
, font_spec
, Qnil
, Qnil
);
1761 Fset_fontset_font (name
, Qnil
, font_spec
, Qnil
, Qnil
);
1764 set_fontset_ascii (fontset
, font_name
);
1766 return XINT (FONTSET_ID (fontset
));
1770 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1771 FONTSET is changed, we delete an entry of FONTSET if any from
1772 auto_fontset_alist so that FONTSET is not re-used by
1773 fontset_from_font. */
1776 update_auto_fontset_alist (Lisp_Object font_object
, Lisp_Object fontset
)
1778 Lisp_Object prev
, tail
;
1780 for (prev
= Qnil
, tail
= auto_fontset_alist
; CONSP (tail
);
1781 prev
= tail
, tail
= XCDR (tail
))
1782 if (EQ (fontset
, XCDR (XCAR (tail
))))
1785 auto_fontset_alist
= XCDR (tail
);
1787 XSETCDR (prev
, XCDR (tail
));
1793 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1794 FONT-OBJECT is the font for the character at POSITION in the current
1795 buffer. This is computed from all the text properties and overlays
1796 that apply to POSITION. POSITION may be nil, in which case,
1797 FONT-SPEC is the font for displaying the character CH with the
1800 GLYPH-CODE is the glyph code in the font to use for the character.
1802 If the 2nd optional arg CH is non-nil, it is a character to check
1803 the font instead of the character at POSITION.
1805 It returns nil in the following cases:
1807 (1) The window system doesn't have a font for the character (thus
1808 it is displayed by an empty box).
1810 (2) The character code is invalid.
1812 (3) If POSITION is not nil, and the current buffer is not displayed
1815 In addition, the returned font name may not take into account of
1816 such redisplay engine hooks as what used in jit-lock-mode if
1817 POSITION is currently not visible. */
1820 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1821 doc
: /* For internal use only. */)
1822 (Lisp_Object position
, Lisp_Object ch
)
1824 ptrdiff_t pos
, pos_byte
, dummy
;
1830 if (NILP (position
))
1832 CHECK_CHARACTER (ch
);
1834 f
= XFRAME (selected_frame
);
1835 face_id
= lookup_basic_face (f
, DEFAULT_FACE_ID
);
1843 CHECK_NUMBER_COERCE_MARKER (position
);
1844 if (! (BEGV
<= XINT (position
) && XINT (position
) < ZV
))
1845 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1846 pos
= XINT (position
);
1847 pos_byte
= CHAR_TO_BYTE (pos
);
1849 c
= FETCH_CHAR (pos_byte
);
1855 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1858 w
= XWINDOW (window
);
1859 f
= XFRAME (w
->frame
);
1860 face_id
= face_at_buffer_position (w
, pos
, &dummy
,
1861 pos
+ 100, false, -1);
1863 if (! CHAR_VALID_P (c
))
1865 if (!FRAME_WINDOW_P (f
))
1867 /* We need the basic faces to be valid below, so recompute them if
1868 some code just happened to clear the face cache. */
1869 if (FRAME_FACE_CACHE (f
)->used
== 0)
1870 recompute_basic_faces (f
);
1871 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
, pos
, Qnil
);
1872 face
= FACE_FROM_ID (f
, face_id
);
1875 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
1876 Lisp_Object font_object
;
1878 if (code
== FONT_INVALID_CODE
)
1880 XSETFONT (font_object
, face
->font
);
1881 return Fcons (font_object
, INTEGER_TO_CONS (code
));
1887 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1888 doc
: /* Return information about a fontset FONTSET on frame FRAME.
1890 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1891 for the default fontset. FRAME nil means the selected frame.
1893 The value is a char-table whose elements have this form:
1895 ((FONT OPENED-FONT ...) ...)
1897 FONT is a name of font specified for a range of characters.
1899 OPENED-FONT is a name of a font actually opened.
1901 The char-table has one extra slot. If FONTSET is not the default
1902 fontset, the value the extra slot is a char-table containing the
1903 information about the derived fonts from the default fontset. The
1904 format is the same as above. */)
1905 (Lisp_Object fontset
, Lisp_Object frame
)
1907 Lisp_Object
*realized
[2], fontsets
[2], tables
[2];
1908 Lisp_Object val
, elt
;
1911 check_window_system (NULL
);
1912 fontset
= check_fontset_name (fontset
, &frame
);
1914 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1915 in the table `realized'. */
1917 SAFE_ALLOCA_LISP (realized
[0], 2 * ASIZE (Vfontset_table
));
1918 realized
[1] = realized
[0] + ASIZE (Vfontset_table
);
1919 for (i
= j
= 0; i
< ASIZE (Vfontset_table
); i
++)
1921 elt
= FONTSET_FROM_ID (i
);
1923 && EQ (FONTSET_BASE (elt
), fontset
)
1924 && EQ (FONTSET_FRAME (elt
), frame
))
1925 realized
[0][j
++] = elt
;
1927 realized
[0][j
] = Qnil
;
1929 for (i
= j
= 0; ! NILP (realized
[0][i
]); i
++)
1931 elt
= FONTSET_DEFAULT (realized
[0][i
]);
1933 realized
[1][j
++] = elt
;
1935 realized
[1][j
] = Qnil
;
1937 tables
[0] = Fmake_char_table (Qfontset_info
, Qnil
);
1938 fontsets
[0] = fontset
;
1939 if (!EQ (fontset
, Vdefault_fontset
))
1941 tables
[1] = Fmake_char_table (Qnil
, Qnil
);
1942 set_char_table_extras (tables
[0], 0, tables
[1]);
1943 fontsets
[1] = Vdefault_fontset
;
1946 /* Accumulate information of the fontset in TABLE. The format of
1947 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1948 for (k
= 0; k
<= 1; k
++)
1950 for (c
= 0; c
<= MAX_CHAR
; )
1952 int from
= c
, to
= MAX_5_BYTE_CHAR
;
1954 if (c
<= MAX_5_BYTE_CHAR
)
1956 val
= char_table_ref_and_range (fontsets
[k
], c
, &from
, &to
);
1960 val
= FONTSET_FALLBACK (fontsets
[k
]);
1967 /* At first, set ALIST to ((FONT-SPEC) ...). */
1968 for (alist
= Qnil
, i
= 0; i
< ASIZE (val
); i
++)
1969 if (! NILP (AREF (val
, i
)))
1970 alist
= Fcons (Fcons (FONT_DEF_SPEC (AREF (val
, i
)), Qnil
),
1972 alist
= Fnreverse (alist
);
1974 /* Then store opened font names to cdr of each elements. */
1975 for (i
= 0; ! NILP (realized
[k
][i
]); i
++)
1977 if (c
<= MAX_5_BYTE_CHAR
)
1978 val
= FONTSET_REF (realized
[k
][i
], c
);
1980 val
= FONTSET_FALLBACK (realized
[k
][i
]);
1981 if (! CONSP (val
) || ! VECTORP (XCDR (val
)))
1983 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
1985 for (j
= 0; j
< ASIZE (val
); j
++)
1987 elt
= AREF (val
, j
);
1988 if (!NILP (elt
) && FONT_OBJECT_P (RFONT_DEF_OBJECT (elt
)))
1990 Lisp_Object font_object
= RFONT_DEF_OBJECT (elt
);
1991 Lisp_Object slot
, name
;
1993 slot
= Fassq (RFONT_DEF_SPEC (elt
), alist
);
1994 name
= AREF (font_object
, FONT_NAME_INDEX
);
1995 if (NILP (Fmember (name
, XCDR (slot
))))
1996 nconc2 (slot
, list1 (name
));
2001 /* Store ALIST in TBL for characters C..TO. */
2002 if (c
<= MAX_5_BYTE_CHAR
)
2003 char_table_set_range (tables
[k
], c
, to
, alist
);
2005 set_char_table_defalt (tables
[k
], alist
);
2007 /* At last, change each elements to font names. */
2008 for (; CONSP (alist
); alist
= XCDR (alist
))
2011 XSETCAR (elt
, Ffont_xlfd_name (XCAR (elt
), Qnil
));
2016 if (EQ (fontset
, Vdefault_fontset
))
2025 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 3, 0,
2026 doc
: /* Return a font name pattern for character CH in fontset NAME.
2027 If NAME is t, find a pattern in the default fontset.
2028 If NAME is nil, find a pattern in the fontset of the selected frame.
2030 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2031 family name and REGISTRY is a font registry name. This is actually
2032 the first font name pattern for CH in the fontset or in the default
2035 If the 2nd optional arg ALL is non-nil, return a list of all font name
2037 (Lisp_Object name
, Lisp_Object ch
, Lisp_Object all
)
2040 Lisp_Object fontset
, elt
, list
, repertory
, val
;
2045 fontset
= check_fontset_name (name
, &frame
);
2047 CHECK_CHARACTER (ch
);
2052 for (i
= 0, elt
= FONTSET_REF (fontset
, c
); i
< 2;
2053 i
++, elt
= FONTSET_FALLBACK (fontset
))
2055 for (j
= 0; j
< ASIZE (elt
); j
++)
2057 Lisp_Object family
, registry
;
2059 val
= AREF (elt
, j
);
2062 repertory
= AREF (val
, 1);
2063 if (INTEGERP (repertory
))
2065 struct charset
*charset
= CHARSET_FROM_ID (XINT (repertory
));
2067 if (! CHAR_CHARSET_P (c
, charset
))
2070 else if (CHAR_TABLE_P (repertory
))
2072 if (NILP (CHAR_TABLE_REF (repertory
, c
)))
2075 val
= AREF (val
, 0);
2076 /* VAL is a FONT-SPEC */
2077 family
= AREF (val
, FONT_FAMILY_INDEX
);
2078 if (! NILP (family
))
2079 family
= SYMBOL_NAME (family
);
2080 registry
= AREF (val
, FONT_REGISTRY_INDEX
);
2081 if (! NILP (registry
))
2082 registry
= SYMBOL_NAME (registry
);
2083 val
= Fcons (family
, registry
);
2086 list
= Fcons (val
, list
);
2088 if (EQ (fontset
, Vdefault_fontset
))
2090 fontset
= Vdefault_fontset
;
2092 return (Fnreverse (list
));
2095 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
2096 doc
: /* Return a list of all defined fontset names. */)
2099 Lisp_Object fontset
, list
;
2103 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
2105 fontset
= FONTSET_FROM_ID (i
);
2107 && BASE_FONTSET_P (fontset
))
2108 list
= Fcons (FONTSET_NAME (fontset
), list
);
2115 #ifdef ENABLE_CHECKING
2117 Lisp_Object
dump_fontset (Lisp_Object
) EXTERNALLY_VISIBLE
;
2120 dump_fontset (Lisp_Object fontset
)
2124 vec
= Fmake_vector (make_number (3), Qnil
);
2125 ASET (vec
, 0, FONTSET_ID (fontset
));
2127 if (BASE_FONTSET_P (fontset
))
2129 ASET (vec
, 1, FONTSET_NAME (fontset
));
2135 frame
= FONTSET_FRAME (fontset
);
2138 struct frame
*f
= XFRAME (frame
);
2140 if (FRAME_LIVE_P (f
))
2142 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)),
2146 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), Qnil
));
2148 if (!NILP (FONTSET_DEFAULT (fontset
)))
2149 ASET (vec
, 2, FONTSET_ID (FONTSET_DEFAULT (fontset
)));
2154 DEFUN ("fontset-list-all", Ffontset_list_all
, Sfontset_list_all
, 0, 0, 0,
2155 doc
: /* Return a brief summary of all fontsets for debug use. */)
2161 for (i
= 0, val
= Qnil
; i
< ASIZE (Vfontset_table
); i
++)
2162 if (! NILP (AREF (Vfontset_table
, i
)))
2163 val
= Fcons (dump_fontset (AREF (Vfontset_table
, i
)), val
);
2164 return (Fnreverse (val
));
2166 #endif /* ENABLE_CHECKING */
2169 syms_of_fontset (void)
2171 DEFSYM (Qfontset
, "fontset");
2172 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (8));
2173 DEFSYM (Qfontset_info
, "fontset-info");
2174 Fput (Qfontset_info
, Qchar_table_extra_slots
, make_number (1));
2176 DEFSYM (Qappend
, "append");
2177 DEFSYM (Qlatin
, "latin");
2179 Vcached_fontset_data
= Qnil
;
2180 staticpro (&Vcached_fontset_data
);
2182 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
2183 staticpro (&Vfontset_table
);
2185 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
2186 staticpro (&Vdefault_fontset
);
2187 set_fontset_id (Vdefault_fontset
, make_number (0));
2190 build_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));
2191 ASET (Vfontset_table
, 0, Vdefault_fontset
);
2192 next_fontset_id
= 1;
2194 auto_fontset_alist
= Qnil
;
2195 staticpro (&auto_fontset_alist
);
2197 DEFVAR_LISP ("font-encoding-charset-alist", Vfont_encoding_charset_alist
,
2199 Alist of charsets vs the charsets to determine the preferred font encoding.
2200 Each element looks like (CHARSET . ENCODING-CHARSET),
2201 where ENCODING-CHARSET is a charset registered in the variable
2202 `font-encoding-alist' as ENCODING.
2204 When a text has a property `charset' and the value is CHARSET, a font
2205 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2206 Vfont_encoding_charset_alist
= Qnil
;
2208 DEFVAR_LISP ("use-default-ascent", Vuse_default_ascent
,
2210 Char table of characters whose ascent values should be ignored.
2211 If an entry for a character is non-nil, the ascent value of the glyph
2212 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2214 This affects how a composite character which contains
2215 such a character is displayed on screen. */);
2216 Vuse_default_ascent
= Qnil
;
2218 DEFVAR_LISP ("ignore-relative-composition", Vignore_relative_composition
,
2220 Char table of characters which are not composed relatively.
2221 If an entry for a character is non-nil, a composition sequence
2222 which contains that character is displayed so that
2223 the glyph of that character is put without considering
2224 an ascent and descent value of a previous character. */);
2225 Vignore_relative_composition
= Qnil
;
2227 DEFVAR_LISP ("alternate-fontname-alist", Valternate_fontname_alist
,
2228 doc
: /* Alist of fontname vs list of the alternate fontnames.
2229 When a specified font name is not found, the corresponding
2230 alternate fontnames (if any) are tried instead. */);
2231 Valternate_fontname_alist
= Qnil
;
2233 DEFVAR_LISP ("fontset-alias-alist", Vfontset_alias_alist
,
2234 doc
: /* Alist of fontset names vs the aliases. */);
2235 Vfontset_alias_alist
2236 = list1 (Fcons (FONTSET_NAME (Vdefault_fontset
),
2237 build_pure_c_string ("fontset-default")));
2239 DEFVAR_LISP ("vertical-centering-font-regexp",
2240 Vvertical_centering_font_regexp
,
2241 doc
: /* Regexp matching font names that require vertical centering on display.
2242 When a character is displayed with such fonts, the character is displayed
2243 at the vertical center of lines. */);
2244 Vvertical_centering_font_regexp
= Qnil
;
2246 DEFVAR_LISP ("otf-script-alist", Votf_script_alist
,
2247 doc
: /* Alist of OpenType script tags vs the corresponding script names. */);
2248 Votf_script_alist
= Qnil
;
2250 defsubr (&Squery_fontset
);
2251 defsubr (&Snew_fontset
);
2252 defsubr (&Sset_fontset_font
);
2253 defsubr (&Sinternal_char_font
);
2254 defsubr (&Sfontset_info
);
2255 defsubr (&Sfontset_font
);
2256 defsubr (&Sfontset_list
);
2257 #ifdef ENABLE_CHECKING
2258 defsubr (&Sfontset_list_all
);