1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985-1986, 1993-1995, 1997-2011
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
27 #include "intervals.h"
29 #include "character.h"
31 #include "blockinput.h"
32 #include "region-cache.h"
38 static void insert_from_string_1 (Lisp_Object string
,
39 EMACS_INT pos
, EMACS_INT pos_byte
,
40 EMACS_INT nchars
, EMACS_INT nbytes
,
41 int inherit
, int before_markers
);
42 static void insert_from_buffer_1 (struct buffer
*buf
,
43 EMACS_INT from
, EMACS_INT nchars
,
45 static void gap_left (EMACS_INT charpos
, EMACS_INT bytepos
, int newgap
);
46 static void gap_right (EMACS_INT charpos
, EMACS_INT bytepos
);
47 static void adjust_markers_for_insert (EMACS_INT from
, EMACS_INT from_byte
,
48 EMACS_INT to
, EMACS_INT to_byte
,
50 static void adjust_markers_for_replace (EMACS_INT
, EMACS_INT
, EMACS_INT
,
51 EMACS_INT
, EMACS_INT
, EMACS_INT
);
52 static void adjust_point (EMACS_INT nchars
, EMACS_INT nbytes
);
54 static Lisp_Object
Fcombine_after_change_execute (void);
56 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
57 describing changes which happened while combine_after_change_calls
58 was nonzero. We use this to decide how to call them
59 once the deferral ends.
62 BEG-UNCHANGED is the number of chars before the changed range.
63 END-UNCHANGED is the number of chars after the changed range,
64 and CHANGE-AMOUNT is the number of characters inserted by the change
65 (negative for a deletion). */
66 static Lisp_Object combine_after_change_list
;
68 /* Buffer which combine_after_change_list is about. */
69 static Lisp_Object combine_after_change_buffer
;
71 Lisp_Object Qinhibit_modification_hooks
;
73 static void signal_before_change (EMACS_INT
, EMACS_INT
, EMACS_INT
*);
75 #define CHECK_MARKERS() \
78 if (check_markers_debug_flag) \
86 register struct Lisp_Marker
*tail
;
87 int multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
89 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
91 if (tail
->buffer
->text
!= current_buffer
->text
)
93 if (tail
->charpos
> Z
)
95 if (tail
->bytepos
> Z_BYTE
)
97 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
102 /* Move gap to position CHARPOS.
103 Note that this can quit! */
106 move_gap (EMACS_INT charpos
)
108 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
111 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
112 Note that this can quit! */
115 move_gap_both (EMACS_INT charpos
, EMACS_INT bytepos
)
117 if (bytepos
< GPT_BYTE
)
118 gap_left (charpos
, bytepos
, 0);
119 else if (bytepos
> GPT_BYTE
)
120 gap_right (charpos
, bytepos
);
123 /* Move the gap to a position less than the current GPT.
124 BYTEPOS describes the new position as a byte position,
125 and CHARPOS is the corresponding char position.
126 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
129 gap_left (EMACS_INT charpos
, EMACS_INT bytepos
, int newgap
)
131 register unsigned char *to
, *from
;
132 register EMACS_INT i
;
136 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
143 /* Now copy the characters. To move the gap down,
144 copy characters up. */
148 /* I gets number of characters left to copy. */
149 i
= new_s1
- bytepos
;
152 /* If a quit is requested, stop copying now.
153 Change BYTEPOS to be where we have actually moved the gap to. */
157 charpos
= BYTE_TO_CHAR (bytepos
);
160 /* Move at most 32000 chars before checking again for a quit. */
165 memmove (to
, from
, i
);
168 /* Adjust buffer data structure, to put the gap at BYTEPOS.
169 BYTEPOS is where the loop above stopped, which may be what
170 was specified or may be where a quit was detected. */
173 if (bytepos
< charpos
)
175 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
179 /* Move the gap to a position greater than the current GPT.
180 BYTEPOS describes the new position as a byte position,
181 and CHARPOS is the corresponding char position. */
184 gap_right (EMACS_INT charpos
, EMACS_INT bytepos
)
186 register unsigned char *to
, *from
;
187 register EMACS_INT i
;
190 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
197 /* Now copy the characters. To move the gap up,
198 copy characters down. */
202 /* I gets number of characters left to copy. */
203 i
= bytepos
- new_s1
;
206 /* If a quit is requested, stop copying now.
207 Change BYTEPOS to be where we have actually moved the gap to. */
211 charpos
= BYTE_TO_CHAR (bytepos
);
214 /* Move at most 32000 chars before checking again for a quit. */
218 memmove (to
, from
, i
);
224 if (bytepos
< charpos
)
226 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
230 /* Adjust all markers for a deletion
231 whose range in bytes is FROM_BYTE to TO_BYTE.
232 The range in charpos is FROM to TO.
234 This function assumes that the gap is adjacent to
235 or inside of the range being deleted. */
238 adjust_markers_for_delete (EMACS_INT from
, EMACS_INT from_byte
,
239 EMACS_INT to
, EMACS_INT to_byte
)
242 register struct Lisp_Marker
*m
;
243 register EMACS_INT charpos
;
245 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
247 charpos
= m
->charpos
;
252 /* If the marker is after the deletion,
253 relocate by number of chars / bytes deleted. */
256 m
->charpos
-= to
- from
;
257 m
->bytepos
-= to_byte
- from_byte
;
259 /* Here's the case where a marker is inside text being deleted. */
260 else if (charpos
> from
)
262 if (! m
->insertion_type
)
263 { /* Normal markers will end up at the beginning of the
264 re-inserted text after undoing a deletion, and must be
265 adjusted to move them to the correct place. */
266 XSETMISC (marker
, m
);
267 record_marker_adjustment (marker
, from
- charpos
);
269 else if (charpos
< to
)
270 { /* Before-insertion markers will automatically move forward
271 upon re-inserting the deleted text, so we have to arrange
272 for them to move backward to the correct position. */
273 XSETMISC (marker
, m
);
274 record_marker_adjustment (marker
, to
- charpos
);
277 m
->bytepos
= from_byte
;
279 /* Here's the case where a before-insertion marker is immediately
280 before the deleted region. */
281 else if (charpos
== from
&& m
->insertion_type
)
283 /* Undoing the change uses normal insertion, which will
284 incorrectly make MARKER move forward, so we arrange for it
285 to then move backward to the correct place at the beginning
286 of the deleted region. */
287 XSETMISC (marker
, m
);
288 record_marker_adjustment (marker
, to
- from
);
294 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
295 to TO / TO_BYTE. We have to relocate the charpos of every marker
296 that points after the insertion (but not their bytepos).
298 When a marker points at the insertion point,
299 we advance it if either its insertion-type is t
300 or BEFORE_MARKERS is true. */
303 adjust_markers_for_insert (EMACS_INT from
, EMACS_INT from_byte
,
304 EMACS_INT to
, EMACS_INT to_byte
, int before_markers
)
306 struct Lisp_Marker
*m
;
308 EMACS_INT nchars
= to
- from
;
309 EMACS_INT nbytes
= to_byte
- from_byte
;
311 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
313 eassert (m
->bytepos
>= m
->charpos
314 && m
->bytepos
- m
->charpos
<= Z_BYTE
- Z
);
316 if (m
->bytepos
== from_byte
)
318 if (m
->insertion_type
|| before_markers
)
320 m
->bytepos
= to_byte
;
322 if (m
->insertion_type
)
326 else if (m
->bytepos
> from_byte
)
328 m
->bytepos
+= nbytes
;
329 m
->charpos
+= nchars
;
333 /* Adjusting only markers whose insertion-type is t may result in
334 - disordered start and end in overlays, and
335 - disordered overlays in the slot `overlays_before' of current_buffer. */
338 fix_start_end_in_overlays(from
, to
);
339 fix_overlays_before (current_buffer
, from
, to
);
343 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
345 This is used only when the value of point changes due to an insert
346 or delete; it does not represent a conceptual change in point as a
347 marker. In particular, point is not crossing any interval
348 boundaries, so there's no need to use the usual SET_PT macro. In
349 fact it would be incorrect to do so, because either the old or the
350 new value of point is out of sync with the current set of
354 adjust_point (EMACS_INT nchars
, EMACS_INT nbytes
)
356 SET_BUF_PT_BOTH (current_buffer
, PT
+ nchars
, PT_BYTE
+ nbytes
);
357 /* In a single-byte buffer, the two positions must be equal. */
358 eassert (PT_BYTE
>= PT
&& PT_BYTE
- PT
<= ZV_BYTE
- ZV
);
361 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
362 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
363 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
367 adjust_markers_for_replace (EMACS_INT from
, EMACS_INT from_byte
,
368 EMACS_INT old_chars
, EMACS_INT old_bytes
,
369 EMACS_INT new_chars
, EMACS_INT new_bytes
)
371 register struct Lisp_Marker
*m
;
372 EMACS_INT prev_to_byte
= from_byte
+ old_bytes
;
373 EMACS_INT diff_chars
= new_chars
- old_chars
;
374 EMACS_INT diff_bytes
= new_bytes
- old_bytes
;
376 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
378 if (m
->bytepos
>= prev_to_byte
)
380 m
->charpos
+= diff_chars
;
381 m
->bytepos
+= diff_bytes
;
383 else if (m
->bytepos
> from_byte
)
386 m
->bytepos
= from_byte
;
394 /* Make the gap NBYTES_ADDED bytes longer. */
397 make_gap_larger (EMACS_INT nbytes_added
)
400 EMACS_INT real_gap_loc
;
401 EMACS_INT real_gap_loc_byte
;
402 EMACS_INT old_gap_size
;
404 /* If we have to get more space, get enough to last a while. */
405 nbytes_added
+= 2000;
407 { EMACS_INT total_size
= Z_BYTE
- BEG_BYTE
+ GAP_SIZE
+ nbytes_added
;
409 /* Don't allow a buffer size that won't fit in a Lisp integer. */
410 || total_size
!= XINT (make_number (total_size
)))
411 error ("Buffer exceeds maximum size");
414 enlarge_buffer_text (current_buffer
, nbytes_added
);
416 /* Prevent quitting in move_gap. */
421 real_gap_loc_byte
= GPT_BYTE
;
422 old_gap_size
= GAP_SIZE
;
424 /* Call the newly allocated space a gap at the end of the whole space. */
426 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
427 GAP_SIZE
= nbytes_added
;
429 /* Move the new gap down to be consecutive with the end of the old one.
430 This adjusts the markers properly too. */
431 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
433 /* Now combine the two into one large gap. */
434 GAP_SIZE
+= old_gap_size
;
436 GPT_BYTE
= real_gap_loc_byte
;
444 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
446 /* Make the gap NBYTES_REMOVED bytes shorter. */
449 make_gap_smaller (EMACS_INT nbytes_removed
)
452 EMACS_INT real_gap_loc
;
453 EMACS_INT real_gap_loc_byte
;
455 EMACS_INT real_Z_byte
;
456 EMACS_INT real_beg_unchanged
;
457 EMACS_INT new_gap_size
;
459 /* Make sure the gap is at least 20 bytes. */
460 if (GAP_SIZE
- nbytes_removed
< 20)
461 nbytes_removed
= GAP_SIZE
- 20;
463 /* Prevent quitting in move_gap. */
468 real_gap_loc_byte
= GPT_BYTE
;
469 new_gap_size
= GAP_SIZE
- nbytes_removed
;
471 real_Z_byte
= Z_BYTE
;
472 real_beg_unchanged
= BEG_UNCHANGED
;
474 /* Pretend that the last unwanted part of the gap is the entire gap,
475 and that the first desired part of the gap is part of the buffer
477 memset (GPT_ADDR
, 0, new_gap_size
);
479 GPT_BYTE
+= new_gap_size
;
481 Z_BYTE
+= new_gap_size
;
482 GAP_SIZE
= nbytes_removed
;
484 /* Move the unwanted pretend gap to the end of the buffer. This
485 adjusts the markers properly too. */
486 gap_right (Z
, Z_BYTE
);
488 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
490 /* Now restore the desired gap. */
491 GAP_SIZE
= new_gap_size
;
493 GPT_BYTE
= real_gap_loc_byte
;
495 Z_BYTE
= real_Z_byte
;
496 BEG_UNCHANGED
= real_beg_unchanged
;
504 #endif /* USE_MMAP_FOR_BUFFERS || REL_ALLOC || DOUG_LEA_MALLOC */
507 make_gap (EMACS_INT nbytes_added
)
509 if (nbytes_added
>= 0)
510 make_gap_larger (nbytes_added
);
511 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
513 make_gap_smaller (-nbytes_added
);
517 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
518 FROM_MULTIBYTE says whether the incoming text is multibyte.
519 TO_MULTIBYTE says whether to store the text as multibyte.
520 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
522 Return the number of bytes stored at TO_ADDR. */
525 copy_text (const unsigned char *from_addr
, unsigned char *to_addr
,
526 EMACS_INT nbytes
, int from_multibyte
, int to_multibyte
)
528 if (from_multibyte
== to_multibyte
)
530 memcpy (to_addr
, from_addr
, nbytes
);
533 else if (from_multibyte
)
535 EMACS_INT nchars
= 0;
536 EMACS_INT bytes_left
= nbytes
;
538 while (bytes_left
> 0)
541 c
= STRING_CHAR_AND_LENGTH (from_addr
, thislen
);
542 if (! ASCII_CHAR_P (c
))
545 from_addr
+= thislen
;
546 bytes_left
-= thislen
;
553 unsigned char *initial_to_addr
= to_addr
;
555 /* Convert single-byte to multibyte. */
558 int c
= *from_addr
++;
560 if (!ASCII_CHAR_P (c
))
562 c
= BYTE8_TO_CHAR (c
);
563 to_addr
+= CHAR_STRING (c
, to_addr
);
567 /* Special case for speed. */
568 *to_addr
++ = c
, nbytes
--;
570 return to_addr
- initial_to_addr
;
574 /* Insert a string of specified length before point.
575 This function judges multibyteness based on
576 enable_multibyte_characters in the current buffer;
577 it never converts between single-byte and multibyte.
579 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
580 prepare_to_modify_buffer could relocate the text. */
583 insert (const char *string
, EMACS_INT nbytes
)
587 EMACS_INT len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
588 insert_1_both (string
, len
, nbytes
, 0, 1, 0);
590 signal_after_change (opoint
, 0, len
);
591 update_compositions (opoint
, PT
, CHECK_BORDER
);
595 /* Likewise, but inherit text properties from neighboring characters. */
598 insert_and_inherit (const char *string
, EMACS_INT nbytes
)
602 EMACS_INT len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
603 insert_1_both (string
, len
, nbytes
, 1, 1, 0);
605 signal_after_change (opoint
, 0, len
);
606 update_compositions (opoint
, PT
, CHECK_BORDER
);
610 /* Insert the character C before point. Do not inherit text properties. */
615 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
618 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
619 len
= CHAR_STRING (c
, str
);
626 insert ((char *) str
, len
);
629 /* Insert the null-terminated string S before point. */
632 insert_string (const char *s
)
634 insert (s
, strlen (s
));
637 /* Like `insert' except that all markers pointing at the place where
638 the insertion happens are adjusted to point after it.
639 Don't use this function to insert part of a Lisp string,
640 since gc could happen and relocate it. */
643 insert_before_markers (const char *string
, EMACS_INT nbytes
)
647 EMACS_INT len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
648 insert_1_both (string
, len
, nbytes
, 0, 1, 1);
650 signal_after_change (opoint
, 0, len
);
651 update_compositions (opoint
, PT
, CHECK_BORDER
);
655 /* Likewise, but inherit text properties from neighboring characters. */
658 insert_before_markers_and_inherit (const char *string
,
663 EMACS_INT len
= chars_in_text ((unsigned char *) string
, nbytes
), opoint
;
664 insert_1_both (string
, len
, nbytes
, 1, 1, 1);
666 signal_after_change (opoint
, 0, len
);
667 update_compositions (opoint
, PT
, CHECK_BORDER
);
671 /* Subroutine used by the insert functions above. */
674 insert_1 (const char *string
, EMACS_INT nbytes
,
675 int inherit
, int prepare
, int before_markers
)
677 insert_1_both (string
, chars_in_text ((unsigned char *) string
, nbytes
),
678 nbytes
, inherit
, prepare
, before_markers
);
682 #ifdef BYTE_COMBINING_DEBUG
684 /* See if the bytes before POS/POS_BYTE combine with bytes
685 at the start of STRING to form a single character.
686 If so, return the number of bytes at the start of STRING
687 which combine in this way. Otherwise, return 0. */
690 count_combining_before (const unsigned char *string
, EMACS_INT length
,
691 EMACS_INT pos
, EMACS_INT pos_byte
)
693 int len
, combining_bytes
;
694 const unsigned char *p
;
696 if (NILP (current_buffer
->enable_multibyte_characters
))
699 /* At first, we can exclude the following cases:
700 (1) STRING[0] can't be a following byte of multibyte sequence.
701 (2) POS is the start of the current buffer.
702 (3) A character before POS is not a multibyte character. */
703 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
705 if (pos_byte
== BEG_BYTE
) /* case (2) */
708 p
= BYTE_POS_ADDR (pos_byte
- 1);
709 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
710 if (! LEADING_CODE_P (*p
)) /* case (3) */
713 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
714 if (combining_bytes
<= 0)
715 /* The character preceding POS is, complete and no room for
716 combining bytes (combining_bytes == 0), or an independent 8-bit
717 character (combining_bytes < 0). */
720 /* We have a combination situation. Count the bytes at STRING that
723 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
726 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
729 /* See if the bytes after POS/POS_BYTE combine with bytes
730 at the end of STRING to form a single character.
731 If so, return the number of bytes after POS/POS_BYTE
732 which combine in this way. Otherwise, return 0. */
735 count_combining_after (const unsigned char *string
,
736 EMACS_INT length
, EMACS_INT pos
, EMACS_INT pos_byte
)
738 EMACS_INT opos_byte
= pos_byte
;
743 if (NILP (current_buffer
->enable_multibyte_characters
))
746 /* At first, we can exclude the following cases:
747 (1) The last byte of STRING is an ASCII.
748 (2) POS is the last of the current buffer.
749 (3) A character at POS can't be a following byte of multibyte
751 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
753 if (pos_byte
== Z_BYTE
) /* case (2) */
755 bufp
= BYTE_POS_ADDR (pos_byte
);
756 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
760 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
766 /* All characters in STRING are not character head. We must
767 check also preceding bytes at POS. We are sure that the gap
769 unsigned char *p
= BEG_ADDR
;
771 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
773 if (i
< 0 || !LEADING_CODE_P (p
[i
]))
776 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
777 return (bytes
<= pos_byte
- 1 - i
+ length
779 : bytes
- (pos_byte
- 1 - i
+ length
));
781 if (!LEADING_CODE_P (string
[i
]))
784 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
786 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
788 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
794 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
795 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
796 are the same as in insert_1. */
799 insert_1_both (const char *string
,
800 EMACS_INT nchars
, EMACS_INT nbytes
,
801 int inherit
, int prepare
, int before_markers
)
806 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
810 /* Do this before moving and increasing the gap,
811 because the before-change hooks might move the gap
812 or make it smaller. */
813 prepare_to_modify_buffer (PT
, PT
, NULL
);
816 move_gap_both (PT
, PT_BYTE
);
817 if (GAP_SIZE
< nbytes
)
818 make_gap (nbytes
- GAP_SIZE
);
820 #ifdef BYTE_COMBINING_DEBUG
821 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
822 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
826 /* Record deletion of the surrounding text that combines with
827 the insertion. This, together with recording the insertion,
828 will add up to the right stuff in the undo list. */
829 record_insert (PT
, nchars
);
831 CHARS_MODIFF
= MODIFF
;
833 memcpy (GPT_ADDR
, string
, nbytes
);
842 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
847 /* The insert may have been in the unchanged region, so check again. */
848 if (Z
- GPT
< END_UNCHANGED
)
849 END_UNCHANGED
= Z
- GPT
;
851 adjust_overlays_for_insert (PT
, nchars
);
852 adjust_markers_for_insert (PT
, PT_BYTE
,
853 PT
+ nchars
, PT_BYTE
+ nbytes
,
856 if (BUF_INTERVALS (current_buffer
) != 0)
857 offset_intervals (current_buffer
, PT
, nchars
);
859 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
860 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
863 adjust_point (nchars
, nbytes
);
868 /* Insert the part of the text of STRING, a Lisp object assumed to be
869 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
870 starting at position POS / POS_BYTE. If the text of STRING has properties,
871 copy them into the buffer.
873 It does not work to use `insert' for this, because a GC could happen
874 before we copy the stuff into the buffer, and relocate the string
875 without insert noticing. */
878 insert_from_string (Lisp_Object string
, EMACS_INT pos
, EMACS_INT pos_byte
,
879 EMACS_INT length
, EMACS_INT length_byte
, int inherit
)
881 EMACS_INT opoint
= PT
;
883 if (SCHARS (string
) == 0)
886 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
888 signal_after_change (opoint
, 0, PT
- opoint
);
889 update_compositions (opoint
, PT
, CHECK_BORDER
);
892 /* Like `insert_from_string' except that all markers pointing
893 at the place where the insertion happens are adjusted to point after it. */
896 insert_from_string_before_markers (Lisp_Object string
,
897 EMACS_INT pos
, EMACS_INT pos_byte
,
898 EMACS_INT length
, EMACS_INT length_byte
,
901 EMACS_INT opoint
= PT
;
903 if (SCHARS (string
) == 0)
906 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
908 signal_after_change (opoint
, 0, PT
- opoint
);
909 update_compositions (opoint
, PT
, CHECK_BORDER
);
912 /* Subroutine of the insertion functions above. */
915 insert_from_string_1 (Lisp_Object string
, EMACS_INT pos
, EMACS_INT pos_byte
,
916 EMACS_INT nchars
, EMACS_INT nbytes
,
917 int inherit
, int before_markers
)
920 EMACS_INT outgoing_nbytes
= nbytes
;
923 /* Make OUTGOING_NBYTES describe the text
924 as it will be inserted in this buffer. */
926 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
927 outgoing_nbytes
= nchars
;
928 else if (! STRING_MULTIBYTE (string
))
930 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
934 /* Do this before moving and increasing the gap,
935 because the before-change hooks might move the gap
936 or make it smaller. */
937 prepare_to_modify_buffer (PT
, PT
, NULL
);
940 move_gap_both (PT
, PT_BYTE
);
941 if (GAP_SIZE
< outgoing_nbytes
)
942 make_gap (outgoing_nbytes
- GAP_SIZE
);
945 /* Copy the string text into the buffer, perhaps converting
946 between single-byte and multibyte. */
947 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
948 STRING_MULTIBYTE (string
),
949 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
951 #ifdef BYTE_COMBINING_DEBUG
952 /* We have copied text into the gap, but we have not altered
953 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
954 to these functions and get the same results as we would
955 have got earlier on. Meanwhile, PT_ADDR does point to
956 the text that has been stored by copy_text. */
957 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
958 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
962 record_insert (PT
, nchars
);
964 CHARS_MODIFF
= MODIFF
;
966 GAP_SIZE
-= outgoing_nbytes
;
970 GPT_BYTE
+= outgoing_nbytes
;
971 ZV_BYTE
+= outgoing_nbytes
;
972 Z_BYTE
+= outgoing_nbytes
;
973 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
978 /* The insert may have been in the unchanged region, so check again. */
979 if (Z
- GPT
< END_UNCHANGED
)
980 END_UNCHANGED
= Z
- GPT
;
982 adjust_overlays_for_insert (PT
, nchars
);
983 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
984 PT_BYTE
+ outgoing_nbytes
,
987 offset_intervals (current_buffer
, PT
, nchars
);
989 intervals
= STRING_INTERVALS (string
);
990 /* Get the intervals for the part of the string we are inserting. */
991 if (nbytes
< SBYTES (string
))
992 intervals
= copy_intervals (intervals
, pos
, nchars
);
994 /* Insert those intervals. */
995 graft_intervals_into_buffer (intervals
, PT
, nchars
,
996 current_buffer
, inherit
);
998 adjust_point (nchars
, outgoing_nbytes
);
1003 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1004 starting at GPT_ADDR. */
1007 insert_from_gap (EMACS_INT nchars
, EMACS_INT nbytes
)
1009 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1012 record_insert (GPT
, nchars
);
1022 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1027 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1028 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1031 if (BUF_INTERVALS (current_buffer
) != 0)
1033 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1034 graft_intervals_into_buffer (NULL_INTERVAL
, GPT
- nchars
, nchars
,
1038 if (GPT
- nchars
< PT
)
1039 adjust_point (nchars
, nbytes
);
1044 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1045 current buffer. If the text in BUF has properties, they are absorbed
1046 into the current buffer.
1048 It does not work to use `insert' for this, because a malloc could happen
1049 and relocate BUF's text before the copy happens. */
1052 insert_from_buffer (struct buffer
*buf
,
1053 EMACS_INT charpos
, EMACS_INT nchars
, int inherit
)
1055 EMACS_INT opoint
= PT
;
1057 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1058 signal_after_change (opoint
, 0, PT
- opoint
);
1059 update_compositions (opoint
, PT
, CHECK_BORDER
);
1063 insert_from_buffer_1 (struct buffer
*buf
,
1064 EMACS_INT from
, EMACS_INT nchars
, int inherit
)
1066 register Lisp_Object temp
;
1067 EMACS_INT chunk
, chunk_expanded
;
1068 EMACS_INT from_byte
= buf_charpos_to_bytepos (buf
, from
);
1069 EMACS_INT to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1070 EMACS_INT incoming_nbytes
= to_byte
- from_byte
;
1071 EMACS_INT outgoing_nbytes
= incoming_nbytes
;
1074 /* Make OUTGOING_NBYTES describe the text
1075 as it will be inserted in this buffer. */
1077 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1078 outgoing_nbytes
= nchars
;
1079 else if (NILP (BVAR (buf
, enable_multibyte_characters
)))
1081 EMACS_INT outgoing_before_gap
= 0;
1082 EMACS_INT outgoing_after_gap
= 0;
1084 if (from
< BUF_GPT (buf
))
1086 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1087 if (chunk
> incoming_nbytes
)
1088 chunk
= incoming_nbytes
;
1090 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1096 if (chunk
< incoming_nbytes
)
1098 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1100 incoming_nbytes
- chunk
);
1102 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1105 /* Make sure point-max won't overflow after this insertion. */
1106 XSETINT (temp
, outgoing_nbytes
+ Z
);
1107 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1108 error ("Maximum buffer size exceeded");
1110 /* Do this before moving and increasing the gap,
1111 because the before-change hooks might move the gap
1112 or make it smaller. */
1113 prepare_to_modify_buffer (PT
, PT
, NULL
);
1116 move_gap_both (PT
, PT_BYTE
);
1117 if (GAP_SIZE
< outgoing_nbytes
)
1118 make_gap (outgoing_nbytes
- GAP_SIZE
);
1120 if (from
< BUF_GPT (buf
))
1122 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1123 if (chunk
> incoming_nbytes
)
1124 chunk
= incoming_nbytes
;
1125 /* Record number of output bytes, so we know where
1126 to put the output from the second copy_text. */
1128 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1130 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1131 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1134 chunk_expanded
= chunk
= 0;
1136 if (chunk
< incoming_nbytes
)
1137 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1138 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1139 ! NILP (BVAR (buf
, enable_multibyte_characters
)),
1140 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1142 #ifdef BYTE_COMBINING_DEBUG
1143 /* We have copied text into the gap, but we have not altered
1144 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1145 to these functions and get the same results as we would
1146 have got earlier on. Meanwhile, GPT_ADDR does point to
1147 the text that has been stored by copy_text. */
1148 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1149 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1153 record_insert (PT
, nchars
);
1155 CHARS_MODIFF
= MODIFF
;
1157 GAP_SIZE
-= outgoing_nbytes
;
1161 GPT_BYTE
+= outgoing_nbytes
;
1162 ZV_BYTE
+= outgoing_nbytes
;
1163 Z_BYTE
+= outgoing_nbytes
;
1164 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1169 /* The insert may have been in the unchanged region, so check again. */
1170 if (Z
- GPT
< END_UNCHANGED
)
1171 END_UNCHANGED
= Z
- GPT
;
1173 adjust_overlays_for_insert (PT
, nchars
);
1174 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1175 PT_BYTE
+ outgoing_nbytes
,
1178 if (BUF_INTERVALS (current_buffer
) != 0)
1179 offset_intervals (current_buffer
, PT
, nchars
);
1181 /* Get the intervals for the part of the string we are inserting. */
1182 intervals
= BUF_INTERVALS (buf
);
1183 if (nchars
< BUF_Z (buf
) - BUF_BEG (buf
))
1185 if (buf
== current_buffer
&& PT
<= from
)
1187 intervals
= copy_intervals (intervals
, from
, nchars
);
1190 /* Insert those intervals. */
1191 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1193 adjust_point (nchars
, outgoing_nbytes
);
1196 /* Record undo information and adjust markers and position keepers for
1197 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1198 chars (LEN_BYTE bytes) which resides in the gap just after
1201 PREV_TEXT nil means the new text was just inserted. */
1204 adjust_after_replace (EMACS_INT from
, EMACS_INT from_byte
,
1205 Lisp_Object prev_text
, EMACS_INT len
, EMACS_INT len_byte
)
1207 EMACS_INT nchars_del
= 0, nbytes_del
= 0;
1209 #ifdef BYTE_COMBINING_DEBUG
1210 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1211 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1215 if (STRINGP (prev_text
))
1217 nchars_del
= SCHARS (prev_text
);
1218 nbytes_del
= SBYTES (prev_text
);
1221 /* Update various buffer positions for the new text. */
1222 GAP_SIZE
-= len_byte
;
1224 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1225 GPT
+= len
; GPT_BYTE
+= len_byte
;
1226 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1229 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1232 adjust_markers_for_insert (from
, from_byte
,
1233 from
+ len
, from_byte
+ len_byte
, 0);
1235 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1238 record_delete (from
, prev_text
);
1239 record_insert (from
, len
);
1242 if (len
> nchars_del
)
1243 adjust_overlays_for_insert (from
, len
- nchars_del
);
1244 else if (len
< nchars_del
)
1245 adjust_overlays_for_delete (from
, nchars_del
- len
);
1246 if (BUF_INTERVALS (current_buffer
) != 0)
1248 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1252 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1254 /* As byte combining will decrease Z, we must check this again. */
1255 if (Z
- GPT
< END_UNCHANGED
)
1256 END_UNCHANGED
= Z
- GPT
;
1261 evaporate_overlays (from
);
1263 CHARS_MODIFF
= MODIFF
;
1266 /* Record undo information, adjust markers and position keepers for an
1267 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1268 text already exists in the current buffer but character length (TO
1269 - FROM) may be incorrect, the correct length is NEWLEN. */
1272 adjust_after_insert (EMACS_INT from
, EMACS_INT from_byte
,
1273 EMACS_INT to
, EMACS_INT to_byte
, EMACS_INT newlen
)
1275 EMACS_INT len
= to
- from
, len_byte
= to_byte
- from_byte
;
1278 move_gap_both (to
, to_byte
);
1279 GAP_SIZE
+= len_byte
;
1280 GPT
-= len
; GPT_BYTE
-= len_byte
;
1281 ZV
-= len
; ZV_BYTE
-= len_byte
;
1282 Z
-= len
; Z_BYTE
-= len_byte
;
1283 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1286 /* Replace the text from character positions FROM to TO with NEW,
1287 If PREPARE is nonzero, call prepare_to_modify_buffer.
1288 If INHERIT, the newly inserted text should inherit text properties
1289 from the surrounding non-deleted text. */
1291 /* Note that this does not yet handle markers quite right.
1292 Also it needs to record a single undo-entry that does a replacement
1293 rather than a separate delete and insert.
1294 That way, undo will also handle markers properly.
1296 But if MARKERS is 0, don't relocate markers. */
1299 replace_range (EMACS_INT from
, EMACS_INT to
, Lisp_Object
new,
1300 int prepare
, int inherit
, int markers
)
1302 EMACS_INT inschars
= SCHARS (new);
1303 EMACS_INT insbytes
= SBYTES (new);
1304 EMACS_INT from_byte
, to_byte
;
1305 EMACS_INT nbytes_del
, nchars_del
;
1306 register Lisp_Object temp
;
1307 struct gcpro gcpro1
;
1309 EMACS_INT outgoing_insbytes
= insbytes
;
1310 Lisp_Object deletion
;
1319 EMACS_INT range_length
= to
- from
;
1320 prepare_to_modify_buffer (from
, to
, &from
);
1321 to
= from
+ range_length
;
1326 /* Make args be valid */
1332 from_byte
= CHAR_TO_BYTE (from
);
1333 to_byte
= CHAR_TO_BYTE (to
);
1335 nchars_del
= to
- from
;
1336 nbytes_del
= to_byte
- from_byte
;
1338 if (nbytes_del
<= 0 && insbytes
== 0)
1341 /* Make OUTGOING_INSBYTES describe the text
1342 as it will be inserted in this buffer. */
1344 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
1345 outgoing_insbytes
= inschars
;
1346 else if (! STRING_MULTIBYTE (new))
1348 = count_size_as_multibyte (SDATA (new), insbytes
);
1350 /* Make sure point-max won't overflow after this insertion. */
1351 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1352 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1353 error ("Maximum buffer size exceeded");
1357 /* Make sure the gap is somewhere in or next to what we are deleting. */
1359 gap_right (from
, from_byte
);
1361 gap_left (to
, to_byte
, 0);
1363 /* Even if we don't record for undo, we must keep the original text
1364 because we may have to recover it because of inappropriate byte
1366 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1367 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1369 GAP_SIZE
+= nbytes_del
;
1372 ZV_BYTE
-= nbytes_del
;
1373 Z_BYTE
-= nbytes_del
;
1375 GPT_BYTE
= from_byte
;
1376 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1381 if (GPT
- BEG
< BEG_UNCHANGED
)
1382 BEG_UNCHANGED
= GPT
- BEG
;
1383 if (Z
- GPT
< END_UNCHANGED
)
1384 END_UNCHANGED
= Z
- GPT
;
1386 if (GAP_SIZE
< insbytes
)
1387 make_gap (insbytes
- GAP_SIZE
);
1389 /* Copy the string text into the buffer, perhaps converting
1390 between single-byte and multibyte. */
1391 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1392 STRING_MULTIBYTE (new),
1393 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
1395 #ifdef BYTE_COMBINING_DEBUG
1396 /* We have copied text into the gap, but we have not marked
1397 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1398 here, for both the previous text and the following text.
1399 Meanwhile, GPT_ADDR does point to
1400 the text that has been stored by copy_text. */
1401 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1402 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1406 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1408 /* Record the insertion first, so that when we undo,
1409 the deletion will be undone first. Thus, undo
1410 will insert before deleting, and thus will keep
1411 the markers before and after this text separate. */
1412 record_insert (from
+ SCHARS (deletion
), inschars
);
1413 record_delete (from
, deletion
);
1416 GAP_SIZE
-= outgoing_insbytes
;
1420 GPT_BYTE
+= outgoing_insbytes
;
1421 ZV_BYTE
+= outgoing_insbytes
;
1422 Z_BYTE
+= outgoing_insbytes
;
1423 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1428 /* Adjust the overlay center as needed. This must be done after
1429 adjusting the markers that bound the overlays. */
1430 adjust_overlays_for_delete (from
, nchars_del
);
1431 adjust_overlays_for_insert (from
, inschars
);
1433 /* Adjust markers for the deletion and the insertion. */
1435 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1436 inschars
, outgoing_insbytes
);
1438 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1440 /* Get the intervals for the part of the string we are inserting--
1441 not including the combined-before bytes. */
1442 intervals
= STRING_INTERVALS (new);
1443 /* Insert those intervals. */
1444 graft_intervals_into_buffer (intervals
, from
, inschars
,
1445 current_buffer
, inherit
);
1447 /* Relocate point as if it were a marker. */
1449 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1450 (from_byte
+ outgoing_insbytes
1451 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1453 if (outgoing_insbytes
== 0)
1454 evaporate_overlays (from
);
1459 CHARS_MODIFF
= MODIFF
;
1462 signal_after_change (from
, nchars_del
, GPT
- from
);
1463 update_compositions (from
, GPT
, CHECK_BORDER
);
1466 /* Replace the text from character positions FROM to TO with
1467 the text in INS of length INSCHARS.
1468 Keep the text properties that applied to the old characters
1469 (extending them to all the new chars if there are more new chars).
1471 Note that this does not yet handle markers quite right.
1473 If MARKERS is nonzero, relocate markers.
1475 Unlike most functions at this level, never call
1476 prepare_to_modify_buffer and never call signal_after_change. */
1479 replace_range_2 (EMACS_INT from
, EMACS_INT from_byte
,
1480 EMACS_INT to
, EMACS_INT to_byte
,
1481 const char *ins
, EMACS_INT inschars
, EMACS_INT insbytes
,
1484 EMACS_INT nbytes_del
, nchars_del
;
1489 nchars_del
= to
- from
;
1490 nbytes_del
= to_byte
- from_byte
;
1492 if (nbytes_del
<= 0 && insbytes
== 0)
1495 /* Make sure point-max won't overflow after this insertion. */
1496 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1497 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1498 error ("Maximum buffer size exceeded");
1500 /* Make sure the gap is somewhere in or next to what we are deleting. */
1502 gap_right (from
, from_byte
);
1504 gap_left (to
, to_byte
, 0);
1506 GAP_SIZE
+= nbytes_del
;
1509 ZV_BYTE
-= nbytes_del
;
1510 Z_BYTE
-= nbytes_del
;
1512 GPT_BYTE
= from_byte
;
1513 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1518 if (GPT
- BEG
< BEG_UNCHANGED
)
1519 BEG_UNCHANGED
= GPT
- BEG
;
1520 if (Z
- GPT
< END_UNCHANGED
)
1521 END_UNCHANGED
= Z
- GPT
;
1523 if (GAP_SIZE
< insbytes
)
1524 make_gap (insbytes
- GAP_SIZE
);
1526 /* Copy the replacement text into the buffer. */
1527 memcpy (GPT_ADDR
, ins
, insbytes
);
1529 #ifdef BYTE_COMBINING_DEBUG
1530 /* We have copied text into the gap, but we have not marked
1531 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1532 here, for both the previous text and the following text.
1533 Meanwhile, GPT_ADDR does point to
1534 the text that has been stored by copy_text. */
1535 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1536 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1540 GAP_SIZE
-= insbytes
;
1544 GPT_BYTE
+= insbytes
;
1545 ZV_BYTE
+= insbytes
;
1547 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1552 /* Adjust the overlay center as needed. This must be done after
1553 adjusting the markers that bound the overlays. */
1554 if (nchars_del
!= inschars
)
1556 adjust_overlays_for_insert (from
, inschars
);
1557 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1560 /* Adjust markers for the deletion and the insertion. */
1562 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1563 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1564 inschars
, insbytes
);
1566 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1568 /* Relocate point as if it were a marker. */
1569 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1572 /* PT was within the deleted text. Move it to FROM. */
1573 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1575 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1579 evaporate_overlays (from
);
1584 CHARS_MODIFF
= MODIFF
;
1587 /* Delete characters in current buffer
1588 from FROM up to (but not including) TO.
1589 If TO comes before FROM, we delete nothing. */
1592 del_range (EMACS_INT from
, EMACS_INT to
)
1594 del_range_1 (from
, to
, 1, 0);
1597 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1598 RET_STRING says to return the deleted text. */
1601 del_range_1 (EMACS_INT from
, EMACS_INT to
, int prepare
, int ret_string
)
1603 EMACS_INT from_byte
, to_byte
;
1604 Lisp_Object deletion
;
1605 struct gcpro gcpro1
;
1607 /* Make args be valid */
1618 EMACS_INT range_length
= to
- from
;
1619 prepare_to_modify_buffer (from
, to
, &from
);
1620 to
= min (ZV
, from
+ range_length
);
1623 from_byte
= CHAR_TO_BYTE (from
);
1624 to_byte
= CHAR_TO_BYTE (to
);
1626 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1628 signal_after_change (from
, to
- from
, 0);
1629 update_compositions (from
, from
, CHECK_HEAD
);
1634 /* Like del_range_1 but args are byte positions, not char positions. */
1637 del_range_byte (EMACS_INT from_byte
, EMACS_INT to_byte
, int prepare
)
1641 /* Make args be valid */
1642 if (from_byte
< BEGV_BYTE
)
1643 from_byte
= BEGV_BYTE
;
1644 if (to_byte
> ZV_BYTE
)
1647 if (to_byte
<= from_byte
)
1650 from
= BYTE_TO_CHAR (from_byte
);
1651 to
= BYTE_TO_CHAR (to_byte
);
1655 EMACS_INT old_from
= from
, old_to
= Z
- to
;
1656 EMACS_INT 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 /* Like del_range_1, but positions are specified both as charpos
1680 del_range_both (EMACS_INT from
, EMACS_INT from_byte
,
1681 EMACS_INT to
, EMACS_INT to_byte
, int prepare
)
1683 /* Make args be valid */
1684 if (from_byte
< BEGV_BYTE
)
1685 from_byte
= BEGV_BYTE
;
1686 if (to_byte
> ZV_BYTE
)
1689 if (to_byte
<= from_byte
)
1699 EMACS_INT old_from
= from
, old_to
= Z
- to
;
1700 EMACS_INT range_length
= to
- from
;
1701 prepare_to_modify_buffer (from
, to
, &from
);
1702 to
= from
+ range_length
;
1704 if (old_from
!= from
)
1705 from_byte
= CHAR_TO_BYTE (from
);
1711 else if (old_to
== Z
- to
)
1712 to_byte
= CHAR_TO_BYTE (to
);
1715 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1716 signal_after_change (from
, to
- from
, 0);
1717 update_compositions (from
, from
, CHECK_HEAD
);
1720 /* Delete a range of text, specified both as character positions
1721 and byte positions. FROM and TO are character positions,
1722 while FROM_BYTE and TO_BYTE are byte positions.
1723 If RET_STRING is true, the deleted area is returned as a string. */
1726 del_range_2 (EMACS_INT from
, EMACS_INT from_byte
,
1727 EMACS_INT to
, EMACS_INT to_byte
, int ret_string
)
1729 register EMACS_INT nbytes_del
, nchars_del
;
1730 Lisp_Object deletion
;
1734 nchars_del
= to
- from
;
1735 nbytes_del
= to_byte
- from_byte
;
1737 /* Make sure the gap is somewhere in or next to what we are deleting. */
1739 gap_right (from
, from_byte
);
1741 gap_left (to
, to_byte
, 0);
1743 #ifdef BYTE_COMBINING_DEBUG
1744 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1745 Z_BYTE
- to_byte
, from
, from_byte
))
1749 if (ret_string
|| ! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1750 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1754 /* Relocate all markers pointing into the new, larger gap
1755 to point at the end of the text before the gap.
1756 Do this before recording the deletion,
1757 so that undo handles this after reinserting the text. */
1758 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1760 if (! EQ (BVAR (current_buffer
, undo_list
), Qt
))
1761 record_delete (from
, deletion
);
1763 CHARS_MODIFF
= MODIFF
;
1765 /* Relocate point as if it were a marker. */
1767 adjust_point (from
- (PT
< to
? PT
: to
),
1768 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1770 offset_intervals (current_buffer
, from
, - nchars_del
);
1772 /* Adjust the overlay center as needed. This must be done after
1773 adjusting the markers that bound the overlays. */
1774 adjust_overlays_for_delete (from
, nchars_del
);
1776 GAP_SIZE
+= nbytes_del
;
1777 ZV_BYTE
-= nbytes_del
;
1778 Z_BYTE
-= nbytes_del
;
1782 GPT_BYTE
= from_byte
;
1783 if (GAP_SIZE
> 0 && !current_buffer
->text
->inhibit_shrinking
)
1784 /* Put an anchor, unless called from decode_coding_object which
1785 needs to access the previous gap contents. */
1791 if (GPT
- BEG
< BEG_UNCHANGED
)
1792 BEG_UNCHANGED
= GPT
- BEG
;
1793 if (Z
- GPT
< END_UNCHANGED
)
1794 END_UNCHANGED
= Z
- GPT
;
1798 evaporate_overlays (from
);
1803 /* Call this if you're about to change the region of BUFFER from
1804 character positions START to END. This checks the read-only
1805 properties of the region, calls the necessary modification hooks,
1806 and warns the next redisplay that it should pay attention to that
1809 If PRESERVE_CHARS_MODIFF is non-zero, do not update CHARS_MODIFF.
1810 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
1813 modify_region (struct buffer
*buffer
, EMACS_INT start
, EMACS_INT end
,
1814 int preserve_chars_modiff
)
1816 struct buffer
*old_buffer
= current_buffer
;
1818 if (buffer
!= old_buffer
)
1819 set_buffer_internal (buffer
);
1821 prepare_to_modify_buffer (start
, end
, NULL
);
1823 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1825 if (MODIFF
<= SAVE_MODIFF
)
1826 record_first_change ();
1828 if (! preserve_chars_modiff
)
1829 CHARS_MODIFF
= MODIFF
;
1831 BVAR (buffer
, point_before_scroll
) = Qnil
;
1833 if (buffer
!= old_buffer
)
1834 set_buffer_internal (old_buffer
);
1837 /* Check that it is okay to modify the buffer between START and END,
1838 which are char positions.
1840 Run the before-change-function, if any. If intervals are in use,
1841 verify that the text to be modified is not read-only, and call
1842 any modification properties the text may have.
1844 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1845 by holding its value temporarily in a marker. */
1848 prepare_to_modify_buffer (EMACS_INT start
, EMACS_INT end
,
1849 EMACS_INT
*preserve_ptr
)
1851 struct buffer
*base_buffer
;
1853 if (!NILP (BVAR (current_buffer
, read_only
)))
1854 Fbarf_if_buffer_read_only ();
1856 /* Let redisplay consider other windows than selected_window
1857 if modifying another buffer. */
1858 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1859 ++windows_or_buffers_changed
;
1861 if (BUF_INTERVALS (current_buffer
) != 0)
1865 Lisp_Object preserve_marker
;
1866 struct gcpro gcpro1
;
1867 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1868 GCPRO1 (preserve_marker
);
1869 verify_interval_modification (current_buffer
, start
, end
);
1870 *preserve_ptr
= marker_position (preserve_marker
);
1871 unchain_marker (XMARKER (preserve_marker
));
1875 verify_interval_modification (current_buffer
, start
, end
);
1878 /* For indirect buffers, use the base buffer to check clashes. */
1879 if (current_buffer
->base_buffer
!= 0)
1880 base_buffer
= current_buffer
->base_buffer
;
1882 base_buffer
= current_buffer
;
1884 #ifdef CLASH_DETECTION
1885 if (!NILP (BVAR (base_buffer
, file_truename
))
1886 /* Make binding buffer-file-name to nil effective. */
1887 && !NILP (BVAR (base_buffer
, filename
))
1888 && SAVE_MODIFF
>= MODIFF
)
1889 lock_file (BVAR (base_buffer
, file_truename
));
1891 /* At least warn if this file has changed on disk since it was visited. */
1892 if (!NILP (BVAR (base_buffer
, filename
))
1893 && SAVE_MODIFF
>= MODIFF
1894 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1895 && !NILP (Ffile_exists_p (BVAR (base_buffer
, filename
))))
1896 call1 (intern ("ask-user-about-supersession-threat"),
1897 BVAR (base_buffer
,filename
));
1898 #endif /* not CLASH_DETECTION */
1900 /* If `select-active-regions' is non-nil, save the region text. */
1901 if (!NILP (BVAR (current_buffer
, mark_active
))
1902 && !inhibit_modification_hooks
1903 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1904 && NILP (Vsaved_region_selection
)
1905 && (EQ (Vselect_active_regions
, Qonly
)
1906 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1907 : (!NILP (Vselect_active_regions
)
1908 && !NILP (Vtransient_mark_mode
))))
1910 EMACS_INT b
= XMARKER (BVAR (current_buffer
, mark
))->charpos
;
1913 Vsaved_region_selection
= make_buffer_string (b
, e
, 0);
1915 Vsaved_region_selection
= make_buffer_string (e
, b
, 0);
1918 signal_before_change (start
, end
, preserve_ptr
);
1920 if (current_buffer
->newline_cache
)
1921 invalidate_region_cache (current_buffer
,
1922 current_buffer
->newline_cache
,
1923 start
- BEG
, Z
- end
);
1924 if (current_buffer
->width_run_cache
)
1925 invalidate_region_cache (current_buffer
,
1926 current_buffer
->width_run_cache
,
1927 start
- BEG
, Z
- end
);
1929 Vdeactivate_mark
= Qt
;
1932 /* These macros work with an argument named `preserve_ptr'
1933 and a local variable named `preserve_marker'. */
1935 #define PRESERVE_VALUE \
1936 if (preserve_ptr && NILP (preserve_marker)) \
1937 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1939 #define RESTORE_VALUE \
1940 if (! NILP (preserve_marker)) \
1942 *preserve_ptr = marker_position (preserve_marker); \
1943 unchain_marker (XMARKER (preserve_marker)); \
1946 #define PRESERVE_START_END \
1947 if (NILP (start_marker)) \
1948 start_marker = Fcopy_marker (start, Qnil); \
1949 if (NILP (end_marker)) \
1950 end_marker = Fcopy_marker (end, Qnil);
1952 #define FETCH_START \
1953 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1956 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1958 /* Set a variable to nil if an error occurred.
1959 Don't change the variable if there was no error.
1960 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
1961 VARIABLE is the variable to maybe set to nil.
1962 NO-ERROR-FLAG is nil if there was an error,
1963 anything else meaning no error (so this function does nothing). */
1965 reset_var_on_error (Lisp_Object val
)
1967 if (NILP (XCDR (val
)))
1968 Fset (XCAR (val
), Qnil
);
1972 /* Signal a change to the buffer immediately before it happens.
1973 START_INT and END_INT are the bounds of the text to be changed.
1975 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1976 by holding its value temporarily in a marker. */
1979 signal_before_change (EMACS_INT start_int
, EMACS_INT end_int
,
1980 EMACS_INT
*preserve_ptr
)
1982 Lisp_Object start
, end
;
1983 Lisp_Object start_marker
, end_marker
;
1984 Lisp_Object preserve_marker
;
1985 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1986 int count
= SPECPDL_INDEX ();
1988 if (inhibit_modification_hooks
)
1991 start
= make_number (start_int
);
1992 end
= make_number (end_int
);
1993 preserve_marker
= Qnil
;
1994 start_marker
= Qnil
;
1996 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1998 specbind (Qinhibit_modification_hooks
, Qt
);
2000 /* If buffer is unmodified, run a special hook for that case. The
2001 check for Vfirst_change_hook is just a minor optimization. */
2002 if (SAVE_MODIFF
>= MODIFF
2003 && !NILP (Vfirst_change_hook
))
2007 Frun_hooks (1, &Qfirst_change_hook
);
2010 /* Now run the before-change-functions if any. */
2011 if (!NILP (Vbefore_change_functions
))
2013 Lisp_Object args
[3];
2014 Lisp_Object rvoe_arg
= Fcons (Qbefore_change_functions
, Qnil
);
2019 /* Mark before-change-functions to be reset to nil in case of error. */
2020 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2022 /* Actually run the hook functions. */
2023 args
[0] = Qbefore_change_functions
;
2024 args
[1] = FETCH_START
;
2025 args
[2] = FETCH_END
;
2026 Frun_hook_with_args (3, args
);
2028 /* There was no error: unarm the reset_on_error. */
2029 XSETCDR (rvoe_arg
, Qt
);
2032 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2035 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2036 FETCH_START
, FETCH_END
, Qnil
);
2039 if (! NILP (start_marker
))
2040 free_marker (start_marker
);
2041 if (! NILP (end_marker
))
2042 free_marker (end_marker
);
2046 unbind_to (count
, Qnil
);
2049 /* Signal a change immediately after it happens.
2050 CHARPOS is the character position of the start of the changed text.
2051 LENDEL is the number of characters of the text before the change.
2052 (Not the whole buffer; just the part that was changed.)
2053 LENINS is the number of characters in that part of the text
2054 after the change. */
2057 signal_after_change (EMACS_INT charpos
, EMACS_INT lendel
, EMACS_INT lenins
)
2059 int count
= SPECPDL_INDEX ();
2060 if (inhibit_modification_hooks
)
2063 /* If we are deferring calls to the after-change functions
2064 and there are no before-change functions,
2065 just record the args that we were going to use. */
2066 if (! NILP (Vcombine_after_change_calls
)
2067 && NILP (Vbefore_change_functions
)
2068 && !current_buffer
->overlays_before
2069 && !current_buffer
->overlays_after
)
2073 if (!NILP (combine_after_change_list
)
2074 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2075 Fcombine_after_change_execute ();
2077 elt
= Fcons (make_number (charpos
- BEG
),
2078 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2079 Fcons (make_number (lenins
- lendel
), Qnil
)));
2080 combine_after_change_list
2081 = Fcons (elt
, combine_after_change_list
);
2082 combine_after_change_buffer
= Fcurrent_buffer ();
2087 if (!NILP (combine_after_change_list
))
2088 Fcombine_after_change_execute ();
2090 specbind (Qinhibit_modification_hooks
, Qt
);
2092 if (!NILP (Vafter_change_functions
))
2094 Lisp_Object args
[4];
2095 Lisp_Object rvoe_arg
= Fcons (Qafter_change_functions
, Qnil
);
2097 /* Mark after-change-functions to be reset to nil in case of error. */
2098 record_unwind_protect (reset_var_on_error
, rvoe_arg
);
2100 /* Actually run the hook functions. */
2101 args
[0] = Qafter_change_functions
;
2102 XSETFASTINT (args
[1], charpos
);
2103 XSETFASTINT (args
[2], charpos
+ lenins
);
2104 XSETFASTINT (args
[3], lendel
);
2105 Frun_hook_with_args (4, args
);
2107 /* There was no error: unarm the reset_on_error. */
2108 XSETCDR (rvoe_arg
, Qt
);
2111 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2112 report_overlay_modification (make_number (charpos
),
2113 make_number (charpos
+ lenins
),
2115 make_number (charpos
),
2116 make_number (charpos
+ lenins
),
2117 make_number (lendel
));
2119 /* After an insertion, call the text properties
2120 insert-behind-hooks or insert-in-front-hooks. */
2122 report_interval_modification (make_number (charpos
),
2123 make_number (charpos
+ lenins
));
2125 unbind_to (count
, Qnil
);
2129 Fcombine_after_change_execute_1 (Lisp_Object val
)
2131 Vcombine_after_change_calls
= val
;
2135 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2136 Scombine_after_change_execute
, 0, 0, 0,
2137 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2140 int count
= SPECPDL_INDEX ();
2141 EMACS_INT beg
, end
, change
;
2142 EMACS_INT begpos
, endpos
;
2145 if (NILP (combine_after_change_list
))
2148 /* It is rare for combine_after_change_buffer to be invalid, but
2149 possible. It can happen when combine-after-change-calls is
2150 non-nil, and insertion calls a file handler (e.g. through
2151 lock_file) which scribbles into a temp file -- cyd */
2152 if (!BUFFERP (combine_after_change_buffer
)
2153 || NILP (BVAR (XBUFFER (combine_after_change_buffer
), name
)))
2155 combine_after_change_list
= Qnil
;
2159 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2161 Fset_buffer (combine_after_change_buffer
);
2163 /* # chars unchanged at beginning of buffer. */
2165 /* # chars unchanged at end of buffer. */
2167 /* Total amount of insertion (negative for deletion). */
2170 /* Scan the various individual changes,
2171 accumulating the range info in BEG, END and CHANGE. */
2172 for (tail
= combine_after_change_list
; CONSP (tail
);
2176 EMACS_INT thisbeg
, thisend
, thischange
;
2178 /* Extract the info from the next element. */
2182 thisbeg
= XINT (XCAR (elt
));
2187 thisend
= XINT (XCAR (elt
));
2192 thischange
= XINT (XCAR (elt
));
2194 /* Merge this range into the accumulated range. */
2195 change
+= thischange
;
2202 /* Get the current start and end positions of the range
2203 that was changed. */
2207 /* We are about to handle these, so discard them. */
2208 combine_after_change_list
= Qnil
;
2210 /* Now run the after-change functions for real.
2211 Turn off the flag that defers them. */
2212 record_unwind_protect (Fcombine_after_change_execute_1
,
2213 Vcombine_after_change_calls
);
2214 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2215 update_compositions (begpos
, endpos
, CHECK_ALL
);
2217 return unbind_to (count
, Qnil
);
2221 syms_of_insdel (void)
2223 staticpro (&combine_after_change_list
);
2224 staticpro (&combine_after_change_buffer
);
2225 combine_after_change_list
= Qnil
;
2226 combine_after_change_buffer
= Qnil
;
2228 DEFVAR_BOOL ("check-markers-debug-flag", check_markers_debug_flag
,
2229 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2230 check_markers_debug_flag
= 0;
2231 DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls
,
2232 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2233 Vcombine_after_change_calls
= Qnil
;
2235 DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks
,
2236 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2237 This affects `before-change-functions' and `after-change-functions',
2238 as well as hooks attached to text properties and overlays. */);
2239 inhibit_modification_hooks
= 0;
2240 Qinhibit_modification_hooks
= intern_c_string ("inhibit-modification-hooks");
2241 staticpro (&Qinhibit_modification_hooks
);
2243 defsubr (&Scombine_after_change_execute
);