1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000, 2001
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 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "intervals.h"
27 #include "character.h"
29 #include "blockinput.h"
30 #include "region-cache.h"
36 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
37 static void insert_from_buffer_1 ();
38 static void gap_left
P_ ((int, int, int));
39 static void gap_right
P_ ((int, int));
40 static void adjust_markers_gap_motion
P_ ((int, int, int));
41 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
42 void adjust_markers_for_delete
P_ ((int, int, int, int));
43 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
44 static void adjust_point
P_ ((int, int));
46 Lisp_Object
Fcombine_after_change_execute ();
48 /* Non-nil means don't call the after-change-functions right away,
49 just record an element in Vcombine_after_change_calls_list. */
50 Lisp_Object Vcombine_after_change_calls
;
52 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
53 describing changes which happened while combine_after_change_calls
54 was nonzero. We use this to decide how to call them
55 once the deferral ends.
58 BEG-UNCHANGED is the number of chars before the changed range.
59 END-UNCHANGED is the number of chars after the changed range,
60 and CHANGE-AMOUNT is the number of characters inserted by the change
61 (negative for a deletion). */
62 Lisp_Object combine_after_change_list
;
64 /* Buffer which combine_after_change_list is about. */
65 Lisp_Object combine_after_change_buffer
;
67 Lisp_Object Qinhibit_modification_hooks
;
70 /* Check all markers in the current buffer, looking for something invalid. */
72 static int check_markers_debug_flag
;
74 #define CHECK_MARKERS() \
75 if (check_markers_debug_flag) \
82 register Lisp_Object tail
;
83 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
85 tail
= BUF_MARKERS (current_buffer
);
89 if (XMARKER (tail
)->buffer
->text
!= current_buffer
->text
)
91 if (XMARKER (tail
)->charpos
> Z
)
93 if (XMARKER (tail
)->bytepos
> Z_BYTE
)
95 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (XMARKER (tail
)->bytepos
)))
98 tail
= XMARKER (tail
)->chain
;
102 /* Move gap to position CHARPOS.
103 Note that this can quit! */
109 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
112 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
113 Note that this can quit! */
116 move_gap_both (charpos
, bytepos
)
117 int charpos
, bytepos
;
119 if (bytepos
< GPT_BYTE
)
120 gap_left (charpos
, bytepos
, 0);
121 else if (bytepos
> GPT_BYTE
)
122 gap_right (charpos
, bytepos
);
125 /* Move the gap to a position less than the current GPT.
126 BYTEPOS describes the new position as a byte position,
127 and CHARPOS is the corresponding char position.
128 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
131 gap_left (charpos
, bytepos
, newgap
)
132 register int charpos
, bytepos
;
135 register unsigned char *to
, *from
;
140 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
147 /* Now copy the characters. To move the gap down,
148 copy characters up. */
152 /* I gets number of characters left to copy. */
153 i
= new_s1
- bytepos
;
156 /* If a quit is requested, stop copying now.
157 Change BYTEPOS to be where we have actually moved the gap to. */
161 charpos
= BYTE_TO_CHAR (bytepos
);
164 /* Move at most 32000 chars before checking again for a quit. */
169 /* bcopy is safe if the two areas of memory do not overlap
170 or on systems where bcopy is always safe for moving upward. */
171 && (BCOPY_UPWARD_SAFE
172 || to
- from
>= 128))
174 /* If overlap is not safe, avoid it by not moving too many
175 characters at once. */
176 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
191 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
192 BYTEPOS is where the loop above stopped, which may be what was specified
193 or may be where a quit was detected. */
194 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
197 if (bytepos
< charpos
)
199 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
203 /* Move the gap to a position greater than than the current GPT.
204 BYTEPOS describes the new position as a byte position,
205 and CHARPOS is the corresponding char position. */
208 gap_right (charpos
, bytepos
)
209 register int charpos
, bytepos
;
211 register unsigned char *to
, *from
;
215 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
222 /* Now copy the characters. To move the gap up,
223 copy characters down. */
227 /* I gets number of characters left to copy. */
228 i
= bytepos
- new_s1
;
231 /* If a quit is requested, stop copying now.
232 Change BYTEPOS to be where we have actually moved the gap to. */
236 charpos
= BYTE_TO_CHAR (bytepos
);
239 /* Move at most 32000 chars before checking again for a quit. */
244 /* bcopy is safe if the two areas of memory do not overlap
245 or on systems where bcopy is always safe for moving downward. */
246 && (BCOPY_DOWNWARD_SAFE
247 || from
- to
>= 128))
249 /* If overlap is not safe, avoid it by not moving too many
250 characters at once. */
251 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
266 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
270 if (bytepos
< charpos
)
272 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
276 /* Add AMOUNT to the byte position of every marker in the current buffer
277 whose current byte position is between FROM (exclusive) and TO (inclusive).
279 Also, any markers past the outside of that interval, in the direction
280 of adjustment, are first moved back to the near end of the interval
281 and then adjusted by AMOUNT.
283 When the latter adjustment is done, if AMOUNT is negative,
284 we record the adjustment for undo. (This case happens only for
287 The markers' character positions are not altered,
288 because gap motion does not affect character positions. */
290 int adjust_markers_test
;
293 adjust_markers_gap_motion (from
, to
, amount
)
294 register int from
, to
, amount
;
296 /* Now that a marker has a bytepos, not counting the gap,
297 nothing needs to be done here. */
300 register struct Lisp_Marker
*m
;
303 marker
= BUF_MARKERS (current_buffer
);
305 while (!NILP (marker
))
307 m
= XMARKER (marker
);
311 if (mpos
> to
&& mpos
< to
+ amount
)
313 if (adjust_markers_test
)
320 /* Here's the case where a marker is inside text being deleted.
321 AMOUNT can be negative for gap motion, too,
322 but then this range contains no markers. */
323 if (mpos
> from
+ amount
&& mpos
<= from
)
325 if (adjust_markers_test
)
327 mpos
= from
+ amount
;
330 if (mpos
> from
&& mpos
<= to
)
338 /* Adjust all markers for a deletion
339 whose range in bytes is FROM_BYTE to TO_BYTE.
340 The range in charpos is FROM to TO.
342 This function assumes that the gap is adjacent to
343 or inside of the range being deleted. */
346 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
347 register int from
, from_byte
, to
, to_byte
;
350 register struct Lisp_Marker
*m
;
351 register int charpos
;
353 marker
= BUF_MARKERS (current_buffer
);
355 while (!NILP (marker
))
357 m
= XMARKER (marker
);
358 charpos
= m
->charpos
;
363 /* If the marker is after the deletion,
364 relocate by number of chars / bytes deleted. */
367 m
->charpos
-= to
- from
;
368 m
->bytepos
-= to_byte
- from_byte
;
370 /* Here's the case where a marker is inside text being deleted. */
371 else if (charpos
> from
)
373 if (! m
->insertion_type
)
374 /* Normal markers will end up at the beginning of the
375 re-inserted text after undoing a deletion, and must be
376 adjusted to move them to the correct place. */
377 record_marker_adjustment (marker
, from
- charpos
);
378 else if (charpos
< to
)
379 /* Before-insertion markers will automatically move forward
380 upon re-inserting the deleted text, so we have to arrange
381 for them to move backward to the correct position. */
382 record_marker_adjustment (marker
, charpos
- to
);
385 m
->bytepos
= from_byte
;
387 /* Here's the case where a before-insertion marker is immediately
388 before the deleted region. */
389 else if (charpos
== from
&& m
->insertion_type
)
391 /* Undoing the change uses normal insertion, which will
392 incorrectly make MARKER move forward, so we arrange for it
393 to then move backward to the correct place at the beginning
394 of the deleted region. */
395 record_marker_adjustment (marker
, to
- from
);
403 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
404 to TO / TO_BYTE. We have to relocate the charpos of every marker
405 that points after the insertion (but not their bytepos).
407 When a marker points at the insertion point,
408 we advance it if either its insertion-type is t
409 or BEFORE_MARKERS is true. */
412 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
413 register int from
, from_byte
, to
, to_byte
;
418 int nchars
= to
- from
;
419 int nbytes
= to_byte
- from_byte
;
421 marker
= BUF_MARKERS (current_buffer
);
423 while (!NILP (marker
))
425 register struct Lisp_Marker
*m
= XMARKER (marker
);
427 /* In a single-byte buffer, a marker's two positions must be
431 if (m
->charpos
!= m
->bytepos
)
435 if (m
->bytepos
== from_byte
)
437 if (m
->insertion_type
|| before_markers
)
439 m
->bytepos
= to_byte
;
441 if (m
->insertion_type
)
445 else if (m
->bytepos
> from_byte
)
447 m
->bytepos
+= nbytes
;
448 m
->charpos
+= nchars
;
454 /* Adjusting only markers whose insertion-type is t may result in
455 disordered overlays in the slot `overlays_before'. */
457 fix_overlays_before (current_buffer
, from
, to
);
460 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
462 This is used only when the value of point changes due to an insert
463 or delete; it does not represent a conceptual change in point as a
464 marker. In particular, point is not crossing any interval
465 boundaries, so there's no need to use the usual SET_PT macro. In
466 fact it would be incorrect to do so, because either the old or the
467 new value of point is out of sync with the current set of
471 adjust_point (nchars
, nbytes
)
474 BUF_PT (current_buffer
) += nchars
;
475 BUF_PT_BYTE (current_buffer
) += nbytes
;
477 /* In a single-byte buffer, the two positions must be equal. */
483 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
484 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
485 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
489 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
490 new_chars
, new_bytes
)
491 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
493 Lisp_Object marker
= BUF_MARKERS (current_buffer
);
494 int prev_to_byte
= from_byte
+ old_bytes
;
495 int diff_chars
= new_chars
- old_chars
;
496 int diff_bytes
= new_bytes
- old_bytes
;
498 while (!NILP (marker
))
500 register struct Lisp_Marker
*m
= XMARKER (marker
);
502 if (m
->bytepos
>= prev_to_byte
)
504 m
->charpos
+= diff_chars
;
505 m
->bytepos
+= diff_bytes
;
507 else if (m
->bytepos
> from_byte
)
510 m
->bytepos
= from_byte
;
520 /* Make the gap NBYTES_ADDED bytes longer. */
523 make_gap_larger (nbytes_added
)
528 int real_gap_loc_byte
;
531 /* If we have to get more space, get enough to last a while. */
532 nbytes_added
+= 2000;
534 /* Don't allow a buffer size that won't fit in an int
535 even if it will fit in a Lisp integer.
536 That won't work because so many places use `int'.
538 Make sure we don't introduce overflows in the calculation. */
540 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
541 >= (((EMACS_INT
) 1 << (min (VALBITS
, BITS_PER_INT
) - 1)) - 1
543 error ("Buffer exceeds maximum size");
545 enlarge_buffer_text (current_buffer
, nbytes_added
);
547 /* Prevent quitting in move_gap. */
552 real_gap_loc_byte
= GPT_BYTE
;
553 old_gap_size
= GAP_SIZE
;
555 /* Call the newly allocated space a gap at the end of the whole space. */
557 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
558 GAP_SIZE
= nbytes_added
;
560 /* Move the new gap down to be consecutive with the end of the old one.
561 This adjusts the markers properly too. */
562 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
564 /* Now combine the two into one large gap. */
565 GAP_SIZE
+= old_gap_size
;
567 GPT_BYTE
= real_gap_loc_byte
;
576 /* Make the gap NBYTES_REMOVED bytes shorted. */
579 make_gap_smaller (nbytes_removed
)
584 int real_gap_loc_byte
;
587 int real_beg_unchanged
;
590 /* Make sure the gap is at least 20 bytes. */
591 if (GAP_SIZE
- nbytes_removed
< 20)
592 nbytes_removed
= GAP_SIZE
- 20;
594 /* Prevent quitting in move_gap. */
599 real_gap_loc_byte
= GPT_BYTE
;
600 new_gap_size
= GAP_SIZE
- nbytes_removed
;
602 real_Z_byte
= Z_BYTE
;
603 real_beg_unchanged
= BEG_UNCHANGED
;
605 /* Pretend that the last unwanted part of the gap is the entire gap,
606 and that the first desired part of the gap is part of the buffer
608 bzero (GPT_ADDR
, new_gap_size
);
610 GPT_BYTE
+= new_gap_size
;
612 Z_BYTE
+= new_gap_size
;
613 GAP_SIZE
= nbytes_removed
;
615 /* Move the unwanted pretend gap to the end of the buffer. This
616 adjusts the markers properly too. */
617 gap_right (Z
, Z_BYTE
);
619 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
621 /* Now restore the desired gap. */
622 GAP_SIZE
= new_gap_size
;
624 GPT_BYTE
= real_gap_loc_byte
;
626 Z_BYTE
= real_Z_byte
;
627 BEG_UNCHANGED
= real_beg_unchanged
;
636 make_gap (nbytes_added
)
639 if (nbytes_added
>= 0)
640 make_gap_larger (nbytes_added
);
641 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
643 make_gap_smaller (-nbytes_added
);
647 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
648 FROM_MULTIBYTE says whether the incoming text is multibyte.
649 TO_MULTIBYTE says whether to store the text as multibyte.
650 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
652 Return the number of bytes stored at TO_ADDR. */
655 copy_text (from_addr
, to_addr
, nbytes
,
656 from_multibyte
, to_multibyte
)
657 unsigned char *from_addr
;
658 unsigned char *to_addr
;
660 int from_multibyte
, to_multibyte
;
662 if (from_multibyte
== to_multibyte
)
664 bcopy (from_addr
, to_addr
, nbytes
);
667 else if (from_multibyte
)
670 int bytes_left
= nbytes
;
671 Lisp_Object tbl
= Qnil
;
673 while (bytes_left
> 0)
676 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
677 if (!ASCII_CHAR_P (c
))
678 c
= multibyte_char_to_unibyte (c
, tbl
);
680 from_addr
+= thislen
;
681 bytes_left
-= thislen
;
688 unsigned char *initial_to_addr
= to_addr
;
690 /* Convert single-byte to multibyte. */
693 int c
= *from_addr
++;
697 c
= unibyte_char_to_multibyte (c
);
698 to_addr
+= CHAR_STRING (c
, to_addr
);
702 /* Special case for speed. */
703 *to_addr
++ = c
, nbytes
--;
705 return to_addr
- initial_to_addr
;
709 /* Return the number of bytes it would take
710 to convert some single-byte text to multibyte.
711 The single-byte text consists of NBYTES bytes at PTR. */
714 count_size_as_multibyte (ptr
, nbytes
)
719 int outgoing_nbytes
= 0;
721 for (i
= 0; i
< nbytes
; i
++)
723 unsigned int c
= *ptr
++;
729 c
= unibyte_char_to_multibyte (c
);
730 outgoing_nbytes
+= CHAR_BYTES (c
);
734 return outgoing_nbytes
;
737 /* Insert a string of specified length before point.
738 This function judges multibyteness based on
739 enable_multibyte_characters in the current buffer;
740 it never converts between single-byte and multibyte.
742 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
743 prepare_to_modify_buffer could relocate the text. */
746 insert (string
, nbytes
)
747 register unsigned char *string
;
753 insert_1 (string
, nbytes
, 0, 1, 0);
754 signal_after_change (opoint
, 0, PT
- opoint
);
755 update_compositions (opoint
, PT
, CHECK_BORDER
);
759 /* Likewise, but inherit text properties from neighboring characters. */
762 insert_and_inherit (string
, nbytes
)
763 register unsigned char *string
;
769 insert_1 (string
, nbytes
, 1, 1, 0);
770 signal_after_change (opoint
, 0, PT
- opoint
);
771 update_compositions (opoint
, PT
, CHECK_BORDER
);
775 /* Insert the character C before point. Do not inherit text properties. */
781 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
784 if (! NILP (current_buffer
->enable_multibyte_characters
))
785 len
= CHAR_STRING (c
, str
);
795 /* Insert the null-terminated string S before point. */
801 insert (s
, strlen (s
));
804 /* Like `insert' except that all markers pointing at the place where
805 the insertion happens are adjusted to point after it.
806 Don't use this function to insert part of a Lisp string,
807 since gc could happen and relocate it. */
810 insert_before_markers (string
, nbytes
)
811 unsigned char *string
;
818 insert_1 (string
, nbytes
, 0, 1, 1);
819 signal_after_change (opoint
, 0, PT
- opoint
);
820 update_compositions (opoint
, PT
, CHECK_BORDER
);
824 /* Likewise, but inherit text properties from neighboring characters. */
827 insert_before_markers_and_inherit (string
, nbytes
)
828 unsigned char *string
;
835 insert_1 (string
, nbytes
, 1, 1, 1);
836 signal_after_change (opoint
, 0, PT
- opoint
);
837 update_compositions (opoint
, PT
, CHECK_BORDER
);
841 /* Subroutine used by the insert functions above. */
844 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
845 register unsigned char *string
;
847 int inherit
, prepare
, before_markers
;
849 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
850 inherit
, prepare
, before_markers
);
854 #ifdef BYTE_COMBINING_DEBUG
856 /* See if the bytes before POS/POS_BYTE combine with bytes
857 at the start of STRING to form a single character.
858 If so, return the number of bytes at the start of STRING
859 which combine in this way. Otherwise, return 0. */
862 count_combining_before (string
, length
, pos
, pos_byte
)
863 unsigned char *string
;
867 int len
, combining_bytes
;
870 if (NILP (current_buffer
->enable_multibyte_characters
))
873 /* At first, we can exclude the following cases:
874 (1) STRING[0] can't be a following byte of multibyte sequence.
875 (2) POS is the start of the current buffer.
876 (3) A character before POS is not a multibyte character. */
877 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
879 if (pos_byte
== BEG_BYTE
) /* case (2) */
882 p
= BYTE_POS_ADDR (pos_byte
- 1);
883 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
884 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
887 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
888 if (combining_bytes
<= 0)
889 /* The character preceding POS is, complete and no room for
890 combining bytes (combining_bytes == 0), or an independent 8-bit
891 character (combining_bytes < 0). */
894 /* We have a combination situation. Count the bytes at STRING that
897 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
900 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
903 /* See if the bytes after POS/POS_BYTE combine with bytes
904 at the end of STRING to form a single character.
905 If so, return the number of bytes after POS/POS_BYTE
906 which combine in this way. Otherwise, return 0. */
909 count_combining_after (string
, length
, pos
, pos_byte
)
910 unsigned char *string
;
914 int opos_byte
= pos_byte
;
919 if (NILP (current_buffer
->enable_multibyte_characters
))
922 /* At first, we can exclude the following cases:
923 (1) The last byte of STRING is an ASCII.
924 (2) POS is the last of the current buffer.
925 (3) A character at POS can't be a following byte of multibyte
927 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
929 if (pos_byte
== Z_BYTE
) /* case (2) */
931 bufp
= BYTE_POS_ADDR (pos_byte
);
932 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
936 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
942 /* All characters in STRING are not character head. We must
943 check also preceding bytes at POS. We are sure that the gap
945 unsigned char *p
= BEG_ADDR
;
947 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
949 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
952 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
953 return (bytes
<= pos_byte
- 1 - i
+ length
955 : bytes
- (pos_byte
- 1 - i
+ length
));
957 if (!BASE_LEADING_CODE_P (string
[i
]))
960 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
962 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
964 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
970 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
971 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
972 are the same as in insert_1. */
975 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
976 register unsigned char *string
;
977 register int nchars
, nbytes
;
978 int inherit
, prepare
, before_markers
;
983 if (NILP (current_buffer
->enable_multibyte_characters
))
987 /* Do this before moving and increasing the gap,
988 because the before-change hooks might move the gap
989 or make it smaller. */
990 prepare_to_modify_buffer (PT
, PT
, NULL
);
993 move_gap_both (PT
, PT_BYTE
);
994 if (GAP_SIZE
< nbytes
)
995 make_gap (nbytes
- GAP_SIZE
);
997 #ifdef BYTE_COMBINING_DEBUG
998 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
999 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
1003 /* Record deletion of the surrounding text that combines with
1004 the insertion. This, together with recording the insertion,
1005 will add up to the right stuff in the undo list. */
1006 record_insert (PT
, nchars
);
1009 bcopy (string
, GPT_ADDR
, nbytes
);
1018 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1023 adjust_overlays_for_insert (PT
, nchars
);
1024 adjust_markers_for_insert (PT
, PT_BYTE
,
1025 PT
+ nchars
, PT_BYTE
+ nbytes
,
1028 if (BUF_INTERVALS (current_buffer
) != 0)
1029 offset_intervals (current_buffer
, PT
, nchars
);
1031 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1032 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1035 adjust_point (nchars
, nbytes
);
1040 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1041 starting at GPT_ADDR. */
1044 insert_from_gap (nchars
, nbytes
)
1045 register int nchars
, nbytes
;
1047 if (NILP (current_buffer
->enable_multibyte_characters
))
1050 record_insert (GPT
, nchars
);
1060 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1065 adjust_overlays_for_insert (GPT
, nchars
);
1066 adjust_markers_for_insert (GPT
, GPT_BYTE
,
1067 GPT
+ nchars
, GPT_BYTE
+ nbytes
,
1070 if (BUF_INTERVALS (current_buffer
) != 0)
1071 offset_intervals (current_buffer
, GPT
, nchars
);
1073 if (GPT
- nchars
< PT
)
1074 adjust_point (nchars
, nbytes
);
1079 /* Insert the part of the text of STRING, a Lisp object assumed to be
1080 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1081 starting at position POS / POS_BYTE. If the text of STRING has properties,
1082 copy them into the buffer.
1084 It does not work to use `insert' for this, because a GC could happen
1085 before we bcopy the stuff into the buffer, and relocate the string
1086 without insert noticing. */
1089 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1091 register int pos
, pos_byte
, length
, length_byte
;
1095 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1097 signal_after_change (opoint
, 0, PT
- opoint
);
1098 update_compositions (opoint
, PT
, CHECK_BORDER
);
1101 /* Like `insert_from_string' except that all markers pointing
1102 at the place where the insertion happens are adjusted to point after it. */
1105 insert_from_string_before_markers (string
, pos
, pos_byte
,
1106 length
, length_byte
, inherit
)
1108 register int pos
, pos_byte
, length
, length_byte
;
1112 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1114 signal_after_change (opoint
, 0, PT
- opoint
);
1115 update_compositions (opoint
, PT
, CHECK_BORDER
);
1118 /* Subroutine of the insertion functions above. */
1121 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1122 inherit
, before_markers
)
1124 register int pos
, pos_byte
, nchars
, nbytes
;
1125 int inherit
, before_markers
;
1127 struct gcpro gcpro1
;
1128 int outgoing_nbytes
= nbytes
;
1131 /* Make OUTGOING_NBYTES describe the text
1132 as it will be inserted in this buffer. */
1134 if (NILP (current_buffer
->enable_multibyte_characters
))
1135 outgoing_nbytes
= nchars
;
1136 else if (! STRING_MULTIBYTE (string
))
1138 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1142 /* Do this before moving and increasing the gap,
1143 because the before-change hooks might move the gap
1144 or make it smaller. */
1145 prepare_to_modify_buffer (PT
, PT
, NULL
);
1148 move_gap_both (PT
, PT_BYTE
);
1149 if (GAP_SIZE
< outgoing_nbytes
)
1150 make_gap (outgoing_nbytes
- GAP_SIZE
);
1153 /* Copy the string text into the buffer, perhaps converting
1154 between single-byte and multibyte. */
1155 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1156 STRING_MULTIBYTE (string
),
1157 ! NILP (current_buffer
->enable_multibyte_characters
));
1159 #ifdef BYTE_COMBINING_DEBUG
1160 /* We have copied text into the gap, but we have not altered
1161 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1162 to these functions and get the same results as we would
1163 have got earlier on. Meanwhile, PT_ADDR does point to
1164 the text that has been stored by copy_text. */
1165 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1166 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1170 record_insert (PT
, nchars
);
1173 GAP_SIZE
-= outgoing_nbytes
;
1177 GPT_BYTE
+= outgoing_nbytes
;
1178 ZV_BYTE
+= outgoing_nbytes
;
1179 Z_BYTE
+= outgoing_nbytes
;
1180 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1185 adjust_overlays_for_insert (PT
, nchars
);
1186 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1187 PT_BYTE
+ outgoing_nbytes
,
1190 offset_intervals (current_buffer
, PT
, nchars
);
1192 intervals
= XSTRING (string
)->intervals
;
1193 /* Get the intervals for the part of the string we are inserting. */
1194 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1195 intervals
= copy_intervals (intervals
, pos
, nchars
);
1197 /* Insert those intervals. */
1198 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1199 current_buffer
, inherit
);
1201 adjust_point (nchars
, outgoing_nbytes
);
1204 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1205 current buffer. If the text in BUF has properties, they are absorbed
1206 into the current buffer.
1208 It does not work to use `insert' for this, because a malloc could happen
1209 and relocate BUF's text before the bcopy happens. */
1212 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1214 int charpos
, nchars
;
1219 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1220 signal_after_change (opoint
, 0, PT
- opoint
);
1221 update_compositions (opoint
, PT
, CHECK_BORDER
);
1225 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1230 register Lisp_Object temp
;
1231 int chunk
, chunk_expanded
;
1232 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1233 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1234 int incoming_nbytes
= to_byte
- from_byte
;
1235 int outgoing_nbytes
= incoming_nbytes
;
1238 /* Make OUTGOING_NBYTES describe the text
1239 as it will be inserted in this buffer. */
1241 if (NILP (current_buffer
->enable_multibyte_characters
))
1242 outgoing_nbytes
= nchars
;
1243 else if (NILP (buf
->enable_multibyte_characters
))
1245 int outgoing_before_gap
= 0;
1246 int outgoing_after_gap
= 0;
1248 if (from
< BUF_GPT (buf
))
1250 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1251 if (chunk
> incoming_nbytes
)
1252 chunk
= incoming_nbytes
;
1254 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1260 if (chunk
< incoming_nbytes
)
1262 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1264 incoming_nbytes
- chunk
);
1266 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1269 /* Make sure point-max won't overflow after this insertion. */
1270 XSETINT (temp
, outgoing_nbytes
+ Z
);
1271 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1272 error ("Maximum buffer size exceeded");
1274 /* Do this before moving and increasing the gap,
1275 because the before-change hooks might move the gap
1276 or make it smaller. */
1277 prepare_to_modify_buffer (PT
, PT
, NULL
);
1280 move_gap_both (PT
, PT_BYTE
);
1281 if (GAP_SIZE
< outgoing_nbytes
)
1282 make_gap (outgoing_nbytes
- GAP_SIZE
);
1284 if (from
< BUF_GPT (buf
))
1286 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1287 if (chunk
> incoming_nbytes
)
1288 chunk
= incoming_nbytes
;
1289 /* Record number of output bytes, so we know where
1290 to put the output from the second copy_text. */
1292 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1294 ! NILP (buf
->enable_multibyte_characters
),
1295 ! NILP (current_buffer
->enable_multibyte_characters
));
1298 chunk_expanded
= chunk
= 0;
1300 if (chunk
< incoming_nbytes
)
1301 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1302 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1303 ! NILP (buf
->enable_multibyte_characters
),
1304 ! NILP (current_buffer
->enable_multibyte_characters
));
1306 #ifdef BYTE_COMBINING_DEBUG
1307 /* We have copied text into the gap, but we have not altered
1308 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1309 to these functions and get the same results as we would
1310 have got earlier on. Meanwhile, GPT_ADDR does point to
1311 the text that has been stored by copy_text. */
1312 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1313 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1317 record_insert (PT
, nchars
);
1320 GAP_SIZE
-= outgoing_nbytes
;
1324 GPT_BYTE
+= outgoing_nbytes
;
1325 ZV_BYTE
+= outgoing_nbytes
;
1326 Z_BYTE
+= outgoing_nbytes
;
1327 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1332 adjust_overlays_for_insert (PT
, nchars
);
1333 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1334 PT_BYTE
+ outgoing_nbytes
,
1337 if (BUF_INTERVALS (current_buffer
) != 0)
1338 offset_intervals (current_buffer
, PT
, nchars
);
1340 /* Get the intervals for the part of the string we are inserting. */
1341 intervals
= BUF_INTERVALS (buf
);
1342 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1344 if (buf
== current_buffer
&& PT
<= from
)
1346 intervals
= copy_intervals (intervals
, from
, nchars
);
1349 /* Insert those intervals. */
1350 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1352 adjust_point (nchars
, outgoing_nbytes
);
1355 /* Record undo information and adjust markers and position keepers for
1356 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1357 chars (LEN_BYTE bytes) which resides in the gap just after
1360 PREV_TEXT nil means the new text was just inserted. */
1363 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1364 int from
, from_byte
, len
, len_byte
;
1365 Lisp_Object prev_text
;
1367 int nchars_del
= 0, nbytes_del
= 0;
1369 #ifdef BYTE_COMBINING_DEBUG
1370 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1371 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1375 if (STRINGP (prev_text
))
1377 nchars_del
= XSTRING (prev_text
)->size
;
1378 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1381 /* Update various buffer positions for the new text. */
1382 GAP_SIZE
-= len_byte
;
1384 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1385 GPT
+= len
; GPT_BYTE
+= len_byte
;
1386 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1389 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1392 adjust_markers_for_insert (from
, from_byte
,
1393 from
+ len
, from_byte
+ len_byte
, 0);
1395 if (! EQ (current_buffer
->undo_list
, Qt
))
1398 record_delete (from
, prev_text
);
1399 record_insert (from
, len
);
1402 if (len
> nchars_del
)
1403 adjust_overlays_for_insert (from
, len
- nchars_del
);
1404 else if (len
< nchars_del
)
1405 adjust_overlays_for_delete (from
, nchars_del
- len
);
1406 if (BUF_INTERVALS (current_buffer
) != 0)
1408 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1412 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1414 /* As byte combining will decrease Z, we must check this again. */
1415 if (Z
- GPT
< END_UNCHANGED
)
1416 END_UNCHANGED
= Z
- GPT
;
1421 evaporate_overlays (from
);
1425 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1426 This is for use when undo is not enabled in the current buffer. */
1429 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1430 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1432 #ifdef BYTE_COMBINING_DEBUG
1433 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1434 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1438 /* Update various buffer positions for the new text. */
1439 GAP_SIZE
-= len_byte
;
1441 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1442 GPT
+= len
; GPT_BYTE
+= len_byte
;
1443 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1446 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1449 adjust_markers_for_insert (from
, from_byte
,
1450 from
+ len
, from_byte
+ len_byte
, 0);
1452 if (len
> nchars_del
)
1453 adjust_overlays_for_insert (from
, len
- nchars_del
);
1454 else if (len
< nchars_del
)
1455 adjust_overlays_for_delete (from
, nchars_del
- len
);
1456 if (BUF_INTERVALS (current_buffer
) != 0)
1458 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1462 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1464 /* As byte combining will decrease Z, we must check this again. */
1465 if (Z
- GPT
< END_UNCHANGED
)
1466 END_UNCHANGED
= Z
- GPT
;
1471 evaporate_overlays (from
);
1475 /* Record undo information, adjust markers and position keepers for an
1476 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1477 text already exists in the current buffer but character length (TO
1478 - FROM) may be incorrect, the correct length is NEWLEN. */
1481 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1482 int from
, from_byte
, to
, to_byte
, newlen
;
1484 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1487 move_gap_both (to
, to_byte
);
1488 GAP_SIZE
+= len_byte
;
1489 GPT
-= len
; GPT_BYTE
-= len_byte
;
1490 ZV
-= len
; ZV_BYTE
-= len_byte
;
1491 Z
-= len
; Z_BYTE
-= len_byte
;
1492 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1495 /* Replace the text from character positions FROM to TO with NEW,
1496 If PREPARE is nonzero, call prepare_to_modify_buffer.
1497 If INHERIT, the newly inserted text should inherit text properties
1498 from the surrounding non-deleted text. */
1500 /* Note that this does not yet handle markers quite right.
1501 Also it needs to record a single undo-entry that does a replacement
1502 rather than a separate delete and insert.
1503 That way, undo will also handle markers properly.
1505 But if MARKERS is 0, don't relocate markers. */
1508 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1510 int from
, to
, prepare
, inherit
, markers
;
1512 int inschars
= XSTRING (new)->size
;
1513 int insbytes
= STRING_BYTES (XSTRING (new));
1514 int from_byte
, to_byte
;
1515 int nbytes_del
, nchars_del
;
1516 register Lisp_Object temp
;
1517 struct gcpro gcpro1
;
1519 int outgoing_insbytes
= insbytes
;
1520 Lisp_Object deletion
;
1529 int range_length
= to
- from
;
1530 prepare_to_modify_buffer (from
, to
, &from
);
1531 to
= from
+ range_length
;
1536 /* Make args be valid */
1542 from_byte
= CHAR_TO_BYTE (from
);
1543 to_byte
= CHAR_TO_BYTE (to
);
1545 nchars_del
= to
- from
;
1546 nbytes_del
= to_byte
- from_byte
;
1548 if (nbytes_del
<= 0 && insbytes
== 0)
1551 /* Make OUTGOING_INSBYTES describe the text
1552 as it will be inserted in this buffer. */
1554 if (NILP (current_buffer
->enable_multibyte_characters
))
1555 outgoing_insbytes
= inschars
;
1556 else if (! STRING_MULTIBYTE (new))
1558 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1560 /* Make sure point-max won't overflow after this insertion. */
1561 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1562 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1563 error ("Maximum buffer size exceeded");
1567 /* Make sure the gap is somewhere in or next to what we are deleting. */
1569 gap_right (from
, from_byte
);
1571 gap_left (to
, to_byte
, 0);
1573 /* Even if we don't record for undo, we must keep the original text
1574 because we may have to recover it because of inappropriate byte
1576 if (! EQ (current_buffer
->undo_list
, Qt
))
1577 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1579 GAP_SIZE
+= nbytes_del
;
1582 ZV_BYTE
-= nbytes_del
;
1583 Z_BYTE
-= nbytes_del
;
1585 GPT_BYTE
= from_byte
;
1586 *(GPT_ADDR
) = 0; /* Put an anchor. */
1591 if (GPT
- BEG
< BEG_UNCHANGED
)
1592 BEG_UNCHANGED
= GPT
- BEG
;
1593 if (Z
- GPT
< END_UNCHANGED
)
1594 END_UNCHANGED
= Z
- GPT
;
1596 if (GAP_SIZE
< insbytes
)
1597 make_gap (insbytes
- GAP_SIZE
);
1599 /* Copy the string text into the buffer, perhaps converting
1600 between single-byte and multibyte. */
1601 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1602 STRING_MULTIBYTE (new),
1603 ! NILP (current_buffer
->enable_multibyte_characters
));
1605 #ifdef BYTE_COMBINING_DEBUG
1606 /* We have copied text into the gap, but we have not marked
1607 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1608 here, for both the previous text and the following text.
1609 Meanwhile, GPT_ADDR does point to
1610 the text that has been stored by copy_text. */
1611 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1612 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1616 if (! EQ (current_buffer
->undo_list
, Qt
))
1618 record_delete (from
, deletion
);
1619 record_insert (from
, inschars
);
1622 GAP_SIZE
-= outgoing_insbytes
;
1626 GPT_BYTE
+= outgoing_insbytes
;
1627 ZV_BYTE
+= outgoing_insbytes
;
1628 Z_BYTE
+= outgoing_insbytes
;
1629 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1634 /* Adjust the overlay center as needed. This must be done after
1635 adjusting the markers that bound the overlays. */
1636 adjust_overlays_for_delete (from
, nchars_del
);
1637 adjust_overlays_for_insert (from
, inschars
);
1639 /* Adjust markers for the deletion and the insertion. */
1641 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1642 inschars
, outgoing_insbytes
);
1644 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1646 /* Get the intervals for the part of the string we are inserting--
1647 not including the combined-before bytes. */
1648 intervals
= XSTRING (new)->intervals
;
1649 /* Insert those intervals. */
1650 graft_intervals_into_buffer (intervals
, from
, inschars
,
1651 current_buffer
, inherit
);
1653 /* Relocate point as if it were a marker. */
1655 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1656 (from_byte
+ outgoing_insbytes
1657 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1659 if (outgoing_insbytes
== 0)
1660 evaporate_overlays (from
);
1667 signal_after_change (from
, nchars_del
, GPT
- from
);
1668 update_compositions (from
, GPT
, CHECK_BORDER
);
1671 /* Delete characters in current buffer
1672 from FROM up to (but not including) TO.
1673 If TO comes before FROM, we delete nothing. */
1676 del_range (from
, to
)
1677 register int from
, to
;
1679 del_range_1 (from
, to
, 1, 0);
1682 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1683 RET_STRING says to return the deleted text. */
1686 del_range_1 (from
, to
, prepare
, ret_string
)
1687 int from
, to
, prepare
, ret_string
;
1689 int from_byte
, to_byte
;
1690 Lisp_Object deletion
;
1691 struct gcpro gcpro1
;
1693 /* Make args be valid */
1704 int range_length
= to
- from
;
1705 prepare_to_modify_buffer (from
, to
, &from
);
1706 to
= min (ZV
, from
+ range_length
);
1709 from_byte
= CHAR_TO_BYTE (from
);
1710 to_byte
= CHAR_TO_BYTE (to
);
1712 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1714 signal_after_change (from
, to
- from
, 0);
1715 update_compositions (from
, from
, CHECK_HEAD
);
1720 /* Like del_range_1 but args are byte positions, not char positions. */
1723 del_range_byte (from_byte
, to_byte
, prepare
)
1724 int from_byte
, to_byte
, prepare
;
1728 /* Make args be valid */
1729 if (from_byte
< BEGV_BYTE
)
1730 from_byte
= BEGV_BYTE
;
1731 if (to_byte
> ZV_BYTE
)
1734 if (to_byte
<= from_byte
)
1737 from
= BYTE_TO_CHAR (from_byte
);
1738 to
= BYTE_TO_CHAR (to_byte
);
1742 int old_from
= from
, old_to
= Z
- to
;
1743 int range_length
= to
- from
;
1744 prepare_to_modify_buffer (from
, to
, &from
);
1745 to
= from
+ range_length
;
1747 if (old_from
!= from
)
1748 from_byte
= CHAR_TO_BYTE (from
);
1754 else if (old_to
== Z
- to
)
1755 to_byte
= CHAR_TO_BYTE (to
);
1758 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1759 signal_after_change (from
, to
- from
, 0);
1760 update_compositions (from
, from
, CHECK_HEAD
);
1763 /* Like del_range_1, but positions are specified both as charpos
1767 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1768 int from
, from_byte
, to
, to_byte
, prepare
;
1770 /* Make args be valid */
1771 if (from_byte
< BEGV_BYTE
)
1772 from_byte
= BEGV_BYTE
;
1773 if (to_byte
> ZV_BYTE
)
1776 if (to_byte
<= from_byte
)
1786 int old_from
= from
, old_to
= Z
- to
;
1787 int range_length
= to
- from
;
1788 prepare_to_modify_buffer (from
, to
, &from
);
1789 to
= from
+ range_length
;
1791 if (old_from
!= from
)
1792 from_byte
= CHAR_TO_BYTE (from
);
1798 else if (old_to
== Z
- to
)
1799 to_byte
= CHAR_TO_BYTE (to
);
1802 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1803 signal_after_change (from
, to
- from
, 0);
1804 update_compositions (from
, from
, CHECK_HEAD
);
1807 /* Delete a range of text, specified both as character positions
1808 and byte positions. FROM and TO are character positions,
1809 while FROM_BYTE and TO_BYTE are byte positions.
1810 If RET_STRING is true, the deleted area is returned as a string. */
1813 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1814 int from
, from_byte
, to
, to_byte
, ret_string
;
1816 register int nbytes_del
, nchars_del
;
1817 Lisp_Object deletion
;
1821 nchars_del
= to
- from
;
1822 nbytes_del
= to_byte
- from_byte
;
1824 /* Make sure the gap is somewhere in or next to what we are deleting. */
1826 gap_right (from
, from_byte
);
1828 gap_left (to
, to_byte
, 0);
1830 #ifdef BYTE_COMBINING_DEBUG
1831 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1832 Z_BYTE
- to_byte
, from
, from_byte
))
1836 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1837 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1841 /* Relocate all markers pointing into the new, larger gap
1842 to point at the end of the text before the gap.
1843 Do this before recording the deletion,
1844 so that undo handles this after reinserting the text. */
1845 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1847 if (! EQ (current_buffer
->undo_list
, Qt
))
1848 record_delete (from
, deletion
);
1851 /* Relocate point as if it were a marker. */
1853 adjust_point (from
- (PT
< to
? PT
: to
),
1854 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1856 offset_intervals (current_buffer
, from
, - nchars_del
);
1858 /* Adjust the overlay center as needed. This must be done after
1859 adjusting the markers that bound the overlays. */
1860 adjust_overlays_for_delete (from
, nchars_del
);
1862 GAP_SIZE
+= nbytes_del
;
1863 ZV_BYTE
-= nbytes_del
;
1864 Z_BYTE
-= nbytes_del
;
1868 GPT_BYTE
= from_byte
;
1869 *(GPT_ADDR
) = 0; /* Put an anchor. */
1874 if (GPT
- BEG
< BEG_UNCHANGED
)
1875 BEG_UNCHANGED
= GPT
- BEG
;
1876 if (Z
- GPT
< END_UNCHANGED
)
1877 END_UNCHANGED
= Z
- GPT
;
1881 evaporate_overlays (from
);
1886 /* Call this if you're about to change the region of BUFFER from
1887 character positions START to END. This checks the read-only
1888 properties of the region, calls the necessary modification hooks,
1889 and warns the next redisplay that it should pay attention to that
1893 modify_region (buffer
, start
, end
)
1894 struct buffer
*buffer
;
1897 struct buffer
*old_buffer
= current_buffer
;
1899 if (buffer
!= old_buffer
)
1900 set_buffer_internal (buffer
);
1902 prepare_to_modify_buffer (start
, end
, NULL
);
1904 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1906 if (MODIFF
<= SAVE_MODIFF
)
1907 record_first_change ();
1910 buffer
->point_before_scroll
= Qnil
;
1912 if (buffer
!= old_buffer
)
1913 set_buffer_internal (old_buffer
);
1916 /* Check that it is okay to modify the buffer between START and END,
1917 which are char positions.
1919 Run the before-change-function, if any. If intervals are in use,
1920 verify that the text to be modified is not read-only, and call
1921 any modification properties the text may have.
1923 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1924 by holding its value temporarily in a marker. */
1927 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1931 if (!NILP (current_buffer
->read_only
))
1932 Fbarf_if_buffer_read_only ();
1934 /* Let redisplay consider other windows than selected_window
1935 if modifying another buffer. */
1936 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1937 ++windows_or_buffers_changed
;
1939 if (BUF_INTERVALS (current_buffer
) != 0)
1943 Lisp_Object preserve_marker
;
1944 struct gcpro gcpro1
;
1945 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1946 GCPRO1 (preserve_marker
);
1947 verify_interval_modification (current_buffer
, start
, end
);
1948 *preserve_ptr
= marker_position (preserve_marker
);
1949 unchain_marker (preserve_marker
);
1953 verify_interval_modification (current_buffer
, start
, end
);
1956 #ifdef CLASH_DETECTION
1957 if (!NILP (current_buffer
->file_truename
)
1958 /* Make binding buffer-file-name to nil effective. */
1959 && !NILP (current_buffer
->filename
)
1960 && SAVE_MODIFF
>= MODIFF
)
1961 lock_file (current_buffer
->file_truename
);
1963 /* At least warn if this file has changed on disk since it was visited. */
1964 if (!NILP (current_buffer
->filename
)
1965 && SAVE_MODIFF
>= MODIFF
1966 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1967 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1968 call1 (intern ("ask-user-about-supersession-threat"),
1969 current_buffer
->filename
);
1970 #endif /* not CLASH_DETECTION */
1972 signal_before_change (start
, end
, preserve_ptr
);
1974 if (current_buffer
->newline_cache
)
1975 invalidate_region_cache (current_buffer
,
1976 current_buffer
->newline_cache
,
1977 start
- BEG
, Z
- end
);
1978 if (current_buffer
->width_run_cache
)
1979 invalidate_region_cache (current_buffer
,
1980 current_buffer
->width_run_cache
,
1981 start
- BEG
, Z
- end
);
1983 Vdeactivate_mark
= Qt
;
1986 /* These macros work with an argument named `preserve_ptr'
1987 and a local variable named `preserve_marker'. */
1989 #define PRESERVE_VALUE \
1990 if (preserve_ptr && NILP (preserve_marker)) \
1991 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1993 #define RESTORE_VALUE \
1994 if (! NILP (preserve_marker)) \
1996 *preserve_ptr = marker_position (preserve_marker); \
1997 unchain_marker (preserve_marker); \
2000 #define PRESERVE_START_END \
2001 if (NILP (start_marker)) \
2002 start_marker = Fcopy_marker (start, Qnil); \
2003 if (NILP (end_marker)) \
2004 end_marker = Fcopy_marker (end, Qnil);
2006 #define FETCH_START \
2007 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2010 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2012 /* Signal a change to the buffer immediately before it happens.
2013 START_INT and END_INT are the bounds of the text to be changed.
2015 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2016 by holding its value temporarily in a marker. */
2019 signal_before_change (start_int
, end_int
, preserve_ptr
)
2020 int start_int
, end_int
;
2023 Lisp_Object start
, end
;
2024 Lisp_Object start_marker
, end_marker
;
2025 Lisp_Object preserve_marker
;
2026 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2028 if (inhibit_modification_hooks
)
2031 start
= make_number (start_int
);
2032 end
= make_number (end_int
);
2033 preserve_marker
= Qnil
;
2034 start_marker
= Qnil
;
2036 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2038 /* If buffer is unmodified, run a special hook for that case. */
2039 if (SAVE_MODIFF
>= MODIFF
2040 && !NILP (Vfirst_change_hook
)
2041 && !NILP (Vrun_hooks
))
2045 call1 (Vrun_hooks
, Qfirst_change_hook
);
2048 /* Now run the before-change-functions if any. */
2049 if (!NILP (Vbefore_change_functions
))
2051 Lisp_Object args
[3];
2052 Lisp_Object before_change_functions
;
2053 Lisp_Object after_change_functions
;
2054 struct gcpro gcpro1
, gcpro2
;
2055 struct buffer
*old
= current_buffer
;
2061 /* "Bind" before-change-functions and after-change-functions
2062 to nil--but in a way that errors don't know about.
2063 That way, if there's an error in them, they will stay nil. */
2064 before_change_functions
= Vbefore_change_functions
;
2065 after_change_functions
= Vafter_change_functions
;
2066 Vbefore_change_functions
= Qnil
;
2067 Vafter_change_functions
= Qnil
;
2068 GCPRO2 (before_change_functions
, after_change_functions
);
2070 /* Actually run the hook functions. */
2071 args
[0] = Qbefore_change_functions
;
2072 args
[1] = FETCH_START
;
2073 args
[2] = FETCH_END
;
2074 run_hook_list_with_args (before_change_functions
, 3, args
);
2076 /* "Unbind" the variables we "bound" to nil. Beware a
2077 buffer-local hook which changes the buffer when run (e.g. W3). */
2078 if (old
!= current_buffer
)
2080 new = current_buffer
;
2081 set_buffer_internal (old
);
2082 Vbefore_change_functions
= before_change_functions
;
2083 Vafter_change_functions
= after_change_functions
;
2084 set_buffer_internal (new);
2088 Vbefore_change_functions
= before_change_functions
;
2089 Vafter_change_functions
= after_change_functions
;
2094 if (!NILP (current_buffer
->overlays_before
)
2095 || !NILP (current_buffer
->overlays_after
))
2098 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2099 FETCH_START
, FETCH_END
, Qnil
);
2102 if (! NILP (start_marker
))
2103 free_marker (start_marker
);
2104 if (! NILP (end_marker
))
2105 free_marker (end_marker
);
2110 /* Signal a change immediately after it happens.
2111 CHARPOS is the character position of the start of the changed text.
2112 LENDEL is the number of characters of the text before the change.
2113 (Not the whole buffer; just the part that was changed.)
2114 LENINS is the number of characters in that part of the text
2115 after the change. */
2118 signal_after_change (charpos
, lendel
, lenins
)
2119 int charpos
, lendel
, lenins
;
2121 if (inhibit_modification_hooks
)
2124 /* If we are deferring calls to the after-change functions
2125 and there are no before-change functions,
2126 just record the args that we were going to use. */
2127 if (! NILP (Vcombine_after_change_calls
)
2128 && NILP (Vbefore_change_functions
)
2129 && NILP (current_buffer
->overlays_before
)
2130 && NILP (current_buffer
->overlays_after
))
2134 if (!NILP (combine_after_change_list
)
2135 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2136 Fcombine_after_change_execute ();
2138 elt
= Fcons (make_number (charpos
- BEG
),
2139 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2140 Fcons (make_number (lenins
- lendel
), Qnil
)));
2141 combine_after_change_list
2142 = Fcons (elt
, combine_after_change_list
);
2143 combine_after_change_buffer
= Fcurrent_buffer ();
2148 if (!NILP (combine_after_change_list
))
2149 Fcombine_after_change_execute ();
2151 if (!NILP (Vafter_change_functions
))
2153 Lisp_Object args
[4];
2154 Lisp_Object before_change_functions
;
2155 Lisp_Object after_change_functions
;
2156 struct buffer
*old
= current_buffer
;
2158 struct gcpro gcpro1
, gcpro2
;
2160 /* "Bind" before-change-functions and after-change-functions
2161 to nil--but in a way that errors don't know about.
2162 That way, if there's an error in them, they will stay nil. */
2163 before_change_functions
= Vbefore_change_functions
;
2164 after_change_functions
= Vafter_change_functions
;
2165 Vbefore_change_functions
= Qnil
;
2166 Vafter_change_functions
= Qnil
;
2167 GCPRO2 (before_change_functions
, after_change_functions
);
2169 /* Actually run the hook functions. */
2170 args
[0] = Qafter_change_functions
;
2171 XSETFASTINT (args
[1], charpos
);
2172 XSETFASTINT (args
[2], charpos
+ lenins
);
2173 XSETFASTINT (args
[3], lendel
);
2174 run_hook_list_with_args (after_change_functions
,
2177 /* "Unbind" the variables we "bound" to nil. Beware a
2178 buffer-local hook which changes the buffer when run (e.g. W3). */
2179 if (old
!= current_buffer
)
2181 new = current_buffer
;
2182 set_buffer_internal (old
);
2183 Vbefore_change_functions
= before_change_functions
;
2184 Vafter_change_functions
= after_change_functions
;
2185 set_buffer_internal (new);
2189 Vbefore_change_functions
= before_change_functions
;
2190 Vafter_change_functions
= after_change_functions
;
2195 if (!NILP (current_buffer
->overlays_before
)
2196 || !NILP (current_buffer
->overlays_after
))
2197 report_overlay_modification (make_number (charpos
),
2198 make_number (charpos
+ lenins
),
2200 make_number (charpos
),
2201 make_number (charpos
+ lenins
),
2202 make_number (lendel
));
2204 /* After an insertion, call the text properties
2205 insert-behind-hooks or insert-in-front-hooks. */
2207 report_interval_modification (make_number (charpos
),
2208 make_number (charpos
+ lenins
));
2212 Fcombine_after_change_execute_1 (val
)
2215 Vcombine_after_change_calls
= val
;
2219 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2220 Scombine_after_change_execute
, 0, 0, 0,
2221 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2224 int count
= specpdl_ptr
- specpdl
;
2225 int beg
, end
, change
;
2229 if (NILP (combine_after_change_list
))
2232 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2234 Fset_buffer (combine_after_change_buffer
);
2236 /* # chars unchanged at beginning of buffer. */
2238 /* # chars unchanged at end of buffer. */
2240 /* Total amount of insertion (negative for deletion). */
2243 /* Scan the various individual changes,
2244 accumulating the range info in BEG, END and CHANGE. */
2245 for (tail
= combine_after_change_list
; CONSP (tail
);
2249 int thisbeg
, thisend
, thischange
;
2251 /* Extract the info from the next element. */
2255 thisbeg
= XINT (XCAR (elt
));
2260 thisend
= XINT (XCAR (elt
));
2265 thischange
= XINT (XCAR (elt
));
2267 /* Merge this range into the accumulated range. */
2268 change
+= thischange
;
2275 /* Get the current start and end positions of the range
2276 that was changed. */
2280 /* We are about to handle these, so discard them. */
2281 combine_after_change_list
= Qnil
;
2283 /* Now run the after-change functions for real.
2284 Turn off the flag that defers them. */
2285 record_unwind_protect (Fcombine_after_change_execute_1
,
2286 Vcombine_after_change_calls
);
2287 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2288 update_compositions (begpos
, endpos
, CHECK_ALL
);
2290 return unbind_to (count
, Qnil
);
2296 staticpro (&combine_after_change_list
);
2297 combine_after_change_list
= Qnil
;
2298 combine_after_change_buffer
= Qnil
;
2300 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2301 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2302 check_markers_debug_flag
= 0;
2303 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2304 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2305 Vcombine_after_change_calls
= Qnil
;
2307 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2308 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2309 This affects `before-change-functions' and `after-change-functions',
2310 as well as hooks attached to text properties and overlays. */);
2311 inhibit_modification_hooks
= 0;
2312 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2313 staticpro (&Qinhibit_modification_hooks
);
2315 defsubr (&Scombine_after_change_execute
);