2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5 2005, 2006, 2007, 2008, 2009, 2010
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 */
34 #include "blockinput.h"
36 #include "character.h"
41 #include "dispextern.h"
42 #include "intervals.h"
54 #include "termhooks.h"
60 #define xassert(X) do {if (!(X)) abort ();} while (0)
63 #else /* not FONTSET_DEBUG */
64 #define xassert(X) (void) 0
65 #endif /* not FONTSET_DEBUG */
67 EXFUN (Fclear_face_cache
, 1);
71 A fontset is a collection of font related information to give
72 similar appearance (style, etc) of characters. A fontset has two
73 roles. One is to use for the frame parameter `font' as if it is an
74 ASCII font. In that case, Emacs uses the font specified for
75 `ascii' script for the frame's default font.
77 Another role, the more important one, is to provide information
78 about which font to use for each non-ASCII character.
80 There are two kinds of fontsets; base and realized. A base fontset
81 is created by `new-fontset' from Emacs Lisp explicitly. A realized
82 fontset is created implicitly when a face is realized for ASCII
83 characters. A face is also realized for non-ASCII characters based
84 on an ASCII face. All of non-ASCII faces based on the same ASCII
85 face share the same realized fontset.
87 A fontset object is implemented by a char-table whose default value
88 and parent are always nil.
90 An element of a base fontset is a vector of FONT-DEFs which itself
91 is a vector [ FONT-SPEC ENCODING REPERTORY ].
93 An element of a realized fontset is nil, t, 0, or a vector of this
96 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
97 RFONT-DEF0 RFONT-DEF1 ... ]
99 RFONT-DEFn (i.e. Realized FONT-DEF) has this form:
101 [ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]
103 RFONT-DEFn are automatically reordered by the current charset
106 The value nil means that we have not yet generated the above vector
107 from the base of the fontset.
109 The value t means that no font is available for the corresponding
112 The value 0 means that no font is available for the corresponding
113 range of characters in this fontset, but may be available in the
117 A fontset has 9 extra slots.
119 The 1st slot: the ID number of the fontset
122 base: the name of the fontset
127 realized: the base fontset
131 realized: the frame that the fontset belongs to
134 base: the font name for ASCII characters
139 realized: the ID number of a face to use for characters that
140 has no font in a realized fontset.
144 realized: Alist of font index vs the corresponding repertory
149 realized: If the base is not the default fontset, a fontset
150 realized from the default fontset, else nil.
153 base: Same as element value (but for fallback fonts).
156 All fontsets are recorded in the vector Vfontset_table.
161 There's a special base fontset named `default fontset' which
162 defines the default font specifications. When a base fontset
163 doesn't specify a font for a specific character, the corresponding
164 value in the default fontset is used.
166 The parent of a realized fontset created for such a face that has
167 no fontset is the default fontset.
170 These structures are hidden from the other codes than this file.
171 The other codes handle fontsets only by their ID numbers. They
172 usually use the variable name `fontset' for IDs. But, in this
173 file, we always use varialbe name `id' for IDs, and name `fontset'
174 for an actual fontset object, i.e., char-table.
178 /********** VARIABLES and FUNCTION PROTOTYPES **********/
180 extern Lisp_Object Qfont
;
181 static Lisp_Object Qfontset
;
182 static Lisp_Object Qfontset_info
;
183 static Lisp_Object Qprepend
, Qappend
;
186 /* Vector containing all fontsets. */
187 static Lisp_Object Vfontset_table
;
189 /* Next possibly free fontset ID. Usually this keeps the minimum
190 fontset ID not yet used. */
191 static int next_fontset_id
;
193 /* The default fontset. This gives default FAMILY and REGISTRY of
194 font for each character. */
195 static Lisp_Object Vdefault_fontset
;
197 Lisp_Object Vfont_encoding_charset_alist
;
198 Lisp_Object Vuse_default_ascent
;
199 Lisp_Object Vignore_relative_composition
;
200 Lisp_Object Valternate_fontname_alist
;
201 Lisp_Object Vfontset_alias_alist
;
202 Lisp_Object Vvertical_centering_font_regexp
;
203 Lisp_Object Votf_script_alist
;
205 /* Check if any window system is used now. */
206 void (*check_window_system_func
) (void);
209 /* Prototype declarations for static functions. */
210 static Lisp_Object
fontset_add (Lisp_Object
, Lisp_Object
, Lisp_Object
,
212 static Lisp_Object
fontset_find_font (Lisp_Object
, int, struct face
*,
214 static void reorder_font_vector (Lisp_Object
, struct font
*);
215 static Lisp_Object
fontset_font (Lisp_Object
, int, struct face
*, int);
216 static Lisp_Object
make_fontset (Lisp_Object
, Lisp_Object
, Lisp_Object
);
217 static Lisp_Object
fontset_pattern_regexp (Lisp_Object
);
218 static void accumulate_script_ranges (Lisp_Object
, Lisp_Object
,
220 Lisp_Object
find_font_encoding (Lisp_Object
);
222 static void set_fontset_font (Lisp_Object
, Lisp_Object
);
226 /* Return 1 if ID is a valid fontset id, else return 0. */
229 fontset_id_valid_p (id
)
232 return (id
>= 0 && id
< ASIZE (Vfontset_table
) - 1);
239 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
241 /* Return the fontset with ID. No check of ID's validness. */
242 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
244 /* Macros to access special values of FONTSET. */
245 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
247 /* Macros to access special values of (base) FONTSET. */
248 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
249 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->extras[4]
250 #define FONTSET_SPEC(fontset) XCHAR_TABLE (fontset)->extras[5]
252 /* Macros to access special values of (realized) FONTSET. */
253 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->extras[2]
254 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[3]
255 #define FONTSET_OBJLIST(fontset) XCHAR_TABLE (fontset)->extras[4]
256 #define FONTSET_NOFONT_FACE(fontset) XCHAR_TABLE (fontset)->extras[5]
257 #define FONTSET_REPERTORY(fontset) XCHAR_TABLE (fontset)->extras[6]
258 #define FONTSET_DEFAULT(fontset) XCHAR_TABLE (fontset)->extras[7]
260 /* For both base and realized fontset. */
261 #define FONTSET_FALLBACK(fontset) XCHAR_TABLE (fontset)->extras[8]
263 #define BASE_FONTSET_P(fontset) (NILP (FONTSET_BASE (fontset)))
266 /* Macros for FONT-DEF and RFONT-DEF of fontset. */
267 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory) \
269 (font_def) = Fmake_vector (make_number (3), (font_spec)); \
270 ASET ((font_def), 1, encoding); \
271 ASET ((font_def), 2, repertory); \
274 #define FONT_DEF_SPEC(font_def) AREF (font_def, 0)
275 #define FONT_DEF_ENCODING(font_def) AREF (font_def, 1)
276 #define FONT_DEF_REPERTORY(font_def) AREF (font_def, 2)
278 #define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
279 #define RFONT_DEF_SET_FACE(rfont_def, face_id) \
280 ASET ((rfont_def), 0, make_number (face_id))
281 #define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
282 #define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
283 #define RFONT_DEF_REPERTORY(rfont_def) FONT_DEF_REPERTORY (AREF (rfont_def, 1))
284 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
285 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
286 ASET ((rfont_def), 2, (object))
287 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
288 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
289 ASET ((rfont_def), 3, make_number (score))
290 #define RFONT_DEF_NEW(rfont_def, font_def) \
292 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
293 ASET ((rfont_def), 1, (font_def)); \
294 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
298 /* Return the element of FONTSET for the character C. If FONTSET is a
299 base fontset other then the default fontset and FONTSET doesn't
300 contain information for C, return the information in the default
303 #define FONTSET_REF(fontset, c) \
304 (EQ (fontset, Vdefault_fontset) \
305 ? CHAR_TABLE_REF (fontset, c) \
306 : fontset_ref ((fontset), (c)))
309 fontset_ref (Lisp_Object fontset
, int c
)
313 elt
= CHAR_TABLE_REF (fontset
, c
);
314 if (NILP (elt
) && ! EQ (fontset
, Vdefault_fontset
)
315 /* Don't check Vdefault_fontset for a realized fontset. */
316 && NILP (FONTSET_BASE (fontset
)))
317 elt
= CHAR_TABLE_REF (Vdefault_fontset
, c
);
321 /* Set elements of FONTSET for characters in RANGE to the value ELT.
322 RANGE is a cons (FROM . TO), where FROM and TO are character codes
323 specifying a range. */
325 #define FONTSET_SET(fontset, range, elt) \
326 Fset_char_table_range ((fontset), (range), (elt))
329 /* Modify the elements of FONTSET for characters in RANGE by replacing
330 with ELT or adding ELT. RANGE is a cons (FROM . TO), where FROM
331 and TO are character codes specifying a range. If ADD is nil,
332 replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
335 #define FONTSET_ADD(fontset, range, elt, add) \
338 ? (FONTSET_FALLBACK (fontset) = Fmake_vector (make_number (1), (elt))) \
339 : Fset_char_table_range ((fontset), (range), \
340 Fmake_vector (make_number (1), (elt)))) \
341 : fontset_add ((fontset), (range), (elt), (add)))
344 fontset_add (Lisp_Object fontset
, Lisp_Object range
, Lisp_Object elt
, Lisp_Object add
)
347 int idx
= (EQ (add
, Qappend
) ? 0 : 1);
349 args
[1 - idx
] = Fmake_vector (make_number (1), elt
);
353 int from
= XINT (XCAR (range
));
354 int to
= XINT (XCDR (range
));
358 from1
= from
, to1
= to
;
359 args
[idx
] = char_table_ref_and_range (fontset
, from
, &from1
, &to1
);
360 char_table_set_range (fontset
, from
, to1
,
361 NILP (args
[idx
]) ? args
[1 - idx
]
362 : Fvconcat (2, args
));
368 args
[idx
] = FONTSET_FALLBACK (fontset
);
369 FONTSET_FALLBACK (fontset
)
370 = NILP (args
[idx
]) ? args
[1 - idx
] : Fvconcat (2, args
);
376 fontset_compare_rfontdef (const void *val1
, const void *val2
)
378 return (RFONT_DEF_SCORE (*(Lisp_Object
*) val1
)
379 - RFONT_DEF_SCORE (*(Lisp_Object
*) val2
));
382 /* Update FONT-GROUP which has this form:
383 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
384 RFONT-DEF0 RFONT-DEF1 ... ]
385 Reorder RFONT-DEFs according to the current language, and update
386 CHARSET-ORDERED-LIST-TICK.
388 If PREFERRED_FAMILY is not nil, that family has the higher priority
389 if the encoding charsets or languages in font-specs are the same. */
391 extern Lisp_Object
Fassoc_string (Lisp_Object
, Lisp_Object
, Lisp_Object
);
394 reorder_font_vector (Lisp_Object font_group
, struct font
*font
)
396 Lisp_Object vec
, font_object
;
399 int score_changed
= 0;
402 XSETFONT (font_object
, font
);
406 vec
= XCDR (font_group
);
408 /* Exclude the tailing nil element from the reordering. */
409 if (NILP (AREF (vec
, size
- 1)))
412 for (i
= 0; i
< size
; i
++)
414 Lisp_Object rfont_def
= AREF (vec
, i
);
415 Lisp_Object font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
416 Lisp_Object font_spec
= FONT_DEF_SPEC (font_def
);
417 int score
= RFONT_DEF_SCORE (rfont_def
) & 0xFF;
419 if (! font_match_p (font_spec
, font_object
))
421 Lisp_Object encoding
= FONT_DEF_ENCODING (font_def
);
423 if (! NILP (encoding
))
427 for (tail
= Vcharset_ordered_list
;
428 ! EQ (tail
, Vcharset_non_preferred_head
) && CONSP (tail
);
429 score
+= 0x100, tail
= XCDR (tail
))
430 if (EQ (encoding
, XCAR (tail
)))
435 Lisp_Object lang
= Ffont_get (font_spec
, QClang
);
438 && ! EQ (lang
, Vcurrent_iso639_language
)
439 && (! CONSP (Vcurrent_iso639_language
)
440 || NILP (Fmemq (lang
, Vcurrent_iso639_language
))))
444 if (RFONT_DEF_SCORE (rfont_def
) != score
)
446 RFONT_DEF_SET_SCORE (rfont_def
, score
);
452 qsort (XVECTOR (vec
)->contents
, size
, sizeof (Lisp_Object
),
453 fontset_compare_rfontdef
);
454 XSETCAR (font_group
, make_number (charset_ordered_list_tick
));
457 /* Return a font-group (actually a cons (-1 . FONT-GROUP-VECTOR)) for
458 character C in FONTSET. If C is -1, return a fallback font-group.
459 If C is not -1, the value may be Qt (FONTSET doesn't have a font
460 for C even in the fallback group, or 0 (a font for C may be found
461 only in the fallback group). */
464 fontset_get_font_group (Lisp_Object fontset
, int c
)
466 Lisp_Object font_group
;
467 Lisp_Object base_fontset
;
468 int from
= 0, to
= MAX_CHAR
, i
;
470 xassert (! BASE_FONTSET_P (fontset
));
472 font_group
= CHAR_TABLE_REF (fontset
, c
);
474 font_group
= FONTSET_FALLBACK (fontset
);
475 if (! NILP (font_group
))
477 base_fontset
= FONTSET_BASE (fontset
);
479 font_group
= char_table_ref_and_range (base_fontset
, c
, &from
, &to
);
481 font_group
= FONTSET_FALLBACK (base_fontset
);
482 if (NILP (font_group
))
484 font_group
= make_number (0);
486 char_table_set_range (fontset
, from
, to
, font_group
);
489 font_group
= Fcopy_sequence (font_group
);
490 for (i
= 0; i
< ASIZE (font_group
); i
++)
491 if (! NILP (AREF (font_group
, i
)))
493 Lisp_Object rfont_def
;
495 RFONT_DEF_NEW (rfont_def
, AREF (font_group
, i
));
496 /* Remember the original order. */
497 RFONT_DEF_SET_SCORE (rfont_def
, i
);
498 ASET (font_group
, i
, rfont_def
);
500 font_group
= Fcons (make_number (-1), font_group
);
502 char_table_set_range (fontset
, from
, to
, font_group
);
504 FONTSET_FALLBACK (fontset
) = font_group
;
508 /* Return RFONT-DEF (vector) in the realized fontset FONTSET for the
509 character C. If no font is found, return Qnil if there's a
510 possibility that the default fontset or the fallback font groups
511 have a proper font, and return Qt if not.
513 If a font is found but is not yet opened, open it (if FACE is not
514 NULL) or return Qnil (if FACE is NULL).
516 ID is a charset-id that must be preferred, or -1 meaning no
519 If FALLBACK is nonzero, search only fallback fonts. */
522 fontset_find_font (Lisp_Object fontset
, int c
, struct face
*face
, int id
, int fallback
)
524 Lisp_Object vec
, font_group
;
525 int i
, charset_matched
= 0, found_index
;
526 FRAME_PTR f
= (FRAMEP (FONTSET_FRAME (fontset
))
527 ? XFRAME (FONTSET_FRAME (fontset
)) : XFRAME (selected_frame
));
528 Lisp_Object rfont_def
;
530 font_group
= fontset_get_font_group (fontset
, fallback
? -1 : c
);
531 if (! CONSP (font_group
))
533 vec
= XCDR (font_group
);
534 if (ASIZE (vec
) == 0)
539 if (XINT (XCAR (font_group
)) != charset_ordered_list_tick
)
540 /* We have just created the font-group,
541 or the charset priorities were changed. */
542 reorder_font_vector (font_group
, face
->ascii_face
->font
);
544 /* Find a spec matching with the charset ID to try at
546 for (i
= 0; i
< ASIZE (vec
); i
++)
548 Lisp_Object repertory
;
550 rfont_def
= AREF (vec
, i
);
551 if (NILP (rfont_def
))
553 repertory
= FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def
));
555 if (XINT (repertory
) == id
)
563 /* Find the first available font in the vector of RFONT-DEF. */
564 for (i
= 0; i
< ASIZE (vec
); i
++)
566 Lisp_Object font_def
;
567 Lisp_Object font_entity
, font_object
;
572 if (charset_matched
> 0)
574 /* Try the element matching with the charset ID at first. */
575 found_index
= charset_matched
;
576 /* Make this negative so that we don't come here in the
578 charset_matched
= - charset_matched
;
579 /* We must try the first element in the next loop. */
583 else if (i
== - charset_matched
)
585 /* We have already tried this element and the followings
586 that have the same font specifications in the first
587 iteration. So, skip them all. */
588 rfont_def
= AREF (vec
, i
);
589 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
590 for (; i
+ 1 < ASIZE (vec
); i
++)
592 rfont_def
= AREF (vec
, i
+ 1);
593 if (NILP (rfont_def
))
595 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def
), font_def
))
601 rfont_def
= AREF (vec
, found_index
);
602 if (NILP (rfont_def
))
606 /* This is a sign of not to try the other fonts. */
609 if (INTEGERP (RFONT_DEF_FACE (rfont_def
))
610 && XINT (RFONT_DEF_FACE (rfont_def
)) < 0)
611 /* We couldn't open this font last time. */
614 font_object
= RFONT_DEF_OBJECT (rfont_def
);
615 if (NILP (font_object
))
617 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
620 /* We have not yet opened the font. */
622 /* Find a font best-matching with the spec without checking
623 the support of the character C. That checking is costly,
624 and even without the checking, the found font supports C
625 in high possibility. */
626 font_entity
= font_find_for_lface (f
, face
->lface
,
627 FONT_DEF_SPEC (font_def
), -1);
628 if (NILP (font_entity
))
630 /* Record that no font matches the spec. */
631 RFONT_DEF_SET_FACE (rfont_def
, -1);
634 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
635 FONT_DEF_SPEC (font_def
));
636 if (NILP (font_object
))
638 /* Something strange happened, perhaps because of a
639 Font-backend problem. Too avoid crashing, record
640 that this spec is unsable. It may be better to find
641 another font of the same spec, but currently we don't
643 RFONT_DEF_SET_FACE (rfont_def
, -1);
646 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
649 if (font_has_char (f
, font_object
, c
))
652 /* Find a font already opened, maching with the current spec,
654 font_def
= RFONT_DEF_FONT_DEF (rfont_def
);
655 for (; found_index
+ 1 < ASIZE (vec
); found_index
++)
657 rfont_def
= AREF (vec
, found_index
+ 1);
658 if (NILP (rfont_def
))
660 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def
), font_def
))
662 font_object
= RFONT_DEF_OBJECT (rfont_def
);
663 if (! NILP (font_object
) && font_has_char (f
, font_object
, c
))
670 /* Find a font-entity with the current spec and supporting C. */
671 font_entity
= font_find_for_lface (f
, face
->lface
,
672 FONT_DEF_SPEC (font_def
), c
);
673 if (! NILP (font_entity
))
675 /* We found a font. Open it and insert a new element for
680 font_object
= font_open_for_lface (f
, font_entity
, face
->lface
,
682 if (NILP (font_object
))
684 RFONT_DEF_NEW (rfont_def
, font_def
);
685 RFONT_DEF_SET_OBJECT (rfont_def
, font_object
);
686 RFONT_DEF_SET_SCORE (rfont_def
, RFONT_DEF_SCORE (rfont_def
));
687 new_vec
= Fmake_vector (make_number (ASIZE (vec
) + 1), Qnil
);
689 for (j
= 0; j
< found_index
; j
++)
690 ASET (new_vec
, j
, AREF (vec
, j
));
691 ASET (new_vec
, j
, rfont_def
);
692 for (j
++; j
< ASIZE (new_vec
); j
++)
693 ASET (new_vec
, j
, AREF (vec
, j
- 1));
694 XSETCDR (font_group
, new_vec
);
702 FONTSET_SET (fontset
, make_number (c
), make_number (0));
706 if (fallback
&& found_index
> 0)
708 /* The order of fonts in the fallback font-group is not that
709 important, and it is better to move the found font to the
710 first of the group so that the next try will find it
712 for (i
= found_index
; i
> 0; i
--)
713 ASET (vec
, i
, AREF (vec
, i
- 1));
714 ASET (vec
, 0, rfont_def
);
721 fontset_font (Lisp_Object fontset
, int c
, struct face
*face
, int id
)
723 Lisp_Object rfont_def
, default_rfont_def
;
724 Lisp_Object base_fontset
;
726 /* Try a font-group of FONTSET. */
727 FONT_DEFERRED_LOG ("current fontset: font for", make_number (c
), Qnil
);
728 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 0);
729 if (VECTORP (rfont_def
))
731 if (NILP (rfont_def
))
732 FONTSET_SET (fontset
, make_number (c
), make_number (0));
734 /* Try a font-group of the default fontset. */
735 base_fontset
= FONTSET_BASE (fontset
);
736 if (! EQ (base_fontset
, Vdefault_fontset
))
738 if (NILP (FONTSET_DEFAULT (fontset
)))
739 FONTSET_DEFAULT (fontset
)
740 = make_fontset (FONTSET_FRAME (fontset
), Qnil
, Vdefault_fontset
);
741 FONT_DEFERRED_LOG ("default fontset: font for", make_number (c
), Qnil
);
743 = fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 0);
744 if (VECTORP (default_rfont_def
))
745 return default_rfont_def
;
746 if (NILP (default_rfont_def
))
747 FONTSET_SET (FONTSET_DEFAULT (fontset
), make_number (c
),
751 /* Try a fallback font-group of FONTSET. */
752 if (! EQ (rfont_def
, Qt
))
754 FONT_DEFERRED_LOG ("current fallback: font for", make_number (c
), Qnil
);
755 rfont_def
= fontset_find_font (fontset
, c
, face
, id
, 1);
756 if (VECTORP (rfont_def
))
758 /* Remember that FONTSET has no font for C. */
759 FONTSET_SET (fontset
, make_number (c
), Qt
);
762 /* Try a fallback font-group of the default fontset. */
763 if (! EQ (base_fontset
, Vdefault_fontset
)
764 && ! EQ (default_rfont_def
, Qt
))
766 FONT_DEFERRED_LOG ("default fallback: font for", make_number (c
), Qnil
);
767 rfont_def
= fontset_find_font (FONTSET_DEFAULT (fontset
), c
, face
, id
, 1);
768 if (VECTORP (rfont_def
))
770 /* Remember that the default fontset has no font for C. */
771 FONTSET_SET (FONTSET_DEFAULT (fontset
), make_number (c
), Qt
);
777 /* Return a newly created fontset with NAME. If BASE is nil, make a
778 base fontset. Otherwise make a realized fontset whose base is
782 make_fontset (Lisp_Object frame
, Lisp_Object name
, Lisp_Object base
)
785 int size
= ASIZE (Vfontset_table
);
786 int id
= next_fontset_id
;
788 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
789 the next available fontset ID. So it is expected that this loop
790 terminates quickly. In addition, as the last element of
791 Vfontset_table is always nil, we don't have to check the range of
793 while (!NILP (AREF (Vfontset_table
, id
))) id
++;
796 Vfontset_table
= larger_vector (Vfontset_table
, size
+ 32, Qnil
);
798 fontset
= Fmake_char_table (Qfontset
, Qnil
);
800 FONTSET_ID (fontset
) = make_number (id
);
803 FONTSET_NAME (fontset
) = name
;
807 FONTSET_NAME (fontset
) = Qnil
;
808 FONTSET_FRAME (fontset
) = frame
;
809 FONTSET_BASE (fontset
) = base
;
812 ASET (Vfontset_table
, id
, fontset
);
813 next_fontset_id
= id
+ 1;
818 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
820 /* Return the name of the fontset who has ID. */
823 fontset_name (int id
)
827 fontset
= FONTSET_FROM_ID (id
);
828 return FONTSET_NAME (fontset
);
832 /* Return the ASCII font name of the fontset who has ID. */
835 fontset_ascii (int id
)
837 Lisp_Object fontset
, elt
;
839 fontset
= FONTSET_FROM_ID (id
);
840 elt
= FONTSET_ASCII (fontset
);
847 free_realized_fontset (FRAME_PTR f
, Lisp_Object fontset
)
852 for (tail
= FONTSET_OBJLIST (fontset
); CONSP (tail
); tail
= XCDR (tail
))
854 xassert (FONT_OBJECT_P (XCAR (tail
)));
855 font_close_object (f
, XCAR (tail
));
859 /* Free fontset of FACE defined on frame F. Called from
860 free_realized_face. */
863 free_face_fontset (FRAME_PTR f
, struct face
*face
)
867 fontset
= FONTSET_FROM_ID (face
->fontset
);
870 xassert (! BASE_FONTSET_P (fontset
));
871 xassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
872 free_realized_fontset (f
, fontset
);
873 ASET (Vfontset_table
, face
->fontset
, Qnil
);
874 if (face
->fontset
< next_fontset_id
)
875 next_fontset_id
= face
->fontset
;
876 if (! NILP (FONTSET_DEFAULT (fontset
)))
878 int id
= XINT (FONTSET_ID (FONTSET_DEFAULT (fontset
)));
880 fontset
= AREF (Vfontset_table
, id
);
881 xassert (!NILP (fontset
) && ! BASE_FONTSET_P (fontset
));
882 xassert (f
== XFRAME (FONTSET_FRAME (fontset
)));
883 free_realized_fontset (f
, fontset
);
884 ASET (Vfontset_table
, id
, Qnil
);
885 if (id
< next_fontset_id
)
886 next_fontset_id
= face
->fontset
;
892 /* Return 1 if FACE is suitable for displaying character C.
893 Otherwise return 0. Called from the macro FACE_SUITABLE_FOR_CHAR_P
894 when C is not an ASCII character. */
897 face_suitable_for_char_p (struct face
*face
, int c
)
899 Lisp_Object fontset
, rfont_def
;
901 fontset
= FONTSET_FROM_ID (face
->fontset
);
902 rfont_def
= fontset_font (fontset
, c
, NULL
, -1);
903 return (VECTORP (rfont_def
)
904 && INTEGERP (RFONT_DEF_FACE (rfont_def
))
905 && face
->id
== XINT (RFONT_DEF_FACE (rfont_def
)));
909 /* Return ID of face suitable for displaying character C on frame F.
910 FACE must be reazlied for ASCII characters in advance. Called from
911 the macro FACE_FOR_CHAR. */
914 face_for_char (FRAME_PTR f
, struct face
*face
, int c
, int pos
, Lisp_Object object
)
916 Lisp_Object fontset
, rfont_def
, charset
;
920 /* If face->fontset is negative (that happens when no font is found
921 for face), just return face->ascii_face because we can't do
922 anything. Perhaps, we should fix the callers to assure
923 that face->fontset is always valid. */
924 if (ASCII_CHAR_P (c
) || face
->fontset
< 0)
925 return face
->ascii_face
->id
;
927 xassert (fontset_id_valid_p (face
->fontset
));
928 fontset
= FONTSET_FROM_ID (face
->fontset
);
929 xassert (!BASE_FONTSET_P (fontset
));
938 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
939 if (CHARSETP (charset
))
943 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
944 if (CONSP (val
) && CHARSETP (XCDR (val
)))
945 charset
= XCDR (val
);
946 id
= XINT (CHARSET_SYMBOL_ID (charset
));
952 rfont_def
= fontset_font (fontset
, c
, face
, id
);
953 if (VECTORP (rfont_def
))
955 if (INTEGERP (RFONT_DEF_FACE (rfont_def
)))
956 face_id
= XINT (RFONT_DEF_FACE (rfont_def
));
959 Lisp_Object font_object
;
961 font_object
= RFONT_DEF_OBJECT (rfont_def
);
962 face_id
= face_for_font (f
, font_object
, face
);
963 RFONT_DEF_SET_FACE (rfont_def
, face_id
);
968 if (INTEGERP (FONTSET_NOFONT_FACE (fontset
)))
969 face_id
= XINT (FONTSET_NOFONT_FACE (fontset
));
972 face_id
= face_for_font (f
, Qnil
, face
);
973 FONTSET_NOFONT_FACE (fontset
) = make_number (face_id
);
976 xassert (face_id
>= 0);
982 font_for_char (struct face
*face
, int c
, int pos
, Lisp_Object object
)
984 Lisp_Object fontset
, rfont_def
, charset
;
987 if (ASCII_CHAR_P (c
))
989 Lisp_Object font_object
;
991 XSETFONT (font_object
, face
->ascii_face
->font
);
995 xassert (fontset_id_valid_p (face
->fontset
));
996 fontset
= FONTSET_FROM_ID (face
->fontset
);
997 xassert (!BASE_FONTSET_P (fontset
));
1005 charset
= Fget_char_property (make_number (pos
), Qcharset
, object
);
1006 if (CHARSETP (charset
))
1010 val
= assq_no_quit (charset
, Vfont_encoding_charset_alist
);
1011 if (CONSP (val
) && CHARSETP (XCDR (val
)))
1012 charset
= XCDR (val
);
1013 id
= XINT (CHARSET_SYMBOL_ID (charset
));
1019 rfont_def
= fontset_font (fontset
, c
, face
, id
);
1020 return (VECTORP (rfont_def
)
1021 ? RFONT_DEF_OBJECT (rfont_def
)
1026 /* Make a realized fontset for ASCII face FACE on frame F from the
1027 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1028 default fontset as the base. Value is the id of the new fontset.
1029 Called from realize_x_face. */
1032 make_fontset_for_ascii_face (FRAME_PTR f
, int base_fontset_id
, struct face
*face
)
1034 Lisp_Object base_fontset
, fontset
, frame
;
1036 XSETFRAME (frame
, f
);
1037 if (base_fontset_id
>= 0)
1039 base_fontset
= FONTSET_FROM_ID (base_fontset_id
);
1040 if (!BASE_FONTSET_P (base_fontset
))
1041 base_fontset
= FONTSET_BASE (base_fontset
);
1042 if (! BASE_FONTSET_P (base_fontset
))
1046 base_fontset
= Vdefault_fontset
;
1048 fontset
= make_fontset (frame
, Qnil
, base_fontset
);
1049 return XINT (FONTSET_ID (fontset
));
1054 /* Cache data used by fontset_pattern_regexp. The car part is a
1055 pattern string containing at least one wild card, the cdr part is
1056 the corresponding regular expression. */
1057 static Lisp_Object Vcached_fontset_data
;
1059 #define CACHED_FONTSET_NAME ((char *) SDATA (XCAR (Vcached_fontset_data)))
1060 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1062 /* If fontset name PATTERN contains any wild card, return regular
1063 expression corresponding to PATTERN. */
1066 fontset_pattern_regexp (Lisp_Object pattern
)
1068 if (!index ((char *) SDATA (pattern
), '*')
1069 && !index ((char *) SDATA (pattern
), '?'))
1070 /* PATTERN does not contain any wild cards. */
1073 if (!CONSP (Vcached_fontset_data
)
1074 || strcmp ((char *) SDATA (pattern
), CACHED_FONTSET_NAME
))
1076 /* We must at first update the cached data. */
1077 unsigned char *regex
, *p0
, *p1
;
1078 int ndashes
= 0, nstars
= 0, nescs
= 0;
1080 for (p0
= SDATA (pattern
); *p0
; p0
++)
1084 else if (*p0
== '*')
1087 || *p0
== '.' || *p0
== '\\'
1088 || *p0
== '+' || *p0
== '^'
1093 /* If PATTERN is not full XLFD we conert "*" to ".*". Otherwise
1094 we convert "*" to "[^-]*" which is much faster in regular
1095 expression matching. */
1097 p1
= regex
= (unsigned char *) alloca (SBYTES (pattern
) + 2 * nstars
+ 2 * nescs
+ 1);
1099 p1
= regex
= (unsigned char *) alloca (SBYTES (pattern
) + 5 * nstars
+ 2 * nescs
+ 1);
1102 for (p0
= SDATA (pattern
); *p0
; p0
++)
1109 *p1
++ = '[', *p1
++ = '^', *p1
++ = '-', *p1
++ = ']';
1112 else if (*p0
== '?')
1115 || *p0
== '.' || *p0
== '\\'
1116 || *p0
== '+' || *p0
== '^'
1118 *p1
++ = '\\', *p1
++ = *p0
;
1125 Vcached_fontset_data
= Fcons (build_string ((char *) SDATA (pattern
)),
1126 build_string ((char *) regex
));
1129 return CACHED_FONTSET_REGEX
;
1132 /* Return ID of the base fontset named NAME. If there's no such
1133 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1134 0: pattern containing '*' and '?' as wildcards
1135 1: regular expression
1136 2: literal fontset name
1140 fs_query_fontset (Lisp_Object name
, int name_pattern
)
1145 name
= Fdowncase (name
);
1146 if (name_pattern
!= 1)
1148 tem
= Frassoc (name
, Vfontset_alias_alist
);
1150 tem
= Fassoc (name
, Vfontset_alias_alist
);
1151 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1153 else if (name_pattern
== 0)
1155 tem
= fontset_pattern_regexp (name
);
1164 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1166 Lisp_Object fontset
, this_name
;
1168 fontset
= FONTSET_FROM_ID (i
);
1170 || !BASE_FONTSET_P (fontset
))
1173 this_name
= FONTSET_NAME (fontset
);
1174 if (name_pattern
== 1
1175 ? fast_string_match_ignore_case (name
, this_name
) >= 0
1176 : !xstrcasecmp (SDATA (name
), SDATA (this_name
)))
1183 DEFUN ("query-fontset", Fquery_fontset
, Squery_fontset
, 1, 2, 0,
1184 doc
: /* Return the name of a fontset that matches PATTERN.
1185 The value is nil if there is no matching fontset.
1186 PATTERN can contain `*' or `?' as a wildcard
1187 just as X font name matching algorithm allows.
1188 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1190 Lisp_Object pattern
, regexpp
;
1192 Lisp_Object fontset
;
1195 (*check_window_system_func
) ();
1197 CHECK_STRING (pattern
);
1199 if (SCHARS (pattern
) == 0)
1202 id
= fs_query_fontset (pattern
, !NILP (regexpp
));
1206 fontset
= FONTSET_FROM_ID (id
);
1207 return FONTSET_NAME (fontset
);
1210 /* Return a list of base fontset names matching PATTERN on frame F. */
1213 list_fontsets (FRAME_PTR f
, Lisp_Object pattern
, int size
)
1215 Lisp_Object frame
, regexp
, val
;
1218 XSETFRAME (frame
, f
);
1220 regexp
= fontset_pattern_regexp (pattern
);
1223 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1225 Lisp_Object fontset
, name
;
1227 fontset
= FONTSET_FROM_ID (id
);
1229 || !BASE_FONTSET_P (fontset
)
1230 || !EQ (frame
, FONTSET_FRAME (fontset
)))
1232 name
= FONTSET_NAME (fontset
);
1234 if (STRINGP (regexp
)
1235 ? (fast_string_match (regexp
, name
) < 0)
1236 : strcmp ((char *) SDATA (pattern
), (char *) SDATA (name
)))
1239 val
= Fcons (Fcopy_sequence (FONTSET_NAME (fontset
)), val
);
1246 /* Free all realized fontsets whose base fontset is BASE. */
1249 free_realized_fontsets (Lisp_Object base
)
1254 /* For the moment, this doesn't work because free_realized_face
1255 doesn't remove FACE from a cache. Until we find a solution, we
1256 suppress this code, and simply use Fclear_face_cache even though
1257 that is not efficient. */
1259 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1261 Lisp_Object
this = AREF (Vfontset_table
, id
);
1263 if (EQ (FONTSET_BASE (this), base
))
1267 for (tail
= FONTSET_FACE_ALIST (this); CONSP (tail
);
1270 FRAME_PTR f
= XFRAME (FONTSET_FRAME (this));
1271 int face_id
= XINT (XCDR (XCAR (tail
)));
1272 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1274 /* Face THIS itself is also freed by the following call. */
1275 free_realized_face (f
, face
);
1281 /* But, we don't have to call Fclear_face_cache if no fontset has
1282 been realized from BASE. */
1283 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1285 Lisp_Object
this = AREF (Vfontset_table
, id
);
1287 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base
))
1289 Fclear_face_cache (Qt
);
1297 /* Check validity of NAME as a fontset name and return the
1298 corresponding fontset. If not valid, signal an error.
1300 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1303 Set *FRAME to the actual frame. */
1306 check_fontset_name (Lisp_Object name
, Lisp_Object
*frame
)
1311 *frame
= selected_frame
;
1312 CHECK_LIVE_FRAME (*frame
);
1315 return Vdefault_fontset
;
1318 id
= FRAME_FONTSET (XFRAME (*frame
));
1322 CHECK_STRING (name
);
1323 /* First try NAME as literal. */
1324 id
= fs_query_fontset (name
, 2);
1326 /* For backward compatibility, try again NAME as pattern. */
1327 id
= fs_query_fontset (name
, 0);
1329 error ("Fontset `%s' does not exist", SDATA (name
));
1331 return FONTSET_FROM_ID (id
);
1335 accumulate_script_ranges (Lisp_Object arg
, Lisp_Object range
, Lisp_Object val
)
1337 if (EQ (XCAR (arg
), val
))
1340 XSETCDR (arg
, Fcons (Fcons (XCAR (range
), XCDR (range
)), XCDR (arg
)));
1342 XSETCDR (arg
, Fcons (Fcons (range
, range
), XCDR (arg
)));
1347 /* Callback function for map_charset_chars in Fset_fontset_font.
1348 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1350 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1351 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1352 The consumed ranges are poped up from SCRIPT_RANGE_LIST, and the
1353 new SCRIPT_RANGE_LIST is stored in ARG.
1355 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1356 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1360 set_fontset_font (Lisp_Object arg
, Lisp_Object range
)
1362 Lisp_Object fontset
, font_def
, add
, ascii
, script_range_list
;
1363 int from
= XINT (XCAR (range
)), to
= XINT (XCDR (range
));
1365 fontset
= AREF (arg
, 0);
1366 font_def
= AREF (arg
, 1);
1367 add
= AREF (arg
, 2);
1368 ascii
= AREF (arg
, 3);
1369 script_range_list
= AREF (arg
, 4);
1371 if (NILP (ascii
) && from
< 0x80)
1376 range
= Fcons (make_number (0x80), XCDR (range
));
1379 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1380 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1381 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1383 for (; CONSP (script_range_list
) && SCRIPT_TO
< from
; POP_SCRIPT_RANGE ())
1384 FONTSET_ADD (fontset
, XCAR (script_range_list
), font_def
, add
);
1385 if (CONSP (script_range_list
))
1387 if (SCRIPT_FROM
< from
)
1388 range
= Fcons (make_number (SCRIPT_FROM
), XCDR (range
));
1389 while (CONSP (script_range_list
) && SCRIPT_TO
<= to
)
1390 POP_SCRIPT_RANGE ();
1391 if (CONSP (script_range_list
) && SCRIPT_FROM
<= to
)
1392 XSETCAR (XCAR (script_range_list
), make_number (to
+ 1));
1395 FONTSET_ADD (fontset
, range
, font_def
, add
);
1396 ASET (arg
, 4, script_range_list
);
1399 extern Lisp_Object QCfamily
, QCregistry
;
1400 static void update_auto_fontset_alist (Lisp_Object
, Lisp_Object
);
1403 DEFUN ("set-fontset-font", Fset_fontset_font
, Sset_fontset_font
, 3, 5, 0,
1405 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1407 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1408 the default fontset.
1410 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1411 In that case, use FONT-SPEC for all characters in the range FROM and
1414 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1415 all characters that belong to the script.
1417 TARGET may be a charset. In that case, use FONT-SPEC for all
1418 characters in the charset.
1420 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1421 that no FONT-SPEC is specified.
1423 FONT-SPEC may one of these:
1424 * A font-spec object made by the function `font-spec' (which see).
1425 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1426 REGISTRY is a font registry name. FAMILY may contain foundry
1427 name, and REGISTRY may contain encoding name.
1428 * A font name string.
1429 * nil, which explicitly specifies that there's no font for TARGET.
1431 Optional 4th argument FRAME is a frame or nil for the selected frame
1432 that is concerned in the case that NAME is nil.
1434 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1435 to the font specifications for TARGET previously set. If it is
1436 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1437 appended. By default, FONT-SPEC overrides the previous settings. */)
1438 (name
, target
, font_spec
, frame
, add
)
1439 Lisp_Object name
, target
, font_spec
, frame
, add
;
1441 Lisp_Object fontset
;
1442 Lisp_Object font_def
, registry
, family
;
1443 Lisp_Object range_list
;
1444 struct charset
*charset
= NULL
;
1445 Lisp_Object fontname
;
1446 int ascii_changed
= 0;
1448 fontset
= check_fontset_name (name
, &frame
);
1451 if (CONSP (font_spec
))
1453 Lisp_Object spec
= Ffont_spec (0, NULL
);
1455 font_parse_family_registry (XCAR (font_spec
), XCDR (font_spec
), spec
);
1457 fontname
= Ffont_xlfd_name (font_spec
, Qnil
);
1459 else if (STRINGP (font_spec
))
1461 Lisp_Object args
[2];
1462 extern Lisp_Object QCname
;
1464 fontname
= font_spec
;
1466 args
[1] = font_spec
;
1467 font_spec
= Ffont_spec (2, args
);
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 encoding
= find_font_encoding (concat3 (family
, build_string ("-"),
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
= Fcons (Fcons (target
, target
), Qnil
);
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
= Fcons (target
, Qnil
);
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
= Fcons (target
, Qnil
);
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
= Fcons (Qnil
, 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
= Fmake_vector (make_number (5), Qnil
);
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
, frame
, alist
;
1598 int fontset_id
= XINT (FONTSET_ID (fontset
));
1600 FONTSET_ASCII (fontset
) = fontname
;
1601 name
= FONTSET_NAME (fontset
);
1602 FOR_EACH_FRAME (tail
, frame
)
1604 FRAME_PTR f
= XFRAME (frame
);
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 alist
= Fcons (Fcons (Qfont
, Fcons (name
, font_object
)), Qnil
);
1621 Fmodify_frame_parameters (frame
, alist
);
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. */)
1649 Lisp_Object name
, fontlist
;
1651 Lisp_Object fontset
;
1654 CHECK_STRING (name
);
1655 CHECK_LIST (fontlist
);
1657 name
= Fdowncase (name
);
1658 id
= fs_query_fontset (name
, 0);
1661 Lisp_Object font_spec
= Ffont_spec (0, NULL
);
1662 Lisp_Object short_name
;
1666 if (font_parse_xlfd ((char *) SDATA (name
), font_spec
) < 0)
1667 error ("Fontset name must be in XLFD format");
1668 short_name
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1669 if (strncmp ((char *) SDATA (SYMBOL_NAME (short_name
)), "fontset-", 8)
1670 || SBYTES (SYMBOL_NAME (short_name
)) < 9)
1671 error ("Registry field of fontset name must be \"fontset-*\"");
1672 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (short_name
)),
1673 Vfontset_alias_alist
);
1674 ASET (font_spec
, FONT_REGISTRY_INDEX
, Qiso8859_1
);
1675 fontset
= make_fontset (Qnil
, name
, Qnil
);
1676 len
= font_unparse_xlfd (font_spec
, 0, xlfd
, 256);
1678 error ("Invalid fontset name (perhaps too long): %s", SDATA (name
));
1679 FONTSET_ASCII (fontset
) = make_unibyte_string (xlfd
, len
);
1683 fontset
= FONTSET_FROM_ID (id
);
1684 free_realized_fontsets (fontset
);
1685 Fset_char_table_range (fontset
, Qt
, Qnil
);
1688 for (; ! NILP (fontlist
); fontlist
= Fcdr (fontlist
))
1690 Lisp_Object elt
, script
;
1692 elt
= Fcar (fontlist
);
1693 script
= Fcar (elt
);
1695 if (CONSP (elt
) && (NILP (XCDR (elt
)) || CONSP (XCDR (elt
))))
1696 for (; CONSP (elt
); elt
= XCDR (elt
))
1697 Fset_fontset_font (name
, script
, XCAR (elt
), Qnil
, Qappend
);
1699 Fset_fontset_font (name
, script
, elt
, Qnil
, Qappend
);
1705 /* Alist of automatically created fontsets. Each element is a cons
1706 (FONT-SPEC . FONTSET-ID). */
1707 static Lisp_Object auto_fontset_alist
;
1709 /* Number of automatically created fontsets. */
1710 static int num_auto_fontsets
;
1712 /* Retun a fontset synthesized from FONT-OBJECT. This is called from
1713 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1714 frame, and the returned fontset is used for the default fontset of
1715 that frame. The fontset specifies a font of the same registry as
1716 FONT-OBJECT for all characters in the repertory of the registry
1717 (see Vfont_encoding_alist). If the repertory is not known, the
1718 fontset specifies the font for all Latin characters assuming that a
1719 user intends to use FONT-OBJECT for Latin characters. */
1722 fontset_from_font (Lisp_Object font_object
)
1724 Lisp_Object font_name
= font_get_name (font_object
);
1725 Lisp_Object font_spec
= Fcopy_font_spec (font_object
);
1726 Lisp_Object registry
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1727 Lisp_Object fontset_spec
, alias
, name
, fontset
;
1730 val
= assoc_no_quit (font_spec
, auto_fontset_alist
);
1732 return XINT (FONTSET_ID (XCDR (val
)));
1733 if (num_auto_fontsets
++ == 0)
1734 alias
= intern ("fontset-startup");
1739 sprintf (temp
, "fontset-auto%d", num_auto_fontsets
- 1);
1740 alias
= intern (temp
);
1742 fontset_spec
= Fcopy_font_spec (font_spec
);
1743 ASET (fontset_spec
, FONT_REGISTRY_INDEX
, alias
);
1744 name
= Ffont_xlfd_name (fontset_spec
, Qnil
);
1747 fontset
= make_fontset (Qnil
, name
, Qnil
);
1748 Vfontset_alias_alist
= Fcons (Fcons (name
, SYMBOL_NAME (alias
)),
1749 Vfontset_alias_alist
);
1750 alias
= Fdowncase (AREF (font_object
, FONT_NAME_INDEX
));
1751 Vfontset_alias_alist
= Fcons (Fcons (name
, alias
), Vfontset_alias_alist
);
1752 auto_fontset_alist
= Fcons (Fcons (font_spec
, fontset
), auto_fontset_alist
);
1753 font_spec
= Ffont_spec (0, NULL
);
1754 ASET (font_spec
, FONT_REGISTRY_INDEX
, registry
);
1756 Lisp_Object target
= find_font_encoding (SYMBOL_NAME (registry
));
1759 target
= XCDR (target
);
1760 if (! CHARSETP (target
))
1762 Fset_fontset_font (name
, target
, font_spec
, Qnil
, Qnil
);
1763 Fset_fontset_font (name
, Qnil
, font_spec
, Qnil
, Qnil
);
1766 FONTSET_ASCII (fontset
) = font_name
;
1768 return XINT (FONTSET_ID (fontset
));
1772 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1773 FONTSET is changed, we delete an entry of FONTSET if any from
1774 auto_fontset_alist so that FONTSET is not re-used by
1775 fontset_from_font. */
1778 update_auto_fontset_alist (Lisp_Object font_object
, Lisp_Object fontset
)
1780 Lisp_Object prev
, tail
;
1782 for (prev
= Qnil
, tail
= auto_fontset_alist
; CONSP (tail
);
1783 prev
= tail
, tail
= XCDR (tail
))
1784 if (EQ (fontset
, XCDR (XCAR (tail
))))
1787 auto_fontset_alist
= XCDR (tail
);
1789 XSETCDR (prev
, XCDR (tail
));
1795 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1796 FONT-OBJECT is the font for the character at POSITION in the current
1797 buffer. This is computed from all the text properties and overlays
1798 that apply to POSITION. POSTION may be nil, in which case,
1799 FONT-SPEC is the font for displaying the character CH with the
1802 GLYPH-CODE is the glyph code in the font to use for the character.
1804 If the 2nd optional arg CH is non-nil, it is a character to check
1805 the font instead of the character at POSITION.
1807 It returns nil in the following cases:
1809 (1) The window system doesn't have a font for the character (thus
1810 it is displayed by an empty box).
1812 (2) The character code is invalid.
1814 (3) If POSITION is not nil, and the current buffer is not displayed
1817 In addition, the returned font name may not take into account of
1818 such redisplay engine hooks as what used in jit-lock-mode if
1819 POSITION is currently not visible. */
1822 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1823 doc
: /* For internal use only. */)
1825 Lisp_Object position
, ch
;
1827 EMACS_INT pos
, pos_byte
, dummy
;
1834 if (NILP (position
))
1836 CHECK_CHARACTER (ch
);
1838 f
= XFRAME (selected_frame
);
1839 face_id
= lookup_basic_face (f
, DEFAULT_FACE_ID
);
1845 Lisp_Object window
, charset
;
1848 CHECK_NUMBER_COERCE_MARKER (position
);
1849 pos
= XINT (position
);
1850 if (pos
< BEGV
|| pos
>= ZV
)
1851 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1852 pos_byte
= CHAR_TO_BYTE (pos
);
1854 c
= FETCH_CHAR (pos_byte
);
1860 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1863 w
= XWINDOW (window
);
1864 f
= XFRAME (w
->frame
);
1865 face_id
= face_at_buffer_position (w
, pos
, -1, -1, &dummy
,
1867 charset
= Fget_char_property (position
, Qcharset
, Qnil
);
1868 if (CHARSETP (charset
))
1869 cs_id
= XINT (CHARSET_SYMBOL_ID (charset
));
1873 if (! CHAR_VALID_P (c
, 0))
1875 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
, pos
, Qnil
);
1876 face
= FACE_FROM_ID (f
, face_id
);
1879 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
1880 Lisp_Object font_object
;
1881 /* Assignment to EMACS_INT stops GCC whining about limited range
1883 EMACS_INT cod
= code
;
1885 if (code
== FONT_INVALID_CODE
)
1887 XSETFONT (font_object
, face
->font
);
1888 if (cod
<= MOST_POSITIVE_FIXNUM
)
1889 return Fcons (font_object
, make_number (code
));
1890 return Fcons (font_object
, Fcons (make_number (code
>> 16),
1891 make_number (code
& 0xFFFF)));
1897 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1898 doc
: /* Return information about a fontset FONTSET on frame FRAME.
1900 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1901 for the default fontset. FRAME nil means the selected frame.
1903 The value is a char-table whose elements have this form:
1905 ((FONT OPENED-FONT ...) ...)
1907 FONT is a name of font specified for a range of characters.
1909 OPENED-FONT is a name of a font actually opened.
1911 The char-table has one extra slot. If FONTSET is not the default
1912 fontset, the value the extra slot is a char-table containing the
1913 information about the derived fonts from the default fontset. The
1914 format is the same as above. */)
1916 Lisp_Object fontset
, frame
;
1919 Lisp_Object
*realized
[2], fontsets
[2], tables
[2];
1920 Lisp_Object val
, elt
;
1923 (*check_window_system_func
) ();
1925 fontset
= check_fontset_name (fontset
, &frame
);
1928 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1929 in the table `realized'. */
1930 realized
[0] = (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1931 * ASIZE (Vfontset_table
));
1932 for (i
= j
= 0; i
< ASIZE (Vfontset_table
); i
++)
1934 elt
= FONTSET_FROM_ID (i
);
1936 && EQ (FONTSET_BASE (elt
), fontset
)
1937 && EQ (FONTSET_FRAME (elt
), frame
))
1938 realized
[0][j
++] = elt
;
1940 realized
[0][j
] = Qnil
;
1942 realized
[1] = (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1943 * ASIZE (Vfontset_table
));
1944 for (i
= j
= 0; ! NILP (realized
[0][i
]); i
++)
1946 elt
= FONTSET_DEFAULT (realized
[0][i
]);
1948 realized
[1][j
++] = elt
;
1950 realized
[1][j
] = Qnil
;
1952 tables
[0] = Fmake_char_table (Qfontset_info
, Qnil
);
1953 fontsets
[0] = fontset
;
1954 if (!EQ (fontset
, Vdefault_fontset
))
1956 tables
[1] = Fmake_char_table (Qnil
, Qnil
);
1957 XCHAR_TABLE (tables
[0])->extras
[0] = tables
[1];
1958 fontsets
[1] = Vdefault_fontset
;
1961 /* Accumulate information of the fontset in TABLE. The format of
1962 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1963 for (k
= 0; k
<= 1; k
++)
1965 for (c
= 0; c
<= MAX_CHAR
; )
1967 int from
= c
, to
= MAX_5_BYTE_CHAR
;
1969 if (c
<= MAX_5_BYTE_CHAR
)
1971 val
= char_table_ref_and_range (fontsets
[k
], c
, &from
, &to
);
1975 val
= FONTSET_FALLBACK (fontsets
[k
]);
1982 /* At first, set ALIST to ((FONT-SPEC) ...). */
1983 for (alist
= Qnil
, i
= 0; i
< ASIZE (val
); i
++)
1984 if (! NILP (AREF (val
, i
)))
1985 alist
= Fcons (Fcons (FONT_DEF_SPEC (AREF (val
, i
)), Qnil
),
1987 alist
= Fnreverse (alist
);
1989 /* Then store opened font names to cdr of each elements. */
1990 for (i
= 0; ! NILP (realized
[k
][i
]); i
++)
1992 if (c
<= MAX_5_BYTE_CHAR
)
1993 val
= FONTSET_REF (realized
[k
][i
], c
);
1995 val
= FONTSET_FALLBACK (realized
[k
][i
]);
1996 if (! CONSP (val
) || ! VECTORP (XCDR (val
)))
1998 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
2000 for (j
= 0; j
< ASIZE (val
); j
++)
2002 elt
= AREF (val
, j
);
2003 if (FONT_OBJECT_P (RFONT_DEF_OBJECT (elt
)))
2005 Lisp_Object font_object
= RFONT_DEF_OBJECT (elt
);
2006 Lisp_Object slot
, name
;
2008 slot
= Fassq (RFONT_DEF_SPEC (elt
), alist
);
2009 name
= AREF (font_object
, FONT_NAME_INDEX
);
2010 if (NILP (Fmember (name
, XCDR (slot
))))
2011 nconc2 (slot
, Fcons (name
, Qnil
));
2016 /* Store ALIST in TBL for characters C..TO. */
2017 if (c
<= MAX_5_BYTE_CHAR
)
2018 char_table_set_range (tables
[k
], c
, to
, alist
);
2020 XCHAR_TABLE (tables
[k
])->defalt
= alist
;
2022 /* At last, change each elements to font names. */
2023 for (; CONSP (alist
); alist
= XCDR (alist
))
2026 XSETCAR (elt
, Ffont_xlfd_name (XCAR (elt
), Qnil
));
2031 if (EQ (fontset
, Vdefault_fontset
))
2039 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 3, 0,
2040 doc
: /* Return a font name pattern for character CH in fontset NAME.
2041 If NAME is t, find a pattern in the default fontset.
2042 If NAME is nil, find a pattern in the fontset of the selected frame.
2044 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2045 family name and REGISTRY is a font registry name. This is actually
2046 the first font name pattern for CH in the fontset or in the default
2049 If the 2nd optional arg ALL is non-nil, return a list of all font name
2052 Lisp_Object name
, ch
, all
;
2055 Lisp_Object fontset
, elt
, list
, repertory
, val
;
2060 fontset
= check_fontset_name (name
, &frame
);
2062 CHECK_CHARACTER (ch
);
2067 for (i
= 0, elt
= FONTSET_REF (fontset
, c
); i
< 2;
2068 i
++, elt
= FONTSET_FALLBACK (fontset
))
2070 for (j
= 0; j
< ASIZE (elt
); j
++)
2072 Lisp_Object family
, registry
;
2074 val
= AREF (elt
, j
);
2077 repertory
= AREF (val
, 1);
2078 if (INTEGERP (repertory
))
2080 struct charset
*charset
= CHARSET_FROM_ID (XINT (repertory
));
2082 if (! CHAR_CHARSET_P (c
, charset
))
2085 else if (CHAR_TABLE_P (repertory
))
2087 if (NILP (CHAR_TABLE_REF (repertory
, c
)))
2090 val
= AREF (val
, 0);
2091 /* VAL is a FONT-SPEC */
2092 family
= AREF (val
, FONT_FAMILY_INDEX
);
2093 if (! NILP (family
))
2094 family
= SYMBOL_NAME (family
);
2095 registry
= AREF (val
, FONT_REGISTRY_INDEX
);
2096 if (! NILP (registry
))
2097 registry
= SYMBOL_NAME (registry
);
2098 val
= Fcons (family
, registry
);
2101 list
= Fcons (val
, list
);
2103 if (EQ (fontset
, Vdefault_fontset
))
2105 fontset
= Vdefault_fontset
;
2107 return (Fnreverse (list
));
2110 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
2111 doc
: /* Return a list of all defined fontset names. */)
2114 Lisp_Object fontset
, list
;
2118 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
2120 fontset
= FONTSET_FROM_ID (i
);
2122 && BASE_FONTSET_P (fontset
))
2123 list
= Fcons (FONTSET_NAME (fontset
), list
);
2130 #ifdef FONTSET_DEBUG
2133 dump_fontset (fontset
)
2134 Lisp_Object fontset
;
2138 vec
= Fmake_vector (make_number (3), Qnil
);
2139 ASET (vec
, 0, FONTSET_ID (fontset
));
2141 if (BASE_FONTSET_P (fontset
))
2143 ASET (vec
, 1, FONTSET_NAME (fontset
));
2149 frame
= FONTSET_FRAME (fontset
);
2152 FRAME_PTR f
= XFRAME (frame
);
2154 if (FRAME_LIVE_P (f
))
2156 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), f
->name
));
2159 Fcons (FONTSET_NAME (FONTSET_BASE (fontset
)), Qnil
));
2161 if (!NILP (FONTSET_DEFAULT (fontset
)))
2162 ASET (vec
, 2, FONTSET_ID (FONTSET_DEFAULT (fontset
)));
2167 DEFUN ("fontset-list-all", Ffontset_list_all
, Sfontset_list_all
, 0, 0, 0,
2168 doc
: /* Return a brief summary of all fontsets for debug use. */)
2174 for (i
= 0, val
= Qnil
; i
< ASIZE (Vfontset_table
); i
++)
2175 if (! NILP (AREF (Vfontset_table
, i
)))
2176 val
= Fcons (dump_fontset (AREF (Vfontset_table
, i
)), val
);
2177 return (Fnreverse (val
));
2179 #endif /* FONTSET_DEBUG */
2182 syms_of_fontset (void)
2184 DEFSYM (Qfontset
, "fontset");
2185 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (9));
2186 DEFSYM (Qfontset_info
, "fontset-info");
2187 Fput (Qfontset_info
, Qchar_table_extra_slots
, make_number (1));
2189 DEFSYM (Qprepend
, "prepend");
2190 DEFSYM (Qappend
, "append");
2191 DEFSYM (Qlatin
, "latin");
2193 Vcached_fontset_data
= Qnil
;
2194 staticpro (&Vcached_fontset_data
);
2196 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
2197 staticpro (&Vfontset_table
);
2199 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
2200 staticpro (&Vdefault_fontset
);
2201 FONTSET_ID (Vdefault_fontset
) = make_number (0);
2202 FONTSET_NAME (Vdefault_fontset
)
2203 = make_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
2204 ASET (Vfontset_table
, 0, Vdefault_fontset
);
2205 next_fontset_id
= 1;
2207 auto_fontset_alist
= Qnil
;
2208 staticpro (&auto_fontset_alist
);
2210 DEFVAR_LISP ("font-encoding-charset-alist", &Vfont_encoding_charset_alist
,
2212 Alist of charsets vs the charsets to determine the preferred font encoding.
2213 Each element looks like (CHARSET . ENCODING-CHARSET),
2214 where ENCODING-CHARSET is a charset registered in the variable
2215 `font-encoding-alist' as ENCODING.
2217 When a text has a property `charset' and the value is CHARSET, a font
2218 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2219 Vfont_encoding_charset_alist
= Qnil
;
2221 DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent
,
2223 Char table of characters whose ascent values should be ignored.
2224 If an entry for a character is non-nil, the ascent value of the glyph
2225 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2227 This affects how a composite character which contains
2228 such a character is displayed on screen. */);
2229 Vuse_default_ascent
= Qnil
;
2231 DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition
,
2233 Char table of characters which are not composed relatively.
2234 If an entry for a character is non-nil, a composition sequence
2235 which contains that character is displayed so that
2236 the glyph of that character is put without considering
2237 an ascent and descent value of a previous character. */);
2238 Vignore_relative_composition
= Qnil
;
2240 DEFVAR_LISP ("alternate-fontname-alist", &Valternate_fontname_alist
,
2241 doc
: /* Alist of fontname vs list of the alternate fontnames.
2242 When a specified font name is not found, the corresponding
2243 alternate fontnames (if any) are tried instead. */);
2244 Valternate_fontname_alist
= Qnil
;
2246 DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist
,
2247 doc
: /* Alist of fontset names vs the aliases. */);
2248 Vfontset_alias_alist
= Fcons (Fcons (FONTSET_NAME (Vdefault_fontset
),
2249 make_pure_c_string ("fontset-default")),
2252 DEFVAR_LISP ("vertical-centering-font-regexp",
2253 &Vvertical_centering_font_regexp
,
2254 doc
: /* *Regexp matching font names that require vertical centering on display.
2255 When a character is displayed with such fonts, the character is displayed
2256 at the vertical center of lines. */);
2257 Vvertical_centering_font_regexp
= Qnil
;
2259 DEFVAR_LISP ("otf-script-alist", &Votf_script_alist
,
2260 doc
: /* Alist of OpenType script tags vs the corresponding script names. */);
2261 Votf_script_alist
= Qnil
;
2263 defsubr (&Squery_fontset
);
2264 defsubr (&Snew_fontset
);
2265 defsubr (&Sset_fontset_font
);
2266 defsubr (&Sinternal_char_font
);
2267 defsubr (&Sfontset_info
);
2268 defsubr (&Sfontset_font
);
2269 defsubr (&Sfontset_list
);
2270 #ifdef FONTSET_DEBUG
2271 defsubr (&Sfontset_list_all
);
2275 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
2276 (do not change this comment) */