1 /* Composite sequence support.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008 Free Software Foundation, Inc.
4 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
7 Copyright (C) 2003, 2006
8 National Institute of Advanced Industrial Science and Technology (AIST)
9 Registration Number H13PRO009
11 This file is part of GNU Emacs.
13 GNU Emacs is free software: you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
18 GNU Emacs is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "character.h"
30 #include "intervals.h"
33 #include "dispextern.h"
36 /* Emacs uses special text property `composition' to support character
37 composition. A sequence of characters that have the same (i.e. eq)
38 `composition' property value is treated as a single composite
39 sequence (we call it just `composition' here after). Characters in
40 a composition are all composed somehow on the screen.
42 The property value has this form when the composition is made:
43 ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
44 then turns to this form:
45 (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
46 when the composition is registered in composition_hash_table and
47 composition_table. These rather peculiar structures were designed
48 to make it easy to distinguish them quickly (we can do that by
49 checking only the first element) and to extract LENGTH (from the
50 former form) and COMPOSITION-ID (from the latter form).
52 We register a composition when it is displayed, or when the width
53 is required (for instance, to calculate columns).
55 LENGTH -- Length of the composition. This information is used to
56 check the validity of the composition.
58 COMPONENTS -- Character, string, vector, list, or nil.
60 If it is nil, characters in the text are composed relatively
61 according to their metrics in font glyphs.
63 If it is a character or a string, the character or characters
64 in the string are composed relatively.
66 If it is a vector or list of integers, the element is a
67 character or an encoded composition rule. The characters are
68 composed according to the rules. (2N)th elements are
69 characters to be composed and (2N+1)th elements are
70 composition rules to tell how to compose (2N+2)th element with
71 the previously composed 2N glyphs.
73 COMPONENTS-VEC -- Vector of integers. In relative composition, the
74 elements are characters to be composed. In rule-base
75 composition, the elements are characters or encoded
78 MODIFICATION-FUNC -- If non nil, it is a function to call when the
79 composition gets invalid after a modification in a buffer. If
80 it is nil, a function in `composition-function-table' of the
81 first character in the sequence is called.
83 COMPOSITION-ID --Identification number of the composition. It is
84 used as an index to composition_table for the composition.
86 When Emacs has to display a composition or has to know its
87 displaying width, the function get_composition_id is called. It
88 returns COMPOSITION-ID so that the caller can access the
89 information about the composition through composition_table. If a
90 COMPOSITION-ID has not yet been assigned to the composition,
91 get_composition_id checks the validity of `composition' property,
92 and, if valid, assigns a new ID, registers the information in
93 composition_hash_table and composition_table, and changes the form
94 of the property value. If the property is invalid, return -1
95 without changing the property value.
97 We use two tables to keep information about composition;
98 composition_hash_table and composition_table.
100 The former is a hash table in which keys are COMPONENTS-VECs and
101 values are the corresponding COMPOSITION-IDs. This hash table is
102 weak, but as each key (COMPONENTS-VEC) is also kept as a value of the
103 `composition' property, it won't be collected as garbage until all
104 bits of text that have the same COMPONENTS-VEC are deleted.
106 The latter is a table of pointers to `struct composition' indexed
107 by COMPOSITION-ID. This structure keeps the other information (see
110 In general, a text property holds information about individual
111 characters. But, a `composition' property holds information about
112 a sequence of characters (in this sense, it is like the `intangible'
113 property). That means that we should not share the property value
114 in adjacent compositions -- we can't distinguish them if they have the
115 same property. So, after any changes, we call
116 `update_compositions' and change a property of one of adjacent
117 compositions to a copy of it. This function also runs a proper
118 composition modification function to make a composition that gets
119 invalid by the change valid again.
121 As the value of the `composition' property holds information about a
122 specific range of text, the value gets invalid if we change the
123 text in the range. We treat the `composition' property as always
124 rear-nonsticky (currently by setting default-text-properties to
125 (rear-nonsticky (composition))) and we never make properties of
126 adjacent compositions identical. Thus, any such changes make the
127 range just shorter. So, we can check the validity of the `composition'
128 property by comparing LENGTH information with the actual length of
134 Lisp_Object Qcomposition
;
136 /* Table of pointers to the structure `composition' indexed by
137 COMPOSITION-ID. This structure is for storing information about
138 each composition except for COMPONENTS-VEC. */
139 struct composition
**composition_table
;
141 /* The current size of `composition_table'. */
142 static int composition_table_size
;
144 /* Number of compositions currently made. */
147 /* Hash table for compositions. The key is COMPONENTS-VEC of
148 `composition' property. The value is the corresponding
150 Lisp_Object composition_hash_table
;
152 /* Function to call to adjust composition. */
153 Lisp_Object Vcompose_chars_after_function
;
155 Lisp_Object Qauto_composed
;
156 Lisp_Object Vauto_composition_function
;
157 Lisp_Object Qauto_composition_function
;
158 Lisp_Object Vcomposition_function_table
;
160 EXFUN (Fremove_list_of_text_properties
, 4);
162 /* Temporary variable used in macros COMPOSITION_XXX. */
163 Lisp_Object composition_temp
;
166 /* Return COMPOSITION-ID of a composition at buffer position
167 CHARPOS/BYTEPOS and length NCHARS. The `composition' property of
168 the sequence is PROP. STRING, if non-nil, is a string that
169 contains the composition instead of the current buffer.
171 If the composition is invalid, return -1. */
174 get_composition_id (charpos
, bytepos
, nchars
, prop
, string
)
175 int charpos
, bytepos
, nchars
;
176 Lisp_Object prop
, string
;
178 Lisp_Object id
, length
, components
, key
, *key_contents
;
180 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (composition_hash_table
);
183 struct composition
*cmp
;
187 Form-A: ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
189 Form-B: (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
191 if (nchars
== 0 || !CONSP (prop
))
192 goto invalid_composition
;
197 /* PROP should be Form-B. */
198 if (XINT (id
) < 0 || XINT (id
) >= n_compositions
)
199 goto invalid_composition
;
203 /* PROP should be Form-A.
204 Thus, ID should be (LENGTH . COMPONENTS). */
206 goto invalid_composition
;
208 if (!INTEGERP (length
) || XINT (length
) != nchars
)
209 goto invalid_composition
;
211 components
= XCDR (id
);
213 /* Check if the same composition has already been registered or not
214 by consulting composition_hash_table. The key for this table is
215 COMPONENTS (converted to a vector COMPONENTS-VEC) or, if it is
216 nil, vector of characters in the composition range. */
217 if (INTEGERP (components
))
218 key
= Fmake_vector (make_number (1), components
);
219 else if (STRINGP (components
) || CONSP (components
))
220 key
= Fvconcat (1, &components
);
221 else if (VECTORP (components
))
223 else if (NILP (components
))
225 key
= Fmake_vector (make_number (nchars
), Qnil
);
226 if (STRINGP (string
))
227 for (i
= 0; i
< nchars
; i
++)
229 FETCH_STRING_CHAR_ADVANCE (ch
, string
, charpos
, bytepos
);
230 XVECTOR (key
)->contents
[i
] = make_number (ch
);
233 for (i
= 0; i
< nchars
; i
++)
235 FETCH_CHAR_ADVANCE (ch
, charpos
, bytepos
);
236 XVECTOR (key
)->contents
[i
] = make_number (ch
);
240 goto invalid_composition
;
242 hash_index
= hash_lookup (hash_table
, key
, &hash_code
);
245 /* We have already registered the same composition. Change PROP
246 from Form-A above to Form-B while replacing COMPONENTS with
247 COMPONENTS-VEC stored in the hash table. We can directly
248 modify the cons cell of PROP because it is not shared. */
249 key
= HASH_KEY (hash_table
, hash_index
);
250 id
= HASH_VALUE (hash_table
, hash_index
);
252 XSETCDR (prop
, Fcons (make_number (nchars
), Fcons (key
, XCDR (prop
))));
256 /* This composition is a new one. We must register it. */
258 /* Check if we have sufficient memory to store this information. */
259 if (composition_table_size
== 0)
261 composition_table_size
= 256;
263 = (struct composition
**) xmalloc (sizeof (composition_table
[0])
264 * composition_table_size
);
266 else if (composition_table_size
<= n_compositions
)
268 composition_table_size
+= 256;
270 = (struct composition
**) xrealloc (composition_table
,
271 sizeof (composition_table
[0])
272 * composition_table_size
);
275 key_contents
= XVECTOR (key
)->contents
;
277 /* Check if the contents of COMPONENTS are valid if COMPONENTS is a
278 vector or a list. It should be a sequence of:
279 char1 rule1 char2 rule2 char3 ... ruleN charN+1 */
281 if (VECTORP (components
)
282 && ASIZE (components
) >= 2
283 && VECTORP (AREF (components
, 0)))
285 /* COMPONENTS is a glyph-string. */
286 int len
= ASIZE (key
);
288 for (i
= 1; i
< len
; i
++)
289 if (! VECTORP (AREF (key
, i
)))
290 goto invalid_composition
;
292 else if (VECTORP (components
) || CONSP (components
))
294 int len
= XVECTOR (key
)->size
;
296 /* The number of elements should be odd. */
298 goto invalid_composition
;
299 /* All elements should be integers (character or encoded
300 composition rule). */
301 for (i
= 0; i
< len
; i
++)
303 if (!INTEGERP (key_contents
[i
]))
304 goto invalid_composition
;
308 /* Change PROP from Form-A above to Form-B. We can directly modify
309 the cons cell of PROP because it is not shared. */
310 XSETFASTINT (id
, n_compositions
);
312 XSETCDR (prop
, Fcons (make_number (nchars
), Fcons (key
, XCDR (prop
))));
314 /* Register the composition in composition_hash_table. */
315 hash_index
= hash_put (hash_table
, key
, id
, hash_code
);
317 /* Register the composition in composition_table. */
318 cmp
= (struct composition
*) xmalloc (sizeof (struct composition
));
320 cmp
->method
= (NILP (components
)
321 ? COMPOSITION_RELATIVE
322 : ((INTEGERP (components
) || STRINGP (components
))
323 ? COMPOSITION_WITH_ALTCHARS
324 : COMPOSITION_WITH_RULE_ALTCHARS
));
325 cmp
->hash_index
= hash_index
;
326 glyph_len
= (cmp
->method
== COMPOSITION_WITH_RULE_ALTCHARS
327 ? (XVECTOR (key
)->size
+ 1) / 2
328 : XVECTOR (key
)->size
);
329 cmp
->glyph_len
= glyph_len
;
330 cmp
->offsets
= (short *) xmalloc (sizeof (short) * glyph_len
* 2);
333 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
335 /* Relative composition. */
337 for (i
= 0; i
< glyph_len
; i
++)
340 ch
= XINT (key_contents
[i
]);
341 this_width
= (ch
== '\t' ? 1 : CHAR_WIDTH (ch
));
342 if (cmp
->width
< this_width
)
343 cmp
->width
= this_width
;
348 /* Rule-base composition. */
349 float leftmost
= 0.0, rightmost
;
351 ch
= XINT (key_contents
[0]);
352 rightmost
= ch
!= '\t' ? CHAR_WIDTH (ch
) : 1;
354 for (i
= 1; i
< glyph_len
; i
+= 2)
356 int rule
, gref
, nref
, xoff
, yoff
;
360 rule
= XINT (key_contents
[i
]);
361 ch
= XINT (key_contents
[i
+ 1]);
362 this_width
= ch
!= '\t' ? CHAR_WIDTH (ch
) : 1;
364 /* A composition rule is specified by an integer value
365 that encodes global and new reference points (GREF and
366 NREF). GREF and NREF are specified by numbers as
374 ---3---4---5--- baseline
378 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
379 this_left
= (leftmost
380 + (gref
% 3) * (rightmost
- leftmost
) / 2.0
381 - (nref
% 3) * this_width
/ 2.0);
383 if (this_left
< leftmost
)
384 leftmost
= this_left
;
385 if (this_left
+ this_width
> rightmost
)
386 rightmost
= this_left
+ this_width
;
389 cmp
->width
= rightmost
- leftmost
;
390 if (cmp
->width
< (rightmost
- leftmost
))
391 /* To get a ceiling integer value. */
395 composition_table
[n_compositions
] = cmp
;
397 return n_compositions
++;
400 /* Would it be better to remove this `composition' property? */
405 /* Find a composition at or nearest to position POS of OBJECT (buffer
408 OBJECT defaults to the current buffer. If there's a composition at
409 POS, set *START and *END to the start and end of the sequence,
410 *PROP to the `composition' property, and return 1.
412 If there's no composition at POS and LIMIT is negative, return 0.
414 Otherwise, search for a composition forward (LIMIT > POS) or
415 backward (LIMIT < POS). In this case, LIMIT bounds the search.
417 If a composition is found, set *START, *END, and *PROP as above,
418 and return 1, else return 0.
420 This doesn't check the validity of composition. */
423 find_composition (pos
, limit
, start
, end
, prop
, object
)
425 EMACS_INT
*start
, *end
;
426 Lisp_Object
*prop
, object
;
430 if (get_property_and_range (pos
, Qcomposition
, prop
, start
, end
, object
))
433 if (limit
< 0 || limit
== pos
)
436 if (limit
> pos
) /* search forward */
438 val
= Fnext_single_property_change (make_number (pos
), Qcomposition
,
439 object
, make_number (limit
));
444 else /* search backward */
446 if (get_property_and_range (pos
- 1, Qcomposition
, prop
, start
, end
,
449 val
= Fprevious_single_property_change (make_number (pos
), Qcomposition
,
450 object
, make_number (limit
));
456 get_property_and_range (pos
, Qcomposition
, prop
, start
, end
, object
);
460 /* Run a proper function to adjust the composition sitting between
461 FROM and TO with property PROP. */
464 run_composition_function (from
, to
, prop
)
469 EMACS_INT start
, end
;
471 func
= COMPOSITION_MODIFICATION_FUNC (prop
);
472 /* If an invalid composition precedes or follows, try to make them
475 && find_composition (from
- 1, -1, &start
, &end
, &prop
, Qnil
)
476 && !COMPOSITION_VALID_P (start
, end
, prop
))
479 && find_composition (to
, -1, &start
, &end
, &prop
, Qnil
)
480 && !COMPOSITION_VALID_P (start
, end
, prop
))
482 if (!NILP (Ffboundp (func
)))
483 call2 (func
, make_number (from
), make_number (to
));
486 /* Make invalid compositions adjacent to or inside FROM and TO valid.
487 CHECK_MASK is bitwise `or' of mask bits defined by macros
488 CHECK_XXX (see the comment in composite.h).
490 It also resets the text-property `auto-composed' to a proper region
491 so that automatic character composition works correctly later while
492 displaying the region.
494 This function is called when a buffer text is changed. If the
495 change is deletion, FROM == TO. Otherwise, FROM < TO. */
498 update_compositions (from
, to
, check_mask
)
503 EMACS_INT start
, end
;
504 /* The beginning and end of the region to set the property
505 `auto-composed' to nil. */
506 EMACS_INT min_pos
= from
, max_pos
= to
;
508 if (inhibit_modification_hooks
)
511 /* If FROM and TO are not in a valid range, do nothing. */
512 if (! (BEGV
<= from
&& from
<= to
&& to
<= ZV
))
515 if (check_mask
& CHECK_HEAD
)
517 /* FROM should be at composition boundary. But, insertion or
518 deletion will make two compositions adjacent and
519 indistinguishable when they have same (eq) property. To
520 avoid it, in such a case, we change the property of the
521 latter to the copy of it. */
523 && find_composition (from
- 1, -1, &start
, &end
, &prop
, Qnil
)
524 && COMPOSITION_VALID_P (start
, end
, prop
))
530 Fput_text_property (make_number (from
), make_number (end
),
532 Fcons (XCAR (prop
), XCDR (prop
)), Qnil
);
533 run_composition_function (start
, end
, prop
);
537 && find_composition (from
, -1, &start
, &from
, &prop
, Qnil
)
538 && COMPOSITION_VALID_P (start
, from
, prop
))
542 run_composition_function (start
, from
, prop
);
546 if (check_mask
& CHECK_INSIDE
)
548 /* In this case, we are sure that (check & CHECK_TAIL) is also
549 nonzero. Thus, here we should check only compositions before
552 && find_composition (from
, to
, &start
, &from
, &prop
, Qnil
)
553 && COMPOSITION_VALID_P (start
, from
, prop
)
555 run_composition_function (start
, from
, prop
);
558 if (check_mask
& CHECK_TAIL
)
561 && find_composition (to
- 1, -1, &start
, &end
, &prop
, Qnil
)
562 && COMPOSITION_VALID_P (start
, end
, prop
))
564 /* TO should be also at composition boundary. But,
565 insertion or deletion will make two compositions adjacent
566 and indistinguishable when they have same (eq) property.
567 To avoid it, in such a case, we change the property of
568 the former to the copy of it. */
571 Fput_text_property (make_number (start
), make_number (to
),
573 Fcons (XCAR (prop
), XCDR (prop
)), Qnil
);
576 run_composition_function (start
, end
, prop
);
579 && find_composition (to
, -1, &start
, &end
, &prop
, Qnil
)
580 && COMPOSITION_VALID_P (start
, end
, prop
))
582 run_composition_function (start
, end
, prop
);
586 if (min_pos
< max_pos
)
588 int count
= SPECPDL_INDEX ();
590 specbind (Qinhibit_read_only
, Qt
);
591 specbind (Qinhibit_modification_hooks
, Qt
);
592 specbind (Qinhibit_point_motion_hooks
, Qt
);
593 Fremove_list_of_text_properties (make_number (min_pos
),
594 make_number (max_pos
),
595 Fcons (Qauto_composed
, Qnil
), Qnil
);
596 unbind_to (count
, Qnil
);
601 /* Modify composition property values in LIST destructively. LIST is
602 a list as returned from text_property_list. Change values to the
603 top-level copies of them so that none of them are `eq'. */
606 make_composition_value_copy (list
)
609 Lisp_Object plist
, val
;
611 for (; CONSP (list
); list
= XCDR (list
))
613 plist
= XCAR (XCDR (XCDR (XCAR (list
))));
614 while (CONSP (plist
) && CONSP (XCDR (plist
)))
616 if (EQ (XCAR (plist
), Qcomposition
)
617 && (val
= XCAR (XCDR (plist
)), CONSP (val
)))
618 XSETCAR (XCDR (plist
), Fcons (XCAR (val
), XCDR (val
)));
619 plist
= XCDR (XCDR (plist
));
625 /* Make text in the region between START and END a composition that
626 has COMPONENTS and MODIFICATION-FUNC.
628 If STRING is non-nil, then operate on characters contained between
629 indices START and END in STRING. */
632 compose_text (start
, end
, components
, modification_func
, string
)
634 Lisp_Object components
, modification_func
, string
;
638 prop
= Fcons (Fcons (make_number (end
- start
), components
),
640 Fput_text_property (make_number (start
), make_number (end
),
641 Qcomposition
, prop
, string
);
645 static Lisp_Object autocmp_chars
P_ ((Lisp_Object
, EMACS_INT
, EMACS_INT
,
646 EMACS_INT
, struct window
*,
647 struct face
*, Lisp_Object
));
650 /* Lisp glyph-string handlers */
652 /* Hash table for automatic composition. The key is a header of a
653 lgstring (Lispy glyph-string), and the value is a body of a
656 static Lisp_Object gstring_hash_table
;
658 static Lisp_Object gstring_lookup_cache
P_ ((Lisp_Object
));
661 gstring_lookup_cache (header
)
664 struct Lisp_Hash_Table
*h
= XHASH_TABLE (gstring_hash_table
);
665 int i
= hash_lookup (h
, header
, NULL
);
667 return (i
>= 0 ? HASH_VALUE (h
, i
) : Qnil
);
671 composition_gstring_put_cache (gstring
, len
)
675 struct Lisp_Hash_Table
*h
= XHASH_TABLE (gstring_hash_table
);
677 Lisp_Object header
, copy
;
680 header
= LGSTRING_HEADER (gstring
);
681 hash
= h
->hashfn (h
, header
);
684 len
= LGSTRING_GLYPH_LEN (gstring
);
685 for (i
= 0; i
< len
; i
++)
686 if (NILP (LGSTRING_GLYPH (gstring
, i
)))
691 copy
= Fmake_vector (make_number (len
+ 2), Qnil
);
692 LGSTRING_SET_HEADER (copy
, Fcopy_sequence (header
));
693 for (i
= 0; i
< len
; i
++)
694 LGSTRING_SET_GLYPH (copy
, i
, Fcopy_sequence (LGSTRING_GLYPH (gstring
, i
)));
695 i
= hash_put (h
, LGSTRING_HEADER (copy
), copy
, hash
);
696 LGSTRING_SET_ID (copy
, make_number (i
));
701 composition_gstring_from_id (id
)
704 struct Lisp_Hash_Table
*h
= XHASH_TABLE (gstring_hash_table
);
706 return HASH_VALUE (h
, id
);
709 static Lisp_Object fill_gstring_header
P_ ((Lisp_Object
, Lisp_Object
,
710 Lisp_Object
, Lisp_Object
,
714 composition_gstring_p (gstring
)
720 if (! VECTORP (gstring
) || ASIZE (gstring
) < 2)
722 header
= LGSTRING_HEADER (gstring
);
723 if (! VECTORP (header
) || ASIZE (header
) < 2)
725 if (! NILP (LGSTRING_FONT (gstring
))
726 && ! FONT_OBJECT_P (LGSTRING_FONT (gstring
)))
728 for (i
= 1; i
< ASIZE (LGSTRING_HEADER (gstring
)); i
++)
729 if (! NATNUMP (AREF (LGSTRING_HEADER (gstring
), i
)))
731 if (! NILP (LGSTRING_ID (gstring
)) && ! NATNUMP (LGSTRING_ID (gstring
)))
733 for (i
= 0; i
< LGSTRING_GLYPH_LEN (gstring
); i
++)
735 Lisp_Object glyph
= LGSTRING_GLYPH (gstring
, i
);
738 if (! VECTORP (glyph
) || ASIZE (glyph
) != LGLYPH_SIZE
)
745 composition_gstring_width (gstring
, from
, to
, metrics
)
748 struct font_metrics
*metrics
;
755 Lisp_Object font_object
= LGSTRING_FONT (gstring
);
756 struct font
*font
= XFONT_OBJECT (font_object
);
758 metrics
->ascent
= font
->ascent
;
759 metrics
->descent
= font
->descent
;
760 metrics
->width
= metrics
->lbearing
= metrics
->rbearing
= 0;
762 for (glyph
= &LGSTRING_GLYPH (gstring
, from
); from
< to
; from
++, glyph
++)
766 if (NILP (LGLYPH_ADJUSTMENT (*glyph
)))
767 width
+= LGLYPH_WIDTH (*glyph
);
769 width
+= LGLYPH_WADJUST (*glyph
);
772 x
= metrics
->width
+ LGLYPH_LBEARING (*glyph
) + LGLYPH_XOFF (*glyph
);
773 if (metrics
->lbearing
> x
)
774 metrics
->lbearing
= x
;
775 x
= metrics
->width
+ LGLYPH_RBEARING (*glyph
) + LGLYPH_XOFF (*glyph
);
776 if (metrics
->rbearing
< x
)
777 metrics
->rbearing
= x
;
778 metrics
->width
= width
;
779 x
= LGLYPH_ASCENT (*glyph
) - LGLYPH_YOFF (*glyph
);
780 if (metrics
->ascent
< x
)
782 x
= LGLYPH_DESCENT (*glyph
) - LGLYPH_YOFF (*glyph
);
783 if (metrics
->descent
< x
)
784 metrics
->descent
= x
;
791 static Lisp_Object gstring_work
;
792 static Lisp_Object gstring_work_headers
;
795 fill_gstring_header (header
, start
, end
, font_object
, string
)
796 Lisp_Object header
, start
, end
, font_object
, string
;
798 EMACS_INT from
, to
, from_byte
;
803 if (NILP (current_buffer
->enable_multibyte_characters
))
804 error ("Attempt to shape unibyte text");
805 validate_region (&start
, &end
);
806 from
= XFASTINT (start
);
808 from_byte
= CHAR_TO_BYTE (from
);
812 CHECK_STRING (string
);
813 if (! STRING_MULTIBYTE (current_buffer
->enable_multibyte_characters
))
814 error ("Attempt to shape unibyte text");
815 CHECK_NATNUM (start
);
819 if (from
< 0 || from
> to
|| to
> SCHARS (string
))
820 args_out_of_range_3 (string
, start
, end
);
821 from_byte
= string_char_to_byte (string
, from
);
826 error ("Attempt to shape zero-length text");
827 if (VECTORP (header
))
829 if (ASIZE (header
) != len
+ 1)
830 args_out_of_range (header
, make_number (len
+ 1));
835 header
= AREF (gstring_work_headers
, len
- 1);
837 header
= Fmake_vector (make_number (len
+ 1), Qnil
);
840 ASET (header
, 0, font_object
);
841 for (i
= 0; i
< len
; i
++)
846 FETCH_CHAR_ADVANCE_NO_CHECK (c
, from
, from_byte
);
848 FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c
, string
, from
, from_byte
);
849 ASET (header
, i
+ 1, make_number (c
));
854 extern void font_fill_lglyph_metrics
P_ ((Lisp_Object
, Lisp_Object
));
857 fill_gstring_body (gstring
)
860 Lisp_Object font_object
= LGSTRING_FONT (gstring
);
861 Lisp_Object header
= AREF (gstring
, 0);
862 EMACS_INT len
= LGSTRING_CHAR_LEN (gstring
);
865 for (i
= 0; i
< len
; i
++)
867 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
868 EMACS_INT c
= XINT (AREF (header
, i
+ 1));
873 LGSTRING_SET_GLYPH (gstring
, i
, g
);
875 LGLYPH_SET_FROM (g
, i
);
876 LGLYPH_SET_TO (g
, i
);
877 LGLYPH_SET_CHAR (g
, c
);
878 if (! NILP (font_object
))
880 font_fill_lglyph_metrics (g
, font_object
);
884 int width
= XFASTINT (CHAR_TABLE_REF (Vchar_width_table
, c
));
886 LGLYPH_SET_CODE (g
, c
);
887 LGLYPH_SET_LBEARING (g
, 0);
888 LGLYPH_SET_RBEARING (g
, width
);
889 LGLYPH_SET_WIDTH (g
, width
);
890 LGLYPH_SET_ASCENT (g
, 1);
891 LGLYPH_SET_DESCENT (g
, 0);
893 LGLYPH_SET_ADJUSTMENT (g
, Qnil
);
895 if (i
< LGSTRING_GLYPH_LEN (gstring
))
896 LGSTRING_SET_GLYPH (gstring
, i
, Qnil
);
899 EXFUN (Fre_search_forward
, 4);
901 /* Try to compose the characters at CHARPOS according to CFT_ELEMENT
902 which is an element of composition-fucntion-table (which see).
903 LIMIT limits the characters to compose. STRING, if not nil, is a
904 target string. WIN is a window where the characters are being
908 autocmp_chars (cft_element
, charpos
, bytepos
, limit
, win
, face
, string
)
909 Lisp_Object cft_element
;
910 EMACS_INT charpos
, bytepos
, limit
;
915 int count
= SPECPDL_INDEX ();
916 FRAME_PTR f
= XFRAME (win
->frame
);
917 Lisp_Object pos
= make_number (charpos
);
918 EMACS_INT pt
= PT
, pt_byte
= PT_BYTE
;
920 record_unwind_save_match_data ();
921 for (; CONSP (cft_element
); cft_element
= XCDR (cft_element
))
923 Lisp_Object elt
= XCAR (cft_element
);
925 Lisp_Object font_object
= Qnil
, gstring
;
928 if (! VECTORP (elt
) || ASIZE (elt
) != 3)
932 TEMP_SET_PT_BOTH (charpos
, bytepos
);
936 ? EQ (Fstring_match (re
, string
, pos
), pos
)
937 : (! NILP (Fre_search_forward (re
, make_number (limit
), Qt
, Qnil
))
938 && EQ (Fmatch_beginning (make_number (0)), pos
)))))
940 to
= (NILP (re
) ? charpos
+ 1 : XINT (Fmatch_end (make_number (0))));
941 #ifdef HAVE_WINDOW_SYSTEM
942 if (FRAME_WINDOW_P (f
))
944 font_object
= font_range (charpos
, &to
, win
, face
, string
);
945 if (! FONT_OBJECT_P (font_object
))
948 TEMP_SET_PT_BOTH (pt
, pt_byte
);
949 return unbind_to (count
, Qnil
);
952 #endif /* not HAVE_WINDOW_SYSTEM */
953 gstring
= Fcomposition_get_gstring (pos
, make_number (to
),
954 font_object
, string
);
955 if (NILP (LGSTRING_ID (gstring
)))
959 args
[0] = Vauto_composition_function
;
960 args
[1] = AREF (elt
, 2);
962 args
[3] = make_number (to
);
963 args
[4] = font_object
;
965 gstring
= safe_call (6, args
);
968 TEMP_SET_PT_BOTH (pt
, pt_byte
);
969 return unbind_to (count
, gstring
);
973 TEMP_SET_PT_BOTH (pt
, pt_byte
);
974 return unbind_to (count
, Qnil
);
978 /* Update cmp_it->stop_pos to the next position after CHARPOS (and
979 BYTEPOS) where character composition may happen. If BYTEPOS is
980 negative, compoute it. If it is a static composition, set
981 cmp_it->ch to -1. Otherwise, set cmp_it->ch to the character that
982 triggers a automatic composition. */
985 composition_compute_stop_pos (cmp_it
, charpos
, bytepos
, endpos
, string
)
986 struct composition_it
*cmp_it
;
987 EMACS_INT charpos
, bytepos
, endpos
;
990 EMACS_INT start
, end
, c
;
991 Lisp_Object prop
, val
;
993 cmp_it
->stop_pos
= endpos
;
994 if (find_composition (charpos
, endpos
, &start
, &end
, &prop
, string
)
995 && COMPOSITION_VALID_P (start
, end
, prop
))
997 cmp_it
->stop_pos
= endpos
= start
;
1000 if (NILP (current_buffer
->enable_multibyte_characters
)
1001 || ! FUNCTIONP (Vauto_composition_function
))
1005 if (STRINGP (string
))
1006 bytepos
= string_char_to_byte (string
, charpos
);
1008 bytepos
= CHAR_TO_BYTE (charpos
);
1012 while (charpos
< endpos
)
1014 if (STRINGP (string
))
1015 FETCH_STRING_CHAR_ADVANCE (c
, string
, charpos
, bytepos
);
1017 FETCH_CHAR_ADVANCE (c
, charpos
, bytepos
);
1018 val
= CHAR_TABLE_REF (Vcomposition_function_table
, c
);
1023 for (; CONSP (val
); val
= XCDR (val
))
1026 if (VECTORP (elt
) && ASIZE (elt
) == 3 && NATNUMP (AREF (elt
, 1))
1027 && charpos
- 1 - XFASTINT (AREF (elt
, 1)) >= start
)
1032 cmp_it
->stop_pos
= charpos
- 1 - XFASTINT (AREF (elt
, 1));
1040 /* Check if the character at CHARPOS (and BYTEPOS) is composed
1041 (possibly with the following charaters) on window W. ENDPOS limits
1042 characters to be composed. FACE, in non-NULL, is a base face of
1043 the character. If STRING is not nil, it is a string containing the
1044 character to check, and CHARPOS and BYTEPOS are indices in the
1045 string. In that case, FACE must not be NULL.
1047 If the character is composed, setup members of CMP_IT (id, nglyphs,
1048 and from), and return 1. Otherwise, update CMP_IT->stop_pos, and
1052 composition_reseat_it (cmp_it
, charpos
, bytepos
, endpos
, w
, face
, string
)
1053 struct composition_it
*cmp_it
;
1054 EMACS_INT charpos
, bytepos
, endpos
;
1061 /* We are looking at a static composition. */
1062 EMACS_INT start
, end
;
1065 find_composition (charpos
, -1, &start
, &end
, &prop
, string
);
1066 cmp_it
->id
= get_composition_id (charpos
, bytepos
, end
- start
,
1069 goto no_composition
;
1070 cmp_it
->nchars
= end
- start
;
1071 cmp_it
->nglyphs
= composition_table
[cmp_it
->id
]->glyph_len
;
1078 val
= CHAR_TABLE_REF (Vcomposition_function_table
, cmp_it
->ch
);
1080 goto no_composition
;
1081 val
= autocmp_chars (val
, charpos
, bytepos
, endpos
, w
, face
, string
);
1082 if (! composition_gstring_p (val
))
1083 goto no_composition
;
1084 if (NILP (LGSTRING_ID (val
)))
1085 val
= composition_gstring_put_cache (val
, -1);
1086 cmp_it
->id
= XINT (LGSTRING_ID (val
));
1087 for (i
= 0; i
< LGSTRING_GLYPH_LEN (val
); i
++)
1088 if (NILP (LGSTRING_GLYPH (val
, i
)))
1090 cmp_it
->nglyphs
= i
;
1097 if (STRINGP (string
))
1098 bytepos
+= MULTIBYTE_LENGTH_NO_CHECK (SDATA (string
) + bytepos
);
1101 composition_compute_stop_pos (cmp_it
, charpos
, bytepos
, endpos
, string
);
1106 composition_update_it (cmp_it
, charpos
, bytepos
, string
)
1107 struct composition_it
*cmp_it
;
1108 EMACS_INT charpos
, bytepos
;
1115 struct composition
*cmp
= composition_table
[cmp_it
->id
];
1117 cmp_it
->to
= cmp_it
->nglyphs
;
1118 if (cmp_it
->nglyphs
== 0)
1122 for (i
= 0; i
< cmp
->glyph_len
; i
++)
1123 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
1128 cmp_it
->width
= cmp
->width
;
1132 Lisp_Object gstring
= composition_gstring_from_id (cmp_it
->id
);
1134 if (cmp_it
->nglyphs
== 0)
1137 cmp_it
->nchars
= LGSTRING_CHAR_LEN (gstring
);
1142 Lisp_Object glyph
= LGSTRING_GLYPH (gstring
, cmp_it
->from
);
1143 int from
= LGLYPH_FROM (glyph
);
1145 c
= XINT (LGSTRING_CHAR (gstring
, from
));
1146 cmp_it
->nchars
= LGLYPH_TO (glyph
) - from
+ 1;
1147 cmp_it
->width
= (LGLYPH_WIDTH (glyph
) > 0
1148 ? CHAR_WIDTH (LGLYPH_CHAR (glyph
)) : 0);
1149 for (cmp_it
->to
= cmp_it
->from
+ 1; cmp_it
->to
< cmp_it
->nglyphs
;
1152 glyph
= LGSTRING_GLYPH (gstring
, cmp_it
->to
);
1153 if (LGLYPH_FROM (glyph
) != from
)
1155 if (LGLYPH_WIDTH (glyph
) > 0)
1156 cmp_it
->width
+= CHAR_WIDTH (LGLYPH_CHAR (glyph
));
1161 charpos
+= cmp_it
->nchars
;
1162 if (STRINGP (string
))
1163 cmp_it
->nbytes
= string_char_to_byte (string
, charpos
) - bytepos
;
1165 cmp_it
->nbytes
= CHAR_TO_BYTE (charpos
) - bytepos
;
1171 composition_adjust_point (last_pt
)
1174 /* Now check the automatic composition. */
1175 EMACS_INT charpos
, bytepos
, startpos
, beg
, end
, pos
;
1176 Lisp_Object val
, cat
;
1180 if (PT
== BEGV
|| PT
== ZV
)
1183 if (get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
1184 && COMPOSITION_VALID_P (beg
, end
, val
)
1185 && beg
< PT
/* && end > PT <- It's always the case. */
1186 && (last_pt
<= beg
|| last_pt
>= end
))
1187 return (PT
< last_pt
? beg
: end
);
1189 if (NILP (current_buffer
->enable_multibyte_characters
)
1190 || ! FUNCTIONP (Vauto_composition_function
))
1193 c
= FETCH_MULTIBYTE_CHAR (PT_BYTE
);
1194 cat
= CHAR_TABLE_REF (Vunicode_category_table
, c
);
1196 && ((c
= SDATA (SYMBOL_NAME (cat
))[0]) == 'C' || c
== 'Z'))
1197 /* A control character is never composed. */
1202 limit
= (last_pt
< PT
? last_pt
: BEGV
);
1204 DEC_BOTH (charpos
, bytepos
);
1205 c
= FETCH_MULTIBYTE_CHAR (bytepos
);
1206 cat
= CHAR_TABLE_REF (Vunicode_category_table
, c
);
1208 && ((c
= SDATA (SYMBOL_NAME (cat
))[0]) == 'C' || c
== 'Z'))
1210 INC_BOTH (charpos
, bytepos
);
1213 } while (charpos
> limit
);
1216 limit
= (last_pt
< PT
? ZV
: last_pt
);
1220 while (charpos
< limit
)
1222 c
= FETCH_MULTIBYTE_CHAR (bytepos
);
1227 cat
= CHAR_TABLE_REF (Vunicode_category_table
, c
);
1229 && ((ch
= SDATA (SYMBOL_NAME (cat
))[0]) == 'C' || ch
== 'Z'))
1232 val
= CHAR_TABLE_REF (Vcomposition_function_table
, c
);
1235 INC_BOTH (charpos
, bytepos
);
1238 for (; CONSP (val
); val
= XCDR (val
))
1240 Lisp_Object elt
= XCAR (val
);
1242 if (VECTORP (elt
) && ASIZE (elt
) == 3 && NATNUMP (AREF (elt
, 1))
1243 && (pos
= charpos
- XFASTINT (AREF (elt
, 1))) < PT
1246 Lisp_Object gstring
;
1249 if (XFASTINT (AREF (elt
, 1)) == 0)
1252 pos_byte
= CHAR_TO_BYTE (pos
);
1253 gstring
= autocmp_chars (val
, pos
, pos_byte
, Z
,
1254 XWINDOW (selected_window
), NULL
, Qnil
);
1255 if (composition_gstring_p (gstring
))
1257 if (pos
+ LGSTRING_CHAR_LEN (gstring
) > PT
)
1261 for (i
= 0; i
< LGSTRING_GLYPH_LEN (gstring
); i
++)
1263 Lisp_Object glyph
= LGSTRING_GLYPH (gstring
, i
);
1267 if (pos
+ LGLYPH_FROM (glyph
) == PT
)
1269 if (pos
+ LGLYPH_TO (glyph
) + 1 > PT
)
1270 return (PT
< last_pt
1271 ? pos
+ LGLYPH_FROM (glyph
)
1272 : pos
+ LGLYPH_TO (glyph
) + 1);
1276 charpos
= startpos
= pos
+ LGSTRING_CHAR_LEN (gstring
);
1277 bytepos
= CHAR_TO_BYTE (charpos
);
1283 INC_BOTH (charpos
, bytepos
);
1288 DEFUN ("composition-get-gstring", Fcomposition_get_gstring
,
1289 Scomposition_get_gstring
, 4, 4, 0,
1290 doc
: /* Return a glyph-string for characters between FROM and TO.
1291 If the glhph string is for graphic display, FONT-OBJECT must be
1292 a font-object to use for those characters.
1293 Otherwise (for terminal display), FONT-OBJECT must be nil.
1295 If the optional 4th argument STRING is not nil, it is a string
1296 containing the target characters between indices FROM and TO.
1298 A glhph-string is a vector containing information about how to display
1299 specific character sequence. The format is:
1300 [HEADER ID GLYPH ...]
1302 HEADER is a vector of this form:
1303 [FONT-OBJECT CHAR ...]
1305 FONT-OBJECT is a font-object for all glyphs in the glyph-string,
1306 or nil if not yet decided.
1307 CHARs are characters to be composed by GLYPHs.
1309 ID is an identification number of the glyph-string. It may be nil if
1312 GLYPH is a vector whose elements has this form:
1313 [ FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT
1314 [ [X-OFF Y-OFF WADJUST] | nil] ]
1316 FROM-IDX and TO-IDX are used internally and should not be touched.
1317 C is the character of the glyph.
1318 CODE is the glyph-code of C in FONT-OBJECT.
1319 WIDTH thru DESCENT are the metrics (in pixels) of the glyph.
1320 X-OFF and Y-OFF are offests to the base position for the glyph.
1321 WADJUST is the adjustment to the normal width of the glyph.
1323 If GLYPH is nil, the remaining elements of the glhph-string vector
1325 (from
, to
, font_object
, string
)
1326 Lisp_Object font_object
, from
, to
, string
;
1328 Lisp_Object gstring
, header
;
1330 if (! NILP (font_object
))
1331 CHECK_FONT_OBJECT (font_object
);
1332 header
= fill_gstring_header (Qnil
, from
, to
, font_object
, string
);
1333 gstring
= gstring_lookup_cache (header
);
1334 if (! NILP (gstring
))
1336 LGSTRING_SET_HEADER (gstring_work
, header
);
1337 LGSTRING_SET_ID (gstring_work
, Qnil
);
1338 fill_gstring_body (gstring_work
);
1339 return gstring_work
;
1343 /* Emacs Lisp APIs. */
1345 DEFUN ("compose-region-internal", Fcompose_region_internal
,
1346 Scompose_region_internal
, 2, 4, 0,
1347 doc
: /* Internal use only.
1349 Compose text in the region between START and END.
1350 Optional 3rd and 4th arguments are COMPONENTS and MODIFICATION-FUNC
1351 for the composition. See `compose-region' for more detail. */)
1352 (start
, end
, components
, modification_func
)
1353 Lisp_Object start
, end
, components
, modification_func
;
1355 validate_region (&start
, &end
);
1356 if (!NILP (components
)
1357 && !INTEGERP (components
)
1358 && !CONSP (components
)
1359 && !STRINGP (components
))
1360 CHECK_VECTOR (components
);
1362 compose_text (XINT (start
), XINT (end
), components
, modification_func
, Qnil
);
1366 DEFUN ("compose-string-internal", Fcompose_string_internal
,
1367 Scompose_string_internal
, 3, 5, 0,
1368 doc
: /* Internal use only.
1370 Compose text between indices START and END of STRING.
1371 Optional 4th and 5th arguments are COMPONENTS and MODIFICATION-FUNC
1372 for the composition. See `compose-string' for more detail. */)
1373 (string
, start
, end
, components
, modification_func
)
1374 Lisp_Object string
, start
, end
, components
, modification_func
;
1376 CHECK_STRING (string
);
1377 CHECK_NUMBER (start
);
1380 if (XINT (start
) < 0 ||
1381 XINT (start
) > XINT (end
)
1382 || XINT (end
) > SCHARS (string
))
1383 args_out_of_range (start
, end
);
1385 compose_text (XINT (start
), XINT (end
), components
, modification_func
, string
);
1389 DEFUN ("find-composition-internal", Ffind_composition_internal
,
1390 Sfind_composition_internal
, 4, 4, 0,
1391 doc
: /* Internal use only.
1393 Return information about composition at or nearest to position POS.
1394 See `find-composition' for more detail. */)
1395 (pos
, limit
, string
, detail_p
)
1396 Lisp_Object pos
, limit
, string
, detail_p
;
1398 Lisp_Object prop
, tail
;
1399 EMACS_INT start
, end
;
1402 CHECK_NUMBER_COERCE_MARKER (pos
);
1406 CHECK_NUMBER_COERCE_MARKER (limit
);
1414 CHECK_STRING (string
);
1415 if (XINT (pos
) < 0 || XINT (pos
) > SCHARS (string
))
1416 args_out_of_range (string
, pos
);
1420 if (XINT (pos
) < BEGV
|| XINT (pos
) > ZV
)
1421 args_out_of_range (Fcurrent_buffer (), pos
);
1424 if (!find_composition (start
, end
, &start
, &end
, &prop
, string
))
1426 if (!COMPOSITION_VALID_P (start
, end
, prop
))
1427 return Fcons (make_number (start
), Fcons (make_number (end
),
1428 Fcons (Qnil
, Qnil
)));
1429 if (NILP (detail_p
))
1430 return Fcons (make_number (start
), Fcons (make_number (end
),
1433 if (COMPOSITION_REGISTERD_P (prop
))
1434 id
= COMPOSITION_ID (prop
);
1437 int start_byte
= (NILP (string
)
1438 ? CHAR_TO_BYTE (start
)
1439 : string_char_to_byte (string
, start
));
1440 id
= get_composition_id (start
, start_byte
, end
- start
, prop
, string
);
1445 Lisp_Object components
, relative_p
, mod_func
;
1446 enum composition_method method
= COMPOSITION_METHOD (prop
);
1447 int width
= composition_table
[id
]->width
;
1449 components
= Fcopy_sequence (COMPOSITION_COMPONENTS (prop
));
1450 relative_p
= (method
== COMPOSITION_WITH_RULE_ALTCHARS
1452 mod_func
= COMPOSITION_MODIFICATION_FUNC (prop
);
1453 tail
= Fcons (components
,
1456 Fcons (make_number (width
), Qnil
))));
1461 return Fcons (make_number (start
), Fcons (make_number (end
), tail
));
1466 syms_of_composite ()
1470 Qcomposition
= intern ("composition");
1471 staticpro (&Qcomposition
);
1473 /* Make a hash table for static composition. */
1475 Lisp_Object args
[6];
1476 extern Lisp_Object QCsize
;
1480 args
[2] = QCweakness
;
1481 /* We used to make the hash table weak so that unreferenced
1482 compositions can be garbage-collected. But, usually once
1483 created compositions are repeatedly used in an Emacs session,
1484 and thus it's not worth to save memory in such a way. So, we
1485 make the table not weak. */
1488 args
[5] = make_number (311);
1489 composition_hash_table
= Fmake_hash_table (6, args
);
1490 staticpro (&composition_hash_table
);
1493 /* Make a hash table for glyph-string. */
1495 Lisp_Object args
[6];
1496 extern Lisp_Object QCsize
;
1500 args
[2] = QCweakness
;
1503 args
[5] = make_number (311);
1504 gstring_hash_table
= Fmake_hash_table (6, args
);
1505 staticpro (&gstring_hash_table
);
1508 staticpro (&gstring_work_headers
);
1509 gstring_work_headers
= Fmake_vector (make_number (8), Qnil
);
1510 for (i
= 0; i
< 8; i
++)
1511 ASET (gstring_work_headers
, i
, Fmake_vector (make_number (i
+ 2), Qnil
));
1512 staticpro (&gstring_work
);
1513 gstring_work
= Fmake_vector (make_number (10), Qnil
);
1515 /* Text property `composition' should be nonsticky by default. */
1516 Vtext_property_default_nonsticky
1517 = Fcons (Fcons (Qcomposition
, Qt
), Vtext_property_default_nonsticky
);
1519 DEFVAR_LISP ("compose-chars-after-function", &Vcompose_chars_after_function
,
1520 doc
: /* Function to adjust composition of buffer text.
1522 The function is called with three arguments FROM, TO, and OBJECT.
1523 FROM and TO specify the range of text of which composition should be
1524 adjusted. OBJECT, if non-nil, is a string that contains the text.
1526 This function is called after a text with `composition' property is
1527 inserted or deleted to keep `composition' property of buffer text
1530 The default value is the function `compose-chars-after'. */);
1531 Vcompose_chars_after_function
= intern ("compose-chars-after");
1533 Qauto_composed
= intern ("auto-composed");
1534 staticpro (&Qauto_composed
);
1536 Qauto_composition_function
= intern ("auto-composition-function");
1537 staticpro (&Qauto_composition_function
);
1539 DEFVAR_LISP ("auto-composition-function", &Vauto_composition_function
,
1540 doc
: /* Function to call to compose characters automatically.
1541 The function is called from the display routine with four arguments,
1542 FROM, TO, WINDOW, and STRING.
1544 If STRING is nil, the function must compose characters in the region
1545 between FROM and TO in the current buffer.
1547 Otherwise, STRING is a string, and FROM and TO are indices into the
1548 string. In this case, the function must compose characters in the
1550 Vauto_composition_function
= Qnil
;
1552 DEFVAR_LISP ("composition-function-table", &Vcomposition_function_table
,
1553 doc
: /* Char-able of functions for automatic character composition.
1554 For each character that has to be composed automatically with
1555 preceding and/or following characters, this char-table contains
1556 a function to call to compose that character.
1558 The element at index C in the table, if non-nil, is a list of
1559 this form: ([PATTERN PREV-CHARS FUNC] ...)
1561 PATTERN is a regular expression with which C and the surrounding
1562 characters must match.
1564 PREV-CHARS is a number of characters before C to check the
1565 matching with PATTERN. If it is 0, PATTERN must match with C and
1566 the following characters. If it is 1, PATTERN must match with a
1567 character before C and the following characters.
1569 If PREV-CHARS is 0, PATTERN can be nil, which means that the
1570 single character C should be composed.
1572 FUNC is a function to return a glyph-string representing a
1573 composition of the characters matching with PATTERN. It is
1574 called with one argument GSTRING.
1576 GSTRING is a template of a glyph-string to return. It is already
1577 filled with a proper header for the characters to compose, and
1578 glyphs corresponding to those characters one by one. The
1579 function must return a new glyph-string of the same header as
1580 GSTRING, or modify GSTRING itself and return it.
1582 See also the documentation of `auto-composition-mode'. */);
1583 Vcomposition_function_table
= Fmake_char_table (Qnil
, Qnil
);
1585 defsubr (&Scompose_region_internal
);
1586 defsubr (&Scompose_string_internal
);
1587 defsubr (&Sfind_composition_internal
);
1588 defsubr (&Scomposition_get_gstring
);
1591 /* arch-tag: 79cefaf8-ca48-4eed-97e5-d5afb290d272
1592 (do not change this comment) */