1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
25 #include "intervals.h"
27 #include "character.h"
29 #include "blockinput.h"
30 #include "region-cache.h"
36 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
37 static void insert_from_buffer_1 ();
38 static void gap_left
P_ ((int, int, int));
39 static void gap_right
P_ ((int, int));
40 static void adjust_markers_gap_motion
P_ ((int, int, int));
41 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
42 void adjust_markers_for_delete
P_ ((int, int, int, int));
43 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
44 static void adjust_point
P_ ((int, int));
46 Lisp_Object
Fcombine_after_change_execute ();
48 /* Non-nil means don't call the after-change-functions right away,
49 just record an element in Vcombine_after_change_calls_list. */
50 Lisp_Object Vcombine_after_change_calls
;
52 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
53 describing changes which happened while combine_after_change_calls
54 was nonzero. We use this to decide how to call them
55 once the deferral ends.
58 BEG-UNCHANGED is the number of chars before the changed range.
59 END-UNCHANGED is the number of chars after the changed range,
60 and CHANGE-AMOUNT is the number of characters inserted by the change
61 (negative for a deletion). */
62 Lisp_Object combine_after_change_list
;
64 /* Buffer which combine_after_change_list is about. */
65 Lisp_Object combine_after_change_buffer
;
67 Lisp_Object Qinhibit_modification_hooks
;
70 /* Check all markers in the current buffer, looking for something invalid. */
72 static int check_markers_debug_flag
;
74 #define CHECK_MARKERS() \
75 if (check_markers_debug_flag) \
82 register struct Lisp_Marker
*tail
;
83 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
85 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
87 if (tail
->buffer
->text
!= current_buffer
->text
)
89 if (tail
->charpos
> Z
)
91 if (tail
->bytepos
> Z_BYTE
)
93 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
98 /* Move gap to position CHARPOS.
99 Note that this can quit! */
105 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
108 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
109 Note that this can quit! */
112 move_gap_both (charpos
, bytepos
)
113 int charpos
, bytepos
;
115 if (bytepos
< GPT_BYTE
)
116 gap_left (charpos
, bytepos
, 0);
117 else if (bytepos
> GPT_BYTE
)
118 gap_right (charpos
, bytepos
);
121 /* Move the gap to a position less than the current GPT.
122 BYTEPOS describes the new position as a byte position,
123 and CHARPOS is the corresponding char position.
124 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
127 gap_left (charpos
, bytepos
, newgap
)
128 register int charpos
, bytepos
;
131 register unsigned char *to
, *from
;
136 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
143 /* Now copy the characters. To move the gap down,
144 copy characters up. */
148 /* I gets number of characters left to copy. */
149 i
= new_s1
- bytepos
;
152 /* If a quit is requested, stop copying now.
153 Change BYTEPOS to be where we have actually moved the gap to. */
157 charpos
= BYTE_TO_CHAR (bytepos
);
160 /* Move at most 32000 chars before checking again for a quit. */
165 /* bcopy is safe if the two areas of memory do not overlap
166 or on systems where bcopy is always safe for moving upward. */
167 && (BCOPY_UPWARD_SAFE
168 || to
- from
>= 128))
170 /* If overlap is not safe, avoid it by not moving too many
171 characters at once. */
172 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
187 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
188 BYTEPOS is where the loop above stopped, which may be what was specified
189 or may be where a quit was detected. */
190 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
193 if (bytepos
< charpos
)
195 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
199 /* Move the gap to a position greater than than the current GPT.
200 BYTEPOS describes the new position as a byte position,
201 and CHARPOS is the corresponding char position. */
204 gap_right (charpos
, bytepos
)
205 register int charpos
, bytepos
;
207 register unsigned char *to
, *from
;
211 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
218 /* Now copy the characters. To move the gap up,
219 copy characters down. */
223 /* I gets number of characters left to copy. */
224 i
= bytepos
- new_s1
;
227 /* If a quit is requested, stop copying now.
228 Change BYTEPOS to be where we have actually moved the gap to. */
232 charpos
= BYTE_TO_CHAR (bytepos
);
235 /* Move at most 32000 chars before checking again for a quit. */
240 /* bcopy is safe if the two areas of memory do not overlap
241 or on systems where bcopy is always safe for moving downward. */
242 && (BCOPY_DOWNWARD_SAFE
243 || from
- to
>= 128))
245 /* If overlap is not safe, avoid it by not moving too many
246 characters at once. */
247 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
262 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
266 if (bytepos
< charpos
)
268 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
272 /* Add AMOUNT to the byte position of every marker in the current buffer
273 whose current byte position is between FROM (exclusive) and TO (inclusive).
275 Also, any markers past the outside of that interval, in the direction
276 of adjustment, are first moved back to the near end of the interval
277 and then adjusted by AMOUNT.
279 When the latter adjustment is done, if AMOUNT is negative,
280 we record the adjustment for undo. (This case happens only for
283 The markers' character positions are not altered,
284 because gap motion does not affect character positions. */
286 int adjust_markers_test
;
289 adjust_markers_gap_motion (from
, to
, amount
)
290 register int from
, to
, amount
;
292 /* Now that a marker has a bytepos, not counting the gap,
293 nothing needs to be done here. */
296 register struct Lisp_Marker
*m
;
299 marker
= BUF_MARKERS (current_buffer
);
301 while (!NILP (marker
))
303 m
= XMARKER (marker
);
307 if (mpos
> to
&& mpos
< to
+ amount
)
309 if (adjust_markers_test
)
316 /* Here's the case where a marker is inside text being deleted.
317 AMOUNT can be negative for gap motion, too,
318 but then this range contains no markers. */
319 if (mpos
> from
+ amount
&& mpos
<= from
)
321 if (adjust_markers_test
)
323 mpos
= from
+ amount
;
326 if (mpos
> from
&& mpos
<= to
)
334 /* Adjust all markers for a deletion
335 whose range in bytes is FROM_BYTE to TO_BYTE.
336 The range in charpos is FROM to TO.
338 This function assumes that the gap is adjacent to
339 or inside of the range being deleted. */
342 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
343 register int from
, from_byte
, to
, to_byte
;
346 register struct Lisp_Marker
*m
;
347 register int charpos
;
349 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
351 charpos
= m
->charpos
;
356 /* If the marker is after the deletion,
357 relocate by number of chars / bytes deleted. */
360 m
->charpos
-= to
- from
;
361 m
->bytepos
-= to_byte
- from_byte
;
363 /* Here's the case where a marker is inside text being deleted. */
364 else if (charpos
> from
)
366 if (! m
->insertion_type
)
367 { /* Normal markers will end up at the beginning of the
368 re-inserted text after undoing a deletion, and must be
369 adjusted to move them to the correct place. */
370 XSETMISC (marker
, m
);
371 record_marker_adjustment (marker
, from
- charpos
);
373 else if (charpos
< to
)
374 { /* Before-insertion markers will automatically move forward
375 upon re-inserting the deleted text, so we have to arrange
376 for them to move backward to the correct position. */
377 XSETMISC (marker
, m
);
378 record_marker_adjustment (marker
, charpos
- to
);
381 m
->bytepos
= from_byte
;
383 /* Here's the case where a before-insertion marker is immediately
384 before the deleted region. */
385 else if (charpos
== from
&& m
->insertion_type
)
387 /* Undoing the change uses normal insertion, which will
388 incorrectly make MARKER move forward, so we arrange for it
389 to then move backward to the correct place at the beginning
390 of the deleted region. */
391 XSETMISC (marker
, m
);
392 record_marker_adjustment (marker
, to
- from
);
398 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
399 to TO / TO_BYTE. We have to relocate the charpos of every marker
400 that points after the insertion (but not their bytepos).
402 When a marker points at the insertion point,
403 we advance it if either its insertion-type is t
404 or BEFORE_MARKERS is true. */
407 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
408 register int from
, from_byte
, to
, to_byte
;
411 struct Lisp_Marker
*m
;
413 int nchars
= to
- from
;
414 int nbytes
= to_byte
- from_byte
;
416 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
418 /* In a single-byte buffer, a marker's two positions must be
422 if (m
->charpos
!= m
->bytepos
)
426 if (m
->bytepos
== from_byte
)
428 if (m
->insertion_type
|| before_markers
)
430 m
->bytepos
= to_byte
;
432 if (m
->insertion_type
)
436 else if (m
->bytepos
> from_byte
)
438 m
->bytepos
+= nbytes
;
439 m
->charpos
+= nchars
;
443 /* Adjusting only markers whose insertion-type is t may result in
444 - disordered start and end in overlays, and
445 - disordered overlays in the slot `overlays_before' of current_buffer. */
448 fix_start_end_in_overlays(from
, to
);
449 fix_overlays_before (current_buffer
, from
, to
);
453 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
455 This is used only when the value of point changes due to an insert
456 or delete; it does not represent a conceptual change in point as a
457 marker. In particular, point is not crossing any interval
458 boundaries, so there's no need to use the usual SET_PT macro. In
459 fact it would be incorrect to do so, because either the old or the
460 new value of point is out of sync with the current set of
464 adjust_point (nchars
, nbytes
)
467 BUF_PT (current_buffer
) += nchars
;
468 BUF_PT_BYTE (current_buffer
) += nbytes
;
470 /* In a single-byte buffer, the two positions must be equal. */
476 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
477 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
478 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
482 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
483 new_chars
, new_bytes
)
484 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
486 register struct Lisp_Marker
*m
;
487 int prev_to_byte
= from_byte
+ old_bytes
;
488 int diff_chars
= new_chars
- old_chars
;
489 int diff_bytes
= new_bytes
- old_bytes
;
491 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
493 if (m
->bytepos
>= prev_to_byte
)
495 m
->charpos
+= diff_chars
;
496 m
->bytepos
+= diff_bytes
;
498 else if (m
->bytepos
> from_byte
)
501 m
->bytepos
= from_byte
;
509 /* Make the gap NBYTES_ADDED bytes longer. */
512 make_gap_larger (nbytes_added
)
517 int real_gap_loc_byte
;
520 /* If we have to get more space, get enough to last a while. */
521 nbytes_added
+= 2000;
523 /* Don't allow a buffer size that won't fit in an int
524 even if it will fit in a Lisp integer.
525 That won't work because so many places use `int'.
527 Make sure we don't introduce overflows in the calculation. */
529 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
530 >= (((EMACS_INT
) 1 << (min (VALBITS
, BITS_PER_INT
) - 1)) - 1
532 error ("Buffer exceeds maximum size");
534 enlarge_buffer_text (current_buffer
, nbytes_added
);
536 /* Prevent quitting in move_gap. */
541 real_gap_loc_byte
= GPT_BYTE
;
542 old_gap_size
= GAP_SIZE
;
544 /* Call the newly allocated space a gap at the end of the whole space. */
546 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
547 GAP_SIZE
= nbytes_added
;
549 /* Move the new gap down to be consecutive with the end of the old one.
550 This adjusts the markers properly too. */
551 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
553 /* Now combine the two into one large gap. */
554 GAP_SIZE
+= old_gap_size
;
556 GPT_BYTE
= real_gap_loc_byte
;
565 /* Make the gap NBYTES_REMOVED bytes shorter. */
568 make_gap_smaller (nbytes_removed
)
573 int real_gap_loc_byte
;
576 int real_beg_unchanged
;
579 /* Make sure the gap is at least 20 bytes. */
580 if (GAP_SIZE
- nbytes_removed
< 20)
581 nbytes_removed
= GAP_SIZE
- 20;
583 /* Prevent quitting in move_gap. */
588 real_gap_loc_byte
= GPT_BYTE
;
589 new_gap_size
= GAP_SIZE
- nbytes_removed
;
591 real_Z_byte
= Z_BYTE
;
592 real_beg_unchanged
= BEG_UNCHANGED
;
594 /* Pretend that the last unwanted part of the gap is the entire gap,
595 and that the first desired part of the gap is part of the buffer
597 bzero (GPT_ADDR
, new_gap_size
);
599 GPT_BYTE
+= new_gap_size
;
601 Z_BYTE
+= new_gap_size
;
602 GAP_SIZE
= nbytes_removed
;
604 /* Move the unwanted pretend gap to the end of the buffer. This
605 adjusts the markers properly too. */
606 gap_right (Z
, Z_BYTE
);
608 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
610 /* Now restore the desired gap. */
611 GAP_SIZE
= new_gap_size
;
613 GPT_BYTE
= real_gap_loc_byte
;
615 Z_BYTE
= real_Z_byte
;
616 BEG_UNCHANGED
= real_beg_unchanged
;
625 make_gap (nbytes_added
)
628 if (nbytes_added
>= 0)
629 make_gap_larger (nbytes_added
);
630 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
632 make_gap_smaller (-nbytes_added
);
636 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
637 FROM_MULTIBYTE says whether the incoming text is multibyte.
638 TO_MULTIBYTE says whether to store the text as multibyte.
639 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
641 Return the number of bytes stored at TO_ADDR. */
644 copy_text (from_addr
, to_addr
, nbytes
,
645 from_multibyte
, to_multibyte
)
646 const unsigned char *from_addr
;
647 unsigned char *to_addr
;
649 int from_multibyte
, to_multibyte
;
651 if (from_multibyte
== to_multibyte
)
653 bcopy (from_addr
, to_addr
, nbytes
);
656 else if (from_multibyte
)
659 int bytes_left
= nbytes
;
660 Lisp_Object tbl
= Qnil
;
662 while (bytes_left
> 0)
665 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
666 if (!ASCII_CHAR_P (c
))
667 c
= multibyte_char_to_unibyte (c
, tbl
);
669 from_addr
+= thislen
;
670 bytes_left
-= thislen
;
677 unsigned char *initial_to_addr
= to_addr
;
679 /* Convert single-byte to multibyte. */
682 int c
= *from_addr
++;
686 c
= unibyte_char_to_multibyte (c
);
687 to_addr
+= CHAR_STRING (c
, to_addr
);
691 /* Special case for speed. */
692 *to_addr
++ = c
, nbytes
--;
694 return to_addr
- initial_to_addr
;
698 /* Return the number of bytes it would take
699 to convert some single-byte text to multibyte.
700 The single-byte text consists of NBYTES bytes at PTR. */
703 count_size_as_multibyte (ptr
, nbytes
)
704 const unsigned char *ptr
;
708 int outgoing_nbytes
= 0;
710 for (i
= 0; i
< nbytes
; i
++)
712 unsigned int c
= *ptr
++;
718 c
= unibyte_char_to_multibyte (c
);
719 outgoing_nbytes
+= CHAR_BYTES (c
);
723 return outgoing_nbytes
;
726 /* Insert a string of specified length before point.
727 This function judges multibyteness based on
728 enable_multibyte_characters in the current buffer;
729 it never converts between single-byte and multibyte.
731 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
732 prepare_to_modify_buffer could relocate the text. */
735 insert (string
, nbytes
)
736 register const unsigned char *string
;
741 int len
= chars_in_text (string
, nbytes
), opoint
;
742 insert_1_both (string
, len
, nbytes
, 0, 1, 0);
744 signal_after_change (opoint
, 0, len
);
745 update_compositions (opoint
, PT
, CHECK_BORDER
);
749 /* Likewise, but inherit text properties from neighboring characters. */
752 insert_and_inherit (string
, nbytes
)
753 register const unsigned char *string
;
758 int len
= chars_in_text (string
, nbytes
), opoint
;
759 insert_1_both (string
, len
, nbytes
, 1, 1, 0);
761 signal_after_change (opoint
, 0, len
);
762 update_compositions (opoint
, PT
, CHECK_BORDER
);
766 /* Insert the character C before point. Do not inherit text properties. */
772 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
775 if (! NILP (current_buffer
->enable_multibyte_characters
))
776 len
= CHAR_STRING (c
, str
);
786 /* Insert the null-terminated string S before point. */
792 insert (s
, strlen (s
));
795 /* Like `insert' except that all markers pointing at the place where
796 the insertion happens are adjusted to point after it.
797 Don't use this function to insert part of a Lisp string,
798 since gc could happen and relocate it. */
801 insert_before_markers (string
, nbytes
)
802 const unsigned char *string
;
807 int len
= chars_in_text (string
, nbytes
), opoint
;
808 insert_1_both (string
, len
, nbytes
, 0, 1, 1);
810 signal_after_change (opoint
, 0, len
);
811 update_compositions (opoint
, PT
, CHECK_BORDER
);
815 /* Likewise, but inherit text properties from neighboring characters. */
818 insert_before_markers_and_inherit (string
, nbytes
)
819 const unsigned char *string
;
824 int len
= chars_in_text (string
, nbytes
), opoint
;
825 insert_1_both (string
, len
, nbytes
, 1, 1, 1);
827 signal_after_change (opoint
, 0, len
);
828 update_compositions (opoint
, PT
, CHECK_BORDER
);
832 /* Subroutine used by the insert functions above. */
835 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
836 register const unsigned char *string
;
838 int inherit
, prepare
, before_markers
;
840 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
841 inherit
, prepare
, before_markers
);
845 #ifdef BYTE_COMBINING_DEBUG
847 /* See if the bytes before POS/POS_BYTE combine with bytes
848 at the start of STRING to form a single character.
849 If so, return the number of bytes at the start of STRING
850 which combine in this way. Otherwise, return 0. */
853 count_combining_before (string
, length
, pos
, pos_byte
)
854 const unsigned char *string
;
858 int len
, combining_bytes
;
859 const unsigned char *p
;
861 if (NILP (current_buffer
->enable_multibyte_characters
))
864 /* At first, we can exclude the following cases:
865 (1) STRING[0] can't be a following byte of multibyte sequence.
866 (2) POS is the start of the current buffer.
867 (3) A character before POS is not a multibyte character. */
868 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
870 if (pos_byte
== BEG_BYTE
) /* case (2) */
873 p
= BYTE_POS_ADDR (pos_byte
- 1);
874 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
875 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
878 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
879 if (combining_bytes
<= 0)
880 /* The character preceding POS is, complete and no room for
881 combining bytes (combining_bytes == 0), or an independent 8-bit
882 character (combining_bytes < 0). */
885 /* We have a combination situation. Count the bytes at STRING that
888 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
891 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
894 /* See if the bytes after POS/POS_BYTE combine with bytes
895 at the end of STRING to form a single character.
896 If so, return the number of bytes after POS/POS_BYTE
897 which combine in this way. Otherwise, return 0. */
900 count_combining_after (string
, length
, pos
, pos_byte
)
901 const unsigned char *string
;
905 int opos_byte
= pos_byte
;
910 if (NILP (current_buffer
->enable_multibyte_characters
))
913 /* At first, we can exclude the following cases:
914 (1) The last byte of STRING is an ASCII.
915 (2) POS is the last of the current buffer.
916 (3) A character at POS can't be a following byte of multibyte
918 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
920 if (pos_byte
== Z_BYTE
) /* case (2) */
922 bufp
= BYTE_POS_ADDR (pos_byte
);
923 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
927 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
933 /* All characters in STRING are not character head. We must
934 check also preceding bytes at POS. We are sure that the gap
936 unsigned char *p
= BEG_ADDR
;
938 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
940 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
943 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
944 return (bytes
<= pos_byte
- 1 - i
+ length
946 : bytes
- (pos_byte
- 1 - i
+ length
));
948 if (!BASE_LEADING_CODE_P (string
[i
]))
951 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
953 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
955 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
961 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
962 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
963 are the same as in insert_1. */
966 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
967 register const unsigned char *string
;
968 register int nchars
, nbytes
;
969 int inherit
, prepare
, before_markers
;
974 if (NILP (current_buffer
->enable_multibyte_characters
))
978 /* Do this before moving and increasing the gap,
979 because the before-change hooks might move the gap
980 or make it smaller. */
981 prepare_to_modify_buffer (PT
, PT
, NULL
);
984 move_gap_both (PT
, PT_BYTE
);
985 if (GAP_SIZE
< nbytes
)
986 make_gap (nbytes
- GAP_SIZE
);
988 #ifdef BYTE_COMBINING_DEBUG
989 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
990 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
994 /* Record deletion of the surrounding text that combines with
995 the insertion. This, together with recording the insertion,
996 will add up to the right stuff in the undo list. */
997 record_insert (PT
, nchars
);
999 CHARS_MODIFF
= MODIFF
;
1001 bcopy (string
, GPT_ADDR
, nbytes
);
1010 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1015 /* The insert may have been in the unchanged region, so check again. */
1016 if (Z
- GPT
< END_UNCHANGED
)
1017 END_UNCHANGED
= Z
- GPT
;
1019 adjust_overlays_for_insert (PT
, nchars
);
1020 adjust_markers_for_insert (PT
, PT_BYTE
,
1021 PT
+ nchars
, PT_BYTE
+ nbytes
,
1024 if (BUF_INTERVALS (current_buffer
) != 0)
1025 offset_intervals (current_buffer
, PT
, nchars
);
1027 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1028 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1031 adjust_point (nchars
, nbytes
);
1036 /* Insert the part of the text of STRING, a Lisp object assumed to be
1037 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1038 starting at position POS / POS_BYTE. If the text of STRING has properties,
1039 copy them into the buffer.
1041 It does not work to use `insert' for this, because a GC could happen
1042 before we bcopy the stuff into the buffer, and relocate the string
1043 without insert noticing. */
1046 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1048 register int pos
, pos_byte
, length
, length_byte
;
1053 if (SCHARS (string
) == 0)
1056 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1058 signal_after_change (opoint
, 0, PT
- opoint
);
1059 update_compositions (opoint
, PT
, CHECK_BORDER
);
1062 /* Like `insert_from_string' except that all markers pointing
1063 at the place where the insertion happens are adjusted to point after it. */
1066 insert_from_string_before_markers (string
, pos
, pos_byte
,
1067 length
, length_byte
, inherit
)
1069 register int pos
, pos_byte
, length
, length_byte
;
1074 if (SCHARS (string
) == 0)
1077 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1079 signal_after_change (opoint
, 0, PT
- opoint
);
1080 update_compositions (opoint
, PT
, CHECK_BORDER
);
1083 /* Subroutine of the insertion functions above. */
1086 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1087 inherit
, before_markers
)
1089 register int pos
, pos_byte
, nchars
, nbytes
;
1090 int inherit
, before_markers
;
1092 struct gcpro gcpro1
;
1093 int outgoing_nbytes
= nbytes
;
1096 /* Make OUTGOING_NBYTES describe the text
1097 as it will be inserted in this buffer. */
1099 if (NILP (current_buffer
->enable_multibyte_characters
))
1100 outgoing_nbytes
= nchars
;
1101 else if (! STRING_MULTIBYTE (string
))
1103 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
1107 /* Do this before moving and increasing the gap,
1108 because the before-change hooks might move the gap
1109 or make it smaller. */
1110 prepare_to_modify_buffer (PT
, PT
, NULL
);
1113 move_gap_both (PT
, PT_BYTE
);
1114 if (GAP_SIZE
< outgoing_nbytes
)
1115 make_gap (outgoing_nbytes
- GAP_SIZE
);
1118 /* Copy the string text into the buffer, perhaps converting
1119 between single-byte and multibyte. */
1120 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
1121 STRING_MULTIBYTE (string
),
1122 ! NILP (current_buffer
->enable_multibyte_characters
));
1124 #ifdef BYTE_COMBINING_DEBUG
1125 /* We have copied text into the gap, but we have not altered
1126 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1127 to these functions and get the same results as we would
1128 have got earlier on. Meanwhile, PT_ADDR does point to
1129 the text that has been stored by copy_text. */
1130 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1131 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1135 record_insert (PT
, nchars
);
1137 CHARS_MODIFF
= MODIFF
;
1139 GAP_SIZE
-= outgoing_nbytes
;
1143 GPT_BYTE
+= outgoing_nbytes
;
1144 ZV_BYTE
+= outgoing_nbytes
;
1145 Z_BYTE
+= outgoing_nbytes
;
1146 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1151 /* The insert may have been in the unchanged region, so check again. */
1152 if (Z
- GPT
< END_UNCHANGED
)
1153 END_UNCHANGED
= Z
- GPT
;
1155 adjust_overlays_for_insert (PT
, nchars
);
1156 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1157 PT_BYTE
+ outgoing_nbytes
,
1160 offset_intervals (current_buffer
, PT
, nchars
);
1162 intervals
= STRING_INTERVALS (string
);
1163 /* Get the intervals for the part of the string we are inserting. */
1164 if (nbytes
< SBYTES (string
))
1165 intervals
= copy_intervals (intervals
, pos
, nchars
);
1167 /* Insert those intervals. */
1168 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1169 current_buffer
, inherit
);
1171 adjust_point (nchars
, outgoing_nbytes
);
1176 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1177 starting at GPT_ADDR. */
1180 insert_from_gap (nchars
, nbytes
)
1181 register int nchars
, nbytes
;
1183 if (NILP (current_buffer
->enable_multibyte_characters
))
1186 record_insert (GPT
, nchars
);
1196 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1201 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1202 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1205 if (BUF_INTERVALS (current_buffer
) != 0)
1207 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1208 graft_intervals_into_buffer (NULL_INTERVAL
, GPT
- nchars
, nchars
,
1212 if (GPT
- nchars
< PT
)
1213 adjust_point (nchars
, nbytes
);
1218 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1219 current buffer. If the text in BUF has properties, they are absorbed
1220 into the current buffer.
1222 It does not work to use `insert' for this, because a malloc could happen
1223 and relocate BUF's text before the bcopy happens. */
1226 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1228 int charpos
, nchars
;
1233 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1234 signal_after_change (opoint
, 0, PT
- opoint
);
1235 update_compositions (opoint
, PT
, CHECK_BORDER
);
1239 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1244 register Lisp_Object temp
;
1245 int chunk
, chunk_expanded
;
1246 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1247 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1248 int incoming_nbytes
= to_byte
- from_byte
;
1249 int outgoing_nbytes
= incoming_nbytes
;
1252 /* Make OUTGOING_NBYTES describe the text
1253 as it will be inserted in this buffer. */
1255 if (NILP (current_buffer
->enable_multibyte_characters
))
1256 outgoing_nbytes
= nchars
;
1257 else if (NILP (buf
->enable_multibyte_characters
))
1259 int outgoing_before_gap
= 0;
1260 int outgoing_after_gap
= 0;
1262 if (from
< BUF_GPT (buf
))
1264 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1265 if (chunk
> incoming_nbytes
)
1266 chunk
= incoming_nbytes
;
1268 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1274 if (chunk
< incoming_nbytes
)
1276 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1278 incoming_nbytes
- chunk
);
1280 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1283 /* Make sure point-max won't overflow after this insertion. */
1284 XSETINT (temp
, outgoing_nbytes
+ Z
);
1285 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1286 error ("Maximum buffer size exceeded");
1288 /* Do this before moving and increasing the gap,
1289 because the before-change hooks might move the gap
1290 or make it smaller. */
1291 prepare_to_modify_buffer (PT
, PT
, NULL
);
1294 move_gap_both (PT
, PT_BYTE
);
1295 if (GAP_SIZE
< outgoing_nbytes
)
1296 make_gap (outgoing_nbytes
- GAP_SIZE
);
1298 if (from
< BUF_GPT (buf
))
1300 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1301 if (chunk
> incoming_nbytes
)
1302 chunk
= incoming_nbytes
;
1303 /* Record number of output bytes, so we know where
1304 to put the output from the second copy_text. */
1306 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1308 ! NILP (buf
->enable_multibyte_characters
),
1309 ! NILP (current_buffer
->enable_multibyte_characters
));
1312 chunk_expanded
= chunk
= 0;
1314 if (chunk
< incoming_nbytes
)
1315 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1316 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1317 ! NILP (buf
->enable_multibyte_characters
),
1318 ! NILP (current_buffer
->enable_multibyte_characters
));
1320 #ifdef BYTE_COMBINING_DEBUG
1321 /* We have copied text into the gap, but we have not altered
1322 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1323 to these functions and get the same results as we would
1324 have got earlier on. Meanwhile, GPT_ADDR does point to
1325 the text that has been stored by copy_text. */
1326 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1327 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1331 record_insert (PT
, nchars
);
1333 CHARS_MODIFF
= MODIFF
;
1335 GAP_SIZE
-= outgoing_nbytes
;
1339 GPT_BYTE
+= outgoing_nbytes
;
1340 ZV_BYTE
+= outgoing_nbytes
;
1341 Z_BYTE
+= outgoing_nbytes
;
1342 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1347 /* The insert may have been in the unchanged region, so check again. */
1348 if (Z
- GPT
< END_UNCHANGED
)
1349 END_UNCHANGED
= Z
- GPT
;
1351 adjust_overlays_for_insert (PT
, nchars
);
1352 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1353 PT_BYTE
+ outgoing_nbytes
,
1356 if (BUF_INTERVALS (current_buffer
) != 0)
1357 offset_intervals (current_buffer
, PT
, nchars
);
1359 /* Get the intervals for the part of the string we are inserting. */
1360 intervals
= BUF_INTERVALS (buf
);
1361 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1363 if (buf
== current_buffer
&& PT
<= from
)
1365 intervals
= copy_intervals (intervals
, from
, nchars
);
1368 /* Insert those intervals. */
1369 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1371 adjust_point (nchars
, outgoing_nbytes
);
1374 /* Record undo information and adjust markers and position keepers for
1375 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1376 chars (LEN_BYTE bytes) which resides in the gap just after
1379 PREV_TEXT nil means the new text was just inserted. */
1382 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1383 int from
, from_byte
, len
, len_byte
;
1384 Lisp_Object prev_text
;
1386 int nchars_del
= 0, nbytes_del
= 0;
1388 #ifdef BYTE_COMBINING_DEBUG
1389 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1390 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1394 if (STRINGP (prev_text
))
1396 nchars_del
= SCHARS (prev_text
);
1397 nbytes_del
= SBYTES (prev_text
);
1400 /* Update various buffer positions for the new text. */
1401 GAP_SIZE
-= len_byte
;
1403 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1404 GPT
+= len
; GPT_BYTE
+= len_byte
;
1405 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1408 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1411 adjust_markers_for_insert (from
, from_byte
,
1412 from
+ len
, from_byte
+ len_byte
, 0);
1414 if (! EQ (current_buffer
->undo_list
, Qt
))
1417 record_delete (from
, prev_text
);
1418 record_insert (from
, len
);
1421 if (len
> nchars_del
)
1422 adjust_overlays_for_insert (from
, len
- nchars_del
);
1423 else if (len
< nchars_del
)
1424 adjust_overlays_for_delete (from
, nchars_del
- len
);
1425 if (BUF_INTERVALS (current_buffer
) != 0)
1427 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1431 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1433 /* As byte combining will decrease Z, we must check this again. */
1434 if (Z
- GPT
< END_UNCHANGED
)
1435 END_UNCHANGED
= Z
- GPT
;
1440 evaporate_overlays (from
);
1442 CHARS_MODIFF
= MODIFF
;
1445 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1446 This is for use when undo is not enabled in the current buffer. */
1449 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1450 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1452 #ifdef BYTE_COMBINING_DEBUG
1453 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1454 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1458 /* Update various buffer positions for the new text. */
1459 GAP_SIZE
-= len_byte
;
1461 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1462 GPT
+= len
; GPT_BYTE
+= len_byte
;
1463 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1466 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1469 adjust_markers_for_insert (from
, from_byte
,
1470 from
+ len
, from_byte
+ len_byte
, 0);
1472 if (len
> nchars_del
)
1473 adjust_overlays_for_insert (from
, len
- nchars_del
);
1474 else if (len
< nchars_del
)
1475 adjust_overlays_for_delete (from
, nchars_del
- len
);
1476 if (BUF_INTERVALS (current_buffer
) != 0)
1478 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1482 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1484 /* As byte combining will decrease Z, we must check this again. */
1485 if (Z
- GPT
< END_UNCHANGED
)
1486 END_UNCHANGED
= Z
- GPT
;
1491 evaporate_overlays (from
);
1493 CHARS_MODIFF
= MODIFF
;
1496 /* Record undo information, adjust markers and position keepers for an
1497 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1498 text already exists in the current buffer but character length (TO
1499 - FROM) may be incorrect, the correct length is NEWLEN. */
1502 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1503 int from
, from_byte
, to
, to_byte
, newlen
;
1505 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1508 move_gap_both (to
, to_byte
);
1509 GAP_SIZE
+= len_byte
;
1510 GPT
-= len
; GPT_BYTE
-= len_byte
;
1511 ZV
-= len
; ZV_BYTE
-= len_byte
;
1512 Z
-= len
; Z_BYTE
-= len_byte
;
1513 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1516 /* Replace the text from character positions FROM to TO with NEW,
1517 If PREPARE is nonzero, call prepare_to_modify_buffer.
1518 If INHERIT, the newly inserted text should inherit text properties
1519 from the surrounding non-deleted text. */
1521 /* Note that this does not yet handle markers quite right.
1522 Also it needs to record a single undo-entry that does a replacement
1523 rather than a separate delete and insert.
1524 That way, undo will also handle markers properly.
1526 But if MARKERS is 0, don't relocate markers. */
1529 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1531 int from
, to
, prepare
, inherit
, markers
;
1533 int inschars
= SCHARS (new);
1534 int insbytes
= SBYTES (new);
1535 int from_byte
, to_byte
;
1536 int nbytes_del
, nchars_del
;
1537 register Lisp_Object temp
;
1538 struct gcpro gcpro1
;
1540 int outgoing_insbytes
= insbytes
;
1541 Lisp_Object deletion
;
1550 int range_length
= to
- from
;
1551 prepare_to_modify_buffer (from
, to
, &from
);
1552 to
= from
+ range_length
;
1557 /* Make args be valid */
1563 from_byte
= CHAR_TO_BYTE (from
);
1564 to_byte
= CHAR_TO_BYTE (to
);
1566 nchars_del
= to
- from
;
1567 nbytes_del
= to_byte
- from_byte
;
1569 if (nbytes_del
<= 0 && insbytes
== 0)
1572 /* Make OUTGOING_INSBYTES describe the text
1573 as it will be inserted in this buffer. */
1575 if (NILP (current_buffer
->enable_multibyte_characters
))
1576 outgoing_insbytes
= inschars
;
1577 else if (! STRING_MULTIBYTE (new))
1579 = count_size_as_multibyte (SDATA (new), insbytes
);
1581 /* Make sure point-max won't overflow after this insertion. */
1582 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1583 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1584 error ("Maximum buffer size exceeded");
1588 /* Make sure the gap is somewhere in or next to what we are deleting. */
1590 gap_right (from
, from_byte
);
1592 gap_left (to
, to_byte
, 0);
1594 /* Even if we don't record for undo, we must keep the original text
1595 because we may have to recover it because of inappropriate byte
1597 if (! EQ (current_buffer
->undo_list
, Qt
))
1598 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1600 GAP_SIZE
+= nbytes_del
;
1603 ZV_BYTE
-= nbytes_del
;
1604 Z_BYTE
-= nbytes_del
;
1606 GPT_BYTE
= from_byte
;
1607 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1612 if (GPT
- BEG
< BEG_UNCHANGED
)
1613 BEG_UNCHANGED
= GPT
- BEG
;
1614 if (Z
- GPT
< END_UNCHANGED
)
1615 END_UNCHANGED
= Z
- GPT
;
1617 if (GAP_SIZE
< insbytes
)
1618 make_gap (insbytes
- GAP_SIZE
);
1620 /* Copy the string text into the buffer, perhaps converting
1621 between single-byte and multibyte. */
1622 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1623 STRING_MULTIBYTE (new),
1624 ! NILP (current_buffer
->enable_multibyte_characters
));
1626 #ifdef BYTE_COMBINING_DEBUG
1627 /* We have copied text into the gap, but we have not marked
1628 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1629 here, for both the previous text and the following text.
1630 Meanwhile, GPT_ADDR does point to
1631 the text that has been stored by copy_text. */
1632 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1633 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1637 if (! EQ (current_buffer
->undo_list
, Qt
))
1639 /* Record the insertion first, so that when we undo,
1640 the deletion will be undone first. Thus, undo
1641 will insert before deleting, and thus will keep
1642 the markers before and after this text separate. */
1643 record_insert (from
+ SCHARS (deletion
), inschars
);
1644 record_delete (from
, deletion
);
1647 GAP_SIZE
-= outgoing_insbytes
;
1651 GPT_BYTE
+= outgoing_insbytes
;
1652 ZV_BYTE
+= outgoing_insbytes
;
1653 Z_BYTE
+= outgoing_insbytes
;
1654 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1659 /* Adjust the overlay center as needed. This must be done after
1660 adjusting the markers that bound the overlays. */
1661 adjust_overlays_for_delete (from
, nchars_del
);
1662 adjust_overlays_for_insert (from
, inschars
);
1664 /* Adjust markers for the deletion and the insertion. */
1666 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1667 inschars
, outgoing_insbytes
);
1669 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1671 /* Get the intervals for the part of the string we are inserting--
1672 not including the combined-before bytes. */
1673 intervals
= STRING_INTERVALS (new);
1674 /* Insert those intervals. */
1675 graft_intervals_into_buffer (intervals
, from
, inschars
,
1676 current_buffer
, inherit
);
1678 /* Relocate point as if it were a marker. */
1680 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1681 (from_byte
+ outgoing_insbytes
1682 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1684 if (outgoing_insbytes
== 0)
1685 evaporate_overlays (from
);
1690 CHARS_MODIFF
= MODIFF
;
1693 signal_after_change (from
, nchars_del
, GPT
- from
);
1694 update_compositions (from
, GPT
, CHECK_BORDER
);
1697 /* Replace the text from character positions FROM to TO with
1698 the text in INS of length INSCHARS.
1699 Keep the text properties that applied to the old characters
1700 (extending them to all the new chars if there are more new chars).
1702 Note that this does not yet handle markers quite right.
1704 If MARKERS is nonzero, relocate markers.
1706 Unlike most functions at this level, never call
1707 prepare_to_modify_buffer and never call signal_after_change. */
1710 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1711 int from
, from_byte
, to
, to_byte
;
1713 int inschars
, insbytes
, markers
;
1715 int nbytes_del
, nchars_del
;
1720 nchars_del
= to
- from
;
1721 nbytes_del
= to_byte
- from_byte
;
1723 if (nbytes_del
<= 0 && insbytes
== 0)
1726 /* Make sure point-max won't overflow after this insertion. */
1727 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1728 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1729 error ("Maximum buffer size exceeded");
1731 /* Make sure the gap is somewhere in or next to what we are deleting. */
1733 gap_right (from
, from_byte
);
1735 gap_left (to
, to_byte
, 0);
1737 GAP_SIZE
+= nbytes_del
;
1740 ZV_BYTE
-= nbytes_del
;
1741 Z_BYTE
-= nbytes_del
;
1743 GPT_BYTE
= from_byte
;
1744 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1749 if (GPT
- BEG
< BEG_UNCHANGED
)
1750 BEG_UNCHANGED
= GPT
- BEG
;
1751 if (Z
- GPT
< END_UNCHANGED
)
1752 END_UNCHANGED
= Z
- GPT
;
1754 if (GAP_SIZE
< insbytes
)
1755 make_gap (insbytes
- GAP_SIZE
);
1757 /* Copy the replacement text into the buffer. */
1758 bcopy (ins
, GPT_ADDR
, insbytes
);
1760 #ifdef BYTE_COMBINING_DEBUG
1761 /* We have copied text into the gap, but we have not marked
1762 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1763 here, for both the previous text and the following text.
1764 Meanwhile, GPT_ADDR does point to
1765 the text that has been stored by copy_text. */
1766 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1767 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1771 GAP_SIZE
-= insbytes
;
1775 GPT_BYTE
+= insbytes
;
1776 ZV_BYTE
+= insbytes
;
1778 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1783 /* Adjust the overlay center as needed. This must be done after
1784 adjusting the markers that bound the overlays. */
1785 if (nchars_del
!= inschars
)
1787 adjust_overlays_for_insert (from
, inschars
);
1788 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1791 /* Adjust markers for the deletion and the insertion. */
1793 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1794 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1795 inschars
, insbytes
);
1797 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1799 /* Relocate point as if it were a marker. */
1800 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1803 /* PT was within the deleted text. Move it to FROM. */
1804 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1806 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1810 evaporate_overlays (from
);
1815 CHARS_MODIFF
= MODIFF
;
1818 /* Delete characters in current buffer
1819 from FROM up to (but not including) TO.
1820 If TO comes before FROM, we delete nothing. */
1823 del_range (from
, to
)
1824 register int from
, to
;
1826 del_range_1 (from
, to
, 1, 0);
1829 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1830 RET_STRING says to return the deleted text. */
1833 del_range_1 (from
, to
, prepare
, ret_string
)
1834 int from
, to
, prepare
, ret_string
;
1836 int from_byte
, to_byte
;
1837 Lisp_Object deletion
;
1838 struct gcpro gcpro1
;
1840 /* Make args be valid */
1851 int range_length
= to
- from
;
1852 prepare_to_modify_buffer (from
, to
, &from
);
1853 to
= min (ZV
, from
+ range_length
);
1856 from_byte
= CHAR_TO_BYTE (from
);
1857 to_byte
= CHAR_TO_BYTE (to
);
1859 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1861 signal_after_change (from
, to
- from
, 0);
1862 update_compositions (from
, from
, CHECK_HEAD
);
1867 /* Like del_range_1 but args are byte positions, not char positions. */
1870 del_range_byte (from_byte
, to_byte
, prepare
)
1871 int from_byte
, to_byte
, prepare
;
1875 /* Make args be valid */
1876 if (from_byte
< BEGV_BYTE
)
1877 from_byte
= BEGV_BYTE
;
1878 if (to_byte
> ZV_BYTE
)
1881 if (to_byte
<= from_byte
)
1884 from
= BYTE_TO_CHAR (from_byte
);
1885 to
= BYTE_TO_CHAR (to_byte
);
1889 int old_from
= from
, old_to
= Z
- to
;
1890 int range_length
= to
- from
;
1891 prepare_to_modify_buffer (from
, to
, &from
);
1892 to
= from
+ range_length
;
1894 if (old_from
!= from
)
1895 from_byte
= CHAR_TO_BYTE (from
);
1901 else if (old_to
== Z
- to
)
1902 to_byte
= CHAR_TO_BYTE (to
);
1905 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1906 signal_after_change (from
, to
- from
, 0);
1907 update_compositions (from
, from
, CHECK_HEAD
);
1910 /* Like del_range_1, but positions are specified both as charpos
1914 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1915 int from
, from_byte
, to
, to_byte
, prepare
;
1917 /* Make args be valid */
1918 if (from_byte
< BEGV_BYTE
)
1919 from_byte
= BEGV_BYTE
;
1920 if (to_byte
> ZV_BYTE
)
1923 if (to_byte
<= from_byte
)
1933 int old_from
= from
, old_to
= Z
- to
;
1934 int range_length
= to
- from
;
1935 prepare_to_modify_buffer (from
, to
, &from
);
1936 to
= from
+ range_length
;
1938 if (old_from
!= from
)
1939 from_byte
= CHAR_TO_BYTE (from
);
1945 else if (old_to
== Z
- to
)
1946 to_byte
= CHAR_TO_BYTE (to
);
1949 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1950 signal_after_change (from
, to
- from
, 0);
1951 update_compositions (from
, from
, CHECK_HEAD
);
1954 /* Delete a range of text, specified both as character positions
1955 and byte positions. FROM and TO are character positions,
1956 while FROM_BYTE and TO_BYTE are byte positions.
1957 If RET_STRING is true, the deleted area is returned as a string. */
1960 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1961 int from
, from_byte
, to
, to_byte
, ret_string
;
1963 register int nbytes_del
, nchars_del
;
1964 Lisp_Object deletion
;
1968 nchars_del
= to
- from
;
1969 nbytes_del
= to_byte
- from_byte
;
1971 /* Make sure the gap is somewhere in or next to what we are deleting. */
1973 gap_right (from
, from_byte
);
1975 gap_left (to
, to_byte
, 0);
1977 #ifdef BYTE_COMBINING_DEBUG
1978 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1979 Z_BYTE
- to_byte
, from
, from_byte
))
1983 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1984 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1988 /* Relocate all markers pointing into the new, larger gap
1989 to point at the end of the text before the gap.
1990 Do this before recording the deletion,
1991 so that undo handles this after reinserting the text. */
1992 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1994 if (! EQ (current_buffer
->undo_list
, Qt
))
1995 record_delete (from
, deletion
);
1997 CHARS_MODIFF
= MODIFF
;
1999 /* Relocate point as if it were a marker. */
2001 adjust_point (from
- (PT
< to
? PT
: to
),
2002 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
2004 offset_intervals (current_buffer
, from
, - nchars_del
);
2006 /* Adjust the overlay center as needed. This must be done after
2007 adjusting the markers that bound the overlays. */
2008 adjust_overlays_for_delete (from
, nchars_del
);
2010 GAP_SIZE
+= nbytes_del
;
2011 ZV_BYTE
-= nbytes_del
;
2012 Z_BYTE
-= nbytes_del
;
2016 GPT_BYTE
= from_byte
;
2017 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
2022 if (GPT
- BEG
< BEG_UNCHANGED
)
2023 BEG_UNCHANGED
= GPT
- BEG
;
2024 if (Z
- GPT
< END_UNCHANGED
)
2025 END_UNCHANGED
= Z
- GPT
;
2029 evaporate_overlays (from
);
2034 /* Call this if you're about to change the region of BUFFER from
2035 character positions START to END. This checks the read-only
2036 properties of the region, calls the necessary modification hooks,
2037 and warns the next redisplay that it should pay attention to that
2040 If PRESERVE_CHARS_MODIFF is non-zero, do not update CHARS_MODIFF.
2041 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
2044 modify_region (buffer
, start
, end
, preserve_chars_modiff
)
2045 struct buffer
*buffer
;
2046 int start
, end
, preserve_chars_modiff
;
2048 struct buffer
*old_buffer
= current_buffer
;
2050 if (buffer
!= old_buffer
)
2051 set_buffer_internal (buffer
);
2053 prepare_to_modify_buffer (start
, end
, NULL
);
2055 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
2057 if (MODIFF
<= SAVE_MODIFF
)
2058 record_first_change ();
2060 if (! preserve_chars_modiff
)
2061 CHARS_MODIFF
= MODIFF
;
2063 buffer
->point_before_scroll
= Qnil
;
2065 if (buffer
!= old_buffer
)
2066 set_buffer_internal (old_buffer
);
2069 /* Check that it is okay to modify the buffer between START and END,
2070 which are char positions.
2072 Run the before-change-function, if any. If intervals are in use,
2073 verify that the text to be modified is not read-only, and call
2074 any modification properties the text may have.
2076 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2077 by holding its value temporarily in a marker. */
2080 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2084 struct buffer
*base_buffer
;
2086 if (!NILP (current_buffer
->read_only
))
2087 Fbarf_if_buffer_read_only ();
2089 /* Let redisplay consider other windows than selected_window
2090 if modifying another buffer. */
2091 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2092 ++windows_or_buffers_changed
;
2094 if (BUF_INTERVALS (current_buffer
) != 0)
2098 Lisp_Object preserve_marker
;
2099 struct gcpro gcpro1
;
2100 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2101 GCPRO1 (preserve_marker
);
2102 verify_interval_modification (current_buffer
, start
, end
);
2103 *preserve_ptr
= marker_position (preserve_marker
);
2104 unchain_marker (XMARKER (preserve_marker
));
2108 verify_interval_modification (current_buffer
, start
, end
);
2111 /* For indirect buffers, use the base buffer to check clashes. */
2112 if (current_buffer
->base_buffer
!= 0)
2113 base_buffer
= current_buffer
->base_buffer
;
2115 base_buffer
= current_buffer
;
2117 #ifdef CLASH_DETECTION
2118 if (!NILP (base_buffer
->file_truename
)
2119 /* Make binding buffer-file-name to nil effective. */
2120 && !NILP (base_buffer
->filename
)
2121 && SAVE_MODIFF
>= MODIFF
)
2122 lock_file (base_buffer
->file_truename
);
2124 /* At least warn if this file has changed on disk since it was visited. */
2125 if (!NILP (base_buffer
->filename
)
2126 && SAVE_MODIFF
>= MODIFF
2127 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2128 && !NILP (Ffile_exists_p (base_buffer
->filename
)))
2129 call1 (intern ("ask-user-about-supersession-threat"),
2130 base_buffer
->filename
);
2131 #endif /* not CLASH_DETECTION */
2133 signal_before_change (start
, end
, preserve_ptr
);
2135 if (current_buffer
->newline_cache
)
2136 invalidate_region_cache (current_buffer
,
2137 current_buffer
->newline_cache
,
2138 start
- BEG
, Z
- end
);
2139 if (current_buffer
->width_run_cache
)
2140 invalidate_region_cache (current_buffer
,
2141 current_buffer
->width_run_cache
,
2142 start
- BEG
, Z
- end
);
2144 Vdeactivate_mark
= Qt
;
2147 /* These macros work with an argument named `preserve_ptr'
2148 and a local variable named `preserve_marker'. */
2150 #define PRESERVE_VALUE \
2151 if (preserve_ptr && NILP (preserve_marker)) \
2152 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2154 #define RESTORE_VALUE \
2155 if (! NILP (preserve_marker)) \
2157 *preserve_ptr = marker_position (preserve_marker); \
2158 unchain_marker (XMARKER (preserve_marker)); \
2161 #define PRESERVE_START_END \
2162 if (NILP (start_marker)) \
2163 start_marker = Fcopy_marker (start, Qnil); \
2164 if (NILP (end_marker)) \
2165 end_marker = Fcopy_marker (end, Qnil);
2167 #define FETCH_START \
2168 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2171 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2173 /* Set a variable to nil if an error occurred.
2174 Don't change the variable if there was no error.
2175 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
2176 VARIABLE is the variable to maybe set to nil.
2177 NO-ERROR-FLAG is nil if there was an error,
2178 anything else meaning no error (so this function does nothing). */
2180 reset_var_on_error (val
)
2183 if (NILP (XCDR (val
)))
2184 Fset (XCAR (val
), Qnil
);
2188 /* Signal a change to the buffer immediately before it happens.
2189 START_INT and END_INT are the bounds of the text to be changed.
2191 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2192 by holding its value temporarily in a marker. */
2195 signal_before_change (start_int
, end_int
, preserve_ptr
)
2196 int start_int
, end_int
;
2199 Lisp_Object start
, end
;
2200 Lisp_Object start_marker
, end_marker
;
2201 Lisp_Object preserve_marker
;
2202 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2203 int count
= SPECPDL_INDEX ();
2205 if (inhibit_modification_hooks
)
2208 start
= make_number (start_int
);
2209 end
= make_number (end_int
);
2210 preserve_marker
= Qnil
;
2211 start_marker
= Qnil
;
2213 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2215 specbind (Qinhibit_modification_hooks
, Qt
);
2217 /* If buffer is unmodified, run a special hook for that case. */
2218 if (SAVE_MODIFF
>= MODIFF
2219 && !NILP (Vfirst_change_hook
)
2220 && !NILP (Vrun_hooks
))
2224 call1 (Vrun_hooks
, Qfirst_change_hook
);
2227 /* Now run the before-change-functions if any. */
2228 if (!NILP (Vbefore_change_functions
))
2230 Lisp_Object args
[3];
2231 Lisp_Object rvoe_arg
= Fcons (Qbefore_change_functions
, Qnil
);
2236 /* Mark before-change-functions to be reset to nil in case of error. */
2237 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2239 /* Actually run the hook functions. */
2240 args
[0] = Qbefore_change_functions
;
2241 args
[1] = FETCH_START
;
2242 args
[2] = FETCH_END
;
2243 Frun_hook_with_args (3, args
);
2245 /* There was no error: unarm the reset_on_error. */
2246 XSETCDR (rvoe_arg
, Qt
);
2249 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2252 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2253 FETCH_START
, FETCH_END
, Qnil
);
2256 if (! NILP (start_marker
))
2257 free_marker (start_marker
);
2258 if (! NILP (end_marker
))
2259 free_marker (end_marker
);
2263 unbind_to (count
, Qnil
);
2266 /* Signal a change immediately after it happens.
2267 CHARPOS is the character position of the start of the changed text.
2268 LENDEL is the number of characters of the text before the change.
2269 (Not the whole buffer; just the part that was changed.)
2270 LENINS is the number of characters in that part of the text
2271 after the change. */
2274 signal_after_change (charpos
, lendel
, lenins
)
2275 int charpos
, lendel
, lenins
;
2277 int count
= SPECPDL_INDEX ();
2278 if (inhibit_modification_hooks
)
2281 /* If we are deferring calls to the after-change functions
2282 and there are no before-change functions,
2283 just record the args that we were going to use. */
2284 if (! NILP (Vcombine_after_change_calls
)
2285 && NILP (Vbefore_change_functions
)
2286 && !current_buffer
->overlays_before
2287 && !current_buffer
->overlays_after
)
2291 if (!NILP (combine_after_change_list
)
2292 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2293 Fcombine_after_change_execute ();
2295 elt
= Fcons (make_number (charpos
- BEG
),
2296 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2297 Fcons (make_number (lenins
- lendel
), Qnil
)));
2298 combine_after_change_list
2299 = Fcons (elt
, combine_after_change_list
);
2300 combine_after_change_buffer
= Fcurrent_buffer ();
2305 if (!NILP (combine_after_change_list
))
2306 Fcombine_after_change_execute ();
2308 specbind (Qinhibit_modification_hooks
, Qt
);
2310 if (!NILP (Vafter_change_functions
))
2312 Lisp_Object args
[4];
2313 Lisp_Object rvoe_arg
= Fcons (Qafter_change_functions
, Qnil
);
2315 /* Mark after-change-functions to be reset to nil in case of error. */
2316 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2318 /* Actually run the hook functions. */
2319 args
[0] = Qafter_change_functions
;
2320 XSETFASTINT (args
[1], charpos
);
2321 XSETFASTINT (args
[2], charpos
+ lenins
);
2322 XSETFASTINT (args
[3], lendel
);
2323 Frun_hook_with_args (4, args
);
2325 /* There was no error: unarm the reset_on_error. */
2326 XSETCDR (rvoe_arg
, Qt
);
2329 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2330 report_overlay_modification (make_number (charpos
),
2331 make_number (charpos
+ lenins
),
2333 make_number (charpos
),
2334 make_number (charpos
+ lenins
),
2335 make_number (lendel
));
2337 /* After an insertion, call the text properties
2338 insert-behind-hooks or insert-in-front-hooks. */
2340 report_interval_modification (make_number (charpos
),
2341 make_number (charpos
+ lenins
));
2343 unbind_to (count
, Qnil
);
2347 Fcombine_after_change_execute_1 (val
)
2350 Vcombine_after_change_calls
= val
;
2354 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2355 Scombine_after_change_execute
, 0, 0, 0,
2356 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2359 int count
= SPECPDL_INDEX ();
2360 int beg
, end
, change
;
2364 if (NILP (combine_after_change_list
))
2367 /* It is rare for combine_after_change_buffer to be invalid, but
2368 possible. It can happen when combine-after-change-calls is
2369 non-nil, and insertion calls a file handler (e.g. through
2370 lock_file) which scribbles into a temp file -- cyd */
2371 if (!BUFFERP (combine_after_change_buffer
)
2372 || NILP (XBUFFER (combine_after_change_buffer
)->name
))
2374 combine_after_change_list
= Qnil
;
2378 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2380 Fset_buffer (combine_after_change_buffer
);
2382 /* # chars unchanged at beginning of buffer. */
2384 /* # chars unchanged at end of buffer. */
2386 /* Total amount of insertion (negative for deletion). */
2389 /* Scan the various individual changes,
2390 accumulating the range info in BEG, END and CHANGE. */
2391 for (tail
= combine_after_change_list
; CONSP (tail
);
2395 int thisbeg
, thisend
, thischange
;
2397 /* Extract the info from the next element. */
2401 thisbeg
= XINT (XCAR (elt
));
2406 thisend
= XINT (XCAR (elt
));
2411 thischange
= XINT (XCAR (elt
));
2413 /* Merge this range into the accumulated range. */
2414 change
+= thischange
;
2421 /* Get the current start and end positions of the range
2422 that was changed. */
2426 /* We are about to handle these, so discard them. */
2427 combine_after_change_list
= Qnil
;
2429 /* Now run the after-change functions for real.
2430 Turn off the flag that defers them. */
2431 record_unwind_protect (Fcombine_after_change_execute_1
,
2432 Vcombine_after_change_calls
);
2433 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2434 update_compositions (begpos
, endpos
, CHECK_ALL
);
2436 return unbind_to (count
, Qnil
);
2442 staticpro (&combine_after_change_list
);
2443 staticpro (&combine_after_change_buffer
);
2444 combine_after_change_list
= Qnil
;
2445 combine_after_change_buffer
= Qnil
;
2447 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2448 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2449 check_markers_debug_flag
= 0;
2450 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2451 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2452 Vcombine_after_change_calls
= Qnil
;
2454 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2455 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2456 This affects `before-change-functions' and `after-change-functions',
2457 as well as hooks attached to text properties and overlays. */);
2458 inhibit_modification_hooks
= 0;
2459 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2460 staticpro (&Qinhibit_modification_hooks
);
2462 defsubr (&Scombine_after_change_execute
);
2465 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2466 (do not change this comment) */