1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985-1986, 1993-1995, 1997-2012
3 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 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
27 #include "intervals.h"
28 #include "character.h"
31 #include "blockinput.h"
32 #include "region-cache.h"
34 static void insert_from_string_1 (Lisp_Object
, ptrdiff_t, ptrdiff_t, ptrdiff_t,
35 ptrdiff_t, bool, bool);
36 static void insert_from_buffer_1 (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
37 static void gap_left (ptrdiff_t, ptrdiff_t, bool);
38 static void gap_right (ptrdiff_t, ptrdiff_t);
40 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
41 describing changes which happened while combine_after_change_calls
42 was non-nil. We use this to decide how to call them
43 once the deferral ends.
46 BEG-UNCHANGED is the number of chars before the changed range.
47 END-UNCHANGED is the number of chars after the changed range,
48 and CHANGE-AMOUNT is the number of characters inserted by the change
49 (negative for a deletion). */
50 static Lisp_Object combine_after_change_list
;
52 /* Buffer which combine_after_change_list is about. */
53 static Lisp_Object combine_after_change_buffer
;
55 Lisp_Object Qinhibit_modification_hooks
;
57 static void signal_before_change (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
59 /* Also used in marker.c to enable expensive marker checks. */
66 struct Lisp_Marker
*tail
;
67 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
69 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
71 if (tail
->buffer
->text
!= current_buffer
->text
)
73 if (tail
->charpos
> Z
)
75 if (tail
->bytepos
> Z_BYTE
)
77 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
82 #else /* not MARKER_DEBUG */
84 #define check_markers() do { } while (0)
86 #endif /* MARKER_DEBUG */
88 /* Move gap to position CHARPOS.
89 Note that this can quit! */
92 move_gap (ptrdiff_t charpos
)
94 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
97 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
98 Note that this can quit! */
101 move_gap_both (ptrdiff_t charpos
, ptrdiff_t bytepos
)
103 if (bytepos
< GPT_BYTE
)
104 gap_left (charpos
, bytepos
, 0);
105 else if (bytepos
> GPT_BYTE
)
106 gap_right (charpos
, bytepos
);
109 /* Move the gap to a position less than the current GPT.
110 BYTEPOS describes the new position as a byte position,
111 and CHARPOS is the corresponding char position.
112 If NEWGAP, then don't update beg_unchanged and end_unchanged. */
115 gap_left (ptrdiff_t charpos
, ptrdiff_t bytepos
, bool newgap
)
117 unsigned char *to
, *from
;
122 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
129 /* Now copy the characters. To move the gap down,
130 copy characters up. */
134 /* I gets number of characters left to copy. */
135 i
= new_s1
- bytepos
;
138 /* If a quit is requested, stop copying now.
139 Change BYTEPOS to be where we have actually moved the gap to. */
143 charpos
= BYTE_TO_CHAR (bytepos
);
146 /* Move at most 32000 chars before checking again for a quit. */
151 memmove (to
, from
, i
);
154 /* Adjust buffer data structure, to put the gap at BYTEPOS.
155 BYTEPOS is where the loop above stopped, which may be what
156 was specified or may be where a quit was detected. */
159 eassert (charpos
<= bytepos
);
160 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
164 /* Move the gap to a position greater than the current GPT.
165 BYTEPOS describes the new position as a byte position,
166 and CHARPOS is the corresponding char position. */
169 gap_right (ptrdiff_t charpos
, ptrdiff_t bytepos
)
171 register unsigned char *to
, *from
;
172 register ptrdiff_t i
;
175 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
182 /* Now copy the characters. To move the gap up,
183 copy characters down. */
187 /* I gets number of characters left to copy. */
188 i
= bytepos
- new_s1
;
191 /* If a quit is requested, stop copying now.
192 Change BYTEPOS to be where we have actually moved the gap to. */
196 charpos
= BYTE_TO_CHAR (bytepos
);
199 /* Move at most 32000 chars before checking again for a quit. */
203 memmove (to
, from
, i
);
209 eassert (charpos
<= bytepos
);
210 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
214 /* Adjust all markers for a deletion
215 whose range in bytes is FROM_BYTE to TO_BYTE.
216 The range in charpos is FROM to TO.
218 This function assumes that the gap is adjacent to
219 or inside of the range being deleted. */
222 adjust_markers_for_delete (ptrdiff_t from
, ptrdiff_t from_byte
,
223 ptrdiff_t to
, ptrdiff_t to_byte
)
226 register struct Lisp_Marker
*m
;
227 register ptrdiff_t charpos
;
229 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
231 charpos
= m
->charpos
;
232 eassert (charpos
<= Z
);
234 /* If the marker is after the deletion,
235 relocate by number of chars / bytes deleted. */
238 m
->charpos
-= to
- from
;
239 m
->bytepos
-= to_byte
- from_byte
;
241 /* Here's the case where a marker is inside text being deleted. */
242 else if (charpos
> from
)
244 if (! m
->insertion_type
)
245 { /* Normal markers will end up at the beginning of the
246 re-inserted text after undoing a deletion, and must be
247 adjusted to move them to the correct place. */
248 XSETMISC (marker
, m
);
249 record_marker_adjustment (marker
, from
- charpos
);
251 else if (charpos
< to
)
252 { /* Before-insertion markers will automatically move forward
253 upon re-inserting the deleted text, so we have to arrange
254 for them to move backward to the correct position. */
255 XSETMISC (marker
, m
);
256 record_marker_adjustment (marker
, to
- charpos
);
259 m
->bytepos
= from_byte
;
261 /* Here's the case where a before-insertion marker is immediately
262 before the deleted region. */
263 else if (charpos
== from
&& m
->insertion_type
)
265 /* Undoing the change uses normal insertion, which will
266 incorrectly make MARKER move forward, so we arrange for it
267 to then move backward to the correct place at the beginning
268 of the deleted region. */
269 XSETMISC (marker
, m
);
270 record_marker_adjustment (marker
, to
- from
);
276 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
277 to TO / TO_BYTE. We have to relocate the charpos of every marker
278 that points after the insertion (but not their bytepos).
280 When a marker points at the insertion point,
281 we advance it if either its insertion-type is t
282 or BEFORE_MARKERS is true. */
285 adjust_markers_for_insert (ptrdiff_t from
, ptrdiff_t from_byte
,
286 ptrdiff_t to
, ptrdiff_t to_byte
, bool before_markers
)
288 struct Lisp_Marker
*m
;
290 ptrdiff_t nchars
= to
- from
;
291 ptrdiff_t nbytes
= to_byte
- from_byte
;
293 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
295 eassert (m
->bytepos
>= m
->charpos
296 && m
->bytepos
- m
->charpos
<= Z_BYTE
- Z
);
298 if (m
->bytepos
== from_byte
)
300 if (m
->insertion_type
|| before_markers
)
302 m
->bytepos
= to_byte
;
304 if (m
->insertion_type
)
308 else if (m
->bytepos
> from_byte
)
310 m
->bytepos
+= nbytes
;
311 m
->charpos
+= nchars
;
315 /* Adjusting only markers whose insertion-type is t may result in
316 - disordered start and end in overlays, and
317 - disordered overlays in the slot `overlays_before' of current_buffer. */
320 fix_start_end_in_overlays (from
, to
);
321 fix_overlays_before (current_buffer
, from
, to
);
325 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
327 This is used only when the value of point changes due to an insert
328 or delete; it does not represent a conceptual change in point as a
329 marker. In particular, point is not crossing any interval
330 boundaries, so there's no need to use the usual SET_PT macro. In
331 fact it would be incorrect to do so, because either the old or the
332 new value of point is out of sync with the current set of
336 adjust_point (ptrdiff_t nchars
, ptrdiff_t nbytes
)
338 SET_BUF_PT_BOTH (current_buffer
, PT
+ nchars
, PT_BYTE
+ nbytes
);
339 /* In a single-byte buffer, the two positions must be equal. */
340 eassert (PT_BYTE
>= PT
&& PT_BYTE
- PT
<= ZV_BYTE
- ZV
);
343 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
344 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
345 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
349 adjust_markers_for_replace (ptrdiff_t from
, ptrdiff_t from_byte
,
350 ptrdiff_t old_chars
, ptrdiff_t old_bytes
,
351 ptrdiff_t new_chars
, ptrdiff_t new_bytes
)
353 register struct Lisp_Marker
*m
;
354 ptrdiff_t prev_to_byte
= from_byte
+ old_bytes
;
355 ptrdiff_t diff_chars
= new_chars
- old_chars
;
356 ptrdiff_t diff_bytes
= new_bytes
- old_bytes
;
358 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
360 if (m
->bytepos
>= prev_to_byte
)
362 m
->charpos
+= diff_chars
;
363 m
->bytepos
+= diff_bytes
;
365 else if (m
->bytepos
> from_byte
)
368 m
->bytepos
= from_byte
;
377 buffer_overflow (void)
379 error ("Maximum buffer size exceeded");
382 /* Make the gap NBYTES_ADDED bytes longer. */
385 make_gap_larger (ptrdiff_t nbytes_added
)
388 ptrdiff_t real_gap_loc
;
389 ptrdiff_t real_gap_loc_byte
;
390 ptrdiff_t old_gap_size
;
391 ptrdiff_t current_size
= Z_BYTE
- BEG_BYTE
+ GAP_SIZE
;
392 enum { enough_for_a_while
= 2000 };
394 if (BUF_BYTES_MAX
- current_size
< nbytes_added
)
397 /* If we have to get more space, get enough to last a while;
398 but do not exceed the maximum buffer size. */
399 nbytes_added
= min (nbytes_added
+ enough_for_a_while
,
400 BUF_BYTES_MAX
- current_size
);
402 enlarge_buffer_text (current_buffer
, nbytes_added
);
404 /* Prevent quitting in move_gap. */
409 real_gap_loc_byte
= GPT_BYTE
;
410 old_gap_size
= GAP_SIZE
;
412 /* Call the newly allocated space a gap at the end of the whole space. */
414 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
415 GAP_SIZE
= nbytes_added
;
417 /* Move the new gap down to be consecutive with the end of the old one.
418 This adjusts the markers properly too. */
419 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
421 /* Now combine the two into one large gap. */
422 GAP_SIZE
+= old_gap_size
;
424 GPT_BYTE
= real_gap_loc_byte
;
432 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
434 /* Make the gap NBYTES_REMOVED bytes shorter. */
437 make_gap_smaller (ptrdiff_t nbytes_removed
)
440 ptrdiff_t real_gap_loc
;
441 ptrdiff_t real_gap_loc_byte
;
443 ptrdiff_t real_Z_byte
;
444 ptrdiff_t real_beg_unchanged
;
445 ptrdiff_t new_gap_size
;
447 /* Make sure the gap is at least 20 bytes. */
448 if (GAP_SIZE
- nbytes_removed
< 20)
449 nbytes_removed
= GAP_SIZE
- 20;
451 /* Prevent quitting in move_gap. */
456 real_gap_loc_byte
= GPT_BYTE
;
457 new_gap_size
= GAP_SIZE
- nbytes_removed
;
459 real_Z_byte
= Z_BYTE
;
460 real_beg_unchanged
= BEG_UNCHANGED
;
462 /* Pretend that the last unwanted part of the gap is the entire gap,
463 and that the first desired part of the gap is part of the buffer
465 memset (GPT_ADDR
, 0, new_gap_size
);
467 GPT_BYTE
+= new_gap_size
;
469 Z_BYTE
+= new_gap_size
;
470 GAP_SIZE
= nbytes_removed
;
472 /* Move the unwanted pretend gap to the end of the buffer. This
473 adjusts the markers properly too. */
474 gap_right (Z
, Z_BYTE
);
476 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
478 /* Now restore the desired gap. */
479 GAP_SIZE
= new_gap_size
;
481 GPT_BYTE
= real_gap_loc_byte
;
483 Z_BYTE
= real_Z_byte
;
484 BEG_UNCHANGED
= real_beg_unchanged
;
492 #endif /* USE_MMAP_FOR_BUFFERS || REL_ALLOC || DOUG_LEA_MALLOC */
495 make_gap (ptrdiff_t nbytes_added
)
497 if (nbytes_added
>= 0)
498 make_gap_larger (nbytes_added
);
499 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
501 make_gap_smaller (-nbytes_added
);
505 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
506 FROM_MULTIBYTE says whether the incoming text is multibyte.
507 TO_MULTIBYTE says whether to store the text as multibyte.
508 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
510 Return the number of bytes stored at TO_ADDR. */
513 copy_text (const unsigned char *from_addr
, unsigned char *to_addr
,
514 ptrdiff_t nbytes
, bool from_multibyte
, bool to_multibyte
)
516 if (from_multibyte
== to_multibyte
)
518 memcpy (to_addr
, from_addr
, nbytes
);
521 else if (from_multibyte
)
523 ptrdiff_t nchars
= 0;
524 ptrdiff_t bytes_left
= nbytes
;
526 while (bytes_left
> 0)
529 c
= STRING_CHAR_AND_LENGTH (from_addr
, thislen
);
530 if (! ASCII_CHAR_P (c
))
533 from_addr
+= thislen
;
534 bytes_left
-= thislen
;
541 unsigned char *initial_to_addr
= to_addr
;
543 /* Convert single-byte to multibyte. */
546 int c
= *from_addr
++;
548 if (!ASCII_CHAR_P (c
))
550 c
= BYTE8_TO_CHAR (c
);
551 to_addr
+= CHAR_STRING (c
, to_addr
);
555 /* Special case for speed. */
556 *to_addr
++ = c
, nbytes
--;
558 return to_addr
- initial_to_addr
;
562 /* Insert a string of specified length before point.
563 This function judges multibyteness based on
564 enable_multibyte_characters in the current buffer;
565 it never converts between single-byte and multibyte.
567 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
568 prepare_to_modify_buffer could relocate the text. */
571 insert (const char *string
, ptrdiff_t nbytes
)
575 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
576 insert_1_both (string
, len
, nbytes
, 0, 1, 0);
578 signal_after_change (opoint
, 0, len
);
579 update_compositions (opoint
, PT
, CHECK_BORDER
);
583 /* Likewise, but inherit text properties from neighboring characters. */
586 insert_and_inherit (const char *string
, ptrdiff_t nbytes
)
590 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
591 insert_1_both (string
, len
, nbytes
, 1, 1, 0);
593 signal_after_change (opoint
, 0, len
);
594 update_compositions (opoint
, PT
, CHECK_BORDER
);
598 /* Insert the character C before point. Do not inherit text properties. */
603 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
606 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
607 len
= CHAR_STRING (c
, str
);
614 insert ((char *) str
, len
);
617 /* Insert the null-terminated string S before point. */
620 insert_string (const char *s
)
622 insert (s
, strlen (s
));
625 /* Like `insert' except that all markers pointing at the place where
626 the insertion happens are adjusted to point after it.
627 Don't use this function to insert part of a Lisp string,
628 since gc could happen and relocate it. */
631 insert_before_markers (const char *string
, ptrdiff_t nbytes
)
635 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
636 insert_1_both (string
, len
, nbytes
, 0, 1, 1);
638 signal_after_change (opoint
, 0, len
);
639 update_compositions (opoint
, PT
, CHECK_BORDER
);
643 /* Likewise, but inherit text properties from neighboring characters. */
646 insert_before_markers_and_inherit (const char *string
,
651 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
652 insert_1_both (string
, len
, nbytes
, 1, 1, 1);
654 signal_after_change (opoint
, 0, len
);
655 update_compositions (opoint
, PT
, CHECK_BORDER
);
659 /* Subroutine used by the insert functions above. */
662 insert_1 (const char *string
, ptrdiff_t nbytes
,
663 bool inherit
, bool prepare
, bool before_markers
)
665 insert_1_both (string
, chars_in_text ((unsigned char *) string
, nbytes
),
666 nbytes
, inherit
, prepare
, before_markers
);
670 #ifdef BYTE_COMBINING_DEBUG
672 /* See if the bytes before POS/POS_BYTE combine with bytes
673 at the start of STRING to form a single character.
674 If so, return the number of bytes at the start of STRING
675 which combine in this way. Otherwise, return 0. */
678 count_combining_before (const unsigned char *string
, ptrdiff_t length
,
679 ptrdiff_t pos
, ptrdiff_t pos_byte
)
681 int len
, combining_bytes
;
682 const unsigned char *p
;
684 if (NILP (current_buffer
->enable_multibyte_characters
))
687 /* At first, we can exclude the following cases:
688 (1) STRING[0] can't be a following byte of multibyte sequence.
689 (2) POS is the start of the current buffer.
690 (3) A character before POS is not a multibyte character. */
691 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
693 if (pos_byte
== BEG_BYTE
) /* case (2) */
696 p
= BYTE_POS_ADDR (pos_byte
- 1);
697 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
698 if (! LEADING_CODE_P (*p
)) /* case (3) */
701 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
702 if (combining_bytes
<= 0)
703 /* The character preceding POS is, complete and no room for
704 combining bytes (combining_bytes == 0), or an independent 8-bit
705 character (combining_bytes < 0). */
708 /* We have a combination situation. Count the bytes at STRING that
711 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
714 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
717 /* See if the bytes after POS/POS_BYTE combine with bytes
718 at the end of STRING to form a single character.
719 If so, return the number of bytes after POS/POS_BYTE
720 which combine in this way. Otherwise, return 0. */
723 count_combining_after (const unsigned char *string
,
724 ptrdiff_t length
, ptrdiff_t pos
, ptrdiff_t pos_byte
)
726 ptrdiff_t opos_byte
= pos_byte
;
731 if (NILP (current_buffer
->enable_multibyte_characters
))
734 /* At first, we can exclude the following cases:
735 (1) The last byte of STRING is an ASCII.
736 (2) POS is the last of the current buffer.
737 (3) A character at POS can't be a following byte of multibyte
739 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
741 if (pos_byte
== Z_BYTE
) /* case (2) */
743 bufp
= BYTE_POS_ADDR (pos_byte
);
744 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
748 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
754 /* All characters in STRING are not character head. We must
755 check also preceding bytes at POS. We are sure that the gap
757 unsigned char *p
= BEG_ADDR
;
759 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
761 if (i
< 0 || !LEADING_CODE_P (p
[i
]))
764 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
765 return (bytes
<= pos_byte
- 1 - i
+ length
767 : bytes
- (pos_byte
- 1 - i
+ length
));
769 if (!LEADING_CODE_P (string
[i
]))
772 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
774 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
776 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
782 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
783 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
784 are the same as in insert_1. */
787 insert_1_both (const char *string
,
788 ptrdiff_t nchars
, ptrdiff_t nbytes
,
789 bool inherit
, bool prepare
, bool before_markers
)
794 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
798 /* Do this before moving and increasing the gap,
799 because the before-change hooks might move the gap
800 or make it smaller. */
801 prepare_to_modify_buffer (PT
, PT
, NULL
);
804 move_gap_both (PT
, PT_BYTE
);
805 if (GAP_SIZE
< nbytes
)
806 make_gap (nbytes
- GAP_SIZE
);
808 #ifdef BYTE_COMBINING_DEBUG
809 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
810 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
814 /* Record deletion of the surrounding text that combines with
815 the insertion. This, together with recording the insertion,
816 will add up to the right stuff in the undo list. */
817 record_insert (PT
, nchars
);
819 CHARS_MODIFF
= MODIFF
;
821 memcpy (GPT_ADDR
, string
, nbytes
);
830 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
832 eassert (GPT
<= GPT_BYTE
);
834 /* The insert may have been in the unchanged region, so check again. */
835 if (Z
- GPT
< END_UNCHANGED
)
836 END_UNCHANGED
= Z
- GPT
;
838 adjust_overlays_for_insert (PT
, nchars
);
839 adjust_markers_for_insert (PT
, PT_BYTE
,
840 PT
+ nchars
, PT_BYTE
+ nbytes
,
843 offset_intervals (current_buffer
, PT
, nchars
);
845 if (!inherit
&& buffer_intervals (current_buffer
))
846 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
849 adjust_point (nchars
, nbytes
);
854 /* Insert the part of the text of STRING, a Lisp object assumed to be
855 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
856 starting at position POS / POS_BYTE. If the text of STRING has properties,
857 copy them into the buffer.
859 It does not work to use `insert' for this, because a GC could happen
860 before we copy the stuff into the buffer, and relocate the string
861 without insert noticing. */
864 insert_from_string (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
865 ptrdiff_t length
, ptrdiff_t length_byte
, bool inherit
)
867 ptrdiff_t opoint
= PT
;
869 if (SCHARS (string
) == 0)
872 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
874 signal_after_change (opoint
, 0, PT
- opoint
);
875 update_compositions (opoint
, PT
, CHECK_BORDER
);
878 /* Like `insert_from_string' except that all markers pointing
879 at the place where the insertion happens are adjusted to point after it. */
882 insert_from_string_before_markers (Lisp_Object string
,
883 ptrdiff_t pos
, ptrdiff_t pos_byte
,
884 ptrdiff_t length
, ptrdiff_t length_byte
,
887 ptrdiff_t opoint
= PT
;
889 if (SCHARS (string
) == 0)
892 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
894 signal_after_change (opoint
, 0, PT
- opoint
);
895 update_compositions (opoint
, PT
, CHECK_BORDER
);
898 /* Subroutine of the insertion functions above. */
901 insert_from_string_1 (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
902 ptrdiff_t nchars
, ptrdiff_t nbytes
,
903 bool inherit
, bool before_markers
)
906 ptrdiff_t outgoing_nbytes
= nbytes
;
909 /* Make OUTGOING_NBYTES describe the text
910 as it will be inserted in this buffer. */
912 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
913 outgoing_nbytes
= nchars
;
914 else if (! STRING_MULTIBYTE (string
))
916 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
920 /* Do this before moving and increasing the gap,
921 because the before-change hooks might move the gap
922 or make it smaller. */
923 prepare_to_modify_buffer (PT
, PT
, NULL
);
926 move_gap_both (PT
, PT_BYTE
);
927 if (GAP_SIZE
< outgoing_nbytes
)
928 make_gap (outgoing_nbytes
- GAP_SIZE
);
931 /* Copy the string text into the buffer, perhaps converting
932 between single-byte and multibyte. */
933 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
934 STRING_MULTIBYTE (string
),
935 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
937 #ifdef BYTE_COMBINING_DEBUG
938 /* We have copied text into the gap, but we have not altered
939 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
940 to these functions and get the same results as we would
941 have got earlier on. Meanwhile, PT_ADDR does point to
942 the text that has been stored by copy_text. */
943 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
944 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
948 record_insert (PT
, nchars
);
950 CHARS_MODIFF
= MODIFF
;
952 GAP_SIZE
-= outgoing_nbytes
;
956 GPT_BYTE
+= outgoing_nbytes
;
957 ZV_BYTE
+= outgoing_nbytes
;
958 Z_BYTE
+= outgoing_nbytes
;
959 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
961 eassert (GPT
<= GPT_BYTE
);
963 /* The insert may have been in the unchanged region, so check again. */
964 if (Z
- GPT
< END_UNCHANGED
)
965 END_UNCHANGED
= Z
- GPT
;
967 adjust_overlays_for_insert (PT
, nchars
);
968 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
969 PT_BYTE
+ outgoing_nbytes
,
972 offset_intervals (current_buffer
, PT
, nchars
);
974 intervals
= string_intervals (string
);
975 /* Get the intervals for the part of the string we are inserting. */
976 if (nbytes
< SBYTES (string
))
977 intervals
= copy_intervals (intervals
, pos
, nchars
);
979 /* Insert those intervals. */
980 graft_intervals_into_buffer (intervals
, PT
, nchars
,
981 current_buffer
, inherit
);
983 adjust_point (nchars
, outgoing_nbytes
);
988 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
989 starting at GPT_ADDR. */
992 insert_from_gap (ptrdiff_t nchars
, ptrdiff_t nbytes
)
994 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
997 record_insert (GPT
, nchars
);
1007 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1009 eassert (GPT
<= GPT_BYTE
);
1011 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1012 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1015 if (buffer_intervals (current_buffer
))
1017 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1018 graft_intervals_into_buffer (NULL
, GPT
- nchars
, nchars
,
1022 if (GPT
- nchars
< PT
)
1023 adjust_point (nchars
, nbytes
);
1028 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1029 current buffer. If the text in BUF has properties, they are absorbed
1030 into the current buffer.
1032 It does not work to use `insert' for this, because a malloc could happen
1033 and relocate BUF's text before the copy happens. */
1036 insert_from_buffer (struct buffer
*buf
,
1037 ptrdiff_t charpos
, ptrdiff_t nchars
, bool inherit
)
1039 ptrdiff_t opoint
= PT
;
1041 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1042 signal_after_change (opoint
, 0, PT
- opoint
);
1043 update_compositions (opoint
, PT
, CHECK_BORDER
);
1047 insert_from_buffer_1 (struct buffer
*buf
,
1048 ptrdiff_t from
, ptrdiff_t nchars
, bool inherit
)
1050 ptrdiff_t chunk
, chunk_expanded
;
1051 ptrdiff_t from_byte
= buf_charpos_to_bytepos (buf
, from
);
1052 ptrdiff_t to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1053 ptrdiff_t incoming_nbytes
= to_byte
- from_byte
;
1054 ptrdiff_t outgoing_nbytes
= incoming_nbytes
;
1057 /* Make OUTGOING_NBYTES describe the text
1058 as it will be inserted in this buffer. */
1060 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1061 outgoing_nbytes
= nchars
;
1062 else if (NILP (BVAR (buf
, enable_multibyte_characters
)))
1064 ptrdiff_t outgoing_before_gap
= 0;
1065 ptrdiff_t outgoing_after_gap
= 0;
1067 if (from
< BUF_GPT (buf
))
1069 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1070 if (chunk
> incoming_nbytes
)
1071 chunk
= incoming_nbytes
;
1073 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1079 if (chunk
< incoming_nbytes
)
1081 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1083 incoming_nbytes
- chunk
);
1085 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1088 /* Do this before moving and increasing the gap,
1089 because the before-change hooks might move the gap
1090 or make it smaller. */
1091 prepare_to_modify_buffer (PT
, PT
, NULL
);
1094 move_gap_both (PT
, PT_BYTE
);
1095 if (GAP_SIZE
< outgoing_nbytes
)
1096 make_gap (outgoing_nbytes
- GAP_SIZE
);
1098 if (from
< BUF_GPT (buf
))
1100 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1101 if (chunk
> incoming_nbytes
)
1102 chunk
= incoming_nbytes
;
1103 /* Record number of output bytes, so we know where
1104 to put the output from the second copy_text. */
1106 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1108 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1109 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1112 chunk_expanded
= chunk
= 0;
1114 if (chunk
< incoming_nbytes
)
1115 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1116 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1117 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1118 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1120 #ifdef BYTE_COMBINING_DEBUG
1121 /* We have copied text into the gap, but we have not altered
1122 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1123 to these functions and get the same results as we would
1124 have got earlier on. Meanwhile, GPT_ADDR does point to
1125 the text that has been stored by copy_text. */
1126 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1127 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1131 record_insert (PT
, nchars
);
1133 CHARS_MODIFF
= MODIFF
;
1135 GAP_SIZE
-= outgoing_nbytes
;
1139 GPT_BYTE
+= outgoing_nbytes
;
1140 ZV_BYTE
+= outgoing_nbytes
;
1141 Z_BYTE
+= outgoing_nbytes
;
1142 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1144 eassert (GPT
<= GPT_BYTE
);
1146 /* The insert may have been in the unchanged region, so check again. */
1147 if (Z
- GPT
< END_UNCHANGED
)
1148 END_UNCHANGED
= Z
- GPT
;
1150 adjust_overlays_for_insert (PT
, nchars
);
1151 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1152 PT_BYTE
+ outgoing_nbytes
,
1155 offset_intervals (current_buffer
, PT
, nchars
);
1157 /* Get the intervals for the part of the string we are inserting. */
1158 intervals
= buffer_intervals (buf
);
1159 if (nchars
< BUF_Z (buf
) - BUF_BEG (buf
))
1161 if (buf
== current_buffer
&& PT
<= from
)
1163 intervals
= copy_intervals (intervals
, from
, nchars
);
1166 /* Insert those intervals. */
1167 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1169 adjust_point (nchars
, outgoing_nbytes
);
1172 /* Record undo information and adjust markers and position keepers for
1173 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1174 chars (LEN_BYTE bytes) which resides in the gap just after
1177 PREV_TEXT nil means the new text was just inserted. */
1180 adjust_after_replace (ptrdiff_t from
, ptrdiff_t from_byte
,
1181 Lisp_Object prev_text
, ptrdiff_t len
, ptrdiff_t len_byte
)
1183 ptrdiff_t nchars_del
= 0, nbytes_del
= 0;
1185 #ifdef BYTE_COMBINING_DEBUG
1186 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1187 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1191 if (STRINGP (prev_text
))
1193 nchars_del
= SCHARS (prev_text
);
1194 nbytes_del
= SBYTES (prev_text
);
1197 /* Update various buffer positions for the new text. */
1198 GAP_SIZE
-= len_byte
;
1200 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1201 GPT
+= len
; GPT_BYTE
+= len_byte
;
1202 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1205 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1208 adjust_markers_for_insert (from
, from_byte
,
1209 from
+ len
, from_byte
+ len_byte
, 0);
1211 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1214 record_delete (from
, prev_text
);
1215 record_insert (from
, len
);
1218 if (len
> nchars_del
)
1219 adjust_overlays_for_insert (from
, len
- nchars_del
);
1220 else if (len
< nchars_del
)
1221 adjust_overlays_for_delete (from
, nchars_del
- len
);
1223 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1226 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1228 /* As byte combining will decrease Z, we must check this again. */
1229 if (Z
- GPT
< END_UNCHANGED
)
1230 END_UNCHANGED
= Z
- GPT
;
1235 evaporate_overlays (from
);
1237 CHARS_MODIFF
= MODIFF
;
1240 /* Record undo information, adjust markers and position keepers for an
1241 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1242 text already exists in the current buffer but character length (TO
1243 - FROM) may be incorrect, the correct length is NEWLEN. */
1246 adjust_after_insert (ptrdiff_t from
, ptrdiff_t from_byte
,
1247 ptrdiff_t to
, ptrdiff_t to_byte
, ptrdiff_t newlen
)
1249 ptrdiff_t len
= to
- from
, len_byte
= to_byte
- from_byte
;
1252 move_gap_both (to
, to_byte
);
1253 GAP_SIZE
+= len_byte
;
1254 GPT
-= len
; GPT_BYTE
-= len_byte
;
1255 ZV
-= len
; ZV_BYTE
-= len_byte
;
1256 Z
-= len
; Z_BYTE
-= len_byte
;
1257 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1260 /* Replace the text from character positions FROM to TO with NEW,
1261 If PREPARE, call prepare_to_modify_buffer.
1262 If INHERIT, the newly inserted text should inherit text properties
1263 from the surrounding non-deleted text. */
1265 /* Note that this does not yet handle markers quite right.
1266 Also it needs to record a single undo-entry that does a replacement
1267 rather than a separate delete and insert.
1268 That way, undo will also handle markers properly.
1270 But if MARKERS is 0, don't relocate markers. */
1273 replace_range (ptrdiff_t from
, ptrdiff_t to
, Lisp_Object
new,
1274 bool prepare
, bool inherit
, bool markers
)
1276 ptrdiff_t inschars
= SCHARS (new);
1277 ptrdiff_t insbytes
= SBYTES (new);
1278 ptrdiff_t from_byte
, to_byte
;
1279 ptrdiff_t nbytes_del
, nchars_del
;
1280 struct gcpro gcpro1
;
1282 ptrdiff_t outgoing_insbytes
= insbytes
;
1283 Lisp_Object deletion
;
1292 ptrdiff_t range_length
= to
- from
;
1293 prepare_to_modify_buffer (from
, to
, &from
);
1294 to
= from
+ range_length
;
1299 /* Make args be valid. */
1305 from_byte
= CHAR_TO_BYTE (from
);
1306 to_byte
= CHAR_TO_BYTE (to
);
1308 nchars_del
= to
- from
;
1309 nbytes_del
= to_byte
- from_byte
;
1311 if (nbytes_del
<= 0 && insbytes
== 0)
1314 /* Make OUTGOING_INSBYTES describe the text
1315 as it will be inserted in this buffer. */
1317 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1318 outgoing_insbytes
= inschars
;
1319 else if (! STRING_MULTIBYTE (new))
1321 = count_size_as_multibyte (SDATA (new), insbytes
);
1325 /* Make sure the gap is somewhere in or next to what we are deleting. */
1327 gap_right (from
, from_byte
);
1329 gap_left (to
, to_byte
, 0);
1331 /* Even if we don't record for undo, we must keep the original text
1332 because we may have to recover it because of inappropriate byte
1334 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1335 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1337 GAP_SIZE
+= nbytes_del
;
1340 ZV_BYTE
-= nbytes_del
;
1341 Z_BYTE
-= nbytes_del
;
1343 GPT_BYTE
= from_byte
;
1344 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1346 eassert (GPT
<= GPT_BYTE
);
1348 if (GPT
- BEG
< BEG_UNCHANGED
)
1349 BEG_UNCHANGED
= GPT
- BEG
;
1350 if (Z
- GPT
< END_UNCHANGED
)
1351 END_UNCHANGED
= Z
- GPT
;
1353 if (GAP_SIZE
< outgoing_insbytes
)
1354 make_gap (outgoing_insbytes
- GAP_SIZE
);
1356 /* Copy the string text into the buffer, perhaps converting
1357 between single-byte and multibyte. */
1358 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1359 STRING_MULTIBYTE (new),
1360 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1362 #ifdef BYTE_COMBINING_DEBUG
1363 /* We have copied text into the gap, but we have not marked
1364 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1365 here, for both the previous text and the following text.
1366 Meanwhile, GPT_ADDR does point to
1367 the text that has been stored by copy_text. */
1368 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1369 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1373 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1375 /* Record the insertion first, so that when we undo,
1376 the deletion will be undone first. Thus, undo
1377 will insert before deleting, and thus will keep
1378 the markers before and after this text separate. */
1379 record_insert (from
+ SCHARS (deletion
), inschars
);
1380 record_delete (from
, deletion
);
1383 GAP_SIZE
-= outgoing_insbytes
;
1387 GPT_BYTE
+= outgoing_insbytes
;
1388 ZV_BYTE
+= outgoing_insbytes
;
1389 Z_BYTE
+= outgoing_insbytes
;
1390 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1392 eassert (GPT
<= GPT_BYTE
);
1394 /* Adjust markers for the deletion and the insertion. */
1396 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1397 inschars
, outgoing_insbytes
);
1399 /* Adjust the overlay center as needed. This must be done after
1400 adjusting the markers that bound the overlays. */
1401 adjust_overlays_for_delete (from
, nchars_del
);
1402 adjust_overlays_for_insert (from
, inschars
);
1404 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1406 /* Get the intervals for the part of the string we are inserting--
1407 not including the combined-before bytes. */
1408 intervals
= string_intervals (new);
1409 /* Insert those intervals. */
1410 graft_intervals_into_buffer (intervals
, from
, inschars
,
1411 current_buffer
, inherit
);
1413 /* Relocate point as if it were a marker. */
1415 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1416 (from_byte
+ outgoing_insbytes
1417 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1419 if (outgoing_insbytes
== 0)
1420 evaporate_overlays (from
);
1425 CHARS_MODIFF
= MODIFF
;
1428 signal_after_change (from
, nchars_del
, GPT
- from
);
1429 update_compositions (from
, GPT
, CHECK_BORDER
);
1432 /* Replace the text from character positions FROM to TO with
1433 the text in INS of length INSCHARS.
1434 Keep the text properties that applied to the old characters
1435 (extending them to all the new chars if there are more new chars).
1437 Note that this does not yet handle markers quite right.
1439 If MARKERS, relocate markers.
1441 Unlike most functions at this level, never call
1442 prepare_to_modify_buffer and never call signal_after_change. */
1445 replace_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1446 ptrdiff_t to
, ptrdiff_t to_byte
,
1447 const char *ins
, ptrdiff_t inschars
, ptrdiff_t insbytes
,
1450 ptrdiff_t nbytes_del
, nchars_del
;
1454 nchars_del
= to
- from
;
1455 nbytes_del
= to_byte
- from_byte
;
1457 if (nbytes_del
<= 0 && insbytes
== 0)
1460 /* Make sure the gap is somewhere in or next to what we are deleting. */
1462 gap_right (from
, from_byte
);
1464 gap_left (to
, to_byte
, 0);
1466 GAP_SIZE
+= nbytes_del
;
1469 ZV_BYTE
-= nbytes_del
;
1470 Z_BYTE
-= nbytes_del
;
1472 GPT_BYTE
= from_byte
;
1473 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1475 eassert (GPT
<= GPT_BYTE
);
1477 if (GPT
- BEG
< BEG_UNCHANGED
)
1478 BEG_UNCHANGED
= GPT
- BEG
;
1479 if (Z
- GPT
< END_UNCHANGED
)
1480 END_UNCHANGED
= Z
- GPT
;
1482 if (GAP_SIZE
< insbytes
)
1483 make_gap (insbytes
- GAP_SIZE
);
1485 /* Copy the replacement text into the buffer. */
1486 memcpy (GPT_ADDR
, ins
, insbytes
);
1488 #ifdef BYTE_COMBINING_DEBUG
1489 /* We have copied text into the gap, but we have not marked
1490 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1491 here, for both the previous text and the following text.
1492 Meanwhile, GPT_ADDR does point to
1493 the text that has been stored by copy_text. */
1494 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1495 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1499 GAP_SIZE
-= insbytes
;
1503 GPT_BYTE
+= insbytes
;
1504 ZV_BYTE
+= insbytes
;
1506 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1508 eassert (GPT
<= GPT_BYTE
);
1510 /* Adjust markers for the deletion and the insertion. */
1512 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1513 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1514 inschars
, insbytes
);
1516 /* Adjust the overlay center as needed. This must be done after
1517 adjusting the markers that bound the overlays. */
1518 if (nchars_del
!= inschars
)
1520 adjust_overlays_for_insert (from
, inschars
);
1521 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1524 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1526 /* Relocate point as if it were a marker. */
1527 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1530 /* PT was within the deleted text. Move it to FROM. */
1531 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1533 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1537 evaporate_overlays (from
);
1542 CHARS_MODIFF
= MODIFF
;
1545 /* Delete characters in current buffer
1546 from FROM up to (but not including) TO.
1547 If TO comes before FROM, we delete nothing. */
1550 del_range (ptrdiff_t from
, ptrdiff_t to
)
1552 del_range_1 (from
, to
, 1, 0);
1555 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1556 RET_STRING says to return the deleted text. */
1559 del_range_1 (ptrdiff_t from
, ptrdiff_t to
, bool prepare
, bool ret_string
)
1561 ptrdiff_t from_byte
, to_byte
;
1562 Lisp_Object deletion
;
1563 struct gcpro gcpro1
;
1565 /* Make args be valid */
1576 ptrdiff_t range_length
= to
- from
;
1577 prepare_to_modify_buffer (from
, to
, &from
);
1578 to
= min (ZV
, from
+ range_length
);
1581 from_byte
= CHAR_TO_BYTE (from
);
1582 to_byte
= CHAR_TO_BYTE (to
);
1584 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1586 signal_after_change (from
, to
- from
, 0);
1587 update_compositions (from
, from
, CHECK_HEAD
);
1592 /* Like del_range_1 but args are byte positions, not char positions. */
1595 del_range_byte (ptrdiff_t from_byte
, ptrdiff_t to_byte
, bool prepare
)
1599 /* Make args be valid */
1600 if (from_byte
< BEGV_BYTE
)
1601 from_byte
= BEGV_BYTE
;
1602 if (to_byte
> ZV_BYTE
)
1605 if (to_byte
<= from_byte
)
1608 from
= BYTE_TO_CHAR (from_byte
);
1609 to
= BYTE_TO_CHAR (to_byte
);
1613 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1614 ptrdiff_t range_length
= to
- from
;
1615 prepare_to_modify_buffer (from
, to
, &from
);
1616 to
= from
+ range_length
;
1618 if (old_from
!= from
)
1619 from_byte
= CHAR_TO_BYTE (from
);
1625 else if (old_to
== Z
- to
)
1626 to_byte
= CHAR_TO_BYTE (to
);
1629 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1630 signal_after_change (from
, to
- from
, 0);
1631 update_compositions (from
, from
, CHECK_HEAD
);
1634 /* Like del_range_1, but positions are specified both as charpos
1638 del_range_both (ptrdiff_t from
, ptrdiff_t from_byte
,
1639 ptrdiff_t to
, ptrdiff_t to_byte
, bool prepare
)
1641 /* Make args be valid */
1642 if (from_byte
< BEGV_BYTE
)
1643 from_byte
= BEGV_BYTE
;
1644 if (to_byte
> ZV_BYTE
)
1647 if (to_byte
<= from_byte
)
1657 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1658 ptrdiff_t range_length
= to
- from
;
1659 prepare_to_modify_buffer (from
, to
, &from
);
1660 to
= from
+ range_length
;
1662 if (old_from
!= from
)
1663 from_byte
= CHAR_TO_BYTE (from
);
1669 else if (old_to
== Z
- to
)
1670 to_byte
= CHAR_TO_BYTE (to
);
1673 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1674 signal_after_change (from
, to
- from
, 0);
1675 update_compositions (from
, from
, CHECK_HEAD
);
1678 /* Delete a range of text, specified both as character positions
1679 and byte positions. FROM and TO are character positions,
1680 while FROM_BYTE and TO_BYTE are byte positions.
1681 If RET_STRING, the deleted area is returned as a string. */
1684 del_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1685 ptrdiff_t to
, ptrdiff_t to_byte
, bool ret_string
)
1687 ptrdiff_t nbytes_del
, nchars_del
;
1688 Lisp_Object deletion
;
1692 nchars_del
= to
- from
;
1693 nbytes_del
= to_byte
- from_byte
;
1695 /* Make sure the gap is somewhere in or next to what we are deleting. */
1697 gap_right (from
, from_byte
);
1699 gap_left (to
, to_byte
, 0);
1701 #ifdef BYTE_COMBINING_DEBUG
1702 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1703 Z_BYTE
- to_byte
, from
, from_byte
))
1707 if (ret_string
|| ! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1708 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1712 /* Relocate all markers pointing into the new, larger gap
1713 to point at the end of the text before the gap.
1714 Do this before recording the deletion,
1715 so that undo handles this after reinserting the text. */
1716 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1718 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1719 record_delete (from
, deletion
);
1721 CHARS_MODIFF
= MODIFF
;
1723 /* Relocate point as if it were a marker. */
1725 adjust_point (from
- (PT
< to
? PT
: to
),
1726 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1728 offset_intervals (current_buffer
, from
, - nchars_del
);
1730 /* Adjust the overlay center as needed. This must be done after
1731 adjusting the markers that bound the overlays. */
1732 adjust_overlays_for_delete (from
, nchars_del
);
1734 GAP_SIZE
+= nbytes_del
;
1735 ZV_BYTE
-= nbytes_del
;
1736 Z_BYTE
-= nbytes_del
;
1740 GPT_BYTE
= from_byte
;
1741 if (GAP_SIZE
> 0 && !current_buffer
->text
->inhibit_shrinking
)
1742 /* Put an anchor, unless called from decode_coding_object which
1743 needs to access the previous gap contents. */
1746 eassert (GPT
<= GPT_BYTE
);
1748 if (GPT
- BEG
< BEG_UNCHANGED
)
1749 BEG_UNCHANGED
= GPT
- BEG
;
1750 if (Z
- GPT
< END_UNCHANGED
)
1751 END_UNCHANGED
= Z
- GPT
;
1755 evaporate_overlays (from
);
1760 /* Call this if you're about to change the region of BUFFER from
1761 character positions START to END. This checks the read-only
1762 properties of the region, calls the necessary modification hooks,
1763 and warns the next redisplay that it should pay attention to that
1766 If PRESERVE_CHARS_MODIFF, do not update CHARS_MODIFF.
1767 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
1770 modify_region (struct buffer
*buffer
, ptrdiff_t start
, ptrdiff_t end
,
1771 bool preserve_chars_modiff
)
1773 struct buffer
*old_buffer
= current_buffer
;
1775 set_buffer_internal (buffer
);
1777 prepare_to_modify_buffer (start
, end
, NULL
);
1779 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1781 if (MODIFF
<= SAVE_MODIFF
)
1782 record_first_change ();
1784 if (! preserve_chars_modiff
)
1785 CHARS_MODIFF
= MODIFF
;
1787 bset_point_before_scroll (buffer
, Qnil
);
1789 set_buffer_internal (old_buffer
);
1792 /* Check that it is okay to modify the buffer between START and END,
1793 which are char positions.
1795 Run the before-change-function, if any. If intervals are in use,
1796 verify that the text to be modified is not read-only, and call
1797 any modification properties the text may have.
1799 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1800 by holding its value temporarily in a marker. */
1803 prepare_to_modify_buffer (ptrdiff_t start
, ptrdiff_t end
,
1804 ptrdiff_t *preserve_ptr
)
1806 struct buffer
*base_buffer
;
1808 if (!NILP (BVAR (current_buffer
, read_only
)))
1809 Fbarf_if_buffer_read_only ();
1811 /* Let redisplay consider other windows than selected_window
1812 if modifying another buffer. */
1813 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1814 ++windows_or_buffers_changed
;
1816 if (buffer_intervals (current_buffer
))
1820 Lisp_Object preserve_marker
;
1821 struct gcpro gcpro1
;
1822 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1823 GCPRO1 (preserve_marker
);
1824 verify_interval_modification (current_buffer
, start
, end
);
1825 *preserve_ptr
= marker_position (preserve_marker
);
1826 unchain_marker (XMARKER (preserve_marker
));
1830 verify_interval_modification (current_buffer
, start
, end
);
1833 /* For indirect buffers, use the base buffer to check clashes. */
1834 if (current_buffer
->base_buffer
!= 0)
1835 base_buffer
= current_buffer
->base_buffer
;
1837 base_buffer
= current_buffer
;
1839 #ifdef CLASH_DETECTION
1840 if (!NILP (BVAR (base_buffer
, file_truename
))
1841 /* Make binding buffer-file-name to nil effective. */
1842 && !NILP (BVAR (base_buffer
, filename
))
1843 && SAVE_MODIFF
>= MODIFF
)
1844 lock_file (BVAR (base_buffer
, file_truename
));
1846 /* At least warn if this file has changed on disk since it was visited. */
1847 if (!NILP (BVAR (base_buffer
, filename
))
1848 && SAVE_MODIFF
>= MODIFF
1849 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1850 && !NILP (Ffile_exists_p (BVAR (base_buffer
, filename
))))
1851 call1 (intern ("ask-user-about-supersession-threat"),
1852 BVAR (base_buffer
,filename
));
1853 #endif /* not CLASH_DETECTION */
1855 /* If `select-active-regions' is non-nil, save the region text. */
1856 if (!NILP (BVAR (current_buffer
, mark_active
))
1857 && !inhibit_modification_hooks
1858 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1859 && NILP (Vsaved_region_selection
)
1860 && (EQ (Vselect_active_regions
, Qonly
)
1861 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1862 : (!NILP (Vselect_active_regions
)
1863 && !NILP (Vtransient_mark_mode
))))
1865 ptrdiff_t b
= XMARKER (BVAR (current_buffer
, mark
))->charpos
;
1868 Vsaved_region_selection
= make_buffer_string (b
, e
, 0);
1870 Vsaved_region_selection
= make_buffer_string (e
, b
, 0);
1873 signal_before_change (start
, end
, preserve_ptr
);
1875 if (current_buffer
->newline_cache
)
1876 invalidate_region_cache (current_buffer
,
1877 current_buffer
->newline_cache
,
1878 start
- BEG
, Z
- end
);
1879 if (current_buffer
->width_run_cache
)
1880 invalidate_region_cache (current_buffer
,
1881 current_buffer
->width_run_cache
,
1882 start
- BEG
, Z
- end
);
1884 Vdeactivate_mark
= Qt
;
1887 /* These macros work with an argument named `preserve_ptr'
1888 and a local variable named `preserve_marker'. */
1890 #define PRESERVE_VALUE \
1891 if (preserve_ptr && NILP (preserve_marker)) \
1892 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1894 #define RESTORE_VALUE \
1895 if (! NILP (preserve_marker)) \
1897 *preserve_ptr = marker_position (preserve_marker); \
1898 unchain_marker (XMARKER (preserve_marker)); \
1901 #define PRESERVE_START_END \
1902 if (NILP (start_marker)) \
1903 start_marker = Fcopy_marker (start, Qnil); \
1904 if (NILP (end_marker)) \
1905 end_marker = Fcopy_marker (end, Qnil);
1907 #define FETCH_START \
1908 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1911 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1913 /* Set a variable to nil if an error occurred.
1914 Don't change the variable if there was no error.
1915 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
1916 VARIABLE is the variable to maybe set to nil.
1917 NO-ERROR-FLAG is nil if there was an error,
1918 anything else meaning no error (so this function does nothing). */
1920 reset_var_on_error (Lisp_Object val
)
1922 if (NILP (XCDR (val
)))
1923 Fset (XCAR (val
), Qnil
);
1927 /* Signal a change to the buffer immediately before it happens.
1928 START_INT and END_INT are the bounds of the text to be changed.
1930 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1931 by holding its value temporarily in a marker. */
1934 signal_before_change (ptrdiff_t start_int
, ptrdiff_t end_int
,
1935 ptrdiff_t *preserve_ptr
)
1937 Lisp_Object start
, end
;
1938 Lisp_Object start_marker
, end_marker
;
1939 Lisp_Object preserve_marker
;
1940 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1941 ptrdiff_t count
= SPECPDL_INDEX ();
1943 if (inhibit_modification_hooks
)
1946 start
= make_number (start_int
);
1947 end
= make_number (end_int
);
1948 preserve_marker
= Qnil
;
1949 start_marker
= Qnil
;
1951 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1953 specbind (Qinhibit_modification_hooks
, Qt
);
1955 /* If buffer is unmodified, run a special hook for that case. The
1956 check for Vfirst_change_hook is just a minor optimization. */
1957 if (SAVE_MODIFF
>= MODIFF
1958 && !NILP (Vfirst_change_hook
))
1962 Frun_hooks (1, &Qfirst_change_hook
);
1965 /* Now run the before-change-functions if any. */
1966 if (!NILP (Vbefore_change_functions
))
1968 Lisp_Object args
[3];
1969 Lisp_Object rvoe_arg
= Fcons (Qbefore_change_functions
, Qnil
);
1974 /* Mark before-change-functions to be reset to nil in case of error. */
1975 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
1977 /* Actually run the hook functions. */
1978 args
[0] = Qbefore_change_functions
;
1979 args
[1] = FETCH_START
;
1980 args
[2] = FETCH_END
;
1981 Frun_hook_with_args (3, args
);
1983 /* There was no error: unarm the reset_on_error. */
1984 XSETCDR (rvoe_arg
, Qt
);
1987 if (buffer_has_overlays ())
1990 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1991 FETCH_START
, FETCH_END
, Qnil
);
1994 if (! NILP (start_marker
))
1995 free_marker (start_marker
);
1996 if (! NILP (end_marker
))
1997 free_marker (end_marker
);
2001 unbind_to (count
, Qnil
);
2004 /* Signal a change immediately after it happens.
2005 CHARPOS is the character position of the start of the changed text.
2006 LENDEL is the number of characters of the text before the change.
2007 (Not the whole buffer; just the part that was changed.)
2008 LENINS is the number of characters in that part of the text
2009 after the change. */
2012 signal_after_change (ptrdiff_t charpos
, ptrdiff_t lendel
, ptrdiff_t lenins
)
2014 ptrdiff_t count
= SPECPDL_INDEX ();
2015 if (inhibit_modification_hooks
)
2018 /* If we are deferring calls to the after-change functions
2019 and there are no before-change functions,
2020 just record the args that we were going to use. */
2021 if (! NILP (Vcombine_after_change_calls
)
2022 && NILP (Vbefore_change_functions
)
2023 && !buffer_has_overlays ())
2027 if (!NILP (combine_after_change_list
)
2028 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2029 Fcombine_after_change_execute ();
2031 elt
= Fcons (make_number (charpos
- BEG
),
2032 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2033 Fcons (make_number (lenins
- lendel
), Qnil
)));
2034 combine_after_change_list
2035 = Fcons (elt
, combine_after_change_list
);
2036 combine_after_change_buffer
= Fcurrent_buffer ();
2041 if (!NILP (combine_after_change_list
))
2042 Fcombine_after_change_execute ();
2044 specbind (Qinhibit_modification_hooks
, Qt
);
2046 if (!NILP (Vafter_change_functions
))
2048 Lisp_Object args
[4];
2049 Lisp_Object rvoe_arg
= Fcons (Qafter_change_functions
, Qnil
);
2051 /* Mark after-change-functions to be reset to nil in case of error. */
2052 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2054 /* Actually run the hook functions. */
2055 args
[0] = Qafter_change_functions
;
2056 XSETFASTINT (args
[1], charpos
);
2057 XSETFASTINT (args
[2], charpos
+ lenins
);
2058 XSETFASTINT (args
[3], lendel
);
2059 Frun_hook_with_args (4, args
);
2061 /* There was no error: unarm the reset_on_error. */
2062 XSETCDR (rvoe_arg
, Qt
);
2065 if (buffer_has_overlays ())
2066 report_overlay_modification (make_number (charpos
),
2067 make_number (charpos
+ lenins
),
2069 make_number (charpos
),
2070 make_number (charpos
+ lenins
),
2071 make_number (lendel
));
2073 /* After an insertion, call the text properties
2074 insert-behind-hooks or insert-in-front-hooks. */
2076 report_interval_modification (make_number (charpos
),
2077 make_number (charpos
+ lenins
));
2079 unbind_to (count
, Qnil
);
2083 Fcombine_after_change_execute_1 (Lisp_Object val
)
2085 Vcombine_after_change_calls
= val
;
2089 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2090 Scombine_after_change_execute
, 0, 0, 0,
2091 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2094 ptrdiff_t count
= SPECPDL_INDEX ();
2095 ptrdiff_t beg
, end
, change
;
2096 ptrdiff_t begpos
, endpos
;
2099 if (NILP (combine_after_change_list
))
2102 /* It is rare for combine_after_change_buffer to be invalid, but
2103 possible. It can happen when combine-after-change-calls is
2104 non-nil, and insertion calls a file handler (e.g. through
2105 lock_file) which scribbles into a temp file -- cyd */
2106 if (!BUFFERP (combine_after_change_buffer
)
2107 || !BUFFER_LIVE_P (XBUFFER (combine_after_change_buffer
)))
2109 combine_after_change_list
= Qnil
;
2113 record_unwind_current_buffer ();
2115 Fset_buffer (combine_after_change_buffer
);
2117 /* # chars unchanged at beginning of buffer. */
2119 /* # chars unchanged at end of buffer. */
2121 /* Total amount of insertion (negative for deletion). */
2124 /* Scan the various individual changes,
2125 accumulating the range info in BEG, END and CHANGE. */
2126 for (tail
= combine_after_change_list
; CONSP (tail
);
2130 ptrdiff_t thisbeg
, thisend
, thischange
;
2132 /* Extract the info from the next element. */
2136 thisbeg
= XINT (XCAR (elt
));
2141 thisend
= XINT (XCAR (elt
));
2146 thischange
= XINT (XCAR (elt
));
2148 /* Merge this range into the accumulated range. */
2149 change
+= thischange
;
2156 /* Get the current start and end positions of the range
2157 that was changed. */
2161 /* We are about to handle these, so discard them. */
2162 combine_after_change_list
= Qnil
;
2164 /* Now run the after-change functions for real.
2165 Turn off the flag that defers them. */
2166 record_unwind_protect (Fcombine_after_change_execute_1
,
2167 Vcombine_after_change_calls
);
2168 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2169 update_compositions (begpos
, endpos
, CHECK_ALL
);
2171 return unbind_to (count
, Qnil
);
2175 syms_of_insdel (void)
2177 staticpro (&combine_after_change_list
);
2178 staticpro (&combine_after_change_buffer
);
2179 combine_after_change_list
= Qnil
;
2180 combine_after_change_buffer
= Qnil
;
2182 DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls
,
2183 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2184 Vcombine_after_change_calls
= Qnil
;
2186 DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks
,
2187 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2188 This affects `before-change-functions' and `after-change-functions',
2189 as well as hooks attached to text properties and overlays. */);
2190 inhibit_modification_hooks
= 0;
2191 DEFSYM (Qinhibit_modification_hooks
, "inhibit-modification-hooks");
2193 defsubr (&Scombine_after_change_execute
);