Stop vc-print-log from jumping to the top
[emacs.git] / src / fontset.c
blob763d84628b54dc4af8136c299a38c57fa16f0768
1 /* Fontset handler.
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/>. */
27 #include <config.h>
28 #include <stdio.h>
30 #include "lisp.h"
31 #include "blockinput.h"
32 #include "character.h"
33 #include "buffer.h"
34 #include "charset.h"
35 #include "ccl.h"
36 #include "keyboard.h"
37 #include "frame.h"
38 #include "dispextern.h"
39 #include "intervals.h"
40 #include "fontset.h"
41 #include "window.h"
42 #ifdef HAVE_WINDOW_SYSTEM
43 #include TERM_HEADER
44 #endif /* HAVE_WINDOW_SYSTEM */
45 #include "termhooks.h"
46 #include "font.h"
48 /* FONTSET
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
73 form:
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
83 priority list.
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
89 range of characters.
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
93 default fontset.
95 A fontset has 8 extra slots.
97 The 1st slot:
98 base: the ID number of the fontset
99 realized: Likewise
101 The 2nd slot:
102 base: the name of the fontset
103 realized: nil
105 The 3rd slot:
106 base: the font name for ASCII characters
107 realized: nil
109 The 4th slot:
110 base: nil
111 realized: the base fontset
113 The 5th slot:
114 base: nil
115 realized: the frame that the fontset belongs to
117 The 6th slot:
118 base: nil
119 realized: the ID number of a face to use for characters that
120 has no font in a realized fontset.
122 The 7th slot:
123 base: nil
124 realized: If the base is not the default fontset, a fontset
125 realized from the default fontset, else nil.
127 The 8th slot:
128 base: Same as element value (but for fallback fonts).
129 realized: Likewise.
131 All fontsets are recorded in the vector Vfontset_table.
134 DEFAULT FONTSET
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. */
172 static bool
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]
188 static void
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]
197 static void
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]
204 static void
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]
213 static void
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]
220 static void
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]
227 static void
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]
234 static void
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]
243 static void
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) \
253 do { \
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); \
258 } while (0)
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
275 preferable. */
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) \
280 do { \
281 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
282 ASET ((rfont_def), 1, (font_def)); \
283 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
284 } while (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
290 fontset. */
292 #define FONTSET_REF(fontset, c) \
293 (EQ (fontset, Vdefault_fontset) \
294 ? CHAR_TABLE_REF (fontset, c) \
295 : fontset_ref ((fontset), (c)))
297 static Lisp_Object
298 fontset_ref (Lisp_Object fontset, int c)
300 Lisp_Object elt;
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);
307 return elt;
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,
322 append ELT. */
324 #define FONTSET_ADD(fontset, range, elt, add) \
325 (NILP (add) \
326 ? (NILP (range) \
327 ? (set_fontset_fallback \
328 (fontset, Fmake_vector (make_number (1), (elt)))) \
329 : ((void) \
330 Fset_char_table_range (fontset, range, \
331 Fmake_vector (make_number (1), elt)))) \
332 : fontset_add ((fontset), (range), (elt), (add)))
334 static void
335 fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Object add)
337 Lisp_Object args[2];
338 int idx = (EQ (add, Qappend) ? 0 : 1);
340 args[1 - idx] = Fmake_vector (make_number (1), elt);
342 if (CONSP (range))
344 int from = XINT (XCAR (range));
345 int to = XINT (XCDR (range));
346 int from1, to1;
348 do {
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)));
354 from = to1 + 1;
355 } while (from < to);
357 else
359 args[idx] = FONTSET_FALLBACK (fontset);
360 set_fontset_fallback (fontset,
361 (NILP (args[idx]) ? args[1 - idx]
362 : CALLMANY (Fvconcat, args)));
366 static int
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. */
382 static void
383 reorder_font_vector (Lisp_Object font_group, struct font *font)
385 Lisp_Object vec, font_object;
386 int size;
387 int i;
388 bool score_changed = false;
390 if (font)
391 XSETFONT (font_object, font);
392 else
393 font_object = Qnil;
395 vec = XCDR (font_group);
396 size = ASIZE (vec);
397 /* Exclude the tailing nil element from the reordering. */
398 if (NILP (AREF (vec, size - 1)))
399 size--;
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
411 and language.. */
413 else if (! font_match_p (font_spec, font_object))
415 Lisp_Object encoding = FONT_DEF_ENCODING (font_def);
417 if (! NILP (encoding))
419 Lisp_Object tail;
421 for (tail = Vcharset_ordered_list;
422 ! EQ (tail, Vcharset_non_preferred_head) && CONSP (tail);
423 tail = XCDR (tail))
424 if (EQ (encoding, XCAR (tail)))
425 break;
426 else if (score <= min (INT_MAX, MOST_POSITIVE_FIXNUM) - 0x100)
427 score += 0x100;
429 else
431 Lisp_Object lang = Ffont_get (font_spec, QClang);
433 if (! NILP (lang)
434 && ! EQ (lang, Vcurrent_iso639_language)
435 && (! CONSP (Vcurrent_iso639_language)
436 || NILP (Fmemq (lang, Vcurrent_iso639_language))))
437 score |= 0x100;
440 if (RFONT_DEF_SCORE (rfont_def) != score)
442 RFONT_DEF_SET_SCORE (rfont_def, score);
443 score_changed = true;
447 if (score_changed)
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). */
460 static Lisp_Object
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));
468 if (c >= 0)
469 font_group = CHAR_TABLE_REF (fontset, c);
470 else
471 font_group = FONTSET_FALLBACK (fontset);
472 if (! NILP (font_group))
473 return font_group;
474 base_fontset = FONTSET_BASE (fontset);
475 if (NILP (base_fontset))
476 font_group = Qnil;
477 else if (c >= 0)
478 font_group = char_table_ref_and_range (base_fontset, c, &from, &to);
479 else
480 font_group = FONTSET_FALLBACK (base_fontset);
481 if (NILP (font_group))
483 font_group = make_number (0);
484 if (c >= 0)
485 char_table_set_range (fontset, from, to, font_group);
486 return font_group;
488 if (!VECTORP (font_group))
489 return 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);
502 if (c >= 0)
503 char_table_set_range (fontset, from, to, font_group);
504 else
505 set_fontset_fallback (fontset, font_group);
506 return 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
518 preference.
520 If FALLBACK, search only fallback fonts. */
522 static Lisp_Object
523 fontset_find_font (Lisp_Object fontset, int c, struct face *face, int id,
524 bool fallback)
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))
535 return font_group;
536 vec = XCDR (font_group);
537 if (ASIZE (vec) == 0)
538 return Qnil;
540 if (ASIZE (vec) > 1)
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);
546 if (id >= 0)
547 /* Find a spec matching with the charset ID to try at
548 first. */
549 for (i = 0; i < ASIZE (vec); i++)
551 Lisp_Object repertory;
553 rfont_def = AREF (vec, i);
554 if (NILP (rfont_def))
555 break;
556 repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));
558 if (XINT (repertory) == id)
560 charset_matched = i;
561 break;
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;
572 found_index = i;
573 if (i == 0)
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
580 next loop. */
581 charset_matched = - charset_matched;
582 /* We must try the first element in the next loop. */
583 i--;
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))
597 break;
598 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
599 break;
601 continue;
604 rfont_def = AREF (vec, found_index);
605 if (NILP (rfont_def))
607 if (i < 0)
608 continue;
609 /* This is a sign of not to try the other fonts. */
610 return Qt;
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. */
615 continue;
617 font_object = RFONT_DEF_OBJECT (rfont_def);
618 if (NILP (font_object))
620 font_def = RFONT_DEF_FONT_DEF (rfont_def);
622 if (! face)
623 /* We have not yet opened the font. */
624 return Qnil;
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);
635 continue;
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
645 have such an API. */
646 RFONT_DEF_SET_FACE (rfont_def, -1);
647 continue;
649 RFONT_DEF_SET_OBJECT (rfont_def, font_object);
652 if (font_has_char (f, font_object, c))
653 goto found;
655 /* Find a font already opened, matching with the current spec,
656 and supporting C. */
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))
662 break;
663 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
664 break;
665 font_object = RFONT_DEF_OBJECT (rfont_def);
666 if (! NILP (font_object) && font_has_char (f, font_object, c))
668 found_index++;
669 goto found;
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
679 that font in VEC. */
680 Lisp_Object new_vec;
681 int j;
683 font_object = font_open_for_lface (f, font_entity, face->lface,
684 Qnil);
685 if (NILP (font_object))
686 continue;
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);
691 found_index++;
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);
698 vec = new_vec;
699 goto found;
701 if (i >= 0)
702 i = found_index;
705 FONTSET_SET (fontset, make_number (c), make_number (0));
706 return Qnil;
708 found:
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
714 quickly. */
715 for (i = found_index; i > 0; i--)
716 ASET (vec, i, AREF (vec, i - 1));
717 ASET (vec, 0, rfont_def);
719 return rfont_def;
723 static Lisp_Object
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))
733 return 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)))
742 set_fontset_default
743 (fontset,
744 make_fontset (FONTSET_FRAME (fontset), Qnil, Vdefault_fontset));
745 FONT_DEFERRED_LOG ("default fontset: font for", make_number (c), Qnil);
746 default_rfont_def
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),
752 make_number (0));
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))
761 return 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))
773 return rfont_def;
774 /* Remember that the default fontset has no font for C. */
775 FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c), Qt);
778 return Qnil;
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
783 BASE. */
785 static Lisp_Object
786 make_fontset (Lisp_Object frame, Lisp_Object name, Lisp_Object base)
788 Lisp_Object fontset;
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
796 id. */
797 while (!NILP (AREF (Vfontset_table, id))) id++;
799 if (id + 1 == size)
800 Vfontset_table = larger_vector (Vfontset_table, 1, -1);
802 fontset = Fmake_char_table (Qfontset, Qnil);
804 set_fontset_id (fontset, make_number (id));
805 if (NILP (base))
806 set_fontset_name (fontset, name);
807 else
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;
816 return fontset;
820 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
822 /* Return the name of the fontset who has ID. */
824 Lisp_Object
825 fontset_name (int id)
827 Lisp_Object fontset;
829 fontset = FONTSET_FROM_ID (id);
830 return FONTSET_NAME (fontset);
834 /* Return the ASCII font name of the fontset who has ID. */
836 Lisp_Object
837 fontset_ascii (int id)
839 Lisp_Object fontset, elt;
841 fontset= FONTSET_FROM_ID (id);
842 elt = FONTSET_ASCII (fontset);
843 if (CONSP (elt))
844 elt = XCAR (elt);
845 return elt;
848 /* Free fontset of FACE defined on frame F. Called from
849 free_realized_face. */
851 void
852 free_face_fontset (struct frame *f, struct face *face)
854 Lisp_Object fontset;
856 fontset = FONTSET_FROM_ID (face->fontset);
857 if (NILP (fontset))
858 return;
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;
875 face->fontset = -1;
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;
887 int face_id;
888 int id;
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 #ifdef HAVE_NS
896 if (face->font)
898 /* Fonts often have characters in other scripts, like symbol, even if they
899 don't match script: symbol. So check if the character is present
900 in the current face first. Only enable for NS for now, but should
901 perhaps be general? */
902 Lisp_Object font_object;
903 XSETFONT (font_object, face->font);
904 if (font_has_char (f, font_object, c)) return face->id;
906 #endif
908 fontset = FONTSET_FROM_ID (face->fontset);
909 eassert (!BASE_FONTSET_P (fontset));
911 if (pos < 0)
913 id = -1;
914 charset = Qnil;
916 else
918 charset = Fget_char_property (make_number (pos), Qcharset, object);
919 if (CHARSETP (charset))
921 Lisp_Object val;
923 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
924 if (CONSP (val) && CHARSETP (XCDR (val)))
925 charset = XCDR (val);
926 id = XINT (CHARSET_SYMBOL_ID (charset));
928 else
929 id = -1;
932 rfont_def = fontset_font (fontset, c, face, id);
933 if (VECTORP (rfont_def))
935 if (INTEGERP (RFONT_DEF_FACE (rfont_def)))
936 face_id = XINT (RFONT_DEF_FACE (rfont_def));
937 else
939 Lisp_Object font_object;
941 font_object = RFONT_DEF_OBJECT (rfont_def);
942 face_id = face_for_font (f, font_object, face);
943 RFONT_DEF_SET_FACE (rfont_def, face_id);
946 else
948 if (INTEGERP (FONTSET_NOFONT_FACE (fontset)))
949 face_id = XINT (FONTSET_NOFONT_FACE (fontset));
950 else
952 face_id = face_for_font (f, Qnil, face);
953 set_fontset_nofont_face (fontset, make_number (face_id));
956 eassert (face_id >= 0);
957 return face_id;
961 Lisp_Object
962 font_for_char (struct face *face, int c, ptrdiff_t pos, Lisp_Object object)
964 Lisp_Object fontset, rfont_def, charset;
965 int id;
967 if (ASCII_CHAR_P (c))
969 Lisp_Object font_object;
971 XSETFONT (font_object, face->ascii_face->font);
972 return font_object;
975 eassert (fontset_id_valid_p (face->fontset));
976 fontset = FONTSET_FROM_ID (face->fontset);
977 eassert (!BASE_FONTSET_P (fontset));
978 if (pos < 0)
980 id = -1;
981 charset = Qnil;
983 else
985 charset = Fget_char_property (make_number (pos), Qcharset, object);
986 if (CHARSETP (charset))
988 Lisp_Object val;
990 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
991 if (CONSP (val) && CHARSETP (XCDR (val)))
992 charset = XCDR (val);
993 id = XINT (CHARSET_SYMBOL_ID (charset));
995 else
996 id = -1;
999 rfont_def = fontset_font (fontset, c, face, id);
1000 return (VECTORP (rfont_def)
1001 ? RFONT_DEF_OBJECT (rfont_def)
1002 : Qnil);
1006 /* Make a realized fontset for ASCII face FACE on frame F from the
1007 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1008 default fontset as the base. Value is the id of the new fontset.
1009 Called from realize_x_face. */
1012 make_fontset_for_ascii_face (struct frame *f, int base_fontset_id, struct face *face)
1014 Lisp_Object base_fontset, fontset, frame;
1016 XSETFRAME (frame, f);
1017 if (base_fontset_id >= 0)
1019 base_fontset = FONTSET_FROM_ID (base_fontset_id);
1020 if (!BASE_FONTSET_P (base_fontset))
1021 base_fontset = FONTSET_BASE (base_fontset);
1022 eassert (BASE_FONTSET_P (base_fontset));
1024 else
1025 base_fontset = Vdefault_fontset;
1027 fontset = make_fontset (frame, Qnil, base_fontset);
1028 return XINT (FONTSET_ID (fontset));
1033 /* Cache data used by fontset_pattern_regexp. The car part is a
1034 pattern string containing at least one wild card, the cdr part is
1035 the corresponding regular expression. */
1036 static Lisp_Object Vcached_fontset_data;
1038 #define CACHED_FONTSET_NAME SSDATA (XCAR (Vcached_fontset_data))
1039 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1041 /* If fontset name PATTERN contains any wild card, return regular
1042 expression corresponding to PATTERN. */
1044 static Lisp_Object
1045 fontset_pattern_regexp (Lisp_Object pattern)
1047 if (!strchr (SSDATA (pattern), '*')
1048 && !strchr (SSDATA (pattern), '?'))
1049 /* PATTERN does not contain any wild cards. */
1050 return Qnil;
1052 if (!CONSP (Vcached_fontset_data)
1053 || strcmp (SSDATA (pattern), CACHED_FONTSET_NAME))
1055 /* We must at first update the cached data. */
1056 unsigned char *regex, *p0, *p1;
1057 int ndashes = 0, nstars = 0, nescs = 0;
1059 for (p0 = SDATA (pattern); *p0; p0++)
1061 if (*p0 == '-')
1062 ndashes++;
1063 else if (*p0 == '*')
1064 nstars++;
1065 else if (*p0 == '['
1066 || *p0 == '.' || *p0 == '\\'
1067 || *p0 == '+' || *p0 == '^'
1068 || *p0 == '$')
1069 nescs++;
1072 /* If PATTERN is not full XLFD we convert "*" to ".*". Otherwise
1073 we convert "*" to "[^-]*" which is much faster in regular
1074 expression matching. */
1075 ptrdiff_t regexsize = (SBYTES (pattern)
1076 + (ndashes < 14 ? 2 : 5) * nstars
1077 + 2 * nescs + 3);
1078 USE_SAFE_ALLOCA;
1079 p1 = regex = SAFE_ALLOCA (regexsize);
1081 *p1++ = '^';
1082 for (p0 = SDATA (pattern); *p0; p0++)
1084 if (*p0 == '*')
1086 if (ndashes < 14)
1087 *p1++ = '.';
1088 else
1089 *p1++ = '[', *p1++ = '^', *p1++ = '-', *p1++ = ']';
1090 *p1++ = '*';
1092 else if (*p0 == '?')
1093 *p1++ = '.';
1094 else if (*p0 == '['
1095 || *p0 == '.' || *p0 == '\\'
1096 || *p0 == '+' || *p0 == '^'
1097 || *p0 == '$')
1098 *p1++ = '\\', *p1++ = *p0;
1099 else
1100 *p1++ = *p0;
1102 *p1++ = '$';
1103 *p1++ = 0;
1105 Vcached_fontset_data = Fcons (build_string (SSDATA (pattern)),
1106 build_string ((char *) regex));
1107 SAFE_FREE ();
1110 return CACHED_FONTSET_REGEX;
1113 /* Return ID of the base fontset named NAME. If there's no such
1114 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1115 0: pattern containing '*' and '?' as wildcards
1116 1: regular expression
1117 2: literal fontset name
1121 fs_query_fontset (Lisp_Object name, int name_pattern)
1123 Lisp_Object tem;
1124 int i;
1126 name = Fdowncase (name);
1127 if (name_pattern != 1)
1129 tem = Frassoc (name, Vfontset_alias_alist);
1130 if (NILP (tem))
1131 tem = Fassoc (name, Vfontset_alias_alist);
1132 if (CONSP (tem) && STRINGP (XCAR (tem)))
1133 name = XCAR (tem);
1134 else if (name_pattern == 0)
1136 tem = fontset_pattern_regexp (name);
1137 if (STRINGP (tem))
1139 name = tem;
1140 name_pattern = 1;
1145 for (i = 0; i < ASIZE (Vfontset_table); i++)
1147 Lisp_Object fontset, this_name;
1149 fontset = FONTSET_FROM_ID (i);
1150 if (NILP (fontset)
1151 || !BASE_FONTSET_P (fontset))
1152 continue;
1154 this_name = FONTSET_NAME (fontset);
1155 if (name_pattern == 1
1156 ? fast_string_match_ignore_case (name, this_name) >= 0
1157 : !xstrcasecmp (SSDATA (name), SSDATA (this_name)))
1158 return i;
1160 return -1;
1164 DEFUN ("query-fontset", Fquery_fontset, Squery_fontset, 1, 2, 0,
1165 doc: /* Return the name of a fontset that matches PATTERN.
1166 The value is nil if there is no matching fontset.
1167 PATTERN can contain `*' or `?' as a wildcard
1168 just as X font name matching algorithm allows.
1169 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1170 (Lisp_Object pattern, Lisp_Object regexpp)
1172 Lisp_Object fontset;
1173 int id;
1175 check_window_system (NULL);
1177 CHECK_STRING (pattern);
1179 if (SCHARS (pattern) == 0)
1180 return Qnil;
1182 id = fs_query_fontset (pattern, !NILP (regexpp));
1183 if (id < 0)
1184 return Qnil;
1186 fontset = FONTSET_FROM_ID (id);
1187 return FONTSET_NAME (fontset);
1190 /* Return a list of base fontset names matching PATTERN on frame F. */
1192 Lisp_Object
1193 list_fontsets (struct frame *f, Lisp_Object pattern, int size)
1195 Lisp_Object frame, regexp, val;
1196 int id;
1198 XSETFRAME (frame, f);
1200 regexp = fontset_pattern_regexp (pattern);
1201 val = Qnil;
1203 for (id = 0; id < ASIZE (Vfontset_table); id++)
1205 Lisp_Object fontset, name;
1207 fontset = FONTSET_FROM_ID (id);
1208 if (NILP (fontset)
1209 || !BASE_FONTSET_P (fontset)
1210 || !EQ (frame, FONTSET_FRAME (fontset)))
1211 continue;
1212 name = FONTSET_NAME (fontset);
1214 if (STRINGP (regexp)
1215 ? (fast_string_match (regexp, name) < 0)
1216 : strcmp (SSDATA (pattern), SSDATA (name)))
1217 continue;
1219 val = Fcons (Fcopy_sequence (FONTSET_NAME (fontset)), val);
1222 return val;
1226 /* Free all realized fontsets whose base fontset is BASE. */
1228 static void
1229 free_realized_fontsets (Lisp_Object base)
1231 int id;
1233 #if 0
1234 /* For the moment, this doesn't work because free_realized_face
1235 doesn't remove FACE from a cache. Until we find a solution, we
1236 suppress this code, and simply use Fclear_face_cache even though
1237 that is not efficient. */
1238 block_input ();
1239 for (id = 0; id < ASIZE (Vfontset_table); id++)
1241 Lisp_Object this = AREF (Vfontset_table, id);
1243 if (EQ (FONTSET_BASE (this), base))
1245 Lisp_Object tail;
1247 for (tail = FONTSET_FACE_ALIST (this); CONSP (tail);
1248 tail = XCDR (tail))
1250 struct frame *f = XFRAME (FONTSET_FRAME (this));
1251 int face_id = XINT (XCDR (XCAR (tail)));
1252 struct face *face = FACE_FROM_ID (f, face_id);
1254 /* Face THIS itself is also freed by the following call. */
1255 free_realized_face (f, face);
1259 unblock_input ();
1260 #else /* not 0 */
1261 /* But, we don't have to call Fclear_face_cache if no fontset has
1262 been realized from BASE. */
1263 for (id = 0; id < ASIZE (Vfontset_table); id++)
1265 Lisp_Object this = AREF (Vfontset_table, id);
1267 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base))
1269 Fclear_face_cache (Qt);
1270 break;
1273 #endif /* not 0 */
1277 /* Check validity of NAME as a fontset name and return the
1278 corresponding fontset. If not valid, signal an error.
1280 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1281 fontset of *FRAME.
1283 Set *FRAME to the actual frame. */
1285 static Lisp_Object
1286 check_fontset_name (Lisp_Object name, Lisp_Object *frame)
1288 int id;
1289 struct frame *f = decode_live_frame (*frame);
1291 XSETFRAME (*frame, f);
1293 if (EQ (name, Qt))
1294 return Vdefault_fontset;
1295 if (NILP (name))
1296 id = FRAME_FONTSET (f);
1297 else
1299 CHECK_STRING (name);
1300 /* First try NAME as literal. */
1301 id = fs_query_fontset (name, 2);
1302 if (id < 0)
1303 /* For backward compatibility, try again NAME as pattern. */
1304 id = fs_query_fontset (name, 0);
1305 if (id < 0)
1306 error ("Fontset `%s' does not exist", SDATA (name));
1308 return FONTSET_FROM_ID (id);
1311 static void
1312 accumulate_script_ranges (Lisp_Object arg, Lisp_Object range, Lisp_Object val)
1314 if (EQ (XCAR (arg), val))
1316 if (CONSP (range))
1317 XSETCDR (arg, Fcons (Fcons (XCAR (range), XCDR (range)), XCDR (arg)));
1318 else
1319 XSETCDR (arg, Fcons (Fcons (range, range), XCDR (arg)));
1324 /* Callback function for map_charset_chars in Fset_fontset_font.
1325 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1327 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1328 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1329 The consumed ranges are popped up from SCRIPT_RANGE_LIST, and the
1330 new SCRIPT_RANGE_LIST is stored in ARG.
1332 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1333 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1334 case. */
1336 static void
1337 set_fontset_font (Lisp_Object arg, Lisp_Object range)
1339 Lisp_Object fontset, font_def, add, ascii, script_range_list;
1340 int from = XINT (XCAR (range)), to = XINT (XCDR (range));
1342 fontset = AREF (arg, 0);
1343 font_def = AREF (arg, 1);
1344 add = AREF (arg, 2);
1345 ascii = AREF (arg, 3);
1346 script_range_list = AREF (arg, 4);
1348 if (NILP (ascii) && from < 0x80)
1350 if (to < 0x80)
1351 return;
1352 from = 0x80;
1353 range = Fcons (make_number (0x80), XCDR (range));
1356 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1357 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1358 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1360 for (; CONSP (script_range_list) && SCRIPT_TO < from; POP_SCRIPT_RANGE ())
1361 FONTSET_ADD (fontset, XCAR (script_range_list), font_def, add);
1362 if (CONSP (script_range_list))
1364 if (SCRIPT_FROM < from)
1365 range = Fcons (make_number (SCRIPT_FROM), XCDR (range));
1366 while (CONSP (script_range_list) && SCRIPT_TO <= to)
1367 POP_SCRIPT_RANGE ();
1368 if (CONSP (script_range_list) && SCRIPT_FROM <= to)
1369 XSETCAR (XCAR (script_range_list), make_number (to + 1));
1372 FONTSET_ADD (fontset, range, font_def, add);
1373 ASET (arg, 4, script_range_list);
1376 static void update_auto_fontset_alist (Lisp_Object, Lisp_Object);
1379 DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 5, 0,
1380 doc: /*
1381 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1383 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1384 the default fontset.
1386 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1387 In that case, use FONT-SPEC for all characters in the range FROM and
1388 TO (inclusive).
1390 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1391 all characters that belong to the script.
1393 TARGET may be a charset. In that case, use FONT-SPEC for all
1394 characters in the charset.
1396 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1397 that no FONT-SPEC is specified.
1399 FONT-SPEC may one of these:
1400 * A font-spec object made by the function `font-spec' (which see).
1401 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1402 REGISTRY is a font registry name. FAMILY may contain foundry
1403 name, and REGISTRY may contain encoding name.
1404 * A font name string.
1405 * nil, which explicitly specifies that there's no font for TARGET.
1407 Optional 4th argument FRAME is a frame or nil for the selected frame
1408 that is concerned in the case that NAME is nil.
1410 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1411 to the font specifications for TARGET previously set. If it is
1412 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1413 appended. By default, FONT-SPEC overrides the previous settings. */)
1414 (Lisp_Object name, Lisp_Object target, Lisp_Object font_spec, Lisp_Object frame, Lisp_Object add)
1416 Lisp_Object fontset;
1417 Lisp_Object font_def, registry, family;
1418 Lisp_Object range_list;
1419 struct charset *charset = NULL;
1420 Lisp_Object fontname;
1421 bool ascii_changed = 0;
1423 fontset = check_fontset_name (name, &frame);
1425 fontname = Qnil;
1426 if (CONSP (font_spec))
1428 Lisp_Object spec = Ffont_spec (0, NULL);
1430 font_parse_family_registry (XCAR (font_spec), XCDR (font_spec), spec);
1431 font_spec = spec;
1432 fontname = Ffont_xlfd_name (font_spec, Qnil);
1434 else if (STRINGP (font_spec))
1436 fontname = font_spec;
1437 font_spec = CALLN (Ffont_spec, QCname, fontname);
1439 else if (FONT_SPEC_P (font_spec))
1440 fontname = Ffont_xlfd_name (font_spec, Qnil);
1441 else if (! NILP (font_spec))
1442 Fsignal (Qfont, list2 (build_string ("Invalid font-spec"), font_spec));
1444 if (! NILP (font_spec))
1446 Lisp_Object encoding, repertory;
1448 family = AREF (font_spec, FONT_FAMILY_INDEX);
1449 if (! NILP (family) )
1450 family = SYMBOL_NAME (family);
1451 registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1452 if (! NILP (registry))
1453 registry = Fdowncase (SYMBOL_NAME (registry));
1454 AUTO_STRING (dash, "-");
1455 encoding = find_font_encoding (concat3 (family, dash, registry));
1456 if (NILP (encoding))
1457 encoding = Qascii;
1459 if (SYMBOLP (encoding))
1461 CHECK_CHARSET (encoding);
1462 encoding = repertory = CHARSET_SYMBOL_ID (encoding);
1464 else
1466 repertory = XCDR (encoding);
1467 encoding = XCAR (encoding);
1468 CHECK_CHARSET (encoding);
1469 encoding = CHARSET_SYMBOL_ID (encoding);
1470 if (! NILP (repertory) && SYMBOLP (repertory))
1472 CHECK_CHARSET (repertory);
1473 repertory = CHARSET_SYMBOL_ID (repertory);
1476 FONT_DEF_NEW (font_def, font_spec, encoding, repertory);
1478 else
1479 font_def = Qnil;
1481 if (CHARACTERP (target))
1483 if (XFASTINT (target) < 0x80)
1484 error ("Can't set a font for partial ASCII range");
1485 range_list = list1 (Fcons (target, target));
1487 else if (CONSP (target))
1489 Lisp_Object from, to;
1491 from = Fcar (target);
1492 to = Fcdr (target);
1493 CHECK_CHARACTER (from);
1494 CHECK_CHARACTER (to);
1495 if (XFASTINT (from) < 0x80)
1497 if (XFASTINT (from) != 0 || XFASTINT (to) < 0x7F)
1498 error ("Can't set a font for partial ASCII range");
1499 ascii_changed = 1;
1501 range_list = list1 (target);
1503 else if (SYMBOLP (target) && !NILP (target))
1505 Lisp_Object script_list;
1506 Lisp_Object val;
1508 range_list = Qnil;
1509 script_list = XCHAR_TABLE (Vchar_script_table)->extras[0];
1510 if (! NILP (Fmemq (target, script_list)))
1512 if (EQ (target, Qlatin))
1513 ascii_changed = 1;
1514 val = list1 (target);
1515 map_char_table (accumulate_script_ranges, Qnil, Vchar_script_table,
1516 val);
1517 range_list = Fnreverse (XCDR (val));
1519 if (CHARSETP (target))
1521 CHECK_CHARSET_GET_CHARSET (target, charset);
1522 if (charset->ascii_compatible_p)
1523 ascii_changed = 1;
1525 else if (NILP (range_list))
1526 error ("Invalid script or charset name: %s",
1527 SDATA (SYMBOL_NAME (target)));
1529 else if (NILP (target))
1530 range_list = list1 (Qnil);
1531 else
1532 error ("Invalid target for setting a font");
1534 if (ascii_changed)
1536 Lisp_Object val;
1538 if (NILP (font_spec))
1539 error ("Can't set ASCII font to nil");
1540 val = CHAR_TABLE_REF (fontset, 0);
1541 if (! NILP (val) && EQ (add, Qappend))
1542 /* We are going to change just an additional font for ASCII. */
1543 ascii_changed = 0;
1546 if (charset)
1548 Lisp_Object arg;
1550 arg = make_uninit_vector (5);
1551 ASET (arg, 0, fontset);
1552 ASET (arg, 1, font_def);
1553 ASET (arg, 2, add);
1554 ASET (arg, 3, ascii_changed ? Qt : Qnil);
1555 ASET (arg, 4, range_list);
1557 map_charset_chars (set_fontset_font, Qnil, arg, charset,
1558 CHARSET_MIN_CODE (charset),
1559 CHARSET_MAX_CODE (charset));
1560 range_list = AREF (arg, 4);
1562 for (; CONSP (range_list); range_list = XCDR (range_list))
1563 FONTSET_ADD (fontset, XCAR (range_list), font_def, add);
1565 if (ascii_changed)
1567 Lisp_Object tail, fr;
1568 int fontset_id = XINT (FONTSET_ID (fontset));
1570 set_fontset_ascii (fontset, fontname);
1571 name = FONTSET_NAME (fontset);
1572 FOR_EACH_FRAME (tail, fr)
1574 struct frame *f = XFRAME (fr);
1575 Lisp_Object font_object;
1576 struct face *face;
1578 if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f))
1579 continue;
1580 if (fontset_id != FRAME_FONTSET (f))
1581 continue;
1582 face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
1583 if (face)
1584 font_object = font_load_for_lface (f, face->lface, font_spec);
1585 else
1586 font_object = font_open_by_spec (f, font_spec);
1587 if (! NILP (font_object))
1589 update_auto_fontset_alist (font_object, fontset);
1590 AUTO_FRAME_ARG (arg, Qfont, Fcons (name, font_object));
1591 Fmodify_frame_parameters (fr, arg);
1596 /* Free all realized fontsets whose base is FONTSET. This way, the
1597 specified character(s) are surely redisplayed by a correct
1598 font. */
1599 free_realized_fontsets (fontset);
1601 return Qnil;
1605 DEFUN ("new-fontset", Fnew_fontset, Snew_fontset, 2, 2, 0,
1606 doc: /* Create a new fontset NAME from font information in FONTLIST.
1608 FONTLIST is an alist of scripts vs the corresponding font specification list.
1609 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1610 character of SCRIPT is displayed by a font that matches one of
1611 FONT-SPEC.
1613 SCRIPT is a symbol that appears in the first extra slot of the
1614 char-table `char-script-table'.
1616 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1617 `set-fontset-font' for the meaning. */)
1618 (Lisp_Object name, Lisp_Object fontlist)
1620 Lisp_Object fontset;
1621 int id;
1623 CHECK_STRING (name);
1624 CHECK_LIST (fontlist);
1626 name = Fdowncase (name);
1627 id = fs_query_fontset (name, 0);
1628 if (id < 0)
1630 Lisp_Object font_spec = Ffont_spec (0, NULL);
1631 Lisp_Object short_name;
1632 char xlfd[256];
1633 int len;
1635 if (font_parse_xlfd (SSDATA (name), SBYTES (name), font_spec) < 0)
1636 error ("Fontset name must be in XLFD format");
1637 short_name = AREF (font_spec, FONT_REGISTRY_INDEX);
1638 if (strncmp (SSDATA (SYMBOL_NAME (short_name)), "fontset-", 8)
1639 || SBYTES (SYMBOL_NAME (short_name)) < 9)
1640 error ("Registry field of fontset name must be \"fontset-*\"");
1641 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (short_name)),
1642 Vfontset_alias_alist);
1643 ASET (font_spec, FONT_REGISTRY_INDEX, Qiso8859_1);
1644 fontset = make_fontset (Qnil, name, Qnil);
1645 len = font_unparse_xlfd (font_spec, 0, xlfd, 256);
1646 if (len < 0)
1647 error ("Invalid fontset name (perhaps too long): %s", SDATA (name));
1648 set_fontset_ascii (fontset, make_unibyte_string (xlfd, len));
1650 else
1652 fontset = FONTSET_FROM_ID (id);
1653 free_realized_fontsets (fontset);
1654 Fset_char_table_range (fontset, Qt, Qnil);
1657 for (; CONSP (fontlist); fontlist = XCDR (fontlist))
1659 Lisp_Object elt, script;
1661 elt = XCAR (fontlist);
1662 script = Fcar (elt);
1663 elt = Fcdr (elt);
1664 if (CONSP (elt) && (NILP (XCDR (elt)) || CONSP (XCDR (elt))))
1665 for (; CONSP (elt); elt = XCDR (elt))
1666 Fset_fontset_font (name, script, XCAR (elt), Qnil, Qappend);
1667 else
1668 Fset_fontset_font (name, script, elt, Qnil, Qappend);
1670 return name;
1674 /* Alist of automatically created fontsets. Each element is a cons
1675 (FONT-SPEC . FONTSET-ID). */
1676 static Lisp_Object auto_fontset_alist;
1678 /* Number of automatically created fontsets. */
1679 static ptrdiff_t num_auto_fontsets;
1681 /* Return a fontset synthesized from FONT-OBJECT. This is called from
1682 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1683 frame, and the returned fontset is used for the default fontset of
1684 that frame. The fontset specifies a font of the same registry as
1685 FONT-OBJECT for all characters in the repertory of the registry
1686 (see Vfont_encoding_alist). If the repertory is not known, the
1687 fontset specifies the font for all Latin characters assuming that a
1688 user intends to use FONT-OBJECT for Latin characters. */
1691 fontset_from_font (Lisp_Object font_object)
1693 Lisp_Object font_name = font_get_name (font_object);
1694 Lisp_Object font_spec = copy_font_spec (font_object);
1695 Lisp_Object registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1696 Lisp_Object fontset_spec, alias, name, fontset;
1697 Lisp_Object val;
1699 val = assoc_no_quit (font_spec, auto_fontset_alist);
1700 if (CONSP (val))
1701 return XINT (FONTSET_ID (XCDR (val)));
1702 if (num_auto_fontsets++ == 0)
1703 alias = intern ("fontset-startup");
1704 else
1706 char temp[sizeof "fontset-auto" + INT_STRLEN_BOUND (ptrdiff_t)];
1708 sprintf (temp, "fontset-auto%"pD"d", num_auto_fontsets - 1);
1709 alias = intern (temp);
1711 fontset_spec = copy_font_spec (font_spec);
1712 ASET (fontset_spec, FONT_REGISTRY_INDEX, alias);
1713 name = Ffont_xlfd_name (fontset_spec, Qnil);
1714 eassert (!NILP (name));
1715 fontset = make_fontset (Qnil, name, Qnil);
1716 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (alias)),
1717 Vfontset_alias_alist);
1718 alias = Fdowncase (AREF (font_object, FONT_NAME_INDEX));
1719 Vfontset_alias_alist = Fcons (Fcons (name, alias), Vfontset_alias_alist);
1720 auto_fontset_alist = Fcons (Fcons (font_spec, fontset), auto_fontset_alist);
1721 font_spec = Ffont_spec (0, NULL);
1722 ASET (font_spec, FONT_REGISTRY_INDEX, registry);
1724 Lisp_Object target = find_font_encoding (SYMBOL_NAME (registry));
1726 if (CONSP (target))
1727 target = XCDR (target);
1728 if (! CHARSETP (target))
1729 target = Qlatin;
1730 Fset_fontset_font (name, target, font_spec, Qnil, Qnil);
1731 Fset_fontset_font (name, Qnil, font_spec, Qnil, Qnil);
1734 set_fontset_ascii (fontset, font_name);
1736 return XINT (FONTSET_ID (fontset));
1740 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1741 FONTSET is changed, we delete an entry of FONTSET if any from
1742 auto_fontset_alist so that FONTSET is not re-used by
1743 fontset_from_font. */
1745 static void
1746 update_auto_fontset_alist (Lisp_Object font_object, Lisp_Object fontset)
1748 Lisp_Object prev, tail;
1750 for (prev = Qnil, tail = auto_fontset_alist; CONSP (tail);
1751 prev = tail, tail = XCDR (tail))
1752 if (EQ (fontset, XCDR (XCAR (tail))))
1754 if (NILP (prev))
1755 auto_fontset_alist = XCDR (tail);
1756 else
1757 XSETCDR (prev, XCDR (tail));
1758 break;
1763 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1764 FONT-OBJECT is the font for the character at POSITION in the current
1765 buffer. This is computed from all the text properties and overlays
1766 that apply to POSITION. POSITION may be nil, in which case,
1767 FONT-SPEC is the font for displaying the character CH with the
1768 default face.
1770 GLYPH-CODE is the glyph code in the font to use for the character.
1772 If the 2nd optional arg CH is non-nil, it is a character to check
1773 the font instead of the character at POSITION.
1775 It returns nil in the following cases:
1777 (1) The window system doesn't have a font for the character (thus
1778 it is displayed by an empty box).
1780 (2) The character code is invalid.
1782 (3) If POSITION is not nil, and the current buffer is not displayed
1783 in any window.
1785 In addition, the returned font name may not take into account of
1786 such redisplay engine hooks as what used in jit-lock-mode if
1787 POSITION is currently not visible. */
1790 DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
1791 doc: /* For internal use only. */)
1792 (Lisp_Object position, Lisp_Object ch)
1794 ptrdiff_t pos, pos_byte, dummy;
1795 int face_id;
1796 int c;
1797 struct frame *f;
1798 struct face *face;
1800 if (NILP (position))
1802 CHECK_CHARACTER (ch);
1803 c = XINT (ch);
1804 f = XFRAME (selected_frame);
1805 face_id = lookup_basic_face (f, DEFAULT_FACE_ID);
1806 pos = -1;
1808 else
1810 Lisp_Object window;
1811 struct window *w;
1813 CHECK_NUMBER_COERCE_MARKER (position);
1814 if (! (BEGV <= XINT (position) && XINT (position) < ZV))
1815 args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
1816 pos = XINT (position);
1817 pos_byte = CHAR_TO_BYTE (pos);
1818 if (NILP (ch))
1819 c = FETCH_CHAR (pos_byte);
1820 else
1822 CHECK_NATNUM (ch);
1823 c = XINT (ch);
1825 window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
1826 if (NILP (window))
1827 return Qnil;
1828 w = XWINDOW (window);
1829 f = XFRAME (w->frame);
1830 face_id = face_at_buffer_position (w, pos, &dummy,
1831 pos + 100, false, -1);
1833 if (! CHAR_VALID_P (c))
1834 return Qnil;
1835 if (!FRAME_WINDOW_P (f))
1836 return Qnil;
1837 /* We need the basic faces to be valid below, so recompute them if
1838 some code just happened to clear the face cache. */
1839 if (FRAME_FACE_CACHE (f)->used == 0)
1840 recompute_basic_faces (f);
1841 face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
1842 face = FACE_FROM_ID (f, face_id);
1843 if (face->font)
1845 unsigned code = face->font->driver->encode_char (face->font, c);
1846 Lisp_Object font_object;
1848 if (code == FONT_INVALID_CODE)
1849 return Qnil;
1850 XSETFONT (font_object, face->font);
1851 return Fcons (font_object, INTEGER_TO_CONS (code));
1853 return Qnil;
1857 DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
1858 doc: /* Return information about a fontset FONTSET on frame FRAME.
1860 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1861 for the default fontset. FRAME nil means the selected frame.
1863 The value is a char-table whose elements have this form:
1865 ((FONT OPENED-FONT ...) ...)
1867 FONT is a name of font specified for a range of characters.
1869 OPENED-FONT is a name of a font actually opened.
1871 The char-table has one extra slot. If FONTSET is not the default
1872 fontset, the value the extra slot is a char-table containing the
1873 information about the derived fonts from the default fontset. The
1874 format is the same as above. */)
1875 (Lisp_Object fontset, Lisp_Object frame)
1877 Lisp_Object *realized[2], fontsets[2], tables[2];
1878 Lisp_Object val, elt;
1879 int c, i, j, k;
1881 check_window_system (NULL);
1882 fontset = check_fontset_name (fontset, &frame);
1884 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1885 in the table `realized'. */
1886 USE_SAFE_ALLOCA;
1887 SAFE_ALLOCA_LISP (realized[0], 2 * ASIZE (Vfontset_table));
1888 realized[1] = realized[0] + ASIZE (Vfontset_table);
1889 for (i = j = 0; i < ASIZE (Vfontset_table); i++)
1891 elt = FONTSET_FROM_ID (i);
1892 if (!NILP (elt)
1893 && EQ (FONTSET_BASE (elt), fontset)
1894 && EQ (FONTSET_FRAME (elt), frame))
1895 realized[0][j++] = elt;
1897 realized[0][j] = Qnil;
1899 for (i = j = 0; ! NILP (realized[0][i]); i++)
1901 elt = FONTSET_DEFAULT (realized[0][i]);
1902 if (! NILP (elt))
1903 realized[1][j++] = elt;
1905 realized[1][j] = Qnil;
1907 tables[0] = Fmake_char_table (Qfontset_info, Qnil);
1908 fontsets[0] = fontset;
1909 if (!EQ (fontset, Vdefault_fontset))
1911 tables[1] = Fmake_char_table (Qnil, Qnil);
1912 set_char_table_extras (tables[0], 0, tables[1]);
1913 fontsets[1] = Vdefault_fontset;
1916 /* Accumulate information of the fontset in TABLE. The format of
1917 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1918 for (k = 0; k <= 1; k++)
1920 for (c = 0; c <= MAX_CHAR; )
1922 int from = c, to = MAX_5_BYTE_CHAR;
1924 if (c <= MAX_5_BYTE_CHAR)
1926 val = char_table_ref_and_range (fontsets[k], c, &from, &to);
1928 else
1930 val = FONTSET_FALLBACK (fontsets[k]);
1931 to = MAX_CHAR;
1933 if (VECTORP (val))
1935 Lisp_Object alist;
1937 /* At first, set ALIST to ((FONT-SPEC) ...). */
1938 for (alist = Qnil, i = 0; i < ASIZE (val); i++)
1939 if (! NILP (AREF (val, i)))
1940 alist = Fcons (Fcons (FONT_DEF_SPEC (AREF (val, i)), Qnil),
1941 alist);
1942 alist = Fnreverse (alist);
1944 /* Then store opened font names to cdr of each elements. */
1945 for (i = 0; ! NILP (realized[k][i]); i++)
1947 if (c <= MAX_5_BYTE_CHAR)
1948 val = FONTSET_REF (realized[k][i], c);
1949 else
1950 val = FONTSET_FALLBACK (realized[k][i]);
1951 if (! CONSP (val) || ! VECTORP (XCDR (val)))
1952 continue;
1953 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
1954 val = XCDR (val);
1955 for (j = 0; j < ASIZE (val); j++)
1957 elt = AREF (val, j);
1958 if (FONT_OBJECT_P (RFONT_DEF_OBJECT (elt)))
1960 Lisp_Object font_object = RFONT_DEF_OBJECT (elt);
1961 Lisp_Object slot, name;
1963 slot = Fassq (RFONT_DEF_SPEC (elt), alist);
1964 name = AREF (font_object, FONT_NAME_INDEX);
1965 if (NILP (Fmember (name, XCDR (slot))))
1966 nconc2 (slot, list1 (name));
1971 /* Store ALIST in TBL for characters C..TO. */
1972 if (c <= MAX_5_BYTE_CHAR)
1973 char_table_set_range (tables[k], c, to, alist);
1974 else
1975 set_char_table_defalt (tables[k], alist);
1977 /* At last, change each elements to font names. */
1978 for (; CONSP (alist); alist = XCDR (alist))
1980 elt = XCAR (alist);
1981 XSETCAR (elt, Ffont_xlfd_name (XCAR (elt), Qnil));
1984 c = to + 1;
1986 if (EQ (fontset, Vdefault_fontset))
1987 break;
1990 SAFE_FREE ();
1991 return tables[0];
1995 DEFUN ("fontset-font", Ffontset_font, Sfontset_font, 2, 3, 0,
1996 doc: /* Return a font name pattern for character CH in fontset NAME.
1997 If NAME is t, find a pattern in the default fontset.
1998 If NAME is nil, find a pattern in the fontset of the selected frame.
2000 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2001 family name and REGISTRY is a font registry name. This is actually
2002 the first font name pattern for CH in the fontset or in the default
2003 fontset.
2005 If the 2nd optional arg ALL is non-nil, return a list of all font name
2006 patterns. */)
2007 (Lisp_Object name, Lisp_Object ch, Lisp_Object all)
2009 int c;
2010 Lisp_Object fontset, elt, list, repertory, val;
2011 int i, j;
2012 Lisp_Object frame;
2014 frame = Qnil;
2015 fontset = check_fontset_name (name, &frame);
2017 CHECK_CHARACTER (ch);
2018 c = XINT (ch);
2019 list = Qnil;
2020 while (1)
2022 for (i = 0, elt = FONTSET_REF (fontset, c); i < 2;
2023 i++, elt = FONTSET_FALLBACK (fontset))
2024 if (VECTORP (elt))
2025 for (j = 0; j < ASIZE (elt); j++)
2027 Lisp_Object family, registry;
2029 val = AREF (elt, j);
2030 if (NILP (val))
2031 return Qnil;
2032 repertory = AREF (val, 1);
2033 if (INTEGERP (repertory))
2035 struct charset *charset = CHARSET_FROM_ID (XINT (repertory));
2037 if (! CHAR_CHARSET_P (c, charset))
2038 continue;
2040 else if (CHAR_TABLE_P (repertory))
2042 if (NILP (CHAR_TABLE_REF (repertory, c)))
2043 continue;
2045 val = AREF (val, 0);
2046 /* VAL is a FONT-SPEC */
2047 family = AREF (val, FONT_FAMILY_INDEX);
2048 if (! NILP (family))
2049 family = SYMBOL_NAME (family);
2050 registry = AREF (val, FONT_REGISTRY_INDEX);
2051 if (! NILP (registry))
2052 registry = SYMBOL_NAME (registry);
2053 val = Fcons (family, registry);
2054 if (NILP (all))
2055 return val;
2056 list = Fcons (val, list);
2058 if (EQ (fontset, Vdefault_fontset))
2059 break;
2060 fontset = Vdefault_fontset;
2062 return (Fnreverse (list));
2065 DEFUN ("fontset-list", Ffontset_list, Sfontset_list, 0, 0, 0,
2066 doc: /* Return a list of all defined fontset names. */)
2067 (void)
2069 Lisp_Object fontset, list;
2070 int i;
2072 list = Qnil;
2073 for (i = 0; i < ASIZE (Vfontset_table); i++)
2075 fontset = FONTSET_FROM_ID (i);
2076 if (!NILP (fontset)
2077 && BASE_FONTSET_P (fontset))
2078 list = Fcons (FONTSET_NAME (fontset), list);
2081 return list;
2085 #ifdef ENABLE_CHECKING
2087 Lisp_Object dump_fontset (Lisp_Object) EXTERNALLY_VISIBLE;
2089 Lisp_Object
2090 dump_fontset (Lisp_Object fontset)
2092 Lisp_Object vec;
2094 vec = Fmake_vector (make_number (3), Qnil);
2095 ASET (vec, 0, FONTSET_ID (fontset));
2097 if (BASE_FONTSET_P (fontset))
2099 ASET (vec, 1, FONTSET_NAME (fontset));
2101 else
2103 Lisp_Object frame;
2105 frame = FONTSET_FRAME (fontset);
2106 if (FRAMEP (frame))
2108 struct frame *f = XFRAME (frame);
2110 if (FRAME_LIVE_P (f))
2111 ASET (vec, 1,
2112 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)),
2113 f->name));
2114 else
2115 ASET (vec, 1,
2116 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)), Qnil));
2118 if (!NILP (FONTSET_DEFAULT (fontset)))
2119 ASET (vec, 2, FONTSET_ID (FONTSET_DEFAULT (fontset)));
2121 return vec;
2124 DEFUN ("fontset-list-all", Ffontset_list_all, Sfontset_list_all, 0, 0, 0,
2125 doc: /* Return a brief summary of all fontsets for debug use. */)
2126 (void)
2128 Lisp_Object val;
2129 int i;
2131 for (i = 0, val = Qnil; i < ASIZE (Vfontset_table); i++)
2132 if (! NILP (AREF (Vfontset_table, i)))
2133 val = Fcons (dump_fontset (AREF (Vfontset_table, i)), val);
2134 return (Fnreverse (val));
2136 #endif /* ENABLE_CHECKING */
2138 void
2139 syms_of_fontset (void)
2141 DEFSYM (Qfontset, "fontset");
2142 Fput (Qfontset, Qchar_table_extra_slots, make_number (8));
2143 DEFSYM (Qfontset_info, "fontset-info");
2144 Fput (Qfontset_info, Qchar_table_extra_slots, make_number (1));
2146 DEFSYM (Qprepend, "prepend");
2147 DEFSYM (Qappend, "append");
2148 DEFSYM (Qlatin, "latin");
2150 Vcached_fontset_data = Qnil;
2151 staticpro (&Vcached_fontset_data);
2153 Vfontset_table = Fmake_vector (make_number (32), Qnil);
2154 staticpro (&Vfontset_table);
2156 Vdefault_fontset = Fmake_char_table (Qfontset, Qnil);
2157 staticpro (&Vdefault_fontset);
2158 set_fontset_id (Vdefault_fontset, make_number (0));
2159 set_fontset_name
2160 (Vdefault_fontset,
2161 build_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));
2162 ASET (Vfontset_table, 0, Vdefault_fontset);
2163 next_fontset_id = 1;
2165 auto_fontset_alist = Qnil;
2166 staticpro (&auto_fontset_alist);
2168 DEFVAR_LISP ("font-encoding-charset-alist", Vfont_encoding_charset_alist,
2169 doc: /*
2170 Alist of charsets vs the charsets to determine the preferred font encoding.
2171 Each element looks like (CHARSET . ENCODING-CHARSET),
2172 where ENCODING-CHARSET is a charset registered in the variable
2173 `font-encoding-alist' as ENCODING.
2175 When a text has a property `charset' and the value is CHARSET, a font
2176 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2177 Vfont_encoding_charset_alist = Qnil;
2179 DEFVAR_LISP ("use-default-ascent", Vuse_default_ascent,
2180 doc: /*
2181 Char table of characters whose ascent values should be ignored.
2182 If an entry for a character is non-nil, the ascent value of the glyph
2183 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2185 This affects how a composite character which contains
2186 such a character is displayed on screen. */);
2187 Vuse_default_ascent = Qnil;
2189 DEFVAR_LISP ("ignore-relative-composition", Vignore_relative_composition,
2190 doc: /*
2191 Char table of characters which are not composed relatively.
2192 If an entry for a character is non-nil, a composition sequence
2193 which contains that character is displayed so that
2194 the glyph of that character is put without considering
2195 an ascent and descent value of a previous character. */);
2196 Vignore_relative_composition = Qnil;
2198 DEFVAR_LISP ("alternate-fontname-alist", Valternate_fontname_alist,
2199 doc: /* Alist of fontname vs list of the alternate fontnames.
2200 When a specified font name is not found, the corresponding
2201 alternate fontnames (if any) are tried instead. */);
2202 Valternate_fontname_alist = Qnil;
2204 DEFVAR_LISP ("fontset-alias-alist", Vfontset_alias_alist,
2205 doc: /* Alist of fontset names vs the aliases. */);
2206 Vfontset_alias_alist
2207 = list1 (Fcons (FONTSET_NAME (Vdefault_fontset),
2208 build_pure_c_string ("fontset-default")));
2210 DEFVAR_LISP ("vertical-centering-font-regexp",
2211 Vvertical_centering_font_regexp,
2212 doc: /* Regexp matching font names that require vertical centering on display.
2213 When a character is displayed with such fonts, the character is displayed
2214 at the vertical center of lines. */);
2215 Vvertical_centering_font_regexp = Qnil;
2217 DEFVAR_LISP ("otf-script-alist", Votf_script_alist,
2218 doc: /* Alist of OpenType script tags vs the corresponding script names. */);
2219 Votf_script_alist = Qnil;
2221 defsubr (&Squery_fontset);
2222 defsubr (&Snew_fontset);
2223 defsubr (&Sset_fontset_font);
2224 defsubr (&Sinternal_char_font);
2225 defsubr (&Sfontset_info);
2226 defsubr (&Sfontset_font);
2227 defsubr (&Sfontset_list);
2228 #ifdef ENABLE_CHECKING
2229 defsubr (&Sfontset_list_all);
2230 #endif