etags.el fix for compressed files
[emacs.git] / src / fontset.c
blobc6148e9fa372f98129f35319d95f1587f7f28ba1
1 /* Fontset handler.
3 Copyright (C) 2001-2013 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_X_WINDOWS
43 #include "xterm.h"
44 #endif
45 #ifdef HAVE_NTGUI
46 #include "w32term.h"
47 #endif
48 #ifdef HAVE_NS
49 #include "nsterm.h"
50 #endif
51 #include "termhooks.h"
53 #include "font.h"
55 /* FONTSET
57 A fontset is a collection of font related information to give
58 similar appearance (style, etc) of characters. A fontset has two
59 roles. One is to use for the frame parameter `font' as if it is an
60 ASCII font. In that case, Emacs uses the font specified for
61 `ascii' script for the frame's default font.
63 Another role, the more important one, is to provide information
64 about which font to use for each non-ASCII character.
66 There are two kinds of fontsets; base and realized. A base fontset
67 is created by `new-fontset' from Emacs Lisp explicitly. A realized
68 fontset is created implicitly when a face is realized for ASCII
69 characters. A face is also realized for non-ASCII characters based
70 on an ASCII face. All of non-ASCII faces based on the same ASCII
71 face share the same realized fontset.
73 A fontset object is implemented by a char-table whose default value
74 and parent are always nil.
76 An element of a base fontset is a vector of FONT-DEFs which itself
77 is a vector [ FONT-SPEC ENCODING REPERTORY ].
79 An element of a realized fontset is nil, t, 0, or a vector of this
80 form:
82 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
83 RFONT-DEF0 RFONT-DEF1 ... ]
85 RFONT-DEFn (i.e. Realized FONT-DEF) has this form:
87 [ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]
89 RFONT-DEFn are automatically reordered by the current charset
90 priority list.
92 The value nil means that we have not yet generated the above vector
93 from the base of the fontset.
95 The value t means that no font is available for the corresponding
96 range of characters.
98 The value 0 means that no font is available for the corresponding
99 range of characters in this fontset, but may be available in the
100 default fontset.
103 A fontset has 9 extra slots.
105 The 1st slot: the ID number of the fontset
107 The 2nd slot:
108 base: the name of the fontset
109 realized: nil
111 The 3rd slot:
112 base: nil
113 realized: the base fontset
115 The 4th slot:
116 base: nil
117 realized: the frame that the fontset belongs to
119 The 5th slot:
120 base: the font name for ASCII characters
121 realized: nil
123 The 6th slot:
124 base: nil
125 realized: the ID number of a face to use for characters that
126 has no font in a realized fontset.
128 The 7th slot:
129 base: nil
130 realized: Alist of font index vs the corresponding repertory
131 char-table.
133 The 8th slot:
134 base: nil
135 realized: If the base is not the default fontset, a fontset
136 realized from the default fontset, else nil.
138 The 9th slot:
139 base: Same as element value (but for fallback fonts).
140 realized: Likewise.
142 All fontsets are recorded in the vector Vfontset_table.
145 DEFAULT FONTSET
147 There's a special base fontset named `default fontset' which
148 defines the default font specifications. When a base fontset
149 doesn't specify a font for a specific character, the corresponding
150 value in the default fontset is used.
152 The parent of a realized fontset created for such a face that has
153 no fontset is the default fontset.
156 These structures are hidden from the other codes than this file.
157 The other codes handle fontsets only by their ID numbers. They
158 usually use the variable name `fontset' for IDs. But, in this
159 file, we always use variable name `id' for IDs, and name `fontset'
160 for an actual fontset object, i.e., char-table.
164 /********** VARIABLES and FUNCTION PROTOTYPES **********/
166 static Lisp_Object Qfontset;
167 static Lisp_Object Qfontset_info;
168 static Lisp_Object Qprepend, Qappend;
169 Lisp_Object Qlatin;
171 /* Vector containing all fontsets. */
172 static Lisp_Object Vfontset_table;
174 /* Next possibly free fontset ID. Usually this keeps the minimum
175 fontset ID not yet used. */
176 static int next_fontset_id;
178 /* The default fontset. This gives default FAMILY and REGISTRY of
179 font for each character. */
180 static Lisp_Object Vdefault_fontset;
182 /* Check if any window system is used now. */
183 void (*check_window_system_func) (void);
186 /* Prototype declarations for static functions. */
187 static Lisp_Object make_fontset (Lisp_Object, Lisp_Object, Lisp_Object);
189 /* Return true if ID is a valid fontset id.
190 Optimized away if ENABLE_CHECKING is not defined. */
192 static bool
193 fontset_id_valid_p (int id)
195 return (id >= 0 && id < ASIZE (Vfontset_table) - 1);
200 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
202 /* Return the fontset with ID. No check of ID's validness. */
203 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
205 /* Access special values of FONTSET. */
207 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
208 static void
209 set_fontset_id (Lisp_Object fontset, Lisp_Object id)
211 set_char_table_extras (fontset, 0, id);
214 /* Access special values of (base) FONTSET. */
216 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
217 static void
218 set_fontset_name (Lisp_Object fontset, Lisp_Object name)
220 set_char_table_extras (fontset, 1, name);
223 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->extras[4]
224 static void
225 set_fontset_ascii (Lisp_Object fontset, Lisp_Object ascii)
227 set_char_table_extras (fontset, 4, ascii);
230 /* Access special values of (realized) FONTSET. */
232 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->extras[2]
233 static void
234 set_fontset_base (Lisp_Object fontset, Lisp_Object base)
236 set_char_table_extras (fontset, 2, base);
239 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[3]
240 static void
241 set_fontset_frame (Lisp_Object fontset, Lisp_Object frame)
243 set_char_table_extras (fontset, 3, frame);
246 #define FONTSET_NOFONT_FACE(fontset) XCHAR_TABLE (fontset)->extras[5]
247 static void
248 set_fontset_nofont_face (Lisp_Object fontset, Lisp_Object face)
250 set_char_table_extras (fontset, 5, face);
253 #define FONTSET_DEFAULT(fontset) XCHAR_TABLE (fontset)->extras[7]
254 static void
255 set_fontset_default (Lisp_Object fontset, Lisp_Object def)
257 set_char_table_extras (fontset, 7, def);
260 /* For both base and realized fontset. */
262 #define FONTSET_FALLBACK(fontset) XCHAR_TABLE (fontset)->extras[8]
263 static void
264 set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
266 set_char_table_extras (fontset, 8, fallback);
269 #define BASE_FONTSET_P(fontset) (NILP (FONTSET_BASE (fontset)))
271 /* Macros for FONT-DEF and RFONT-DEF of fontset. */
272 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory) \
273 do { \
274 (font_def) = Fmake_vector (make_number (3), (font_spec)); \
275 ASET ((font_def), 1, encoding); \
276 ASET ((font_def), 2, repertory); \
277 } while (0)
279 #define FONT_DEF_SPEC(font_def) AREF (font_def, 0)
280 #define FONT_DEF_ENCODING(font_def) AREF (font_def, 1)
281 #define FONT_DEF_REPERTORY(font_def) AREF (font_def, 2)
283 #define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
284 #define RFONT_DEF_SET_FACE(rfont_def, face_id) \
285 ASET ((rfont_def), 0, make_number (face_id))
286 #define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
287 #define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
288 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
289 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
290 ASET ((rfont_def), 2, (object))
291 /* Score of RFONT_DEF is an integer value; the lowest 8 bits represent
292 the order of listing by font backends, the higher bits represents
293 the order given by charset priority list. The smaller value is
294 preferable. */
295 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
296 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
297 ASET ((rfont_def), 3, make_number (score))
298 #define RFONT_DEF_NEW(rfont_def, font_def) \
299 do { \
300 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
301 ASET ((rfont_def), 1, (font_def)); \
302 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
303 } while (0)
306 /* Return the element of FONTSET for the character C. If FONTSET is a
307 base fontset other then the default fontset and FONTSET doesn't
308 contain information for C, return the information in the default
309 fontset. */
311 #define FONTSET_REF(fontset, c) \
312 (EQ (fontset, Vdefault_fontset) \
313 ? CHAR_TABLE_REF (fontset, c) \
314 : fontset_ref ((fontset), (c)))
316 static Lisp_Object
317 fontset_ref (Lisp_Object fontset, int c)
319 Lisp_Object elt;
321 elt = CHAR_TABLE_REF (fontset, c);
322 if (NILP (elt) && ! EQ (fontset, Vdefault_fontset)
323 /* Don't check Vdefault_fontset for a realized fontset. */
324 && NILP (FONTSET_BASE (fontset)))
325 elt = CHAR_TABLE_REF (Vdefault_fontset, c);
326 return elt;
329 /* Set elements of FONTSET for characters in RANGE to the value ELT.
330 RANGE is a cons (FROM . TO), where FROM and TO are character codes
331 specifying a range. */
333 #define FONTSET_SET(fontset, range, elt) \
334 Fset_char_table_range ((fontset), (range), (elt))
337 /* Modify the elements of FONTSET for characters in RANGE by replacing
338 with ELT or adding ELT. RANGE is a cons (FROM . TO), where FROM
339 and TO are character codes specifying a range. If ADD is nil,
340 replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
341 append ELT. */
343 #define FONTSET_ADD(fontset, range, elt, add) \
344 (NILP (add) \
345 ? (NILP (range) \
346 ? (set_fontset_fallback \
347 (fontset, Fmake_vector (make_number (1), (elt)))) \
348 : ((void) \
349 Fset_char_table_range (fontset, range, \
350 Fmake_vector (make_number (1), elt)))) \
351 : fontset_add ((fontset), (range), (elt), (add)))
353 static void
354 fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Object add)
356 Lisp_Object args[2];
357 int idx = (EQ (add, Qappend) ? 0 : 1);
359 args[1 - idx] = Fmake_vector (make_number (1), elt);
361 if (CONSP (range))
363 int from = XINT (XCAR (range));
364 int to = XINT (XCDR (range));
365 int from1, to1;
367 do {
368 from1 = from, to1 = to;
369 args[idx] = char_table_ref_and_range (fontset, from, &from1, &to1);
370 char_table_set_range (fontset, from, to1,
371 NILP (args[idx]) ? args[1 - idx]
372 : Fvconcat (2, args));
373 from = to1 + 1;
374 } while (from < to);
376 else
378 args[idx] = FONTSET_FALLBACK (fontset);
379 set_fontset_fallback
380 (fontset, NILP (args[idx]) ? args[1 - idx] : Fvconcat (2, args));
384 static int
385 fontset_compare_rfontdef (const void *val1, const void *val2)
387 return (RFONT_DEF_SCORE (*(Lisp_Object *) val1)
388 - RFONT_DEF_SCORE (*(Lisp_Object *) val2));
391 /* Update FONT-GROUP which has this form:
392 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
393 RFONT-DEF0 RFONT-DEF1 ... ]
394 Reorder RFONT-DEFs according to the current language, and update
395 CHARSET-ORDERED-LIST-TICK.
397 If PREFERRED_FAMILY is not nil, that family has the higher priority
398 if the encoding charsets or languages in font-specs are the same. */
400 static void
401 reorder_font_vector (Lisp_Object font_group, struct font *font)
403 Lisp_Object vec, font_object;
404 int size;
405 int i;
406 bool score_changed = 0;
408 if (font)
409 XSETFONT (font_object, font);
410 else
411 font_object = Qnil;
413 vec = XCDR (font_group);
414 size = ASIZE (vec);
415 /* Exclude the tailing nil element from the reordering. */
416 if (NILP (AREF (vec, size - 1)))
417 size--;
419 for (i = 0; i < size; i++)
421 Lisp_Object rfont_def = AREF (vec, i);
422 Lisp_Object font_def = RFONT_DEF_FONT_DEF (rfont_def);
423 Lisp_Object font_spec = FONT_DEF_SPEC (font_def);
424 int score = RFONT_DEF_SCORE (rfont_def) & 0xFF;
425 Lisp_Object otf_spec = Ffont_get (font_spec, QCotf);
427 if (! NILP (otf_spec))
428 /* A font-spec with :otf is preferable regardless of encoding
429 and language.. */
431 else if (! font_match_p (font_spec, font_object))
433 Lisp_Object encoding = FONT_DEF_ENCODING (font_def);
435 if (! NILP (encoding))
437 Lisp_Object tail;
439 for (tail = Vcharset_ordered_list;
440 ! EQ (tail, Vcharset_non_preferred_head) && CONSP (tail);
441 tail = XCDR (tail))
442 if (EQ (encoding, XCAR (tail)))
443 break;
444 else if (score <= min (INT_MAX, MOST_POSITIVE_FIXNUM) - 0x100)
445 score += 0x100;
447 else
449 Lisp_Object lang = Ffont_get (font_spec, QClang);
451 if (! NILP (lang)
452 && ! EQ (lang, Vcurrent_iso639_language)
453 && (! CONSP (Vcurrent_iso639_language)
454 || NILP (Fmemq (lang, Vcurrent_iso639_language))))
455 score |= 0x100;
458 if (RFONT_DEF_SCORE (rfont_def) != score)
460 RFONT_DEF_SET_SCORE (rfont_def, score);
461 score_changed = 1;
465 if (score_changed)
466 qsort (XVECTOR (vec)->contents, size, word_size,
467 fontset_compare_rfontdef);
468 XSETCAR (font_group, make_number (charset_ordered_list_tick));
471 /* Return a font-group (actually a cons (-1 . FONT-GROUP-VECTOR)) for
472 character C in FONTSET. If C is -1, return a fallback font-group.
473 If C is not -1, the value may be Qt (FONTSET doesn't have a font
474 for C even in the fallback group), or 0 (a font for C may be found
475 only in the fallback group). */
477 static Lisp_Object
478 fontset_get_font_group (Lisp_Object fontset, int c)
480 Lisp_Object font_group;
481 Lisp_Object base_fontset;
482 int from = 0, to = MAX_CHAR, i;
484 eassert (! BASE_FONTSET_P (fontset));
485 if (c >= 0)
486 font_group = CHAR_TABLE_REF (fontset, c);
487 else
488 font_group = FONTSET_FALLBACK (fontset);
489 if (! NILP (font_group))
490 return font_group;
491 base_fontset = FONTSET_BASE (fontset);
492 if (NILP (base_fontset))
493 font_group = Qnil;
494 else if (c >= 0)
495 font_group = char_table_ref_and_range (base_fontset, c, &from, &to);
496 else
497 font_group = FONTSET_FALLBACK (base_fontset);
498 if (NILP (font_group))
500 font_group = make_number (0);
501 if (c >= 0)
502 char_table_set_range (fontset, from, to, font_group);
503 return font_group;
505 if (!VECTORP (font_group))
506 return font_group;
507 font_group = Fcopy_sequence (font_group);
508 for (i = 0; i < ASIZE (font_group); i++)
509 if (! NILP (AREF (font_group, i)))
511 Lisp_Object rfont_def;
513 RFONT_DEF_NEW (rfont_def, AREF (font_group, i));
514 /* Remember the original order. */
515 RFONT_DEF_SET_SCORE (rfont_def, i);
516 ASET (font_group, i, rfont_def);
518 font_group = Fcons (make_number (-1), font_group);
519 if (c >= 0)
520 char_table_set_range (fontset, from, to, font_group);
521 else
522 set_fontset_fallback (fontset, font_group);
523 return font_group;
526 /* Return RFONT-DEF (vector) in the realized fontset FONTSET for the
527 character C. If no font is found, return Qnil if there's a
528 possibility that the default fontset or the fallback font groups
529 have a proper font, and return Qt if not.
531 If a font is found but is not yet opened, open it (if FACE is not
532 NULL) or return Qnil (if FACE is NULL).
534 ID is a charset-id that must be preferred, or -1 meaning no
535 preference.
537 If FALLBACK, search only fallback fonts. */
539 static Lisp_Object
540 fontset_find_font (Lisp_Object fontset, int c, struct face *face, int id,
541 bool fallback)
543 Lisp_Object vec, font_group;
544 int i, charset_matched = 0, found_index;
545 FRAME_PTR f = (FRAMEP (FONTSET_FRAME (fontset))
546 ? XFRAME (FONTSET_FRAME (fontset)) : XFRAME (selected_frame));
547 Lisp_Object rfont_def;
549 font_group = fontset_get_font_group (fontset, fallback ? -1 : c);
550 if (! CONSP (font_group))
551 return font_group;
552 vec = XCDR (font_group);
553 if (ASIZE (vec) == 0)
554 return Qnil;
556 if (ASIZE (vec) > 1)
558 if (XINT (XCAR (font_group)) != charset_ordered_list_tick)
559 /* We have just created the font-group,
560 or the charset priorities were changed. */
561 reorder_font_vector (font_group, face->ascii_face->font);
562 if (id >= 0)
563 /* Find a spec matching with the charset ID to try at
564 first. */
565 for (i = 0; i < ASIZE (vec); i++)
567 Lisp_Object repertory;
569 rfont_def = AREF (vec, i);
570 if (NILP (rfont_def))
571 break;
572 repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));
574 if (XINT (repertory) == id)
576 charset_matched = i;
577 break;
582 /* Find the first available font in the vector of RFONT-DEF. */
583 for (i = 0; i < ASIZE (vec); i++)
585 Lisp_Object font_def;
586 Lisp_Object font_entity, font_object;
588 found_index = i;
589 if (i == 0)
591 if (charset_matched > 0)
593 /* Try the element matching with the charset ID at first. */
594 found_index = charset_matched;
595 /* Make this negative so that we don't come here in the
596 next loop. */
597 charset_matched = - charset_matched;
598 /* We must try the first element in the next loop. */
599 i--;
602 else if (i == - charset_matched)
604 /* We have already tried this element and the followings
605 that have the same font specifications in the first
606 iteration. So, skip them all. */
607 rfont_def = AREF (vec, i);
608 font_def = RFONT_DEF_FONT_DEF (rfont_def);
609 for (; i + 1 < ASIZE (vec); i++)
611 rfont_def = AREF (vec, i + 1);
612 if (NILP (rfont_def))
613 break;
614 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
615 break;
617 continue;
620 rfont_def = AREF (vec, found_index);
621 if (NILP (rfont_def))
623 if (i < 0)
624 continue;
625 /* This is a sign of not to try the other fonts. */
626 return Qt;
628 if (INTEGERP (RFONT_DEF_FACE (rfont_def))
629 && XINT (RFONT_DEF_FACE (rfont_def)) < 0)
630 /* We couldn't open this font last time. */
631 continue;
633 font_object = RFONT_DEF_OBJECT (rfont_def);
634 if (NILP (font_object))
636 font_def = RFONT_DEF_FONT_DEF (rfont_def);
638 if (! face)
639 /* We have not yet opened the font. */
640 return Qnil;
641 /* Find a font best-matching with the spec without checking
642 the support of the character C. That checking is costly,
643 and even without the checking, the found font supports C
644 in high possibility. */
645 font_entity = font_find_for_lface (f, face->lface,
646 FONT_DEF_SPEC (font_def), -1);
647 if (NILP (font_entity))
649 /* Record that no font matches the spec. */
650 RFONT_DEF_SET_FACE (rfont_def, -1);
651 continue;
653 font_object = font_open_for_lface (f, font_entity, face->lface,
654 FONT_DEF_SPEC (font_def));
655 if (NILP (font_object))
657 /* Something strange happened, perhaps because of a
658 Font-backend problem. Too avoid crashing, record
659 that this spec is unusable. It may be better to find
660 another font of the same spec, but currently we don't
661 have such an API. */
662 RFONT_DEF_SET_FACE (rfont_def, -1);
663 continue;
665 RFONT_DEF_SET_OBJECT (rfont_def, font_object);
668 if (font_has_char (f, font_object, c))
669 goto found;
671 /* Find a font already opened, matching with the current spec,
672 and supporting C. */
673 font_def = RFONT_DEF_FONT_DEF (rfont_def);
674 for (; found_index + 1 < ASIZE (vec); found_index++)
676 rfont_def = AREF (vec, found_index + 1);
677 if (NILP (rfont_def))
678 break;
679 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
680 break;
681 font_object = RFONT_DEF_OBJECT (rfont_def);
682 if (! NILP (font_object) && font_has_char (f, font_object, c))
684 found_index++;
685 goto found;
689 /* Find a font-entity with the current spec and supporting C. */
690 font_entity = font_find_for_lface (f, face->lface,
691 FONT_DEF_SPEC (font_def), c);
692 if (! NILP (font_entity))
694 /* We found a font. Open it and insert a new element for
695 that font in VEC. */
696 Lisp_Object new_vec;
697 int j;
699 font_object = font_open_for_lface (f, font_entity, face->lface,
700 Qnil);
701 if (NILP (font_object))
702 continue;
703 RFONT_DEF_NEW (rfont_def, font_def);
704 RFONT_DEF_SET_OBJECT (rfont_def, font_object);
705 RFONT_DEF_SET_SCORE (rfont_def, RFONT_DEF_SCORE (rfont_def));
706 new_vec = Fmake_vector (make_number (ASIZE (vec) + 1), Qnil);
707 found_index++;
708 for (j = 0; j < found_index; j++)
709 ASET (new_vec, j, AREF (vec, j));
710 ASET (new_vec, j, rfont_def);
711 for (j++; j < ASIZE (new_vec); j++)
712 ASET (new_vec, j, AREF (vec, j - 1));
713 XSETCDR (font_group, new_vec);
714 vec = new_vec;
715 goto found;
717 if (i >= 0)
718 i = found_index;
721 FONTSET_SET (fontset, make_number (c), make_number (0));
722 return Qnil;
724 found:
725 if (fallback && found_index > 0)
727 /* The order of fonts in the fallback font-group is not that
728 important, and it is better to move the found font to the
729 first of the group so that the next try will find it
730 quickly. */
731 for (i = found_index; i > 0; i--)
732 ASET (vec, i, AREF (vec, i - 1));
733 ASET (vec, 0, rfont_def);
735 return rfont_def;
739 static Lisp_Object
740 fontset_font (Lisp_Object fontset, int c, struct face *face, int id)
742 Lisp_Object rfont_def, default_rfont_def IF_LINT (= Qnil);
743 Lisp_Object base_fontset;
745 /* Try a font-group of FONTSET. */
746 FONT_DEFERRED_LOG ("current fontset: font for", make_number (c), Qnil);
747 rfont_def = fontset_find_font (fontset, c, face, id, 0);
748 if (VECTORP (rfont_def))
749 return rfont_def;
750 if (NILP (rfont_def))
751 FONTSET_SET (fontset, make_number (c), make_number (0));
753 /* Try a font-group of the default fontset. */
754 base_fontset = FONTSET_BASE (fontset);
755 if (! EQ (base_fontset, Vdefault_fontset))
757 if (NILP (FONTSET_DEFAULT (fontset)))
758 set_fontset_default
759 (fontset,
760 make_fontset (FONTSET_FRAME (fontset), Qnil, Vdefault_fontset));
761 FONT_DEFERRED_LOG ("default fontset: font for", make_number (c), Qnil);
762 default_rfont_def
763 = fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 0);
764 if (VECTORP (default_rfont_def))
765 return default_rfont_def;
766 if (NILP (default_rfont_def))
767 FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c),
768 make_number (0));
771 /* Try a fallback font-group of FONTSET. */
772 if (! EQ (rfont_def, Qt))
774 FONT_DEFERRED_LOG ("current fallback: font for", make_number (c), Qnil);
775 rfont_def = fontset_find_font (fontset, c, face, id, 1);
776 if (VECTORP (rfont_def))
777 return rfont_def;
778 /* Remember that FONTSET has no font for C. */
779 FONTSET_SET (fontset, make_number (c), Qt);
782 /* Try a fallback font-group of the default fontset. */
783 if (! EQ (base_fontset, Vdefault_fontset)
784 && ! EQ (default_rfont_def, Qt))
786 FONT_DEFERRED_LOG ("default fallback: font for", make_number (c), Qnil);
787 rfont_def = fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 1);
788 if (VECTORP (rfont_def))
789 return rfont_def;
790 /* Remember that the default fontset has no font for C. */
791 FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c), Qt);
794 return Qnil;
797 /* Return a newly created fontset with NAME. If BASE is nil, make a
798 base fontset. Otherwise make a realized fontset whose base is
799 BASE. */
801 static Lisp_Object
802 make_fontset (Lisp_Object frame, Lisp_Object name, Lisp_Object base)
804 Lisp_Object fontset;
805 int size = ASIZE (Vfontset_table);
806 int id = next_fontset_id;
808 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
809 the next available fontset ID. So it is expected that this loop
810 terminates quickly. In addition, as the last element of
811 Vfontset_table is always nil, we don't have to check the range of
812 id. */
813 while (!NILP (AREF (Vfontset_table, id))) id++;
815 if (id + 1 == size)
816 Vfontset_table = larger_vector (Vfontset_table, 1, -1);
818 fontset = Fmake_char_table (Qfontset, Qnil);
820 set_fontset_id (fontset, make_number (id));
821 if (NILP (base))
822 set_fontset_name (fontset, name);
823 else
825 set_fontset_name (fontset, Qnil);
826 set_fontset_frame (fontset, frame);
827 set_fontset_base (fontset, base);
830 ASET (Vfontset_table, id, fontset);
831 next_fontset_id = id + 1;
832 return fontset;
836 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
838 /* Return the name of the fontset who has ID. */
840 Lisp_Object
841 fontset_name (int id)
843 Lisp_Object fontset;
845 fontset = FONTSET_FROM_ID (id);
846 return FONTSET_NAME (fontset);
850 /* Return the ASCII font name of the fontset who has ID. */
852 Lisp_Object
853 fontset_ascii (int id)
855 Lisp_Object fontset, elt;
857 fontset= FONTSET_FROM_ID (id);
858 elt = FONTSET_ASCII (fontset);
859 if (CONSP (elt))
860 elt = XCAR (elt);
861 return elt;
864 static void
865 free_realized_fontset (FRAME_PTR f, Lisp_Object fontset)
867 #if 0
868 Lisp_Object tail;
870 if (0)
871 for (tail = FONTSET_OBJLIST (fontset); CONSP (tail); tail = XCDR (tail))
873 eassert (FONT_OBJECT_P (XCAR (tail)));
874 font_close_object (f, XCAR (tail));
876 #endif
879 /* Free fontset of FACE defined on frame F. Called from
880 free_realized_face. */
882 void
883 free_face_fontset (FRAME_PTR f, struct face *face)
885 Lisp_Object fontset;
887 fontset = FONTSET_FROM_ID (face->fontset);
888 if (NILP (fontset))
889 return;
890 eassert (! BASE_FONTSET_P (fontset));
891 eassert (f == XFRAME (FONTSET_FRAME (fontset)));
892 free_realized_fontset (f, fontset);
893 ASET (Vfontset_table, face->fontset, Qnil);
894 if (face->fontset < next_fontset_id)
895 next_fontset_id = face->fontset;
896 if (! NILP (FONTSET_DEFAULT (fontset)))
898 int id = XINT (FONTSET_ID (FONTSET_DEFAULT (fontset)));
900 fontset = AREF (Vfontset_table, id);
901 eassert (!NILP (fontset) && ! BASE_FONTSET_P (fontset));
902 eassert (f == XFRAME (FONTSET_FRAME (fontset)));
903 free_realized_fontset (f, fontset);
904 ASET (Vfontset_table, id, Qnil);
905 if (id < next_fontset_id)
906 next_fontset_id = face->fontset;
908 face->fontset = -1;
912 #if 0
913 /* Return true if FACE is suitable for displaying character C.
914 Called from the macro FACE_SUITABLE_FOR_CHAR_P
915 when C is not an ASCII character. */
917 bool
918 face_suitable_for_char_p (struct face *face, int c)
920 Lisp_Object fontset, rfont_def;
922 fontset = FONTSET_FROM_ID (face->fontset);
923 rfont_def = fontset_font (fontset, c, NULL, -1);
924 return (VECTORP (rfont_def)
925 && INTEGERP (RFONT_DEF_FACE (rfont_def))
926 && face->id == XINT (RFONT_DEF_FACE (rfont_def)));
928 #endif
931 /* Return ID of face suitable for displaying character C on frame F.
932 FACE must be realized for ASCII characters in advance. Called from
933 the macro FACE_FOR_CHAR. */
936 face_for_char (FRAME_PTR f, struct face *face, int c, int pos, Lisp_Object object)
938 Lisp_Object fontset, rfont_def, charset;
939 int face_id;
940 int id;
942 /* If face->fontset is negative (that happens when no font is found
943 for face), just return face->ascii_face because we can't do
944 anything. Perhaps, we should fix the callers to assure
945 that face->fontset is always valid. */
946 if (ASCII_CHAR_P (c) || face->fontset < 0)
947 return face->ascii_face->id;
949 eassert (fontset_id_valid_p (face->fontset));
950 fontset = FONTSET_FROM_ID (face->fontset);
951 eassert (!BASE_FONTSET_P (fontset));
953 if (pos < 0)
955 id = -1;
956 charset = Qnil;
958 else
960 charset = Fget_char_property (make_number (pos), Qcharset, object);
961 if (CHARSETP (charset))
963 Lisp_Object val;
965 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
966 if (CONSP (val) && CHARSETP (XCDR (val)))
967 charset = XCDR (val);
968 id = XINT (CHARSET_SYMBOL_ID (charset));
970 else
971 id = -1;
974 rfont_def = fontset_font (fontset, c, face, id);
975 if (VECTORP (rfont_def))
977 if (INTEGERP (RFONT_DEF_FACE (rfont_def)))
978 face_id = XINT (RFONT_DEF_FACE (rfont_def));
979 else
981 Lisp_Object font_object;
983 font_object = RFONT_DEF_OBJECT (rfont_def);
984 face_id = face_for_font (f, font_object, face);
985 RFONT_DEF_SET_FACE (rfont_def, face_id);
988 else
990 if (INTEGERP (FONTSET_NOFONT_FACE (fontset)))
991 face_id = XINT (FONTSET_NOFONT_FACE (fontset));
992 else
994 face_id = face_for_font (f, Qnil, face);
995 set_fontset_nofont_face (fontset, make_number (face_id));
998 eassert (face_id >= 0);
999 return face_id;
1003 Lisp_Object
1004 font_for_char (struct face *face, int c, int pos, Lisp_Object object)
1006 Lisp_Object fontset, rfont_def, charset;
1007 int id;
1009 if (ASCII_CHAR_P (c))
1011 Lisp_Object font_object;
1013 XSETFONT (font_object, face->ascii_face->font);
1014 return font_object;
1017 eassert (fontset_id_valid_p (face->fontset));
1018 fontset = FONTSET_FROM_ID (face->fontset);
1019 eassert (!BASE_FONTSET_P (fontset));
1020 if (pos < 0)
1022 id = -1;
1023 charset = Qnil;
1025 else
1027 charset = Fget_char_property (make_number (pos), Qcharset, object);
1028 if (CHARSETP (charset))
1030 Lisp_Object val;
1032 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
1033 if (CONSP (val) && CHARSETP (XCDR (val)))
1034 charset = XCDR (val);
1035 id = XINT (CHARSET_SYMBOL_ID (charset));
1037 else
1038 id = -1;
1041 rfont_def = fontset_font (fontset, c, face, id);
1042 return (VECTORP (rfont_def)
1043 ? RFONT_DEF_OBJECT (rfont_def)
1044 : Qnil);
1048 /* Make a realized fontset for ASCII face FACE on frame F from the
1049 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1050 default fontset as the base. Value is the id of the new fontset.
1051 Called from realize_x_face. */
1054 make_fontset_for_ascii_face (FRAME_PTR f, int base_fontset_id, struct face *face)
1056 Lisp_Object base_fontset, fontset, frame;
1058 XSETFRAME (frame, f);
1059 if (base_fontset_id >= 0)
1061 base_fontset = FONTSET_FROM_ID (base_fontset_id);
1062 if (!BASE_FONTSET_P (base_fontset))
1063 base_fontset = FONTSET_BASE (base_fontset);
1064 eassert (BASE_FONTSET_P (base_fontset));
1066 else
1067 base_fontset = Vdefault_fontset;
1069 fontset = make_fontset (frame, Qnil, base_fontset);
1070 return XINT (FONTSET_ID (fontset));
1075 /* Cache data used by fontset_pattern_regexp. The car part is a
1076 pattern string containing at least one wild card, the cdr part is
1077 the corresponding regular expression. */
1078 static Lisp_Object Vcached_fontset_data;
1080 #define CACHED_FONTSET_NAME SSDATA (XCAR (Vcached_fontset_data))
1081 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1083 /* If fontset name PATTERN contains any wild card, return regular
1084 expression corresponding to PATTERN. */
1086 static Lisp_Object
1087 fontset_pattern_regexp (Lisp_Object pattern)
1089 if (!strchr (SSDATA (pattern), '*')
1090 && !strchr (SSDATA (pattern), '?'))
1091 /* PATTERN does not contain any wild cards. */
1092 return Qnil;
1094 if (!CONSP (Vcached_fontset_data)
1095 || strcmp (SSDATA (pattern), CACHED_FONTSET_NAME))
1097 /* We must at first update the cached data. */
1098 unsigned char *regex, *p0, *p1;
1099 int ndashes = 0, nstars = 0, nescs = 0;
1101 for (p0 = SDATA (pattern); *p0; p0++)
1103 if (*p0 == '-')
1104 ndashes++;
1105 else if (*p0 == '*')
1106 nstars++;
1107 else if (*p0 == '['
1108 || *p0 == '.' || *p0 == '\\'
1109 || *p0 == '+' || *p0 == '^'
1110 || *p0 == '$')
1111 nescs++;
1114 /* If PATTERN is not full XLFD we convert "*" to ".*". Otherwise
1115 we convert "*" to "[^-]*" which is much faster in regular
1116 expression matching. */
1117 if (ndashes < 14)
1118 p1 = regex = alloca (SBYTES (pattern) + 2 * nstars + 2 * nescs + 1);
1119 else
1120 p1 = regex = alloca (SBYTES (pattern) + 5 * nstars + 2 * nescs + 1);
1122 *p1++ = '^';
1123 for (p0 = SDATA (pattern); *p0; p0++)
1125 if (*p0 == '*')
1127 if (ndashes < 14)
1128 *p1++ = '.';
1129 else
1130 *p1++ = '[', *p1++ = '^', *p1++ = '-', *p1++ = ']';
1131 *p1++ = '*';
1133 else if (*p0 == '?')
1134 *p1++ = '.';
1135 else if (*p0 == '['
1136 || *p0 == '.' || *p0 == '\\'
1137 || *p0 == '+' || *p0 == '^'
1138 || *p0 == '$')
1139 *p1++ = '\\', *p1++ = *p0;
1140 else
1141 *p1++ = *p0;
1143 *p1++ = '$';
1144 *p1++ = 0;
1146 Vcached_fontset_data = Fcons (build_string (SSDATA (pattern)),
1147 build_string ((char *) regex));
1150 return CACHED_FONTSET_REGEX;
1153 /* Return ID of the base fontset named NAME. If there's no such
1154 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1155 0: pattern containing '*' and '?' as wildcards
1156 1: regular expression
1157 2: literal fontset name
1161 fs_query_fontset (Lisp_Object name, int name_pattern)
1163 Lisp_Object tem;
1164 int i;
1166 name = Fdowncase (name);
1167 if (name_pattern != 1)
1169 tem = Frassoc (name, Vfontset_alias_alist);
1170 if (NILP (tem))
1171 tem = Fassoc (name, Vfontset_alias_alist);
1172 if (CONSP (tem) && STRINGP (XCAR (tem)))
1173 name = XCAR (tem);
1174 else if (name_pattern == 0)
1176 tem = fontset_pattern_regexp (name);
1177 if (STRINGP (tem))
1179 name = tem;
1180 name_pattern = 1;
1185 for (i = 0; i < ASIZE (Vfontset_table); i++)
1187 Lisp_Object fontset, this_name;
1189 fontset = FONTSET_FROM_ID (i);
1190 if (NILP (fontset)
1191 || !BASE_FONTSET_P (fontset))
1192 continue;
1194 this_name = FONTSET_NAME (fontset);
1195 if (name_pattern == 1
1196 ? fast_string_match_ignore_case (name, this_name) >= 0
1197 : !xstrcasecmp (SSDATA (name), SSDATA (this_name)))
1198 return i;
1200 return -1;
1204 DEFUN ("query-fontset", Fquery_fontset, Squery_fontset, 1, 2, 0,
1205 doc: /* Return the name of a fontset that matches PATTERN.
1206 The value is nil if there is no matching fontset.
1207 PATTERN can contain `*' or `?' as a wildcard
1208 just as X font name matching algorithm allows.
1209 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1210 (Lisp_Object pattern, Lisp_Object regexpp)
1212 Lisp_Object fontset;
1213 int id;
1215 (*check_window_system_func) ();
1217 CHECK_STRING (pattern);
1219 if (SCHARS (pattern) == 0)
1220 return Qnil;
1222 id = fs_query_fontset (pattern, !NILP (regexpp));
1223 if (id < 0)
1224 return Qnil;
1226 fontset = FONTSET_FROM_ID (id);
1227 return FONTSET_NAME (fontset);
1230 /* Return a list of base fontset names matching PATTERN on frame F. */
1232 Lisp_Object
1233 list_fontsets (FRAME_PTR f, Lisp_Object pattern, int size)
1235 Lisp_Object frame, regexp, val;
1236 int id;
1238 XSETFRAME (frame, f);
1240 regexp = fontset_pattern_regexp (pattern);
1241 val = Qnil;
1243 for (id = 0; id < ASIZE (Vfontset_table); id++)
1245 Lisp_Object fontset, name;
1247 fontset = FONTSET_FROM_ID (id);
1248 if (NILP (fontset)
1249 || !BASE_FONTSET_P (fontset)
1250 || !EQ (frame, FONTSET_FRAME (fontset)))
1251 continue;
1252 name = FONTSET_NAME (fontset);
1254 if (STRINGP (regexp)
1255 ? (fast_string_match (regexp, name) < 0)
1256 : strcmp (SSDATA (pattern), SSDATA (name)))
1257 continue;
1259 val = Fcons (Fcopy_sequence (FONTSET_NAME (fontset)), val);
1262 return val;
1266 /* Free all realized fontsets whose base fontset is BASE. */
1268 static void
1269 free_realized_fontsets (Lisp_Object base)
1271 int id;
1273 #if 0
1274 /* For the moment, this doesn't work because free_realized_face
1275 doesn't remove FACE from a cache. Until we find a solution, we
1276 suppress this code, and simply use Fclear_face_cache even though
1277 that is not efficient. */
1278 block_input ();
1279 for (id = 0; id < ASIZE (Vfontset_table); id++)
1281 Lisp_Object this = AREF (Vfontset_table, id);
1283 if (EQ (FONTSET_BASE (this), base))
1285 Lisp_Object tail;
1287 for (tail = FONTSET_FACE_ALIST (this); CONSP (tail);
1288 tail = XCDR (tail))
1290 FRAME_PTR f = XFRAME (FONTSET_FRAME (this));
1291 int face_id = XINT (XCDR (XCAR (tail)));
1292 struct face *face = FACE_FROM_ID (f, face_id);
1294 /* Face THIS itself is also freed by the following call. */
1295 free_realized_face (f, face);
1299 unblock_input ();
1300 #else /* not 0 */
1301 /* But, we don't have to call Fclear_face_cache if no fontset has
1302 been realized from BASE. */
1303 for (id = 0; id < ASIZE (Vfontset_table); id++)
1305 Lisp_Object this = AREF (Vfontset_table, id);
1307 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base))
1309 Fclear_face_cache (Qt);
1310 break;
1313 #endif /* not 0 */
1317 /* Check validity of NAME as a fontset name and return the
1318 corresponding fontset. If not valid, signal an error.
1320 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1321 fontset of *FRAME.
1323 Set *FRAME to the actual frame. */
1325 static Lisp_Object
1326 check_fontset_name (Lisp_Object name, Lisp_Object *frame)
1328 int id;
1330 if (NILP (*frame))
1331 *frame = selected_frame;
1332 CHECK_LIVE_FRAME (*frame);
1334 if (EQ (name, Qt))
1335 return Vdefault_fontset;
1336 if (NILP (name))
1338 id = FRAME_FONTSET (XFRAME (*frame));
1340 else
1342 CHECK_STRING (name);
1343 /* First try NAME as literal. */
1344 id = fs_query_fontset (name, 2);
1345 if (id < 0)
1346 /* For backward compatibility, try again NAME as pattern. */
1347 id = fs_query_fontset (name, 0);
1348 if (id < 0)
1349 error ("Fontset `%s' does not exist", SDATA (name));
1351 return FONTSET_FROM_ID (id);
1354 static void
1355 accumulate_script_ranges (Lisp_Object arg, Lisp_Object range, Lisp_Object val)
1357 if (EQ (XCAR (arg), val))
1359 if (CONSP (range))
1360 XSETCDR (arg, Fcons (Fcons (XCAR (range), XCDR (range)), XCDR (arg)));
1361 else
1362 XSETCDR (arg, Fcons (Fcons (range, range), XCDR (arg)));
1367 /* Callback function for map_charset_chars in Fset_fontset_font.
1368 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1370 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1371 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1372 The consumed ranges are popped up from SCRIPT_RANGE_LIST, and the
1373 new SCRIPT_RANGE_LIST is stored in ARG.
1375 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1376 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1377 case. */
1379 static void
1380 set_fontset_font (Lisp_Object arg, Lisp_Object range)
1382 Lisp_Object fontset, font_def, add, ascii, script_range_list;
1383 int from = XINT (XCAR (range)), to = XINT (XCDR (range));
1385 fontset = AREF (arg, 0);
1386 font_def = AREF (arg, 1);
1387 add = AREF (arg, 2);
1388 ascii = AREF (arg, 3);
1389 script_range_list = AREF (arg, 4);
1391 if (NILP (ascii) && from < 0x80)
1393 if (to < 0x80)
1394 return;
1395 from = 0x80;
1396 range = Fcons (make_number (0x80), XCDR (range));
1399 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1400 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1401 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1403 for (; CONSP (script_range_list) && SCRIPT_TO < from; POP_SCRIPT_RANGE ())
1404 FONTSET_ADD (fontset, XCAR (script_range_list), font_def, add);
1405 if (CONSP (script_range_list))
1407 if (SCRIPT_FROM < from)
1408 range = Fcons (make_number (SCRIPT_FROM), XCDR (range));
1409 while (CONSP (script_range_list) && SCRIPT_TO <= to)
1410 POP_SCRIPT_RANGE ();
1411 if (CONSP (script_range_list) && SCRIPT_FROM <= to)
1412 XSETCAR (XCAR (script_range_list), make_number (to + 1));
1415 FONTSET_ADD (fontset, range, font_def, add);
1416 ASET (arg, 4, script_range_list);
1419 static void update_auto_fontset_alist (Lisp_Object, Lisp_Object);
1422 DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 5, 0,
1423 doc: /*
1424 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1426 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1427 the default fontset.
1429 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1430 In that case, use FONT-SPEC for all characters in the range FROM and
1431 TO (inclusive).
1433 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1434 all characters that belong to the script.
1436 TARGET may be a charset. In that case, use FONT-SPEC for all
1437 characters in the charset.
1439 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1440 that no FONT-SPEC is specified.
1442 FONT-SPEC may one of these:
1443 * A font-spec object made by the function `font-spec' (which see).
1444 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1445 REGISTRY is a font registry name. FAMILY may contain foundry
1446 name, and REGISTRY may contain encoding name.
1447 * A font name string.
1448 * nil, which explicitly specifies that there's no font for TARGET.
1450 Optional 4th argument FRAME is a frame or nil for the selected frame
1451 that is concerned in the case that NAME is nil.
1453 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1454 to the font specifications for TARGET previously set. If it is
1455 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1456 appended. By default, FONT-SPEC overrides the previous settings. */)
1457 (Lisp_Object name, Lisp_Object target, Lisp_Object font_spec, Lisp_Object frame, Lisp_Object add)
1459 Lisp_Object fontset;
1460 Lisp_Object font_def, registry, family;
1461 Lisp_Object range_list;
1462 struct charset *charset = NULL;
1463 Lisp_Object fontname;
1464 bool ascii_changed = 0;
1466 fontset = check_fontset_name (name, &frame);
1468 fontname = Qnil;
1469 if (CONSP (font_spec))
1471 Lisp_Object spec = Ffont_spec (0, NULL);
1473 font_parse_family_registry (XCAR (font_spec), XCDR (font_spec), spec);
1474 font_spec = spec;
1475 fontname = Ffont_xlfd_name (font_spec, Qnil);
1477 else if (STRINGP (font_spec))
1479 Lisp_Object args[2];
1481 fontname = font_spec;
1482 args[0] = QCname;
1483 args[1] = font_spec;
1484 font_spec = Ffont_spec (2, args);
1486 else if (FONT_SPEC_P (font_spec))
1487 fontname = Ffont_xlfd_name (font_spec, Qnil);
1488 else if (! NILP (font_spec))
1489 Fsignal (Qfont, list2 (build_string ("Invalid font-spec"), font_spec));
1491 if (! NILP (font_spec))
1493 Lisp_Object encoding, repertory;
1495 family = AREF (font_spec, FONT_FAMILY_INDEX);
1496 if (! NILP (family) )
1497 family = SYMBOL_NAME (family);
1498 registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1499 if (! NILP (registry))
1500 registry = Fdowncase (SYMBOL_NAME (registry));
1501 encoding = find_font_encoding (concat3 (family, build_string ("-"),
1502 registry));
1503 if (NILP (encoding))
1504 encoding = Qascii;
1506 if (SYMBOLP (encoding))
1508 CHECK_CHARSET (encoding);
1509 encoding = repertory = CHARSET_SYMBOL_ID (encoding);
1511 else
1513 repertory = XCDR (encoding);
1514 encoding = XCAR (encoding);
1515 CHECK_CHARSET (encoding);
1516 encoding = CHARSET_SYMBOL_ID (encoding);
1517 if (! NILP (repertory) && SYMBOLP (repertory))
1519 CHECK_CHARSET (repertory);
1520 repertory = CHARSET_SYMBOL_ID (repertory);
1523 FONT_DEF_NEW (font_def, font_spec, encoding, repertory);
1525 else
1526 font_def = Qnil;
1528 if (CHARACTERP (target))
1530 if (XFASTINT (target) < 0x80)
1531 error ("Can't set a font for partial ASCII range");
1532 range_list = Fcons (Fcons (target, target), Qnil);
1534 else if (CONSP (target))
1536 Lisp_Object from, to;
1538 from = Fcar (target);
1539 to = Fcdr (target);
1540 CHECK_CHARACTER (from);
1541 CHECK_CHARACTER (to);
1542 if (XFASTINT (from) < 0x80)
1544 if (XFASTINT (from) != 0 || XFASTINT (to) < 0x7F)
1545 error ("Can't set a font for partial ASCII range");
1546 ascii_changed = 1;
1548 range_list = Fcons (target, Qnil);
1550 else if (SYMBOLP (target) && !NILP (target))
1552 Lisp_Object script_list;
1553 Lisp_Object val;
1555 range_list = Qnil;
1556 script_list = XCHAR_TABLE (Vchar_script_table)->extras[0];
1557 if (! NILP (Fmemq (target, script_list)))
1559 if (EQ (target, Qlatin))
1560 ascii_changed = 1;
1561 val = Fcons (target, Qnil);
1562 map_char_table (accumulate_script_ranges, Qnil, Vchar_script_table,
1563 val);
1564 range_list = Fnreverse (XCDR (val));
1566 if (CHARSETP (target))
1568 CHECK_CHARSET_GET_CHARSET (target, charset);
1569 if (charset->ascii_compatible_p)
1570 ascii_changed = 1;
1572 else if (NILP (range_list))
1573 error ("Invalid script or charset name: %s",
1574 SDATA (SYMBOL_NAME (target)));
1576 else if (NILP (target))
1577 range_list = Fcons (Qnil, Qnil);
1578 else
1579 error ("Invalid target for setting a font");
1581 if (ascii_changed)
1583 Lisp_Object val;
1585 if (NILP (font_spec))
1586 error ("Can't set ASCII font to nil");
1587 val = CHAR_TABLE_REF (fontset, 0);
1588 if (! NILP (val) && EQ (add, Qappend))
1589 /* We are going to change just an additional font for ASCII. */
1590 ascii_changed = 0;
1593 if (charset)
1595 Lisp_Object arg;
1597 arg = Fmake_vector (make_number (5), Qnil);
1598 ASET (arg, 0, fontset);
1599 ASET (arg, 1, font_def);
1600 ASET (arg, 2, add);
1601 ASET (arg, 3, ascii_changed ? Qt : Qnil);
1602 ASET (arg, 4, range_list);
1604 map_charset_chars (set_fontset_font, Qnil, arg, charset,
1605 CHARSET_MIN_CODE (charset),
1606 CHARSET_MAX_CODE (charset));
1607 range_list = AREF (arg, 4);
1609 for (; CONSP (range_list); range_list = XCDR (range_list))
1610 FONTSET_ADD (fontset, XCAR (range_list), font_def, add);
1612 if (ascii_changed)
1614 Lisp_Object tail, fr, alist;
1615 int fontset_id = XINT (FONTSET_ID (fontset));
1617 set_fontset_ascii (fontset, fontname);
1618 name = FONTSET_NAME (fontset);
1619 FOR_EACH_FRAME (tail, fr)
1621 FRAME_PTR f = XFRAME (fr);
1622 Lisp_Object font_object;
1623 struct face *face;
1625 if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f))
1626 continue;
1627 if (fontset_id != FRAME_FONTSET (f))
1628 continue;
1629 face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
1630 if (face)
1631 font_object = font_load_for_lface (f, face->lface, font_spec);
1632 else
1633 font_object = font_open_by_spec (f, font_spec);
1634 if (! NILP (font_object))
1636 update_auto_fontset_alist (font_object, fontset);
1637 alist = Fcons (Fcons (Qfont, Fcons (name, font_object)), Qnil);
1638 Fmodify_frame_parameters (fr, alist);
1643 /* Free all realized fontsets whose base is FONTSET. This way, the
1644 specified character(s) are surely redisplayed by a correct
1645 font. */
1646 free_realized_fontsets (fontset);
1648 return Qnil;
1652 DEFUN ("new-fontset", Fnew_fontset, Snew_fontset, 2, 2, 0,
1653 doc: /* Create a new fontset NAME from font information in FONTLIST.
1655 FONTLIST is an alist of scripts vs the corresponding font specification list.
1656 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1657 character of SCRIPT is displayed by a font that matches one of
1658 FONT-SPEC.
1660 SCRIPT is a symbol that appears in the first extra slot of the
1661 char-table `char-script-table'.
1663 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1664 `set-fontset-font' for the meaning. */)
1665 (Lisp_Object name, Lisp_Object fontlist)
1667 Lisp_Object fontset;
1668 int id;
1670 CHECK_STRING (name);
1671 CHECK_LIST (fontlist);
1673 name = Fdowncase (name);
1674 id = fs_query_fontset (name, 0);
1675 if (id < 0)
1677 Lisp_Object font_spec = Ffont_spec (0, NULL);
1678 Lisp_Object short_name;
1679 char xlfd[256];
1680 int len;
1682 if (font_parse_xlfd (SSDATA (name), SBYTES (name), font_spec) < 0)
1683 error ("Fontset name must be in XLFD format");
1684 short_name = AREF (font_spec, FONT_REGISTRY_INDEX);
1685 if (strncmp (SSDATA (SYMBOL_NAME (short_name)), "fontset-", 8)
1686 || SBYTES (SYMBOL_NAME (short_name)) < 9)
1687 error ("Registry field of fontset name must be \"fontset-*\"");
1688 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (short_name)),
1689 Vfontset_alias_alist);
1690 ASET (font_spec, FONT_REGISTRY_INDEX, Qiso8859_1);
1691 fontset = make_fontset (Qnil, name, Qnil);
1692 len = font_unparse_xlfd (font_spec, 0, xlfd, 256);
1693 if (len < 0)
1694 error ("Invalid fontset name (perhaps too long): %s", SDATA (name));
1695 set_fontset_ascii (fontset, make_unibyte_string (xlfd, len));
1697 else
1699 fontset = FONTSET_FROM_ID (id);
1700 free_realized_fontsets (fontset);
1701 Fset_char_table_range (fontset, Qt, Qnil);
1704 for (; CONSP (fontlist); fontlist = XCDR (fontlist))
1706 Lisp_Object elt, script;
1708 elt = XCAR (fontlist);
1709 script = Fcar (elt);
1710 elt = Fcdr (elt);
1711 if (CONSP (elt) && (NILP (XCDR (elt)) || CONSP (XCDR (elt))))
1712 for (; CONSP (elt); elt = XCDR (elt))
1713 Fset_fontset_font (name, script, XCAR (elt), Qnil, Qappend);
1714 else
1715 Fset_fontset_font (name, script, elt, Qnil, Qappend);
1717 return name;
1721 /* Alist of automatically created fontsets. Each element is a cons
1722 (FONT-SPEC . FONTSET-ID). */
1723 static Lisp_Object auto_fontset_alist;
1725 /* Number of automatically created fontsets. */
1726 static ptrdiff_t num_auto_fontsets;
1728 /* Return a fontset synthesized from FONT-OBJECT. This is called from
1729 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1730 frame, and the returned fontset is used for the default fontset of
1731 that frame. The fontset specifies a font of the same registry as
1732 FONT-OBJECT for all characters in the repertory of the registry
1733 (see Vfont_encoding_alist). If the repertory is not known, the
1734 fontset specifies the font for all Latin characters assuming that a
1735 user intends to use FONT-OBJECT for Latin characters. */
1738 fontset_from_font (Lisp_Object font_object)
1740 Lisp_Object font_name = font_get_name (font_object);
1741 Lisp_Object font_spec = copy_font_spec (font_object);
1742 Lisp_Object registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1743 Lisp_Object fontset_spec, alias, name, fontset;
1744 Lisp_Object val;
1746 val = assoc_no_quit (font_spec, auto_fontset_alist);
1747 if (CONSP (val))
1748 return XINT (FONTSET_ID (XCDR (val)));
1749 if (num_auto_fontsets++ == 0)
1750 alias = intern ("fontset-startup");
1751 else
1753 char temp[sizeof "fontset-auto" + INT_STRLEN_BOUND (ptrdiff_t)];
1755 sprintf (temp, "fontset-auto%"pD"d", num_auto_fontsets - 1);
1756 alias = intern (temp);
1758 fontset_spec = copy_font_spec (font_spec);
1759 ASET (fontset_spec, FONT_REGISTRY_INDEX, alias);
1760 name = Ffont_xlfd_name (fontset_spec, Qnil);
1761 eassert (!NILP (name));
1762 fontset = make_fontset (Qnil, name, Qnil);
1763 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (alias)),
1764 Vfontset_alias_alist);
1765 alias = Fdowncase (AREF (font_object, FONT_NAME_INDEX));
1766 Vfontset_alias_alist = Fcons (Fcons (name, alias), Vfontset_alias_alist);
1767 auto_fontset_alist = Fcons (Fcons (font_spec, fontset), auto_fontset_alist);
1768 font_spec = Ffont_spec (0, NULL);
1769 ASET (font_spec, FONT_REGISTRY_INDEX, registry);
1771 Lisp_Object target = find_font_encoding (SYMBOL_NAME (registry));
1773 if (CONSP (target))
1774 target = XCDR (target);
1775 if (! CHARSETP (target))
1776 target = Qlatin;
1777 Fset_fontset_font (name, target, font_spec, Qnil, Qnil);
1778 Fset_fontset_font (name, Qnil, font_spec, Qnil, Qnil);
1781 set_fontset_ascii (fontset, font_name);
1783 return XINT (FONTSET_ID (fontset));
1787 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1788 FONTSET is changed, we delete an entry of FONTSET if any from
1789 auto_fontset_alist so that FONTSET is not re-used by
1790 fontset_from_font. */
1792 static void
1793 update_auto_fontset_alist (Lisp_Object font_object, Lisp_Object fontset)
1795 Lisp_Object prev, tail;
1797 for (prev = Qnil, tail = auto_fontset_alist; CONSP (tail);
1798 prev = tail, tail = XCDR (tail))
1799 if (EQ (fontset, XCDR (XCAR (tail))))
1801 if (NILP (prev))
1802 auto_fontset_alist = XCDR (tail);
1803 else
1804 XSETCDR (prev, XCDR (tail));
1805 break;
1810 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1811 FONT-OBJECT is the font for the character at POSITION in the current
1812 buffer. This is computed from all the text properties and overlays
1813 that apply to POSITION. POSITION may be nil, in which case,
1814 FONT-SPEC is the font for displaying the character CH with the
1815 default face.
1817 GLYPH-CODE is the glyph code in the font to use for the character.
1819 If the 2nd optional arg CH is non-nil, it is a character to check
1820 the font instead of the character at POSITION.
1822 It returns nil in the following cases:
1824 (1) The window system doesn't have a font for the character (thus
1825 it is displayed by an empty box).
1827 (2) The character code is invalid.
1829 (3) If POSITION is not nil, and the current buffer is not displayed
1830 in any window.
1832 In addition, the returned font name may not take into account of
1833 such redisplay engine hooks as what used in jit-lock-mode if
1834 POSITION is currently not visible. */
1837 DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
1838 doc: /* For internal use only. */)
1839 (Lisp_Object position, Lisp_Object ch)
1841 ptrdiff_t pos, pos_byte, dummy;
1842 int face_id;
1843 int c;
1844 struct frame *f;
1845 struct face *face;
1847 if (NILP (position))
1849 CHECK_CHARACTER (ch);
1850 c = XINT (ch);
1851 f = XFRAME (selected_frame);
1852 face_id = lookup_basic_face (f, DEFAULT_FACE_ID);
1853 pos = -1;
1855 else
1857 Lisp_Object window;
1858 struct window *w;
1860 CHECK_NUMBER_COERCE_MARKER (position);
1861 if (! (BEGV <= XINT (position) && XINT (position) < ZV))
1862 args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
1863 pos = XINT (position);
1864 pos_byte = CHAR_TO_BYTE (pos);
1865 if (NILP (ch))
1866 c = FETCH_CHAR (pos_byte);
1867 else
1869 CHECK_NATNUM (ch);
1870 c = XINT (ch);
1872 window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
1873 if (NILP (window))
1874 return Qnil;
1875 w = XWINDOW (window);
1876 f = XFRAME (w->frame);
1877 face_id = face_at_buffer_position (w, pos, -1, -1, &dummy,
1878 pos + 100, 0, -1);
1880 if (! CHAR_VALID_P (c))
1881 return Qnil;
1882 if (!FRAME_WINDOW_P (f))
1883 return Qnil;
1884 face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
1885 face = FACE_FROM_ID (f, face_id);
1886 if (face->font)
1888 unsigned code = face->font->driver->encode_char (face->font, c);
1889 Lisp_Object font_object;
1891 if (code == FONT_INVALID_CODE)
1892 return Qnil;
1893 XSETFONT (font_object, face->font);
1894 return Fcons (font_object, INTEGER_TO_CONS (code));
1896 return Qnil;
1900 DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
1901 doc: /* Return information about a fontset FONTSET on frame FRAME.
1903 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1904 for the default fontset. FRAME nil means the selected frame.
1906 The value is a char-table whose elements have this form:
1908 ((FONT OPENED-FONT ...) ...)
1910 FONT is a name of font specified for a range of characters.
1912 OPENED-FONT is a name of a font actually opened.
1914 The char-table has one extra slot. If FONTSET is not the default
1915 fontset, the value the extra slot is a char-table containing the
1916 information about the derived fonts from the default fontset. The
1917 format is the same as above. */)
1918 (Lisp_Object fontset, Lisp_Object frame)
1920 Lisp_Object *realized[2], fontsets[2], tables[2];
1921 Lisp_Object val, elt;
1922 int c, i, j, k;
1924 (*check_window_system_func) ();
1926 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] = alloca (word_size * ASIZE (Vfontset_table));
1931 for (i = j = 0; i < ASIZE (Vfontset_table); i++)
1933 elt = FONTSET_FROM_ID (i);
1934 if (!NILP (elt)
1935 && EQ (FONTSET_BASE (elt), fontset)
1936 && EQ (FONTSET_FRAME (elt), frame))
1937 realized[0][j++] = elt;
1939 realized[0][j] = Qnil;
1941 realized[1] = alloca (word_size * ASIZE (Vfontset_table));
1942 for (i = j = 0; ! NILP (realized[0][i]); i++)
1944 elt = FONTSET_DEFAULT (realized[0][i]);
1945 if (! NILP (elt))
1946 realized[1][j++] = elt;
1948 realized[1][j] = Qnil;
1950 tables[0] = Fmake_char_table (Qfontset_info, Qnil);
1951 fontsets[0] = fontset;
1952 if (!EQ (fontset, Vdefault_fontset))
1954 tables[1] = Fmake_char_table (Qnil, Qnil);
1955 set_char_table_extras (tables[0], 0, tables[1]);
1956 fontsets[1] = Vdefault_fontset;
1959 /* Accumulate information of the fontset in TABLE. The format of
1960 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1961 for (k = 0; k <= 1; k++)
1963 for (c = 0; c <= MAX_CHAR; )
1965 int from = c, to = MAX_5_BYTE_CHAR;
1967 if (c <= MAX_5_BYTE_CHAR)
1969 val = char_table_ref_and_range (fontsets[k], c, &from, &to);
1971 else
1973 val = FONTSET_FALLBACK (fontsets[k]);
1974 to = MAX_CHAR;
1976 if (VECTORP (val))
1978 Lisp_Object alist;
1980 /* At first, set ALIST to ((FONT-SPEC) ...). */
1981 for (alist = Qnil, i = 0; i < ASIZE (val); i++)
1982 if (! NILP (AREF (val, i)))
1983 alist = Fcons (Fcons (FONT_DEF_SPEC (AREF (val, i)), Qnil),
1984 alist);
1985 alist = Fnreverse (alist);
1987 /* Then store opened font names to cdr of each elements. */
1988 for (i = 0; ! NILP (realized[k][i]); i++)
1990 if (c <= MAX_5_BYTE_CHAR)
1991 val = FONTSET_REF (realized[k][i], c);
1992 else
1993 val = FONTSET_FALLBACK (realized[k][i]);
1994 if (! CONSP (val) || ! VECTORP (XCDR (val)))
1995 continue;
1996 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
1997 val = XCDR (val);
1998 for (j = 0; j < ASIZE (val); j++)
2000 elt = AREF (val, j);
2001 if (FONT_OBJECT_P (RFONT_DEF_OBJECT (elt)))
2003 Lisp_Object font_object = RFONT_DEF_OBJECT (elt);
2004 Lisp_Object slot, name;
2006 slot = Fassq (RFONT_DEF_SPEC (elt), alist);
2007 name = AREF (font_object, FONT_NAME_INDEX);
2008 if (NILP (Fmember (name, XCDR (slot))))
2009 nconc2 (slot, Fcons (name, Qnil));
2014 /* Store ALIST in TBL for characters C..TO. */
2015 if (c <= MAX_5_BYTE_CHAR)
2016 char_table_set_range (tables[k], c, to, alist);
2017 else
2018 set_char_table_defalt (tables[k], alist);
2020 /* At last, change each elements to font names. */
2021 for (; CONSP (alist); alist = XCDR (alist))
2023 elt = XCAR (alist);
2024 XSETCAR (elt, Ffont_xlfd_name (XCAR (elt), Qnil));
2027 c = to + 1;
2029 if (EQ (fontset, Vdefault_fontset))
2030 break;
2033 return tables[0];
2037 DEFUN ("fontset-font", Ffontset_font, Sfontset_font, 2, 3, 0,
2038 doc: /* Return a font name pattern for character CH in fontset NAME.
2039 If NAME is t, find a pattern in the default fontset.
2040 If NAME is nil, find a pattern in the fontset of the selected frame.
2042 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2043 family name and REGISTRY is a font registry name. This is actually
2044 the first font name pattern for CH in the fontset or in the default
2045 fontset.
2047 If the 2nd optional arg ALL is non-nil, return a list of all font name
2048 patterns. */)
2049 (Lisp_Object name, Lisp_Object ch, Lisp_Object all)
2051 int c;
2052 Lisp_Object fontset, elt, list, repertory, val;
2053 int i, j;
2054 Lisp_Object frame;
2056 frame = Qnil;
2057 fontset = check_fontset_name (name, &frame);
2059 CHECK_CHARACTER (ch);
2060 c = XINT (ch);
2061 list = Qnil;
2062 while (1)
2064 for (i = 0, elt = FONTSET_REF (fontset, c); i < 2;
2065 i++, elt = FONTSET_FALLBACK (fontset))
2066 if (VECTORP (elt))
2067 for (j = 0; j < ASIZE (elt); j++)
2069 Lisp_Object family, registry;
2071 val = AREF (elt, j);
2072 if (NILP (val))
2073 return Qnil;
2074 repertory = AREF (val, 1);
2075 if (INTEGERP (repertory))
2077 struct charset *charset = CHARSET_FROM_ID (XINT (repertory));
2079 if (! CHAR_CHARSET_P (c, charset))
2080 continue;
2082 else if (CHAR_TABLE_P (repertory))
2084 if (NILP (CHAR_TABLE_REF (repertory, c)))
2085 continue;
2087 val = AREF (val, 0);
2088 /* VAL is a FONT-SPEC */
2089 family = AREF (val, FONT_FAMILY_INDEX);
2090 if (! NILP (family))
2091 family = SYMBOL_NAME (family);
2092 registry = AREF (val, FONT_REGISTRY_INDEX);
2093 if (! NILP (registry))
2094 registry = SYMBOL_NAME (registry);
2095 val = Fcons (family, registry);
2096 if (NILP (all))
2097 return val;
2098 list = Fcons (val, list);
2100 if (EQ (fontset, Vdefault_fontset))
2101 break;
2102 fontset = Vdefault_fontset;
2104 return (Fnreverse (list));
2107 DEFUN ("fontset-list", Ffontset_list, Sfontset_list, 0, 0, 0,
2108 doc: /* Return a list of all defined fontset names. */)
2109 (void)
2111 Lisp_Object fontset, list;
2112 int i;
2114 list = Qnil;
2115 for (i = 0; i < ASIZE (Vfontset_table); i++)
2117 fontset = FONTSET_FROM_ID (i);
2118 if (!NILP (fontset)
2119 && BASE_FONTSET_P (fontset))
2120 list = Fcons (FONTSET_NAME (fontset), list);
2123 return list;
2127 #ifdef ENABLE_CHECKING
2129 Lisp_Object dump_fontset (Lisp_Object) EXTERNALLY_VISIBLE;
2131 Lisp_Object
2132 dump_fontset (Lisp_Object fontset)
2134 Lisp_Object vec;
2136 vec = Fmake_vector (make_number (3), Qnil);
2137 ASET (vec, 0, FONTSET_ID (fontset));
2139 if (BASE_FONTSET_P (fontset))
2141 ASET (vec, 1, FONTSET_NAME (fontset));
2143 else
2145 Lisp_Object frame;
2147 frame = FONTSET_FRAME (fontset);
2148 if (FRAMEP (frame))
2150 FRAME_PTR f = XFRAME (frame);
2152 if (FRAME_LIVE_P (f))
2153 ASET (vec, 1,
2154 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)),
2155 f->name));
2156 else
2157 ASET (vec, 1,
2158 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)), Qnil));
2160 if (!NILP (FONTSET_DEFAULT (fontset)))
2161 ASET (vec, 2, FONTSET_ID (FONTSET_DEFAULT (fontset)));
2163 return vec;
2166 DEFUN ("fontset-list-all", Ffontset_list_all, Sfontset_list_all, 0, 0, 0,
2167 doc: /* Return a brief summary of all fontsets for debug use. */)
2168 (void)
2170 Lisp_Object val;
2171 int i;
2173 for (i = 0, val = Qnil; i < ASIZE (Vfontset_table); i++)
2174 if (! NILP (AREF (Vfontset_table, i)))
2175 val = Fcons (dump_fontset (AREF (Vfontset_table, i)), val);
2176 return (Fnreverse (val));
2178 #endif /* ENABLE_CHECKING */
2180 void
2181 syms_of_fontset (void)
2183 DEFSYM (Qfontset, "fontset");
2184 Fput (Qfontset, Qchar_table_extra_slots, make_number (9));
2185 DEFSYM (Qfontset_info, "fontset-info");
2186 Fput (Qfontset_info, Qchar_table_extra_slots, make_number (1));
2188 DEFSYM (Qprepend, "prepend");
2189 DEFSYM (Qappend, "append");
2190 DEFSYM (Qlatin, "latin");
2192 Vcached_fontset_data = Qnil;
2193 staticpro (&Vcached_fontset_data);
2195 Vfontset_table = Fmake_vector (make_number (32), Qnil);
2196 staticpro (&Vfontset_table);
2198 Vdefault_fontset = Fmake_char_table (Qfontset, Qnil);
2199 staticpro (&Vdefault_fontset);
2200 set_fontset_id (Vdefault_fontset, make_number (0));
2201 set_fontset_name
2202 (Vdefault_fontset,
2203 build_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,
2211 doc: /*
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,
2222 doc: /*
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,
2232 doc: /*
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 build_pure_c_string ("fontset-default")),
2250 Qnil);
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 ENABLE_CHECKING
2271 defsubr (&Sfontset_list_all);
2272 #endif