Remove an incorrect assertion on move_it_by_lines.
[emacs.git] / src / fontset.c
blobd06491ddf255d6307d2edac59652e0fd4ea7a8e5
1 /* Fontset handler.
3 Copyright (C) 2001-2012 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 /* #define FONTSET_DEBUG */
29 #include <config.h>
30 #include <stdio.h>
31 #include <setjmp.h>
33 #include "lisp.h"
34 #include "blockinput.h"
35 #include "buffer.h"
36 #include "character.h"
37 #include "charset.h"
38 #include "ccl.h"
39 #include "keyboard.h"
40 #include "frame.h"
41 #include "dispextern.h"
42 #include "intervals.h"
43 #include "fontset.h"
44 #include "window.h"
45 #ifdef HAVE_X_WINDOWS
46 #include "xterm.h"
47 #endif
48 #ifdef WINDOWSNT
49 #include "w32term.h"
50 #endif
51 #ifdef HAVE_NS
52 #include "nsterm.h"
53 #endif
54 #include "termhooks.h"
56 #include "font.h"
58 #undef xassert
59 #ifdef FONTSET_DEBUG
60 #define xassert(X) do {if (!(X)) abort ();} while (0)
61 #else /* not FONTSET_DEBUG */
62 #define xassert(X) (void) 0
63 #endif /* not FONTSET_DEBUG */
65 /* FONTSET
67 A fontset is a collection of font related information to give
68 similar appearance (style, etc) of characters. A fontset has two
69 roles. One is to use for the frame parameter `font' as if it is an
70 ASCII font. In that case, Emacs uses the font specified for
71 `ascii' script for the frame's default font.
73 Another role, the more important one, is to provide information
74 about which font to use for each non-ASCII character.
76 There are two kinds of fontsets; base and realized. A base fontset
77 is created by `new-fontset' from Emacs Lisp explicitly. A realized
78 fontset is created implicitly when a face is realized for ASCII
79 characters. A face is also realized for non-ASCII characters based
80 on an ASCII face. All of non-ASCII faces based on the same ASCII
81 face share the same realized fontset.
83 A fontset object is implemented by a char-table whose default value
84 and parent are always nil.
86 An element of a base fontset is a vector of FONT-DEFs which itself
87 is a vector [ FONT-SPEC ENCODING REPERTORY ].
89 An element of a realized fontset is nil, t, 0, or a vector of this
90 form:
92 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
93 RFONT-DEF0 RFONT-DEF1 ... ]
95 RFONT-DEFn (i.e. Realized FONT-DEF) has this form:
97 [ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]
99 RFONT-DEFn are automatically reordered by the current charset
100 priority list.
102 The value nil means that we have not yet generated the above vector
103 from the base of the fontset.
105 The value t means that no font is available for the corresponding
106 range of characters.
108 The value 0 means that no font is available for the corresponding
109 range of characters in this fontset, but may be available in the
110 default fontset.
113 A fontset has 9 extra slots.
115 The 1st slot: the ID number of the fontset
117 The 2nd slot:
118 base: the name of the fontset
119 realized: nil
121 The 3rd slot:
122 base: nil
123 realized: the base fontset
125 The 4th slot:
126 base: nil
127 realized: the frame that the fontset belongs to
129 The 5th slot:
130 base: the font name for ASCII characters
131 realized: nil
133 The 6th slot:
134 base: nil
135 realized: the ID number of a face to use for characters that
136 has no font in a realized fontset.
138 The 7th slot:
139 base: nil
140 realized: Alist of font index vs the corresponding repertory
141 char-table.
143 The 8th slot:
144 base: nil
145 realized: If the base is not the default fontset, a fontset
146 realized from the default fontset, else nil.
148 The 9th slot:
149 base: Same as element value (but for fallback fonts).
150 realized: Likewise.
152 All fontsets are recorded in the vector Vfontset_table.
155 DEFAULT FONTSET
157 There's a special base fontset named `default fontset' which
158 defines the default font specifications. When a base fontset
159 doesn't specify a font for a specific character, the corresponding
160 value in the default fontset is used.
162 The parent of a realized fontset created for such a face that has
163 no fontset is the default fontset.
166 These structures are hidden from the other codes than this file.
167 The other codes handle fontsets only by their ID numbers. They
168 usually use the variable name `fontset' for IDs. But, in this
169 file, we always use variable name `id' for IDs, and name `fontset'
170 for an actual fontset object, i.e., char-table.
174 /********** VARIABLES and FUNCTION PROTOTYPES **********/
176 static Lisp_Object Qfontset;
177 static Lisp_Object Qfontset_info;
178 static Lisp_Object Qprepend, Qappend;
179 Lisp_Object Qlatin;
181 /* Vector containing all fontsets. */
182 static Lisp_Object Vfontset_table;
184 /* Next possibly free fontset ID. Usually this keeps the minimum
185 fontset ID not yet used. */
186 static int next_fontset_id;
188 /* The default fontset. This gives default FAMILY and REGISTRY of
189 font for each character. */
190 static Lisp_Object Vdefault_fontset;
192 /* Check if any window system is used now. */
193 void (*check_window_system_func) (void);
196 /* Prototype declarations for static functions. */
197 static Lisp_Object fontset_add (Lisp_Object, Lisp_Object, Lisp_Object,
198 Lisp_Object);
199 static Lisp_Object fontset_find_font (Lisp_Object, int, struct face *,
200 int, int);
201 static void reorder_font_vector (Lisp_Object, struct font *);
202 static Lisp_Object fontset_font (Lisp_Object, int, struct face *, int);
203 static Lisp_Object make_fontset (Lisp_Object, Lisp_Object, Lisp_Object);
204 static Lisp_Object fontset_pattern_regexp (Lisp_Object);
205 static void accumulate_script_ranges (Lisp_Object, Lisp_Object,
206 Lisp_Object);
207 static void set_fontset_font (Lisp_Object, Lisp_Object);
209 #ifdef FONTSET_DEBUG
211 /* Return 1 if ID is a valid fontset id, else return 0. */
213 static int
214 fontset_id_valid_p (int id)
216 return (id >= 0 && id < ASIZE (Vfontset_table) - 1);
219 #endif
223 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
225 /* Return the fontset with ID. No check of ID's validness. */
226 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
228 /* Macros to access special values of FONTSET. */
229 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
231 /* Macros to access special values of (base) FONTSET. */
232 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
233 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->extras[4]
234 /* #define FONTSET_SPEC(fontset) XCHAR_TABLE (fontset)->extras[5] */
236 /* Macros to access special values of (realized) FONTSET. */
237 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->extras[2]
238 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[3]
239 /* #define FONTSET_OBJLIST(fontset) XCHAR_TABLE (fontset)->extras[4] */
240 #define FONTSET_NOFONT_FACE(fontset) XCHAR_TABLE (fontset)->extras[5]
241 /* #define FONTSET_REPERTORY(fontset) XCHAR_TABLE (fontset)->extras[6] */
242 #define FONTSET_DEFAULT(fontset) XCHAR_TABLE (fontset)->extras[7]
244 /* For both base and realized fontset. */
245 #define FONTSET_FALLBACK(fontset) XCHAR_TABLE (fontset)->extras[8]
247 #define BASE_FONTSET_P(fontset) (NILP (FONTSET_BASE (fontset)))
250 /* Macros for FONT-DEF and RFONT-DEF of fontset. */
251 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory) \
252 do { \
253 (font_def) = Fmake_vector (make_number (3), (font_spec)); \
254 ASET ((font_def), 1, encoding); \
255 ASET ((font_def), 2, repertory); \
256 } while (0)
258 #define FONT_DEF_SPEC(font_def) AREF (font_def, 0)
259 #define FONT_DEF_ENCODING(font_def) AREF (font_def, 1)
260 #define FONT_DEF_REPERTORY(font_def) AREF (font_def, 2)
262 #define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
263 #define RFONT_DEF_SET_FACE(rfont_def, face_id) \
264 ASET ((rfont_def), 0, make_number (face_id))
265 #define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
266 #define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
267 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
268 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
269 ASET ((rfont_def), 2, (object))
270 /* Score of RFONT_DEF is an integer value; the lowest 8 bits represent
271 the order of listing by font backends, the higher bits represents
272 the order given by charset priority list. The smaller value is
273 preferable. */
274 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
275 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
276 ASET ((rfont_def), 3, make_number (score))
277 #define RFONT_DEF_NEW(rfont_def, font_def) \
278 do { \
279 (rfont_def) = Fmake_vector (make_number (4), Qnil); \
280 ASET ((rfont_def), 1, (font_def)); \
281 RFONT_DEF_SET_SCORE ((rfont_def), 0); \
282 } while (0)
285 /* Return the element of FONTSET for the character C. If FONTSET is a
286 base fontset other then the default fontset and FONTSET doesn't
287 contain information for C, return the information in the default
288 fontset. */
290 #define FONTSET_REF(fontset, c) \
291 (EQ (fontset, Vdefault_fontset) \
292 ? CHAR_TABLE_REF (fontset, c) \
293 : fontset_ref ((fontset), (c)))
295 static Lisp_Object
296 fontset_ref (Lisp_Object fontset, int c)
298 Lisp_Object elt;
300 elt = CHAR_TABLE_REF (fontset, c);
301 if (NILP (elt) && ! EQ (fontset, Vdefault_fontset)
302 /* Don't check Vdefault_fontset for a realized fontset. */
303 && NILP (FONTSET_BASE (fontset)))
304 elt = CHAR_TABLE_REF (Vdefault_fontset, c);
305 return elt;
308 /* Set elements of FONTSET for characters in RANGE to the value ELT.
309 RANGE is a cons (FROM . TO), where FROM and TO are character codes
310 specifying a range. */
312 #define FONTSET_SET(fontset, range, elt) \
313 Fset_char_table_range ((fontset), (range), (elt))
316 /* Modify the elements of FONTSET for characters in RANGE by replacing
317 with ELT or adding ELT. RANGE is a cons (FROM . TO), where FROM
318 and TO are character codes specifying a range. If ADD is nil,
319 replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
320 append ELT. */
322 #define FONTSET_ADD(fontset, range, elt, add) \
323 (NILP (add) \
324 ? (NILP (range) \
325 ? (FONTSET_FALLBACK (fontset) = Fmake_vector (make_number (1), (elt))) \
326 : Fset_char_table_range ((fontset), (range), \
327 Fmake_vector (make_number (1), (elt)))) \
328 : fontset_add ((fontset), (range), (elt), (add)))
330 static Lisp_Object
331 fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Object add)
333 Lisp_Object args[2];
334 int idx = (EQ (add, Qappend) ? 0 : 1);
336 args[1 - idx] = Fmake_vector (make_number (1), elt);
338 if (CONSP (range))
340 int from = XINT (XCAR (range));
341 int to = XINT (XCDR (range));
342 int from1, to1;
344 do {
345 from1 = from, to1 = to;
346 args[idx] = char_table_ref_and_range (fontset, from, &from1, &to1);
347 char_table_set_range (fontset, from, to1,
348 NILP (args[idx]) ? args[1 - idx]
349 : Fvconcat (2, args));
350 from = to1 + 1;
351 } while (from < to);
353 else
355 args[idx] = FONTSET_FALLBACK (fontset);
356 FONTSET_FALLBACK (fontset)
357 = NILP (args[idx]) ? args[1 - idx] : Fvconcat (2, args);
359 return Qnil;
362 static int
363 fontset_compare_rfontdef (const void *val1, const void *val2)
365 return (RFONT_DEF_SCORE (*(Lisp_Object *) val1)
366 - RFONT_DEF_SCORE (*(Lisp_Object *) val2));
369 /* Update FONT-GROUP which has this form:
370 [ CHARSET-ORDERED-LIST-TICK PREFERRED-RFONT-DEF
371 RFONT-DEF0 RFONT-DEF1 ... ]
372 Reorder RFONT-DEFs according to the current language, and update
373 CHARSET-ORDERED-LIST-TICK.
375 If PREFERRED_FAMILY is not nil, that family has the higher priority
376 if the encoding charsets or languages in font-specs are the same. */
378 static void
379 reorder_font_vector (Lisp_Object font_group, struct font *font)
381 Lisp_Object vec, font_object;
382 int size;
383 int i;
384 int score_changed = 0;
386 if (font)
387 XSETFONT (font_object, font);
388 else
389 font_object = Qnil;
391 vec = XCDR (font_group);
392 size = ASIZE (vec);
393 /* Exclude the tailing nil element from the reordering. */
394 if (NILP (AREF (vec, size - 1)))
395 size--;
397 for (i = 0; i < size; i++)
399 Lisp_Object rfont_def = AREF (vec, i);
400 Lisp_Object font_def = RFONT_DEF_FONT_DEF (rfont_def);
401 Lisp_Object font_spec = FONT_DEF_SPEC (font_def);
402 int score = RFONT_DEF_SCORE (rfont_def) & 0xFF;
403 Lisp_Object otf_spec = Ffont_get (font_spec, QCotf);
405 if (! NILP (otf_spec))
406 /* A font-spec with :otf is preferable regardless of encoding
407 and language.. */
409 else if (! font_match_p (font_spec, font_object))
411 Lisp_Object encoding = FONT_DEF_ENCODING (font_def);
413 if (! NILP (encoding))
415 Lisp_Object tail;
417 for (tail = Vcharset_ordered_list;
418 ! EQ (tail, Vcharset_non_preferred_head) && CONSP (tail);
419 score += 0x100, tail = XCDR (tail))
420 if (EQ (encoding, XCAR (tail)))
421 break;
423 else
425 Lisp_Object lang = Ffont_get (font_spec, QClang);
427 if (! NILP (lang)
428 && ! EQ (lang, Vcurrent_iso639_language)
429 && (! CONSP (Vcurrent_iso639_language)
430 || NILP (Fmemq (lang, Vcurrent_iso639_language))))
431 score |= 0x100;
434 if (RFONT_DEF_SCORE (rfont_def) != score)
436 RFONT_DEF_SET_SCORE (rfont_def, score);
437 score_changed = 1;
441 if (score_changed)
442 qsort (XVECTOR (vec)->contents, size, sizeof (Lisp_Object),
443 fontset_compare_rfontdef);
444 XSETCAR (font_group, make_number (charset_ordered_list_tick));
447 /* Return a font-group (actually a cons (-1 . FONT-GROUP-VECTOR)) for
448 character C in FONTSET. If C is -1, return a fallback font-group.
449 If C is not -1, the value may be Qt (FONTSET doesn't have a font
450 for C even in the fallback group), or 0 (a font for C may be found
451 only in the fallback group). */
453 static Lisp_Object
454 fontset_get_font_group (Lisp_Object fontset, int c)
456 Lisp_Object font_group;
457 Lisp_Object base_fontset;
458 int from = 0, to = MAX_CHAR, i;
460 xassert (! BASE_FONTSET_P (fontset));
461 if (c >= 0)
462 font_group = CHAR_TABLE_REF (fontset, c);
463 else
464 font_group = FONTSET_FALLBACK (fontset);
465 if (! NILP (font_group))
466 return font_group;
467 base_fontset = FONTSET_BASE (fontset);
468 if (NILP (base_fontset))
469 font_group = Qnil;
470 else if (c >= 0)
471 font_group = char_table_ref_and_range (base_fontset, c, &from, &to);
472 else
473 font_group = FONTSET_FALLBACK (base_fontset);
474 if (NILP (font_group))
476 font_group = make_number (0);
477 if (c >= 0)
478 char_table_set_range (fontset, from, to, font_group);
479 return font_group;
481 if (!VECTORP (font_group))
482 return font_group;
483 font_group = Fcopy_sequence (font_group);
484 for (i = 0; i < ASIZE (font_group); i++)
485 if (! NILP (AREF (font_group, i)))
487 Lisp_Object rfont_def;
489 RFONT_DEF_NEW (rfont_def, AREF (font_group, i));
490 /* Remember the original order. */
491 RFONT_DEF_SET_SCORE (rfont_def, i);
492 ASET (font_group, i, rfont_def);
494 font_group = Fcons (make_number (-1), font_group);
495 if (c >= 0)
496 char_table_set_range (fontset, from, to, font_group);
497 else
498 FONTSET_FALLBACK (fontset) = font_group;
499 return font_group;
502 /* Return RFONT-DEF (vector) in the realized fontset FONTSET for the
503 character C. If no font is found, return Qnil if there's a
504 possibility that the default fontset or the fallback font groups
505 have a proper font, and return Qt if not.
507 If a font is found but is not yet opened, open it (if FACE is not
508 NULL) or return Qnil (if FACE is NULL).
510 ID is a charset-id that must be preferred, or -1 meaning no
511 preference.
513 If FALLBACK is nonzero, search only fallback fonts. */
515 static Lisp_Object
516 fontset_find_font (Lisp_Object fontset, int c, struct face *face, int id, int fallback)
518 Lisp_Object vec, font_group;
519 int i, charset_matched = 0, found_index;
520 FRAME_PTR f = (FRAMEP (FONTSET_FRAME (fontset))
521 ? XFRAME (FONTSET_FRAME (fontset)) : XFRAME (selected_frame));
522 Lisp_Object rfont_def;
524 font_group = fontset_get_font_group (fontset, fallback ? -1 : c);
525 if (! CONSP (font_group))
526 return font_group;
527 vec = XCDR (font_group);
528 if (ASIZE (vec) == 0)
529 return Qnil;
531 if (ASIZE (vec) > 1)
533 if (XINT (XCAR (font_group)) != charset_ordered_list_tick)
534 /* We have just created the font-group,
535 or the charset priorities were changed. */
536 reorder_font_vector (font_group, face->ascii_face->font);
537 if (id >= 0)
538 /* Find a spec matching with the charset ID to try at
539 first. */
540 for (i = 0; i < ASIZE (vec); i++)
542 Lisp_Object repertory;
544 rfont_def = AREF (vec, i);
545 if (NILP (rfont_def))
546 break;
547 repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));
549 if (XINT (repertory) == id)
551 charset_matched = i;
552 break;
557 /* Find the first available font in the vector of RFONT-DEF. */
558 for (i = 0; i < ASIZE (vec); i++)
560 Lisp_Object font_def;
561 Lisp_Object font_entity, font_object;
563 found_index = i;
564 if (i == 0)
566 if (charset_matched > 0)
568 /* Try the element matching with the charset ID at first. */
569 found_index = charset_matched;
570 /* Make this negative so that we don't come here in the
571 next loop. */
572 charset_matched = - charset_matched;
573 /* We must try the first element in the next loop. */
574 i--;
577 else if (i == - charset_matched)
579 /* We have already tried this element and the followings
580 that have the same font specifications in the first
581 iteration. So, skip them all. */
582 rfont_def = AREF (vec, i);
583 font_def = RFONT_DEF_FONT_DEF (rfont_def);
584 for (; i + 1 < ASIZE (vec); i++)
586 rfont_def = AREF (vec, i + 1);
587 if (NILP (rfont_def))
588 break;
589 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
590 break;
592 continue;
595 rfont_def = AREF (vec, found_index);
596 if (NILP (rfont_def))
598 if (i < 0)
599 continue;
600 /* This is a sign of not to try the other fonts. */
601 return Qt;
603 if (INTEGERP (RFONT_DEF_FACE (rfont_def))
604 && XINT (RFONT_DEF_FACE (rfont_def)) < 0)
605 /* We couldn't open this font last time. */
606 continue;
608 font_object = RFONT_DEF_OBJECT (rfont_def);
609 if (NILP (font_object))
611 font_def = RFONT_DEF_FONT_DEF (rfont_def);
613 if (! face)
614 /* We have not yet opened the font. */
615 return Qnil;
616 /* Find a font best-matching with the spec without checking
617 the support of the character C. That checking is costly,
618 and even without the checking, the found font supports C
619 in high possibility. */
620 font_entity = font_find_for_lface (f, face->lface,
621 FONT_DEF_SPEC (font_def), -1);
622 if (NILP (font_entity))
624 /* Record that no font matches the spec. */
625 RFONT_DEF_SET_FACE (rfont_def, -1);
626 continue;
628 font_object = font_open_for_lface (f, font_entity, face->lface,
629 FONT_DEF_SPEC (font_def));
630 if (NILP (font_object))
632 /* Something strange happened, perhaps because of a
633 Font-backend problem. Too avoid crashing, record
634 that this spec is unusable. It may be better to find
635 another font of the same spec, but currently we don't
636 have such an API. */
637 RFONT_DEF_SET_FACE (rfont_def, -1);
638 continue;
640 RFONT_DEF_SET_OBJECT (rfont_def, font_object);
643 if (font_has_char (f, font_object, c))
644 goto found;
646 /* Find a font already opened, matching with the current spec,
647 and supporting C. */
648 font_def = RFONT_DEF_FONT_DEF (rfont_def);
649 for (; found_index + 1 < ASIZE (vec); found_index++)
651 rfont_def = AREF (vec, found_index + 1);
652 if (NILP (rfont_def))
653 break;
654 if (! EQ (RFONT_DEF_FONT_DEF (rfont_def), font_def))
655 break;
656 font_object = RFONT_DEF_OBJECT (rfont_def);
657 if (! NILP (font_object) && font_has_char (f, font_object, c))
659 found_index++;
660 goto found;
664 /* Find a font-entity with the current spec and supporting C. */
665 font_entity = font_find_for_lface (f, face->lface,
666 FONT_DEF_SPEC (font_def), c);
667 if (! NILP (font_entity))
669 /* We found a font. Open it and insert a new element for
670 that font in VEC. */
671 Lisp_Object new_vec;
672 int j;
674 font_object = font_open_for_lface (f, font_entity, face->lface,
675 Qnil);
676 if (NILP (font_object))
677 continue;
678 RFONT_DEF_NEW (rfont_def, font_def);
679 RFONT_DEF_SET_OBJECT (rfont_def, font_object);
680 RFONT_DEF_SET_SCORE (rfont_def, RFONT_DEF_SCORE (rfont_def));
681 new_vec = Fmake_vector (make_number (ASIZE (vec) + 1), Qnil);
682 found_index++;
683 for (j = 0; j < found_index; j++)
684 ASET (new_vec, j, AREF (vec, j));
685 ASET (new_vec, j, rfont_def);
686 for (j++; j < ASIZE (new_vec); j++)
687 ASET (new_vec, j, AREF (vec, j - 1));
688 XSETCDR (font_group, new_vec);
689 vec = new_vec;
690 goto found;
692 if (i >= 0)
693 i = found_index;
696 FONTSET_SET (fontset, make_number (c), make_number (0));
697 return Qnil;
699 found:
700 if (fallback && found_index > 0)
702 /* The order of fonts in the fallback font-group is not that
703 important, and it is better to move the found font to the
704 first of the group so that the next try will find it
705 quickly. */
706 for (i = found_index; i > 0; i--)
707 ASET (vec, i, AREF (vec, i - 1));
708 ASET (vec, 0, rfont_def);
710 return rfont_def;
714 static Lisp_Object
715 fontset_font (Lisp_Object fontset, int c, struct face *face, int id)
717 Lisp_Object rfont_def, default_rfont_def IF_LINT (= Qnil);
718 Lisp_Object base_fontset;
720 /* Try a font-group of FONTSET. */
721 FONT_DEFERRED_LOG ("current fontset: font for", make_number (c), Qnil);
722 rfont_def = fontset_find_font (fontset, c, face, id, 0);
723 if (VECTORP (rfont_def))
724 return rfont_def;
725 if (NILP (rfont_def))
726 FONTSET_SET (fontset, make_number (c), make_number (0));
728 /* Try a font-group of the default fontset. */
729 base_fontset = FONTSET_BASE (fontset);
730 if (! EQ (base_fontset, Vdefault_fontset))
732 if (NILP (FONTSET_DEFAULT (fontset)))
733 FONTSET_DEFAULT (fontset)
734 = make_fontset (FONTSET_FRAME (fontset), Qnil, Vdefault_fontset);
735 FONT_DEFERRED_LOG ("default fontset: font for", make_number (c), Qnil);
736 default_rfont_def
737 = fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 0);
738 if (VECTORP (default_rfont_def))
739 return default_rfont_def;
740 if (NILP (default_rfont_def))
741 FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c),
742 make_number (0));
745 /* Try a fallback font-group of FONTSET. */
746 if (! EQ (rfont_def, Qt))
748 FONT_DEFERRED_LOG ("current fallback: font for", make_number (c), Qnil);
749 rfont_def = fontset_find_font (fontset, c, face, id, 1);
750 if (VECTORP (rfont_def))
751 return rfont_def;
752 /* Remember that FONTSET has no font for C. */
753 FONTSET_SET (fontset, make_number (c), Qt);
756 /* Try a fallback font-group of the default fontset. */
757 if (! EQ (base_fontset, Vdefault_fontset)
758 && ! EQ (default_rfont_def, Qt))
760 FONT_DEFERRED_LOG ("default fallback: font for", make_number (c), Qnil);
761 rfont_def = fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 1);
762 if (VECTORP (rfont_def))
763 return rfont_def;
764 /* Remember that the default fontset has no font for C. */
765 FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c), Qt);
768 return Qnil;
771 /* Return a newly created fontset with NAME. If BASE is nil, make a
772 base fontset. Otherwise make a realized fontset whose base is
773 BASE. */
775 static Lisp_Object
776 make_fontset (Lisp_Object frame, Lisp_Object name, Lisp_Object base)
778 Lisp_Object fontset;
779 int size = ASIZE (Vfontset_table);
780 int id = next_fontset_id;
782 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
783 the next available fontset ID. So it is expected that this loop
784 terminates quickly. In addition, as the last element of
785 Vfontset_table is always nil, we don't have to check the range of
786 id. */
787 while (!NILP (AREF (Vfontset_table, id))) id++;
789 if (id + 1 == size)
790 Vfontset_table = larger_vector (Vfontset_table, size + 32, Qnil);
792 fontset = Fmake_char_table (Qfontset, Qnil);
794 FONTSET_ID (fontset) = make_number (id);
795 if (NILP (base))
797 FONTSET_NAME (fontset) = name;
799 else
801 FONTSET_NAME (fontset) = Qnil;
802 FONTSET_FRAME (fontset) = frame;
803 FONTSET_BASE (fontset) = base;
806 ASET (Vfontset_table, id, fontset);
807 next_fontset_id = id + 1;
808 return fontset;
812 /********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
814 /* Return the name of the fontset who has ID. */
816 Lisp_Object
817 fontset_name (int id)
819 Lisp_Object fontset;
821 fontset = FONTSET_FROM_ID (id);
822 return FONTSET_NAME (fontset);
826 /* Return the ASCII font name of the fontset who has ID. */
828 Lisp_Object
829 fontset_ascii (int id)
831 Lisp_Object fontset, elt;
833 fontset= FONTSET_FROM_ID (id);
834 elt = FONTSET_ASCII (fontset);
835 if (CONSP (elt))
836 elt = XCAR (elt);
837 return elt;
840 static void
841 free_realized_fontset (FRAME_PTR f, Lisp_Object fontset)
843 #if 0
844 Lisp_Object tail;
846 if (0)
847 for (tail = FONTSET_OBJLIST (fontset); CONSP (tail); tail = XCDR (tail))
849 xassert (FONT_OBJECT_P (XCAR (tail)));
850 font_close_object (f, XCAR (tail));
852 #endif
855 /* Free fontset of FACE defined on frame F. Called from
856 free_realized_face. */
858 void
859 free_face_fontset (FRAME_PTR f, struct face *face)
861 Lisp_Object fontset;
863 fontset = FONTSET_FROM_ID (face->fontset);
864 if (NILP (fontset))
865 return;
866 xassert (! BASE_FONTSET_P (fontset));
867 xassert (f == XFRAME (FONTSET_FRAME (fontset)));
868 free_realized_fontset (f, fontset);
869 ASET (Vfontset_table, face->fontset, Qnil);
870 if (face->fontset < next_fontset_id)
871 next_fontset_id = face->fontset;
872 if (! NILP (FONTSET_DEFAULT (fontset)))
874 int id = XINT (FONTSET_ID (FONTSET_DEFAULT (fontset)));
876 fontset = AREF (Vfontset_table, id);
877 xassert (!NILP (fontset) && ! BASE_FONTSET_P (fontset));
878 xassert (f == XFRAME (FONTSET_FRAME (fontset)));
879 free_realized_fontset (f, fontset);
880 ASET (Vfontset_table, id, Qnil);
881 if (id < next_fontset_id)
882 next_fontset_id = face->fontset;
884 face->fontset = -1;
888 #if 0
889 /* Return 1 if FACE is suitable for displaying character C.
890 Otherwise return 0. Called from the macro FACE_SUITABLE_FOR_CHAR_P
891 when C is not an ASCII character. */
894 face_suitable_for_char_p (struct face *face, int c)
896 Lisp_Object fontset, rfont_def;
898 fontset = FONTSET_FROM_ID (face->fontset);
899 rfont_def = fontset_font (fontset, c, NULL, -1);
900 return (VECTORP (rfont_def)
901 && INTEGERP (RFONT_DEF_FACE (rfont_def))
902 && face->id == XINT (RFONT_DEF_FACE (rfont_def)));
904 #endif
907 /* Return ID of face suitable for displaying character C on frame F.
908 FACE must be realized for ASCII characters in advance. Called from
909 the macro FACE_FOR_CHAR. */
912 face_for_char (FRAME_PTR f, struct face *face, int c, int pos, Lisp_Object object)
914 Lisp_Object fontset, rfont_def, charset;
915 int face_id;
916 int id;
918 /* If face->fontset is negative (that happens when no font is found
919 for face), just return face->ascii_face because we can't do
920 anything. Perhaps, we should fix the callers to assure
921 that face->fontset is always valid. */
922 if (ASCII_CHAR_P (c) || face->fontset < 0)
923 return face->ascii_face->id;
925 xassert (fontset_id_valid_p (face->fontset));
926 fontset = FONTSET_FROM_ID (face->fontset);
927 xassert (!BASE_FONTSET_P (fontset));
929 if (pos < 0)
931 id = -1;
932 charset = Qnil;
934 else
936 charset = Fget_char_property (make_number (pos), Qcharset, object);
937 if (CHARSETP (charset))
939 Lisp_Object val;
941 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
942 if (CONSP (val) && CHARSETP (XCDR (val)))
943 charset = XCDR (val);
944 id = XINT (CHARSET_SYMBOL_ID (charset));
946 else
947 id = -1;
950 rfont_def = fontset_font (fontset, c, face, id);
951 if (VECTORP (rfont_def))
953 if (INTEGERP (RFONT_DEF_FACE (rfont_def)))
954 face_id = XINT (RFONT_DEF_FACE (rfont_def));
955 else
957 Lisp_Object font_object;
959 font_object = RFONT_DEF_OBJECT (rfont_def);
960 face_id = face_for_font (f, font_object, face);
961 RFONT_DEF_SET_FACE (rfont_def, face_id);
964 else
966 if (INTEGERP (FONTSET_NOFONT_FACE (fontset)))
967 face_id = XINT (FONTSET_NOFONT_FACE (fontset));
968 else
970 face_id = face_for_font (f, Qnil, face);
971 FONTSET_NOFONT_FACE (fontset) = make_number (face_id);
974 xassert (face_id >= 0);
975 return face_id;
979 Lisp_Object
980 font_for_char (struct face *face, int c, int pos, Lisp_Object object)
982 Lisp_Object fontset, rfont_def, charset;
983 int id;
985 if (ASCII_CHAR_P (c))
987 Lisp_Object font_object;
989 XSETFONT (font_object, face->ascii_face->font);
990 return font_object;
993 xassert (fontset_id_valid_p (face->fontset));
994 fontset = FONTSET_FROM_ID (face->fontset);
995 xassert (!BASE_FONTSET_P (fontset));
996 if (pos < 0)
998 id = -1;
999 charset = Qnil;
1001 else
1003 charset = Fget_char_property (make_number (pos), Qcharset, object);
1004 if (CHARSETP (charset))
1006 Lisp_Object val;
1008 val = assq_no_quit (charset, Vfont_encoding_charset_alist);
1009 if (CONSP (val) && CHARSETP (XCDR (val)))
1010 charset = XCDR (val);
1011 id = XINT (CHARSET_SYMBOL_ID (charset));
1013 else
1014 id = -1;
1017 rfont_def = fontset_font (fontset, c, face, id);
1018 return (VECTORP (rfont_def)
1019 ? RFONT_DEF_OBJECT (rfont_def)
1020 : Qnil);
1024 /* Make a realized fontset for ASCII face FACE on frame F from the
1025 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
1026 default fontset as the base. Value is the id of the new fontset.
1027 Called from realize_x_face. */
1030 make_fontset_for_ascii_face (FRAME_PTR f, int base_fontset_id, struct face *face)
1032 Lisp_Object base_fontset, fontset, frame;
1034 XSETFRAME (frame, f);
1035 if (base_fontset_id >= 0)
1037 base_fontset = FONTSET_FROM_ID (base_fontset_id);
1038 if (!BASE_FONTSET_P (base_fontset))
1039 base_fontset = FONTSET_BASE (base_fontset);
1040 if (! BASE_FONTSET_P (base_fontset))
1041 abort ();
1043 else
1044 base_fontset = Vdefault_fontset;
1046 fontset = make_fontset (frame, Qnil, base_fontset);
1047 return XINT (FONTSET_ID (fontset));
1052 /* Cache data used by fontset_pattern_regexp. The car part is a
1053 pattern string containing at least one wild card, the cdr part is
1054 the corresponding regular expression. */
1055 static Lisp_Object Vcached_fontset_data;
1057 #define CACHED_FONTSET_NAME SSDATA (XCAR (Vcached_fontset_data))
1058 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
1060 /* If fontset name PATTERN contains any wild card, return regular
1061 expression corresponding to PATTERN. */
1063 static Lisp_Object
1064 fontset_pattern_regexp (Lisp_Object pattern)
1066 if (!strchr (SSDATA (pattern), '*')
1067 && !strchr (SSDATA (pattern), '?'))
1068 /* PATTERN does not contain any wild cards. */
1069 return Qnil;
1071 if (!CONSP (Vcached_fontset_data)
1072 || strcmp (SSDATA (pattern), CACHED_FONTSET_NAME))
1074 /* We must at first update the cached data. */
1075 unsigned char *regex, *p0, *p1;
1076 int ndashes = 0, nstars = 0, nescs = 0;
1078 for (p0 = SDATA (pattern); *p0; p0++)
1080 if (*p0 == '-')
1081 ndashes++;
1082 else if (*p0 == '*')
1083 nstars++;
1084 else if (*p0 == '['
1085 || *p0 == '.' || *p0 == '\\'
1086 || *p0 == '+' || *p0 == '^'
1087 || *p0 == '$')
1088 nescs++;
1091 /* If PATTERN is not full XLFD we convert "*" to ".*". Otherwise
1092 we convert "*" to "[^-]*" which is much faster in regular
1093 expression matching. */
1094 if (ndashes < 14)
1095 p1 = regex = (unsigned char *) alloca (SBYTES (pattern) + 2 * nstars + 2 * nescs + 1);
1096 else
1097 p1 = regex = (unsigned char *) alloca (SBYTES (pattern) + 5 * nstars + 2 * nescs + 1);
1099 *p1++ = '^';
1100 for (p0 = SDATA (pattern); *p0; p0++)
1102 if (*p0 == '*')
1104 if (ndashes < 14)
1105 *p1++ = '.';
1106 else
1107 *p1++ = '[', *p1++ = '^', *p1++ = '-', *p1++ = ']';
1108 *p1++ = '*';
1110 else if (*p0 == '?')
1111 *p1++ = '.';
1112 else if (*p0 == '['
1113 || *p0 == '.' || *p0 == '\\'
1114 || *p0 == '+' || *p0 == '^'
1115 || *p0 == '$')
1116 *p1++ = '\\', *p1++ = *p0;
1117 else
1118 *p1++ = *p0;
1120 *p1++ = '$';
1121 *p1++ = 0;
1123 Vcached_fontset_data = Fcons (build_string (SSDATA (pattern)),
1124 build_string ((char *) regex));
1127 return CACHED_FONTSET_REGEX;
1130 /* Return ID of the base fontset named NAME. If there's no such
1131 fontset, return -1. NAME_PATTERN specifies how to treat NAME as this:
1132 0: pattern containing '*' and '?' as wildcards
1133 1: regular expression
1134 2: literal fontset name
1138 fs_query_fontset (Lisp_Object name, int name_pattern)
1140 Lisp_Object tem;
1141 int i;
1143 name = Fdowncase (name);
1144 if (name_pattern != 1)
1146 tem = Frassoc (name, Vfontset_alias_alist);
1147 if (NILP (tem))
1148 tem = Fassoc (name, Vfontset_alias_alist);
1149 if (CONSP (tem) && STRINGP (XCAR (tem)))
1150 name = XCAR (tem);
1151 else if (name_pattern == 0)
1153 tem = fontset_pattern_regexp (name);
1154 if (STRINGP (tem))
1156 name = tem;
1157 name_pattern = 1;
1162 for (i = 0; i < ASIZE (Vfontset_table); i++)
1164 Lisp_Object fontset, this_name;
1166 fontset = FONTSET_FROM_ID (i);
1167 if (NILP (fontset)
1168 || !BASE_FONTSET_P (fontset))
1169 continue;
1171 this_name = FONTSET_NAME (fontset);
1172 if (name_pattern == 1
1173 ? fast_string_match_ignore_case (name, this_name) >= 0
1174 : !xstrcasecmp (SSDATA (name), SSDATA (this_name)))
1175 return i;
1177 return -1;
1181 DEFUN ("query-fontset", Fquery_fontset, Squery_fontset, 1, 2, 0,
1182 doc: /* Return the name of a fontset that matches PATTERN.
1183 The value is nil if there is no matching fontset.
1184 PATTERN can contain `*' or `?' as a wildcard
1185 just as X font name matching algorithm allows.
1186 If REGEXPP is non-nil, PATTERN is a regular expression. */)
1187 (Lisp_Object pattern, Lisp_Object regexpp)
1189 Lisp_Object fontset;
1190 int id;
1192 (*check_window_system_func) ();
1194 CHECK_STRING (pattern);
1196 if (SCHARS (pattern) == 0)
1197 return Qnil;
1199 id = fs_query_fontset (pattern, !NILP (regexpp));
1200 if (id < 0)
1201 return Qnil;
1203 fontset = FONTSET_FROM_ID (id);
1204 return FONTSET_NAME (fontset);
1207 /* Return a list of base fontset names matching PATTERN on frame F. */
1209 Lisp_Object
1210 list_fontsets (FRAME_PTR f, Lisp_Object pattern, int size)
1212 Lisp_Object frame, regexp, val;
1213 int id;
1215 XSETFRAME (frame, f);
1217 regexp = fontset_pattern_regexp (pattern);
1218 val = Qnil;
1220 for (id = 0; id < ASIZE (Vfontset_table); id++)
1222 Lisp_Object fontset, name;
1224 fontset = FONTSET_FROM_ID (id);
1225 if (NILP (fontset)
1226 || !BASE_FONTSET_P (fontset)
1227 || !EQ (frame, FONTSET_FRAME (fontset)))
1228 continue;
1229 name = FONTSET_NAME (fontset);
1231 if (STRINGP (regexp)
1232 ? (fast_string_match (regexp, name) < 0)
1233 : strcmp (SSDATA (pattern), SSDATA (name)))
1234 continue;
1236 val = Fcons (Fcopy_sequence (FONTSET_NAME (fontset)), val);
1239 return val;
1243 /* Free all realized fontsets whose base fontset is BASE. */
1245 static void
1246 free_realized_fontsets (Lisp_Object base)
1248 int id;
1250 #if 0
1251 /* For the moment, this doesn't work because free_realized_face
1252 doesn't remove FACE from a cache. Until we find a solution, we
1253 suppress this code, and simply use Fclear_face_cache even though
1254 that is not efficient. */
1255 BLOCK_INPUT;
1256 for (id = 0; id < ASIZE (Vfontset_table); id++)
1258 Lisp_Object this = AREF (Vfontset_table, id);
1260 if (EQ (FONTSET_BASE (this), base))
1262 Lisp_Object tail;
1264 for (tail = FONTSET_FACE_ALIST (this); CONSP (tail);
1265 tail = XCDR (tail))
1267 FRAME_PTR f = XFRAME (FONTSET_FRAME (this));
1268 int face_id = XINT (XCDR (XCAR (tail)));
1269 struct face *face = FACE_FROM_ID (f, face_id);
1271 /* Face THIS itself is also freed by the following call. */
1272 free_realized_face (f, face);
1276 UNBLOCK_INPUT;
1277 #else /* not 0 */
1278 /* But, we don't have to call Fclear_face_cache if no fontset has
1279 been realized from BASE. */
1280 for (id = 0; id < ASIZE (Vfontset_table); id++)
1282 Lisp_Object this = AREF (Vfontset_table, id);
1284 if (CHAR_TABLE_P (this) && EQ (FONTSET_BASE (this), base))
1286 Fclear_face_cache (Qt);
1287 break;
1290 #endif /* not 0 */
1294 /* Check validity of NAME as a fontset name and return the
1295 corresponding fontset. If not valid, signal an error.
1297 If NAME is t, return Vdefault_fontset. If NAME is nil, return the
1298 fontset of *FRAME.
1300 Set *FRAME to the actual frame. */
1302 static Lisp_Object
1303 check_fontset_name (Lisp_Object name, Lisp_Object *frame)
1305 int id;
1307 if (NILP (*frame))
1308 *frame = selected_frame;
1309 CHECK_LIVE_FRAME (*frame);
1311 if (EQ (name, Qt))
1312 return Vdefault_fontset;
1313 if (NILP (name))
1315 id = FRAME_FONTSET (XFRAME (*frame));
1317 else
1319 CHECK_STRING (name);
1320 /* First try NAME as literal. */
1321 id = fs_query_fontset (name, 2);
1322 if (id < 0)
1323 /* For backward compatibility, try again NAME as pattern. */
1324 id = fs_query_fontset (name, 0);
1325 if (id < 0)
1326 error ("Fontset `%s' does not exist", SDATA (name));
1328 return FONTSET_FROM_ID (id);
1331 static void
1332 accumulate_script_ranges (Lisp_Object arg, Lisp_Object range, Lisp_Object val)
1334 if (EQ (XCAR (arg), val))
1336 if (CONSP (range))
1337 XSETCDR (arg, Fcons (Fcons (XCAR (range), XCDR (range)), XCDR (arg)));
1338 else
1339 XSETCDR (arg, Fcons (Fcons (range, range), XCDR (arg)));
1344 /* Callback function for map_charset_chars in Fset_fontset_font.
1345 ARG is a vector [ FONTSET FONT_DEF ADD ASCII SCRIPT_RANGE_LIST ].
1347 In FONTSET, set FONT_DEF in a fashion specified by ADD for
1348 characters in RANGE and ranges in SCRIPT_RANGE_LIST before RANGE.
1349 The consumed ranges are popped up from SCRIPT_RANGE_LIST, and the
1350 new SCRIPT_RANGE_LIST is stored in ARG.
1352 If ASCII is nil, don't set FONT_DEF for ASCII characters. It is
1353 assured that SCRIPT_RANGE_LIST doesn't contain ASCII in that
1354 case. */
1356 static void
1357 set_fontset_font (Lisp_Object arg, Lisp_Object range)
1359 Lisp_Object fontset, font_def, add, ascii, script_range_list;
1360 int from = XINT (XCAR (range)), to = XINT (XCDR (range));
1362 fontset = AREF (arg, 0);
1363 font_def = AREF (arg, 1);
1364 add = AREF (arg, 2);
1365 ascii = AREF (arg, 3);
1366 script_range_list = AREF (arg, 4);
1368 if (NILP (ascii) && from < 0x80)
1370 if (to < 0x80)
1371 return;
1372 from = 0x80;
1373 range = Fcons (make_number (0x80), XCDR (range));
1376 #define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
1377 #define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
1378 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
1380 for (; CONSP (script_range_list) && SCRIPT_TO < from; POP_SCRIPT_RANGE ())
1381 FONTSET_ADD (fontset, XCAR (script_range_list), font_def, add);
1382 if (CONSP (script_range_list))
1384 if (SCRIPT_FROM < from)
1385 range = Fcons (make_number (SCRIPT_FROM), XCDR (range));
1386 while (CONSP (script_range_list) && SCRIPT_TO <= to)
1387 POP_SCRIPT_RANGE ();
1388 if (CONSP (script_range_list) && SCRIPT_FROM <= to)
1389 XSETCAR (XCAR (script_range_list), make_number (to + 1));
1392 FONTSET_ADD (fontset, range, font_def, add);
1393 ASET (arg, 4, script_range_list);
1396 static void update_auto_fontset_alist (Lisp_Object, Lisp_Object);
1399 DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 5, 0,
1400 doc: /*
1401 Modify fontset NAME to use FONT-SPEC for TARGET characters.
1403 NAME is a fontset name string, nil for the fontset of FRAME, or t for
1404 the default fontset.
1406 TARGET may be a cons; (FROM . TO), where FROM and TO are characters.
1407 In that case, use FONT-SPEC for all characters in the range FROM and
1408 TO (inclusive).
1410 TARGET may be a script name symbol. In that case, use FONT-SPEC for
1411 all characters that belong to the script.
1413 TARGET may be a charset. In that case, use FONT-SPEC for all
1414 characters in the charset.
1416 TARGET may be nil. In that case, use FONT-SPEC for any characters for
1417 that no FONT-SPEC is specified.
1419 FONT-SPEC may one of these:
1420 * A font-spec object made by the function `font-spec' (which see).
1421 * A cons (FAMILY . REGISTRY), where FAMILY is a font family name and
1422 REGISTRY is a font registry name. FAMILY may contain foundry
1423 name, and REGISTRY may contain encoding name.
1424 * A font name string.
1425 * nil, which explicitly specifies that there's no font for TARGET.
1427 Optional 4th argument FRAME is a frame or nil for the selected frame
1428 that is concerned in the case that NAME is nil.
1430 Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
1431 to the font specifications for TARGET previously set. If it is
1432 `prepend', FONT-SPEC is prepended. If it is `append', FONT-SPEC is
1433 appended. By default, FONT-SPEC overrides the previous settings. */)
1434 (Lisp_Object name, Lisp_Object target, Lisp_Object font_spec, Lisp_Object frame, Lisp_Object add)
1436 Lisp_Object fontset;
1437 Lisp_Object font_def, registry, family;
1438 Lisp_Object range_list;
1439 struct charset *charset = NULL;
1440 Lisp_Object fontname;
1441 int ascii_changed = 0;
1443 fontset = check_fontset_name (name, &frame);
1445 fontname = Qnil;
1446 if (CONSP (font_spec))
1448 Lisp_Object spec = Ffont_spec (0, NULL);
1450 font_parse_family_registry (XCAR (font_spec), XCDR (font_spec), spec);
1451 font_spec = spec;
1452 fontname = Ffont_xlfd_name (font_spec, Qnil);
1454 else if (STRINGP (font_spec))
1456 Lisp_Object args[2];
1458 fontname = font_spec;
1459 args[0] = QCname;
1460 args[1] = font_spec;
1461 font_spec = Ffont_spec (2, args);
1463 else if (FONT_SPEC_P (font_spec))
1464 fontname = Ffont_xlfd_name (font_spec, Qnil);
1465 else if (! NILP (font_spec))
1466 Fsignal (Qfont, list2 (build_string ("Invalid font-spec"), font_spec));
1468 if (! NILP (font_spec))
1470 Lisp_Object encoding, repertory;
1472 family = AREF (font_spec, FONT_FAMILY_INDEX);
1473 if (! NILP (family) )
1474 family = SYMBOL_NAME (family);
1475 registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1476 if (! NILP (registry))
1477 registry = Fdowncase (SYMBOL_NAME (registry));
1478 encoding = find_font_encoding (concat3 (family, build_string ("-"),
1479 registry));
1480 if (NILP (encoding))
1481 encoding = Qascii;
1483 if (SYMBOLP (encoding))
1485 CHECK_CHARSET (encoding);
1486 encoding = repertory = CHARSET_SYMBOL_ID (encoding);
1488 else
1490 repertory = XCDR (encoding);
1491 encoding = XCAR (encoding);
1492 CHECK_CHARSET (encoding);
1493 encoding = CHARSET_SYMBOL_ID (encoding);
1494 if (! NILP (repertory) && SYMBOLP (repertory))
1496 CHECK_CHARSET (repertory);
1497 repertory = CHARSET_SYMBOL_ID (repertory);
1500 FONT_DEF_NEW (font_def, font_spec, encoding, repertory);
1502 else
1503 font_def = Qnil;
1505 if (CHARACTERP (target))
1507 if (XFASTINT (target) < 0x80)
1508 error ("Can't set a font for partial ASCII range");
1509 range_list = Fcons (Fcons (target, target), Qnil);
1511 else if (CONSP (target))
1513 Lisp_Object from, to;
1515 from = Fcar (target);
1516 to = Fcdr (target);
1517 CHECK_CHARACTER (from);
1518 CHECK_CHARACTER (to);
1519 if (XFASTINT (from) < 0x80)
1521 if (XFASTINT (from) != 0 || XFASTINT (to) < 0x7F)
1522 error ("Can't set a font for partial ASCII range");
1523 ascii_changed = 1;
1525 range_list = Fcons (target, Qnil);
1527 else if (SYMBOLP (target) && !NILP (target))
1529 Lisp_Object script_list;
1530 Lisp_Object val;
1532 range_list = Qnil;
1533 script_list = XCHAR_TABLE (Vchar_script_table)->extras[0];
1534 if (! NILP (Fmemq (target, script_list)))
1536 if (EQ (target, Qlatin))
1537 ascii_changed = 1;
1538 val = Fcons (target, Qnil);
1539 map_char_table (accumulate_script_ranges, Qnil, Vchar_script_table,
1540 val);
1541 range_list = Fnreverse (XCDR (val));
1543 if (CHARSETP (target))
1545 CHECK_CHARSET_GET_CHARSET (target, charset);
1546 if (charset->ascii_compatible_p)
1547 ascii_changed = 1;
1549 else if (NILP (range_list))
1550 error ("Invalid script or charset name: %s",
1551 SDATA (SYMBOL_NAME (target)));
1553 else if (NILP (target))
1554 range_list = Fcons (Qnil, Qnil);
1555 else
1556 error ("Invalid target for setting a font");
1558 if (ascii_changed)
1560 Lisp_Object val;
1562 if (NILP (font_spec))
1563 error ("Can't set ASCII font to nil");
1564 val = CHAR_TABLE_REF (fontset, 0);
1565 if (! NILP (val) && EQ (add, Qappend))
1566 /* We are going to change just an additional font for ASCII. */
1567 ascii_changed = 0;
1570 if (charset)
1572 Lisp_Object arg;
1574 arg = Fmake_vector (make_number (5), Qnil);
1575 ASET (arg, 0, fontset);
1576 ASET (arg, 1, font_def);
1577 ASET (arg, 2, add);
1578 ASET (arg, 3, ascii_changed ? Qt : Qnil);
1579 ASET (arg, 4, range_list);
1581 map_charset_chars (set_fontset_font, Qnil, arg, charset,
1582 CHARSET_MIN_CODE (charset),
1583 CHARSET_MAX_CODE (charset));
1584 range_list = AREF (arg, 4);
1586 for (; CONSP (range_list); range_list = XCDR (range_list))
1587 FONTSET_ADD (fontset, XCAR (range_list), font_def, add);
1589 if (ascii_changed)
1591 Lisp_Object tail, fr, alist;
1592 int fontset_id = XINT (FONTSET_ID (fontset));
1594 FONTSET_ASCII (fontset) = fontname;
1595 name = FONTSET_NAME (fontset);
1596 FOR_EACH_FRAME (tail, fr)
1598 FRAME_PTR f = XFRAME (fr);
1599 Lisp_Object font_object;
1600 struct face *face;
1602 if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f))
1603 continue;
1604 if (fontset_id != FRAME_FONTSET (f))
1605 continue;
1606 face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
1607 if (face)
1608 font_object = font_load_for_lface (f, face->lface, font_spec);
1609 else
1610 font_object = font_open_by_spec (f, font_spec);
1611 if (! NILP (font_object))
1613 update_auto_fontset_alist (font_object, fontset);
1614 alist = Fcons (Fcons (Qfont, Fcons (name, font_object)), Qnil);
1615 Fmodify_frame_parameters (fr, alist);
1620 /* Free all realized fontsets whose base is FONTSET. This way, the
1621 specified character(s) are surely redisplayed by a correct
1622 font. */
1623 free_realized_fontsets (fontset);
1625 return Qnil;
1629 DEFUN ("new-fontset", Fnew_fontset, Snew_fontset, 2, 2, 0,
1630 doc: /* Create a new fontset NAME from font information in FONTLIST.
1632 FONTLIST is an alist of scripts vs the corresponding font specification list.
1633 Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where a
1634 character of SCRIPT is displayed by a font that matches one of
1635 FONT-SPEC.
1637 SCRIPT is a symbol that appears in the first extra slot of the
1638 char-table `char-script-table'.
1640 FONT-SPEC is a vector, a cons, or a string. See the documentation of
1641 `set-fontset-font' for the meaning. */)
1642 (Lisp_Object name, Lisp_Object fontlist)
1644 Lisp_Object fontset;
1645 int id;
1647 CHECK_STRING (name);
1648 CHECK_LIST (fontlist);
1650 name = Fdowncase (name);
1651 id = fs_query_fontset (name, 0);
1652 if (id < 0)
1654 Lisp_Object font_spec = Ffont_spec (0, NULL);
1655 Lisp_Object short_name;
1656 char xlfd[256];
1657 int len;
1659 if (font_parse_xlfd (SSDATA (name), font_spec) < 0)
1660 error ("Fontset name must be in XLFD format");
1661 short_name = AREF (font_spec, FONT_REGISTRY_INDEX);
1662 if (strncmp (SSDATA (SYMBOL_NAME (short_name)), "fontset-", 8)
1663 || SBYTES (SYMBOL_NAME (short_name)) < 9)
1664 error ("Registry field of fontset name must be \"fontset-*\"");
1665 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (short_name)),
1666 Vfontset_alias_alist);
1667 ASET (font_spec, FONT_REGISTRY_INDEX, Qiso8859_1);
1668 fontset = make_fontset (Qnil, name, Qnil);
1669 len = font_unparse_xlfd (font_spec, 0, xlfd, 256);
1670 if (len < 0)
1671 error ("Invalid fontset name (perhaps too long): %s", SDATA (name));
1672 FONTSET_ASCII (fontset) = make_unibyte_string (xlfd, len);
1674 else
1676 fontset = FONTSET_FROM_ID (id);
1677 free_realized_fontsets (fontset);
1678 Fset_char_table_range (fontset, Qt, Qnil);
1681 for (; ! NILP (fontlist); fontlist = Fcdr (fontlist))
1683 Lisp_Object elt, script;
1685 elt = Fcar (fontlist);
1686 script = Fcar (elt);
1687 elt = Fcdr (elt);
1688 if (CONSP (elt) && (NILP (XCDR (elt)) || CONSP (XCDR (elt))))
1689 for (; CONSP (elt); elt = XCDR (elt))
1690 Fset_fontset_font (name, script, XCAR (elt), Qnil, Qappend);
1691 else
1692 Fset_fontset_font (name, script, elt, Qnil, Qappend);
1694 return name;
1698 /* Alist of automatically created fontsets. Each element is a cons
1699 (FONT-SPEC . FONTSET-ID). */
1700 static Lisp_Object auto_fontset_alist;
1702 /* Number of automatically created fontsets. */
1703 static printmax_t num_auto_fontsets;
1705 /* Return a fontset synthesized from FONT-OBJECT. This is called from
1706 x_new_font when FONT-OBJECT is used for the default ASCII font of a
1707 frame, and the returned fontset is used for the default fontset of
1708 that frame. The fontset specifies a font of the same registry as
1709 FONT-OBJECT for all characters in the repertory of the registry
1710 (see Vfont_encoding_alist). If the repertory is not known, the
1711 fontset specifies the font for all Latin characters assuming that a
1712 user intends to use FONT-OBJECT for Latin characters. */
1715 fontset_from_font (Lisp_Object font_object)
1717 Lisp_Object font_name = font_get_name (font_object);
1718 Lisp_Object font_spec = copy_font_spec (font_object);
1719 Lisp_Object registry = AREF (font_spec, FONT_REGISTRY_INDEX);
1720 Lisp_Object fontset_spec, alias, name, fontset;
1721 Lisp_Object val;
1723 val = assoc_no_quit (font_spec, auto_fontset_alist);
1724 if (CONSP (val))
1725 return XINT (FONTSET_ID (XCDR (val)));
1726 if (num_auto_fontsets++ == 0)
1727 alias = intern ("fontset-startup");
1728 else
1730 char temp[sizeof "fontset-auto" + INT_STRLEN_BOUND (printmax_t)];
1732 sprintf (temp, "fontset-auto%"pMd, num_auto_fontsets - 1);
1733 alias = intern (temp);
1735 fontset_spec = copy_font_spec (font_spec);
1736 ASET (fontset_spec, FONT_REGISTRY_INDEX, alias);
1737 name = Ffont_xlfd_name (fontset_spec, Qnil);
1738 if (NILP (name))
1739 abort ();
1740 fontset = make_fontset (Qnil, name, Qnil);
1741 Vfontset_alias_alist = Fcons (Fcons (name, SYMBOL_NAME (alias)),
1742 Vfontset_alias_alist);
1743 alias = Fdowncase (AREF (font_object, FONT_NAME_INDEX));
1744 Vfontset_alias_alist = Fcons (Fcons (name, alias), Vfontset_alias_alist);
1745 auto_fontset_alist = Fcons (Fcons (font_spec, fontset), auto_fontset_alist);
1746 font_spec = Ffont_spec (0, NULL);
1747 ASET (font_spec, FONT_REGISTRY_INDEX, registry);
1749 Lisp_Object target = find_font_encoding (SYMBOL_NAME (registry));
1751 if (CONSP (target))
1752 target = XCDR (target);
1753 if (! CHARSETP (target))
1754 target = Qlatin;
1755 Fset_fontset_font (name, target, font_spec, Qnil, Qnil);
1756 Fset_fontset_font (name, Qnil, font_spec, Qnil, Qnil);
1759 FONTSET_ASCII (fontset) = font_name;
1761 return XINT (FONTSET_ID (fontset));
1765 /* Update auto_fontset_alist for FONTSET. When an ASCII font of
1766 FONTSET is changed, we delete an entry of FONTSET if any from
1767 auto_fontset_alist so that FONTSET is not re-used by
1768 fontset_from_font. */
1770 static void
1771 update_auto_fontset_alist (Lisp_Object font_object, Lisp_Object fontset)
1773 Lisp_Object prev, tail;
1775 for (prev = Qnil, tail = auto_fontset_alist; CONSP (tail);
1776 prev = tail, tail = XCDR (tail))
1777 if (EQ (fontset, XCDR (XCAR (tail))))
1779 if (NILP (prev))
1780 auto_fontset_alist = XCDR (tail);
1781 else
1782 XSETCDR (prev, XCDR (tail));
1783 break;
1788 /* Return a cons (FONT-OBJECT . GLYPH-CODE).
1789 FONT-OBJECT is the font for the character at POSITION in the current
1790 buffer. This is computed from all the text properties and overlays
1791 that apply to POSITION. POSITION may be nil, in which case,
1792 FONT-SPEC is the font for displaying the character CH with the
1793 default face.
1795 GLYPH-CODE is the glyph code in the font to use for the character.
1797 If the 2nd optional arg CH is non-nil, it is a character to check
1798 the font instead of the character at POSITION.
1800 It returns nil in the following cases:
1802 (1) The window system doesn't have a font for the character (thus
1803 it is displayed by an empty box).
1805 (2) The character code is invalid.
1807 (3) If POSITION is not nil, and the current buffer is not displayed
1808 in any window.
1810 In addition, the returned font name may not take into account of
1811 such redisplay engine hooks as what used in jit-lock-mode if
1812 POSITION is currently not visible. */
1815 DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
1816 doc: /* For internal use only. */)
1817 (Lisp_Object position, Lisp_Object ch)
1819 EMACS_INT pos, pos_byte, dummy;
1820 int face_id;
1821 int c;
1822 struct frame *f;
1823 struct face *face;
1825 if (NILP (position))
1827 CHECK_CHARACTER (ch);
1828 c = XINT (ch);
1829 f = XFRAME (selected_frame);
1830 face_id = lookup_basic_face (f, DEFAULT_FACE_ID);
1831 pos = -1;
1833 else
1835 Lisp_Object window;
1836 struct window *w;
1838 CHECK_NUMBER_COERCE_MARKER (position);
1839 pos = XINT (position);
1840 if (pos < BEGV || pos >= ZV)
1841 args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
1842 pos_byte = CHAR_TO_BYTE (pos);
1843 if (NILP (ch))
1844 c = FETCH_CHAR (pos_byte);
1845 else
1847 CHECK_NATNUM (ch);
1848 c = XINT (ch);
1850 window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
1851 if (NILP (window))
1852 return Qnil;
1853 w = XWINDOW (window);
1854 f = XFRAME (w->frame);
1855 face_id = face_at_buffer_position (w, pos, -1, -1, &dummy,
1856 pos + 100, 0, -1);
1858 if (! CHAR_VALID_P (c))
1859 return Qnil;
1860 face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
1861 face = FACE_FROM_ID (f, face_id);
1862 if (face->font)
1864 unsigned code = face->font->driver->encode_char (face->font, c);
1865 Lisp_Object font_object;
1867 if (code == FONT_INVALID_CODE)
1868 return Qnil;
1869 XSETFONT (font_object, face->font);
1870 return Fcons (font_object, INTEGER_TO_CONS (code));
1872 return Qnil;
1876 DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
1877 doc: /* Return information about a fontset FONTSET on frame FRAME.
1879 FONTSET is a fontset name string, nil for the fontset of FRAME, or t
1880 for the default fontset. FRAME nil means the selected frame.
1882 The value is a char-table whose elements have this form:
1884 ((FONT OPENED-FONT ...) ...)
1886 FONT is a name of font specified for a range of characters.
1888 OPENED-FONT is a name of a font actually opened.
1890 The char-table has one extra slot. If FONTSET is not the default
1891 fontset, the value the extra slot is a char-table containing the
1892 information about the derived fonts from the default fontset. The
1893 format is the same as above. */)
1894 (Lisp_Object fontset, Lisp_Object frame)
1896 Lisp_Object *realized[2], fontsets[2], tables[2];
1897 Lisp_Object val, elt;
1898 int c, i, j, k;
1900 (*check_window_system_func) ();
1902 fontset = check_fontset_name (fontset, &frame);
1904 /* Recode fontsets realized on FRAME from the base fontset FONTSET
1905 in the table `realized'. */
1906 realized[0] = (Lisp_Object *) alloca (sizeof (Lisp_Object)
1907 * ASIZE (Vfontset_table));
1908 for (i = j = 0; i < ASIZE (Vfontset_table); i++)
1910 elt = FONTSET_FROM_ID (i);
1911 if (!NILP (elt)
1912 && EQ (FONTSET_BASE (elt), fontset)
1913 && EQ (FONTSET_FRAME (elt), frame))
1914 realized[0][j++] = elt;
1916 realized[0][j] = Qnil;
1918 realized[1] = (Lisp_Object *) alloca (sizeof (Lisp_Object)
1919 * ASIZE (Vfontset_table));
1920 for (i = j = 0; ! NILP (realized[0][i]); i++)
1922 elt = FONTSET_DEFAULT (realized[0][i]);
1923 if (! NILP (elt))
1924 realized[1][j++] = elt;
1926 realized[1][j] = Qnil;
1928 tables[0] = Fmake_char_table (Qfontset_info, Qnil);
1929 fontsets[0] = fontset;
1930 if (!EQ (fontset, Vdefault_fontset))
1932 tables[1] = Fmake_char_table (Qnil, Qnil);
1933 XCHAR_TABLE (tables[0])->extras[0] = tables[1];
1934 fontsets[1] = Vdefault_fontset;
1937 /* Accumulate information of the fontset in TABLE. The format of
1938 each element is ((FONT-SPEC OPENED-FONT ...) ...). */
1939 for (k = 0; k <= 1; k++)
1941 for (c = 0; c <= MAX_CHAR; )
1943 int from = c, to = MAX_5_BYTE_CHAR;
1945 if (c <= MAX_5_BYTE_CHAR)
1947 val = char_table_ref_and_range (fontsets[k], c, &from, &to);
1949 else
1951 val = FONTSET_FALLBACK (fontsets[k]);
1952 to = MAX_CHAR;
1954 if (VECTORP (val))
1956 Lisp_Object alist;
1958 /* At first, set ALIST to ((FONT-SPEC) ...). */
1959 for (alist = Qnil, i = 0; i < ASIZE (val); i++)
1960 if (! NILP (AREF (val, i)))
1961 alist = Fcons (Fcons (FONT_DEF_SPEC (AREF (val, i)), Qnil),
1962 alist);
1963 alist = Fnreverse (alist);
1965 /* Then store opened font names to cdr of each elements. */
1966 for (i = 0; ! NILP (realized[k][i]); i++)
1968 if (c <= MAX_5_BYTE_CHAR)
1969 val = FONTSET_REF (realized[k][i], c);
1970 else
1971 val = FONTSET_FALLBACK (realized[k][i]);
1972 if (! CONSP (val) || ! VECTORP (XCDR (val)))
1973 continue;
1974 /* VAL: (int . [[FACE-ID FONT-DEF FONT-OBJECT int] ... ]) */
1975 val = XCDR (val);
1976 for (j = 0; j < ASIZE (val); j++)
1978 elt = AREF (val, j);
1979 if (FONT_OBJECT_P (RFONT_DEF_OBJECT (elt)))
1981 Lisp_Object font_object = RFONT_DEF_OBJECT (elt);
1982 Lisp_Object slot, name;
1984 slot = Fassq (RFONT_DEF_SPEC (elt), alist);
1985 name = AREF (font_object, FONT_NAME_INDEX);
1986 if (NILP (Fmember (name, XCDR (slot))))
1987 nconc2 (slot, Fcons (name, Qnil));
1992 /* Store ALIST in TBL for characters C..TO. */
1993 if (c <= MAX_5_BYTE_CHAR)
1994 char_table_set_range (tables[k], c, to, alist);
1995 else
1996 XCHAR_TABLE (tables[k])->defalt = alist;
1998 /* At last, change each elements to font names. */
1999 for (; CONSP (alist); alist = XCDR (alist))
2001 elt = XCAR (alist);
2002 XSETCAR (elt, Ffont_xlfd_name (XCAR (elt), Qnil));
2005 c = to + 1;
2007 if (EQ (fontset, Vdefault_fontset))
2008 break;
2011 return tables[0];
2015 DEFUN ("fontset-font", Ffontset_font, Sfontset_font, 2, 3, 0,
2016 doc: /* Return a font name pattern for character CH in fontset NAME.
2017 If NAME is t, find a pattern in the default fontset.
2018 If NAME is nil, find a pattern in the fontset of the selected frame.
2020 The value has the form (FAMILY . REGISTRY), where FAMILY is a font
2021 family name and REGISTRY is a font registry name. This is actually
2022 the first font name pattern for CH in the fontset or in the default
2023 fontset.
2025 If the 2nd optional arg ALL is non-nil, return a list of all font name
2026 patterns. */)
2027 (Lisp_Object name, Lisp_Object ch, Lisp_Object all)
2029 int c;
2030 Lisp_Object fontset, elt, list, repertory, val;
2031 int i, j;
2032 Lisp_Object frame;
2034 frame = Qnil;
2035 fontset = check_fontset_name (name, &frame);
2037 CHECK_CHARACTER (ch);
2038 c = XINT (ch);
2039 list = Qnil;
2040 while (1)
2042 for (i = 0, elt = FONTSET_REF (fontset, c); i < 2;
2043 i++, elt = FONTSET_FALLBACK (fontset))
2044 if (VECTORP (elt))
2045 for (j = 0; j < ASIZE (elt); j++)
2047 Lisp_Object family, registry;
2049 val = AREF (elt, j);
2050 if (NILP (val))
2051 return Qnil;
2052 repertory = AREF (val, 1);
2053 if (INTEGERP (repertory))
2055 struct charset *charset = CHARSET_FROM_ID (XINT (repertory));
2057 if (! CHAR_CHARSET_P (c, charset))
2058 continue;
2060 else if (CHAR_TABLE_P (repertory))
2062 if (NILP (CHAR_TABLE_REF (repertory, c)))
2063 continue;
2065 val = AREF (val, 0);
2066 /* VAL is a FONT-SPEC */
2067 family = AREF (val, FONT_FAMILY_INDEX);
2068 if (! NILP (family))
2069 family = SYMBOL_NAME (family);
2070 registry = AREF (val, FONT_REGISTRY_INDEX);
2071 if (! NILP (registry))
2072 registry = SYMBOL_NAME (registry);
2073 val = Fcons (family, registry);
2074 if (NILP (all))
2075 return val;
2076 list = Fcons (val, list);
2078 if (EQ (fontset, Vdefault_fontset))
2079 break;
2080 fontset = Vdefault_fontset;
2082 return (Fnreverse (list));
2085 DEFUN ("fontset-list", Ffontset_list, Sfontset_list, 0, 0, 0,
2086 doc: /* Return a list of all defined fontset names. */)
2087 (void)
2089 Lisp_Object fontset, list;
2090 int i;
2092 list = Qnil;
2093 for (i = 0; i < ASIZE (Vfontset_table); i++)
2095 fontset = FONTSET_FROM_ID (i);
2096 if (!NILP (fontset)
2097 && BASE_FONTSET_P (fontset))
2098 list = Fcons (FONTSET_NAME (fontset), list);
2101 return list;
2105 #ifdef FONTSET_DEBUG
2107 Lisp_Object dump_fontset (Lisp_Object) EXTERNALLY_VISIBLE;
2109 Lisp_Object
2110 dump_fontset (Lisp_Object fontset)
2112 Lisp_Object vec;
2114 vec = Fmake_vector (make_number (3), Qnil);
2115 ASET (vec, 0, FONTSET_ID (fontset));
2117 if (BASE_FONTSET_P (fontset))
2119 ASET (vec, 1, FONTSET_NAME (fontset));
2121 else
2123 Lisp_Object frame;
2125 frame = FONTSET_FRAME (fontset);
2126 if (FRAMEP (frame))
2128 FRAME_PTR f = XFRAME (frame);
2130 if (FRAME_LIVE_P (f))
2131 ASET (vec, 1,
2132 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)), f->name));
2133 else
2134 ASET (vec, 1,
2135 Fcons (FONTSET_NAME (FONTSET_BASE (fontset)), Qnil));
2137 if (!NILP (FONTSET_DEFAULT (fontset)))
2138 ASET (vec, 2, FONTSET_ID (FONTSET_DEFAULT (fontset)));
2140 return vec;
2143 DEFUN ("fontset-list-all", Ffontset_list_all, Sfontset_list_all, 0, 0, 0,
2144 doc: /* Return a brief summary of all fontsets for debug use. */)
2145 (void)
2147 Lisp_Object val;
2148 int i;
2150 for (i = 0, val = Qnil; i < ASIZE (Vfontset_table); i++)
2151 if (! NILP (AREF (Vfontset_table, i)))
2152 val = Fcons (dump_fontset (AREF (Vfontset_table, i)), val);
2153 return (Fnreverse (val));
2155 #endif /* FONTSET_DEBUG */
2157 void
2158 syms_of_fontset (void)
2160 DEFSYM (Qfontset, "fontset");
2161 Fput (Qfontset, Qchar_table_extra_slots, make_number (9));
2162 DEFSYM (Qfontset_info, "fontset-info");
2163 Fput (Qfontset_info, Qchar_table_extra_slots, make_number (1));
2165 DEFSYM (Qprepend, "prepend");
2166 DEFSYM (Qappend, "append");
2167 DEFSYM (Qlatin, "latin");
2169 Vcached_fontset_data = Qnil;
2170 staticpro (&Vcached_fontset_data);
2172 Vfontset_table = Fmake_vector (make_number (32), Qnil);
2173 staticpro (&Vfontset_table);
2175 Vdefault_fontset = Fmake_char_table (Qfontset, Qnil);
2176 staticpro (&Vdefault_fontset);
2177 FONTSET_ID (Vdefault_fontset) = make_number (0);
2178 FONTSET_NAME (Vdefault_fontset)
2179 = make_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
2180 ASET (Vfontset_table, 0, Vdefault_fontset);
2181 next_fontset_id = 1;
2183 auto_fontset_alist = Qnil;
2184 staticpro (&auto_fontset_alist);
2186 DEFVAR_LISP ("font-encoding-charset-alist", Vfont_encoding_charset_alist,
2187 doc: /*
2188 Alist of charsets vs the charsets to determine the preferred font encoding.
2189 Each element looks like (CHARSET . ENCODING-CHARSET),
2190 where ENCODING-CHARSET is a charset registered in the variable
2191 `font-encoding-alist' as ENCODING.
2193 When a text has a property `charset' and the value is CHARSET, a font
2194 whose encoding corresponds to ENCODING-CHARSET is preferred. */);
2195 Vfont_encoding_charset_alist = Qnil;
2197 DEFVAR_LISP ("use-default-ascent", Vuse_default_ascent,
2198 doc: /*
2199 Char table of characters whose ascent values should be ignored.
2200 If an entry for a character is non-nil, the ascent value of the glyph
2201 is assumed to be specified by _MULE_DEFAULT_ASCENT property of a font.
2203 This affects how a composite character which contains
2204 such a character is displayed on screen. */);
2205 Vuse_default_ascent = Qnil;
2207 DEFVAR_LISP ("ignore-relative-composition", Vignore_relative_composition,
2208 doc: /*
2209 Char table of characters which are not composed relatively.
2210 If an entry for a character is non-nil, a composition sequence
2211 which contains that character is displayed so that
2212 the glyph of that character is put without considering
2213 an ascent and descent value of a previous character. */);
2214 Vignore_relative_composition = Qnil;
2216 DEFVAR_LISP ("alternate-fontname-alist", Valternate_fontname_alist,
2217 doc: /* Alist of fontname vs list of the alternate fontnames.
2218 When a specified font name is not found, the corresponding
2219 alternate fontnames (if any) are tried instead. */);
2220 Valternate_fontname_alist = Qnil;
2222 DEFVAR_LISP ("fontset-alias-alist", Vfontset_alias_alist,
2223 doc: /* Alist of fontset names vs the aliases. */);
2224 Vfontset_alias_alist = Fcons (Fcons (FONTSET_NAME (Vdefault_fontset),
2225 make_pure_c_string ("fontset-default")),
2226 Qnil);
2228 DEFVAR_LISP ("vertical-centering-font-regexp",
2229 Vvertical_centering_font_regexp,
2230 doc: /* *Regexp matching font names that require vertical centering on display.
2231 When a character is displayed with such fonts, the character is displayed
2232 at the vertical center of lines. */);
2233 Vvertical_centering_font_regexp = Qnil;
2235 DEFVAR_LISP ("otf-script-alist", Votf_script_alist,
2236 doc: /* Alist of OpenType script tags vs the corresponding script names. */);
2237 Votf_script_alist = Qnil;
2239 defsubr (&Squery_fontset);
2240 defsubr (&Snew_fontset);
2241 defsubr (&Sset_fontset_font);
2242 defsubr (&Sinternal_char_font);
2243 defsubr (&Sfontset_info);
2244 defsubr (&Sfontset_font);
2245 defsubr (&Sfontset_list);
2246 #ifdef FONTSET_DEBUG
2247 defsubr (&Sfontset_list_all);
2248 #endif