1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000, 01, 2003, 2005
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
;
1050 if (SCHARS (string
) == 0)
1053 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1055 signal_after_change (opoint
, 0, PT
- opoint
);
1056 update_compositions (opoint
, PT
, CHECK_BORDER
);
1059 /* Like `insert_from_string' except that all markers pointing
1060 at the place where the insertion happens are adjusted to point after it. */
1063 insert_from_string_before_markers (string
, pos
, pos_byte
,
1064 length
, length_byte
, inherit
)
1066 register int pos
, pos_byte
, length
, length_byte
;
1071 if (SCHARS (string
) == 0)
1074 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1076 signal_after_change (opoint
, 0, PT
- opoint
);
1077 update_compositions (opoint
, PT
, CHECK_BORDER
);
1080 /* Subroutine of the insertion functions above. */
1083 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1084 inherit
, before_markers
)
1086 register int pos
, pos_byte
, nchars
, nbytes
;
1087 int inherit
, before_markers
;
1089 struct gcpro gcpro1
;
1090 int outgoing_nbytes
= nbytes
;
1093 /* Make OUTGOING_NBYTES describe the text
1094 as it will be inserted in this buffer. */
1096 if (NILP (current_buffer
->enable_multibyte_characters
))
1097 outgoing_nbytes
= nchars
;
1098 else if (! STRING_MULTIBYTE (string
))
1100 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
1104 /* Do this before moving and increasing the gap,
1105 because the before-change hooks might move the gap
1106 or make it smaller. */
1107 prepare_to_modify_buffer (PT
, PT
, NULL
);
1110 move_gap_both (PT
, PT_BYTE
);
1111 if (GAP_SIZE
< outgoing_nbytes
)
1112 make_gap (outgoing_nbytes
- GAP_SIZE
);
1115 /* Copy the string text into the buffer, perhaps converting
1116 between single-byte and multibyte. */
1117 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
1118 STRING_MULTIBYTE (string
),
1119 ! NILP (current_buffer
->enable_multibyte_characters
));
1121 #ifdef BYTE_COMBINING_DEBUG
1122 /* We have copied text into the gap, but we have not altered
1123 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1124 to these functions and get the same results as we would
1125 have got earlier on. Meanwhile, PT_ADDR does point to
1126 the text that has been stored by copy_text. */
1127 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1128 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1132 record_insert (PT
, nchars
);
1135 GAP_SIZE
-= outgoing_nbytes
;
1139 GPT_BYTE
+= outgoing_nbytes
;
1140 ZV_BYTE
+= outgoing_nbytes
;
1141 Z_BYTE
+= outgoing_nbytes
;
1142 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1147 /* The insert may have been in the unchanged region, so check again. */
1148 if (Z
- GPT
< END_UNCHANGED
)
1149 END_UNCHANGED
= Z
- GPT
;
1151 adjust_overlays_for_insert (PT
, nchars
);
1152 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1153 PT_BYTE
+ outgoing_nbytes
,
1156 offset_intervals (current_buffer
, PT
, nchars
);
1158 intervals
= STRING_INTERVALS (string
);
1159 /* Get the intervals for the part of the string we are inserting. */
1160 if (nbytes
< SBYTES (string
))
1161 intervals
= copy_intervals (intervals
, pos
, nchars
);
1163 /* Insert those intervals. */
1164 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1165 current_buffer
, inherit
);
1167 adjust_point (nchars
, outgoing_nbytes
);
1172 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1173 starting at GPT_ADDR. */
1176 insert_from_gap (nchars
, nbytes
)
1177 register int nchars
, nbytes
;
1179 if (NILP (current_buffer
->enable_multibyte_characters
))
1182 record_insert (GPT
, nchars
);
1192 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1197 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1198 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1201 if (BUF_INTERVALS (current_buffer
) != 0)
1203 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1204 graft_intervals_into_buffer (NULL_INTERVAL
, GPT
- nchars
, nchars
,
1208 if (GPT
- nchars
< PT
)
1209 adjust_point (nchars
, nbytes
);
1214 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1215 current buffer. If the text in BUF has properties, they are absorbed
1216 into the current buffer.
1218 It does not work to use `insert' for this, because a malloc could happen
1219 and relocate BUF's text before the bcopy happens. */
1222 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1224 int charpos
, nchars
;
1229 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1230 signal_after_change (opoint
, 0, PT
- opoint
);
1231 update_compositions (opoint
, PT
, CHECK_BORDER
);
1235 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1240 register Lisp_Object temp
;
1241 int chunk
, chunk_expanded
;
1242 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1243 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1244 int incoming_nbytes
= to_byte
- from_byte
;
1245 int outgoing_nbytes
= incoming_nbytes
;
1248 /* Make OUTGOING_NBYTES describe the text
1249 as it will be inserted in this buffer. */
1251 if (NILP (current_buffer
->enable_multibyte_characters
))
1252 outgoing_nbytes
= nchars
;
1253 else if (NILP (buf
->enable_multibyte_characters
))
1255 int outgoing_before_gap
= 0;
1256 int outgoing_after_gap
= 0;
1258 if (from
< BUF_GPT (buf
))
1260 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1261 if (chunk
> incoming_nbytes
)
1262 chunk
= incoming_nbytes
;
1264 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1270 if (chunk
< incoming_nbytes
)
1272 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1274 incoming_nbytes
- chunk
);
1276 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1279 /* Make sure point-max won't overflow after this insertion. */
1280 XSETINT (temp
, outgoing_nbytes
+ Z
);
1281 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1282 error ("Maximum buffer size exceeded");
1284 /* Do this before moving and increasing the gap,
1285 because the before-change hooks might move the gap
1286 or make it smaller. */
1287 prepare_to_modify_buffer (PT
, PT
, NULL
);
1290 move_gap_both (PT
, PT_BYTE
);
1291 if (GAP_SIZE
< outgoing_nbytes
)
1292 make_gap (outgoing_nbytes
- GAP_SIZE
);
1294 if (from
< BUF_GPT (buf
))
1296 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1297 if (chunk
> incoming_nbytes
)
1298 chunk
= incoming_nbytes
;
1299 /* Record number of output bytes, so we know where
1300 to put the output from the second copy_text. */
1302 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1304 ! NILP (buf
->enable_multibyte_characters
),
1305 ! NILP (current_buffer
->enable_multibyte_characters
));
1308 chunk_expanded
= chunk
= 0;
1310 if (chunk
< incoming_nbytes
)
1311 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1312 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1313 ! NILP (buf
->enable_multibyte_characters
),
1314 ! NILP (current_buffer
->enable_multibyte_characters
));
1316 #ifdef BYTE_COMBINING_DEBUG
1317 /* We have copied text into the gap, but we have not altered
1318 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1319 to these functions and get the same results as we would
1320 have got earlier on. Meanwhile, GPT_ADDR does point to
1321 the text that has been stored by copy_text. */
1322 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1323 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1327 record_insert (PT
, nchars
);
1330 GAP_SIZE
-= outgoing_nbytes
;
1334 GPT_BYTE
+= outgoing_nbytes
;
1335 ZV_BYTE
+= outgoing_nbytes
;
1336 Z_BYTE
+= outgoing_nbytes
;
1337 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1342 /* The insert may have been in the unchanged region, so check again. */
1343 if (Z
- GPT
< END_UNCHANGED
)
1344 END_UNCHANGED
= Z
- GPT
;
1346 adjust_overlays_for_insert (PT
, nchars
);
1347 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1348 PT_BYTE
+ outgoing_nbytes
,
1351 if (BUF_INTERVALS (current_buffer
) != 0)
1352 offset_intervals (current_buffer
, PT
, nchars
);
1354 /* Get the intervals for the part of the string we are inserting. */
1355 intervals
= BUF_INTERVALS (buf
);
1356 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1358 if (buf
== current_buffer
&& PT
<= from
)
1360 intervals
= copy_intervals (intervals
, from
, nchars
);
1363 /* Insert those intervals. */
1364 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1366 adjust_point (nchars
, outgoing_nbytes
);
1369 /* Record undo information and adjust markers and position keepers for
1370 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1371 chars (LEN_BYTE bytes) which resides in the gap just after
1374 PREV_TEXT nil means the new text was just inserted. */
1377 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1378 int from
, from_byte
, len
, len_byte
;
1379 Lisp_Object prev_text
;
1381 int nchars_del
= 0, nbytes_del
= 0;
1383 #ifdef BYTE_COMBINING_DEBUG
1384 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1385 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1389 if (STRINGP (prev_text
))
1391 nchars_del
= SCHARS (prev_text
);
1392 nbytes_del
= SBYTES (prev_text
);
1395 /* Update various buffer positions for the new text. */
1396 GAP_SIZE
-= len_byte
;
1398 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1399 GPT
+= len
; GPT_BYTE
+= len_byte
;
1400 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1403 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1406 adjust_markers_for_insert (from
, from_byte
,
1407 from
+ len
, from_byte
+ len_byte
, 0);
1409 if (! EQ (current_buffer
->undo_list
, Qt
))
1412 record_delete (from
, prev_text
);
1413 record_insert (from
, len
);
1416 if (len
> nchars_del
)
1417 adjust_overlays_for_insert (from
, len
- nchars_del
);
1418 else if (len
< nchars_del
)
1419 adjust_overlays_for_delete (from
, nchars_del
- len
);
1420 if (BUF_INTERVALS (current_buffer
) != 0)
1422 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1426 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1428 /* As byte combining will decrease Z, we must check this again. */
1429 if (Z
- GPT
< END_UNCHANGED
)
1430 END_UNCHANGED
= Z
- GPT
;
1435 evaporate_overlays (from
);
1439 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1440 This is for use when undo is not enabled in the current buffer. */
1443 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1444 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1446 #ifdef BYTE_COMBINING_DEBUG
1447 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1448 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1452 /* Update various buffer positions for the new text. */
1453 GAP_SIZE
-= len_byte
;
1455 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1456 GPT
+= len
; GPT_BYTE
+= len_byte
;
1457 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1460 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1463 adjust_markers_for_insert (from
, from_byte
,
1464 from
+ len
, from_byte
+ len_byte
, 0);
1466 if (len
> nchars_del
)
1467 adjust_overlays_for_insert (from
, len
- nchars_del
);
1468 else if (len
< nchars_del
)
1469 adjust_overlays_for_delete (from
, nchars_del
- len
);
1470 if (BUF_INTERVALS (current_buffer
) != 0)
1472 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1476 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1478 /* As byte combining will decrease Z, we must check this again. */
1479 if (Z
- GPT
< END_UNCHANGED
)
1480 END_UNCHANGED
= Z
- GPT
;
1485 evaporate_overlays (from
);
1489 /* Record undo information, adjust markers and position keepers for an
1490 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1491 text already exists in the current buffer but character length (TO
1492 - FROM) may be incorrect, the correct length is NEWLEN. */
1495 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1496 int from
, from_byte
, to
, to_byte
, newlen
;
1498 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1501 move_gap_both (to
, to_byte
);
1502 GAP_SIZE
+= len_byte
;
1503 GPT
-= len
; GPT_BYTE
-= len_byte
;
1504 ZV
-= len
; ZV_BYTE
-= len_byte
;
1505 Z
-= len
; Z_BYTE
-= len_byte
;
1506 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1509 /* Replace the text from character positions FROM to TO with NEW,
1510 If PREPARE is nonzero, call prepare_to_modify_buffer.
1511 If INHERIT, the newly inserted text should inherit text properties
1512 from the surrounding non-deleted text. */
1514 /* Note that this does not yet handle markers quite right.
1515 Also it needs to record a single undo-entry that does a replacement
1516 rather than a separate delete and insert.
1517 That way, undo will also handle markers properly.
1519 But if MARKERS is 0, don't relocate markers. */
1522 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1524 int from
, to
, prepare
, inherit
, markers
;
1526 int inschars
= SCHARS (new);
1527 int insbytes
= SBYTES (new);
1528 int from_byte
, to_byte
;
1529 int nbytes_del
, nchars_del
;
1530 register Lisp_Object temp
;
1531 struct gcpro gcpro1
;
1533 int outgoing_insbytes
= insbytes
;
1534 Lisp_Object deletion
;
1543 int range_length
= to
- from
;
1544 prepare_to_modify_buffer (from
, to
, &from
);
1545 to
= from
+ range_length
;
1550 /* Make args be valid */
1556 from_byte
= CHAR_TO_BYTE (from
);
1557 to_byte
= CHAR_TO_BYTE (to
);
1559 nchars_del
= to
- from
;
1560 nbytes_del
= to_byte
- from_byte
;
1562 if (nbytes_del
<= 0 && insbytes
== 0)
1565 /* Make OUTGOING_INSBYTES describe the text
1566 as it will be inserted in this buffer. */
1568 if (NILP (current_buffer
->enable_multibyte_characters
))
1569 outgoing_insbytes
= inschars
;
1570 else if (! STRING_MULTIBYTE (new))
1572 = count_size_as_multibyte (SDATA (new), insbytes
);
1574 /* Make sure point-max won't overflow after this insertion. */
1575 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1576 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1577 error ("Maximum buffer size exceeded");
1581 /* Make sure the gap is somewhere in or next to what we are deleting. */
1583 gap_right (from
, from_byte
);
1585 gap_left (to
, to_byte
, 0);
1587 /* Even if we don't record for undo, we must keep the original text
1588 because we may have to recover it because of inappropriate byte
1590 if (! EQ (current_buffer
->undo_list
, Qt
))
1591 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1593 GAP_SIZE
+= nbytes_del
;
1596 ZV_BYTE
-= nbytes_del
;
1597 Z_BYTE
-= nbytes_del
;
1599 GPT_BYTE
= from_byte
;
1600 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1605 if (GPT
- BEG
< BEG_UNCHANGED
)
1606 BEG_UNCHANGED
= GPT
- BEG
;
1607 if (Z
- GPT
< END_UNCHANGED
)
1608 END_UNCHANGED
= Z
- GPT
;
1610 if (GAP_SIZE
< insbytes
)
1611 make_gap (insbytes
- GAP_SIZE
);
1613 /* Copy the string text into the buffer, perhaps converting
1614 between single-byte and multibyte. */
1615 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1616 STRING_MULTIBYTE (new),
1617 ! NILP (current_buffer
->enable_multibyte_characters
));
1619 #ifdef BYTE_COMBINING_DEBUG
1620 /* We have copied text into the gap, but we have not marked
1621 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1622 here, for both the previous text and the following text.
1623 Meanwhile, GPT_ADDR does point to
1624 the text that has been stored by copy_text. */
1625 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1626 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1630 if (! EQ (current_buffer
->undo_list
, Qt
))
1632 record_delete (from
, deletion
);
1633 record_insert (from
, inschars
);
1636 GAP_SIZE
-= outgoing_insbytes
;
1640 GPT_BYTE
+= outgoing_insbytes
;
1641 ZV_BYTE
+= outgoing_insbytes
;
1642 Z_BYTE
+= outgoing_insbytes
;
1643 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1648 /* Adjust the overlay center as needed. This must be done after
1649 adjusting the markers that bound the overlays. */
1650 adjust_overlays_for_delete (from
, nchars_del
);
1651 adjust_overlays_for_insert (from
, inschars
);
1653 /* Adjust markers for the deletion and the insertion. */
1655 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1656 inschars
, outgoing_insbytes
);
1658 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1660 /* Get the intervals for the part of the string we are inserting--
1661 not including the combined-before bytes. */
1662 intervals
= STRING_INTERVALS (new);
1663 /* Insert those intervals. */
1664 graft_intervals_into_buffer (intervals
, from
, inschars
,
1665 current_buffer
, inherit
);
1667 /* Relocate point as if it were a marker. */
1669 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1670 (from_byte
+ outgoing_insbytes
1671 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1673 if (outgoing_insbytes
== 0)
1674 evaporate_overlays (from
);
1681 signal_after_change (from
, nchars_del
, GPT
- from
);
1682 update_compositions (from
, GPT
, CHECK_BORDER
);
1685 /* Replace the text from character positions FROM to TO with
1686 the text in INS of length INSCHARS.
1687 Keep the text properties that applied to the old characters
1688 (extending them to all the new chars if there are more new chars).
1690 Note that this does not yet handle markers quite right.
1692 If MARKERS is nonzero, relocate markers.
1694 Unlike most functions at this level, never call
1695 prepare_to_modify_buffer and never call signal_after_change. */
1698 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1699 int from
, from_byte
, to
, to_byte
;
1701 int inschars
, insbytes
, markers
;
1703 int nbytes_del
, nchars_del
;
1708 nchars_del
= to
- from
;
1709 nbytes_del
= to_byte
- from_byte
;
1711 if (nbytes_del
<= 0 && insbytes
== 0)
1714 /* Make sure point-max won't overflow after this insertion. */
1715 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1716 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1717 error ("Maximum buffer size exceeded");
1719 /* Make sure the gap is somewhere in or next to what we are deleting. */
1721 gap_right (from
, from_byte
);
1723 gap_left (to
, to_byte
, 0);
1725 GAP_SIZE
+= nbytes_del
;
1728 ZV_BYTE
-= nbytes_del
;
1729 Z_BYTE
-= nbytes_del
;
1731 GPT_BYTE
= from_byte
;
1732 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1737 if (GPT
- BEG
< BEG_UNCHANGED
)
1738 BEG_UNCHANGED
= GPT
- BEG
;
1739 if (Z
- GPT
< END_UNCHANGED
)
1740 END_UNCHANGED
= Z
- GPT
;
1742 if (GAP_SIZE
< insbytes
)
1743 make_gap (insbytes
- GAP_SIZE
);
1745 /* Copy the replacement text into the buffer. */
1746 bcopy (ins
, GPT_ADDR
, insbytes
);
1748 #ifdef BYTE_COMBINING_DEBUG
1749 /* We have copied text into the gap, but we have not marked
1750 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1751 here, for both the previous text and the following text.
1752 Meanwhile, GPT_ADDR does point to
1753 the text that has been stored by copy_text. */
1754 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1755 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1759 GAP_SIZE
-= insbytes
;
1763 GPT_BYTE
+= insbytes
;
1764 ZV_BYTE
+= insbytes
;
1766 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1771 /* Adjust the overlay center as needed. This must be done after
1772 adjusting the markers that bound the overlays. */
1773 if (nchars_del
!= inschars
)
1775 adjust_overlays_for_insert (from
, inschars
);
1776 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1779 /* Adjust markers for the deletion and the insertion. */
1781 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1782 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1783 inschars
, insbytes
);
1785 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1787 /* Relocate point as if it were a marker. */
1788 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1791 /* PT was within the deleted text. Move it to FROM. */
1792 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1794 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1798 evaporate_overlays (from
);
1805 /* Delete characters in current buffer
1806 from FROM up to (but not including) TO.
1807 If TO comes before FROM, we delete nothing. */
1810 del_range (from
, to
)
1811 register int from
, to
;
1813 del_range_1 (from
, to
, 1, 0);
1816 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1817 RET_STRING says to return the deleted text. */
1820 del_range_1 (from
, to
, prepare
, ret_string
)
1821 int from
, to
, prepare
, ret_string
;
1823 int from_byte
, to_byte
;
1824 Lisp_Object deletion
;
1825 struct gcpro gcpro1
;
1827 /* Make args be valid */
1838 int range_length
= to
- from
;
1839 prepare_to_modify_buffer (from
, to
, &from
);
1840 to
= min (ZV
, from
+ range_length
);
1843 from_byte
= CHAR_TO_BYTE (from
);
1844 to_byte
= CHAR_TO_BYTE (to
);
1846 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1848 signal_after_change (from
, to
- from
, 0);
1849 update_compositions (from
, from
, CHECK_HEAD
);
1854 /* Like del_range_1 but args are byte positions, not char positions. */
1857 del_range_byte (from_byte
, to_byte
, prepare
)
1858 int from_byte
, to_byte
, prepare
;
1862 /* Make args be valid */
1863 if (from_byte
< BEGV_BYTE
)
1864 from_byte
= BEGV_BYTE
;
1865 if (to_byte
> ZV_BYTE
)
1868 if (to_byte
<= from_byte
)
1871 from
= BYTE_TO_CHAR (from_byte
);
1872 to
= BYTE_TO_CHAR (to_byte
);
1876 int old_from
= from
, old_to
= Z
- to
;
1877 int range_length
= to
- from
;
1878 prepare_to_modify_buffer (from
, to
, &from
);
1879 to
= from
+ range_length
;
1881 if (old_from
!= from
)
1882 from_byte
= CHAR_TO_BYTE (from
);
1888 else if (old_to
== Z
- to
)
1889 to_byte
= CHAR_TO_BYTE (to
);
1892 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1893 signal_after_change (from
, to
- from
, 0);
1894 update_compositions (from
, from
, CHECK_HEAD
);
1897 /* Like del_range_1, but positions are specified both as charpos
1901 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1902 int from
, from_byte
, to
, to_byte
, prepare
;
1904 /* Make args be valid */
1905 if (from_byte
< BEGV_BYTE
)
1906 from_byte
= BEGV_BYTE
;
1907 if (to_byte
> ZV_BYTE
)
1910 if (to_byte
<= from_byte
)
1920 int old_from
= from
, old_to
= Z
- to
;
1921 int range_length
= to
- from
;
1922 prepare_to_modify_buffer (from
, to
, &from
);
1923 to
= from
+ range_length
;
1925 if (old_from
!= from
)
1926 from_byte
= CHAR_TO_BYTE (from
);
1932 else if (old_to
== Z
- to
)
1933 to_byte
= CHAR_TO_BYTE (to
);
1936 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1937 signal_after_change (from
, to
- from
, 0);
1938 update_compositions (from
, from
, CHECK_HEAD
);
1941 /* Delete a range of text, specified both as character positions
1942 and byte positions. FROM and TO are character positions,
1943 while FROM_BYTE and TO_BYTE are byte positions.
1944 If RET_STRING is true, the deleted area is returned as a string. */
1947 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1948 int from
, from_byte
, to
, to_byte
, ret_string
;
1950 register int nbytes_del
, nchars_del
;
1951 Lisp_Object deletion
;
1955 nchars_del
= to
- from
;
1956 nbytes_del
= to_byte
- from_byte
;
1958 /* Make sure the gap is somewhere in or next to what we are deleting. */
1960 gap_right (from
, from_byte
);
1962 gap_left (to
, to_byte
, 0);
1964 #ifdef BYTE_COMBINING_DEBUG
1965 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1966 Z_BYTE
- to_byte
, from
, from_byte
))
1970 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1971 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1975 /* Relocate all markers pointing into the new, larger gap
1976 to point at the end of the text before the gap.
1977 Do this before recording the deletion,
1978 so that undo handles this after reinserting the text. */
1979 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1981 if (! EQ (current_buffer
->undo_list
, Qt
))
1982 record_delete (from
, deletion
);
1985 /* Relocate point as if it were a marker. */
1987 adjust_point (from
- (PT
< to
? PT
: to
),
1988 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1990 offset_intervals (current_buffer
, from
, - nchars_del
);
1992 /* Adjust the overlay center as needed. This must be done after
1993 adjusting the markers that bound the overlays. */
1994 adjust_overlays_for_delete (from
, nchars_del
);
1996 GAP_SIZE
+= nbytes_del
;
1997 ZV_BYTE
-= nbytes_del
;
1998 Z_BYTE
-= nbytes_del
;
2002 GPT_BYTE
= from_byte
;
2003 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
2008 if (GPT
- BEG
< BEG_UNCHANGED
)
2009 BEG_UNCHANGED
= GPT
- BEG
;
2010 if (Z
- GPT
< END_UNCHANGED
)
2011 END_UNCHANGED
= Z
- GPT
;
2015 evaporate_overlays (from
);
2020 /* Call this if you're about to change the region of BUFFER from
2021 character positions START to END. This checks the read-only
2022 properties of the region, calls the necessary modification hooks,
2023 and warns the next redisplay that it should pay attention to that
2027 modify_region (buffer
, start
, end
)
2028 struct buffer
*buffer
;
2031 struct buffer
*old_buffer
= current_buffer
;
2033 if (buffer
!= old_buffer
)
2034 set_buffer_internal (buffer
);
2036 prepare_to_modify_buffer (start
, end
, NULL
);
2038 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
2040 if (MODIFF
<= SAVE_MODIFF
)
2041 record_first_change ();
2044 buffer
->point_before_scroll
= Qnil
;
2046 if (buffer
!= old_buffer
)
2047 set_buffer_internal (old_buffer
);
2050 /* Check that it is okay to modify the buffer between START and END,
2051 which are char positions.
2053 Run the before-change-function, if any. If intervals are in use,
2054 verify that the text to be modified is not read-only, and call
2055 any modification properties the text may have.
2057 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2058 by holding its value temporarily in a marker. */
2061 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2065 if (!NILP (current_buffer
->read_only
))
2066 Fbarf_if_buffer_read_only ();
2068 /* Let redisplay consider other windows than selected_window
2069 if modifying another buffer. */
2070 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2071 ++windows_or_buffers_changed
;
2073 if (BUF_INTERVALS (current_buffer
) != 0)
2077 Lisp_Object preserve_marker
;
2078 struct gcpro gcpro1
;
2079 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2080 GCPRO1 (preserve_marker
);
2081 verify_interval_modification (current_buffer
, start
, end
);
2082 *preserve_ptr
= marker_position (preserve_marker
);
2083 unchain_marker (XMARKER (preserve_marker
));
2087 verify_interval_modification (current_buffer
, start
, end
);
2090 #ifdef CLASH_DETECTION
2091 if (!NILP (current_buffer
->file_truename
)
2092 /* Make binding buffer-file-name to nil effective. */
2093 && !NILP (current_buffer
->filename
)
2094 && SAVE_MODIFF
>= MODIFF
)
2095 lock_file (current_buffer
->file_truename
);
2097 /* At least warn if this file has changed on disk since it was visited. */
2098 if (!NILP (current_buffer
->filename
)
2099 && SAVE_MODIFF
>= MODIFF
2100 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2101 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2102 call1 (intern ("ask-user-about-supersession-threat"),
2103 current_buffer
->filename
);
2104 #endif /* not CLASH_DETECTION */
2106 signal_before_change (start
, end
, preserve_ptr
);
2108 if (current_buffer
->newline_cache
)
2109 invalidate_region_cache (current_buffer
,
2110 current_buffer
->newline_cache
,
2111 start
- BEG
, Z
- end
);
2112 if (current_buffer
->width_run_cache
)
2113 invalidate_region_cache (current_buffer
,
2114 current_buffer
->width_run_cache
,
2115 start
- BEG
, Z
- end
);
2117 Vdeactivate_mark
= Qt
;
2120 /* These macros work with an argument named `preserve_ptr'
2121 and a local variable named `preserve_marker'. */
2123 #define PRESERVE_VALUE \
2124 if (preserve_ptr && NILP (preserve_marker)) \
2125 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2127 #define RESTORE_VALUE \
2128 if (! NILP (preserve_marker)) \
2130 *preserve_ptr = marker_position (preserve_marker); \
2131 unchain_marker (XMARKER (preserve_marker)); \
2134 #define PRESERVE_START_END \
2135 if (NILP (start_marker)) \
2136 start_marker = Fcopy_marker (start, Qnil); \
2137 if (NILP (end_marker)) \
2138 end_marker = Fcopy_marker (end, Qnil);
2140 #define FETCH_START \
2141 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2144 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2146 /* Signal a change to the buffer immediately before it happens.
2147 START_INT and END_INT are the bounds of the text to be changed.
2149 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2150 by holding its value temporarily in a marker. */
2153 signal_before_change (start_int
, end_int
, preserve_ptr
)
2154 int start_int
, end_int
;
2157 Lisp_Object start
, end
;
2158 Lisp_Object start_marker
, end_marker
;
2159 Lisp_Object preserve_marker
;
2160 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2162 if (inhibit_modification_hooks
)
2165 start
= make_number (start_int
);
2166 end
= make_number (end_int
);
2167 preserve_marker
= Qnil
;
2168 start_marker
= Qnil
;
2170 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2172 /* If buffer is unmodified, run a special hook for that case. */
2173 if (SAVE_MODIFF
>= MODIFF
2174 && !NILP (Vfirst_change_hook
)
2175 && !NILP (Vrun_hooks
))
2179 call1 (Vrun_hooks
, Qfirst_change_hook
);
2182 /* Now run the before-change-functions if any. */
2183 if (!NILP (Vbefore_change_functions
))
2185 Lisp_Object args
[3];
2186 Lisp_Object before_change_functions
;
2187 Lisp_Object after_change_functions
;
2188 struct gcpro gcpro1
, gcpro2
;
2189 struct buffer
*old
= current_buffer
;
2195 /* "Bind" before-change-functions and after-change-functions
2196 to nil--but in a way that errors don't know about.
2197 That way, if there's an error in them, they will stay nil. */
2198 before_change_functions
= Vbefore_change_functions
;
2199 after_change_functions
= Vafter_change_functions
;
2200 Vbefore_change_functions
= Qnil
;
2201 Vafter_change_functions
= Qnil
;
2202 GCPRO2 (before_change_functions
, after_change_functions
);
2204 /* Actually run the hook functions. */
2205 args
[0] = Qbefore_change_functions
;
2206 args
[1] = FETCH_START
;
2207 args
[2] = FETCH_END
;
2208 run_hook_list_with_args (before_change_functions
, 3, args
);
2210 /* "Unbind" the variables we "bound" to nil. Beware a
2211 buffer-local hook which changes the buffer when run (e.g. W3). */
2212 if (old
!= current_buffer
)
2214 new = current_buffer
;
2215 set_buffer_internal (old
);
2216 Vbefore_change_functions
= before_change_functions
;
2217 Vafter_change_functions
= after_change_functions
;
2218 set_buffer_internal (new);
2222 Vbefore_change_functions
= before_change_functions
;
2223 Vafter_change_functions
= after_change_functions
;
2228 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2231 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2232 FETCH_START
, FETCH_END
, Qnil
);
2235 if (! NILP (start_marker
))
2236 free_marker (start_marker
);
2237 if (! NILP (end_marker
))
2238 free_marker (end_marker
);
2243 /* Signal a change immediately after it happens.
2244 CHARPOS is the character position of the start of the changed text.
2245 LENDEL is the number of characters of the text before the change.
2246 (Not the whole buffer; just the part that was changed.)
2247 LENINS is the number of characters in that part of the text
2248 after the change. */
2251 signal_after_change (charpos
, lendel
, lenins
)
2252 int charpos
, lendel
, lenins
;
2254 if (inhibit_modification_hooks
)
2257 /* If we are deferring calls to the after-change functions
2258 and there are no before-change functions,
2259 just record the args that we were going to use. */
2260 if (! NILP (Vcombine_after_change_calls
)
2261 && NILP (Vbefore_change_functions
)
2262 && !current_buffer
->overlays_before
2263 && !current_buffer
->overlays_after
)
2267 if (!NILP (combine_after_change_list
)
2268 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2269 Fcombine_after_change_execute ();
2271 elt
= Fcons (make_number (charpos
- BEG
),
2272 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2273 Fcons (make_number (lenins
- lendel
), Qnil
)));
2274 combine_after_change_list
2275 = Fcons (elt
, combine_after_change_list
);
2276 combine_after_change_buffer
= Fcurrent_buffer ();
2281 if (!NILP (combine_after_change_list
))
2282 Fcombine_after_change_execute ();
2284 if (!NILP (Vafter_change_functions
))
2286 Lisp_Object args
[4];
2287 Lisp_Object before_change_functions
;
2288 Lisp_Object after_change_functions
;
2289 struct buffer
*old
= current_buffer
;
2291 struct gcpro gcpro1
, gcpro2
;
2293 /* "Bind" before-change-functions and after-change-functions
2294 to nil--but in a way that errors don't know about.
2295 That way, if there's an error in them, they will stay nil. */
2296 before_change_functions
= Vbefore_change_functions
;
2297 after_change_functions
= Vafter_change_functions
;
2298 Vbefore_change_functions
= Qnil
;
2299 Vafter_change_functions
= Qnil
;
2300 GCPRO2 (before_change_functions
, after_change_functions
);
2302 /* Actually run the hook functions. */
2303 args
[0] = Qafter_change_functions
;
2304 XSETFASTINT (args
[1], charpos
);
2305 XSETFASTINT (args
[2], charpos
+ lenins
);
2306 XSETFASTINT (args
[3], lendel
);
2307 run_hook_list_with_args (after_change_functions
,
2310 /* "Unbind" the variables we "bound" to nil. Beware a
2311 buffer-local hook which changes the buffer when run (e.g. W3). */
2312 if (old
!= current_buffer
)
2314 new = current_buffer
;
2315 set_buffer_internal (old
);
2316 Vbefore_change_functions
= before_change_functions
;
2317 Vafter_change_functions
= after_change_functions
;
2318 set_buffer_internal (new);
2322 Vbefore_change_functions
= before_change_functions
;
2323 Vafter_change_functions
= after_change_functions
;
2328 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2329 report_overlay_modification (make_number (charpos
),
2330 make_number (charpos
+ lenins
),
2332 make_number (charpos
),
2333 make_number (charpos
+ lenins
),
2334 make_number (lendel
));
2336 /* After an insertion, call the text properties
2337 insert-behind-hooks or insert-in-front-hooks. */
2339 report_interval_modification (make_number (charpos
),
2340 make_number (charpos
+ lenins
));
2344 Fcombine_after_change_execute_1 (val
)
2347 Vcombine_after_change_calls
= val
;
2351 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2352 Scombine_after_change_execute
, 0, 0, 0,
2353 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2356 int count
= SPECPDL_INDEX ();
2357 int beg
, end
, change
;
2361 if (NILP (combine_after_change_list
))
2364 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2366 Fset_buffer (combine_after_change_buffer
);
2368 /* # chars unchanged at beginning of buffer. */
2370 /* # chars unchanged at end of buffer. */
2372 /* Total amount of insertion (negative for deletion). */
2375 /* Scan the various individual changes,
2376 accumulating the range info in BEG, END and CHANGE. */
2377 for (tail
= combine_after_change_list
; CONSP (tail
);
2381 int thisbeg
, thisend
, thischange
;
2383 /* Extract the info from the next element. */
2387 thisbeg
= XINT (XCAR (elt
));
2392 thisend
= XINT (XCAR (elt
));
2397 thischange
= XINT (XCAR (elt
));
2399 /* Merge this range into the accumulated range. */
2400 change
+= thischange
;
2407 /* Get the current start and end positions of the range
2408 that was changed. */
2412 /* We are about to handle these, so discard them. */
2413 combine_after_change_list
= Qnil
;
2415 /* Now run the after-change functions for real.
2416 Turn off the flag that defers them. */
2417 record_unwind_protect (Fcombine_after_change_execute_1
,
2418 Vcombine_after_change_calls
);
2419 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2420 update_compositions (begpos
, endpos
, CHECK_ALL
);
2422 return unbind_to (count
, Qnil
);
2428 staticpro (&combine_after_change_list
);
2429 combine_after_change_list
= Qnil
;
2430 combine_after_change_buffer
= Qnil
;
2432 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2433 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2434 check_markers_debug_flag
= 0;
2435 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2436 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2437 Vcombine_after_change_calls
= Qnil
;
2439 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2440 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2441 This affects `before-change-functions' and `after-change-functions',
2442 as well as hooks attached to text properties and overlays. */);
2443 inhibit_modification_hooks
= 0;
2444 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2445 staticpro (&Qinhibit_modification_hooks
);
2447 defsubr (&Scombine_after_change_execute
);
2450 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2451 (do not change this comment) */