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 #ifdef BYTE_COMBINING_DEBUG
663 /* See if the bytes before POS/POS_BYTE combine with bytes
664 at the start of STRING to form a single character.
665 If so, return the number of bytes at the start of STRING
666 which combine in this way. Otherwise, return 0. */
669 count_combining_before (const unsigned char *string
, ptrdiff_t length
,
670 ptrdiff_t pos
, ptrdiff_t pos_byte
)
672 int len
, combining_bytes
;
673 const unsigned char *p
;
675 if (NILP (current_buffer
->enable_multibyte_characters
))
678 /* At first, we can exclude the following cases:
679 (1) STRING[0] can't be a following byte of multibyte sequence.
680 (2) POS is the start of the current buffer.
681 (3) A character before POS is not a multibyte character. */
682 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
684 if (pos_byte
== BEG_BYTE
) /* case (2) */
687 p
= BYTE_POS_ADDR (pos_byte
- 1);
688 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
689 if (! LEADING_CODE_P (*p
)) /* case (3) */
692 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
693 if (combining_bytes
<= 0)
694 /* The character preceding POS is, complete and no room for
695 combining bytes (combining_bytes == 0), or an independent 8-bit
696 character (combining_bytes < 0). */
699 /* We have a combination situation. Count the bytes at STRING that
702 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
705 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
708 /* See if the bytes after POS/POS_BYTE combine with bytes
709 at the end of STRING to form a single character.
710 If so, return the number of bytes after POS/POS_BYTE
711 which combine in this way. Otherwise, return 0. */
714 count_combining_after (const unsigned char *string
,
715 ptrdiff_t length
, ptrdiff_t pos
, ptrdiff_t pos_byte
)
717 ptrdiff_t opos_byte
= pos_byte
;
722 if (NILP (current_buffer
->enable_multibyte_characters
))
725 /* At first, we can exclude the following cases:
726 (1) The last byte of STRING is an ASCII.
727 (2) POS is the last of the current buffer.
728 (3) A character at POS can't be a following byte of multibyte
730 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
732 if (pos_byte
== Z_BYTE
) /* case (2) */
734 bufp
= BYTE_POS_ADDR (pos_byte
);
735 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
739 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
745 /* All characters in STRING are not character head. We must
746 check also preceding bytes at POS. We are sure that the gap
748 unsigned char *p
= BEG_ADDR
;
750 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
752 if (i
< 0 || !LEADING_CODE_P (p
[i
]))
755 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
756 return (bytes
<= pos_byte
- 1 - i
+ length
758 : bytes
- (pos_byte
- 1 - i
+ length
));
760 if (!LEADING_CODE_P (string
[i
]))
763 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
765 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
767 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
773 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
774 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
775 are the same as in insert_1. */
778 insert_1_both (const char *string
,
779 ptrdiff_t nchars
, ptrdiff_t nbytes
,
780 bool inherit
, bool prepare
, bool before_markers
)
785 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
789 /* Do this before moving and increasing the gap,
790 because the before-change hooks might move the gap
791 or make it smaller. */
792 prepare_to_modify_buffer (PT
, PT
, NULL
);
795 move_gap_both (PT
, PT_BYTE
);
796 if (GAP_SIZE
< nbytes
)
797 make_gap (nbytes
- GAP_SIZE
);
799 #ifdef BYTE_COMBINING_DEBUG
800 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
801 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
805 /* Record deletion of the surrounding text that combines with
806 the insertion. This, together with recording the insertion,
807 will add up to the right stuff in the undo list. */
808 record_insert (PT
, nchars
);
810 CHARS_MODIFF
= MODIFF
;
812 memcpy (GPT_ADDR
, string
, nbytes
);
821 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
823 eassert (GPT
<= GPT_BYTE
);
825 /* The insert may have been in the unchanged region, so check again. */
826 if (Z
- GPT
< END_UNCHANGED
)
827 END_UNCHANGED
= Z
- GPT
;
829 adjust_overlays_for_insert (PT
, nchars
);
830 adjust_markers_for_insert (PT
, PT_BYTE
,
831 PT
+ nchars
, PT_BYTE
+ nbytes
,
834 offset_intervals (current_buffer
, PT
, nchars
);
836 if (!inherit
&& buffer_intervals (current_buffer
))
837 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
840 adjust_point (nchars
, nbytes
);
845 /* Insert the part of the text of STRING, a Lisp object assumed to be
846 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
847 starting at position POS / POS_BYTE. If the text of STRING has properties,
848 copy them into the buffer.
850 It does not work to use `insert' for this, because a GC could happen
851 before we copy the stuff into the buffer, and relocate the string
852 without insert noticing. */
855 insert_from_string (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
856 ptrdiff_t length
, ptrdiff_t length_byte
, bool inherit
)
858 ptrdiff_t opoint
= PT
;
860 if (SCHARS (string
) == 0)
863 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
865 signal_after_change (opoint
, 0, PT
- opoint
);
866 update_compositions (opoint
, PT
, CHECK_BORDER
);
869 /* Like `insert_from_string' except that all markers pointing
870 at the place where the insertion happens are adjusted to point after it. */
873 insert_from_string_before_markers (Lisp_Object string
,
874 ptrdiff_t pos
, ptrdiff_t pos_byte
,
875 ptrdiff_t length
, ptrdiff_t length_byte
,
878 ptrdiff_t opoint
= PT
;
880 if (SCHARS (string
) == 0)
883 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
885 signal_after_change (opoint
, 0, PT
- opoint
);
886 update_compositions (opoint
, PT
, CHECK_BORDER
);
889 /* Subroutine of the insertion functions above. */
892 insert_from_string_1 (Lisp_Object string
, ptrdiff_t pos
, ptrdiff_t pos_byte
,
893 ptrdiff_t nchars
, ptrdiff_t nbytes
,
894 bool inherit
, bool before_markers
)
897 ptrdiff_t outgoing_nbytes
= nbytes
;
900 /* Make OUTGOING_NBYTES describe the text
901 as it will be inserted in this buffer. */
903 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
904 outgoing_nbytes
= nchars
;
905 else if (! STRING_MULTIBYTE (string
))
907 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
911 /* Do this before moving and increasing the gap,
912 because the before-change hooks might move the gap
913 or make it smaller. */
914 prepare_to_modify_buffer (PT
, PT
, NULL
);
917 move_gap_both (PT
, PT_BYTE
);
918 if (GAP_SIZE
< outgoing_nbytes
)
919 make_gap (outgoing_nbytes
- GAP_SIZE
);
922 /* Copy the string text into the buffer, perhaps converting
923 between single-byte and multibyte. */
924 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
925 STRING_MULTIBYTE (string
),
926 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
928 #ifdef BYTE_COMBINING_DEBUG
929 /* We have copied text into the gap, but we have not altered
930 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
931 to these functions and get the same results as we would
932 have got earlier on. Meanwhile, PT_ADDR does point to
933 the text that has been stored by copy_text. */
934 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
935 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
939 record_insert (PT
, nchars
);
941 CHARS_MODIFF
= MODIFF
;
943 GAP_SIZE
-= outgoing_nbytes
;
947 GPT_BYTE
+= outgoing_nbytes
;
948 ZV_BYTE
+= outgoing_nbytes
;
949 Z_BYTE
+= outgoing_nbytes
;
950 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
952 eassert (GPT
<= GPT_BYTE
);
954 /* The insert may have been in the unchanged region, so check again. */
955 if (Z
- GPT
< END_UNCHANGED
)
956 END_UNCHANGED
= Z
- GPT
;
958 adjust_overlays_for_insert (PT
, nchars
);
959 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
960 PT_BYTE
+ outgoing_nbytes
,
963 offset_intervals (current_buffer
, PT
, nchars
);
965 intervals
= string_intervals (string
);
966 /* Get the intervals for the part of the string we are inserting. */
967 if (nbytes
< SBYTES (string
))
968 intervals
= copy_intervals (intervals
, pos
, nchars
);
970 /* Insert those intervals. */
971 graft_intervals_into_buffer (intervals
, PT
, nchars
,
972 current_buffer
, inherit
);
974 adjust_point (nchars
, outgoing_nbytes
);
979 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
980 starting at GAP_END_ADDR - NBYTES (if text_at_gap_tail) and at
981 GPT_ADDR (if not text_at_gap_tail). */
984 insert_from_gap (ptrdiff_t nchars
, ptrdiff_t nbytes
, bool text_at_gap_tail
)
986 int ins_charpos
= GPT
;
987 int ins_bytepos
= GPT_BYTE
;
989 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
992 record_insert (GPT
, nchars
);
996 if (! text_at_gap_tail
)
1005 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1007 eassert (GPT
<= GPT_BYTE
);
1009 adjust_overlays_for_insert (ins_charpos
, nchars
);
1010 adjust_markers_for_insert (ins_charpos
, ins_bytepos
,
1011 ins_charpos
+ nchars
, ins_bytepos
+ nbytes
, 0);
1013 if (buffer_intervals (current_buffer
))
1015 offset_intervals (current_buffer
, ins_charpos
, nchars
);
1016 graft_intervals_into_buffer (NULL
, ins_charpos
, nchars
,
1020 if (ins_charpos
< PT
)
1021 adjust_point (nchars
, nbytes
);
1026 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1027 current buffer. If the text in BUF has properties, they are absorbed
1028 into the current buffer.
1030 It does not work to use `insert' for this, because a malloc could happen
1031 and relocate BUF's text before the copy happens. */
1034 insert_from_buffer (struct buffer
*buf
,
1035 ptrdiff_t charpos
, ptrdiff_t nchars
, bool inherit
)
1037 ptrdiff_t opoint
= PT
;
1039 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1040 signal_after_change (opoint
, 0, PT
- opoint
);
1041 update_compositions (opoint
, PT
, CHECK_BORDER
);
1045 insert_from_buffer_1 (struct buffer
*buf
,
1046 ptrdiff_t from
, ptrdiff_t nchars
, bool inherit
)
1048 ptrdiff_t chunk
, chunk_expanded
;
1049 ptrdiff_t from_byte
= buf_charpos_to_bytepos (buf
, from
);
1050 ptrdiff_t to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1051 ptrdiff_t incoming_nbytes
= to_byte
- from_byte
;
1052 ptrdiff_t outgoing_nbytes
= incoming_nbytes
;
1055 /* Make OUTGOING_NBYTES describe the text
1056 as it will be inserted in this buffer. */
1058 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1059 outgoing_nbytes
= nchars
;
1060 else if (NILP (BVAR (buf
, enable_multibyte_characters
)))
1062 ptrdiff_t outgoing_before_gap
= 0;
1063 ptrdiff_t outgoing_after_gap
= 0;
1065 if (from
< BUF_GPT (buf
))
1067 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1068 if (chunk
> incoming_nbytes
)
1069 chunk
= incoming_nbytes
;
1071 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1077 if (chunk
< incoming_nbytes
)
1079 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1081 incoming_nbytes
- chunk
);
1083 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1086 /* Do this before moving and increasing the gap,
1087 because the before-change hooks might move the gap
1088 or make it smaller. */
1089 prepare_to_modify_buffer (PT
, PT
, NULL
);
1092 move_gap_both (PT
, PT_BYTE
);
1093 if (GAP_SIZE
< outgoing_nbytes
)
1094 make_gap (outgoing_nbytes
- GAP_SIZE
);
1096 if (from
< BUF_GPT (buf
))
1098 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1099 if (chunk
> incoming_nbytes
)
1100 chunk
= incoming_nbytes
;
1101 /* Record number of output bytes, so we know where
1102 to put the output from the second copy_text. */
1104 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1106 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1107 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1110 chunk_expanded
= chunk
= 0;
1112 if (chunk
< incoming_nbytes
)
1113 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1114 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1115 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1116 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1118 #ifdef BYTE_COMBINING_DEBUG
1119 /* We have copied text into the gap, but we have not altered
1120 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1121 to these functions and get the same results as we would
1122 have got earlier on. Meanwhile, GPT_ADDR does point to
1123 the text that has been stored by copy_text. */
1124 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1125 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1129 record_insert (PT
, nchars
);
1131 CHARS_MODIFF
= MODIFF
;
1133 GAP_SIZE
-= outgoing_nbytes
;
1137 GPT_BYTE
+= outgoing_nbytes
;
1138 ZV_BYTE
+= outgoing_nbytes
;
1139 Z_BYTE
+= outgoing_nbytes
;
1140 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1142 eassert (GPT
<= GPT_BYTE
);
1144 /* The insert may have been in the unchanged region, so check again. */
1145 if (Z
- GPT
< END_UNCHANGED
)
1146 END_UNCHANGED
= Z
- GPT
;
1148 adjust_overlays_for_insert (PT
, nchars
);
1149 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1150 PT_BYTE
+ outgoing_nbytes
,
1153 offset_intervals (current_buffer
, PT
, nchars
);
1155 /* Get the intervals for the part of the string we are inserting. */
1156 intervals
= buffer_intervals (buf
);
1157 if (nchars
< BUF_Z (buf
) - BUF_BEG (buf
))
1159 if (buf
== current_buffer
&& PT
<= from
)
1161 intervals
= copy_intervals (intervals
, from
, nchars
);
1164 /* Insert those intervals. */
1165 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1167 adjust_point (nchars
, outgoing_nbytes
);
1170 /* Record undo information and adjust markers and position keepers for
1171 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1172 chars (LEN_BYTE bytes) which resides in the gap just after
1175 PREV_TEXT nil means the new text was just inserted. */
1178 adjust_after_replace (ptrdiff_t from
, ptrdiff_t from_byte
,
1179 Lisp_Object prev_text
, ptrdiff_t len
, ptrdiff_t len_byte
)
1181 ptrdiff_t nchars_del
= 0, nbytes_del
= 0;
1183 #ifdef BYTE_COMBINING_DEBUG
1184 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1185 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1189 if (STRINGP (prev_text
))
1191 nchars_del
= SCHARS (prev_text
);
1192 nbytes_del
= SBYTES (prev_text
);
1195 /* Update various buffer positions for the new text. */
1196 GAP_SIZE
-= len_byte
;
1198 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1199 GPT
+= len
; GPT_BYTE
+= len_byte
;
1200 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1203 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1206 adjust_markers_for_insert (from
, from_byte
,
1207 from
+ len
, from_byte
+ len_byte
, 0);
1209 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1212 record_delete (from
, prev_text
);
1213 record_insert (from
, len
);
1216 if (len
> nchars_del
)
1217 adjust_overlays_for_insert (from
, len
- nchars_del
);
1218 else if (len
< nchars_del
)
1219 adjust_overlays_for_delete (from
, nchars_del
- len
);
1221 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1224 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1226 /* As byte combining will decrease Z, we must check this again. */
1227 if (Z
- GPT
< END_UNCHANGED
)
1228 END_UNCHANGED
= Z
- GPT
;
1233 evaporate_overlays (from
);
1235 CHARS_MODIFF
= MODIFF
;
1238 /* Record undo information, adjust markers and position keepers for an
1239 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1240 text already exists in the current buffer but character length (TO
1241 - FROM) may be incorrect, the correct length is NEWLEN. */
1244 adjust_after_insert (ptrdiff_t from
, ptrdiff_t from_byte
,
1245 ptrdiff_t to
, ptrdiff_t to_byte
, ptrdiff_t newlen
)
1247 ptrdiff_t len
= to
- from
, len_byte
= to_byte
- from_byte
;
1250 move_gap_both (to
, to_byte
);
1251 GAP_SIZE
+= len_byte
;
1252 GPT
-= len
; GPT_BYTE
-= len_byte
;
1253 ZV
-= len
; ZV_BYTE
-= len_byte
;
1254 Z
-= len
; Z_BYTE
-= len_byte
;
1255 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1258 /* Replace the text from character positions FROM to TO with NEW,
1259 If PREPARE, call prepare_to_modify_buffer.
1260 If INHERIT, the newly inserted text should inherit text properties
1261 from the surrounding non-deleted text. */
1263 /* Note that this does not yet handle markers quite right.
1264 Also it needs to record a single undo-entry that does a replacement
1265 rather than a separate delete and insert.
1266 That way, undo will also handle markers properly.
1268 But if MARKERS is 0, don't relocate markers. */
1271 replace_range (ptrdiff_t from
, ptrdiff_t to
, Lisp_Object
new,
1272 bool prepare
, bool inherit
, bool markers
)
1274 ptrdiff_t inschars
= SCHARS (new);
1275 ptrdiff_t insbytes
= SBYTES (new);
1276 ptrdiff_t from_byte
, to_byte
;
1277 ptrdiff_t nbytes_del
, nchars_del
;
1278 struct gcpro gcpro1
;
1280 ptrdiff_t outgoing_insbytes
= insbytes
;
1281 Lisp_Object deletion
;
1290 ptrdiff_t range_length
= to
- from
;
1291 prepare_to_modify_buffer (from
, to
, &from
);
1292 to
= from
+ range_length
;
1297 /* Make args be valid. */
1303 from_byte
= CHAR_TO_BYTE (from
);
1304 to_byte
= CHAR_TO_BYTE (to
);
1306 nchars_del
= to
- from
;
1307 nbytes_del
= to_byte
- from_byte
;
1309 if (nbytes_del
<= 0 && insbytes
== 0)
1312 /* Make OUTGOING_INSBYTES describe the text
1313 as it will be inserted in this buffer. */
1315 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1316 outgoing_insbytes
= inschars
;
1317 else if (! STRING_MULTIBYTE (new))
1319 = count_size_as_multibyte (SDATA (new), insbytes
);
1323 /* Make sure the gap is somewhere in or next to what we are deleting. */
1325 gap_right (from
, from_byte
);
1327 gap_left (to
, to_byte
, 0);
1329 /* Even if we don't record for undo, we must keep the original text
1330 because we may have to recover it because of inappropriate byte
1332 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1333 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1335 GAP_SIZE
+= nbytes_del
;
1338 ZV_BYTE
-= nbytes_del
;
1339 Z_BYTE
-= nbytes_del
;
1341 GPT_BYTE
= from_byte
;
1342 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1344 eassert (GPT
<= GPT_BYTE
);
1346 if (GPT
- BEG
< BEG_UNCHANGED
)
1347 BEG_UNCHANGED
= GPT
- BEG
;
1348 if (Z
- GPT
< END_UNCHANGED
)
1349 END_UNCHANGED
= Z
- GPT
;
1351 if (GAP_SIZE
< outgoing_insbytes
)
1352 make_gap (outgoing_insbytes
- GAP_SIZE
);
1354 /* Copy the string text into the buffer, perhaps converting
1355 between single-byte and multibyte. */
1356 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1357 STRING_MULTIBYTE (new),
1358 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1360 #ifdef BYTE_COMBINING_DEBUG
1361 /* We have copied text into the gap, but we have not marked
1362 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1363 here, for both the previous text and the following text.
1364 Meanwhile, GPT_ADDR does point to
1365 the text that has been stored by copy_text. */
1366 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1367 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1371 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1373 /* Record the insertion first, so that when we undo,
1374 the deletion will be undone first. Thus, undo
1375 will insert before deleting, and thus will keep
1376 the markers before and after this text separate. */
1377 record_insert (from
+ SCHARS (deletion
), inschars
);
1378 record_delete (from
, deletion
);
1381 GAP_SIZE
-= outgoing_insbytes
;
1385 GPT_BYTE
+= outgoing_insbytes
;
1386 ZV_BYTE
+= outgoing_insbytes
;
1387 Z_BYTE
+= outgoing_insbytes
;
1388 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1390 eassert (GPT
<= GPT_BYTE
);
1392 /* Adjust markers for the deletion and the insertion. */
1394 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1395 inschars
, outgoing_insbytes
);
1397 /* Adjust the overlay center as needed. This must be done after
1398 adjusting the markers that bound the overlays. */
1399 adjust_overlays_for_delete (from
, nchars_del
);
1400 adjust_overlays_for_insert (from
, inschars
);
1402 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1404 /* Get the intervals for the part of the string we are inserting--
1405 not including the combined-before bytes. */
1406 intervals
= string_intervals (new);
1407 /* Insert those intervals. */
1408 graft_intervals_into_buffer (intervals
, from
, inschars
,
1409 current_buffer
, inherit
);
1411 /* Relocate point as if it were a marker. */
1413 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1414 (from_byte
+ outgoing_insbytes
1415 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1417 if (outgoing_insbytes
== 0)
1418 evaporate_overlays (from
);
1423 CHARS_MODIFF
= MODIFF
;
1426 signal_after_change (from
, nchars_del
, GPT
- from
);
1427 update_compositions (from
, GPT
, CHECK_BORDER
);
1430 /* Replace the text from character positions FROM to TO with
1431 the text in INS of length INSCHARS.
1432 Keep the text properties that applied to the old characters
1433 (extending them to all the new chars if there are more new chars).
1435 Note that this does not yet handle markers quite right.
1437 If MARKERS, relocate markers.
1439 Unlike most functions at this level, never call
1440 prepare_to_modify_buffer and never call signal_after_change. */
1443 replace_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1444 ptrdiff_t to
, ptrdiff_t to_byte
,
1445 const char *ins
, ptrdiff_t inschars
, ptrdiff_t insbytes
,
1448 ptrdiff_t nbytes_del
, nchars_del
;
1452 nchars_del
= to
- from
;
1453 nbytes_del
= to_byte
- from_byte
;
1455 if (nbytes_del
<= 0 && insbytes
== 0)
1458 /* Make sure the gap is somewhere in or next to what we are deleting. */
1460 gap_right (from
, from_byte
);
1462 gap_left (to
, to_byte
, 0);
1464 GAP_SIZE
+= nbytes_del
;
1467 ZV_BYTE
-= nbytes_del
;
1468 Z_BYTE
-= nbytes_del
;
1470 GPT_BYTE
= from_byte
;
1471 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1473 eassert (GPT
<= GPT_BYTE
);
1475 if (GPT
- BEG
< BEG_UNCHANGED
)
1476 BEG_UNCHANGED
= GPT
- BEG
;
1477 if (Z
- GPT
< END_UNCHANGED
)
1478 END_UNCHANGED
= Z
- GPT
;
1480 if (GAP_SIZE
< insbytes
)
1481 make_gap (insbytes
- GAP_SIZE
);
1483 /* Copy the replacement text into the buffer. */
1484 memcpy (GPT_ADDR
, ins
, insbytes
);
1486 #ifdef BYTE_COMBINING_DEBUG
1487 /* We have copied text into the gap, but we have not marked
1488 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1489 here, for both the previous text and the following text.
1490 Meanwhile, GPT_ADDR does point to
1491 the text that has been stored by copy_text. */
1492 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1493 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1497 GAP_SIZE
-= insbytes
;
1501 GPT_BYTE
+= insbytes
;
1502 ZV_BYTE
+= insbytes
;
1504 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1506 eassert (GPT
<= GPT_BYTE
);
1508 /* Adjust markers for the deletion and the insertion. */
1510 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1511 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1512 inschars
, insbytes
);
1514 /* Adjust the overlay center as needed. This must be done after
1515 adjusting the markers that bound the overlays. */
1516 if (nchars_del
!= inschars
)
1518 adjust_overlays_for_insert (from
, inschars
);
1519 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1522 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1524 /* Relocate point as if it were a marker. */
1525 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1528 /* PT was within the deleted text. Move it to FROM. */
1529 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1531 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1535 evaporate_overlays (from
);
1540 CHARS_MODIFF
= MODIFF
;
1543 /* Delete characters in current buffer
1544 from FROM up to (but not including) TO.
1545 If TO comes before FROM, we delete nothing. */
1548 del_range (ptrdiff_t from
, ptrdiff_t to
)
1550 del_range_1 (from
, to
, 1, 0);
1553 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1554 RET_STRING says to return the deleted text. */
1557 del_range_1 (ptrdiff_t from
, ptrdiff_t to
, bool prepare
, bool ret_string
)
1559 ptrdiff_t from_byte
, to_byte
;
1560 Lisp_Object deletion
;
1561 struct gcpro gcpro1
;
1563 /* Make args be valid */
1574 ptrdiff_t range_length
= to
- from
;
1575 prepare_to_modify_buffer (from
, to
, &from
);
1576 to
= min (ZV
, from
+ range_length
);
1579 from_byte
= CHAR_TO_BYTE (from
);
1580 to_byte
= CHAR_TO_BYTE (to
);
1582 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1584 signal_after_change (from
, to
- from
, 0);
1585 update_compositions (from
, from
, CHECK_HEAD
);
1590 /* Like del_range_1 but args are byte positions, not char positions. */
1593 del_range_byte (ptrdiff_t from_byte
, ptrdiff_t to_byte
, bool prepare
)
1597 /* Make args be valid */
1598 if (from_byte
< BEGV_BYTE
)
1599 from_byte
= BEGV_BYTE
;
1600 if (to_byte
> ZV_BYTE
)
1603 if (to_byte
<= from_byte
)
1606 from
= BYTE_TO_CHAR (from_byte
);
1607 to
= BYTE_TO_CHAR (to_byte
);
1611 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1612 ptrdiff_t range_length
= to
- from
;
1613 prepare_to_modify_buffer (from
, to
, &from
);
1614 to
= from
+ range_length
;
1616 if (old_from
!= from
)
1617 from_byte
= CHAR_TO_BYTE (from
);
1623 else if (old_to
== Z
- to
)
1624 to_byte
= CHAR_TO_BYTE (to
);
1627 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1628 signal_after_change (from
, to
- from
, 0);
1629 update_compositions (from
, from
, CHECK_HEAD
);
1632 /* Like del_range_1, but positions are specified both as charpos
1636 del_range_both (ptrdiff_t from
, ptrdiff_t from_byte
,
1637 ptrdiff_t to
, ptrdiff_t to_byte
, bool prepare
)
1639 /* Make args be valid */
1640 if (from_byte
< BEGV_BYTE
)
1641 from_byte
= BEGV_BYTE
;
1642 if (to_byte
> ZV_BYTE
)
1645 if (to_byte
<= from_byte
)
1655 ptrdiff_t old_from
= from
, old_to
= Z
- to
;
1656 ptrdiff_t range_length
= to
- from
;
1657 prepare_to_modify_buffer (from
, to
, &from
);
1658 to
= from
+ range_length
;
1660 if (old_from
!= from
)
1661 from_byte
= CHAR_TO_BYTE (from
);
1667 else if (old_to
== Z
- to
)
1668 to_byte
= CHAR_TO_BYTE (to
);
1671 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1672 signal_after_change (from
, to
- from
, 0);
1673 update_compositions (from
, from
, CHECK_HEAD
);
1676 /* Delete a range of text, specified both as character positions
1677 and byte positions. FROM and TO are character positions,
1678 while FROM_BYTE and TO_BYTE are byte positions.
1679 If RET_STRING, the deleted area is returned as a string. */
1682 del_range_2 (ptrdiff_t from
, ptrdiff_t from_byte
,
1683 ptrdiff_t to
, ptrdiff_t to_byte
, bool ret_string
)
1685 ptrdiff_t nbytes_del
, nchars_del
;
1686 Lisp_Object deletion
;
1690 nchars_del
= to
- from
;
1691 nbytes_del
= to_byte
- from_byte
;
1693 /* Make sure the gap is somewhere in or next to what we are deleting. */
1695 gap_right (from
, from_byte
);
1697 gap_left (to
, to_byte
, 0);
1699 #ifdef BYTE_COMBINING_DEBUG
1700 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1701 Z_BYTE
- to_byte
, from
, from_byte
))
1705 if (ret_string
|| ! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1706 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1710 /* Relocate all markers pointing into the new, larger gap
1711 to point at the end of the text before the gap.
1712 Do this before recording the deletion,
1713 so that undo handles this after reinserting the text. */
1714 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1716 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1717 record_delete (from
, deletion
);
1719 CHARS_MODIFF
= MODIFF
;
1721 /* Relocate point as if it were a marker. */
1723 adjust_point (from
- (PT
< to
? PT
: to
),
1724 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1726 offset_intervals (current_buffer
, from
, - nchars_del
);
1728 /* Adjust the overlay center as needed. This must be done after
1729 adjusting the markers that bound the overlays. */
1730 adjust_overlays_for_delete (from
, nchars_del
);
1732 GAP_SIZE
+= nbytes_del
;
1733 ZV_BYTE
-= nbytes_del
;
1734 Z_BYTE
-= nbytes_del
;
1738 GPT_BYTE
= from_byte
;
1739 if (GAP_SIZE
> 0 && !current_buffer
->text
->inhibit_shrinking
)
1740 /* Put an anchor, unless called from decode_coding_object which
1741 needs to access the previous gap contents. */
1744 eassert (GPT
<= GPT_BYTE
);
1746 if (GPT
- BEG
< BEG_UNCHANGED
)
1747 BEG_UNCHANGED
= GPT
- BEG
;
1748 if (Z
- GPT
< END_UNCHANGED
)
1749 END_UNCHANGED
= Z
- GPT
;
1753 evaporate_overlays (from
);
1758 /* Call this if you're about to change the region of current buffer
1759 from character positions START to END. This checks the read-only
1760 properties of the region, calls the necessary modification hooks,
1761 and warns the next redisplay that it should pay attention to that
1764 If PRESERVE_CHARS_MODIFF, do not update CHARS_MODIFF.
1765 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
1768 modify_region_1 (ptrdiff_t start
, ptrdiff_t end
, bool preserve_chars_modiff
)
1770 prepare_to_modify_buffer (start
, end
, NULL
);
1772 BUF_COMPUTE_UNCHANGED (current_buffer
, start
- 1, end
);
1774 if (MODIFF
<= SAVE_MODIFF
)
1775 record_first_change ();
1777 if (! preserve_chars_modiff
)
1778 CHARS_MODIFF
= MODIFF
;
1780 bset_point_before_scroll (current_buffer
, Qnil
);
1783 /* Check that it is okay to modify the buffer between START and END,
1784 which are char positions.
1786 Run the before-change-function, if any. If intervals are in use,
1787 verify that the text to be modified is not read-only, and call
1788 any modification properties the text may have.
1790 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1791 by holding its value temporarily in a marker. */
1794 prepare_to_modify_buffer (ptrdiff_t start
, ptrdiff_t end
,
1795 ptrdiff_t *preserve_ptr
)
1797 struct buffer
*base_buffer
;
1799 if (!NILP (BVAR (current_buffer
, read_only
)))
1800 Fbarf_if_buffer_read_only ();
1802 /* If we're modifying the buffer other than shown in a selected window,
1803 let redisplay consider other windows if this buffer is visible. */
1804 if (XBUFFER (XWINDOW (selected_window
)->contents
) != current_buffer
1805 && buffer_window_count (current_buffer
))
1806 ++windows_or_buffers_changed
;
1808 if (buffer_intervals (current_buffer
))
1812 Lisp_Object preserve_marker
;
1813 struct gcpro gcpro1
;
1814 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1815 GCPRO1 (preserve_marker
);
1816 verify_interval_modification (current_buffer
, start
, end
);
1817 *preserve_ptr
= marker_position (preserve_marker
);
1818 unchain_marker (XMARKER (preserve_marker
));
1822 verify_interval_modification (current_buffer
, start
, end
);
1825 /* For indirect buffers, use the base buffer to check clashes. */
1826 if (current_buffer
->base_buffer
!= 0)
1827 base_buffer
= current_buffer
->base_buffer
;
1829 base_buffer
= current_buffer
;
1831 #ifdef CLASH_DETECTION
1832 if (!NILP (BVAR (base_buffer
, file_truename
))
1833 /* Make binding buffer-file-name to nil effective. */
1834 && !NILP (BVAR (base_buffer
, filename
))
1835 && SAVE_MODIFF
>= MODIFF
)
1836 lock_file (BVAR (base_buffer
, file_truename
));
1838 /* At least warn if this file has changed on disk since it was visited. */
1839 if (!NILP (BVAR (base_buffer
, filename
))
1840 && SAVE_MODIFF
>= MODIFF
1841 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1842 && !NILP (Ffile_exists_p (BVAR (base_buffer
, filename
))))
1843 call1 (intern ("ask-user-about-supersession-threat"),
1844 BVAR (base_buffer
,filename
));
1845 #endif /* not CLASH_DETECTION */
1847 /* If `select-active-regions' is non-nil, save the region text. */
1848 if (!NILP (BVAR (current_buffer
, mark_active
))
1849 && !inhibit_modification_hooks
1850 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1851 && NILP (Vsaved_region_selection
)
1852 && (EQ (Vselect_active_regions
, Qonly
)
1853 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1854 : (!NILP (Vselect_active_regions
)
1855 && !NILP (Vtransient_mark_mode
))))
1857 ptrdiff_t b
= marker_position (BVAR (current_buffer
, mark
));
1860 Vsaved_region_selection
= make_buffer_string (b
, e
, 0);
1862 Vsaved_region_selection
= make_buffer_string (e
, b
, 0);
1865 signal_before_change (start
, end
, preserve_ptr
);
1867 if (current_buffer
->newline_cache
)
1868 invalidate_region_cache (current_buffer
,
1869 current_buffer
->newline_cache
,
1870 start
- BEG
, Z
- end
);
1871 if (current_buffer
->width_run_cache
)
1872 invalidate_region_cache (current_buffer
,
1873 current_buffer
->width_run_cache
,
1874 start
- BEG
, Z
- end
);
1876 Vdeactivate_mark
= Qt
;
1879 /* These macros work with an argument named `preserve_ptr'
1880 and a local variable named `preserve_marker'. */
1882 #define PRESERVE_VALUE \
1883 if (preserve_ptr && NILP (preserve_marker)) \
1884 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1886 #define RESTORE_VALUE \
1887 if (! NILP (preserve_marker)) \
1889 *preserve_ptr = marker_position (preserve_marker); \
1890 unchain_marker (XMARKER (preserve_marker)); \
1893 #define PRESERVE_START_END \
1894 if (NILP (start_marker)) \
1895 start_marker = Fcopy_marker (start, Qnil); \
1896 if (NILP (end_marker)) \
1897 end_marker = Fcopy_marker (end, Qnil);
1899 #define FETCH_START \
1900 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1903 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1905 /* Set a variable to nil if an error occurred.
1906 Don't change the variable if there was no error.
1907 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
1908 VARIABLE is the variable to maybe set to nil.
1909 NO-ERROR-FLAG is nil if there was an error,
1910 anything else meaning no error (so this function does nothing). */
1912 reset_var_on_error (Lisp_Object val
)
1914 if (NILP (XCDR (val
)))
1915 Fset (XCAR (val
), Qnil
);
1919 /* Signal a change to the buffer immediately before it happens.
1920 START_INT and END_INT are the bounds of the text to be changed.
1922 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1923 by holding its value temporarily in a marker. */
1926 signal_before_change (ptrdiff_t start_int
, ptrdiff_t end_int
,
1927 ptrdiff_t *preserve_ptr
)
1929 Lisp_Object start
, end
;
1930 Lisp_Object start_marker
, end_marker
;
1931 Lisp_Object preserve_marker
;
1932 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1933 ptrdiff_t count
= SPECPDL_INDEX ();
1935 if (inhibit_modification_hooks
)
1938 start
= make_number (start_int
);
1939 end
= make_number (end_int
);
1940 preserve_marker
= Qnil
;
1941 start_marker
= Qnil
;
1943 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1945 specbind (Qinhibit_modification_hooks
, Qt
);
1947 /* If buffer is unmodified, run a special hook for that case. The
1948 check for Vfirst_change_hook is just a minor optimization. */
1949 if (SAVE_MODIFF
>= MODIFF
1950 && !NILP (Vfirst_change_hook
))
1954 Frun_hooks (1, &Qfirst_change_hook
);
1957 /* Now run the before-change-functions if any. */
1958 if (!NILP (Vbefore_change_functions
))
1960 Lisp_Object args
[3];
1961 Lisp_Object rvoe_arg
= Fcons (Qbefore_change_functions
, Qnil
);
1966 /* Mark before-change-functions to be reset to nil in case of error. */
1967 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
1969 /* Actually run the hook functions. */
1970 args
[0] = Qbefore_change_functions
;
1971 args
[1] = FETCH_START
;
1972 args
[2] = FETCH_END
;
1973 Frun_hook_with_args (3, args
);
1975 /* There was no error: unarm the reset_on_error. */
1976 XSETCDR (rvoe_arg
, Qt
);
1979 if (buffer_has_overlays ())
1982 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1983 FETCH_START
, FETCH_END
, Qnil
);
1986 if (! NILP (start_marker
))
1987 free_marker (start_marker
);
1988 if (! NILP (end_marker
))
1989 free_marker (end_marker
);
1993 unbind_to (count
, Qnil
);
1996 /* Signal a change immediately after it happens.
1997 CHARPOS is the character position of the start of the changed text.
1998 LENDEL is the number of characters of the text before the change.
1999 (Not the whole buffer; just the part that was changed.)
2000 LENINS is the number of characters in that part of the text
2001 after the change. */
2004 signal_after_change (ptrdiff_t charpos
, ptrdiff_t lendel
, ptrdiff_t lenins
)
2006 ptrdiff_t count
= SPECPDL_INDEX ();
2007 if (inhibit_modification_hooks
)
2010 /* If we are deferring calls to the after-change functions
2011 and there are no before-change functions,
2012 just record the args that we were going to use. */
2013 if (! NILP (Vcombine_after_change_calls
)
2014 && NILP (Vbefore_change_functions
)
2015 && !buffer_has_overlays ())
2019 if (!NILP (combine_after_change_list
)
2020 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2021 Fcombine_after_change_execute ();
2023 elt
= list3i (charpos
- BEG
, Z
- (charpos
- lendel
+ lenins
),
2025 combine_after_change_list
2026 = Fcons (elt
, combine_after_change_list
);
2027 combine_after_change_buffer
= Fcurrent_buffer ();
2032 if (!NILP (combine_after_change_list
))
2033 Fcombine_after_change_execute ();
2035 specbind (Qinhibit_modification_hooks
, Qt
);
2037 if (!NILP (Vafter_change_functions
))
2039 Lisp_Object args
[4];
2040 Lisp_Object rvoe_arg
= Fcons (Qafter_change_functions
, Qnil
);
2042 /* Mark after-change-functions to be reset to nil in case of error. */
2043 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2045 /* Actually run the hook functions. */
2046 args
[0] = Qafter_change_functions
;
2047 XSETFASTINT (args
[1], charpos
);
2048 XSETFASTINT (args
[2], charpos
+ lenins
);
2049 XSETFASTINT (args
[3], lendel
);
2050 Frun_hook_with_args (4, args
);
2052 /* There was no error: unarm the reset_on_error. */
2053 XSETCDR (rvoe_arg
, Qt
);
2056 if (buffer_has_overlays ())
2057 report_overlay_modification (make_number (charpos
),
2058 make_number (charpos
+ lenins
),
2060 make_number (charpos
),
2061 make_number (charpos
+ lenins
),
2062 make_number (lendel
));
2064 /* After an insertion, call the text properties
2065 insert-behind-hooks or insert-in-front-hooks. */
2067 report_interval_modification (make_number (charpos
),
2068 make_number (charpos
+ lenins
));
2070 unbind_to (count
, Qnil
);
2074 Fcombine_after_change_execute_1 (Lisp_Object val
)
2076 Vcombine_after_change_calls
= val
;
2080 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2081 Scombine_after_change_execute
, 0, 0, 0,
2082 doc
: /* This function is for use internally in the function `combine-after-change-calls'. */)
2085 ptrdiff_t count
= SPECPDL_INDEX ();
2086 ptrdiff_t beg
, end
, change
;
2087 ptrdiff_t begpos
, endpos
;
2090 if (NILP (combine_after_change_list
))
2093 /* It is rare for combine_after_change_buffer to be invalid, but
2094 possible. It can happen when combine-after-change-calls is
2095 non-nil, and insertion calls a file handler (e.g. through
2096 lock_file) which scribbles into a temp file -- cyd */
2097 if (!BUFFERP (combine_after_change_buffer
)
2098 || !BUFFER_LIVE_P (XBUFFER (combine_after_change_buffer
)))
2100 combine_after_change_list
= Qnil
;
2104 record_unwind_current_buffer ();
2106 Fset_buffer (combine_after_change_buffer
);
2108 /* # chars unchanged at beginning of buffer. */
2110 /* # chars unchanged at end of buffer. */
2112 /* Total amount of insertion (negative for deletion). */
2115 /* Scan the various individual changes,
2116 accumulating the range info in BEG, END and CHANGE. */
2117 for (tail
= combine_after_change_list
; CONSP (tail
);
2121 ptrdiff_t thisbeg
, thisend
, thischange
;
2123 /* Extract the info from the next element. */
2127 thisbeg
= XINT (XCAR (elt
));
2132 thisend
= XINT (XCAR (elt
));
2137 thischange
= XINT (XCAR (elt
));
2139 /* Merge this range into the accumulated range. */
2140 change
+= thischange
;
2147 /* Get the current start and end positions of the range
2148 that was changed. */
2152 /* We are about to handle these, so discard them. */
2153 combine_after_change_list
= Qnil
;
2155 /* Now run the after-change functions for real.
2156 Turn off the flag that defers them. */
2157 record_unwind_protect (Fcombine_after_change_execute_1
,
2158 Vcombine_after_change_calls
);
2159 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2160 update_compositions (begpos
, endpos
, CHECK_ALL
);
2162 return unbind_to (count
, Qnil
);
2166 syms_of_insdel (void)
2168 staticpro (&combine_after_change_list
);
2169 staticpro (&combine_after_change_buffer
);
2170 combine_after_change_list
= Qnil
;
2171 combine_after_change_buffer
= Qnil
;
2173 DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls
,
2174 doc
: /* Used internally by the function `combine-after-change-calls' macro. */);
2175 Vcombine_after_change_calls
= Qnil
;
2177 DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks
,
2178 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2179 This affects `before-change-functions' and `after-change-functions',
2180 as well as hooks attached to text properties and overlays. */);
2181 inhibit_modification_hooks
= 0;
2182 DEFSYM (Qinhibit_modification_hooks
, "inhibit-modification-hooks");
2184 defsubr (&Scombine_after_change_execute
);