1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "intervals.h"
29 #include "blockinput.h"
30 #include "region-cache.h"
36 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
37 static void insert_from_buffer_1 ();
38 static void gap_left
P_ ((int, int, int));
39 static void gap_right
P_ ((int, int));
40 static void adjust_markers_gap_motion
P_ ((int, int, int));
41 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
42 void adjust_markers_for_delete
P_ ((int, int, int, int));
43 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
44 static void adjust_point
P_ ((int, int));
46 Lisp_Object
Fcombine_after_change_execute ();
48 /* Non-nil means don't call the after-change-functions right away,
49 just record an element in Vcombine_after_change_calls_list. */
50 Lisp_Object Vcombine_after_change_calls
;
52 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
53 describing changes which happened while combine_after_change_calls
54 was nonzero. We use this to decide how to call them
55 once the deferral ends.
58 BEG-UNCHANGED is the number of chars before the changed range.
59 END-UNCHANGED is the number of chars after the changed range,
60 and CHANGE-AMOUNT is the number of characters inserted by the change
61 (negative for a deletion). */
62 Lisp_Object combine_after_change_list
;
64 /* Buffer which combine_after_change_list is about. */
65 Lisp_Object combine_after_change_buffer
;
67 Lisp_Object Qinhibit_modification_hooks
;
70 /* Check all markers in the current buffer, looking for something invalid. */
72 static int check_markers_debug_flag
;
74 #define CHECK_MARKERS() \
75 if (check_markers_debug_flag) \
82 register Lisp_Object tail
;
83 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
85 tail
= BUF_MARKERS (current_buffer
);
89 if (XMARKER (tail
)->buffer
->text
!= current_buffer
->text
)
91 if (XMARKER (tail
)->charpos
> Z
)
93 if (XMARKER (tail
)->bytepos
> Z_BYTE
)
95 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (XMARKER (tail
)->bytepos
)))
98 tail
= XMARKER (tail
)->chain
;
102 /* Move gap to position CHARPOS.
103 Note that this can quit! */
109 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
112 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
113 Note that this can quit! */
116 move_gap_both (charpos
, bytepos
)
117 int charpos
, bytepos
;
119 if (bytepos
< GPT_BYTE
)
120 gap_left (charpos
, bytepos
, 0);
121 else if (bytepos
> GPT_BYTE
)
122 gap_right (charpos
, bytepos
);
125 /* Move the gap to a position less than the current GPT.
126 BYTEPOS describes the new position as a byte position,
127 and CHARPOS is the corresponding char position.
128 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
131 gap_left (charpos
, bytepos
, newgap
)
132 register int charpos
, bytepos
;
135 register unsigned char *to
, *from
;
140 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
147 /* Now copy the characters. To move the gap down,
148 copy characters up. */
152 /* I gets number of characters left to copy. */
153 i
= new_s1
- bytepos
;
156 /* If a quit is requested, stop copying now.
157 Change BYTEPOS to be where we have actually moved the gap to. */
161 charpos
= BYTE_TO_CHAR (bytepos
);
164 /* Move at most 32000 chars before checking again for a quit. */
169 /* bcopy is safe if the two areas of memory do not overlap
170 or on systems where bcopy is always safe for moving upward. */
171 && (BCOPY_UPWARD_SAFE
172 || to
- from
>= 128))
174 /* If overlap is not safe, avoid it by not moving too many
175 characters at once. */
176 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
191 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
192 BYTEPOS is where the loop above stopped, which may be what was specified
193 or may be where a quit was detected. */
194 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
197 if (bytepos
< charpos
)
199 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
203 /* Move the gap to a position greater than than the current GPT.
204 BYTEPOS describes the new position as a byte position,
205 and CHARPOS is the corresponding char position. */
208 gap_right (charpos
, bytepos
)
209 register int charpos
, bytepos
;
211 register unsigned char *to
, *from
;
215 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
222 /* Now copy the characters. To move the gap up,
223 copy characters down. */
227 /* I gets number of characters left to copy. */
228 i
= bytepos
- new_s1
;
231 /* If a quit is requested, stop copying now.
232 Change BYTEPOS to be where we have actually moved the gap to. */
236 charpos
= BYTE_TO_CHAR (bytepos
);
239 /* Move at most 32000 chars before checking again for a quit. */
244 /* bcopy is safe if the two areas of memory do not overlap
245 or on systems where bcopy is always safe for moving downward. */
246 && (BCOPY_DOWNWARD_SAFE
247 || from
- to
>= 128))
249 /* If overlap is not safe, avoid it by not moving too many
250 characters at once. */
251 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
266 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
270 if (bytepos
< charpos
)
272 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
276 /* Add AMOUNT to the byte position of every marker in the current buffer
277 whose current byte position is between FROM (exclusive) and TO (inclusive).
279 Also, any markers past the outside of that interval, in the direction
280 of adjustment, are first moved back to the near end of the interval
281 and then adjusted by AMOUNT.
283 When the latter adjustment is done, if AMOUNT is negative,
284 we record the adjustment for undo. (This case happens only for
287 The markers' character positions are not altered,
288 because gap motion does not affect character positions. */
290 int adjust_markers_test
;
293 adjust_markers_gap_motion (from
, to
, amount
)
294 register int from
, to
, amount
;
296 /* Now that a marker has a bytepos, not counting the gap,
297 nothing needs to be done here. */
300 register struct Lisp_Marker
*m
;
303 marker
= BUF_MARKERS (current_buffer
);
305 while (!NILP (marker
))
307 m
= XMARKER (marker
);
311 if (mpos
> to
&& mpos
< to
+ amount
)
313 if (adjust_markers_test
)
320 /* Here's the case where a marker is inside text being deleted.
321 AMOUNT can be negative for gap motion, too,
322 but then this range contains no markers. */
323 if (mpos
> from
+ amount
&& mpos
<= from
)
325 if (adjust_markers_test
)
327 mpos
= from
+ amount
;
330 if (mpos
> from
&& mpos
<= to
)
338 /* Adjust all markers for a deletion
339 whose range in bytes is FROM_BYTE to TO_BYTE.
340 The range in charpos is FROM to TO.
342 This function assumes that the gap is adjacent to
343 or inside of the range being deleted. */
346 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
347 register int from
, from_byte
, to
, to_byte
;
350 register struct Lisp_Marker
*m
;
351 register int charpos
;
353 marker
= BUF_MARKERS (current_buffer
);
355 while (!NILP (marker
))
357 m
= XMARKER (marker
);
358 charpos
= m
->charpos
;
363 /* If the marker is after the deletion,
364 relocate by number of chars / bytes deleted. */
367 m
->charpos
-= to
- from
;
368 m
->bytepos
-= to_byte
- from_byte
;
370 /* Here's the case where a marker is inside text being deleted. */
371 else if (charpos
> from
)
373 if (! m
->insertion_type
)
374 /* Normal markers will end up at the beginning of the
375 re-inserted text after undoing a deletion, and must be
376 adjusted to move them to the correct place. */
377 record_marker_adjustment (marker
, from
- charpos
);
378 else if (charpos
< to
)
379 /* Before-insertion markers will automatically move forward
380 upon re-inserting the deleted text, so we have to arrange
381 for them to move backward to the correct position. */
382 record_marker_adjustment (marker
, charpos
- to
);
385 m
->bytepos
= from_byte
;
387 /* Here's the case where a before-insertion marker is immediately
388 before the deleted region. */
389 else if (charpos
== from
&& m
->insertion_type
)
391 /* Undoing the change uses normal insertion, which will
392 incorrectly make MARKER move forward, so we arrange for it
393 to then move backward to the correct place at the beginning
394 of the deleted region. */
395 record_marker_adjustment (marker
, to
- from
);
403 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
404 to TO / TO_BYTE. We have to relocate the charpos of every marker
405 that points after the insertion (but not their bytepos).
407 When a marker points at the insertion point,
408 we advance it if either its insertion-type is t
409 or BEFORE_MARKERS is true. */
412 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
413 register int from
, from_byte
, to
, to_byte
;
418 int nchars
= to
- from
;
419 int nbytes
= to_byte
- from_byte
;
421 marker
= BUF_MARKERS (current_buffer
);
423 while (!NILP (marker
))
425 register struct Lisp_Marker
*m
= XMARKER (marker
);
427 /* In a single-byte buffer, a marker's two positions must be
431 if (m
->charpos
!= m
->bytepos
)
435 if (m
->bytepos
== from_byte
)
437 if (m
->insertion_type
|| before_markers
)
439 m
->bytepos
= to_byte
;
441 if (m
->insertion_type
)
445 else if (m
->bytepos
> from_byte
)
447 m
->bytepos
+= nbytes
;
448 m
->charpos
+= nchars
;
454 /* Adjusting only markers whose insertion-type is t may result in
455 disordered overlays in the slot `overlays_before'. */
457 fix_overlays_before (current_buffer
, from
, to
);
460 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
462 This is used only when the value of point changes due to an insert
463 or delete; it does not represent a conceptual change in point as a
464 marker. In particular, point is not crossing any interval
465 boundaries, so there's no need to use the usual SET_PT macro. In
466 fact it would be incorrect to do so, because either the old or the
467 new value of point is out of sync with the current set of
471 adjust_point (nchars
, nbytes
)
474 BUF_PT (current_buffer
) += nchars
;
475 BUF_PT_BYTE (current_buffer
) += nbytes
;
477 /* In a single-byte buffer, the two positions must be equal. */
483 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
484 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
485 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
489 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
490 new_chars
, new_bytes
)
491 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
493 Lisp_Object marker
= BUF_MARKERS (current_buffer
);
494 int prev_to_byte
= from_byte
+ old_bytes
;
495 int diff_chars
= new_chars
- old_chars
;
496 int diff_bytes
= new_bytes
- old_bytes
;
498 while (!NILP (marker
))
500 register struct Lisp_Marker
*m
= XMARKER (marker
);
502 if (m
->bytepos
>= prev_to_byte
)
504 m
->charpos
+= diff_chars
;
505 m
->bytepos
+= diff_bytes
;
507 else if (m
->bytepos
> from_byte
)
510 m
->bytepos
= from_byte
;
520 /* Make the gap NBYTES_ADDED bytes longer. */
523 make_gap_larger (nbytes_added
)
528 int real_gap_loc_byte
;
531 /* If we have to get more space, get enough to last a while. */
532 nbytes_added
+= 2000;
534 /* Don't allow a buffer size that won't fit in an int
535 even if it will fit in a Lisp integer.
536 That won't work because so many places use `int'.
538 Make sure we don't introduce overflows in the calculation. */
540 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
541 >= (((EMACS_INT
) 1 << (min (VALBITS
, BITS_PER_INT
) - 1)) - 1
543 error ("Buffer exceeds maximum size");
545 enlarge_buffer_text (current_buffer
, nbytes_added
);
547 /* Prevent quitting in move_gap. */
552 real_gap_loc_byte
= GPT_BYTE
;
553 old_gap_size
= GAP_SIZE
;
555 /* Call the newly allocated space a gap at the end of the whole space. */
557 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
558 GAP_SIZE
= nbytes_added
;
560 /* Move the new gap down to be consecutive with the end of the old one.
561 This adjusts the markers properly too. */
562 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
564 /* Now combine the two into one large gap. */
565 GAP_SIZE
+= old_gap_size
;
567 GPT_BYTE
= real_gap_loc_byte
;
576 /* Make the gap NBYTES_REMOVED bytes shorted. */
579 make_gap_smaller (nbytes_removed
)
584 int real_gap_loc_byte
;
589 /* Make sure the gap is at least 20 bytes. */
590 if (GAP_SIZE
- nbytes_removed
< 20)
591 nbytes_removed
= GAP_SIZE
- 20;
593 /* Prevent quitting in move_gap. */
598 real_gap_loc_byte
= GPT_BYTE
;
599 old_gap_size
= GAP_SIZE
;
601 real_Z_byte
= Z_BYTE
;
603 /* Pretend that the last unwanted part of the gap is the entire gap,
604 and that the first desired part of the gap is part of the buffer
606 bzero (GPT_ADDR
, GAP_SIZE
- nbytes_removed
);
607 GPT
+= GAP_SIZE
- nbytes_removed
;
608 GPT_BYTE
+= GAP_SIZE
- nbytes_removed
;
609 Z
+= GAP_SIZE
- nbytes_removed
;
610 Z_BYTE
+= GAP_SIZE
- nbytes_removed
;
611 GAP_SIZE
= nbytes_removed
;
613 /* Move the unwanted pretend gap to the end of the buffer. This
614 adjusts the markers properly too. */
615 gap_right (Z
, Z_BYTE
);
617 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
619 /* Now restore the desired gap. */
620 GAP_SIZE
= old_gap_size
- nbytes_removed
;
622 GPT_BYTE
= real_gap_loc_byte
;
624 Z_BYTE
= real_Z_byte
;
633 make_gap (nbytes_added
)
636 if (nbytes_added
>= 0)
637 make_gap_larger (nbytes_added
);
638 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
640 make_gap_smaller (-nbytes_added
);
644 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
645 FROM_MULTIBYTE says whether the incoming text is multibyte.
646 TO_MULTIBYTE says whether to store the text as multibyte.
647 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
649 Return the number of bytes stored at TO_ADDR. */
652 copy_text (from_addr
, to_addr
, nbytes
,
653 from_multibyte
, to_multibyte
)
654 unsigned char *from_addr
;
655 unsigned char *to_addr
;
657 int from_multibyte
, to_multibyte
;
659 if (from_multibyte
== to_multibyte
)
661 bcopy (from_addr
, to_addr
, nbytes
);
664 else if (from_multibyte
)
667 int bytes_left
= nbytes
;
668 Lisp_Object tbl
= Qnil
;
670 /* We set the variable tbl to the reverse table of
671 Vnonascii_translation_table in advance. */
672 if (CHAR_TABLE_P (Vnonascii_translation_table
))
674 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
676 if (!CHAR_TABLE_P (tbl
))
680 /* Convert multibyte to single byte. */
681 while (bytes_left
> 0)
684 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
685 if (!SINGLE_BYTE_CHAR_P (c
))
686 c
= multibyte_char_to_unibyte (c
, tbl
);
688 from_addr
+= thislen
;
689 bytes_left
-= thislen
;
696 unsigned char *initial_to_addr
= to_addr
;
698 /* Convert single-byte to multibyte. */
701 int c
= *from_addr
++;
705 c
= unibyte_char_to_multibyte (c
);
706 to_addr
+= CHAR_STRING (c
, to_addr
);
710 /* Special case for speed. */
711 *to_addr
++ = c
, nbytes
--;
713 return to_addr
- initial_to_addr
;
717 /* Return the number of bytes it would take
718 to convert some single-byte text to multibyte.
719 The single-byte text consists of NBYTES bytes at PTR. */
722 count_size_as_multibyte (ptr
, nbytes
)
727 int outgoing_nbytes
= 0;
729 for (i
= 0; i
< nbytes
; i
++)
731 unsigned int c
= *ptr
++;
737 c
= unibyte_char_to_multibyte (c
);
738 outgoing_nbytes
+= CHAR_BYTES (c
);
742 return outgoing_nbytes
;
745 /* Insert a string of specified length before point.
746 This function judges multibyteness based on
747 enable_multibyte_characters in the current buffer;
748 it never converts between single-byte and multibyte.
750 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
751 prepare_to_modify_buffer could relocate the text. */
754 insert (string
, nbytes
)
755 register unsigned char *string
;
761 insert_1 (string
, nbytes
, 0, 1, 0);
762 signal_after_change (opoint
, 0, PT
- opoint
);
763 update_compositions (opoint
, PT
, CHECK_BORDER
);
767 /* Likewise, but inherit text properties from neighboring characters. */
770 insert_and_inherit (string
, nbytes
)
771 register unsigned char *string
;
777 insert_1 (string
, nbytes
, 1, 1, 0);
778 signal_after_change (opoint
, 0, PT
- opoint
);
779 update_compositions (opoint
, PT
, CHECK_BORDER
);
783 /* Insert the character C before point. Do not inherit text properties. */
789 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
792 if (! NILP (current_buffer
->enable_multibyte_characters
))
793 len
= CHAR_STRING (c
, str
);
803 /* Insert the null-terminated string S before point. */
809 insert (s
, strlen (s
));
812 /* Like `insert' except that all markers pointing at the place where
813 the insertion happens are adjusted to point after it.
814 Don't use this function to insert part of a Lisp string,
815 since gc could happen and relocate it. */
818 insert_before_markers (string
, nbytes
)
819 unsigned char *string
;
826 insert_1 (string
, nbytes
, 0, 1, 1);
827 signal_after_change (opoint
, 0, PT
- opoint
);
828 update_compositions (opoint
, PT
, CHECK_BORDER
);
832 /* Likewise, but inherit text properties from neighboring characters. */
835 insert_before_markers_and_inherit (string
, nbytes
)
836 unsigned char *string
;
843 insert_1 (string
, nbytes
, 1, 1, 1);
844 signal_after_change (opoint
, 0, PT
- opoint
);
845 update_compositions (opoint
, PT
, CHECK_BORDER
);
849 /* Subroutine used by the insert functions above. */
852 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
853 register unsigned char *string
;
855 int inherit
, prepare
, before_markers
;
857 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
858 inherit
, prepare
, before_markers
);
862 #ifdef BYTE_COMBINING_DEBUG
864 /* See if the bytes before POS/POS_BYTE combine with bytes
865 at the start of STRING to form a single character.
866 If so, return the number of bytes at the start of STRING
867 which combine in this way. Otherwise, return 0. */
870 count_combining_before (string
, length
, pos
, pos_byte
)
871 unsigned char *string
;
875 int len
, combining_bytes
;
878 if (NILP (current_buffer
->enable_multibyte_characters
))
881 /* At first, we can exclude the following cases:
882 (1) STRING[0] can't be a following byte of multibyte sequence.
883 (2) POS is the start of the current buffer.
884 (3) A character before POS is not a multibyte character. */
885 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
887 if (pos_byte
== BEG_BYTE
) /* case (2) */
890 p
= BYTE_POS_ADDR (pos_byte
- 1);
891 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
892 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
895 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
896 if (combining_bytes
<= 0)
897 /* The character preceding POS is, complete and no room for
898 combining bytes (combining_bytes == 0), or an independent 8-bit
899 character (combining_bytes < 0). */
902 /* We have a combination situation. Count the bytes at STRING that
905 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
908 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
911 /* See if the bytes after POS/POS_BYTE combine with bytes
912 at the end of STRING to form a single character.
913 If so, return the number of bytes after POS/POS_BYTE
914 which combine in this way. Otherwise, return 0. */
917 count_combining_after (string
, length
, pos
, pos_byte
)
918 unsigned char *string
;
922 int opos_byte
= pos_byte
;
927 if (NILP (current_buffer
->enable_multibyte_characters
))
930 /* At first, we can exclude the following cases:
931 (1) The last byte of STRING is an ASCII.
932 (2) POS is the last of the current buffer.
933 (3) A character at POS can't be a following byte of multibyte
935 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
937 if (pos_byte
== Z_BYTE
) /* case (2) */
939 bufp
= BYTE_POS_ADDR (pos_byte
);
940 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
944 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
950 /* All characters in STRING are not character head. We must
951 check also preceding bytes at POS. We are sure that the gap
953 unsigned char *p
= BEG_ADDR
;
955 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
957 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
960 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
961 return (bytes
<= pos_byte
- 1 - i
+ length
963 : bytes
- (pos_byte
- 1 - i
+ length
));
965 if (!BASE_LEADING_CODE_P (string
[i
]))
968 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
970 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
972 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
978 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
979 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
980 are the same as in insert_1. */
983 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
984 register unsigned char *string
;
985 register int nchars
, nbytes
;
986 int inherit
, prepare
, before_markers
;
991 if (NILP (current_buffer
->enable_multibyte_characters
))
995 /* Do this before moving and increasing the gap,
996 because the before-change hooks might move the gap
997 or make it smaller. */
998 prepare_to_modify_buffer (PT
, PT
, NULL
);
1001 move_gap_both (PT
, PT_BYTE
);
1002 if (GAP_SIZE
< nbytes
)
1003 make_gap (nbytes
- GAP_SIZE
);
1005 #ifdef BYTE_COMBINING_DEBUG
1006 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
1007 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
1011 /* Record deletion of the surrounding text that combines with
1012 the insertion. This, together with recording the insertion,
1013 will add up to the right stuff in the undo list. */
1014 record_insert (PT
, nchars
);
1017 bcopy (string
, GPT_ADDR
, nbytes
);
1026 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1031 adjust_overlays_for_insert (PT
, nchars
);
1032 adjust_markers_for_insert (PT
, PT_BYTE
,
1033 PT
+ nchars
, PT_BYTE
+ nbytes
,
1036 if (BUF_INTERVALS (current_buffer
) != 0)
1037 offset_intervals (current_buffer
, PT
, nchars
);
1039 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1040 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1043 adjust_point (nchars
, nbytes
);
1048 /* Insert the part of the text of STRING, a Lisp object assumed to be
1049 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1050 starting at position POS / POS_BYTE. If the text of STRING has properties,
1051 copy them into the buffer.
1053 It does not work to use `insert' for this, because a GC could happen
1054 before we bcopy the stuff into the buffer, and relocate the string
1055 without insert noticing. */
1058 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1060 register int pos
, pos_byte
, length
, length_byte
;
1064 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1066 signal_after_change (opoint
, 0, PT
- opoint
);
1067 update_compositions (opoint
, PT
, CHECK_BORDER
);
1070 /* Like `insert_from_string' except that all markers pointing
1071 at the place where the insertion happens are adjusted to point after it. */
1074 insert_from_string_before_markers (string
, pos
, pos_byte
,
1075 length
, length_byte
, inherit
)
1077 register int pos
, pos_byte
, length
, length_byte
;
1081 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1083 signal_after_change (opoint
, 0, PT
- opoint
);
1084 update_compositions (opoint
, PT
, CHECK_BORDER
);
1087 /* Subroutine of the insertion functions above. */
1090 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1091 inherit
, before_markers
)
1093 register int pos
, pos_byte
, nchars
, nbytes
;
1094 int inherit
, before_markers
;
1096 struct gcpro gcpro1
;
1097 int outgoing_nbytes
= nbytes
;
1100 /* Make OUTGOING_NBYTES describe the text
1101 as it will be inserted in this buffer. */
1103 if (NILP (current_buffer
->enable_multibyte_characters
))
1104 outgoing_nbytes
= nchars
;
1105 else if (! STRING_MULTIBYTE (string
))
1107 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1111 /* Do this before moving and increasing the gap,
1112 because the before-change hooks might move the gap
1113 or make it smaller. */
1114 prepare_to_modify_buffer (PT
, PT
, NULL
);
1117 move_gap_both (PT
, PT_BYTE
);
1118 if (GAP_SIZE
< outgoing_nbytes
)
1119 make_gap (outgoing_nbytes
- GAP_SIZE
);
1122 /* Copy the string text into the buffer, perhaps converting
1123 between single-byte and multibyte. */
1124 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1125 STRING_MULTIBYTE (string
),
1126 ! NILP (current_buffer
->enable_multibyte_characters
));
1128 #ifdef BYTE_COMBINING_DEBUG
1129 /* We have copied text into the gap, but we have not altered
1130 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1131 to these functions and get the same results as we would
1132 have got earlier on. Meanwhile, PT_ADDR does point to
1133 the text that has been stored by copy_text. */
1134 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1135 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1139 record_insert (PT
, nchars
);
1142 GAP_SIZE
-= outgoing_nbytes
;
1146 GPT_BYTE
+= outgoing_nbytes
;
1147 ZV_BYTE
+= outgoing_nbytes
;
1148 Z_BYTE
+= outgoing_nbytes
;
1149 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1154 adjust_overlays_for_insert (PT
, nchars
);
1155 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1156 PT_BYTE
+ outgoing_nbytes
,
1159 offset_intervals (current_buffer
, PT
, nchars
);
1161 intervals
= XSTRING (string
)->intervals
;
1162 /* Get the intervals for the part of the string we are inserting. */
1163 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1164 intervals
= copy_intervals (intervals
, pos
, nchars
);
1166 /* Insert those intervals. */
1167 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1168 current_buffer
, inherit
);
1170 adjust_point (nchars
, outgoing_nbytes
);
1173 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1174 current buffer. If the text in BUF has properties, they are absorbed
1175 into the current buffer.
1177 It does not work to use `insert' for this, because a malloc could happen
1178 and relocate BUF's text before the bcopy happens. */
1181 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1183 int charpos
, nchars
;
1188 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1189 signal_after_change (opoint
, 0, PT
- opoint
);
1190 update_compositions (opoint
, PT
, CHECK_BORDER
);
1194 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1199 register Lisp_Object temp
;
1200 int chunk
, chunk_expanded
;
1201 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1202 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1203 int incoming_nbytes
= to_byte
- from_byte
;
1204 int outgoing_nbytes
= incoming_nbytes
;
1207 /* Make OUTGOING_NBYTES describe the text
1208 as it will be inserted in this buffer. */
1210 if (NILP (current_buffer
->enable_multibyte_characters
))
1211 outgoing_nbytes
= nchars
;
1212 else if (NILP (buf
->enable_multibyte_characters
))
1214 int outgoing_before_gap
= 0;
1215 int outgoing_after_gap
= 0;
1217 if (from
< BUF_GPT (buf
))
1219 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1220 if (chunk
> incoming_nbytes
)
1221 chunk
= incoming_nbytes
;
1223 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1229 if (chunk
< incoming_nbytes
)
1231 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1233 incoming_nbytes
- chunk
);
1235 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1238 /* Make sure point-max won't overflow after this insertion. */
1239 XSETINT (temp
, outgoing_nbytes
+ Z
);
1240 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1241 error ("Maximum buffer size exceeded");
1243 /* Do this before moving and increasing the gap,
1244 because the before-change hooks might move the gap
1245 or make it smaller. */
1246 prepare_to_modify_buffer (PT
, PT
, NULL
);
1249 move_gap_both (PT
, PT_BYTE
);
1250 if (GAP_SIZE
< outgoing_nbytes
)
1251 make_gap (outgoing_nbytes
- GAP_SIZE
);
1253 if (from
< BUF_GPT (buf
))
1255 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1256 if (chunk
> incoming_nbytes
)
1257 chunk
= incoming_nbytes
;
1258 /* Record number of output bytes, so we know where
1259 to put the output from the second copy_text. */
1261 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1263 ! NILP (buf
->enable_multibyte_characters
),
1264 ! NILP (current_buffer
->enable_multibyte_characters
));
1267 chunk_expanded
= chunk
= 0;
1269 if (chunk
< incoming_nbytes
)
1270 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1271 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1272 ! NILP (buf
->enable_multibyte_characters
),
1273 ! NILP (current_buffer
->enable_multibyte_characters
));
1275 #ifdef BYTE_COMBINING_DEBUG
1276 /* We have copied text into the gap, but we have not altered
1277 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1278 to these functions and get the same results as we would
1279 have got earlier on. Meanwhile, GPT_ADDR does point to
1280 the text that has been stored by copy_text. */
1281 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1282 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1286 record_insert (PT
, nchars
);
1289 GAP_SIZE
-= outgoing_nbytes
;
1293 GPT_BYTE
+= outgoing_nbytes
;
1294 ZV_BYTE
+= outgoing_nbytes
;
1295 Z_BYTE
+= outgoing_nbytes
;
1296 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1301 adjust_overlays_for_insert (PT
, nchars
);
1302 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1303 PT_BYTE
+ outgoing_nbytes
,
1306 if (BUF_INTERVALS (current_buffer
) != 0)
1307 offset_intervals (current_buffer
, PT
, nchars
);
1309 /* Get the intervals for the part of the string we are inserting. */
1310 intervals
= BUF_INTERVALS (buf
);
1311 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1313 if (buf
== current_buffer
&& PT
<= from
)
1315 intervals
= copy_intervals (intervals
, from
, nchars
);
1318 /* Insert those intervals. */
1319 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1321 adjust_point (nchars
, outgoing_nbytes
);
1324 /* Record undo information and adjust markers and position keepers for
1325 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1326 chars (LEN_BYTE bytes) which resides in the gap just after
1329 PREV_TEXT nil means the new text was just inserted. */
1332 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1333 int from
, from_byte
, len
, len_byte
;
1334 Lisp_Object prev_text
;
1336 int nchars_del
= 0, nbytes_del
= 0;
1338 #ifdef BYTE_COMBINING_DEBUG
1339 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1340 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1344 if (STRINGP (prev_text
))
1346 nchars_del
= XSTRING (prev_text
)->size
;
1347 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1350 /* Update various buffer positions for the new text. */
1351 GAP_SIZE
-= len_byte
;
1353 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1354 GPT
+= len
; GPT_BYTE
+= len_byte
;
1355 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1358 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1361 adjust_markers_for_insert (from
, from_byte
,
1362 from
+ len
, from_byte
+ len_byte
, 0);
1364 if (! EQ (current_buffer
->undo_list
, Qt
))
1367 record_delete (from
, prev_text
);
1368 record_insert (from
, len
);
1371 if (len
> nchars_del
)
1372 adjust_overlays_for_insert (from
, len
- nchars_del
);
1373 else if (len
< nchars_del
)
1374 adjust_overlays_for_delete (from
, nchars_del
- len
);
1375 if (BUF_INTERVALS (current_buffer
) != 0)
1377 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1381 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1383 /* As byte combining will decrease Z, we must check this again. */
1384 if (Z
- GPT
< END_UNCHANGED
)
1385 END_UNCHANGED
= Z
- GPT
;
1390 evaporate_overlays (from
);
1394 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1395 This is for use when undo is not enabled in the current buffer. */
1398 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1399 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1401 #ifdef BYTE_COMBINING_DEBUG
1402 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1403 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1407 /* Update various buffer positions for the new text. */
1408 GAP_SIZE
-= len_byte
;
1410 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1411 GPT
+= len
; GPT_BYTE
+= len_byte
;
1412 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1415 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1418 adjust_markers_for_insert (from
, from_byte
,
1419 from
+ len
, from_byte
+ len_byte
, 0);
1421 if (len
> nchars_del
)
1422 adjust_overlays_for_insert (from
, len
- nchars_del
);
1423 else if (len
< nchars_del
)
1424 adjust_overlays_for_delete (from
, nchars_del
- len
);
1425 if (BUF_INTERVALS (current_buffer
) != 0)
1427 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1431 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1433 /* As byte combining will decrease Z, we must check this again. */
1434 if (Z
- GPT
< END_UNCHANGED
)
1435 END_UNCHANGED
= Z
- GPT
;
1440 evaporate_overlays (from
);
1444 /* Record undo information, adjust markers and position keepers for an
1445 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1446 text already exists in the current buffer but character length (TO
1447 - FROM) may be incorrect, the correct length is NEWLEN. */
1450 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1451 int from
, from_byte
, to
, to_byte
, newlen
;
1453 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1456 move_gap_both (to
, to_byte
);
1457 GAP_SIZE
+= len_byte
;
1458 GPT
-= len
; GPT_BYTE
-= len_byte
;
1459 ZV
-= len
; ZV_BYTE
-= len_byte
;
1460 Z
-= len
; Z_BYTE
-= len_byte
;
1461 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1464 /* Replace the text from character positions FROM to TO with NEW,
1465 If PREPARE is nonzero, call prepare_to_modify_buffer.
1466 If INHERIT, the newly inserted text should inherit text properties
1467 from the surrounding non-deleted text. */
1469 /* Note that this does not yet handle markers quite right.
1470 Also it needs to record a single undo-entry that does a replacement
1471 rather than a separate delete and insert.
1472 That way, undo will also handle markers properly.
1474 But if MARKERS is 0, don't relocate markers. */
1477 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1479 int from
, to
, prepare
, inherit
, markers
;
1481 int inschars
= XSTRING (new)->size
;
1482 int insbytes
= STRING_BYTES (XSTRING (new));
1483 int from_byte
, to_byte
;
1484 int nbytes_del
, nchars_del
;
1485 register Lisp_Object temp
;
1486 struct gcpro gcpro1
;
1488 int outgoing_insbytes
= insbytes
;
1489 Lisp_Object deletion
;
1498 int range_length
= to
- from
;
1499 prepare_to_modify_buffer (from
, to
, &from
);
1500 to
= from
+ range_length
;
1505 /* Make args be valid */
1511 from_byte
= CHAR_TO_BYTE (from
);
1512 to_byte
= CHAR_TO_BYTE (to
);
1514 nchars_del
= to
- from
;
1515 nbytes_del
= to_byte
- from_byte
;
1517 if (nbytes_del
<= 0 && insbytes
== 0)
1520 /* Make OUTGOING_INSBYTES describe the text
1521 as it will be inserted in this buffer. */
1523 if (NILP (current_buffer
->enable_multibyte_characters
))
1524 outgoing_insbytes
= inschars
;
1525 else if (! STRING_MULTIBYTE (new))
1527 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1529 /* Make sure point-max won't overflow after this insertion. */
1530 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1531 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1532 error ("Maximum buffer size exceeded");
1536 /* Make sure the gap is somewhere in or next to what we are deleting. */
1538 gap_right (from
, from_byte
);
1540 gap_left (to
, to_byte
, 0);
1542 /* Even if we don't record for undo, we must keep the original text
1543 because we may have to recover it because of inappropriate byte
1545 if (! EQ (current_buffer
->undo_list
, Qt
))
1546 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1548 GAP_SIZE
+= nbytes_del
;
1551 ZV_BYTE
-= nbytes_del
;
1552 Z_BYTE
-= nbytes_del
;
1554 GPT_BYTE
= from_byte
;
1555 *(GPT_ADDR
) = 0; /* Put an anchor. */
1560 if (GPT
- BEG
< BEG_UNCHANGED
)
1561 BEG_UNCHANGED
= GPT
- BEG
;
1562 if (Z
- GPT
< END_UNCHANGED
)
1563 END_UNCHANGED
= Z
- GPT
;
1565 if (GAP_SIZE
< insbytes
)
1566 make_gap (insbytes
- GAP_SIZE
);
1568 /* Copy the string text into the buffer, perhaps converting
1569 between single-byte and multibyte. */
1570 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1571 STRING_MULTIBYTE (new),
1572 ! NILP (current_buffer
->enable_multibyte_characters
));
1574 #ifdef BYTE_COMBINING_DEBUG
1575 /* We have copied text into the gap, but we have not marked
1576 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1577 here, for both the previous text and the following text.
1578 Meanwhile, GPT_ADDR does point to
1579 the text that has been stored by copy_text. */
1580 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1581 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1585 if (! EQ (current_buffer
->undo_list
, Qt
))
1587 record_delete (from
, deletion
);
1588 record_insert (from
, inschars
);
1591 GAP_SIZE
-= outgoing_insbytes
;
1595 GPT_BYTE
+= outgoing_insbytes
;
1596 ZV_BYTE
+= outgoing_insbytes
;
1597 Z_BYTE
+= outgoing_insbytes
;
1598 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1603 /* Adjust the overlay center as needed. This must be done after
1604 adjusting the markers that bound the overlays. */
1605 adjust_overlays_for_delete (from
, nchars_del
);
1606 adjust_overlays_for_insert (from
, inschars
);
1608 /* Adjust markers for the deletion and the insertion. */
1610 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1611 inschars
, outgoing_insbytes
);
1613 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1615 /* Get the intervals for the part of the string we are inserting--
1616 not including the combined-before bytes. */
1617 intervals
= XSTRING (new)->intervals
;
1618 /* Insert those intervals. */
1619 graft_intervals_into_buffer (intervals
, from
, inschars
,
1620 current_buffer
, inherit
);
1622 /* Relocate point as if it were a marker. */
1624 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1625 (from_byte
+ outgoing_insbytes
1626 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1628 if (outgoing_insbytes
== 0)
1629 evaporate_overlays (from
);
1636 signal_after_change (from
, nchars_del
, GPT
- from
);
1637 update_compositions (from
, GPT
, CHECK_BORDER
);
1640 /* Delete characters in current buffer
1641 from FROM up to (but not including) TO.
1642 If TO comes before FROM, we delete nothing. */
1645 del_range (from
, to
)
1646 register int from
, to
;
1648 del_range_1 (from
, to
, 1, 0);
1651 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1652 RET_STRING says to return the deleted text. */
1655 del_range_1 (from
, to
, prepare
, ret_string
)
1656 int from
, to
, prepare
, ret_string
;
1658 int from_byte
, to_byte
;
1659 Lisp_Object deletion
;
1660 struct gcpro gcpro1
;
1662 /* Make args be valid */
1673 int range_length
= to
- from
;
1674 prepare_to_modify_buffer (from
, to
, &from
);
1675 to
= min (ZV
, from
+ range_length
);
1678 from_byte
= CHAR_TO_BYTE (from
);
1679 to_byte
= CHAR_TO_BYTE (to
);
1681 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1683 signal_after_change (from
, to
- from
, 0);
1684 update_compositions (from
, from
, CHECK_HEAD
);
1689 /* Like del_range_1 but args are byte positions, not char positions. */
1692 del_range_byte (from_byte
, to_byte
, prepare
)
1693 int from_byte
, to_byte
, prepare
;
1697 /* Make args be valid */
1698 if (from_byte
< BEGV_BYTE
)
1699 from_byte
= BEGV_BYTE
;
1700 if (to_byte
> ZV_BYTE
)
1703 if (to_byte
<= from_byte
)
1706 from
= BYTE_TO_CHAR (from_byte
);
1707 to
= BYTE_TO_CHAR (to_byte
);
1711 int old_from
= from
, old_to
= Z
- to
;
1712 int range_length
= to
- from
;
1713 prepare_to_modify_buffer (from
, to
, &from
);
1714 to
= from
+ range_length
;
1716 if (old_from
!= from
)
1717 from_byte
= CHAR_TO_BYTE (from
);
1723 else if (old_to
== Z
- to
)
1724 to_byte
= CHAR_TO_BYTE (to
);
1727 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1728 signal_after_change (from
, to
- from
, 0);
1729 update_compositions (from
, from
, CHECK_HEAD
);
1732 /* Like del_range_1, but positions are specified both as charpos
1736 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1737 int from
, from_byte
, to
, to_byte
, prepare
;
1739 /* Make args be valid */
1740 if (from_byte
< BEGV_BYTE
)
1741 from_byte
= BEGV_BYTE
;
1742 if (to_byte
> ZV_BYTE
)
1745 if (to_byte
<= from_byte
)
1755 int old_from
= from
, old_to
= Z
- to
;
1756 int range_length
= to
- from
;
1757 prepare_to_modify_buffer (from
, to
, &from
);
1758 to
= from
+ range_length
;
1760 if (old_from
!= from
)
1761 from_byte
= CHAR_TO_BYTE (from
);
1767 else if (old_to
== Z
- to
)
1768 to_byte
= CHAR_TO_BYTE (to
);
1771 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1772 signal_after_change (from
, to
- from
, 0);
1773 update_compositions (from
, from
, CHECK_HEAD
);
1776 /* Delete a range of text, specified both as character positions
1777 and byte positions. FROM and TO are character positions,
1778 while FROM_BYTE and TO_BYTE are byte positions.
1779 If RET_STRING is true, the deleted area is returned as a string. */
1782 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1783 int from
, from_byte
, to
, to_byte
, ret_string
;
1785 register int nbytes_del
, nchars_del
;
1786 Lisp_Object deletion
;
1790 nchars_del
= to
- from
;
1791 nbytes_del
= to_byte
- from_byte
;
1793 /* Make sure the gap is somewhere in or next to what we are deleting. */
1795 gap_right (from
, from_byte
);
1797 gap_left (to
, to_byte
, 0);
1799 #ifdef BYTE_COMBINING_DEBUG
1800 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1801 Z_BYTE
- to_byte
, from
, from_byte
))
1805 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1806 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1810 /* Relocate all markers pointing into the new, larger gap
1811 to point at the end of the text before the gap.
1812 Do this before recording the deletion,
1813 so that undo handles this after reinserting the text. */
1814 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1816 if (! EQ (current_buffer
->undo_list
, Qt
))
1817 record_delete (from
, deletion
);
1820 /* Relocate point as if it were a marker. */
1822 adjust_point (from
- (PT
< to
? PT
: to
),
1823 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1825 offset_intervals (current_buffer
, from
, - nchars_del
);
1827 /* Adjust the overlay center as needed. This must be done after
1828 adjusting the markers that bound the overlays. */
1829 adjust_overlays_for_delete (from
, nchars_del
);
1831 GAP_SIZE
+= nbytes_del
;
1832 ZV_BYTE
-= nbytes_del
;
1833 Z_BYTE
-= nbytes_del
;
1837 GPT_BYTE
= from_byte
;
1838 *(GPT_ADDR
) = 0; /* Put an anchor. */
1843 if (GPT
- BEG
< BEG_UNCHANGED
)
1844 BEG_UNCHANGED
= GPT
- BEG
;
1845 if (Z
- GPT
< END_UNCHANGED
)
1846 END_UNCHANGED
= Z
- GPT
;
1850 evaporate_overlays (from
);
1855 /* Call this if you're about to change the region of BUFFER from
1856 character positions START to END. This checks the read-only
1857 properties of the region, calls the necessary modification hooks,
1858 and warns the next redisplay that it should pay attention to that
1862 modify_region (buffer
, start
, end
)
1863 struct buffer
*buffer
;
1866 struct buffer
*old_buffer
= current_buffer
;
1868 if (buffer
!= old_buffer
)
1869 set_buffer_internal (buffer
);
1871 prepare_to_modify_buffer (start
, end
, NULL
);
1873 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1875 if (MODIFF
<= SAVE_MODIFF
)
1876 record_first_change ();
1879 buffer
->point_before_scroll
= Qnil
;
1881 if (buffer
!= old_buffer
)
1882 set_buffer_internal (old_buffer
);
1885 /* Check that it is okay to modify the buffer between START and END,
1886 which are char positions.
1888 Run the before-change-function, if any. If intervals are in use,
1889 verify that the text to be modified is not read-only, and call
1890 any modification properties the text may have.
1892 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1893 by holding its value temporarily in a marker. */
1896 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1900 if (!NILP (current_buffer
->read_only
))
1901 Fbarf_if_buffer_read_only ();
1903 /* Let redisplay consider other windows than selected_window
1904 if modifying another buffer. */
1905 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1906 ++windows_or_buffers_changed
;
1908 if (BUF_INTERVALS (current_buffer
) != 0)
1912 Lisp_Object preserve_marker
;
1913 struct gcpro gcpro1
;
1914 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1915 GCPRO1 (preserve_marker
);
1916 verify_interval_modification (current_buffer
, start
, end
);
1917 *preserve_ptr
= marker_position (preserve_marker
);
1918 unchain_marker (preserve_marker
);
1922 verify_interval_modification (current_buffer
, start
, end
);
1925 #ifdef CLASH_DETECTION
1926 if (!NILP (current_buffer
->file_truename
)
1927 /* Make binding buffer-file-name to nil effective. */
1928 && !NILP (current_buffer
->filename
)
1929 && SAVE_MODIFF
>= MODIFF
)
1930 lock_file (current_buffer
->file_truename
);
1932 /* At least warn if this file has changed on disk since it was visited. */
1933 if (!NILP (current_buffer
->filename
)
1934 && SAVE_MODIFF
>= MODIFF
1935 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1936 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1937 call1 (intern ("ask-user-about-supersession-threat"),
1938 current_buffer
->filename
);
1939 #endif /* not CLASH_DETECTION */
1941 signal_before_change (start
, end
, preserve_ptr
);
1943 if (current_buffer
->newline_cache
)
1944 invalidate_region_cache (current_buffer
,
1945 current_buffer
->newline_cache
,
1946 start
- BEG
, Z
- end
);
1947 if (current_buffer
->width_run_cache
)
1948 invalidate_region_cache (current_buffer
,
1949 current_buffer
->width_run_cache
,
1950 start
- BEG
, Z
- end
);
1952 Vdeactivate_mark
= Qt
;
1955 /* These macros work with an argument named `preserve_ptr'
1956 and a local variable named `preserve_marker'. */
1958 #define PRESERVE_VALUE \
1959 if (preserve_ptr && NILP (preserve_marker)) \
1960 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1962 #define RESTORE_VALUE \
1963 if (! NILP (preserve_marker)) \
1965 *preserve_ptr = marker_position (preserve_marker); \
1966 unchain_marker (preserve_marker); \
1969 #define PRESERVE_START_END \
1970 if (NILP (start_marker)) \
1971 start_marker = Fcopy_marker (start, Qnil); \
1972 if (NILP (end_marker)) \
1973 end_marker = Fcopy_marker (end, Qnil);
1975 #define FETCH_START \
1976 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1979 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1981 /* Signal a change to the buffer immediately before it happens.
1982 START_INT and END_INT are the bounds of the text to be changed.
1984 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1985 by holding its value temporarily in a marker. */
1988 signal_before_change (start_int
, end_int
, preserve_ptr
)
1989 int start_int
, end_int
;
1992 Lisp_Object start
, end
;
1993 Lisp_Object start_marker
, end_marker
;
1994 Lisp_Object preserve_marker
;
1995 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1997 if (inhibit_modification_hooks
)
2000 start
= make_number (start_int
);
2001 end
= make_number (end_int
);
2002 preserve_marker
= Qnil
;
2003 start_marker
= Qnil
;
2005 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2007 /* If buffer is unmodified, run a special hook for that case. */
2008 if (SAVE_MODIFF
>= MODIFF
2009 && !NILP (Vfirst_change_hook
)
2010 && !NILP (Vrun_hooks
))
2014 call1 (Vrun_hooks
, Qfirst_change_hook
);
2017 /* Now run the before-change-functions if any. */
2018 if (!NILP (Vbefore_change_functions
))
2020 Lisp_Object args
[3];
2021 Lisp_Object before_change_functions
;
2022 Lisp_Object after_change_functions
;
2023 struct gcpro gcpro1
, gcpro2
;
2024 struct buffer
*old
= current_buffer
;
2030 /* "Bind" before-change-functions and after-change-functions
2031 to nil--but in a way that errors don't know about.
2032 That way, if there's an error in them, they will stay nil. */
2033 before_change_functions
= Vbefore_change_functions
;
2034 after_change_functions
= Vafter_change_functions
;
2035 Vbefore_change_functions
= Qnil
;
2036 Vafter_change_functions
= Qnil
;
2037 GCPRO2 (before_change_functions
, after_change_functions
);
2039 /* Actually run the hook functions. */
2040 args
[0] = Qbefore_change_functions
;
2041 args
[1] = FETCH_START
;
2042 args
[2] = FETCH_END
;
2043 run_hook_list_with_args (before_change_functions
, 3, args
);
2045 /* "Unbind" the variables we "bound" to nil. Beware a
2046 buffer-local hook which changes the buffer when run (e.g. W3). */
2047 if (old
!= current_buffer
)
2049 new = current_buffer
;
2050 set_buffer_internal (old
);
2051 Vbefore_change_functions
= before_change_functions
;
2052 Vafter_change_functions
= after_change_functions
;
2053 set_buffer_internal (new);
2057 Vbefore_change_functions
= before_change_functions
;
2058 Vafter_change_functions
= after_change_functions
;
2063 if (!NILP (current_buffer
->overlays_before
)
2064 || !NILP (current_buffer
->overlays_after
))
2067 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2068 FETCH_START
, FETCH_END
, Qnil
);
2071 if (! NILP (start_marker
))
2072 free_marker (start_marker
);
2073 if (! NILP (end_marker
))
2074 free_marker (end_marker
);
2079 /* Signal a change immediately after it happens.
2080 CHARPOS is the character position of the start of the changed text.
2081 LENDEL is the number of characters of the text before the change.
2082 (Not the whole buffer; just the part that was changed.)
2083 LENINS is the number of characters in that part of the text
2084 after the change. */
2087 signal_after_change (charpos
, lendel
, lenins
)
2088 int charpos
, lendel
, lenins
;
2090 if (inhibit_modification_hooks
)
2093 /* If we are deferring calls to the after-change functions
2094 and there are no before-change functions,
2095 just record the args that we were going to use. */
2096 if (! NILP (Vcombine_after_change_calls
)
2097 && NILP (Vbefore_change_functions
)
2098 && NILP (current_buffer
->overlays_before
)
2099 && NILP (current_buffer
->overlays_after
))
2103 if (!NILP (combine_after_change_list
)
2104 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2105 Fcombine_after_change_execute ();
2107 elt
= Fcons (make_number (charpos
- BEG
),
2108 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2109 Fcons (make_number (lenins
- lendel
), Qnil
)));
2110 combine_after_change_list
2111 = Fcons (elt
, combine_after_change_list
);
2112 combine_after_change_buffer
= Fcurrent_buffer ();
2117 if (!NILP (combine_after_change_list
))
2118 Fcombine_after_change_execute ();
2120 if (!NILP (Vafter_change_functions
))
2122 Lisp_Object args
[4];
2123 Lisp_Object before_change_functions
;
2124 Lisp_Object after_change_functions
;
2125 struct buffer
*old
= current_buffer
;
2127 struct gcpro gcpro1
, gcpro2
;
2129 /* "Bind" before-change-functions and after-change-functions
2130 to nil--but in a way that errors don't know about.
2131 That way, if there's an error in them, they will stay nil. */
2132 before_change_functions
= Vbefore_change_functions
;
2133 after_change_functions
= Vafter_change_functions
;
2134 Vbefore_change_functions
= Qnil
;
2135 Vafter_change_functions
= Qnil
;
2136 GCPRO2 (before_change_functions
, after_change_functions
);
2138 /* Actually run the hook functions. */
2139 args
[0] = Qafter_change_functions
;
2140 XSETFASTINT (args
[1], charpos
);
2141 XSETFASTINT (args
[2], charpos
+ lenins
);
2142 XSETFASTINT (args
[3], lendel
);
2143 run_hook_list_with_args (after_change_functions
,
2146 /* "Unbind" the variables we "bound" to nil. Beware a
2147 buffer-local hook which changes the buffer when run (e.g. W3). */
2148 if (old
!= current_buffer
)
2150 new = current_buffer
;
2151 set_buffer_internal (old
);
2152 Vbefore_change_functions
= before_change_functions
;
2153 Vafter_change_functions
= after_change_functions
;
2154 set_buffer_internal (new);
2158 Vbefore_change_functions
= before_change_functions
;
2159 Vafter_change_functions
= after_change_functions
;
2164 if (!NILP (current_buffer
->overlays_before
)
2165 || !NILP (current_buffer
->overlays_after
))
2166 report_overlay_modification (make_number (charpos
),
2167 make_number (charpos
+ lenins
),
2169 make_number (charpos
),
2170 make_number (charpos
+ lenins
),
2171 make_number (lendel
));
2173 /* After an insertion, call the text properties
2174 insert-behind-hooks or insert-in-front-hooks. */
2176 report_interval_modification (make_number (charpos
),
2177 make_number (charpos
+ lenins
));
2181 Fcombine_after_change_execute_1 (val
)
2184 Vcombine_after_change_calls
= val
;
2188 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2189 Scombine_after_change_execute
, 0, 0, 0,
2190 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2193 int count
= specpdl_ptr
- specpdl
;
2194 int beg
, end
, change
;
2198 if (NILP (combine_after_change_list
))
2201 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2203 Fset_buffer (combine_after_change_buffer
);
2205 /* # chars unchanged at beginning of buffer. */
2207 /* # chars unchanged at end of buffer. */
2209 /* Total amount of insertion (negative for deletion). */
2212 /* Scan the various individual changes,
2213 accumulating the range info in BEG, END and CHANGE. */
2214 for (tail
= combine_after_change_list
; CONSP (tail
);
2218 int thisbeg
, thisend
, thischange
;
2220 /* Extract the info from the next element. */
2224 thisbeg
= XINT (XCAR (elt
));
2229 thisend
= XINT (XCAR (elt
));
2234 thischange
= XINT (XCAR (elt
));
2236 /* Merge this range into the accumulated range. */
2237 change
+= thischange
;
2244 /* Get the current start and end positions of the range
2245 that was changed. */
2249 /* We are about to handle these, so discard them. */
2250 combine_after_change_list
= Qnil
;
2252 /* Now run the after-change functions for real.
2253 Turn off the flag that defers them. */
2254 record_unwind_protect (Fcombine_after_change_execute_1
,
2255 Vcombine_after_change_calls
);
2256 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2257 update_compositions (begpos
, endpos
, CHECK_ALL
);
2259 return unbind_to (count
, Qnil
);
2265 staticpro (&combine_after_change_list
);
2266 combine_after_change_list
= Qnil
;
2267 combine_after_change_buffer
= Qnil
;
2269 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2270 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2271 check_markers_debug_flag
= 0;
2272 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2273 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2274 Vcombine_after_change_calls
= Qnil
;
2276 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2277 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2278 This affects `before-change-functions' and `after-change-functions',
2279 as well as hooks attached to text properties and overlays. */);
2280 inhibit_modification_hooks
= 0;
2281 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2282 staticpro (&Qinhibit_modification_hooks
);
2284 defsubr (&Scombine_after_change_execute
);