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 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 2, 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_delete (from
, deletion
);
1640 record_insert (from
, inschars
);
1643 GAP_SIZE
-= outgoing_insbytes
;
1647 GPT_BYTE
+= outgoing_insbytes
;
1648 ZV_BYTE
+= outgoing_insbytes
;
1649 Z_BYTE
+= outgoing_insbytes
;
1650 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1655 /* Adjust the overlay center as needed. This must be done after
1656 adjusting the markers that bound the overlays. */
1657 adjust_overlays_for_delete (from
, nchars_del
);
1658 adjust_overlays_for_insert (from
, inschars
);
1660 /* Adjust markers for the deletion and the insertion. */
1662 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1663 inschars
, outgoing_insbytes
);
1665 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1667 /* Get the intervals for the part of the string we are inserting--
1668 not including the combined-before bytes. */
1669 intervals
= STRING_INTERVALS (new);
1670 /* Insert those intervals. */
1671 graft_intervals_into_buffer (intervals
, from
, inschars
,
1672 current_buffer
, inherit
);
1674 /* Relocate point as if it were a marker. */
1676 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1677 (from_byte
+ outgoing_insbytes
1678 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1680 if (outgoing_insbytes
== 0)
1681 evaporate_overlays (from
);
1686 CHARS_MODIFF
= MODIFF
;
1689 signal_after_change (from
, nchars_del
, GPT
- from
);
1690 update_compositions (from
, GPT
, CHECK_BORDER
);
1693 /* Replace the text from character positions FROM to TO with
1694 the text in INS of length INSCHARS.
1695 Keep the text properties that applied to the old characters
1696 (extending them to all the new chars if there are more new chars).
1698 Note that this does not yet handle markers quite right.
1700 If MARKERS is nonzero, relocate markers.
1702 Unlike most functions at this level, never call
1703 prepare_to_modify_buffer and never call signal_after_change. */
1706 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1707 int from
, from_byte
, to
, to_byte
;
1709 int inschars
, insbytes
, markers
;
1711 int nbytes_del
, nchars_del
;
1716 nchars_del
= to
- from
;
1717 nbytes_del
= to_byte
- from_byte
;
1719 if (nbytes_del
<= 0 && insbytes
== 0)
1722 /* Make sure point-max won't overflow after this insertion. */
1723 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1724 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1725 error ("Maximum buffer size exceeded");
1727 /* Make sure the gap is somewhere in or next to what we are deleting. */
1729 gap_right (from
, from_byte
);
1731 gap_left (to
, to_byte
, 0);
1733 GAP_SIZE
+= nbytes_del
;
1736 ZV_BYTE
-= nbytes_del
;
1737 Z_BYTE
-= nbytes_del
;
1739 GPT_BYTE
= from_byte
;
1740 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1745 if (GPT
- BEG
< BEG_UNCHANGED
)
1746 BEG_UNCHANGED
= GPT
- BEG
;
1747 if (Z
- GPT
< END_UNCHANGED
)
1748 END_UNCHANGED
= Z
- GPT
;
1750 if (GAP_SIZE
< insbytes
)
1751 make_gap (insbytes
- GAP_SIZE
);
1753 /* Copy the replacement text into the buffer. */
1754 bcopy (ins
, GPT_ADDR
, insbytes
);
1756 #ifdef BYTE_COMBINING_DEBUG
1757 /* We have copied text into the gap, but we have not marked
1758 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1759 here, for both the previous text and the following text.
1760 Meanwhile, GPT_ADDR does point to
1761 the text that has been stored by copy_text. */
1762 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1763 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1767 GAP_SIZE
-= insbytes
;
1771 GPT_BYTE
+= insbytes
;
1772 ZV_BYTE
+= insbytes
;
1774 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1779 /* Adjust the overlay center as needed. This must be done after
1780 adjusting the markers that bound the overlays. */
1781 if (nchars_del
!= inschars
)
1783 adjust_overlays_for_insert (from
, inschars
);
1784 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1787 /* Adjust markers for the deletion and the insertion. */
1789 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1790 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1791 inschars
, insbytes
);
1793 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1795 /* Relocate point as if it were a marker. */
1796 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1799 /* PT was within the deleted text. Move it to FROM. */
1800 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1802 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1806 evaporate_overlays (from
);
1811 CHARS_MODIFF
= MODIFF
;
1814 /* Delete characters in current buffer
1815 from FROM up to (but not including) TO.
1816 If TO comes before FROM, we delete nothing. */
1819 del_range (from
, to
)
1820 register int from
, to
;
1822 del_range_1 (from
, to
, 1, 0);
1825 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1826 RET_STRING says to return the deleted text. */
1829 del_range_1 (from
, to
, prepare
, ret_string
)
1830 int from
, to
, prepare
, ret_string
;
1832 int from_byte
, to_byte
;
1833 Lisp_Object deletion
;
1834 struct gcpro gcpro1
;
1836 /* Make args be valid */
1847 int range_length
= to
- from
;
1848 prepare_to_modify_buffer (from
, to
, &from
);
1849 to
= min (ZV
, from
+ range_length
);
1852 from_byte
= CHAR_TO_BYTE (from
);
1853 to_byte
= CHAR_TO_BYTE (to
);
1855 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1857 signal_after_change (from
, to
- from
, 0);
1858 update_compositions (from
, from
, CHECK_HEAD
);
1863 /* Like del_range_1 but args are byte positions, not char positions. */
1866 del_range_byte (from_byte
, to_byte
, prepare
)
1867 int from_byte
, to_byte
, prepare
;
1871 /* Make args be valid */
1872 if (from_byte
< BEGV_BYTE
)
1873 from_byte
= BEGV_BYTE
;
1874 if (to_byte
> ZV_BYTE
)
1877 if (to_byte
<= from_byte
)
1880 from
= BYTE_TO_CHAR (from_byte
);
1881 to
= BYTE_TO_CHAR (to_byte
);
1885 int old_from
= from
, old_to
= Z
- to
;
1886 int range_length
= to
- from
;
1887 prepare_to_modify_buffer (from
, to
, &from
);
1888 to
= from
+ range_length
;
1890 if (old_from
!= from
)
1891 from_byte
= CHAR_TO_BYTE (from
);
1897 else if (old_to
== Z
- to
)
1898 to_byte
= CHAR_TO_BYTE (to
);
1901 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1902 signal_after_change (from
, to
- from
, 0);
1903 update_compositions (from
, from
, CHECK_HEAD
);
1906 /* Like del_range_1, but positions are specified both as charpos
1910 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1911 int from
, from_byte
, to
, to_byte
, prepare
;
1913 /* Make args be valid */
1914 if (from_byte
< BEGV_BYTE
)
1915 from_byte
= BEGV_BYTE
;
1916 if (to_byte
> ZV_BYTE
)
1919 if (to_byte
<= from_byte
)
1929 int old_from
= from
, old_to
= Z
- to
;
1930 int range_length
= to
- from
;
1931 prepare_to_modify_buffer (from
, to
, &from
);
1932 to
= from
+ range_length
;
1934 if (old_from
!= from
)
1935 from_byte
= CHAR_TO_BYTE (from
);
1941 else if (old_to
== Z
- to
)
1942 to_byte
= CHAR_TO_BYTE (to
);
1945 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1946 signal_after_change (from
, to
- from
, 0);
1947 update_compositions (from
, from
, CHECK_HEAD
);
1950 /* Delete a range of text, specified both as character positions
1951 and byte positions. FROM and TO are character positions,
1952 while FROM_BYTE and TO_BYTE are byte positions.
1953 If RET_STRING is true, the deleted area is returned as a string. */
1956 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1957 int from
, from_byte
, to
, to_byte
, ret_string
;
1959 register int nbytes_del
, nchars_del
;
1960 Lisp_Object deletion
;
1964 nchars_del
= to
- from
;
1965 nbytes_del
= to_byte
- from_byte
;
1967 /* Make sure the gap is somewhere in or next to what we are deleting. */
1969 gap_right (from
, from_byte
);
1971 gap_left (to
, to_byte
, 0);
1973 #ifdef BYTE_COMBINING_DEBUG
1974 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1975 Z_BYTE
- to_byte
, from
, from_byte
))
1979 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1980 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1984 /* Relocate all markers pointing into the new, larger gap
1985 to point at the end of the text before the gap.
1986 Do this before recording the deletion,
1987 so that undo handles this after reinserting the text. */
1988 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1990 if (! EQ (current_buffer
->undo_list
, Qt
))
1991 record_delete (from
, deletion
);
1993 CHARS_MODIFF
= MODIFF
;
1995 /* Relocate point as if it were a marker. */
1997 adjust_point (from
- (PT
< to
? PT
: to
),
1998 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
2000 offset_intervals (current_buffer
, from
, - nchars_del
);
2002 /* Adjust the overlay center as needed. This must be done after
2003 adjusting the markers that bound the overlays. */
2004 adjust_overlays_for_delete (from
, nchars_del
);
2006 GAP_SIZE
+= nbytes_del
;
2007 ZV_BYTE
-= nbytes_del
;
2008 Z_BYTE
-= nbytes_del
;
2012 GPT_BYTE
= from_byte
;
2013 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
2018 if (GPT
- BEG
< BEG_UNCHANGED
)
2019 BEG_UNCHANGED
= GPT
- BEG
;
2020 if (Z
- GPT
< END_UNCHANGED
)
2021 END_UNCHANGED
= Z
- GPT
;
2025 evaporate_overlays (from
);
2030 /* Call this if you're about to change the region of BUFFER from
2031 character positions START to END. This checks the read-only
2032 properties of the region, calls the necessary modification hooks,
2033 and warns the next redisplay that it should pay attention to that
2036 If PRESERVE_CHARS_MODIFF is non-zero, do not update CHARS_MODIFF.
2037 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
2040 modify_region (buffer
, start
, end
, preserve_chars_modiff
)
2041 struct buffer
*buffer
;
2042 int start
, end
, preserve_chars_modiff
;
2044 struct buffer
*old_buffer
= current_buffer
;
2046 if (buffer
!= old_buffer
)
2047 set_buffer_internal (buffer
);
2049 prepare_to_modify_buffer (start
, end
, NULL
);
2051 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
2053 if (MODIFF
<= SAVE_MODIFF
)
2054 record_first_change ();
2056 if (! preserve_chars_modiff
)
2057 CHARS_MODIFF
= MODIFF
;
2059 buffer
->point_before_scroll
= Qnil
;
2061 if (buffer
!= old_buffer
)
2062 set_buffer_internal (old_buffer
);
2065 /* Check that it is okay to modify the buffer between START and END,
2066 which are char positions.
2068 Run the before-change-function, if any. If intervals are in use,
2069 verify that the text to be modified is not read-only, and call
2070 any modification properties the text may have.
2072 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2073 by holding its value temporarily in a marker. */
2076 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2080 struct buffer
*base_buffer
;
2082 if (!NILP (current_buffer
->read_only
))
2083 Fbarf_if_buffer_read_only ();
2085 /* Let redisplay consider other windows than selected_window
2086 if modifying another buffer. */
2087 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2088 ++windows_or_buffers_changed
;
2090 if (BUF_INTERVALS (current_buffer
) != 0)
2094 Lisp_Object preserve_marker
;
2095 struct gcpro gcpro1
;
2096 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2097 GCPRO1 (preserve_marker
);
2098 verify_interval_modification (current_buffer
, start
, end
);
2099 *preserve_ptr
= marker_position (preserve_marker
);
2100 unchain_marker (XMARKER (preserve_marker
));
2104 verify_interval_modification (current_buffer
, start
, end
);
2107 /* For indirect buffers, use the base buffer to check clashes. */
2108 if (current_buffer
->base_buffer
!= 0)
2109 base_buffer
= current_buffer
->base_buffer
;
2111 base_buffer
= current_buffer
;
2113 #ifdef CLASH_DETECTION
2114 if (!NILP (base_buffer
->file_truename
)
2115 /* Make binding buffer-file-name to nil effective. */
2116 && !NILP (base_buffer
->filename
)
2117 && SAVE_MODIFF
>= MODIFF
)
2118 lock_file (base_buffer
->file_truename
);
2120 /* At least warn if this file has changed on disk since it was visited. */
2121 if (!NILP (base_buffer
->filename
)
2122 && SAVE_MODIFF
>= MODIFF
2123 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2124 && !NILP (Ffile_exists_p (base_buffer
->filename
)))
2125 call1 (intern ("ask-user-about-supersession-threat"),
2126 base_buffer
->filename
);
2127 #endif /* not CLASH_DETECTION */
2129 signal_before_change (start
, end
, preserve_ptr
);
2131 if (current_buffer
->newline_cache
)
2132 invalidate_region_cache (current_buffer
,
2133 current_buffer
->newline_cache
,
2134 start
- BEG
, Z
- end
);
2135 if (current_buffer
->width_run_cache
)
2136 invalidate_region_cache (current_buffer
,
2137 current_buffer
->width_run_cache
,
2138 start
- BEG
, Z
- end
);
2140 Vdeactivate_mark
= Qt
;
2143 /* These macros work with an argument named `preserve_ptr'
2144 and a local variable named `preserve_marker'. */
2146 #define PRESERVE_VALUE \
2147 if (preserve_ptr && NILP (preserve_marker)) \
2148 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2150 #define RESTORE_VALUE \
2151 if (! NILP (preserve_marker)) \
2153 *preserve_ptr = marker_position (preserve_marker); \
2154 unchain_marker (XMARKER (preserve_marker)); \
2157 #define PRESERVE_START_END \
2158 if (NILP (start_marker)) \
2159 start_marker = Fcopy_marker (start, Qnil); \
2160 if (NILP (end_marker)) \
2161 end_marker = Fcopy_marker (end, Qnil);
2163 #define FETCH_START \
2164 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2167 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2169 /* Signal a change to the buffer immediately before it happens.
2170 START_INT and END_INT are the bounds of the text to be changed.
2172 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2173 by holding its value temporarily in a marker. */
2176 signal_before_change (start_int
, end_int
, preserve_ptr
)
2177 int start_int
, end_int
;
2180 Lisp_Object start
, end
;
2181 Lisp_Object start_marker
, end_marker
;
2182 Lisp_Object preserve_marker
;
2183 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2185 if (inhibit_modification_hooks
)
2188 start
= make_number (start_int
);
2189 end
= make_number (end_int
);
2190 preserve_marker
= Qnil
;
2191 start_marker
= Qnil
;
2193 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2195 /* If buffer is unmodified, run a special hook for that case. */
2196 if (SAVE_MODIFF
>= MODIFF
2197 && !NILP (Vfirst_change_hook
)
2198 && !NILP (Vrun_hooks
))
2202 call1 (Vrun_hooks
, Qfirst_change_hook
);
2205 /* Now run the before-change-functions if any. */
2206 if (!NILP (Vbefore_change_functions
))
2208 Lisp_Object args
[3];
2209 Lisp_Object before_change_functions
;
2210 Lisp_Object after_change_functions
;
2211 struct gcpro gcpro1
, gcpro2
;
2212 struct buffer
*old
= current_buffer
;
2218 /* "Bind" before-change-functions and after-change-functions
2219 to nil--but in a way that errors don't know about.
2220 That way, if there's an error in them, they will stay nil. */
2221 before_change_functions
= Vbefore_change_functions
;
2222 after_change_functions
= Vafter_change_functions
;
2223 Vbefore_change_functions
= Qnil
;
2224 Vafter_change_functions
= Qnil
;
2225 GCPRO2 (before_change_functions
, after_change_functions
);
2227 /* Actually run the hook functions. */
2228 args
[0] = Qbefore_change_functions
;
2229 args
[1] = FETCH_START
;
2230 args
[2] = FETCH_END
;
2231 run_hook_list_with_args (before_change_functions
, 3, args
);
2233 /* "Unbind" the variables we "bound" to nil. Beware a
2234 buffer-local hook which changes the buffer when run (e.g. W3). */
2235 if (old
!= current_buffer
)
2237 new = current_buffer
;
2238 set_buffer_internal (old
);
2239 Vbefore_change_functions
= before_change_functions
;
2240 Vafter_change_functions
= after_change_functions
;
2241 set_buffer_internal (new);
2245 Vbefore_change_functions
= before_change_functions
;
2246 Vafter_change_functions
= after_change_functions
;
2251 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2254 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2255 FETCH_START
, FETCH_END
, Qnil
);
2258 if (! NILP (start_marker
))
2259 free_marker (start_marker
);
2260 if (! NILP (end_marker
))
2261 free_marker (end_marker
);
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 if (inhibit_modification_hooks
)
2280 /* If we are deferring calls to the after-change functions
2281 and there are no before-change functions,
2282 just record the args that we were going to use. */
2283 if (! NILP (Vcombine_after_change_calls
)
2284 && NILP (Vbefore_change_functions
)
2285 && !current_buffer
->overlays_before
2286 && !current_buffer
->overlays_after
)
2290 if (!NILP (combine_after_change_list
)
2291 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2292 Fcombine_after_change_execute ();
2294 elt
= Fcons (make_number (charpos
- BEG
),
2295 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2296 Fcons (make_number (lenins
- lendel
), Qnil
)));
2297 combine_after_change_list
2298 = Fcons (elt
, combine_after_change_list
);
2299 combine_after_change_buffer
= Fcurrent_buffer ();
2304 if (!NILP (combine_after_change_list
))
2305 Fcombine_after_change_execute ();
2307 if (!NILP (Vafter_change_functions
))
2309 Lisp_Object args
[4];
2310 Lisp_Object before_change_functions
;
2311 Lisp_Object after_change_functions
;
2312 struct buffer
*old
= current_buffer
;
2314 struct gcpro gcpro1
, gcpro2
;
2316 /* "Bind" before-change-functions and after-change-functions
2317 to nil--but in a way that errors don't know about.
2318 That way, if there's an error in them, they will stay nil. */
2319 before_change_functions
= Vbefore_change_functions
;
2320 after_change_functions
= Vafter_change_functions
;
2321 Vbefore_change_functions
= Qnil
;
2322 Vafter_change_functions
= Qnil
;
2323 GCPRO2 (before_change_functions
, after_change_functions
);
2325 /* Actually run the hook functions. */
2326 args
[0] = Qafter_change_functions
;
2327 XSETFASTINT (args
[1], charpos
);
2328 XSETFASTINT (args
[2], charpos
+ lenins
);
2329 XSETFASTINT (args
[3], lendel
);
2330 run_hook_list_with_args (after_change_functions
,
2333 /* "Unbind" the variables we "bound" to nil. Beware a
2334 buffer-local hook which changes the buffer when run (e.g. W3). */
2335 if (old
!= current_buffer
)
2337 new = current_buffer
;
2338 set_buffer_internal (old
);
2339 Vbefore_change_functions
= before_change_functions
;
2340 Vafter_change_functions
= after_change_functions
;
2341 set_buffer_internal (new);
2345 Vbefore_change_functions
= before_change_functions
;
2346 Vafter_change_functions
= after_change_functions
;
2351 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2352 report_overlay_modification (make_number (charpos
),
2353 make_number (charpos
+ lenins
),
2355 make_number (charpos
),
2356 make_number (charpos
+ lenins
),
2357 make_number (lendel
));
2359 /* After an insertion, call the text properties
2360 insert-behind-hooks or insert-in-front-hooks. */
2362 report_interval_modification (make_number (charpos
),
2363 make_number (charpos
+ lenins
));
2367 Fcombine_after_change_execute_1 (val
)
2370 Vcombine_after_change_calls
= val
;
2374 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2375 Scombine_after_change_execute
, 0, 0, 0,
2376 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2379 int count
= SPECPDL_INDEX ();
2380 int beg
, end
, change
;
2384 if (NILP (combine_after_change_list
))
2387 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2389 Fset_buffer (combine_after_change_buffer
);
2391 /* # chars unchanged at beginning of buffer. */
2393 /* # chars unchanged at end of buffer. */
2395 /* Total amount of insertion (negative for deletion). */
2398 /* Scan the various individual changes,
2399 accumulating the range info in BEG, END and CHANGE. */
2400 for (tail
= combine_after_change_list
; CONSP (tail
);
2404 int thisbeg
, thisend
, thischange
;
2406 /* Extract the info from the next element. */
2410 thisbeg
= XINT (XCAR (elt
));
2415 thisend
= XINT (XCAR (elt
));
2420 thischange
= XINT (XCAR (elt
));
2422 /* Merge this range into the accumulated range. */
2423 change
+= thischange
;
2430 /* Get the current start and end positions of the range
2431 that was changed. */
2435 /* We are about to handle these, so discard them. */
2436 combine_after_change_list
= Qnil
;
2438 /* Now run the after-change functions for real.
2439 Turn off the flag that defers them. */
2440 record_unwind_protect (Fcombine_after_change_execute_1
,
2441 Vcombine_after_change_calls
);
2442 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2443 update_compositions (begpos
, endpos
, CHECK_ALL
);
2445 return unbind_to (count
, Qnil
);
2451 staticpro (&combine_after_change_list
);
2452 staticpro (&combine_after_change_buffer
);
2453 combine_after_change_list
= Qnil
;
2454 combine_after_change_buffer
= Qnil
;
2456 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2457 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2458 check_markers_debug_flag
= 0;
2459 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2460 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2461 Vcombine_after_change_calls
= Qnil
;
2463 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2464 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2465 This affects `before-change-functions' and `after-change-functions',
2466 as well as hooks attached to text properties and overlays. */);
2467 inhibit_modification_hooks
= 0;
2468 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2469 staticpro (&Qinhibit_modification_hooks
);
2471 defsubr (&Scombine_after_change_execute
);
2474 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2475 (do not change this comment) */