1 /* Composite sequence support.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006 Free Software Foundation, Inc.
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
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 2, or (at your option)
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; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 Boston, MA 02110-1301, USA. */
31 #include "character.h"
32 #include "intervals.h"
34 /* Emacs uses special text property `composition' to support character
35 composition. A sequence of characters that have the same (i.e. eq)
36 `composition' property value is treated as a single composite
37 sequence (we call it just `composition' here after). Characters in
38 a composition are all composed somehow on the screen.
40 The property value has this form when the composition is made:
41 ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
42 then turns to this form:
43 (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
44 when the composition is registered in composition_hash_table and
45 composition_table. These rather peculiar structures were designed
46 to make it easy to distinguish them quickly (we can do that by
47 checking only the first element) and to extract LENGTH (from the
48 former form) and COMPOSITION-ID (from the latter form).
50 We register a composition when it is displayed, or when the width
51 is required (for instance, to calculate columns).
53 LENGTH -- Length of the composition. This information is used to
54 check the validity of the composition.
56 COMPONENTS -- Character, string, vector, list, or nil.
58 If it is nil, characters in the text are composed relatively
59 according to their metrics in font glyphs.
61 If it is a character or a string, the character or characters
62 in the string are composed relatively.
64 If it is a vector or list of integers, the element is a
65 character or an encoded composition rule. The characters are
66 composed according to the rules. (2N)th elements are
67 characters to be composed and (2N+1)th elements are
68 composition rules to tell how to compose (2N+2)th element with
69 the previously composed 2N glyphs.
71 COMPONENTS-VEC -- Vector of integers. In relative composition, the
72 elements are characters to be composed. In rule-base
73 composition, the elements are characters or encoded
76 MODIFICATION-FUNC -- If non nil, it is a function to call when the
77 composition gets invalid after a modification in a buffer. If
78 it is nil, a function in `composition-function-table' of the
79 first character in the sequence is called.
81 COMPOSITION-ID --Identification number of the composition. It is
82 used as an index to composition_table for the composition.
84 When Emacs has to display a composition or has to know its
85 displaying width, the function get_composition_id is called. It
86 returns COMPOSITION-ID so that the caller can access the
87 information about the composition through composition_table. If a
88 COMPOSITION-ID has not yet been assigned to the composition,
89 get_composition_id checks the validity of `composition' property,
90 and, if valid, assigns a new ID, registers the information in
91 composition_hash_table and composition_table, and changes the form
92 of the property value. If the property is invalid, return -1
93 without changing the property value.
95 We use two tables to keep information about composition;
96 composition_hash_table and composition_table.
98 The former is a hash table in which keys are COMPONENTS-VECs and
99 values are the corresponding COMPOSITION-IDs. This hash table is
100 weak, but as each key (COMPONENTS-VEC) is also kept as a value of the
101 `composition' property, it won't be collected as garbage until all
102 bits of text that have the same COMPONENTS-VEC are deleted.
104 The latter is a table of pointers to `struct composition' indexed
105 by COMPOSITION-ID. This structure keeps the other information (see
108 In general, a text property holds information about individual
109 characters. But, a `composition' property holds information about
110 a sequence of characters (in this sense, it is like the `intangible'
111 property). That means that we should not share the property value
112 in adjacent compositions -- we can't distinguish them if they have the
113 same property. So, after any changes, we call
114 `update_compositions' and change a property of one of adjacent
115 compositions to a copy of it. This function also runs a proper
116 composition modification function to make a composition that gets
117 invalid by the change valid again.
119 As the value of the `composition' property holds information about a
120 specific range of text, the value gets invalid if we change the
121 text in the range. We treat the `composition' property as always
122 rear-nonsticky (currently by setting default-text-properties to
123 (rear-nonsticky (composition))) and we never make properties of
124 adjacent compositions identical. Thus, any such changes make the
125 range just shorter. So, we can check the validity of the `composition'
126 property by comparing LENGTH information with the actual length of
132 Lisp_Object Qcomposition
;
134 /* Table of pointers to the structure `composition' indexed by
135 COMPOSITION-ID. This structure is for storing information about
136 each composition except for COMPONENTS-VEC. */
137 struct composition
**composition_table
;
139 /* The current size of `composition_table'. */
140 static int composition_table_size
;
142 /* Number of compositions currently made. */
145 /* Hash table for compositions. The key is COMPONENTS-VEC of
146 `composition' property. The value is the corresponding
148 Lisp_Object composition_hash_table
;
150 /* Function to call to adjust composition. */
151 Lisp_Object Vcompose_chars_after_function
;
153 Lisp_Object Qauto_composed
;
154 Lisp_Object Vauto_composition_function
;
155 Lisp_Object Qauto_composition_function
;
157 EXFUN (Fremove_list_of_text_properties
, 4);
159 /* Temporary variable used in macros COMPOSITION_XXX. */
160 Lisp_Object composition_temp
;
162 /* Return COMPOSITION-ID of a composition at buffer position
163 CHARPOS/BYTEPOS and length NCHARS. The `composition' property of
164 the sequence is PROP. STRING, if non-nil, is a string that
165 contains the composition instead of the current buffer.
167 If the composition is invalid, return -1. */
170 get_composition_id (charpos
, bytepos
, nchars
, prop
, string
)
171 int charpos
, bytepos
, nchars
;
172 Lisp_Object prop
, string
;
174 Lisp_Object id
, length
, components
, key
, *key_contents
;
176 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (composition_hash_table
);
179 struct composition
*cmp
;
183 Form-A: ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
185 Form-B: (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
187 if (nchars
== 0 || !CONSP (prop
))
188 goto invalid_composition
;
193 /* PROP should be Form-B. */
194 if (XINT (id
) < 0 || XINT (id
) >= n_compositions
)
195 goto invalid_composition
;
199 /* PROP should be Form-A.
200 Thus, ID should be (LENGTH . COMPONENTS). */
202 goto invalid_composition
;
204 if (!INTEGERP (length
) || XINT (length
) != nchars
)
205 goto invalid_composition
;
207 components
= XCDR (id
);
209 /* Check if the same composition has already been registered or not
210 by consulting composition_hash_table. The key for this table is
211 COMPONENTS (converted to a vector COMPONENTS-VEC) or, if it is
212 nil, vector of characters in the composition range. */
213 if (INTEGERP (components
))
214 key
= Fmake_vector (make_number (1), components
);
215 else if (STRINGP (components
) || CONSP (components
))
216 key
= Fvconcat (1, &components
);
217 else if (VECTORP (components
))
219 else if (NILP (components
))
221 key
= Fmake_vector (make_number (nchars
), Qnil
);
222 if (STRINGP (string
))
223 for (i
= 0; i
< nchars
; i
++)
225 FETCH_STRING_CHAR_ADVANCE (ch
, string
, charpos
, bytepos
);
226 XVECTOR (key
)->contents
[i
] = make_number (ch
);
229 for (i
= 0; i
< nchars
; i
++)
231 FETCH_CHAR_ADVANCE (ch
, charpos
, bytepos
);
232 XVECTOR (key
)->contents
[i
] = make_number (ch
);
236 goto invalid_composition
;
238 hash_index
= hash_lookup (hash_table
, key
, &hash_code
);
241 /* We have already registered the same composition. Change PROP
242 from Form-A above to Form-B while replacing COMPONENTS with
243 COMPONENTS-VEC stored in the hash table. We can directly
244 modify the cons cell of PROP because it is not shared. */
245 key
= HASH_KEY (hash_table
, hash_index
);
246 id
= HASH_VALUE (hash_table
, hash_index
);
248 XSETCDR (prop
, Fcons (make_number (nchars
), Fcons (key
, XCDR (prop
))));
252 /* This composition is a new one. We must register it. */
254 /* Check if we have sufficient memory to store this information. */
255 if (composition_table_size
== 0)
257 composition_table_size
= 256;
259 = (struct composition
**) xmalloc (sizeof (composition_table
[0])
260 * composition_table_size
);
262 else if (composition_table_size
<= n_compositions
)
264 composition_table_size
+= 256;
266 = (struct composition
**) xrealloc (composition_table
,
267 sizeof (composition_table
[0])
268 * composition_table_size
);
271 key_contents
= XVECTOR (key
)->contents
;
273 /* Check if the contents of COMPONENTS are valid if COMPONENTS is a
274 vector or a list. It should be a sequence of:
275 char1 rule1 char2 rule2 char3 ... ruleN charN+1 */
276 if (VECTORP (components
) || CONSP (components
))
278 int len
= XVECTOR (key
)->size
;
280 /* The number of elements should be odd. */
282 goto invalid_composition
;
283 /* All elements should be integers (character or encoded
284 composition rule). */
285 for (i
= 0; i
< len
; i
++)
287 if (!INTEGERP (key_contents
[i
]))
288 goto invalid_composition
;
292 /* Change PROP from Form-A above to Form-B. We can directly modify
293 the cons cell of PROP because it is not shared. */
294 XSETFASTINT (id
, n_compositions
);
296 XSETCDR (prop
, Fcons (make_number (nchars
), Fcons (key
, XCDR (prop
))));
298 /* Register the composition in composition_hash_table. */
299 hash_index
= hash_put (hash_table
, key
, id
, hash_code
);
301 /* Register the composition in composition_table. */
302 cmp
= (struct composition
*) xmalloc (sizeof (struct composition
));
304 cmp
->method
= (NILP (components
)
305 ? COMPOSITION_RELATIVE
306 : ((INTEGERP (components
) || STRINGP (components
))
307 ? COMPOSITION_WITH_ALTCHARS
308 : COMPOSITION_WITH_RULE_ALTCHARS
));
309 cmp
->hash_index
= hash_index
;
310 glyph_len
= (cmp
->method
== COMPOSITION_WITH_RULE_ALTCHARS
311 ? (XVECTOR (key
)->size
+ 1) / 2
312 : XVECTOR (key
)->size
);
313 cmp
->glyph_len
= glyph_len
;
314 cmp
->offsets
= (short *) xmalloc (sizeof (short) * glyph_len
* 2);
317 /* Calculate the width of overall glyphs of the composition. */
318 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
320 /* Relative composition. */
322 for (i
= 0; i
< glyph_len
; i
++)
325 ch
= XINT (key_contents
[i
]);
326 this_width
= CHAR_WIDTH (ch
);
327 if (cmp
->width
< this_width
)
328 cmp
->width
= this_width
;
333 /* Rule-base composition. */
334 float leftmost
= 0.0, rightmost
;
336 ch
= XINT (key_contents
[0]);
337 rightmost
= CHAR_WIDTH (ch
);
339 for (i
= 1; i
< glyph_len
; i
+= 2)
341 int rule
, gref
, nref
, xoff
, yoff
;
345 rule
= XINT (key_contents
[i
]);
346 ch
= XINT (key_contents
[i
+ 1]);
347 this_width
= CHAR_WIDTH (ch
);
349 /* A composition rule is specified by an integer value
350 that encodes global and new reference points (GREF and
351 NREF). GREF and NREF are specified by numbers as
359 ---3---4---5--- baseline
363 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
364 this_left
= (leftmost
365 + (gref
% 3) * (rightmost
- leftmost
) / 2.0
366 - (nref
% 3) * this_width
/ 2.0);
368 if (this_left
< leftmost
)
369 leftmost
= this_left
;
370 if (this_left
+ this_width
> rightmost
)
371 rightmost
= this_left
+ this_width
;
374 cmp
->width
= rightmost
- leftmost
;
375 if (cmp
->width
< (rightmost
- leftmost
))
376 /* To get a ceiling integer value. */
380 composition_table
[n_compositions
] = cmp
;
382 return n_compositions
++;
385 /* Would it be better to remove this `composition' property? */
390 /* Find a composition at or nearest to position POS of OBJECT (buffer
393 OBJECT defaults to the current buffer. If there's a composition at
394 POS, set *START and *END to the start and end of the sequence,
395 *PROP to the `composition' property, and return 1.
397 If there's no composition at POS and LIMIT is negative, return 0.
399 Otherwise, search for a composition forward (LIMIT > POS) or
400 backward (LIMIT < POS). In this case, LIMIT bounds the search.
402 If a composition is found, set *START, *END, and *PROP as above,
403 and return 1, else return 0.
405 This doesn't check the validity of composition. */
408 find_composition (pos
, limit
, start
, end
, prop
, object
)
410 EMACS_INT
*start
, *end
;
411 Lisp_Object
*prop
, object
;
415 if (get_property_and_range (pos
, Qcomposition
, prop
, start
, end
, object
))
418 if (limit
< 0 || limit
== pos
)
421 if (limit
> pos
) /* search forward */
423 val
= Fnext_single_property_change (make_number (pos
), Qcomposition
,
424 object
, make_number (limit
));
429 else /* search backward */
431 if (get_property_and_range (pos
- 1, Qcomposition
, prop
, start
, end
,
434 val
= Fprevious_single_property_change (make_number (pos
), Qcomposition
,
435 object
, make_number (limit
));
441 get_property_and_range (pos
, Qcomposition
, prop
, start
, end
, object
);
445 /* Run a proper function to adjust the composition sitting between
446 FROM and TO with property PROP. */
449 run_composition_function (from
, to
, prop
)
454 EMACS_INT start
, end
;
456 func
= COMPOSITION_MODIFICATION_FUNC (prop
);
457 /* If an invalid composition precedes or follows, try to make them
460 && find_composition (from
- 1, -1, &start
, &end
, &prop
, Qnil
)
461 && !COMPOSITION_VALID_P (start
, end
, prop
))
464 && find_composition (to
, -1, &start
, &end
, &prop
, Qnil
)
465 && !COMPOSITION_VALID_P (start
, end
, prop
))
467 if (!NILP (Ffboundp (func
)))
468 call2 (func
, make_number (from
), make_number (to
));
471 /* Make invalid compositions adjacent to or inside FROM and TO valid.
472 CHECK_MASK is bitwise `or' of mask bits defined by macros
473 CHECK_XXX (see the comment in composite.h).
475 It also resets the text-property `auto-composed' to a proper region
476 so that automatic character composition works correctly later while
477 displaying the region.
479 This function is called when a buffer text is changed. If the
480 change is deletion, FROM == TO. Otherwise, FROM < TO. */
483 update_compositions (from
, to
, check_mask
)
488 EMACS_INT start
, end
;
489 /* The beginning and end of the region to set the property
490 `auto-composed' to nil. */
491 EMACS_INT min_pos
= from
, max_pos
= to
;
493 if (inhibit_modification_hooks
)
496 /* If FROM and TO are not in a valid range, do nothing. */
497 if (! (BEGV
<= from
&& from
<= to
&& to
<= ZV
))
500 if (check_mask
& CHECK_HEAD
)
502 /* FROM should be at composition boundary. But, insertion or
503 deletion will make two compositions adjacent and
504 indistinguishable when they have same (eq) property. To
505 avoid it, in such a case, we change the property of the
506 latter to the copy of it. */
508 && find_composition (from
- 1, -1, &start
, &end
, &prop
, Qnil
))
514 Fput_text_property (make_number (from
), make_number (end
),
516 Fcons (XCAR (prop
), XCDR (prop
)), Qnil
);
517 run_composition_function (start
, end
, prop
);
521 && find_composition (from
, -1, &start
, &from
, &prop
, Qnil
))
525 run_composition_function (start
, from
, prop
);
529 if (check_mask
& CHECK_INSIDE
)
531 /* In this case, we are sure that (check & CHECK_TAIL) is also
532 nonzero. Thus, here we should check only compositions before
535 && find_composition (from
, to
, &start
, &from
, &prop
, Qnil
)
537 run_composition_function (start
, from
, prop
);
540 if (check_mask
& CHECK_TAIL
)
543 && find_composition (to
- 1, -1, &start
, &end
, &prop
, Qnil
))
545 /* TO should be also at composition boundary. But,
546 insertion or deletion will make two compositions adjacent
547 and indistinguishable when they have same (eq) property.
548 To avoid it, in such a case, we change the property of
549 the former to the copy of it. */
552 Fput_text_property (make_number (start
), make_number (to
),
554 Fcons (XCAR (prop
), XCDR (prop
)), Qnil
);
557 run_composition_function (start
, end
, prop
);
560 && find_composition (to
, -1, &start
, &end
, &prop
, Qnil
))
562 run_composition_function (start
, end
, prop
);
566 if (min_pos
< max_pos
)
568 int count
= SPECPDL_INDEX ();
570 specbind (Qinhibit_read_only
, Qt
);
571 specbind (Qinhibit_modification_hooks
, Qt
);
572 specbind (Qinhibit_point_motion_hooks
, Qt
);
573 Fremove_list_of_text_properties (make_number (min_pos
),
574 make_number (max_pos
),
575 Fcons (Qauto_composed
, Qnil
), Qnil
);
576 unbind_to (count
, Qnil
);
581 /* Modify composition property values in LIST destructively. LIST is
582 a list as returned from text_property_list. Change values to the
583 top-level copies of them so that none of them are `eq'. */
586 make_composition_value_copy (list
)
589 Lisp_Object plist
, val
;
591 for (; CONSP (list
); list
= XCDR (list
))
593 plist
= XCAR (XCDR (XCDR (XCAR (list
))));
594 while (CONSP (plist
) && CONSP (XCDR (plist
)))
596 if (EQ (XCAR (plist
), Qcomposition
)
597 && (val
= XCAR (XCDR (plist
)), CONSP (val
)))
598 XSETCAR (XCDR (plist
), Fcons (XCAR (val
), XCDR (val
)));
599 plist
= XCDR (XCDR (plist
));
605 /* Make text in the region between START and END a composition that
606 has COMPONENTS and MODIFICATION-FUNC.
608 If STRING is non-nil, then operate on characters contained between
609 indices START and END in STRING. */
612 compose_text (start
, end
, components
, modification_func
, string
)
614 Lisp_Object components
, modification_func
, string
;
618 prop
= Fcons (Fcons (make_number (end
- start
), components
),
620 Fput_text_property (make_number (start
), make_number (end
),
621 Qcomposition
, prop
, string
);
624 /* Emacs Lisp APIs. */
626 DEFUN ("compose-region-internal", Fcompose_region_internal
,
627 Scompose_region_internal
, 2, 4, 0,
628 doc
: /* Internal use only.
630 Compose text in the region between START and END.
631 Optional 3rd and 4th arguments are COMPONENTS and MODIFICATION-FUNC
632 for the composition. See `compose-region' for more detail. */)
633 (start
, end
, components
, modification_func
)
634 Lisp_Object start
, end
, components
, modification_func
;
636 validate_region (&start
, &end
);
637 if (!NILP (components
)
638 && !INTEGERP (components
)
639 && !CONSP (components
)
640 && !STRINGP (components
))
641 CHECK_VECTOR (components
);
643 compose_text (XINT (start
), XINT (end
), components
, modification_func
, Qnil
);
647 DEFUN ("compose-string-internal", Fcompose_string_internal
,
648 Scompose_string_internal
, 3, 5, 0,
649 doc
: /* Internal use only.
651 Compose text between indices START and END of STRING.
652 Optional 4th and 5th arguments are COMPONENTS and MODIFICATION-FUNC
653 for the composition. See `compose-string' for more detail. */)
654 (string
, start
, end
, components
, modification_func
)
655 Lisp_Object string
, start
, end
, components
, modification_func
;
657 CHECK_STRING (string
);
658 CHECK_NUMBER (start
);
661 if (XINT (start
) < 0 ||
662 XINT (start
) > XINT (end
)
663 || XINT (end
) > SCHARS (string
))
664 args_out_of_range (start
, end
);
666 compose_text (XINT (start
), XINT (end
), components
, modification_func
, string
);
670 DEFUN ("find-composition-internal", Ffind_composition_internal
,
671 Sfind_composition_internal
, 4, 4, 0,
672 doc
: /* Internal use only.
674 Return information about composition at or nearest to position POS.
675 See `find-composition' for more detail. */)
676 (pos
, limit
, string
, detail_p
)
677 Lisp_Object pos
, limit
, string
, detail_p
;
679 Lisp_Object prop
, tail
;
680 EMACS_INT start
, end
;
683 CHECK_NUMBER_COERCE_MARKER (pos
);
687 CHECK_NUMBER_COERCE_MARKER (limit
);
695 CHECK_STRING (string
);
696 if (XINT (pos
) < 0 || XINT (pos
) > SCHARS (string
))
697 args_out_of_range (string
, pos
);
701 if (XINT (pos
) < BEGV
|| XINT (pos
) > ZV
)
702 args_out_of_range (Fcurrent_buffer (), pos
);
705 if (!find_composition (start
, end
, &start
, &end
, &prop
, string
))
707 if (!COMPOSITION_VALID_P (start
, end
, prop
))
708 return Fcons (make_number (start
), Fcons (make_number (end
),
709 Fcons (Qnil
, Qnil
)));
711 return Fcons (make_number (start
), Fcons (make_number (end
),
714 if (COMPOSITION_REGISTERD_P (prop
))
715 id
= COMPOSITION_ID (prop
);
718 int start_byte
= (NILP (string
)
719 ? CHAR_TO_BYTE (start
)
720 : string_char_to_byte (string
, start
));
721 id
= get_composition_id (start
, start_byte
, end
- start
, prop
, string
);
726 Lisp_Object components
, relative_p
, mod_func
;
727 enum composition_method method
= COMPOSITION_METHOD (prop
);
728 int width
= composition_table
[id
]->width
;
730 components
= Fcopy_sequence (COMPOSITION_COMPONENTS (prop
));
731 relative_p
= (method
== COMPOSITION_WITH_RULE_ALTCHARS
733 mod_func
= COMPOSITION_MODIFICATION_FUNC (prop
);
734 tail
= Fcons (components
,
737 Fcons (make_number (width
), Qnil
))));
742 return Fcons (make_number (start
), Fcons (make_number (end
), tail
));
749 Qcomposition
= intern ("composition");
750 staticpro (&Qcomposition
);
752 /* Make a hash table for composition. */
755 extern Lisp_Object QCsize
;
759 args
[2] = QCweakness
;
760 /* We used to make the hash table weak so that unreferenced
761 compostions can be garbage-collected. But, usually once
762 created compositions are repeatedly used in an Emacs session,
763 and thus it's not worth to save memory in such a way. So, we
764 make the table not weak. */
767 args
[5] = make_number (311);
768 composition_hash_table
= Fmake_hash_table (6, args
);
769 staticpro (&composition_hash_table
);
772 /* Text property `composition' should be nonsticky by default. */
773 Vtext_property_default_nonsticky
774 = Fcons (Fcons (Qcomposition
, Qt
), Vtext_property_default_nonsticky
);
776 DEFVAR_LISP ("compose-chars-after-function", &Vcompose_chars_after_function
,
777 doc
: /* Function to adjust composition of buffer text.
779 The function is called with three arguments FROM, TO, and OBJECT.
780 FROM and TO specify the range of text of which composition should be
781 adjusted. OBJECT, if non-nil, is a string that contains the text.
783 This function is called after a text with `composition' property is
784 inserted or deleted to keep `composition' property of buffer text
787 The default value is the function `compose-chars-after'. */);
788 Vcompose_chars_after_function
= intern ("compose-chars-after");
790 Qauto_composed
= intern ("auto-composed");
791 staticpro (&Qauto_composed
);
793 Qauto_composition_function
= intern ("auto-composition-function");
794 staticpro (&Qauto_composition_function
);
796 DEFVAR_LISP ("auto-composition-function", &Vauto_composition_function
,
797 doc
: /* Function to call to compose characters automatically.
798 The function is called from the display routine with two arguments,
801 If STRING is nil, the function must compose characters following POS
802 in the current buffer.
804 Otherwise, STRING is a string, and POS is an index to the string. In
805 this case, the function must compose characters following POS in
807 Vauto_composition_function
= Qnil
;
809 defsubr (&Scompose_region_internal
);
810 defsubr (&Scompose_string_internal
);
811 defsubr (&Sfind_composition_internal
);
814 /* arch-tag: 79cefaf8-ca48-4eed-97e5-d5afb290d272
815 (do not change this comment) */