1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000, 01, 2003
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 struct Lisp_Marker
*tail
;
83 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
85 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
87 if (tail
->buffer
->text
!= current_buffer
->text
)
89 if (tail
->charpos
> Z
)
91 if (tail
->bytepos
> Z_BYTE
)
93 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
98 /* Move gap to position CHARPOS.
99 Note that this can quit! */
105 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
108 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
109 Note that this can quit! */
112 move_gap_both (charpos
, bytepos
)
113 int charpos
, bytepos
;
115 if (bytepos
< GPT_BYTE
)
116 gap_left (charpos
, bytepos
, 0);
117 else if (bytepos
> GPT_BYTE
)
118 gap_right (charpos
, bytepos
);
121 /* Move the gap to a position less than the current GPT.
122 BYTEPOS describes the new position as a byte position,
123 and CHARPOS is the corresponding char position.
124 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
127 gap_left (charpos
, bytepos
, newgap
)
128 register int charpos
, bytepos
;
131 register unsigned char *to
, *from
;
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 /* bcopy is safe if the two areas of memory do not overlap
166 or on systems where bcopy is always safe for moving upward. */
167 && (BCOPY_UPWARD_SAFE
168 || to
- from
>= 128))
170 /* If overlap is not safe, avoid it by not moving too many
171 characters at once. */
172 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
187 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
188 BYTEPOS is where the loop above stopped, which may be what was specified
189 or may be where a quit was detected. */
190 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
193 if (bytepos
< charpos
)
195 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
199 /* Move the gap to a position greater than than the current GPT.
200 BYTEPOS describes the new position as a byte position,
201 and CHARPOS is the corresponding char position. */
204 gap_right (charpos
, bytepos
)
205 register int charpos
, bytepos
;
207 register unsigned char *to
, *from
;
211 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
218 /* Now copy the characters. To move the gap up,
219 copy characters down. */
223 /* I gets number of characters left to copy. */
224 i
= bytepos
- new_s1
;
227 /* If a quit is requested, stop copying now.
228 Change BYTEPOS to be where we have actually moved the gap to. */
232 charpos
= BYTE_TO_CHAR (bytepos
);
235 /* Move at most 32000 chars before checking again for a quit. */
240 /* bcopy is safe if the two areas of memory do not overlap
241 or on systems where bcopy is always safe for moving downward. */
242 && (BCOPY_DOWNWARD_SAFE
243 || from
- to
>= 128))
245 /* If overlap is not safe, avoid it by not moving too many
246 characters at once. */
247 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
262 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
266 if (bytepos
< charpos
)
268 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
272 /* Add AMOUNT to the byte position of every marker in the current buffer
273 whose current byte position is between FROM (exclusive) and TO (inclusive).
275 Also, any markers past the outside of that interval, in the direction
276 of adjustment, are first moved back to the near end of the interval
277 and then adjusted by AMOUNT.
279 When the latter adjustment is done, if AMOUNT is negative,
280 we record the adjustment for undo. (This case happens only for
283 The markers' character positions are not altered,
284 because gap motion does not affect character positions. */
286 int adjust_markers_test
;
289 adjust_markers_gap_motion (from
, to
, amount
)
290 register int from
, to
, amount
;
292 /* Now that a marker has a bytepos, not counting the gap,
293 nothing needs to be done here. */
296 register struct Lisp_Marker
*m
;
299 marker
= BUF_MARKERS (current_buffer
);
301 while (!NILP (marker
))
303 m
= XMARKER (marker
);
307 if (mpos
> to
&& mpos
< to
+ amount
)
309 if (adjust_markers_test
)
316 /* Here's the case where a marker is inside text being deleted.
317 AMOUNT can be negative for gap motion, too,
318 but then this range contains no markers. */
319 if (mpos
> from
+ amount
&& mpos
<= from
)
321 if (adjust_markers_test
)
323 mpos
= from
+ amount
;
326 if (mpos
> from
&& mpos
<= to
)
334 /* Adjust all markers for a deletion
335 whose range in bytes is FROM_BYTE to TO_BYTE.
336 The range in charpos is FROM to TO.
338 This function assumes that the gap is adjacent to
339 or inside of the range being deleted. */
342 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
343 register int from
, from_byte
, to
, to_byte
;
346 register struct Lisp_Marker
*m
;
347 register int charpos
;
349 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
351 charpos
= m
->charpos
;
356 /* If the marker is after the deletion,
357 relocate by number of chars / bytes deleted. */
360 m
->charpos
-= to
- from
;
361 m
->bytepos
-= to_byte
- from_byte
;
363 /* Here's the case where a marker is inside text being deleted. */
364 else if (charpos
> from
)
366 if (! m
->insertion_type
)
367 { /* Normal markers will end up at the beginning of the
368 re-inserted text after undoing a deletion, and must be
369 adjusted to move them to the correct place. */
370 XSETMISC (marker
, m
);
371 record_marker_adjustment (marker
, from
- charpos
);
373 else if (charpos
< to
)
374 { /* Before-insertion markers will automatically move forward
375 upon re-inserting the deleted text, so we have to arrange
376 for them to move backward to the correct position. */
377 XSETMISC (marker
, m
);
378 record_marker_adjustment (marker
, charpos
- to
);
381 m
->bytepos
= from_byte
;
383 /* Here's the case where a before-insertion marker is immediately
384 before the deleted region. */
385 else if (charpos
== from
&& m
->insertion_type
)
387 /* Undoing the change uses normal insertion, which will
388 incorrectly make MARKER move forward, so we arrange for it
389 to then move backward to the correct place at the beginning
390 of the deleted region. */
391 XSETMISC (marker
, m
);
392 record_marker_adjustment (marker
, to
- from
);
398 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
399 to TO / TO_BYTE. We have to relocate the charpos of every marker
400 that points after the insertion (but not their bytepos).
402 When a marker points at the insertion point,
403 we advance it if either its insertion-type is t
404 or BEFORE_MARKERS is true. */
407 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
408 register int from
, from_byte
, to
, to_byte
;
411 struct Lisp_Marker
*m
;
413 int nchars
= to
- from
;
414 int nbytes
= to_byte
- from_byte
;
416 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
418 /* In a single-byte buffer, a marker's two positions must be
422 if (m
->charpos
!= m
->bytepos
)
426 if (m
->bytepos
== from_byte
)
428 if (m
->insertion_type
|| before_markers
)
430 m
->bytepos
= to_byte
;
432 if (m
->insertion_type
)
436 else if (m
->bytepos
> from_byte
)
438 m
->bytepos
+= nbytes
;
439 m
->charpos
+= nchars
;
443 /* Adjusting only markers whose insertion-type is t may result in
444 - disordered start and end in overlays, and
445 - disordered overlays in the slot `overlays_before' of current_buffer. */
448 fix_start_end_in_overlays(from
, to
);
449 fix_overlays_before (current_buffer
, from
, to
);
453 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
455 This is used only when the value of point changes due to an insert
456 or delete; it does not represent a conceptual change in point as a
457 marker. In particular, point is not crossing any interval
458 boundaries, so there's no need to use the usual SET_PT macro. In
459 fact it would be incorrect to do so, because either the old or the
460 new value of point is out of sync with the current set of
464 adjust_point (nchars
, nbytes
)
467 BUF_PT (current_buffer
) += nchars
;
468 BUF_PT_BYTE (current_buffer
) += nbytes
;
470 /* In a single-byte buffer, the two positions must be equal. */
476 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
477 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
478 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
482 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
483 new_chars
, new_bytes
)
484 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
486 register struct Lisp_Marker
*m
;
487 int prev_to_byte
= from_byte
+ old_bytes
;
488 int diff_chars
= new_chars
- old_chars
;
489 int diff_bytes
= new_bytes
- old_bytes
;
491 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
493 if (m
->bytepos
>= prev_to_byte
)
495 m
->charpos
+= diff_chars
;
496 m
->bytepos
+= diff_bytes
;
498 else if (m
->bytepos
> from_byte
)
501 m
->bytepos
= from_byte
;
509 /* Make the gap NBYTES_ADDED bytes longer. */
512 make_gap_larger (nbytes_added
)
517 int real_gap_loc_byte
;
520 /* If we have to get more space, get enough to last a while. */
521 nbytes_added
+= 2000;
523 /* Don't allow a buffer size that won't fit in an int
524 even if it will fit in a Lisp integer.
525 That won't work because so many places use `int'.
527 Make sure we don't introduce overflows in the calculation. */
529 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
530 >= (((EMACS_INT
) 1 << (min (VALBITS
, BITS_PER_INT
) - 1)) - 1
532 error ("Buffer exceeds maximum size");
534 enlarge_buffer_text (current_buffer
, nbytes_added
);
536 /* Prevent quitting in move_gap. */
541 real_gap_loc_byte
= GPT_BYTE
;
542 old_gap_size
= GAP_SIZE
;
544 /* Call the newly allocated space a gap at the end of the whole space. */
546 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
547 GAP_SIZE
= nbytes_added
;
549 /* Move the new gap down to be consecutive with the end of the old one.
550 This adjusts the markers properly too. */
551 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
553 /* Now combine the two into one large gap. */
554 GAP_SIZE
+= old_gap_size
;
556 GPT_BYTE
= real_gap_loc_byte
;
565 /* Make the gap NBYTES_REMOVED bytes shorter. */
568 make_gap_smaller (nbytes_removed
)
573 int real_gap_loc_byte
;
576 int real_beg_unchanged
;
579 /* Make sure the gap is at least 20 bytes. */
580 if (GAP_SIZE
- nbytes_removed
< 20)
581 nbytes_removed
= GAP_SIZE
- 20;
583 /* Prevent quitting in move_gap. */
588 real_gap_loc_byte
= GPT_BYTE
;
589 new_gap_size
= GAP_SIZE
- nbytes_removed
;
591 real_Z_byte
= Z_BYTE
;
592 real_beg_unchanged
= BEG_UNCHANGED
;
594 /* Pretend that the last unwanted part of the gap is the entire gap,
595 and that the first desired part of the gap is part of the buffer
597 bzero (GPT_ADDR
, new_gap_size
);
599 GPT_BYTE
+= new_gap_size
;
601 Z_BYTE
+= new_gap_size
;
602 GAP_SIZE
= nbytes_removed
;
604 /* Move the unwanted pretend gap to the end of the buffer. This
605 adjusts the markers properly too. */
606 gap_right (Z
, Z_BYTE
);
608 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
610 /* Now restore the desired gap. */
611 GAP_SIZE
= new_gap_size
;
613 GPT_BYTE
= real_gap_loc_byte
;
615 Z_BYTE
= real_Z_byte
;
616 BEG_UNCHANGED
= real_beg_unchanged
;
625 make_gap (nbytes_added
)
628 if (nbytes_added
>= 0)
629 make_gap_larger (nbytes_added
);
630 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
632 make_gap_smaller (-nbytes_added
);
636 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
637 FROM_MULTIBYTE says whether the incoming text is multibyte.
638 TO_MULTIBYTE says whether to store the text as multibyte.
639 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
641 Return the number of bytes stored at TO_ADDR. */
644 copy_text (from_addr
, to_addr
, nbytes
,
645 from_multibyte
, to_multibyte
)
646 const unsigned char *from_addr
;
647 unsigned char *to_addr
;
649 int from_multibyte
, to_multibyte
;
651 if (from_multibyte
== to_multibyte
)
653 bcopy (from_addr
, to_addr
, nbytes
);
656 else if (from_multibyte
)
659 int bytes_left
= nbytes
;
660 Lisp_Object tbl
= Qnil
;
662 while (bytes_left
> 0)
665 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
666 if (!ASCII_CHAR_P (c
))
667 c
= multibyte_char_to_unibyte (c
, tbl
);
669 from_addr
+= thislen
;
670 bytes_left
-= thislen
;
677 unsigned char *initial_to_addr
= to_addr
;
679 /* Convert single-byte to multibyte. */
682 int c
= *from_addr
++;
686 c
= unibyte_char_to_multibyte (c
);
687 to_addr
+= CHAR_STRING (c
, to_addr
);
691 /* Special case for speed. */
692 *to_addr
++ = c
, nbytes
--;
694 return to_addr
- initial_to_addr
;
698 /* Return the number of bytes it would take
699 to convert some single-byte text to multibyte.
700 The single-byte text consists of NBYTES bytes at PTR. */
703 count_size_as_multibyte (ptr
, nbytes
)
704 const unsigned char *ptr
;
708 int outgoing_nbytes
= 0;
710 for (i
= 0; i
< nbytes
; i
++)
712 unsigned int c
= *ptr
++;
718 c
= unibyte_char_to_multibyte (c
);
719 outgoing_nbytes
+= CHAR_BYTES (c
);
723 return outgoing_nbytes
;
726 /* Insert a string of specified length before point.
727 This function judges multibyteness based on
728 enable_multibyte_characters in the current buffer;
729 it never converts between single-byte and multibyte.
731 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
732 prepare_to_modify_buffer could relocate the text. */
735 insert (string
, nbytes
)
736 register const unsigned char *string
;
742 insert_1 (string
, nbytes
, 0, 1, 0);
743 signal_after_change (opoint
, 0, PT
- opoint
);
744 update_compositions (opoint
, PT
, CHECK_BORDER
);
748 /* Likewise, but inherit text properties from neighboring characters. */
751 insert_and_inherit (string
, nbytes
)
752 register const unsigned char *string
;
758 insert_1 (string
, nbytes
, 1, 1, 0);
759 signal_after_change (opoint
, 0, PT
- opoint
);
760 update_compositions (opoint
, PT
, CHECK_BORDER
);
764 /* Insert the character C before point. Do not inherit text properties. */
770 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
773 if (! NILP (current_buffer
->enable_multibyte_characters
))
774 len
= CHAR_STRING (c
, str
);
784 /* Insert the null-terminated string S before point. */
790 insert (s
, strlen (s
));
793 /* Like `insert' except that all markers pointing at the place where
794 the insertion happens are adjusted to point after it.
795 Don't use this function to insert part of a Lisp string,
796 since gc could happen and relocate it. */
799 insert_before_markers (string
, nbytes
)
800 const unsigned char *string
;
807 insert_1 (string
, nbytes
, 0, 1, 1);
808 signal_after_change (opoint
, 0, PT
- opoint
);
809 update_compositions (opoint
, PT
, CHECK_BORDER
);
813 /* Likewise, but inherit text properties from neighboring characters. */
816 insert_before_markers_and_inherit (string
, nbytes
)
817 const unsigned char *string
;
824 insert_1 (string
, nbytes
, 1, 1, 1);
825 signal_after_change (opoint
, 0, PT
- opoint
);
826 update_compositions (opoint
, PT
, CHECK_BORDER
);
830 /* Subroutine used by the insert functions above. */
833 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
834 register const unsigned char *string
;
836 int inherit
, prepare
, before_markers
;
838 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
839 inherit
, prepare
, before_markers
);
843 #ifdef BYTE_COMBINING_DEBUG
845 /* See if the bytes before POS/POS_BYTE combine with bytes
846 at the start of STRING to form a single character.
847 If so, return the number of bytes at the start of STRING
848 which combine in this way. Otherwise, return 0. */
851 count_combining_before (string
, length
, pos
, pos_byte
)
852 const unsigned char *string
;
856 int len
, combining_bytes
;
857 const unsigned char *p
;
859 if (NILP (current_buffer
->enable_multibyte_characters
))
862 /* At first, we can exclude the following cases:
863 (1) STRING[0] can't be a following byte of multibyte sequence.
864 (2) POS is the start of the current buffer.
865 (3) A character before POS is not a multibyte character. */
866 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
868 if (pos_byte
== BEG_BYTE
) /* case (2) */
871 p
= BYTE_POS_ADDR (pos_byte
- 1);
872 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
873 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
876 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
877 if (combining_bytes
<= 0)
878 /* The character preceding POS is, complete and no room for
879 combining bytes (combining_bytes == 0), or an independent 8-bit
880 character (combining_bytes < 0). */
883 /* We have a combination situation. Count the bytes at STRING that
886 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
889 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
892 /* See if the bytes after POS/POS_BYTE combine with bytes
893 at the end of STRING to form a single character.
894 If so, return the number of bytes after POS/POS_BYTE
895 which combine in this way. Otherwise, return 0. */
898 count_combining_after (string
, length
, pos
, pos_byte
)
899 const unsigned char *string
;
903 int opos_byte
= pos_byte
;
908 if (NILP (current_buffer
->enable_multibyte_characters
))
911 /* At first, we can exclude the following cases:
912 (1) The last byte of STRING is an ASCII.
913 (2) POS is the last of the current buffer.
914 (3) A character at POS can't be a following byte of multibyte
916 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
918 if (pos_byte
== Z_BYTE
) /* case (2) */
920 bufp
= BYTE_POS_ADDR (pos_byte
);
921 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
925 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
931 /* All characters in STRING are not character head. We must
932 check also preceding bytes at POS. We are sure that the gap
934 unsigned char *p
= BEG_ADDR
;
936 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
938 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
941 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
942 return (bytes
<= pos_byte
- 1 - i
+ length
944 : bytes
- (pos_byte
- 1 - i
+ length
));
946 if (!BASE_LEADING_CODE_P (string
[i
]))
949 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
951 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
953 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
959 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
960 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
961 are the same as in insert_1. */
964 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
965 register const unsigned char *string
;
966 register int nchars
, nbytes
;
967 int inherit
, prepare
, before_markers
;
972 if (NILP (current_buffer
->enable_multibyte_characters
))
976 /* Do this before moving and increasing the gap,
977 because the before-change hooks might move the gap
978 or make it smaller. */
979 prepare_to_modify_buffer (PT
, PT
, NULL
);
982 move_gap_both (PT
, PT_BYTE
);
983 if (GAP_SIZE
< nbytes
)
984 make_gap (nbytes
- GAP_SIZE
);
986 #ifdef BYTE_COMBINING_DEBUG
987 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
988 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
992 /* Record deletion of the surrounding text that combines with
993 the insertion. This, together with recording the insertion,
994 will add up to the right stuff in the undo list. */
995 record_insert (PT
, nchars
);
998 bcopy (string
, GPT_ADDR
, nbytes
);
1007 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1012 /* The insert may have been in the unchanged region, so check again. */
1013 if (Z
- GPT
< END_UNCHANGED
)
1014 END_UNCHANGED
= Z
- GPT
;
1016 adjust_overlays_for_insert (PT
, nchars
);
1017 adjust_markers_for_insert (PT
, PT_BYTE
,
1018 PT
+ nchars
, PT_BYTE
+ nbytes
,
1021 if (BUF_INTERVALS (current_buffer
) != 0)
1022 offset_intervals (current_buffer
, PT
, nchars
);
1024 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1025 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1028 adjust_point (nchars
, nbytes
);
1033 /* Insert the part of the text of STRING, a Lisp object assumed to be
1034 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1035 starting at position POS / POS_BYTE. If the text of STRING has properties,
1036 copy them into the buffer.
1038 It does not work to use `insert' for this, because a GC could happen
1039 before we bcopy the stuff into the buffer, and relocate the string
1040 without insert noticing. */
1043 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1045 register int pos
, pos_byte
, length
, length_byte
;
1049 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1051 signal_after_change (opoint
, 0, PT
- opoint
);
1052 update_compositions (opoint
, PT
, CHECK_BORDER
);
1055 /* Like `insert_from_string' except that all markers pointing
1056 at the place where the insertion happens are adjusted to point after it. */
1059 insert_from_string_before_markers (string
, pos
, pos_byte
,
1060 length
, length_byte
, inherit
)
1062 register int pos
, pos_byte
, length
, length_byte
;
1066 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1068 signal_after_change (opoint
, 0, PT
- opoint
);
1069 update_compositions (opoint
, PT
, CHECK_BORDER
);
1072 /* Subroutine of the insertion functions above. */
1075 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1076 inherit
, before_markers
)
1078 register int pos
, pos_byte
, nchars
, nbytes
;
1079 int inherit
, before_markers
;
1081 struct gcpro gcpro1
;
1082 int outgoing_nbytes
= nbytes
;
1085 /* Make OUTGOING_NBYTES describe the text
1086 as it will be inserted in this buffer. */
1088 if (NILP (current_buffer
->enable_multibyte_characters
))
1089 outgoing_nbytes
= nchars
;
1090 else if (! STRING_MULTIBYTE (string
))
1092 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
1096 /* Do this before moving and increasing the gap,
1097 because the before-change hooks might move the gap
1098 or make it smaller. */
1099 prepare_to_modify_buffer (PT
, PT
, NULL
);
1102 move_gap_both (PT
, PT_BYTE
);
1103 if (GAP_SIZE
< outgoing_nbytes
)
1104 make_gap (outgoing_nbytes
- GAP_SIZE
);
1107 /* Copy the string text into the buffer, perhaps converting
1108 between single-byte and multibyte. */
1109 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
1110 STRING_MULTIBYTE (string
),
1111 ! NILP (current_buffer
->enable_multibyte_characters
));
1113 #ifdef BYTE_COMBINING_DEBUG
1114 /* We have copied text into the gap, but we have not altered
1115 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1116 to these functions and get the same results as we would
1117 have got earlier on. Meanwhile, PT_ADDR does point to
1118 the text that has been stored by copy_text. */
1119 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1120 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1124 record_insert (PT
, nchars
);
1127 GAP_SIZE
-= outgoing_nbytes
;
1131 GPT_BYTE
+= outgoing_nbytes
;
1132 ZV_BYTE
+= outgoing_nbytes
;
1133 Z_BYTE
+= outgoing_nbytes
;
1134 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1139 /* The insert may have been in the unchanged region, so check again. */
1140 if (Z
- GPT
< END_UNCHANGED
)
1141 END_UNCHANGED
= Z
- GPT
;
1143 adjust_overlays_for_insert (PT
, nchars
);
1144 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1145 PT_BYTE
+ outgoing_nbytes
,
1148 offset_intervals (current_buffer
, PT
, nchars
);
1150 intervals
= STRING_INTERVALS (string
);
1151 /* Get the intervals for the part of the string we are inserting. */
1152 if (nbytes
< SBYTES (string
))
1153 intervals
= copy_intervals (intervals
, pos
, nchars
);
1155 /* Insert those intervals. */
1156 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1157 current_buffer
, inherit
);
1159 adjust_point (nchars
, outgoing_nbytes
);
1164 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1165 starting at GPT_ADDR. */
1168 insert_from_gap (nchars
, nbytes
)
1169 register int nchars
, nbytes
;
1171 if (NILP (current_buffer
->enable_multibyte_characters
))
1174 record_insert (GPT
, nchars
);
1184 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1189 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1190 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1193 if (BUF_INTERVALS (current_buffer
) != 0)
1195 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1196 graft_intervals_into_buffer (NULL_INTERVAL
, GPT
- nchars
, nchars
,
1200 if (GPT
- nchars
< PT
)
1201 adjust_point (nchars
, nbytes
);
1206 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1207 current buffer. If the text in BUF has properties, they are absorbed
1208 into the current buffer.
1210 It does not work to use `insert' for this, because a malloc could happen
1211 and relocate BUF's text before the bcopy happens. */
1214 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1216 int charpos
, nchars
;
1221 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1222 signal_after_change (opoint
, 0, PT
- opoint
);
1223 update_compositions (opoint
, PT
, CHECK_BORDER
);
1227 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1232 register Lisp_Object temp
;
1233 int chunk
, chunk_expanded
;
1234 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1235 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1236 int incoming_nbytes
= to_byte
- from_byte
;
1237 int outgoing_nbytes
= incoming_nbytes
;
1240 /* Make OUTGOING_NBYTES describe the text
1241 as it will be inserted in this buffer. */
1243 if (NILP (current_buffer
->enable_multibyte_characters
))
1244 outgoing_nbytes
= nchars
;
1245 else if (NILP (buf
->enable_multibyte_characters
))
1247 int outgoing_before_gap
= 0;
1248 int outgoing_after_gap
= 0;
1250 if (from
< BUF_GPT (buf
))
1252 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1253 if (chunk
> incoming_nbytes
)
1254 chunk
= incoming_nbytes
;
1256 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1262 if (chunk
< incoming_nbytes
)
1264 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1266 incoming_nbytes
- chunk
);
1268 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1271 /* Make sure point-max won't overflow after this insertion. */
1272 XSETINT (temp
, outgoing_nbytes
+ Z
);
1273 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1274 error ("Maximum buffer size exceeded");
1276 /* Do this before moving and increasing the gap,
1277 because the before-change hooks might move the gap
1278 or make it smaller. */
1279 prepare_to_modify_buffer (PT
, PT
, NULL
);
1282 move_gap_both (PT
, PT_BYTE
);
1283 if (GAP_SIZE
< outgoing_nbytes
)
1284 make_gap (outgoing_nbytes
- GAP_SIZE
);
1286 if (from
< BUF_GPT (buf
))
1288 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1289 if (chunk
> incoming_nbytes
)
1290 chunk
= incoming_nbytes
;
1291 /* Record number of output bytes, so we know where
1292 to put the output from the second copy_text. */
1294 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1296 ! NILP (buf
->enable_multibyte_characters
),
1297 ! NILP (current_buffer
->enable_multibyte_characters
));
1300 chunk_expanded
= chunk
= 0;
1302 if (chunk
< incoming_nbytes
)
1303 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1304 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1305 ! NILP (buf
->enable_multibyte_characters
),
1306 ! NILP (current_buffer
->enable_multibyte_characters
));
1308 #ifdef BYTE_COMBINING_DEBUG
1309 /* We have copied text into the gap, but we have not altered
1310 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1311 to these functions and get the same results as we would
1312 have got earlier on. Meanwhile, GPT_ADDR does point to
1313 the text that has been stored by copy_text. */
1314 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1315 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1319 record_insert (PT
, nchars
);
1322 GAP_SIZE
-= outgoing_nbytes
;
1326 GPT_BYTE
+= outgoing_nbytes
;
1327 ZV_BYTE
+= outgoing_nbytes
;
1328 Z_BYTE
+= outgoing_nbytes
;
1329 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1334 /* The insert may have been in the unchanged region, so check again. */
1335 if (Z
- GPT
< END_UNCHANGED
)
1336 END_UNCHANGED
= Z
- GPT
;
1338 adjust_overlays_for_insert (PT
, nchars
);
1339 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1340 PT_BYTE
+ outgoing_nbytes
,
1343 if (BUF_INTERVALS (current_buffer
) != 0)
1344 offset_intervals (current_buffer
, PT
, nchars
);
1346 /* Get the intervals for the part of the string we are inserting. */
1347 intervals
= BUF_INTERVALS (buf
);
1348 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1350 if (buf
== current_buffer
&& PT
<= from
)
1352 intervals
= copy_intervals (intervals
, from
, nchars
);
1355 /* Insert those intervals. */
1356 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1358 adjust_point (nchars
, outgoing_nbytes
);
1361 /* Record undo information and adjust markers and position keepers for
1362 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1363 chars (LEN_BYTE bytes) which resides in the gap just after
1366 PREV_TEXT nil means the new text was just inserted. */
1369 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1370 int from
, from_byte
, len
, len_byte
;
1371 Lisp_Object prev_text
;
1373 int nchars_del
= 0, nbytes_del
= 0;
1375 #ifdef BYTE_COMBINING_DEBUG
1376 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1377 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1381 if (STRINGP (prev_text
))
1383 nchars_del
= SCHARS (prev_text
);
1384 nbytes_del
= SBYTES (prev_text
);
1387 /* Update various buffer positions for the new text. */
1388 GAP_SIZE
-= len_byte
;
1390 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1391 GPT
+= len
; GPT_BYTE
+= len_byte
;
1392 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1395 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1398 adjust_markers_for_insert (from
, from_byte
,
1399 from
+ len
, from_byte
+ len_byte
, 0);
1401 if (! EQ (current_buffer
->undo_list
, Qt
))
1404 record_delete (from
, prev_text
);
1405 record_insert (from
, len
);
1408 if (len
> nchars_del
)
1409 adjust_overlays_for_insert (from
, len
- nchars_del
);
1410 else if (len
< nchars_del
)
1411 adjust_overlays_for_delete (from
, nchars_del
- len
);
1412 if (BUF_INTERVALS (current_buffer
) != 0)
1414 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1418 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1420 /* As byte combining will decrease Z, we must check this again. */
1421 if (Z
- GPT
< END_UNCHANGED
)
1422 END_UNCHANGED
= Z
- GPT
;
1427 evaporate_overlays (from
);
1431 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1432 This is for use when undo is not enabled in the current buffer. */
1435 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1436 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1438 #ifdef BYTE_COMBINING_DEBUG
1439 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1440 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1444 /* Update various buffer positions for the new text. */
1445 GAP_SIZE
-= len_byte
;
1447 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1448 GPT
+= len
; GPT_BYTE
+= len_byte
;
1449 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1452 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1455 adjust_markers_for_insert (from
, from_byte
,
1456 from
+ len
, from_byte
+ len_byte
, 0);
1458 if (len
> nchars_del
)
1459 adjust_overlays_for_insert (from
, len
- nchars_del
);
1460 else if (len
< nchars_del
)
1461 adjust_overlays_for_delete (from
, nchars_del
- len
);
1462 if (BUF_INTERVALS (current_buffer
) != 0)
1464 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1468 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1470 /* As byte combining will decrease Z, we must check this again. */
1471 if (Z
- GPT
< END_UNCHANGED
)
1472 END_UNCHANGED
= Z
- GPT
;
1477 evaporate_overlays (from
);
1481 /* Record undo information, adjust markers and position keepers for an
1482 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1483 text already exists in the current buffer but character length (TO
1484 - FROM) may be incorrect, the correct length is NEWLEN. */
1487 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1488 int from
, from_byte
, to
, to_byte
, newlen
;
1490 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1493 move_gap_both (to
, to_byte
);
1494 GAP_SIZE
+= len_byte
;
1495 GPT
-= len
; GPT_BYTE
-= len_byte
;
1496 ZV
-= len
; ZV_BYTE
-= len_byte
;
1497 Z
-= len
; Z_BYTE
-= len_byte
;
1498 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1501 /* Replace the text from character positions FROM to TO with NEW,
1502 If PREPARE is nonzero, call prepare_to_modify_buffer.
1503 If INHERIT, the newly inserted text should inherit text properties
1504 from the surrounding non-deleted text. */
1506 /* Note that this does not yet handle markers quite right.
1507 Also it needs to record a single undo-entry that does a replacement
1508 rather than a separate delete and insert.
1509 That way, undo will also handle markers properly.
1511 But if MARKERS is 0, don't relocate markers. */
1514 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1516 int from
, to
, prepare
, inherit
, markers
;
1518 int inschars
= SCHARS (new);
1519 int insbytes
= SBYTES (new);
1520 int from_byte
, to_byte
;
1521 int nbytes_del
, nchars_del
;
1522 register Lisp_Object temp
;
1523 struct gcpro gcpro1
;
1525 int outgoing_insbytes
= insbytes
;
1526 Lisp_Object deletion
;
1535 int range_length
= to
- from
;
1536 prepare_to_modify_buffer (from
, to
, &from
);
1537 to
= from
+ range_length
;
1542 /* Make args be valid */
1548 from_byte
= CHAR_TO_BYTE (from
);
1549 to_byte
= CHAR_TO_BYTE (to
);
1551 nchars_del
= to
- from
;
1552 nbytes_del
= to_byte
- from_byte
;
1554 if (nbytes_del
<= 0 && insbytes
== 0)
1557 /* Make OUTGOING_INSBYTES describe the text
1558 as it will be inserted in this buffer. */
1560 if (NILP (current_buffer
->enable_multibyte_characters
))
1561 outgoing_insbytes
= inschars
;
1562 else if (! STRING_MULTIBYTE (new))
1564 = count_size_as_multibyte (SDATA (new), insbytes
);
1566 /* Make sure point-max won't overflow after this insertion. */
1567 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1568 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1569 error ("Maximum buffer size exceeded");
1573 /* Make sure the gap is somewhere in or next to what we are deleting. */
1575 gap_right (from
, from_byte
);
1577 gap_left (to
, to_byte
, 0);
1579 /* Even if we don't record for undo, we must keep the original text
1580 because we may have to recover it because of inappropriate byte
1582 if (! EQ (current_buffer
->undo_list
, Qt
))
1583 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1585 GAP_SIZE
+= nbytes_del
;
1588 ZV_BYTE
-= nbytes_del
;
1589 Z_BYTE
-= nbytes_del
;
1591 GPT_BYTE
= from_byte
;
1592 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1597 if (GPT
- BEG
< BEG_UNCHANGED
)
1598 BEG_UNCHANGED
= GPT
- BEG
;
1599 if (Z
- GPT
< END_UNCHANGED
)
1600 END_UNCHANGED
= Z
- GPT
;
1602 if (GAP_SIZE
< insbytes
)
1603 make_gap (insbytes
- GAP_SIZE
);
1605 /* Copy the string text into the buffer, perhaps converting
1606 between single-byte and multibyte. */
1607 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1608 STRING_MULTIBYTE (new),
1609 ! NILP (current_buffer
->enable_multibyte_characters
));
1611 #ifdef BYTE_COMBINING_DEBUG
1612 /* We have copied text into the gap, but we have not marked
1613 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1614 here, for both the previous text and the following text.
1615 Meanwhile, GPT_ADDR does point to
1616 the text that has been stored by copy_text. */
1617 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1618 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1622 if (! EQ (current_buffer
->undo_list
, Qt
))
1624 record_delete (from
, deletion
);
1625 record_insert (from
, inschars
);
1628 GAP_SIZE
-= outgoing_insbytes
;
1632 GPT_BYTE
+= outgoing_insbytes
;
1633 ZV_BYTE
+= outgoing_insbytes
;
1634 Z_BYTE
+= outgoing_insbytes
;
1635 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1640 /* Adjust the overlay center as needed. This must be done after
1641 adjusting the markers that bound the overlays. */
1642 adjust_overlays_for_delete (from
, nchars_del
);
1643 adjust_overlays_for_insert (from
, inschars
);
1645 /* Adjust markers for the deletion and the insertion. */
1647 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1648 inschars
, outgoing_insbytes
);
1650 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1652 /* Get the intervals for the part of the string we are inserting--
1653 not including the combined-before bytes. */
1654 intervals
= STRING_INTERVALS (new);
1655 /* Insert those intervals. */
1656 graft_intervals_into_buffer (intervals
, from
, inschars
,
1657 current_buffer
, inherit
);
1659 /* Relocate point as if it were a marker. */
1661 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1662 (from_byte
+ outgoing_insbytes
1663 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1665 if (outgoing_insbytes
== 0)
1666 evaporate_overlays (from
);
1673 signal_after_change (from
, nchars_del
, GPT
- from
);
1674 update_compositions (from
, GPT
, CHECK_BORDER
);
1677 /* Replace the text from character positions FROM to TO with
1678 the text in INS of length INSCHARS.
1679 Keep the text properties that applied to the old characters
1680 (extending them to all the new chars if there are more new chars).
1682 Note that this does not yet handle markers quite right.
1684 If MARKERS is nonzero, relocate markers.
1686 Unlike most functions at this level, never call
1687 prepare_to_modify_buffer and never call signal_after_change. */
1690 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1691 int from
, from_byte
, to
, to_byte
;
1693 int inschars
, insbytes
, markers
;
1695 int nbytes_del
, nchars_del
;
1700 nchars_del
= to
- from
;
1701 nbytes_del
= to_byte
- from_byte
;
1703 if (nbytes_del
<= 0 && insbytes
== 0)
1706 /* Make sure point-max won't overflow after this insertion. */
1707 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1708 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1709 error ("Maximum buffer size exceeded");
1711 /* Make sure the gap is somewhere in or next to what we are deleting. */
1713 gap_right (from
, from_byte
);
1715 gap_left (to
, to_byte
, 0);
1717 GAP_SIZE
+= nbytes_del
;
1720 ZV_BYTE
-= nbytes_del
;
1721 Z_BYTE
-= nbytes_del
;
1723 GPT_BYTE
= from_byte
;
1724 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1729 if (GPT
- BEG
< BEG_UNCHANGED
)
1730 BEG_UNCHANGED
= GPT
- BEG
;
1731 if (Z
- GPT
< END_UNCHANGED
)
1732 END_UNCHANGED
= Z
- GPT
;
1734 if (GAP_SIZE
< insbytes
)
1735 make_gap (insbytes
- GAP_SIZE
);
1737 /* Copy the replacement text into the buffer. */
1738 bcopy (ins
, GPT_ADDR
, insbytes
);
1740 #ifdef BYTE_COMBINING_DEBUG
1741 /* We have copied text into the gap, but we have not marked
1742 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1743 here, for both the previous text and the following text.
1744 Meanwhile, GPT_ADDR does point to
1745 the text that has been stored by copy_text. */
1746 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1747 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1751 GAP_SIZE
-= insbytes
;
1755 GPT_BYTE
+= insbytes
;
1756 ZV_BYTE
+= insbytes
;
1758 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1763 /* Adjust the overlay center as needed. This must be done after
1764 adjusting the markers that bound the overlays. */
1765 if (nchars_del
!= inschars
)
1767 adjust_overlays_for_insert (from
, inschars
);
1768 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1771 /* Adjust markers for the deletion and the insertion. */
1773 && ! (nchars_del
== 1 && inschars
== 1))
1774 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1775 inschars
, insbytes
);
1777 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1779 /* Relocate point as if it were a marker. */
1780 if (from
< PT
&& nchars_del
!= inschars
)
1781 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1782 (from_byte
+ insbytes
1783 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1786 evaporate_overlays (from
);
1793 /* Delete characters in current buffer
1794 from FROM up to (but not including) TO.
1795 If TO comes before FROM, we delete nothing. */
1798 del_range (from
, to
)
1799 register int from
, to
;
1801 del_range_1 (from
, to
, 1, 0);
1804 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1805 RET_STRING says to return the deleted text. */
1808 del_range_1 (from
, to
, prepare
, ret_string
)
1809 int from
, to
, prepare
, ret_string
;
1811 int from_byte
, to_byte
;
1812 Lisp_Object deletion
;
1813 struct gcpro gcpro1
;
1815 /* Make args be valid */
1826 int range_length
= to
- from
;
1827 prepare_to_modify_buffer (from
, to
, &from
);
1828 to
= min (ZV
, from
+ range_length
);
1831 from_byte
= CHAR_TO_BYTE (from
);
1832 to_byte
= CHAR_TO_BYTE (to
);
1834 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1836 signal_after_change (from
, to
- from
, 0);
1837 update_compositions (from
, from
, CHECK_HEAD
);
1842 /* Like del_range_1 but args are byte positions, not char positions. */
1845 del_range_byte (from_byte
, to_byte
, prepare
)
1846 int from_byte
, to_byte
, prepare
;
1850 /* Make args be valid */
1851 if (from_byte
< BEGV_BYTE
)
1852 from_byte
= BEGV_BYTE
;
1853 if (to_byte
> ZV_BYTE
)
1856 if (to_byte
<= from_byte
)
1859 from
= BYTE_TO_CHAR (from_byte
);
1860 to
= BYTE_TO_CHAR (to_byte
);
1864 int old_from
= from
, old_to
= Z
- to
;
1865 int range_length
= to
- from
;
1866 prepare_to_modify_buffer (from
, to
, &from
);
1867 to
= from
+ range_length
;
1869 if (old_from
!= from
)
1870 from_byte
= CHAR_TO_BYTE (from
);
1876 else if (old_to
== Z
- to
)
1877 to_byte
= CHAR_TO_BYTE (to
);
1880 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1881 signal_after_change (from
, to
- from
, 0);
1882 update_compositions (from
, from
, CHECK_HEAD
);
1885 /* Like del_range_1, but positions are specified both as charpos
1889 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1890 int from
, from_byte
, to
, to_byte
, prepare
;
1892 /* Make args be valid */
1893 if (from_byte
< BEGV_BYTE
)
1894 from_byte
= BEGV_BYTE
;
1895 if (to_byte
> ZV_BYTE
)
1898 if (to_byte
<= from_byte
)
1908 int old_from
= from
, old_to
= Z
- to
;
1909 int range_length
= to
- from
;
1910 prepare_to_modify_buffer (from
, to
, &from
);
1911 to
= from
+ range_length
;
1913 if (old_from
!= from
)
1914 from_byte
= CHAR_TO_BYTE (from
);
1920 else if (old_to
== Z
- to
)
1921 to_byte
= CHAR_TO_BYTE (to
);
1924 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1925 signal_after_change (from
, to
- from
, 0);
1926 update_compositions (from
, from
, CHECK_HEAD
);
1929 /* Delete a range of text, specified both as character positions
1930 and byte positions. FROM and TO are character positions,
1931 while FROM_BYTE and TO_BYTE are byte positions.
1932 If RET_STRING is true, the deleted area is returned as a string. */
1935 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1936 int from
, from_byte
, to
, to_byte
, ret_string
;
1938 register int nbytes_del
, nchars_del
;
1939 Lisp_Object deletion
;
1943 nchars_del
= to
- from
;
1944 nbytes_del
= to_byte
- from_byte
;
1946 /* Make sure the gap is somewhere in or next to what we are deleting. */
1948 gap_right (from
, from_byte
);
1950 gap_left (to
, to_byte
, 0);
1952 #ifdef BYTE_COMBINING_DEBUG
1953 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1954 Z_BYTE
- to_byte
, from
, from_byte
))
1958 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1959 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1963 /* Relocate all markers pointing into the new, larger gap
1964 to point at the end of the text before the gap.
1965 Do this before recording the deletion,
1966 so that undo handles this after reinserting the text. */
1967 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1969 if (! EQ (current_buffer
->undo_list
, Qt
))
1970 record_delete (from
, deletion
);
1973 /* Relocate point as if it were a marker. */
1975 adjust_point (from
- (PT
< to
? PT
: to
),
1976 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1978 offset_intervals (current_buffer
, from
, - nchars_del
);
1980 /* Adjust the overlay center as needed. This must be done after
1981 adjusting the markers that bound the overlays. */
1982 adjust_overlays_for_delete (from
, nchars_del
);
1984 GAP_SIZE
+= nbytes_del
;
1985 ZV_BYTE
-= nbytes_del
;
1986 Z_BYTE
-= nbytes_del
;
1990 GPT_BYTE
= from_byte
;
1991 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1996 if (GPT
- BEG
< BEG_UNCHANGED
)
1997 BEG_UNCHANGED
= GPT
- BEG
;
1998 if (Z
- GPT
< END_UNCHANGED
)
1999 END_UNCHANGED
= Z
- GPT
;
2003 evaporate_overlays (from
);
2008 /* Call this if you're about to change the region of BUFFER from
2009 character positions START to END. This checks the read-only
2010 properties of the region, calls the necessary modification hooks,
2011 and warns the next redisplay that it should pay attention to that
2015 modify_region (buffer
, start
, end
)
2016 struct buffer
*buffer
;
2019 struct buffer
*old_buffer
= current_buffer
;
2021 if (buffer
!= old_buffer
)
2022 set_buffer_internal (buffer
);
2024 prepare_to_modify_buffer (start
, end
, NULL
);
2026 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
2028 if (MODIFF
<= SAVE_MODIFF
)
2029 record_first_change ();
2032 buffer
->point_before_scroll
= Qnil
;
2034 if (buffer
!= old_buffer
)
2035 set_buffer_internal (old_buffer
);
2038 /* Check that it is okay to modify the buffer between START and END,
2039 which are char positions.
2041 Run the before-change-function, if any. If intervals are in use,
2042 verify that the text to be modified is not read-only, and call
2043 any modification properties the text may have.
2045 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2046 by holding its value temporarily in a marker. */
2049 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2053 if (!NILP (current_buffer
->read_only
))
2054 Fbarf_if_buffer_read_only ();
2056 /* Let redisplay consider other windows than selected_window
2057 if modifying another buffer. */
2058 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2059 ++windows_or_buffers_changed
;
2061 if (BUF_INTERVALS (current_buffer
) != 0)
2065 Lisp_Object preserve_marker
;
2066 struct gcpro gcpro1
;
2067 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2068 GCPRO1 (preserve_marker
);
2069 verify_interval_modification (current_buffer
, start
, end
);
2070 *preserve_ptr
= marker_position (preserve_marker
);
2071 unchain_marker (XMARKER (preserve_marker
));
2075 verify_interval_modification (current_buffer
, start
, end
);
2078 #ifdef CLASH_DETECTION
2079 if (!NILP (current_buffer
->file_truename
)
2080 /* Make binding buffer-file-name to nil effective. */
2081 && !NILP (current_buffer
->filename
)
2082 && SAVE_MODIFF
>= MODIFF
)
2083 lock_file (current_buffer
->file_truename
);
2085 /* At least warn if this file has changed on disk since it was visited. */
2086 if (!NILP (current_buffer
->filename
)
2087 && SAVE_MODIFF
>= MODIFF
2088 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2089 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2090 call1 (intern ("ask-user-about-supersession-threat"),
2091 current_buffer
->filename
);
2092 #endif /* not CLASH_DETECTION */
2094 signal_before_change (start
, end
, preserve_ptr
);
2096 if (current_buffer
->newline_cache
)
2097 invalidate_region_cache (current_buffer
,
2098 current_buffer
->newline_cache
,
2099 start
- BEG
, Z
- end
);
2100 if (current_buffer
->width_run_cache
)
2101 invalidate_region_cache (current_buffer
,
2102 current_buffer
->width_run_cache
,
2103 start
- BEG
, Z
- end
);
2105 Vdeactivate_mark
= Qt
;
2108 /* These macros work with an argument named `preserve_ptr'
2109 and a local variable named `preserve_marker'. */
2111 #define PRESERVE_VALUE \
2112 if (preserve_ptr && NILP (preserve_marker)) \
2113 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2115 #define RESTORE_VALUE \
2116 if (! NILP (preserve_marker)) \
2118 *preserve_ptr = marker_position (preserve_marker); \
2119 unchain_marker (XMARKER (preserve_marker)); \
2122 #define PRESERVE_START_END \
2123 if (NILP (start_marker)) \
2124 start_marker = Fcopy_marker (start, Qnil); \
2125 if (NILP (end_marker)) \
2126 end_marker = Fcopy_marker (end, Qnil);
2128 #define FETCH_START \
2129 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2132 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2134 /* Signal a change to the buffer immediately before it happens.
2135 START_INT and END_INT are the bounds of the text to be changed.
2137 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2138 by holding its value temporarily in a marker. */
2141 signal_before_change (start_int
, end_int
, preserve_ptr
)
2142 int start_int
, end_int
;
2145 Lisp_Object start
, end
;
2146 Lisp_Object start_marker
, end_marker
;
2147 Lisp_Object preserve_marker
;
2148 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2150 if (inhibit_modification_hooks
)
2153 start
= make_number (start_int
);
2154 end
= make_number (end_int
);
2155 preserve_marker
= Qnil
;
2156 start_marker
= Qnil
;
2158 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2160 /* If buffer is unmodified, run a special hook for that case. */
2161 if (SAVE_MODIFF
>= MODIFF
2162 && !NILP (Vfirst_change_hook
)
2163 && !NILP (Vrun_hooks
))
2167 call1 (Vrun_hooks
, Qfirst_change_hook
);
2170 /* Now run the before-change-functions if any. */
2171 if (!NILP (Vbefore_change_functions
))
2173 Lisp_Object args
[3];
2174 Lisp_Object before_change_functions
;
2175 Lisp_Object after_change_functions
;
2176 struct gcpro gcpro1
, gcpro2
;
2177 struct buffer
*old
= current_buffer
;
2183 /* "Bind" before-change-functions and after-change-functions
2184 to nil--but in a way that errors don't know about.
2185 That way, if there's an error in them, they will stay nil. */
2186 before_change_functions
= Vbefore_change_functions
;
2187 after_change_functions
= Vafter_change_functions
;
2188 Vbefore_change_functions
= Qnil
;
2189 Vafter_change_functions
= Qnil
;
2190 GCPRO2 (before_change_functions
, after_change_functions
);
2192 /* Actually run the hook functions. */
2193 args
[0] = Qbefore_change_functions
;
2194 args
[1] = FETCH_START
;
2195 args
[2] = FETCH_END
;
2196 run_hook_list_with_args (before_change_functions
, 3, args
);
2198 /* "Unbind" the variables we "bound" to nil. Beware a
2199 buffer-local hook which changes the buffer when run (e.g. W3). */
2200 if (old
!= current_buffer
)
2202 new = current_buffer
;
2203 set_buffer_internal (old
);
2204 Vbefore_change_functions
= before_change_functions
;
2205 Vafter_change_functions
= after_change_functions
;
2206 set_buffer_internal (new);
2210 Vbefore_change_functions
= before_change_functions
;
2211 Vafter_change_functions
= after_change_functions
;
2216 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2219 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2220 FETCH_START
, FETCH_END
, Qnil
);
2223 if (! NILP (start_marker
))
2224 free_marker (start_marker
);
2225 if (! NILP (end_marker
))
2226 free_marker (end_marker
);
2231 /* Signal a change immediately after it happens.
2232 CHARPOS is the character position of the start of the changed text.
2233 LENDEL is the number of characters of the text before the change.
2234 (Not the whole buffer; just the part that was changed.)
2235 LENINS is the number of characters in that part of the text
2236 after the change. */
2239 signal_after_change (charpos
, lendel
, lenins
)
2240 int charpos
, lendel
, lenins
;
2242 if (inhibit_modification_hooks
)
2245 /* If we are deferring calls to the after-change functions
2246 and there are no before-change functions,
2247 just record the args that we were going to use. */
2248 if (! NILP (Vcombine_after_change_calls
)
2249 && NILP (Vbefore_change_functions
)
2250 && !current_buffer
->overlays_before
2251 && !current_buffer
->overlays_after
)
2255 if (!NILP (combine_after_change_list
)
2256 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2257 Fcombine_after_change_execute ();
2259 elt
= Fcons (make_number (charpos
- BEG
),
2260 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2261 Fcons (make_number (lenins
- lendel
), Qnil
)));
2262 combine_after_change_list
2263 = Fcons (elt
, combine_after_change_list
);
2264 combine_after_change_buffer
= Fcurrent_buffer ();
2269 if (!NILP (combine_after_change_list
))
2270 Fcombine_after_change_execute ();
2272 if (!NILP (Vafter_change_functions
))
2274 Lisp_Object args
[4];
2275 Lisp_Object before_change_functions
;
2276 Lisp_Object after_change_functions
;
2277 struct buffer
*old
= current_buffer
;
2279 struct gcpro gcpro1
, gcpro2
;
2281 /* "Bind" before-change-functions and after-change-functions
2282 to nil--but in a way that errors don't know about.
2283 That way, if there's an error in them, they will stay nil. */
2284 before_change_functions
= Vbefore_change_functions
;
2285 after_change_functions
= Vafter_change_functions
;
2286 Vbefore_change_functions
= Qnil
;
2287 Vafter_change_functions
= Qnil
;
2288 GCPRO2 (before_change_functions
, after_change_functions
);
2290 /* Actually run the hook functions. */
2291 args
[0] = Qafter_change_functions
;
2292 XSETFASTINT (args
[1], charpos
);
2293 XSETFASTINT (args
[2], charpos
+ lenins
);
2294 XSETFASTINT (args
[3], lendel
);
2295 run_hook_list_with_args (after_change_functions
,
2298 /* "Unbind" the variables we "bound" to nil. Beware a
2299 buffer-local hook which changes the buffer when run (e.g. W3). */
2300 if (old
!= current_buffer
)
2302 new = current_buffer
;
2303 set_buffer_internal (old
);
2304 Vbefore_change_functions
= before_change_functions
;
2305 Vafter_change_functions
= after_change_functions
;
2306 set_buffer_internal (new);
2310 Vbefore_change_functions
= before_change_functions
;
2311 Vafter_change_functions
= after_change_functions
;
2316 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2317 report_overlay_modification (make_number (charpos
),
2318 make_number (charpos
+ lenins
),
2320 make_number (charpos
),
2321 make_number (charpos
+ lenins
),
2322 make_number (lendel
));
2324 /* After an insertion, call the text properties
2325 insert-behind-hooks or insert-in-front-hooks. */
2327 report_interval_modification (make_number (charpos
),
2328 make_number (charpos
+ lenins
));
2332 Fcombine_after_change_execute_1 (val
)
2335 Vcombine_after_change_calls
= val
;
2339 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2340 Scombine_after_change_execute
, 0, 0, 0,
2341 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2344 int count
= SPECPDL_INDEX ();
2345 int beg
, end
, change
;
2349 if (NILP (combine_after_change_list
))
2352 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2354 Fset_buffer (combine_after_change_buffer
);
2356 /* # chars unchanged at beginning of buffer. */
2358 /* # chars unchanged at end of buffer. */
2360 /* Total amount of insertion (negative for deletion). */
2363 /* Scan the various individual changes,
2364 accumulating the range info in BEG, END and CHANGE. */
2365 for (tail
= combine_after_change_list
; CONSP (tail
);
2369 int thisbeg
, thisend
, thischange
;
2371 /* Extract the info from the next element. */
2375 thisbeg
= XINT (XCAR (elt
));
2380 thisend
= XINT (XCAR (elt
));
2385 thischange
= XINT (XCAR (elt
));
2387 /* Merge this range into the accumulated range. */
2388 change
+= thischange
;
2395 /* Get the current start and end positions of the range
2396 that was changed. */
2400 /* We are about to handle these, so discard them. */
2401 combine_after_change_list
= Qnil
;
2403 /* Now run the after-change functions for real.
2404 Turn off the flag that defers them. */
2405 record_unwind_protect (Fcombine_after_change_execute_1
,
2406 Vcombine_after_change_calls
);
2407 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2408 update_compositions (begpos
, endpos
, CHECK_ALL
);
2410 return unbind_to (count
, Qnil
);
2416 staticpro (&combine_after_change_list
);
2417 combine_after_change_list
= Qnil
;
2418 combine_after_change_buffer
= Qnil
;
2420 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2421 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2422 check_markers_debug_flag
= 0;
2423 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2424 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2425 Vcombine_after_change_calls
= Qnil
;
2427 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2428 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2429 This affects `before-change-functions' and `after-change-functions',
2430 as well as hooks attached to text properties and overlays. */);
2431 inhibit_modification_hooks
= 0;
2432 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2433 staticpro (&Qinhibit_modification_hooks
);
2435 defsubr (&Scombine_after_change_execute
);
2438 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2439 (do not change this comment) */