1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software
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/>. */
26 #include "intervals.h"
27 #include "character.h"
30 #include "blockinput.h"
31 #include "region-cache.h"
33 static void insert_from_string_1 (Lisp_Object
, ptrdiff_t, ptrdiff_t, ptrdiff_t,
34 ptrdiff_t, bool, bool);
35 static void insert_from_buffer_1 (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
36 static void gap_left (ptrdiff_t, ptrdiff_t, bool);
37 static void gap_right (ptrdiff_t, ptrdiff_t);
39 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
40 describing changes which happened while combine_after_change_calls
41 was non-nil. We use this to decide how to call them
42 once the deferral ends.
45 BEG-UNCHANGED is the number of chars before the changed range.
46 END-UNCHANGED is the number of chars after the changed range,
47 and CHANGE-AMOUNT is the number of characters inserted by the change
48 (negative for a deletion). */
49 static Lisp_Object combine_after_change_list
;
51 /* Buffer which combine_after_change_list is about. */
52 static Lisp_Object combine_after_change_buffer
;
54 Lisp_Object Qinhibit_modification_hooks
;
56 static void signal_before_change (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
58 /* Also used in marker.c to enable expensive marker checks. */
65 struct Lisp_Marker
*tail
;
66 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
68 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
70 if (tail
->buffer
->text
!= current_buffer
->text
)
72 if (tail
->charpos
> Z
)
74 if (tail
->bytepos
> Z_BYTE
)
76 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
81 #else /* not MARKER_DEBUG */
83 #define check_markers() do { } while (0)
85 #endif /* MARKER_DEBUG */
87 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
88 Note that this can quit! */
91 move_gap_both (ptrdiff_t charpos
, ptrdiff_t bytepos
)
93 eassert (charpos
== BYTE_TO_CHAR (bytepos
)
94 && bytepos
== CHAR_TO_BYTE (charpos
));
95 if (bytepos
< GPT_BYTE
)
96 gap_left (charpos
, bytepos
, 0);
97 else if (bytepos
> GPT_BYTE
)
98 gap_right (charpos
, bytepos
);
101 /* Move the gap to a position less than the current GPT.
102 BYTEPOS describes the new position as a byte position,
103 and CHARPOS is the corresponding char position.
104 If NEWGAP, then don't update beg_unchanged and end_unchanged. */
107 gap_left (ptrdiff_t charpos
, ptrdiff_t bytepos
, bool newgap
)
109 unsigned char *to
, *from
;
114 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
121 /* Now copy the characters. To move the gap down,
122 copy characters up. */
126 /* I gets number of characters left to copy. */
127 i
= new_s1
- bytepos
;
130 /* If a quit is requested, stop copying now.
131 Change BYTEPOS to be where we have actually moved the gap to. */
135 charpos
= BYTE_TO_CHAR (bytepos
);
138 /* Move at most 32000 chars before checking again for a quit. */
143 memmove (to
, from
, i
);
146 /* Adjust buffer data structure, to put the gap at BYTEPOS.
147 BYTEPOS is where the loop above stopped, which may be what
148 was specified or may be where a quit was detected. */
151 eassert (charpos
<= bytepos
);
152 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
156 /* Move the gap to a position greater than the current GPT.
157 BYTEPOS describes the new position as a byte position,
158 and CHARPOS is the corresponding char position. */
161 gap_right (ptrdiff_t charpos
, ptrdiff_t bytepos
)
163 register unsigned char *to
, *from
;
164 register ptrdiff_t i
;
167 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
174 /* Now copy the characters. To move the gap up,
175 copy characters down. */
179 /* I gets number of characters left to copy. */
180 i
= bytepos
- new_s1
;
183 /* If a quit is requested, stop copying now.
184 Change BYTEPOS to be where we have actually moved the gap to. */
188 charpos
= BYTE_TO_CHAR (bytepos
);
191 /* Move at most 32000 chars before checking again for a quit. */
195 memmove (to
, from
, i
);
201 eassert (charpos
<= bytepos
);
202 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
206 /* Adjust all markers for a deletion
207 whose range in bytes is FROM_BYTE to TO_BYTE.
208 The range in charpos is FROM to TO.
210 This function assumes that the gap is adjacent to
211 or inside of the range being deleted. */
214 adjust_markers_for_delete (ptrdiff_t from
, ptrdiff_t from_byte
,
215 ptrdiff_t to
, ptrdiff_t to_byte
)
218 register struct Lisp_Marker
*m
;
219 register ptrdiff_t charpos
;
221 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
223 charpos
= m
->charpos
;
224 eassert (charpos
<= Z
);
226 /* If the marker is after the deletion,
227 relocate by number of chars / bytes deleted. */
230 m
->charpos
-= to
- from
;
231 m
->bytepos
-= to_byte
- from_byte
;
233 /* Here's the case where a marker is inside text being deleted. */
234 else if (charpos
> from
)
236 if (! m
->insertion_type
)
237 { /* Normal markers will end up at the beginning of the
238 re-inserted text after undoing a deletion, and must be
239 adjusted to move them to the correct place. */
240 XSETMISC (marker
, m
);
241 record_marker_adjustment (marker
, from
- charpos
);
243 else if (charpos
< to
)
244 { /* Before-insertion markers will automatically move forward
245 upon re-inserting the deleted text, so we have to arrange
246 for them to move backward to the correct position. */
247 XSETMISC (marker
, m
);
248 record_marker_adjustment (marker
, to
- charpos
);
251 m
->bytepos
= from_byte
;
253 /* Here's the case where a before-insertion marker is immediately
254 before the deleted region. */
255 else if (charpos
== from
&& m
->insertion_type
)
257 /* Undoing the change uses normal insertion, which will
258 incorrectly make MARKER move forward, so we arrange for it
259 to then move backward to the correct place at the beginning
260 of the deleted region. */
261 XSETMISC (marker
, m
);
262 record_marker_adjustment (marker
, to
- from
);
268 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
269 to TO / TO_BYTE. We have to relocate the charpos of every marker
270 that points after the insertion (but not their bytepos).
272 When a marker points at the insertion point,
273 we advance it if either its insertion-type is t
274 or BEFORE_MARKERS is true. */
277 adjust_markers_for_insert (ptrdiff_t from
, ptrdiff_t from_byte
,
278 ptrdiff_t to
, ptrdiff_t to_byte
, bool before_markers
)
280 struct Lisp_Marker
*m
;
282 ptrdiff_t nchars
= to
- from
;
283 ptrdiff_t nbytes
= to_byte
- from_byte
;
285 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
287 eassert (m
->bytepos
>= m
->charpos
288 && m
->bytepos
- m
->charpos
<= Z_BYTE
- Z
);
290 if (m
->bytepos
== from_byte
)
292 if (m
->insertion_type
|| before_markers
)
294 m
->bytepos
= to_byte
;
296 if (m
->insertion_type
)
300 else if (m
->bytepos
> from_byte
)
302 m
->bytepos
+= nbytes
;
303 m
->charpos
+= nchars
;
307 /* Adjusting only markers whose insertion-type is t may result in
308 - disordered start and end in overlays, and
309 - disordered overlays in the slot `overlays_before' of current_buffer. */
312 fix_start_end_in_overlays (from
, to
);
313 fix_overlays_before (current_buffer
, from
, to
);
317 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
319 This is used only when the value of point changes due to an insert
320 or delete; it does not represent a conceptual change in point as a
321 marker. In particular, point is not crossing any interval
322 boundaries, so there's no need to use the usual SET_PT macro. In
323 fact it would be incorrect to do so, because either the old or the
324 new value of point is out of sync with the current set of
328 adjust_point (ptrdiff_t nchars
, ptrdiff_t nbytes
)
330 SET_BUF_PT_BOTH (current_buffer
, PT
+ nchars
, PT_BYTE
+ nbytes
);
331 /* In a single-byte buffer, the two positions must be equal. */
332 eassert (PT_BYTE
>= PT
&& PT_BYTE
- PT
<= ZV_BYTE
- ZV
);
335 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
336 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
337 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
341 adjust_markers_for_replace (ptrdiff_t from
, ptrdiff_t from_byte
,
342 ptrdiff_t old_chars
, ptrdiff_t old_bytes
,
343 ptrdiff_t new_chars
, ptrdiff_t new_bytes
)
345 register struct Lisp_Marker
*m
;
346 ptrdiff_t prev_to_byte
= from_byte
+ old_bytes
;
347 ptrdiff_t diff_chars
= new_chars
- old_chars
;
348 ptrdiff_t diff_bytes
= new_bytes
- old_bytes
;
350 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
352 if (m
->bytepos
>= prev_to_byte
)
354 m
->charpos
+= diff_chars
;
355 m
->bytepos
+= diff_bytes
;
357 else if (m
->bytepos
> from_byte
)
360 m
->bytepos
= from_byte
;
369 buffer_overflow (void)
371 error ("Maximum buffer size exceeded");
374 /* Make the gap NBYTES_ADDED bytes longer. */
377 make_gap_larger (ptrdiff_t nbytes_added
)
380 ptrdiff_t real_gap_loc
;
381 ptrdiff_t real_gap_loc_byte
;
382 ptrdiff_t old_gap_size
;
383 ptrdiff_t current_size
= Z_BYTE
- BEG_BYTE
+ GAP_SIZE
;
385 if (BUF_BYTES_MAX
- current_size
< nbytes_added
)
388 /* If we have to get more space, get enough to last a while;
389 but do not exceed the maximum buffer size. */
390 nbytes_added
= min (nbytes_added
+ GAP_BYTES_DFL
,
391 BUF_BYTES_MAX
- current_size
);
393 enlarge_buffer_text (current_buffer
, nbytes_added
);
395 /* Prevent quitting in move_gap. */
400 real_gap_loc_byte
= GPT_BYTE
;
401 old_gap_size
= GAP_SIZE
;
403 /* Call the newly allocated space a gap at the end of the whole space. */
405 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
406 GAP_SIZE
= nbytes_added
;
408 /* Move the new gap down to be consecutive with the end of the old one. */
409 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
411 /* Now combine the two into one large gap. */
412 GAP_SIZE
+= old_gap_size
;
414 GPT_BYTE
= real_gap_loc_byte
;
422 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
424 /* Make the gap NBYTES_REMOVED bytes shorter. */
427 make_gap_smaller (ptrdiff_t nbytes_removed
)
430 ptrdiff_t real_gap_loc
;
431 ptrdiff_t real_gap_loc_byte
;
433 ptrdiff_t real_Z_byte
;
434 ptrdiff_t real_beg_unchanged
;
435 ptrdiff_t new_gap_size
;
437 /* Make sure the gap is at least GAP_BYTES_MIN bytes. */
438 if (GAP_SIZE
- nbytes_removed
< GAP_BYTES_MIN
)
439 nbytes_removed
= GAP_SIZE
- GAP_BYTES_MIN
;
441 /* Prevent quitting in move_gap. */
446 real_gap_loc_byte
= GPT_BYTE
;
447 new_gap_size
= GAP_SIZE
- nbytes_removed
;
449 real_Z_byte
= Z_BYTE
;
450 real_beg_unchanged
= BEG_UNCHANGED
;
452 /* Pretend that the last unwanted part of the gap is the entire gap,
453 and that the first desired part of the gap is part of the buffer
455 memset (GPT_ADDR
, 0, new_gap_size
);
457 GPT_BYTE
+= new_gap_size
;
459 Z_BYTE
+= new_gap_size
;
460 GAP_SIZE
= nbytes_removed
;
462 /* Move the unwanted pretend gap to the end of the buffer. */
463 gap_right (Z
, Z_BYTE
);
465 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
467 /* Now restore the desired gap. */
468 GAP_SIZE
= new_gap_size
;
470 GPT_BYTE
= real_gap_loc_byte
;
472 Z_BYTE
= real_Z_byte
;
473 BEG_UNCHANGED
= real_beg_unchanged
;
481 #endif /* USE_MMAP_FOR_BUFFERS || REL_ALLOC || DOUG_LEA_MALLOC */
484 make_gap (ptrdiff_t nbytes_added
)
486 if (nbytes_added
>= 0)
487 make_gap_larger (nbytes_added
);
488 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
490 make_gap_smaller (-nbytes_added
);
494 /* Add NBYTES to B's gap. It's enough to temporarily
495 fake current_buffer and avoid real switch to B. */
498 make_gap_1 (struct buffer
*b
, ptrdiff_t nbytes
)
500 struct buffer
*oldb
= current_buffer
;
504 current_buffer
= oldb
;
507 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
508 FROM_MULTIBYTE says whether the incoming text is multibyte.
509 TO_MULTIBYTE says whether to store the text as multibyte.
510 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
512 Return the number of bytes stored at TO_ADDR. */
515 copy_text (const unsigned char *from_addr
, unsigned char *to_addr
,
516 ptrdiff_t nbytes
, bool from_multibyte
, bool to_multibyte
)
518 if (from_multibyte
== to_multibyte
)
520 memcpy (to_addr
, from_addr
, nbytes
);
523 else if (from_multibyte
)
525 ptrdiff_t nchars
= 0;
526 ptrdiff_t bytes_left
= nbytes
;
528 while (bytes_left
> 0)
531 c
= STRING_CHAR_AND_LENGTH (from_addr
, thislen
);
532 if (! ASCII_CHAR_P (c
))
535 from_addr
+= thislen
;
536 bytes_left
-= thislen
;
543 unsigned char *initial_to_addr
= to_addr
;
545 /* Convert single-byte to multibyte. */
548 int c
= *from_addr
++;
550 if (!ASCII_CHAR_P (c
))
552 c
= BYTE8_TO_CHAR (c
);
553 to_addr
+= CHAR_STRING (c
, to_addr
);
557 /* Special case for speed. */
558 *to_addr
++ = c
, nbytes
--;
560 return to_addr
- initial_to_addr
;
564 /* Insert a string of specified length before point.
565 This function judges multibyteness based on
566 enable_multibyte_characters in the current buffer;
567 it never converts between single-byte and multibyte.
569 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
570 prepare_to_modify_buffer could relocate the text. */
573 insert (const char *string
, ptrdiff_t nbytes
)
577 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
578 insert_1_both (string
, len
, nbytes
, 0, 1, 0);
580 signal_after_change (opoint
, 0, len
);
581 update_compositions (opoint
, PT
, CHECK_BORDER
);
585 /* Likewise, but inherit text properties from neighboring characters. */
588 insert_and_inherit (const char *string
, ptrdiff_t nbytes
)
592 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
593 insert_1_both (string
, len
, nbytes
, 1, 1, 0);
595 signal_after_change (opoint
, 0, len
);
596 update_compositions (opoint
, PT
, CHECK_BORDER
);
600 /* Insert the character C before point. Do not inherit text properties. */
605 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
608 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
609 len
= CHAR_STRING (c
, str
);
616 insert ((char *) str
, len
);
619 /* Insert the null-terminated string S before point. */
622 insert_string (const char *s
)
624 insert (s
, strlen (s
));
627 /* Like `insert' except that all markers pointing at the place where
628 the insertion happens are adjusted to point after it.
629 Don't use this function to insert part of a Lisp string,
630 since gc could happen and relocate it. */
633 insert_before_markers (const char *string
, ptrdiff_t nbytes
)
637 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
638 insert_1_both (string
, len
, nbytes
, 0, 1, 1);
640 signal_after_change (opoint
, 0, len
);
641 update_compositions (opoint
, PT
, CHECK_BORDER
);
645 /* Likewise, but inherit text properties from neighboring characters. */
648 insert_before_markers_and_inherit (const char *string
,
653 ptrdiff_t len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
654 insert_1_both (string
, len
, nbytes
, 1, 1, 1);
656 signal_after_change (opoint
, 0, len
);
657 update_compositions (opoint
, PT
, CHECK_BORDER
);
661 /* Subroutine used by the insert functions above. */
664 insert_1 (const char *string
, ptrdiff_t nbytes
,
665 bool inherit
, bool prepare
, bool before_markers
)
667 insert_1_both (string
, chars_in_text ((unsigned char *) string
, nbytes
),
668 nbytes
, inherit
, prepare
, before_markers
);
672 #ifdef BYTE_COMBINING_DEBUG
674 /* See if the bytes before POS/POS_BYTE combine with bytes
675 at the start of STRING to form a single character.
676 If so, return the number of bytes at the start of STRING
677 which combine in this way. Otherwise, return 0. */
680 count_combining_before (const unsigned char *string
, ptrdiff_t length
,
681 ptrdiff_t pos
, ptrdiff_t pos_byte
)
683 int len
, combining_bytes
;
684 const unsigned char *p
;
686 if (NILP (current_buffer
->enable_multibyte_characters
))
689 /* At first, we can exclude the following cases:
690 (1) STRING[0] can't be a following byte of multibyte sequence.
691 (2) POS is the start of the current buffer.
692 (3) A character before POS is not a multibyte character. */
693 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
695 if (pos_byte
== BEG_BYTE
) /* case (2) */
698 p
= BYTE_POS_ADDR (pos_byte
- 1);
699 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
700 if (! LEADING_CODE_P (*p
)) /* case (3) */
703 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
704 if (combining_bytes
<= 0)
705 /* The character preceding POS is, complete and no room for
706 combining bytes (combining_bytes == 0), or an independent 8-bit
707 character (combining_bytes < 0). */
710 /* We have a combination situation. Count the bytes at STRING that
713 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
716 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
719 /* See if the bytes after POS/POS_BYTE combine with bytes
720 at the end of STRING to form a single character.
721 If so, return the number of bytes after POS/POS_BYTE
722 which combine in this way. Otherwise, return 0. */
725 count_combining_after (const unsigned char *string
,
726 ptrdiff_t length
, ptrdiff_t pos
, ptrdiff_t pos_byte
)
728 ptrdiff_t opos_byte
= pos_byte
;
733 if (NILP (current_buffer
->enable_multibyte_characters
))
736 /* At first, we can exclude the following cases:
737 (1) The last byte of STRING is an ASCII.
738 (2) POS is the last of the current buffer.
739 (3) A character at POS can't be a following byte of multibyte
741 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
743 if (pos_byte
== Z_BYTE
) /* case (2) */
745 bufp
= BYTE_POS_ADDR (pos_byte
);
746 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
750 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
756 /* All characters in STRING are not character head. We must
757 check also preceding bytes at POS. We are sure that the gap
759 unsigned char *p
= BEG_ADDR
;
761 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
763 if (i
< 0 || !LEADING_CODE_P (p
[i
]))
766 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
767 return (bytes
<= pos_byte
- 1 - i
+ length
769 : bytes
- (pos_byte
- 1 - i
+ length
));
771 if (!LEADING_CODE_P (string
[i
]))
774 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
776 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
778 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
784 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
785 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
786 are the same as in insert_1. */
789 insert_1_both (const char *string
,
790 ptrdiff_t nchars
, ptrdiff_t nbytes
,
791 bool inherit
, bool prepare
, bool before_markers
)
796 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
800 /* Do this before moving and increasing the gap,
801 because the before-change hooks might move the gap
802 or make it smaller. */
803 prepare_to_modify_buffer (PT
, PT
, NULL
);
806 move_gap_both (PT
, PT_BYTE
);
807 if (GAP_SIZE
< nbytes
)
808 make_gap (nbytes
- GAP_SIZE
);
810 #ifdef BYTE_COMBINING_DEBUG
811 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
812 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
816 /* Record deletion of the surrounding text that combines with
817 the insertion. This, together with recording the insertion,
818 will add up to the right stuff in the undo list. */
819 record_insert (PT
, nchars
);
821 CHARS_MODIFF
= MODIFF
;
823 memcpy (GPT_ADDR
, string
, nbytes
);
832 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
834 eassert (GPT
<= GPT_BYTE
);
836 /* The insert may have been in the unchanged region, so check again. */
837 if (Z
- GPT
< END_UNCHANGED
)
838 END_UNCHANGED
= Z
- GPT
;
840 adjust_overlays_for_insert (PT
, nchars
);
841 adjust_markers_for_insert (PT
, PT_BYTE
,
842 PT
+ nchars
, PT_BYTE
+ nbytes
,
845 offset_intervals (current_buffer
, PT
, nchars
);
847 if (!inherit
&& buffer_intervals (current_buffer
))
848 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
851 adjust_point (nchars
, nbytes
);
856 /* Insert the part of the text of STRING, a Lisp object assumed to be
857 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
858 starting at position POS / POS_BYTE. If the text of STRING has properties,
859 copy them into the buffer.
861 It does not work to use `insert' for this, because a GC could happen
862 before we copy the stuff into the buffer, and relocate the string
863 without insert noticing. */
866 insert_from_string (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
867 ptrdiff_t length
, ptrdiff_t length_byte
, bool inherit
)
869 ptrdiff_t opoint
= PT
;
871 if (SCHARS (string
) == 0)
874 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
876 signal_after_change (opoint
, 0, PT
- opoint
);
877 update_compositions (opoint
, PT
, CHECK_BORDER
);
880 /* Like `insert_from_string' except that all markers pointing
881 at the place where the insertion happens are adjusted to point after it. */
884 insert_from_string_before_markers (Lisp_Object string
,
885 ptrdiff_t pos
, ptrdiff_t pos_byte
,
886 ptrdiff_t length
, ptrdiff_t length_byte
,
889 ptrdiff_t opoint
= PT
;
891 if (SCHARS (string
) == 0)
894 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
896 signal_after_change (opoint
, 0, PT
- opoint
);
897 update_compositions (opoint
, PT
, CHECK_BORDER
);
900 /* Subroutine of the insertion functions above. */
903 insert_from_string_1 (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
904 ptrdiff_t nchars
, ptrdiff_t nbytes
,
905 bool inherit
, bool before_markers
)
908 ptrdiff_t outgoing_nbytes
= nbytes
;
911 /* Make OUTGOING_NBYTES describe the text
912 as it will be inserted in this buffer. */
914 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
915 outgoing_nbytes
= nchars
;
916 else if (! STRING_MULTIBYTE (string
))
918 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
922 /* Do this before moving and increasing the gap,
923 because the before-change hooks might move the gap
924 or make it smaller. */
925 prepare_to_modify_buffer (PT
, PT
, NULL
);
928 move_gap_both (PT
, PT_BYTE
);
929 if (GAP_SIZE
< outgoing_nbytes
)
930 make_gap (outgoing_nbytes
- GAP_SIZE
);
933 /* Copy the string text into the buffer, perhaps converting
934 between single-byte and multibyte. */
935 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
936 STRING_MULTIBYTE (string
),
937 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
939 #ifdef BYTE_COMBINING_DEBUG
940 /* We have copied text into the gap, but we have not altered
941 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
942 to these functions and get the same results as we would
943 have got earlier on. Meanwhile, PT_ADDR does point to
944 the text that has been stored by copy_text. */
945 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
946 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
950 record_insert (PT
, nchars
);
952 CHARS_MODIFF
= MODIFF
;
954 GAP_SIZE
-= outgoing_nbytes
;
958 GPT_BYTE
+= outgoing_nbytes
;
959 ZV_BYTE
+= outgoing_nbytes
;
960 Z_BYTE
+= outgoing_nbytes
;
961 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
963 eassert (GPT
<= GPT_BYTE
);
965 /* The insert may have been in the unchanged region, so check again. */
966 if (Z
- GPT
< END_UNCHANGED
)
967 END_UNCHANGED
= Z
- GPT
;
969 adjust_overlays_for_insert (PT
, nchars
);
970 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
971 PT_BYTE
+ outgoing_nbytes
,
974 offset_intervals (current_buffer
, PT
, nchars
);
976 intervals
= string_intervals (string
);
977 /* Get the intervals for the part of the string we are inserting. */
978 if (nbytes
< SBYTES (string
))
979 intervals
= copy_intervals (intervals
, pos
, nchars
);
981 /* Insert those intervals. */
982 graft_intervals_into_buffer (intervals
, PT
, nchars
,
983 current_buffer
, inherit
);
985 adjust_point (nchars
, outgoing_nbytes
);
990 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
991 starting at GPT_ADDR. */
994 insert_from_gap (ptrdiff_t nchars
, ptrdiff_t nbytes
)
996 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
999 record_insert (GPT
, nchars
);
1009 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1011 eassert (GPT
<= GPT_BYTE
);
1013 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1014 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1017 if (buffer_intervals (current_buffer
))
1019 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1020 graft_intervals_into_buffer (NULL
, GPT
- nchars
, nchars
,
1024 if (GPT
- nchars
< PT
)
1025 adjust_point (nchars
, nbytes
);
1030 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1031 current buffer. If the text in BUF has properties, they are absorbed
1032 into the current buffer.
1034 It does not work to use `insert' for this, because a malloc could happen
1035 and relocate BUF's text before the copy happens. */
1038 insert_from_buffer (struct buffer
*buf
,
1039 ptrdiff_t charpos
, ptrdiff_t nchars
, bool inherit
)
1041 ptrdiff_t opoint
= PT
;
1043 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1044 signal_after_change (opoint
, 0, PT
- opoint
);
1045 update_compositions (opoint
, PT
, CHECK_BORDER
);
1049 insert_from_buffer_1 (struct buffer
*buf
,
1050 ptrdiff_t from
, ptrdiff_t nchars
, bool inherit
)
1052 ptrdiff_t chunk
, chunk_expanded
;
1053 ptrdiff_t from_byte
= buf_charpos_to_bytepos (buf
, from
);
1054 ptrdiff_t to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1055 ptrdiff_t incoming_nbytes
= to_byte
- from_byte
;
1056 ptrdiff_t outgoing_nbytes
= incoming_nbytes
;
1059 /* Make OUTGOING_NBYTES describe the text
1060 as it will be inserted in this buffer. */
1062 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1063 outgoing_nbytes
= nchars
;
1064 else if (NILP (BVAR (buf
, enable_multibyte_characters
)))
1066 ptrdiff_t outgoing_before_gap
= 0;
1067 ptrdiff_t outgoing_after_gap
= 0;
1069 if (from
< BUF_GPT (buf
))
1071 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1072 if (chunk
> incoming_nbytes
)
1073 chunk
= incoming_nbytes
;
1075 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1081 if (chunk
< incoming_nbytes
)
1083 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1085 incoming_nbytes
- chunk
);
1087 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1090 /* Do this before moving and increasing the gap,
1091 because the before-change hooks might move the gap
1092 or make it smaller. */
1093 prepare_to_modify_buffer (PT
, PT
, NULL
);
1096 move_gap_both (PT
, PT_BYTE
);
1097 if (GAP_SIZE
< outgoing_nbytes
)
1098 make_gap (outgoing_nbytes
- GAP_SIZE
);
1100 if (from
< BUF_GPT (buf
))
1102 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1103 if (chunk
> incoming_nbytes
)
1104 chunk
= incoming_nbytes
;
1105 /* Record number of output bytes, so we know where
1106 to put the output from the second copy_text. */
1108 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1110 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1111 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1114 chunk_expanded
= chunk
= 0;
1116 if (chunk
< incoming_nbytes
)
1117 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1118 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1119 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1120 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1122 #ifdef BYTE_COMBINING_DEBUG
1123 /* We have copied text into the gap, but we have not altered
1124 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1125 to these functions and get the same results as we would
1126 have got earlier on. Meanwhile, GPT_ADDR does point to
1127 the text that has been stored by copy_text. */
1128 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1129 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1133 record_insert (PT
, nchars
);
1135 CHARS_MODIFF
= MODIFF
;
1137 GAP_SIZE
-= outgoing_nbytes
;
1141 GPT_BYTE
+= outgoing_nbytes
;
1142 ZV_BYTE
+= outgoing_nbytes
;
1143 Z_BYTE
+= outgoing_nbytes
;
1144 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1146 eassert (GPT
<= GPT_BYTE
);
1148 /* The insert may have been in the unchanged region, so check again. */
1149 if (Z
- GPT
< END_UNCHANGED
)
1150 END_UNCHANGED
= Z
- GPT
;
1152 adjust_overlays_for_insert (PT
, nchars
);
1153 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1154 PT_BYTE
+ outgoing_nbytes
,
1157 offset_intervals (current_buffer
, PT
, nchars
);
1159 /* Get the intervals for the part of the string we are inserting. */
1160 intervals
= buffer_intervals (buf
);
1161 if (nchars
< BUF_Z (buf
) - BUF_BEG (buf
))
1163 if (buf
== current_buffer
&& PT
<= from
)
1165 intervals
= copy_intervals (intervals
, from
, nchars
);
1168 /* Insert those intervals. */
1169 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1171 adjust_point (nchars
, outgoing_nbytes
);
1174 /* Record undo information and adjust markers and position keepers for
1175 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1176 chars (LEN_BYTE bytes) which resides in the gap just after
1179 PREV_TEXT nil means the new text was just inserted. */
1182 adjust_after_replace (ptrdiff_t from
, ptrdiff_t from_byte
,
1183 Lisp_Object prev_text
, ptrdiff_t len
, ptrdiff_t len_byte
)
1185 ptrdiff_t nchars_del
= 0, nbytes_del
= 0;
1187 #ifdef BYTE_COMBINING_DEBUG
1188 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1189 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1193 if (STRINGP (prev_text
))
1195 nchars_del
= SCHARS (prev_text
);
1196 nbytes_del
= SBYTES (prev_text
);
1199 /* Update various buffer positions for the new text. */
1200 GAP_SIZE
-= len_byte
;
1202 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1203 GPT
+= len
; GPT_BYTE
+= len_byte
;
1204 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1207 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1210 adjust_markers_for_insert (from
, from_byte
,
1211 from
+ len
, from_byte
+ len_byte
, 0);
1213 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1216 record_delete (from
, prev_text
);
1217 record_insert (from
, len
);
1220 if (len
> nchars_del
)
1221 adjust_overlays_for_insert (from
, len
- nchars_del
);
1222 else if (len
< nchars_del
)
1223 adjust_overlays_for_delete (from
, nchars_del
- len
);
1225 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1228 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1230 /* As byte combining will decrease Z, we must check this again. */
1231 if (Z
- GPT
< END_UNCHANGED
)
1232 END_UNCHANGED
= Z
- GPT
;
1237 evaporate_overlays (from
);
1239 CHARS_MODIFF
= MODIFF
;
1242 /* Record undo information, adjust markers and position keepers for an
1243 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1244 text already exists in the current buffer but character length (TO
1245 - FROM) may be incorrect, the correct length is NEWLEN. */
1248 adjust_after_insert (ptrdiff_t from
, ptrdiff_t from_byte
,
1249 ptrdiff_t to
, ptrdiff_t to_byte
, ptrdiff_t newlen
)
1251 ptrdiff_t len
= to
- from
, len_byte
= to_byte
- from_byte
;
1254 move_gap_both (to
, to_byte
);
1255 GAP_SIZE
+= len_byte
;
1256 GPT
-= len
; GPT_BYTE
-= len_byte
;
1257 ZV
-= len
; ZV_BYTE
-= len_byte
;
1258 Z
-= len
; Z_BYTE
-= len_byte
;
1259 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1262 /* Replace the text from character positions FROM to TO with NEW,
1263 If PREPARE, call prepare_to_modify_buffer.
1264 If INHERIT, the newly inserted text should inherit text properties
1265 from the surrounding non-deleted text. */
1267 /* Note that this does not yet handle markers quite right.
1268 Also it needs to record a single undo-entry that does a replacement
1269 rather than a separate delete and insert.
1270 That way, undo will also handle markers properly.
1272 But if MARKERS is 0, don't relocate markers. */
1275 replace_range (ptrdiff_t from
, ptrdiff_t to
, Lisp_Object
new,
1276 bool prepare
, bool inherit
, bool markers
)
1278 ptrdiff_t inschars
= SCHARS (new);
1279 ptrdiff_t insbytes
= SBYTES (new);
1280 ptrdiff_t from_byte
, to_byte
;
1281 ptrdiff_t nbytes_del
, nchars_del
;
1282 struct gcpro gcpro1
;
1284 ptrdiff_t outgoing_insbytes
= insbytes
;
1285 Lisp_Object deletion
;
1294 ptrdiff_t range_length
= to
- from
;
1295 prepare_to_modify_buffer (from
, to
, &from
);
1296 to
= from
+ range_length
;
1301 /* Make args be valid. */
1307 from_byte
= CHAR_TO_BYTE (from
);
1308 to_byte
= CHAR_TO_BYTE (to
);
1310 nchars_del
= to
- from
;
1311 nbytes_del
= to_byte
- from_byte
;
1313 if (nbytes_del
<= 0 && insbytes
== 0)
1316 /* Make OUTGOING_INSBYTES describe the text
1317 as it will be inserted in this buffer. */
1319 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1320 outgoing_insbytes
= inschars
;
1321 else if (! STRING_MULTIBYTE (new))
1323 = count_size_as_multibyte (SDATA (new), insbytes
);
1327 /* Make sure the gap is somewhere in or next to what we are deleting. */
1329 gap_right (from
, from_byte
);
1331 gap_left (to
, to_byte
, 0);
1333 /* Even if we don't record for undo, we must keep the original text
1334 because we may have to recover it because of inappropriate byte
1336 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1337 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1339 GAP_SIZE
+= nbytes_del
;
1342 ZV_BYTE
-= nbytes_del
;
1343 Z_BYTE
-= nbytes_del
;
1345 GPT_BYTE
= from_byte
;
1346 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1348 eassert (GPT
<= GPT_BYTE
);
1350 if (GPT
- BEG
< BEG_UNCHANGED
)
1351 BEG_UNCHANGED
= GPT
- BEG
;
1352 if (Z
- GPT
< END_UNCHANGED
)
1353 END_UNCHANGED
= Z
- GPT
;
1355 if (GAP_SIZE
< outgoing_insbytes
)
1356 make_gap (outgoing_insbytes
- GAP_SIZE
);
1358 /* Copy the string text into the buffer, perhaps converting
1359 between single-byte and multibyte. */
1360 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1361 STRING_MULTIBYTE (new),
1362 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1364 #ifdef BYTE_COMBINING_DEBUG
1365 /* We have copied text into the gap, but we have not marked
1366 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1367 here, for both the previous text and the following text.
1368 Meanwhile, GPT_ADDR does point to
1369 the text that has been stored by copy_text. */
1370 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1371 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1375 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1377 /* Record the insertion first, so that when we undo,
1378 the deletion will be undone first. Thus, undo
1379 will insert before deleting, and thus will keep
1380 the markers before and after this text separate. */
1381 record_insert (from
+ SCHARS (deletion
), inschars
);
1382 record_delete (from
, deletion
);
1385 GAP_SIZE
-= outgoing_insbytes
;
1389 GPT_BYTE
+= outgoing_insbytes
;
1390 ZV_BYTE
+= outgoing_insbytes
;
1391 Z_BYTE
+= outgoing_insbytes
;
1392 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1394 eassert (GPT
<= GPT_BYTE
);
1396 /* Adjust markers for the deletion and the insertion. */
1398 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1399 inschars
, outgoing_insbytes
);
1401 /* Adjust the overlay center as needed. This must be done after
1402 adjusting the markers that bound the overlays. */
1403 adjust_overlays_for_delete (from
, nchars_del
);
1404 adjust_overlays_for_insert (from
, inschars
);
1406 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1408 /* Get the intervals for the part of the string we are inserting--
1409 not including the combined-before bytes. */
1410 intervals
= string_intervals (new);
1411 /* Insert those intervals. */
1412 graft_intervals_into_buffer (intervals
, from
, inschars
,
1413 current_buffer
, inherit
);
1415 /* Relocate point as if it were a marker. */
1417 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1418 (from_byte
+ outgoing_insbytes
1419 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1421 if (outgoing_insbytes
== 0)
1422 evaporate_overlays (from
);
1427 CHARS_MODIFF
= MODIFF
;
1430 signal_after_change (from
, nchars_del
, GPT
- from
);
1431 update_compositions (from
, GPT
, CHECK_BORDER
);
1434 /* Replace the text from character positions FROM to TO with
1435 the text in INS of length INSCHARS.
1436 Keep the text properties that applied to the old characters
1437 (extending them to all the new chars if there are more new chars).
1439 Note that this does not yet handle markers quite right.
1441 If MARKERS, relocate markers.
1443 Unlike most functions at this level, never call
1444 prepare_to_modify_buffer and never call signal_after_change. */
1447 replace_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1448 ptrdiff_t to
, ptrdiff_t to_byte
,
1449 const char *ins
, ptrdiff_t inschars
, ptrdiff_t insbytes
,
1452 ptrdiff_t nbytes_del
, nchars_del
;
1456 nchars_del
= to
- from
;
1457 nbytes_del
= to_byte
- from_byte
;
1459 if (nbytes_del
<= 0 && insbytes
== 0)
1462 /* Make sure the gap is somewhere in or next to what we are deleting. */
1464 gap_right (from
, from_byte
);
1466 gap_left (to
, to_byte
, 0);
1468 GAP_SIZE
+= nbytes_del
;
1471 ZV_BYTE
-= nbytes_del
;
1472 Z_BYTE
-= nbytes_del
;
1474 GPT_BYTE
= from_byte
;
1475 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1477 eassert (GPT
<= GPT_BYTE
);
1479 if (GPT
- BEG
< BEG_UNCHANGED
)
1480 BEG_UNCHANGED
= GPT
- BEG
;
1481 if (Z
- GPT
< END_UNCHANGED
)
1482 END_UNCHANGED
= Z
- GPT
;
1484 if (GAP_SIZE
< insbytes
)
1485 make_gap (insbytes
- GAP_SIZE
);
1487 /* Copy the replacement text into the buffer. */
1488 memcpy (GPT_ADDR
, ins
, insbytes
);
1490 #ifdef BYTE_COMBINING_DEBUG
1491 /* We have copied text into the gap, but we have not marked
1492 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1493 here, for both the previous text and the following text.
1494 Meanwhile, GPT_ADDR does point to
1495 the text that has been stored by copy_text. */
1496 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1497 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1501 GAP_SIZE
-= insbytes
;
1505 GPT_BYTE
+= insbytes
;
1506 ZV_BYTE
+= insbytes
;
1508 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1510 eassert (GPT
<= GPT_BYTE
);
1512 /* Adjust markers for the deletion and the insertion. */
1514 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1515 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1516 inschars
, insbytes
);
1518 /* Adjust the overlay center as needed. This must be done after
1519 adjusting the markers that bound the overlays. */
1520 if (nchars_del
!= inschars
)
1522 adjust_overlays_for_insert (from
, inschars
);
1523 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1526 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1528 /* Relocate point as if it were a marker. */
1529 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1532 /* PT was within the deleted text. Move it to FROM. */
1533 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1535 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1539 evaporate_overlays (from
);
1544 CHARS_MODIFF
= MODIFF
;
1547 /* Delete characters in current buffer
1548 from FROM up to (but not including) TO.
1549 If TO comes before FROM, we delete nothing. */
1552 del_range (ptrdiff_t from
, ptrdiff_t to
)
1554 del_range_1 (from
, to
, 1, 0);
1557 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1558 RET_STRING says to return the deleted text. */
1561 del_range_1 (ptrdiff_t from
, ptrdiff_t to
, bool prepare
, bool ret_string
)
1563 ptrdiff_t from_byte
, to_byte
;
1564 Lisp_Object deletion
;
1565 struct gcpro gcpro1
;
1567 /* Make args be valid */
1578 ptrdiff_t range_length
= to
- from
;
1579 prepare_to_modify_buffer (from
, to
, &from
);
1580 to
= min (ZV
, from
+ range_length
);
1583 from_byte
= CHAR_TO_BYTE (from
);
1584 to_byte
= CHAR_TO_BYTE (to
);
1586 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1588 signal_after_change (from
, to
- from
, 0);
1589 update_compositions (from
, from
, CHECK_HEAD
);
1594 /* Like del_range_1 but args are byte positions, not char positions. */
1597 del_range_byte (ptrdiff_t from_byte
, ptrdiff_t to_byte
, bool prepare
)
1601 /* Make args be valid */
1602 if (from_byte
< BEGV_BYTE
)
1603 from_byte
= BEGV_BYTE
;
1604 if (to_byte
> ZV_BYTE
)
1607 if (to_byte
<= from_byte
)
1610 from
= BYTE_TO_CHAR (from_byte
);
1611 to
= BYTE_TO_CHAR (to_byte
);
1615 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1616 ptrdiff_t range_length
= to
- from
;
1617 prepare_to_modify_buffer (from
, to
, &from
);
1618 to
= from
+ range_length
;
1620 if (old_from
!= from
)
1621 from_byte
= CHAR_TO_BYTE (from
);
1627 else if (old_to
== Z
- to
)
1628 to_byte
= CHAR_TO_BYTE (to
);
1631 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1632 signal_after_change (from
, to
- from
, 0);
1633 update_compositions (from
, from
, CHECK_HEAD
);
1636 /* Like del_range_1, but positions are specified both as charpos
1640 del_range_both (ptrdiff_t from
, ptrdiff_t from_byte
,
1641 ptrdiff_t to
, ptrdiff_t to_byte
, bool prepare
)
1643 /* Make args be valid */
1644 if (from_byte
< BEGV_BYTE
)
1645 from_byte
= BEGV_BYTE
;
1646 if (to_byte
> ZV_BYTE
)
1649 if (to_byte
<= from_byte
)
1659 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1660 ptrdiff_t range_length
= to
- from
;
1661 prepare_to_modify_buffer (from
, to
, &from
);
1662 to
= from
+ range_length
;
1664 if (old_from
!= from
)
1665 from_byte
= CHAR_TO_BYTE (from
);
1671 else if (old_to
== Z
- to
)
1672 to_byte
= CHAR_TO_BYTE (to
);
1675 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1676 signal_after_change (from
, to
- from
, 0);
1677 update_compositions (from
, from
, CHECK_HEAD
);
1680 /* Delete a range of text, specified both as character positions
1681 and byte positions. FROM and TO are character positions,
1682 while FROM_BYTE and TO_BYTE are byte positions.
1683 If RET_STRING, the deleted area is returned as a string. */
1686 del_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1687 ptrdiff_t to
, ptrdiff_t to_byte
, bool ret_string
)
1689 ptrdiff_t nbytes_del
, nchars_del
;
1690 Lisp_Object deletion
;
1694 nchars_del
= to
- from
;
1695 nbytes_del
= to_byte
- from_byte
;
1697 /* Make sure the gap is somewhere in or next to what we are deleting. */
1699 gap_right (from
, from_byte
);
1701 gap_left (to
, to_byte
, 0);
1703 #ifdef BYTE_COMBINING_DEBUG
1704 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1705 Z_BYTE
- to_byte
, from
, from_byte
))
1709 if (ret_string
|| ! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1710 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1714 /* Relocate all markers pointing into the new, larger gap
1715 to point at the end of the text before the gap.
1716 Do this before recording the deletion,
1717 so that undo handles this after reinserting the text. */
1718 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1720 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1721 record_delete (from
, deletion
);
1723 CHARS_MODIFF
= MODIFF
;
1725 /* Relocate point as if it were a marker. */
1727 adjust_point (from
- (PT
< to
? PT
: to
),
1728 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1730 offset_intervals (current_buffer
, from
, - nchars_del
);
1732 /* Adjust the overlay center as needed. This must be done after
1733 adjusting the markers that bound the overlays. */
1734 adjust_overlays_for_delete (from
, nchars_del
);
1736 GAP_SIZE
+= nbytes_del
;
1737 ZV_BYTE
-= nbytes_del
;
1738 Z_BYTE
-= nbytes_del
;
1742 GPT_BYTE
= from_byte
;
1743 if (GAP_SIZE
> 0 && !current_buffer
->text
->inhibit_shrinking
)
1744 /* Put an anchor, unless called from decode_coding_object which
1745 needs to access the previous gap contents. */
1748 eassert (GPT
<= GPT_BYTE
);
1750 if (GPT
- BEG
< BEG_UNCHANGED
)
1751 BEG_UNCHANGED
= GPT
- BEG
;
1752 if (Z
- GPT
< END_UNCHANGED
)
1753 END_UNCHANGED
= Z
- GPT
;
1757 evaporate_overlays (from
);
1762 /* Call this if you're about to change the region of current buffer
1763 from character positions START to END. This checks the read-only
1764 properties of the region, calls the necessary modification hooks,
1765 and warns the next redisplay that it should pay attention to that
1768 If PRESERVE_CHARS_MODIFF, do not update CHARS_MODIFF.
1769 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
1772 modify_region_1 (ptrdiff_t start
, ptrdiff_t end
, bool preserve_chars_modiff
)
1774 prepare_to_modify_buffer (start
, end
, NULL
);
1776 BUF_COMPUTE_UNCHANGED (current_buffer
, start
- 1, end
);
1778 if (MODIFF
<= SAVE_MODIFF
)
1779 record_first_change ();
1781 if (! preserve_chars_modiff
)
1782 CHARS_MODIFF
= MODIFF
;
1784 bset_point_before_scroll (current_buffer
, Qnil
);
1787 /* Check that it is okay to modify the buffer between START and END,
1788 which are char positions.
1790 Run the before-change-function, if any. If intervals are in use,
1791 verify that the text to be modified is not read-only, and call
1792 any modification properties the text may have.
1794 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1795 by holding its value temporarily in a marker. */
1798 prepare_to_modify_buffer (ptrdiff_t start
, ptrdiff_t end
,
1799 ptrdiff_t *preserve_ptr
)
1801 struct buffer
*base_buffer
;
1803 if (!NILP (BVAR (current_buffer
, read_only
)))
1804 Fbarf_if_buffer_read_only ();
1806 /* If we're modifying the buffer other than shown in a selected window,
1807 let redisplay consider other windows if this buffer is visible. */
1808 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
1809 && buffer_window_count (current_buffer
))
1810 ++windows_or_buffers_changed
;
1812 if (buffer_intervals (current_buffer
))
1816 Lisp_Object preserve_marker
;
1817 struct gcpro gcpro1
;
1818 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1819 GCPRO1 (preserve_marker
);
1820 verify_interval_modification (current_buffer
, start
, end
);
1821 *preserve_ptr
= marker_position (preserve_marker
);
1822 unchain_marker (XMARKER (preserve_marker
));
1826 verify_interval_modification (current_buffer
, start
, end
);
1829 /* For indirect buffers, use the base buffer to check clashes. */
1830 if (current_buffer
->base_buffer
!= 0)
1831 base_buffer
= current_buffer
->base_buffer
;
1833 base_buffer
= current_buffer
;
1835 #ifdef CLASH_DETECTION
1836 if (!NILP (BVAR (base_buffer
, file_truename
))
1837 /* Make binding buffer-file-name to nil effective. */
1838 && !NILP (BVAR (base_buffer
, filename
))
1839 && SAVE_MODIFF
>= MODIFF
)
1840 lock_file (BVAR (base_buffer
, file_truename
));
1842 /* At least warn if this file has changed on disk since it was visited. */
1843 if (!NILP (BVAR (base_buffer
, filename
))
1844 && SAVE_MODIFF
>= MODIFF
1845 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1846 && !NILP (Ffile_exists_p (BVAR (base_buffer
, filename
))))
1847 call1 (intern ("ask-user-about-supersession-threat"),
1848 BVAR (base_buffer
,filename
));
1849 #endif /* not CLASH_DETECTION */
1851 /* If `select-active-regions' is non-nil, save the region text. */
1852 if (!NILP (BVAR (current_buffer
, mark_active
))
1853 && !inhibit_modification_hooks
1854 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1855 && NILP (Vsaved_region_selection
)
1856 && (EQ (Vselect_active_regions
, Qonly
)
1857 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1858 : (!NILP (Vselect_active_regions
)
1859 && !NILP (Vtransient_mark_mode
))))
1861 ptrdiff_t b
= marker_position (BVAR (current_buffer
, mark
));
1864 Vsaved_region_selection
= make_buffer_string (b
, e
, 0);
1866 Vsaved_region_selection
= make_buffer_string (e
, b
, 0);
1869 signal_before_change (start
, end
, preserve_ptr
);
1871 if (current_buffer
->newline_cache
)
1872 invalidate_region_cache (current_buffer
,
1873 current_buffer
->newline_cache
,
1874 start
- BEG
, Z
- end
);
1875 if (current_buffer
->width_run_cache
)
1876 invalidate_region_cache (current_buffer
,
1877 current_buffer
->width_run_cache
,
1878 start
- BEG
, Z
- end
);
1880 Vdeactivate_mark
= Qt
;
1883 /* These macros work with an argument named `preserve_ptr'
1884 and a local variable named `preserve_marker'. */
1886 #define PRESERVE_VALUE \
1887 if (preserve_ptr && NILP (preserve_marker)) \
1888 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1890 #define RESTORE_VALUE \
1891 if (! NILP (preserve_marker)) \
1893 *preserve_ptr = marker_position (preserve_marker); \
1894 unchain_marker (XMARKER (preserve_marker)); \
1897 #define PRESERVE_START_END \
1898 if (NILP (start_marker)) \
1899 start_marker = Fcopy_marker (start, Qnil); \
1900 if (NILP (end_marker)) \
1901 end_marker = Fcopy_marker (end, Qnil);
1903 #define FETCH_START \
1904 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1907 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1909 /* Set a variable to nil if an error occurred.
1910 Don't change the variable if there was no error.
1911 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
1912 VARIABLE is the variable to maybe set to nil.
1913 NO-ERROR-FLAG is nil if there was an error,
1914 anything else meaning no error (so this function does nothing). */
1916 reset_var_on_error (Lisp_Object val
)
1918 if (NILP (XCDR (val
)))
1919 Fset (XCAR (val
), Qnil
);
1923 /* Signal a change to the buffer immediately before it happens.
1924 START_INT and END_INT are the bounds of the text to be changed.
1926 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1927 by holding its value temporarily in a marker. */
1930 signal_before_change (ptrdiff_t start_int
, ptrdiff_t end_int
,
1931 ptrdiff_t *preserve_ptr
)
1933 Lisp_Object start
, end
;
1934 Lisp_Object start_marker
, end_marker
;
1935 Lisp_Object preserve_marker
;
1936 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1937 ptrdiff_t count
= SPECPDL_INDEX ();
1939 if (inhibit_modification_hooks
)
1942 start
= make_number (start_int
);
1943 end
= make_number (end_int
);
1944 preserve_marker
= Qnil
;
1945 start_marker
= Qnil
;
1947 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1949 specbind (Qinhibit_modification_hooks
, Qt
);
1951 /* If buffer is unmodified, run a special hook for that case. The
1952 check for Vfirst_change_hook is just a minor optimization. */
1953 if (SAVE_MODIFF
>= MODIFF
1954 && !NILP (Vfirst_change_hook
))
1958 Frun_hooks (1, &Qfirst_change_hook
);
1961 /* Now run the before-change-functions if any. */
1962 if (!NILP (Vbefore_change_functions
))
1964 Lisp_Object args
[3];
1965 Lisp_Object rvoe_arg
= Fcons (Qbefore_change_functions
, Qnil
);
1970 /* Mark before-change-functions to be reset to nil in case of error. */
1971 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
1973 /* Actually run the hook functions. */
1974 args
[0] = Qbefore_change_functions
;
1975 args
[1] = FETCH_START
;
1976 args
[2] = FETCH_END
;
1977 Frun_hook_with_args (3, args
);
1979 /* There was no error: unarm the reset_on_error. */
1980 XSETCDR (rvoe_arg
, Qt
);
1983 if (buffer_has_overlays ())
1986 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1987 FETCH_START
, FETCH_END
, Qnil
);
1990 if (! NILP (start_marker
))
1991 free_marker (start_marker
);
1992 if (! NILP (end_marker
))
1993 free_marker (end_marker
);
1997 unbind_to (count
, Qnil
);
2000 /* Signal a change immediately after it happens.
2001 CHARPOS is the character position of the start of the changed text.
2002 LENDEL is the number of characters of the text before the change.
2003 (Not the whole buffer; just the part that was changed.)
2004 LENINS is the number of characters in that part of the text
2005 after the change. */
2008 signal_after_change (ptrdiff_t charpos
, ptrdiff_t lendel
, ptrdiff_t lenins
)
2010 ptrdiff_t count
= SPECPDL_INDEX ();
2011 if (inhibit_modification_hooks
)
2014 /* If we are deferring calls to the after-change functions
2015 and there are no before-change functions,
2016 just record the args that we were going to use. */
2017 if (! NILP (Vcombine_after_change_calls
)
2018 && NILP (Vbefore_change_functions
)
2019 && !buffer_has_overlays ())
2023 if (!NILP (combine_after_change_list
)
2024 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2025 Fcombine_after_change_execute ();
2027 elt
= Fcons (make_number (charpos
- BEG
),
2028 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2029 Fcons (make_number (lenins
- lendel
), Qnil
)));
2030 combine_after_change_list
2031 = Fcons (elt
, combine_after_change_list
);
2032 combine_after_change_buffer
= Fcurrent_buffer ();
2037 if (!NILP (combine_after_change_list
))
2038 Fcombine_after_change_execute ();
2040 specbind (Qinhibit_modification_hooks
, Qt
);
2042 if (!NILP (Vafter_change_functions
))
2044 Lisp_Object args
[4];
2045 Lisp_Object rvoe_arg
= Fcons (Qafter_change_functions
, Qnil
);
2047 /* Mark after-change-functions to be reset to nil in case of error. */
2048 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2050 /* Actually run the hook functions. */
2051 args
[0] = Qafter_change_functions
;
2052 XSETFASTINT (args
[1], charpos
);
2053 XSETFASTINT (args
[2], charpos
+ lenins
);
2054 XSETFASTINT (args
[3], lendel
);
2055 Frun_hook_with_args (4, args
);
2057 /* There was no error: unarm the reset_on_error. */
2058 XSETCDR (rvoe_arg
, Qt
);
2061 if (buffer_has_overlays ())
2062 report_overlay_modification (make_number (charpos
),
2063 make_number (charpos
+ lenins
),
2065 make_number (charpos
),
2066 make_number (charpos
+ lenins
),
2067 make_number (lendel
));
2069 /* After an insertion, call the text properties
2070 insert-behind-hooks or insert-in-front-hooks. */
2072 report_interval_modification (make_number (charpos
),
2073 make_number (charpos
+ lenins
));
2075 unbind_to (count
, Qnil
);
2079 Fcombine_after_change_execute_1 (Lisp_Object val
)
2081 Vcombine_after_change_calls
= val
;
2085 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2086 Scombine_after_change_execute
, 0, 0, 0,
2087 doc
: /* This function is for use internally in the function `combine-after-change-calls'. */)
2090 ptrdiff_t count
= SPECPDL_INDEX ();
2091 ptrdiff_t beg
, end
, change
;
2092 ptrdiff_t begpos
, endpos
;
2095 if (NILP (combine_after_change_list
))
2098 /* It is rare for combine_after_change_buffer to be invalid, but
2099 possible. It can happen when combine-after-change-calls is
2100 non-nil, and insertion calls a file handler (e.g. through
2101 lock_file) which scribbles into a temp file -- cyd */
2102 if (!BUFFERP (combine_after_change_buffer
)
2103 || !BUFFER_LIVE_P (XBUFFER (combine_after_change_buffer
)))
2105 combine_after_change_list
= Qnil
;
2109 record_unwind_current_buffer ();
2111 Fset_buffer (combine_after_change_buffer
);
2113 /* # chars unchanged at beginning of buffer. */
2115 /* # chars unchanged at end of buffer. */
2117 /* Total amount of insertion (negative for deletion). */
2120 /* Scan the various individual changes,
2121 accumulating the range info in BEG, END and CHANGE. */
2122 for (tail
= combine_after_change_list
; CONSP (tail
);
2126 ptrdiff_t thisbeg
, thisend
, thischange
;
2128 /* Extract the info from the next element. */
2132 thisbeg
= XINT (XCAR (elt
));
2137 thisend
= XINT (XCAR (elt
));
2142 thischange
= XINT (XCAR (elt
));
2144 /* Merge this range into the accumulated range. */
2145 change
+= thischange
;
2152 /* Get the current start and end positions of the range
2153 that was changed. */
2157 /* We are about to handle these, so discard them. */
2158 combine_after_change_list
= Qnil
;
2160 /* Now run the after-change functions for real.
2161 Turn off the flag that defers them. */
2162 record_unwind_protect (Fcombine_after_change_execute_1
,
2163 Vcombine_after_change_calls
);
2164 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2165 update_compositions (begpos
, endpos
, CHECK_ALL
);
2167 return unbind_to (count
, Qnil
);
2171 syms_of_insdel (void)
2173 staticpro (&combine_after_change_list
);
2174 staticpro (&combine_after_change_buffer
);
2175 combine_after_change_list
= Qnil
;
2176 combine_after_change_buffer
= Qnil
;
2178 DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls
,
2179 doc
: /* Used internally by the function `combine-after-change-calls' macro. */);
2180 Vcombine_after_change_calls
= Qnil
;
2182 DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks
,
2183 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2184 This affects `before-change-functions' and `after-change-functions',
2185 as well as hooks attached to text properties and overlays. */);
2186 inhibit_modification_hooks
= 0;
2187 DEFSYM (Qinhibit_modification_hooks
, "inhibit-modification-hooks");
2189 defsubr (&Scombine_after_change_execute
);