1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006 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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, 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
;
741 int len
= chars_in_text (string
, nbytes
), opoint
;
742 insert_1_both (string
, len
, nbytes
, 0, 1, 0);
744 signal_after_change (opoint
, 0, len
);
745 update_compositions (opoint
, PT
, CHECK_BORDER
);
749 /* Likewise, but inherit text properties from neighboring characters. */
752 insert_and_inherit (string
, nbytes
)
753 register const unsigned char *string
;
758 int len
= chars_in_text (string
, nbytes
), opoint
;
759 insert_1_both (string
, len
, nbytes
, 1, 1, 0);
761 signal_after_change (opoint
, 0, len
);
762 update_compositions (opoint
, PT
, CHECK_BORDER
);
766 /* Insert the character C before point. Do not inherit text properties. */
772 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
775 if (! NILP (current_buffer
->enable_multibyte_characters
))
776 len
= CHAR_STRING (c
, str
);
786 /* Insert the null-terminated string S before point. */
792 insert (s
, strlen (s
));
795 /* Like `insert' except that all markers pointing at the place where
796 the insertion happens are adjusted to point after it.
797 Don't use this function to insert part of a Lisp string,
798 since gc could happen and relocate it. */
801 insert_before_markers (string
, nbytes
)
802 const unsigned char *string
;
807 int len
= chars_in_text (string
, nbytes
), opoint
;
808 insert_1_both (string
, len
, nbytes
, 0, 1, 1);
810 signal_after_change (opoint
, 0, len
);
811 update_compositions (opoint
, PT
, CHECK_BORDER
);
815 /* Likewise, but inherit text properties from neighboring characters. */
818 insert_before_markers_and_inherit (string
, nbytes
)
819 const unsigned char *string
;
824 int len
= chars_in_text (string
, nbytes
), opoint
;
825 insert_1_both (string
, len
, nbytes
, 1, 1, 1);
827 signal_after_change (opoint
, 0, len
);
828 update_compositions (opoint
, PT
, CHECK_BORDER
);
832 /* Subroutine used by the insert functions above. */
835 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
836 register const unsigned char *string
;
838 int inherit
, prepare
, before_markers
;
840 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
841 inherit
, prepare
, before_markers
);
845 #ifdef BYTE_COMBINING_DEBUG
847 /* See if the bytes before POS/POS_BYTE combine with bytes
848 at the start of STRING to form a single character.
849 If so, return the number of bytes at the start of STRING
850 which combine in this way. Otherwise, return 0. */
853 count_combining_before (string
, length
, pos
, pos_byte
)
854 const unsigned char *string
;
858 int len
, combining_bytes
;
859 const unsigned char *p
;
861 if (NILP (current_buffer
->enable_multibyte_characters
))
864 /* At first, we can exclude the following cases:
865 (1) STRING[0] can't be a following byte of multibyte sequence.
866 (2) POS is the start of the current buffer.
867 (3) A character before POS is not a multibyte character. */
868 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
870 if (pos_byte
== BEG_BYTE
) /* case (2) */
873 p
= BYTE_POS_ADDR (pos_byte
- 1);
874 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
875 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
878 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
879 if (combining_bytes
<= 0)
880 /* The character preceding POS is, complete and no room for
881 combining bytes (combining_bytes == 0), or an independent 8-bit
882 character (combining_bytes < 0). */
885 /* We have a combination situation. Count the bytes at STRING that
888 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
891 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
894 /* See if the bytes after POS/POS_BYTE combine with bytes
895 at the end of STRING to form a single character.
896 If so, return the number of bytes after POS/POS_BYTE
897 which combine in this way. Otherwise, return 0. */
900 count_combining_after (string
, length
, pos
, pos_byte
)
901 const unsigned char *string
;
905 int opos_byte
= pos_byte
;
910 if (NILP (current_buffer
->enable_multibyte_characters
))
913 /* At first, we can exclude the following cases:
914 (1) The last byte of STRING is an ASCII.
915 (2) POS is the last of the current buffer.
916 (3) A character at POS can't be a following byte of multibyte
918 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
920 if (pos_byte
== Z_BYTE
) /* case (2) */
922 bufp
= BYTE_POS_ADDR (pos_byte
);
923 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
927 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
933 /* All characters in STRING are not character head. We must
934 check also preceding bytes at POS. We are sure that the gap
936 unsigned char *p
= BEG_ADDR
;
938 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
940 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
943 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
944 return (bytes
<= pos_byte
- 1 - i
+ length
946 : bytes
- (pos_byte
- 1 - i
+ length
));
948 if (!BASE_LEADING_CODE_P (string
[i
]))
951 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
953 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
955 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
961 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
962 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
963 are the same as in insert_1. */
966 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
967 register const unsigned char *string
;
968 register int nchars
, nbytes
;
969 int inherit
, prepare
, before_markers
;
974 if (NILP (current_buffer
->enable_multibyte_characters
))
978 /* Do this before moving and increasing the gap,
979 because the before-change hooks might move the gap
980 or make it smaller. */
981 prepare_to_modify_buffer (PT
, PT
, NULL
);
984 move_gap_both (PT
, PT_BYTE
);
985 if (GAP_SIZE
< nbytes
)
986 make_gap (nbytes
- GAP_SIZE
);
988 #ifdef BYTE_COMBINING_DEBUG
989 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
990 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
994 /* Record deletion of the surrounding text that combines with
995 the insertion. This, together with recording the insertion,
996 will add up to the right stuff in the undo list. */
997 record_insert (PT
, nchars
);
1000 bcopy (string
, GPT_ADDR
, nbytes
);
1009 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1014 /* The insert may have been in the unchanged region, so check again. */
1015 if (Z
- GPT
< END_UNCHANGED
)
1016 END_UNCHANGED
= Z
- GPT
;
1018 adjust_overlays_for_insert (PT
, nchars
);
1019 adjust_markers_for_insert (PT
, PT_BYTE
,
1020 PT
+ nchars
, PT_BYTE
+ nbytes
,
1023 if (BUF_INTERVALS (current_buffer
) != 0)
1024 offset_intervals (current_buffer
, PT
, nchars
);
1026 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1027 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1030 adjust_point (nchars
, nbytes
);
1035 /* Insert the part of the text of STRING, a Lisp object assumed to be
1036 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1037 starting at position POS / POS_BYTE. If the text of STRING has properties,
1038 copy them into the buffer.
1040 It does not work to use `insert' for this, because a GC could happen
1041 before we bcopy the stuff into the buffer, and relocate the string
1042 without insert noticing. */
1045 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1047 register int pos
, pos_byte
, length
, length_byte
;
1052 if (SCHARS (string
) == 0)
1055 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1057 signal_after_change (opoint
, 0, PT
- opoint
);
1058 update_compositions (opoint
, PT
, CHECK_BORDER
);
1061 /* Like `insert_from_string' except that all markers pointing
1062 at the place where the insertion happens are adjusted to point after it. */
1065 insert_from_string_before_markers (string
, pos
, pos_byte
,
1066 length
, length_byte
, inherit
)
1068 register int pos
, pos_byte
, length
, length_byte
;
1073 if (SCHARS (string
) == 0)
1076 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1078 signal_after_change (opoint
, 0, PT
- opoint
);
1079 update_compositions (opoint
, PT
, CHECK_BORDER
);
1082 /* Subroutine of the insertion functions above. */
1085 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1086 inherit
, before_markers
)
1088 register int pos
, pos_byte
, nchars
, nbytes
;
1089 int inherit
, before_markers
;
1091 struct gcpro gcpro1
;
1092 int outgoing_nbytes
= nbytes
;
1095 /* Make OUTGOING_NBYTES describe the text
1096 as it will be inserted in this buffer. */
1098 if (NILP (current_buffer
->enable_multibyte_characters
))
1099 outgoing_nbytes
= nchars
;
1100 else if (! STRING_MULTIBYTE (string
))
1102 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
1106 /* Do this before moving and increasing the gap,
1107 because the before-change hooks might move the gap
1108 or make it smaller. */
1109 prepare_to_modify_buffer (PT
, PT
, NULL
);
1112 move_gap_both (PT
, PT_BYTE
);
1113 if (GAP_SIZE
< outgoing_nbytes
)
1114 make_gap (outgoing_nbytes
- GAP_SIZE
);
1117 /* Copy the string text into the buffer, perhaps converting
1118 between single-byte and multibyte. */
1119 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
1120 STRING_MULTIBYTE (string
),
1121 ! NILP (current_buffer
->enable_multibyte_characters
));
1123 #ifdef BYTE_COMBINING_DEBUG
1124 /* We have copied text into the gap, but we have not altered
1125 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1126 to these functions and get the same results as we would
1127 have got earlier on. Meanwhile, PT_ADDR does point to
1128 the text that has been stored by copy_text. */
1129 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1130 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1134 record_insert (PT
, nchars
);
1137 GAP_SIZE
-= outgoing_nbytes
;
1141 GPT_BYTE
+= outgoing_nbytes
;
1142 ZV_BYTE
+= outgoing_nbytes
;
1143 Z_BYTE
+= outgoing_nbytes
;
1144 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1149 /* The insert may have been in the unchanged region, so check again. */
1150 if (Z
- GPT
< END_UNCHANGED
)
1151 END_UNCHANGED
= Z
- GPT
;
1153 adjust_overlays_for_insert (PT
, nchars
);
1154 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1155 PT_BYTE
+ outgoing_nbytes
,
1158 offset_intervals (current_buffer
, PT
, nchars
);
1160 intervals
= STRING_INTERVALS (string
);
1161 /* Get the intervals for the part of the string we are inserting. */
1162 if (nbytes
< SBYTES (string
))
1163 intervals
= copy_intervals (intervals
, pos
, nchars
);
1165 /* Insert those intervals. */
1166 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1167 current_buffer
, inherit
);
1169 adjust_point (nchars
, outgoing_nbytes
);
1174 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1175 starting at GPT_ADDR. */
1178 insert_from_gap (nchars
, nbytes
)
1179 register int nchars
, nbytes
;
1181 if (NILP (current_buffer
->enable_multibyte_characters
))
1184 record_insert (GPT
, nchars
);
1194 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1199 adjust_overlays_for_insert (GPT
- nchars
, nchars
);
1200 adjust_markers_for_insert (GPT
- nchars
, GPT_BYTE
- nbytes
,
1203 if (BUF_INTERVALS (current_buffer
) != 0)
1205 offset_intervals (current_buffer
, GPT
- nchars
, nchars
);
1206 graft_intervals_into_buffer (NULL_INTERVAL
, GPT
- nchars
, nchars
,
1210 if (GPT
- nchars
< PT
)
1211 adjust_point (nchars
, nbytes
);
1216 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1217 current buffer. If the text in BUF has properties, they are absorbed
1218 into the current buffer.
1220 It does not work to use `insert' for this, because a malloc could happen
1221 and relocate BUF's text before the bcopy happens. */
1224 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1226 int charpos
, nchars
;
1231 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1232 signal_after_change (opoint
, 0, PT
- opoint
);
1233 update_compositions (opoint
, PT
, CHECK_BORDER
);
1237 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1242 register Lisp_Object temp
;
1243 int chunk
, chunk_expanded
;
1244 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1245 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1246 int incoming_nbytes
= to_byte
- from_byte
;
1247 int outgoing_nbytes
= incoming_nbytes
;
1250 /* Make OUTGOING_NBYTES describe the text
1251 as it will be inserted in this buffer. */
1253 if (NILP (current_buffer
->enable_multibyte_characters
))
1254 outgoing_nbytes
= nchars
;
1255 else if (NILP (buf
->enable_multibyte_characters
))
1257 int outgoing_before_gap
= 0;
1258 int outgoing_after_gap
= 0;
1260 if (from
< BUF_GPT (buf
))
1262 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1263 if (chunk
> incoming_nbytes
)
1264 chunk
= incoming_nbytes
;
1266 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1272 if (chunk
< incoming_nbytes
)
1274 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1276 incoming_nbytes
- chunk
);
1278 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1281 /* Make sure point-max won't overflow after this insertion. */
1282 XSETINT (temp
, outgoing_nbytes
+ Z
);
1283 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1284 error ("Maximum buffer size exceeded");
1286 /* Do this before moving and increasing the gap,
1287 because the before-change hooks might move the gap
1288 or make it smaller. */
1289 prepare_to_modify_buffer (PT
, PT
, NULL
);
1292 move_gap_both (PT
, PT_BYTE
);
1293 if (GAP_SIZE
< outgoing_nbytes
)
1294 make_gap (outgoing_nbytes
- GAP_SIZE
);
1296 if (from
< BUF_GPT (buf
))
1298 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1299 if (chunk
> incoming_nbytes
)
1300 chunk
= incoming_nbytes
;
1301 /* Record number of output bytes, so we know where
1302 to put the output from the second copy_text. */
1304 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1306 ! NILP (buf
->enable_multibyte_characters
),
1307 ! NILP (current_buffer
->enable_multibyte_characters
));
1310 chunk_expanded
= chunk
= 0;
1312 if (chunk
< incoming_nbytes
)
1313 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1314 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1315 ! NILP (buf
->enable_multibyte_characters
),
1316 ! NILP (current_buffer
->enable_multibyte_characters
));
1318 #ifdef BYTE_COMBINING_DEBUG
1319 /* We have copied text into the gap, but we have not altered
1320 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1321 to these functions and get the same results as we would
1322 have got earlier on. Meanwhile, GPT_ADDR does point to
1323 the text that has been stored by copy_text. */
1324 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1325 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1329 record_insert (PT
, nchars
);
1332 GAP_SIZE
-= outgoing_nbytes
;
1336 GPT_BYTE
+= outgoing_nbytes
;
1337 ZV_BYTE
+= outgoing_nbytes
;
1338 Z_BYTE
+= outgoing_nbytes
;
1339 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1344 /* The insert may have been in the unchanged region, so check again. */
1345 if (Z
- GPT
< END_UNCHANGED
)
1346 END_UNCHANGED
= Z
- GPT
;
1348 adjust_overlays_for_insert (PT
, nchars
);
1349 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1350 PT_BYTE
+ outgoing_nbytes
,
1353 if (BUF_INTERVALS (current_buffer
) != 0)
1354 offset_intervals (current_buffer
, PT
, nchars
);
1356 /* Get the intervals for the part of the string we are inserting. */
1357 intervals
= BUF_INTERVALS (buf
);
1358 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1360 if (buf
== current_buffer
&& PT
<= from
)
1362 intervals
= copy_intervals (intervals
, from
, nchars
);
1365 /* Insert those intervals. */
1366 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1368 adjust_point (nchars
, outgoing_nbytes
);
1371 /* Record undo information and adjust markers and position keepers for
1372 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1373 chars (LEN_BYTE bytes) which resides in the gap just after
1376 PREV_TEXT nil means the new text was just inserted. */
1379 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1380 int from
, from_byte
, len
, len_byte
;
1381 Lisp_Object prev_text
;
1383 int nchars_del
= 0, nbytes_del
= 0;
1385 #ifdef BYTE_COMBINING_DEBUG
1386 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1387 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1391 if (STRINGP (prev_text
))
1393 nchars_del
= SCHARS (prev_text
);
1394 nbytes_del
= SBYTES (prev_text
);
1397 /* Update various buffer positions for the new text. */
1398 GAP_SIZE
-= len_byte
;
1400 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1401 GPT
+= len
; GPT_BYTE
+= len_byte
;
1402 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1405 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1408 adjust_markers_for_insert (from
, from_byte
,
1409 from
+ len
, from_byte
+ len_byte
, 0);
1411 if (! EQ (current_buffer
->undo_list
, Qt
))
1414 record_delete (from
, prev_text
);
1415 record_insert (from
, len
);
1418 if (len
> nchars_del
)
1419 adjust_overlays_for_insert (from
, len
- nchars_del
);
1420 else if (len
< nchars_del
)
1421 adjust_overlays_for_delete (from
, nchars_del
- len
);
1422 if (BUF_INTERVALS (current_buffer
) != 0)
1424 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1428 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1430 /* As byte combining will decrease Z, we must check this again. */
1431 if (Z
- GPT
< END_UNCHANGED
)
1432 END_UNCHANGED
= Z
- GPT
;
1437 evaporate_overlays (from
);
1441 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1442 This is for use when undo is not enabled in the current buffer. */
1445 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1446 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1448 #ifdef BYTE_COMBINING_DEBUG
1449 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1450 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1454 /* Update various buffer positions for the new text. */
1455 GAP_SIZE
-= len_byte
;
1457 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1458 GPT
+= len
; GPT_BYTE
+= len_byte
;
1459 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1462 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1465 adjust_markers_for_insert (from
, from_byte
,
1466 from
+ len
, from_byte
+ len_byte
, 0);
1468 if (len
> nchars_del
)
1469 adjust_overlays_for_insert (from
, len
- nchars_del
);
1470 else if (len
< nchars_del
)
1471 adjust_overlays_for_delete (from
, nchars_del
- len
);
1472 if (BUF_INTERVALS (current_buffer
) != 0)
1474 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1478 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1480 /* As byte combining will decrease Z, we must check this again. */
1481 if (Z
- GPT
< END_UNCHANGED
)
1482 END_UNCHANGED
= Z
- GPT
;
1487 evaporate_overlays (from
);
1491 /* Record undo information, adjust markers and position keepers for an
1492 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1493 text already exists in the current buffer but character length (TO
1494 - FROM) may be incorrect, the correct length is NEWLEN. */
1497 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1498 int from
, from_byte
, to
, to_byte
, newlen
;
1500 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1503 move_gap_both (to
, to_byte
);
1504 GAP_SIZE
+= len_byte
;
1505 GPT
-= len
; GPT_BYTE
-= len_byte
;
1506 ZV
-= len
; ZV_BYTE
-= len_byte
;
1507 Z
-= len
; Z_BYTE
-= len_byte
;
1508 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1511 /* Replace the text from character positions FROM to TO with NEW,
1512 If PREPARE is nonzero, call prepare_to_modify_buffer.
1513 If INHERIT, the newly inserted text should inherit text properties
1514 from the surrounding non-deleted text. */
1516 /* Note that this does not yet handle markers quite right.
1517 Also it needs to record a single undo-entry that does a replacement
1518 rather than a separate delete and insert.
1519 That way, undo will also handle markers properly.
1521 But if MARKERS is 0, don't relocate markers. */
1524 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1526 int from
, to
, prepare
, inherit
, markers
;
1528 int inschars
= SCHARS (new);
1529 int insbytes
= SBYTES (new);
1530 int from_byte
, to_byte
;
1531 int nbytes_del
, nchars_del
;
1532 register Lisp_Object temp
;
1533 struct gcpro gcpro1
;
1535 int outgoing_insbytes
= insbytes
;
1536 Lisp_Object deletion
;
1545 int range_length
= to
- from
;
1546 prepare_to_modify_buffer (from
, to
, &from
);
1547 to
= from
+ range_length
;
1552 /* Make args be valid */
1558 from_byte
= CHAR_TO_BYTE (from
);
1559 to_byte
= CHAR_TO_BYTE (to
);
1561 nchars_del
= to
- from
;
1562 nbytes_del
= to_byte
- from_byte
;
1564 if (nbytes_del
<= 0 && insbytes
== 0)
1567 /* Make OUTGOING_INSBYTES describe the text
1568 as it will be inserted in this buffer. */
1570 if (NILP (current_buffer
->enable_multibyte_characters
))
1571 outgoing_insbytes
= inschars
;
1572 else if (! STRING_MULTIBYTE (new))
1574 = count_size_as_multibyte (SDATA (new), insbytes
);
1576 /* Make sure point-max won't overflow after this insertion. */
1577 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1578 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1579 error ("Maximum buffer size exceeded");
1583 /* Make sure the gap is somewhere in or next to what we are deleting. */
1585 gap_right (from
, from_byte
);
1587 gap_left (to
, to_byte
, 0);
1589 /* Even if we don't record for undo, we must keep the original text
1590 because we may have to recover it because of inappropriate byte
1592 if (! EQ (current_buffer
->undo_list
, Qt
))
1593 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1595 GAP_SIZE
+= nbytes_del
;
1598 ZV_BYTE
-= nbytes_del
;
1599 Z_BYTE
-= nbytes_del
;
1601 GPT_BYTE
= from_byte
;
1602 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1607 if (GPT
- BEG
< BEG_UNCHANGED
)
1608 BEG_UNCHANGED
= GPT
- BEG
;
1609 if (Z
- GPT
< END_UNCHANGED
)
1610 END_UNCHANGED
= Z
- GPT
;
1612 if (GAP_SIZE
< insbytes
)
1613 make_gap (insbytes
- GAP_SIZE
);
1615 /* Copy the string text into the buffer, perhaps converting
1616 between single-byte and multibyte. */
1617 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1618 STRING_MULTIBYTE (new),
1619 ! NILP (current_buffer
->enable_multibyte_characters
));
1621 #ifdef BYTE_COMBINING_DEBUG
1622 /* We have copied text into the gap, but we have not marked
1623 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1624 here, for both the previous text and the following text.
1625 Meanwhile, GPT_ADDR does point to
1626 the text that has been stored by copy_text. */
1627 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1628 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1632 if (! EQ (current_buffer
->undo_list
, Qt
))
1634 record_delete (from
, deletion
);
1635 record_insert (from
, inschars
);
1638 GAP_SIZE
-= outgoing_insbytes
;
1642 GPT_BYTE
+= outgoing_insbytes
;
1643 ZV_BYTE
+= outgoing_insbytes
;
1644 Z_BYTE
+= outgoing_insbytes
;
1645 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1650 /* Adjust the overlay center as needed. This must be done after
1651 adjusting the markers that bound the overlays. */
1652 adjust_overlays_for_delete (from
, nchars_del
);
1653 adjust_overlays_for_insert (from
, inschars
);
1655 /* Adjust markers for the deletion and the insertion. */
1657 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1658 inschars
, outgoing_insbytes
);
1660 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1662 /* Get the intervals for the part of the string we are inserting--
1663 not including the combined-before bytes. */
1664 intervals
= STRING_INTERVALS (new);
1665 /* Insert those intervals. */
1666 graft_intervals_into_buffer (intervals
, from
, inschars
,
1667 current_buffer
, inherit
);
1669 /* Relocate point as if it were a marker. */
1671 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1672 (from_byte
+ outgoing_insbytes
1673 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1675 if (outgoing_insbytes
== 0)
1676 evaporate_overlays (from
);
1683 signal_after_change (from
, nchars_del
, GPT
- from
);
1684 update_compositions (from
, GPT
, CHECK_BORDER
);
1687 /* Replace the text from character positions FROM to TO with
1688 the text in INS of length INSCHARS.
1689 Keep the text properties that applied to the old characters
1690 (extending them to all the new chars if there are more new chars).
1692 Note that this does not yet handle markers quite right.
1694 If MARKERS is nonzero, relocate markers.
1696 Unlike most functions at this level, never call
1697 prepare_to_modify_buffer and never call signal_after_change. */
1700 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1701 int from
, from_byte
, to
, to_byte
;
1703 int inschars
, insbytes
, markers
;
1705 int nbytes_del
, nchars_del
;
1710 nchars_del
= to
- from
;
1711 nbytes_del
= to_byte
- from_byte
;
1713 if (nbytes_del
<= 0 && insbytes
== 0)
1716 /* Make sure point-max won't overflow after this insertion. */
1717 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1718 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1719 error ("Maximum buffer size exceeded");
1721 /* Make sure the gap is somewhere in or next to what we are deleting. */
1723 gap_right (from
, from_byte
);
1725 gap_left (to
, to_byte
, 0);
1727 GAP_SIZE
+= nbytes_del
;
1730 ZV_BYTE
-= nbytes_del
;
1731 Z_BYTE
-= nbytes_del
;
1733 GPT_BYTE
= from_byte
;
1734 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1739 if (GPT
- BEG
< BEG_UNCHANGED
)
1740 BEG_UNCHANGED
= GPT
- BEG
;
1741 if (Z
- GPT
< END_UNCHANGED
)
1742 END_UNCHANGED
= Z
- GPT
;
1744 if (GAP_SIZE
< insbytes
)
1745 make_gap (insbytes
- GAP_SIZE
);
1747 /* Copy the replacement text into the buffer. */
1748 bcopy (ins
, GPT_ADDR
, insbytes
);
1750 #ifdef BYTE_COMBINING_DEBUG
1751 /* We have copied text into the gap, but we have not marked
1752 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1753 here, for both the previous text and the following text.
1754 Meanwhile, GPT_ADDR does point to
1755 the text that has been stored by copy_text. */
1756 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1757 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1761 GAP_SIZE
-= insbytes
;
1765 GPT_BYTE
+= insbytes
;
1766 ZV_BYTE
+= insbytes
;
1768 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1773 /* Adjust the overlay center as needed. This must be done after
1774 adjusting the markers that bound the overlays. */
1775 if (nchars_del
!= inschars
)
1777 adjust_overlays_for_insert (from
, inschars
);
1778 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1781 /* Adjust markers for the deletion and the insertion. */
1783 && ! (nchars_del
== 1 && inschars
== 1 && nbytes_del
== insbytes
))
1784 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1785 inschars
, insbytes
);
1787 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1789 /* Relocate point as if it were a marker. */
1790 if (from
< PT
&& (nchars_del
!= inschars
|| nbytes_del
!= insbytes
))
1793 /* PT was within the deleted text. Move it to FROM. */
1794 adjust_point (from
- PT
, from_byte
- PT_BYTE
);
1796 adjust_point (inschars
- nchars_del
, insbytes
- nbytes_del
);
1800 evaporate_overlays (from
);
1807 /* Delete characters in current buffer
1808 from FROM up to (but not including) TO.
1809 If TO comes before FROM, we delete nothing. */
1812 del_range (from
, to
)
1813 register int from
, to
;
1815 del_range_1 (from
, to
, 1, 0);
1818 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1819 RET_STRING says to return the deleted text. */
1822 del_range_1 (from
, to
, prepare
, ret_string
)
1823 int from
, to
, prepare
, ret_string
;
1825 int from_byte
, to_byte
;
1826 Lisp_Object deletion
;
1827 struct gcpro gcpro1
;
1829 /* Make args be valid */
1840 int range_length
= to
- from
;
1841 prepare_to_modify_buffer (from
, to
, &from
);
1842 to
= min (ZV
, from
+ range_length
);
1845 from_byte
= CHAR_TO_BYTE (from
);
1846 to_byte
= CHAR_TO_BYTE (to
);
1848 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1850 signal_after_change (from
, to
- from
, 0);
1851 update_compositions (from
, from
, CHECK_HEAD
);
1856 /* Like del_range_1 but args are byte positions, not char positions. */
1859 del_range_byte (from_byte
, to_byte
, prepare
)
1860 int from_byte
, to_byte
, prepare
;
1864 /* Make args be valid */
1865 if (from_byte
< BEGV_BYTE
)
1866 from_byte
= BEGV_BYTE
;
1867 if (to_byte
> ZV_BYTE
)
1870 if (to_byte
<= from_byte
)
1873 from
= BYTE_TO_CHAR (from_byte
);
1874 to
= BYTE_TO_CHAR (to_byte
);
1878 int old_from
= from
, old_to
= Z
- to
;
1879 int range_length
= to
- from
;
1880 prepare_to_modify_buffer (from
, to
, &from
);
1881 to
= from
+ range_length
;
1883 if (old_from
!= from
)
1884 from_byte
= CHAR_TO_BYTE (from
);
1890 else if (old_to
== Z
- to
)
1891 to_byte
= CHAR_TO_BYTE (to
);
1894 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1895 signal_after_change (from
, to
- from
, 0);
1896 update_compositions (from
, from
, CHECK_HEAD
);
1899 /* Like del_range_1, but positions are specified both as charpos
1903 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1904 int from
, from_byte
, to
, to_byte
, prepare
;
1906 /* Make args be valid */
1907 if (from_byte
< BEGV_BYTE
)
1908 from_byte
= BEGV_BYTE
;
1909 if (to_byte
> ZV_BYTE
)
1912 if (to_byte
<= from_byte
)
1922 int old_from
= from
, old_to
= Z
- to
;
1923 int range_length
= to
- from
;
1924 prepare_to_modify_buffer (from
, to
, &from
);
1925 to
= from
+ range_length
;
1927 if (old_from
!= from
)
1928 from_byte
= CHAR_TO_BYTE (from
);
1934 else if (old_to
== Z
- to
)
1935 to_byte
= CHAR_TO_BYTE (to
);
1938 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1939 signal_after_change (from
, to
- from
, 0);
1940 update_compositions (from
, from
, CHECK_HEAD
);
1943 /* Delete a range of text, specified both as character positions
1944 and byte positions. FROM and TO are character positions,
1945 while FROM_BYTE and TO_BYTE are byte positions.
1946 If RET_STRING is true, the deleted area is returned as a string. */
1949 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1950 int from
, from_byte
, to
, to_byte
, ret_string
;
1952 register int nbytes_del
, nchars_del
;
1953 Lisp_Object deletion
;
1957 nchars_del
= to
- from
;
1958 nbytes_del
= to_byte
- from_byte
;
1960 /* Make sure the gap is somewhere in or next to what we are deleting. */
1962 gap_right (from
, from_byte
);
1964 gap_left (to
, to_byte
, 0);
1966 #ifdef BYTE_COMBINING_DEBUG
1967 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1968 Z_BYTE
- to_byte
, from
, from_byte
))
1972 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1973 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1977 /* Relocate all markers pointing into the new, larger gap
1978 to point at the end of the text before the gap.
1979 Do this before recording the deletion,
1980 so that undo handles this after reinserting the text. */
1981 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1983 if (! EQ (current_buffer
->undo_list
, Qt
))
1984 record_delete (from
, deletion
);
1987 /* Relocate point as if it were a marker. */
1989 adjust_point (from
- (PT
< to
? PT
: to
),
1990 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1992 offset_intervals (current_buffer
, from
, - nchars_del
);
1994 /* Adjust the overlay center as needed. This must be done after
1995 adjusting the markers that bound the overlays. */
1996 adjust_overlays_for_delete (from
, nchars_del
);
1998 GAP_SIZE
+= nbytes_del
;
1999 ZV_BYTE
-= nbytes_del
;
2000 Z_BYTE
-= nbytes_del
;
2004 GPT_BYTE
= from_byte
;
2005 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
2010 if (GPT
- BEG
< BEG_UNCHANGED
)
2011 BEG_UNCHANGED
= GPT
- BEG
;
2012 if (Z
- GPT
< END_UNCHANGED
)
2013 END_UNCHANGED
= Z
- GPT
;
2017 evaporate_overlays (from
);
2022 /* Call this if you're about to change the region of BUFFER from
2023 character positions START to END. This checks the read-only
2024 properties of the region, calls the necessary modification hooks,
2025 and warns the next redisplay that it should pay attention to that
2029 modify_region (buffer
, start
, end
)
2030 struct buffer
*buffer
;
2033 struct buffer
*old_buffer
= current_buffer
;
2035 if (buffer
!= old_buffer
)
2036 set_buffer_internal (buffer
);
2038 prepare_to_modify_buffer (start
, end
, NULL
);
2040 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
2042 if (MODIFF
<= SAVE_MODIFF
)
2043 record_first_change ();
2046 buffer
->point_before_scroll
= Qnil
;
2048 if (buffer
!= old_buffer
)
2049 set_buffer_internal (old_buffer
);
2052 /* Check that it is okay to modify the buffer between START and END,
2053 which are char positions.
2055 Run the before-change-function, if any. If intervals are in use,
2056 verify that the text to be modified is not read-only, and call
2057 any modification properties the text may have.
2059 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2060 by holding its value temporarily in a marker. */
2063 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2067 struct buffer
*base_buffer
;
2069 if (!NILP (current_buffer
->read_only
))
2070 Fbarf_if_buffer_read_only ();
2072 /* Let redisplay consider other windows than selected_window
2073 if modifying another buffer. */
2074 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2075 ++windows_or_buffers_changed
;
2077 if (BUF_INTERVALS (current_buffer
) != 0)
2081 Lisp_Object preserve_marker
;
2082 struct gcpro gcpro1
;
2083 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2084 GCPRO1 (preserve_marker
);
2085 verify_interval_modification (current_buffer
, start
, end
);
2086 *preserve_ptr
= marker_position (preserve_marker
);
2087 unchain_marker (XMARKER (preserve_marker
));
2091 verify_interval_modification (current_buffer
, start
, end
);
2094 /* For indirect buffers, use the base buffer to check clashes. */
2095 if (current_buffer
->base_buffer
!= 0)
2096 base_buffer
= current_buffer
->base_buffer
;
2098 base_buffer
= current_buffer
;
2100 #ifdef CLASH_DETECTION
2101 if (!NILP (base_buffer
->file_truename
)
2102 /* Make binding buffer-file-name to nil effective. */
2103 && !NILP (base_buffer
->filename
)
2104 && SAVE_MODIFF
>= MODIFF
)
2105 lock_file (base_buffer
->file_truename
);
2107 /* At least warn if this file has changed on disk since it was visited. */
2108 if (!NILP (base_buffer
->filename
)
2109 && SAVE_MODIFF
>= MODIFF
2110 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2111 && !NILP (Ffile_exists_p (base_buffer
->filename
)))
2112 call1 (intern ("ask-user-about-supersession-threat"),
2113 base_buffer
->filename
);
2114 #endif /* not CLASH_DETECTION */
2116 signal_before_change (start
, end
, preserve_ptr
);
2118 if (current_buffer
->newline_cache
)
2119 invalidate_region_cache (current_buffer
,
2120 current_buffer
->newline_cache
,
2121 start
- BEG
, Z
- end
);
2122 if (current_buffer
->width_run_cache
)
2123 invalidate_region_cache (current_buffer
,
2124 current_buffer
->width_run_cache
,
2125 start
- BEG
, Z
- end
);
2127 Vdeactivate_mark
= Qt
;
2130 /* These macros work with an argument named `preserve_ptr'
2131 and a local variable named `preserve_marker'. */
2133 #define PRESERVE_VALUE \
2134 if (preserve_ptr && NILP (preserve_marker)) \
2135 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2137 #define RESTORE_VALUE \
2138 if (! NILP (preserve_marker)) \
2140 *preserve_ptr = marker_position (preserve_marker); \
2141 unchain_marker (XMARKER (preserve_marker)); \
2144 #define PRESERVE_START_END \
2145 if (NILP (start_marker)) \
2146 start_marker = Fcopy_marker (start, Qnil); \
2147 if (NILP (end_marker)) \
2148 end_marker = Fcopy_marker (end, Qnil);
2150 #define FETCH_START \
2151 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2154 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2156 /* Signal a change to the buffer immediately before it happens.
2157 START_INT and END_INT are the bounds of the text to be changed.
2159 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2160 by holding its value temporarily in a marker. */
2163 signal_before_change (start_int
, end_int
, preserve_ptr
)
2164 int start_int
, end_int
;
2167 Lisp_Object start
, end
;
2168 Lisp_Object start_marker
, end_marker
;
2169 Lisp_Object preserve_marker
;
2170 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2172 if (inhibit_modification_hooks
)
2175 start
= make_number (start_int
);
2176 end
= make_number (end_int
);
2177 preserve_marker
= Qnil
;
2178 start_marker
= Qnil
;
2180 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2182 /* If buffer is unmodified, run a special hook for that case. */
2183 if (SAVE_MODIFF
>= MODIFF
2184 && !NILP (Vfirst_change_hook
)
2185 && !NILP (Vrun_hooks
))
2189 call1 (Vrun_hooks
, Qfirst_change_hook
);
2192 /* Now run the before-change-functions if any. */
2193 if (!NILP (Vbefore_change_functions
))
2195 Lisp_Object args
[3];
2196 Lisp_Object before_change_functions
;
2197 Lisp_Object after_change_functions
;
2198 struct gcpro gcpro1
, gcpro2
;
2199 struct buffer
*old
= current_buffer
;
2205 /* "Bind" before-change-functions and after-change-functions
2206 to nil--but in a way that errors don't know about.
2207 That way, if there's an error in them, they will stay nil. */
2208 before_change_functions
= Vbefore_change_functions
;
2209 after_change_functions
= Vafter_change_functions
;
2210 Vbefore_change_functions
= Qnil
;
2211 Vafter_change_functions
= Qnil
;
2212 GCPRO2 (before_change_functions
, after_change_functions
);
2214 /* Actually run the hook functions. */
2215 args
[0] = Qbefore_change_functions
;
2216 args
[1] = FETCH_START
;
2217 args
[2] = FETCH_END
;
2218 run_hook_list_with_args (before_change_functions
, 3, args
);
2220 /* "Unbind" the variables we "bound" to nil. Beware a
2221 buffer-local hook which changes the buffer when run (e.g. W3). */
2222 if (old
!= current_buffer
)
2224 new = current_buffer
;
2225 set_buffer_internal (old
);
2226 Vbefore_change_functions
= before_change_functions
;
2227 Vafter_change_functions
= after_change_functions
;
2228 set_buffer_internal (new);
2232 Vbefore_change_functions
= before_change_functions
;
2233 Vafter_change_functions
= after_change_functions
;
2238 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2241 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2242 FETCH_START
, FETCH_END
, Qnil
);
2245 if (! NILP (start_marker
))
2246 free_marker (start_marker
);
2247 if (! NILP (end_marker
))
2248 free_marker (end_marker
);
2253 /* Signal a change immediately after it happens.
2254 CHARPOS is the character position of the start of the changed text.
2255 LENDEL is the number of characters of the text before the change.
2256 (Not the whole buffer; just the part that was changed.)
2257 LENINS is the number of characters in that part of the text
2258 after the change. */
2261 signal_after_change (charpos
, lendel
, lenins
)
2262 int charpos
, lendel
, lenins
;
2264 if (inhibit_modification_hooks
)
2267 /* If we are deferring calls to the after-change functions
2268 and there are no before-change functions,
2269 just record the args that we were going to use. */
2270 if (! NILP (Vcombine_after_change_calls
)
2271 && NILP (Vbefore_change_functions
)
2272 && !current_buffer
->overlays_before
2273 && !current_buffer
->overlays_after
)
2277 if (!NILP (combine_after_change_list
)
2278 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2279 Fcombine_after_change_execute ();
2281 elt
= Fcons (make_number (charpos
- BEG
),
2282 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2283 Fcons (make_number (lenins
- lendel
), Qnil
)));
2284 combine_after_change_list
2285 = Fcons (elt
, combine_after_change_list
);
2286 combine_after_change_buffer
= Fcurrent_buffer ();
2291 if (!NILP (combine_after_change_list
))
2292 Fcombine_after_change_execute ();
2294 if (!NILP (Vafter_change_functions
))
2296 Lisp_Object args
[4];
2297 Lisp_Object before_change_functions
;
2298 Lisp_Object after_change_functions
;
2299 struct buffer
*old
= current_buffer
;
2301 struct gcpro gcpro1
, gcpro2
;
2303 /* "Bind" before-change-functions and after-change-functions
2304 to nil--but in a way that errors don't know about.
2305 That way, if there's an error in them, they will stay nil. */
2306 before_change_functions
= Vbefore_change_functions
;
2307 after_change_functions
= Vafter_change_functions
;
2308 Vbefore_change_functions
= Qnil
;
2309 Vafter_change_functions
= Qnil
;
2310 GCPRO2 (before_change_functions
, after_change_functions
);
2312 /* Actually run the hook functions. */
2313 args
[0] = Qafter_change_functions
;
2314 XSETFASTINT (args
[1], charpos
);
2315 XSETFASTINT (args
[2], charpos
+ lenins
);
2316 XSETFASTINT (args
[3], lendel
);
2317 run_hook_list_with_args (after_change_functions
,
2320 /* "Unbind" the variables we "bound" to nil. Beware a
2321 buffer-local hook which changes the buffer when run (e.g. W3). */
2322 if (old
!= current_buffer
)
2324 new = current_buffer
;
2325 set_buffer_internal (old
);
2326 Vbefore_change_functions
= before_change_functions
;
2327 Vafter_change_functions
= after_change_functions
;
2328 set_buffer_internal (new);
2332 Vbefore_change_functions
= before_change_functions
;
2333 Vafter_change_functions
= after_change_functions
;
2338 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2339 report_overlay_modification (make_number (charpos
),
2340 make_number (charpos
+ lenins
),
2342 make_number (charpos
),
2343 make_number (charpos
+ lenins
),
2344 make_number (lendel
));
2346 /* After an insertion, call the text properties
2347 insert-behind-hooks or insert-in-front-hooks. */
2349 report_interval_modification (make_number (charpos
),
2350 make_number (charpos
+ lenins
));
2354 Fcombine_after_change_execute_1 (val
)
2357 Vcombine_after_change_calls
= val
;
2361 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2362 Scombine_after_change_execute
, 0, 0, 0,
2363 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2366 int count
= SPECPDL_INDEX ();
2367 int beg
, end
, change
;
2371 if (NILP (combine_after_change_list
))
2374 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2376 Fset_buffer (combine_after_change_buffer
);
2378 /* # chars unchanged at beginning of buffer. */
2380 /* # chars unchanged at end of buffer. */
2382 /* Total amount of insertion (negative for deletion). */
2385 /* Scan the various individual changes,
2386 accumulating the range info in BEG, END and CHANGE. */
2387 for (tail
= combine_after_change_list
; CONSP (tail
);
2391 int thisbeg
, thisend
, thischange
;
2393 /* Extract the info from the next element. */
2397 thisbeg
= XINT (XCAR (elt
));
2402 thisend
= XINT (XCAR (elt
));
2407 thischange
= XINT (XCAR (elt
));
2409 /* Merge this range into the accumulated range. */
2410 change
+= thischange
;
2417 /* Get the current start and end positions of the range
2418 that was changed. */
2422 /* We are about to handle these, so discard them. */
2423 combine_after_change_list
= Qnil
;
2425 /* Now run the after-change functions for real.
2426 Turn off the flag that defers them. */
2427 record_unwind_protect (Fcombine_after_change_execute_1
,
2428 Vcombine_after_change_calls
);
2429 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2430 update_compositions (begpos
, endpos
, CHECK_ALL
);
2432 return unbind_to (count
, Qnil
);
2438 staticpro (&combine_after_change_list
);
2439 staticpro (&combine_after_change_buffer
);
2440 combine_after_change_list
= Qnil
;
2441 combine_after_change_buffer
= Qnil
;
2443 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2444 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2445 check_markers_debug_flag
= 0;
2446 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2447 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2448 Vcombine_after_change_calls
= Qnil
;
2450 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2451 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2452 This affects `before-change-functions' and `after-change-functions',
2453 as well as hooks attached to text properties and overlays. */);
2454 inhibit_modification_hooks
= 0;
2455 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2456 staticpro (&Qinhibit_modification_hooks
);
2458 defsubr (&Scombine_after_change_execute
);
2461 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2462 (do not change this comment) */