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 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
+ nbytes_added
539 >= MOST_POSITIVE_FIXNUM
)
540 error ("Buffer exceeds maximum size");
542 enlarge_buffer_text (current_buffer
, nbytes_added
);
544 /* Prevent quitting in move_gap. */
549 real_gap_loc_byte
= GPT_BYTE
;
550 old_gap_size
= GAP_SIZE
;
552 /* Call the newly allocated space a gap at the end of the whole space. */
554 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
555 GAP_SIZE
= nbytes_added
;
557 /* Move the new gap down to be consecutive with the end of the old one.
558 This adjusts the markers properly too. */
559 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
561 /* Now combine the two into one large gap. */
562 GAP_SIZE
+= old_gap_size
;
564 GPT_BYTE
= real_gap_loc_byte
;
573 /* Make the gap NBYTES_REMOVED bytes shorted. */
576 make_gap_smaller (nbytes_removed
)
581 int real_gap_loc_byte
;
586 /* Make sure the gap is at least 20 bytes. */
587 if (GAP_SIZE
- nbytes_removed
< 20)
588 nbytes_removed
= GAP_SIZE
- 20;
590 /* Prevent quitting in move_gap. */
595 real_gap_loc_byte
= GPT_BYTE
;
596 old_gap_size
= GAP_SIZE
;
598 real_Z_byte
= Z_BYTE
;
600 /* Pretend that the last unwanted part of the gap is the entire gap,
601 and that the first desired part of the gap is part of the buffer
603 bzero (GPT_ADDR
, GAP_SIZE
- nbytes_removed
);
604 GPT
+= GAP_SIZE
- nbytes_removed
;
605 GPT_BYTE
+= GAP_SIZE
- nbytes_removed
;
606 Z
+= GAP_SIZE
- nbytes_removed
;
607 Z_BYTE
+= GAP_SIZE
- nbytes_removed
;
608 GAP_SIZE
= nbytes_removed
;
610 /* Move the unwanted pretend gap to the end of the buffer. This
611 adjusts the markers properly too. */
612 gap_right (Z
, Z_BYTE
);
614 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
616 /* Now restore the desired gap. */
617 GAP_SIZE
= old_gap_size
- nbytes_removed
;
619 GPT_BYTE
= real_gap_loc_byte
;
621 Z_BYTE
= real_Z_byte
;
630 make_gap (nbytes_added
)
633 if (nbytes_added
>= 0)
634 make_gap_larger (nbytes_added
);
635 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
637 make_gap_smaller (-nbytes_added
);
641 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
642 FROM_MULTIBYTE says whether the incoming text is multibyte.
643 TO_MULTIBYTE says whether to store the text as multibyte.
644 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
646 Return the number of bytes stored at TO_ADDR. */
649 copy_text (from_addr
, to_addr
, nbytes
,
650 from_multibyte
, to_multibyte
)
651 unsigned char *from_addr
;
652 unsigned char *to_addr
;
654 int from_multibyte
, to_multibyte
;
656 if (from_multibyte
== to_multibyte
)
658 bcopy (from_addr
, to_addr
, nbytes
);
661 else if (from_multibyte
)
664 int bytes_left
= nbytes
;
665 Lisp_Object tbl
= Qnil
;
667 /* We set the variable tbl to the reverse table of
668 Vnonascii_translation_table in advance. */
669 if (CHAR_TABLE_P (Vnonascii_translation_table
))
671 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
673 if (!CHAR_TABLE_P (tbl
))
677 /* Convert multibyte to single byte. */
678 while (bytes_left
> 0)
681 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
682 if (!SINGLE_BYTE_CHAR_P (c
))
683 c
= multibyte_char_to_unibyte (c
, tbl
);
685 from_addr
+= thislen
;
686 bytes_left
-= thislen
;
693 unsigned char *initial_to_addr
= to_addr
;
695 /* Convert single-byte to multibyte. */
698 int c
= *from_addr
++;
702 c
= unibyte_char_to_multibyte (c
);
703 to_addr
+= CHAR_STRING (c
, to_addr
);
707 /* Special case for speed. */
708 *to_addr
++ = c
, nbytes
--;
710 return to_addr
- initial_to_addr
;
714 /* Return the number of bytes it would take
715 to convert some single-byte text to multibyte.
716 The single-byte text consists of NBYTES bytes at PTR. */
719 count_size_as_multibyte (ptr
, nbytes
)
724 int outgoing_nbytes
= 0;
726 for (i
= 0; i
< nbytes
; i
++)
728 unsigned int c
= *ptr
++;
734 c
= unibyte_char_to_multibyte (c
);
735 outgoing_nbytes
+= CHAR_BYTES (c
);
739 return outgoing_nbytes
;
742 /* Insert a string of specified length before point.
743 This function judges multibyteness based on
744 enable_multibyte_characters in the current buffer;
745 it never converts between single-byte and multibyte.
747 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
748 prepare_to_modify_buffer could relocate the text. */
751 insert (string
, nbytes
)
752 register unsigned char *string
;
758 insert_1 (string
, nbytes
, 0, 1, 0);
759 signal_after_change (opoint
, 0, PT
- opoint
);
760 update_compositions (opoint
, PT
, CHECK_BORDER
);
764 /* Likewise, but inherit text properties from neighboring characters. */
767 insert_and_inherit (string
, nbytes
)
768 register unsigned char *string
;
774 insert_1 (string
, nbytes
, 1, 1, 0);
775 signal_after_change (opoint
, 0, PT
- opoint
);
776 update_compositions (opoint
, PT
, CHECK_BORDER
);
780 /* Insert the character C before point. Do not inherit text properties. */
786 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
789 if (! NILP (current_buffer
->enable_multibyte_characters
))
790 len
= CHAR_STRING (c
, str
);
800 /* Insert the null-terminated string S before point. */
806 insert (s
, strlen (s
));
809 /* Like `insert' except that all markers pointing at the place where
810 the insertion happens are adjusted to point after it.
811 Don't use this function to insert part of a Lisp string,
812 since gc could happen and relocate it. */
815 insert_before_markers (string
, nbytes
)
816 unsigned char *string
;
823 insert_1 (string
, nbytes
, 0, 1, 1);
824 signal_after_change (opoint
, 0, PT
- opoint
);
825 update_compositions (opoint
, PT
, CHECK_BORDER
);
829 /* Likewise, but inherit text properties from neighboring characters. */
832 insert_before_markers_and_inherit (string
, nbytes
)
833 unsigned char *string
;
840 insert_1 (string
, nbytes
, 1, 1, 1);
841 signal_after_change (opoint
, 0, PT
- opoint
);
842 update_compositions (opoint
, PT
, CHECK_BORDER
);
846 /* Subroutine used by the insert functions above. */
849 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
850 register unsigned char *string
;
852 int inherit
, prepare
, before_markers
;
854 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
855 inherit
, prepare
, before_markers
);
859 #ifdef BYTE_COMBINING_DEBUG
861 /* See if the bytes before POS/POS_BYTE combine with bytes
862 at the start of STRING to form a single character.
863 If so, return the number of bytes at the start of STRING
864 which combine in this way. Otherwise, return 0. */
867 count_combining_before (string
, length
, pos
, pos_byte
)
868 unsigned char *string
;
872 int len
, combining_bytes
;
875 if (NILP (current_buffer
->enable_multibyte_characters
))
878 /* At first, we can exclude the following cases:
879 (1) STRING[0] can't be a following byte of multibyte sequence.
880 (2) POS is the start of the current buffer.
881 (3) A character before POS is not a multibyte character. */
882 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
884 if (pos_byte
== BEG_BYTE
) /* case (2) */
887 p
= BYTE_POS_ADDR (pos_byte
- 1);
888 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
889 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
892 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
893 if (combining_bytes
<= 0)
894 /* The character preceding POS is, complete and no room for
895 combining bytes (combining_bytes == 0), or an independent 8-bit
896 character (combining_bytes < 0). */
899 /* We have a combination situation. Count the bytes at STRING that
902 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
905 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
908 /* See if the bytes after POS/POS_BYTE combine with bytes
909 at the end of STRING to form a single character.
910 If so, return the number of bytes after POS/POS_BYTE
911 which combine in this way. Otherwise, return 0. */
914 count_combining_after (string
, length
, pos
, pos_byte
)
915 unsigned char *string
;
919 int opos_byte
= pos_byte
;
924 if (NILP (current_buffer
->enable_multibyte_characters
))
927 /* At first, we can exclude the following cases:
928 (1) The last byte of STRING is an ASCII.
929 (2) POS is the last of the current buffer.
930 (3) A character at POS can't be a following byte of multibyte
932 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
934 if (pos_byte
== Z_BYTE
) /* case (2) */
936 bufp
= BYTE_POS_ADDR (pos_byte
);
937 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
941 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
947 /* All characters in STRING are not character head. We must
948 check also preceding bytes at POS. We are sure that the gap
950 unsigned char *p
= BEG_ADDR
;
952 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
954 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
957 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
958 return (bytes
<= pos_byte
- 1 - i
+ length
960 : bytes
- (pos_byte
- 1 - i
+ length
));
962 if (!BASE_LEADING_CODE_P (string
[i
]))
965 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
967 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
969 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
975 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
976 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
977 are the same as in insert_1. */
980 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
981 register unsigned char *string
;
982 register int nchars
, nbytes
;
983 int inherit
, prepare
, before_markers
;
988 if (NILP (current_buffer
->enable_multibyte_characters
))
992 /* Do this before moving and increasing the gap,
993 because the before-change hooks might move the gap
994 or make it smaller. */
995 prepare_to_modify_buffer (PT
, PT
, NULL
);
998 move_gap_both (PT
, PT_BYTE
);
999 if (GAP_SIZE
< nbytes
)
1000 make_gap (nbytes
- GAP_SIZE
);
1002 #ifdef BYTE_COMBINING_DEBUG
1003 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
1004 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
1008 /* Record deletion of the surrounding text that combines with
1009 the insertion. This, together with recording the insertion,
1010 will add up to the right stuff in the undo list. */
1011 record_insert (PT
, nchars
);
1014 bcopy (string
, GPT_ADDR
, nbytes
);
1023 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1028 adjust_overlays_for_insert (PT
, nchars
);
1029 adjust_markers_for_insert (PT
, PT_BYTE
,
1030 PT
+ nchars
, PT_BYTE
+ nbytes
,
1033 if (BUF_INTERVALS (current_buffer
) != 0)
1034 offset_intervals (current_buffer
, PT
, nchars
);
1036 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1037 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1040 adjust_point (nchars
, nbytes
);
1045 /* Insert the part of the text of STRING, a Lisp object assumed to be
1046 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1047 starting at position POS / POS_BYTE. If the text of STRING has properties,
1048 copy them into the buffer.
1050 It does not work to use `insert' for this, because a GC could happen
1051 before we bcopy the stuff into the buffer, and relocate the string
1052 without insert noticing. */
1055 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1057 register int pos
, pos_byte
, length
, length_byte
;
1061 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1063 signal_after_change (opoint
, 0, PT
- opoint
);
1064 update_compositions (opoint
, PT
, CHECK_BORDER
);
1067 /* Like `insert_from_string' except that all markers pointing
1068 at the place where the insertion happens are adjusted to point after it. */
1071 insert_from_string_before_markers (string
, pos
, pos_byte
,
1072 length
, length_byte
, inherit
)
1074 register int pos
, pos_byte
, length
, length_byte
;
1078 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1080 signal_after_change (opoint
, 0, PT
- opoint
);
1081 update_compositions (opoint
, PT
, CHECK_BORDER
);
1084 /* Subroutine of the insertion functions above. */
1087 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1088 inherit
, before_markers
)
1090 register int pos
, pos_byte
, nchars
, nbytes
;
1091 int inherit
, before_markers
;
1093 struct gcpro gcpro1
;
1094 int outgoing_nbytes
= nbytes
;
1097 /* Make OUTGOING_NBYTES describe the text
1098 as it will be inserted in this buffer. */
1100 if (NILP (current_buffer
->enable_multibyte_characters
))
1101 outgoing_nbytes
= nchars
;
1102 else if (! STRING_MULTIBYTE (string
))
1104 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1108 /* Do this before moving and increasing the gap,
1109 because the before-change hooks might move the gap
1110 or make it smaller. */
1111 prepare_to_modify_buffer (PT
, PT
, NULL
);
1114 move_gap_both (PT
, PT_BYTE
);
1115 if (GAP_SIZE
< outgoing_nbytes
)
1116 make_gap (outgoing_nbytes
- GAP_SIZE
);
1119 /* Copy the string text into the buffer, perhaps converting
1120 between single-byte and multibyte. */
1121 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1122 STRING_MULTIBYTE (string
),
1123 ! NILP (current_buffer
->enable_multibyte_characters
));
1125 #ifdef BYTE_COMBINING_DEBUG
1126 /* We have copied text into the gap, but we have not altered
1127 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1128 to these functions and get the same results as we would
1129 have got earlier on. Meanwhile, PT_ADDR does point to
1130 the text that has been stored by copy_text. */
1131 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1132 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1136 record_insert (PT
, nchars
);
1139 GAP_SIZE
-= outgoing_nbytes
;
1143 GPT_BYTE
+= outgoing_nbytes
;
1144 ZV_BYTE
+= outgoing_nbytes
;
1145 Z_BYTE
+= outgoing_nbytes
;
1146 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1151 adjust_overlays_for_insert (PT
, nchars
);
1152 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1153 PT_BYTE
+ outgoing_nbytes
,
1156 offset_intervals (current_buffer
, PT
, nchars
);
1158 intervals
= XSTRING (string
)->intervals
;
1159 /* Get the intervals for the part of the string we are inserting. */
1160 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1161 intervals
= copy_intervals (intervals
, pos
, nchars
);
1163 /* Insert those intervals. */
1164 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1165 current_buffer
, inherit
);
1167 adjust_point (nchars
, outgoing_nbytes
);
1170 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1171 current buffer. If the text in BUF has properties, they are absorbed
1172 into the current buffer.
1174 It does not work to use `insert' for this, because a malloc could happen
1175 and relocate BUF's text before the bcopy happens. */
1178 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1180 int charpos
, nchars
;
1185 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1186 signal_after_change (opoint
, 0, PT
- opoint
);
1187 update_compositions (opoint
, PT
, CHECK_BORDER
);
1191 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1196 register Lisp_Object temp
;
1197 int chunk
, chunk_expanded
;
1198 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1199 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1200 int incoming_nbytes
= to_byte
- from_byte
;
1201 int outgoing_nbytes
= incoming_nbytes
;
1204 /* Make OUTGOING_NBYTES describe the text
1205 as it will be inserted in this buffer. */
1207 if (NILP (current_buffer
->enable_multibyte_characters
))
1208 outgoing_nbytes
= nchars
;
1209 else if (NILP (buf
->enable_multibyte_characters
))
1211 int outgoing_before_gap
= 0;
1212 int outgoing_after_gap
= 0;
1214 if (from
< BUF_GPT (buf
))
1216 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1217 if (chunk
> incoming_nbytes
)
1218 chunk
= incoming_nbytes
;
1220 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1226 if (chunk
< incoming_nbytes
)
1228 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1230 incoming_nbytes
- chunk
);
1232 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1235 /* Make sure point-max won't overflow after this insertion. */
1236 XSETINT (temp
, outgoing_nbytes
+ Z
);
1237 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1238 error ("Maximum buffer size exceeded");
1240 /* Do this before moving and increasing the gap,
1241 because the before-change hooks might move the gap
1242 or make it smaller. */
1243 prepare_to_modify_buffer (PT
, PT
, NULL
);
1246 move_gap_both (PT
, PT_BYTE
);
1247 if (GAP_SIZE
< outgoing_nbytes
)
1248 make_gap (outgoing_nbytes
- GAP_SIZE
);
1250 if (from
< BUF_GPT (buf
))
1252 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1253 if (chunk
> incoming_nbytes
)
1254 chunk
= incoming_nbytes
;
1255 /* Record number of output bytes, so we know where
1256 to put the output from the second copy_text. */
1258 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1260 ! NILP (buf
->enable_multibyte_characters
),
1261 ! NILP (current_buffer
->enable_multibyte_characters
));
1264 chunk_expanded
= chunk
= 0;
1266 if (chunk
< incoming_nbytes
)
1267 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1268 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1269 ! NILP (buf
->enable_multibyte_characters
),
1270 ! NILP (current_buffer
->enable_multibyte_characters
));
1272 #ifdef BYTE_COMBINING_DEBUG
1273 /* We have copied text into the gap, but we have not altered
1274 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1275 to these functions and get the same results as we would
1276 have got earlier on. Meanwhile, GPT_ADDR does point to
1277 the text that has been stored by copy_text. */
1278 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1279 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1283 record_insert (PT
, nchars
);
1286 GAP_SIZE
-= outgoing_nbytes
;
1290 GPT_BYTE
+= outgoing_nbytes
;
1291 ZV_BYTE
+= outgoing_nbytes
;
1292 Z_BYTE
+= outgoing_nbytes
;
1293 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1298 adjust_overlays_for_insert (PT
, nchars
);
1299 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1300 PT_BYTE
+ outgoing_nbytes
,
1303 if (BUF_INTERVALS (current_buffer
) != 0)
1304 offset_intervals (current_buffer
, PT
, nchars
);
1306 /* Get the intervals for the part of the string we are inserting. */
1307 intervals
= BUF_INTERVALS (buf
);
1308 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1310 if (buf
== current_buffer
&& PT
<= from
)
1312 intervals
= copy_intervals (intervals
, from
, nchars
);
1315 /* Insert those intervals. */
1316 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1318 adjust_point (nchars
, outgoing_nbytes
);
1321 /* Record undo information and adjust markers and position keepers for
1322 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1323 chars (LEN_BYTE bytes) which resides in the gap just after
1326 PREV_TEXT nil means the new text was just inserted. */
1329 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1330 int from
, from_byte
, len
, len_byte
;
1331 Lisp_Object prev_text
;
1333 int nchars_del
= 0, nbytes_del
= 0;
1335 #ifdef BYTE_COMBINING_DEBUG
1336 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1337 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1341 if (STRINGP (prev_text
))
1343 nchars_del
= XSTRING (prev_text
)->size
;
1344 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1347 /* Update various buffer positions for the new text. */
1348 GAP_SIZE
-= len_byte
;
1350 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1351 GPT
+= len
; GPT_BYTE
+= len_byte
;
1352 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1355 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1358 adjust_markers_for_insert (from
, from_byte
,
1359 from
+ len
, from_byte
+ len_byte
, 0);
1361 if (! EQ (current_buffer
->undo_list
, Qt
))
1364 record_delete (from
, prev_text
);
1365 record_insert (from
, len
);
1368 if (len
> nchars_del
)
1369 adjust_overlays_for_insert (from
, len
- nchars_del
);
1370 else if (len
< nchars_del
)
1371 adjust_overlays_for_delete (from
, nchars_del
- len
);
1372 if (BUF_INTERVALS (current_buffer
) != 0)
1374 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1378 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1380 /* As byte combining will decrease Z, we must check this again. */
1381 if (Z
- GPT
< END_UNCHANGED
)
1382 END_UNCHANGED
= Z
- GPT
;
1387 evaporate_overlays (from
);
1391 /* Record undo information, adjust markers and position keepers for an
1392 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1393 text already exists in the current buffer but character length (TO
1394 - FROM) may be incorrect, the correct length is NEWLEN. */
1397 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1398 int from
, from_byte
, to
, to_byte
, newlen
;
1400 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1403 move_gap_both (to
, to_byte
);
1404 GAP_SIZE
+= len_byte
;
1405 GPT
-= len
; GPT_BYTE
-= len_byte
;
1406 ZV
-= len
; ZV_BYTE
-= len_byte
;
1407 Z
-= len
; Z_BYTE
-= len_byte
;
1408 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1411 /* Replace the text from character positions FROM to TO with NEW,
1412 If PREPARE is nonzero, call prepare_to_modify_buffer.
1413 If INHERIT, the newly inserted text should inherit text properties
1414 from the surrounding non-deleted text. */
1416 /* Note that this does not yet handle markers quite right.
1417 Also it needs to record a single undo-entry that does a replacement
1418 rather than a separate delete and insert.
1419 That way, undo will also handle markers properly.
1421 But if MARKERS is 0, don't relocate markers. */
1424 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1426 int from
, to
, prepare
, inherit
, markers
;
1428 int inschars
= XSTRING (new)->size
;
1429 int insbytes
= STRING_BYTES (XSTRING (new));
1430 int from_byte
, to_byte
;
1431 int nbytes_del
, nchars_del
;
1432 register Lisp_Object temp
;
1433 struct gcpro gcpro1
;
1435 int outgoing_insbytes
= insbytes
;
1436 Lisp_Object deletion
;
1445 int range_length
= to
- from
;
1446 prepare_to_modify_buffer (from
, to
, &from
);
1447 to
= from
+ range_length
;
1452 /* Make args be valid */
1458 from_byte
= CHAR_TO_BYTE (from
);
1459 to_byte
= CHAR_TO_BYTE (to
);
1461 nchars_del
= to
- from
;
1462 nbytes_del
= to_byte
- from_byte
;
1464 if (nbytes_del
<= 0 && insbytes
== 0)
1467 /* Make OUTGOING_INSBYTES describe the text
1468 as it will be inserted in this buffer. */
1470 if (NILP (current_buffer
->enable_multibyte_characters
))
1471 outgoing_insbytes
= inschars
;
1472 else if (! STRING_MULTIBYTE (new))
1474 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1476 /* Make sure point-max won't overflow after this insertion. */
1477 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1478 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1479 error ("Maximum buffer size exceeded");
1483 /* Make sure the gap is somewhere in or next to what we are deleting. */
1485 gap_right (from
, from_byte
);
1487 gap_left (to
, to_byte
, 0);
1489 /* Even if we don't record for undo, we must keep the original text
1490 because we may have to recover it because of inappropriate byte
1492 if (! EQ (current_buffer
->undo_list
, Qt
))
1493 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1495 GAP_SIZE
+= nbytes_del
;
1498 ZV_BYTE
-= nbytes_del
;
1499 Z_BYTE
-= nbytes_del
;
1501 GPT_BYTE
= from_byte
;
1502 *(GPT_ADDR
) = 0; /* Put an anchor. */
1507 if (GPT
- BEG
< BEG_UNCHANGED
)
1508 BEG_UNCHANGED
= GPT
- BEG
;
1509 if (Z
- GPT
< END_UNCHANGED
)
1510 END_UNCHANGED
= Z
- GPT
;
1512 if (GAP_SIZE
< insbytes
)
1513 make_gap (insbytes
- GAP_SIZE
);
1515 /* Copy the string text into the buffer, perhaps converting
1516 between single-byte and multibyte. */
1517 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1518 STRING_MULTIBYTE (new),
1519 ! NILP (current_buffer
->enable_multibyte_characters
));
1521 #ifdef BYTE_COMBINING_DEBUG
1522 /* We have copied text into the gap, but we have not marked
1523 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1524 here, for both the previous text and the following text.
1525 Meanwhile, GPT_ADDR does point to
1526 the text that has been stored by copy_text. */
1527 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1528 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1532 if (! EQ (current_buffer
->undo_list
, Qt
))
1534 record_delete (from
, deletion
);
1535 record_insert (from
, inschars
);
1538 GAP_SIZE
-= outgoing_insbytes
;
1542 GPT_BYTE
+= outgoing_insbytes
;
1543 ZV_BYTE
+= outgoing_insbytes
;
1544 Z_BYTE
+= outgoing_insbytes
;
1545 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1550 /* Adjust the overlay center as needed. This must be done after
1551 adjusting the markers that bound the overlays. */
1552 adjust_overlays_for_delete (from
, nchars_del
);
1553 adjust_overlays_for_insert (from
, inschars
);
1555 /* Adjust markers for the deletion and the insertion. */
1557 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1558 inschars
, outgoing_insbytes
);
1560 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1562 /* Get the intervals for the part of the string we are inserting--
1563 not including the combined-before bytes. */
1564 intervals
= XSTRING (new)->intervals
;
1565 /* Insert those intervals. */
1566 graft_intervals_into_buffer (intervals
, from
, inschars
,
1567 current_buffer
, inherit
);
1569 /* Relocate point as if it were a marker. */
1571 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1572 (from_byte
+ outgoing_insbytes
1573 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1575 if (outgoing_insbytes
== 0)
1576 evaporate_overlays (from
);
1583 signal_after_change (from
, nchars_del
, GPT
- from
);
1584 update_compositions (from
, GPT
, CHECK_BORDER
);
1587 /* Delete characters in current buffer
1588 from FROM up to (but not including) TO.
1589 If TO comes before FROM, we delete nothing. */
1592 del_range (from
, to
)
1593 register int from
, to
;
1595 del_range_1 (from
, to
, 1, 0);
1598 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1599 RET_STRING says to return the deleted text. */
1602 del_range_1 (from
, to
, prepare
, ret_string
)
1603 int from
, to
, prepare
, ret_string
;
1605 int from_byte
, to_byte
;
1606 Lisp_Object deletion
;
1607 struct gcpro gcpro1
;
1609 /* Make args be valid */
1620 int range_length
= to
- from
;
1621 prepare_to_modify_buffer (from
, to
, &from
);
1622 to
= min (ZV
, from
+ range_length
);
1625 from_byte
= CHAR_TO_BYTE (from
);
1626 to_byte
= CHAR_TO_BYTE (to
);
1628 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1630 signal_after_change (from
, to
- from
, 0);
1631 update_compositions (from
, from
, CHECK_HEAD
);
1636 /* Like del_range_1 but args are byte positions, not char positions. */
1639 del_range_byte (from_byte
, to_byte
, prepare
)
1640 int from_byte
, to_byte
, prepare
;
1644 /* Make args be valid */
1645 if (from_byte
< BEGV_BYTE
)
1646 from_byte
= BEGV_BYTE
;
1647 if (to_byte
> ZV_BYTE
)
1650 if (to_byte
<= from_byte
)
1653 from
= BYTE_TO_CHAR (from_byte
);
1654 to
= BYTE_TO_CHAR (to_byte
);
1658 int old_from
= from
, old_to
= Z
- to
;
1659 int range_length
= to
- from
;
1660 prepare_to_modify_buffer (from
, to
, &from
);
1661 to
= from
+ range_length
;
1663 if (old_from
!= from
)
1664 from_byte
= CHAR_TO_BYTE (from
);
1670 else if (old_to
== Z
- to
)
1671 to_byte
= CHAR_TO_BYTE (to
);
1674 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1675 signal_after_change (from
, to
- from
, 0);
1676 update_compositions (from
, from
, CHECK_HEAD
);
1679 /* Like del_range_1, but positions are specified both as charpos
1683 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1684 int from
, from_byte
, to
, to_byte
, prepare
;
1686 /* Make args be valid */
1687 if (from_byte
< BEGV_BYTE
)
1688 from_byte
= BEGV_BYTE
;
1689 if (to_byte
> ZV_BYTE
)
1692 if (to_byte
<= from_byte
)
1702 int old_from
= from
, old_to
= Z
- to
;
1703 int range_length
= to
- from
;
1704 prepare_to_modify_buffer (from
, to
, &from
);
1705 to
= from
+ range_length
;
1707 if (old_from
!= from
)
1708 from_byte
= CHAR_TO_BYTE (from
);
1714 else if (old_to
== Z
- to
)
1715 to_byte
= CHAR_TO_BYTE (to
);
1718 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1719 signal_after_change (from
, to
- from
, 0);
1720 update_compositions (from
, from
, CHECK_HEAD
);
1723 /* Delete a range of text, specified both as character positions
1724 and byte positions. FROM and TO are character positions,
1725 while FROM_BYTE and TO_BYTE are byte positions.
1726 If RET_STRING is true, the deleted area is returned as a string. */
1729 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1730 int from
, from_byte
, to
, to_byte
, ret_string
;
1732 register int nbytes_del
, nchars_del
;
1733 Lisp_Object deletion
;
1737 nchars_del
= to
- from
;
1738 nbytes_del
= to_byte
- from_byte
;
1740 /* Make sure the gap is somewhere in or next to what we are deleting. */
1742 gap_right (from
, from_byte
);
1744 gap_left (to
, to_byte
, 0);
1746 #ifdef BYTE_COMBINING_DEBUG
1747 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1748 Z_BYTE
- to_byte
, from
, from_byte
))
1752 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1753 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1757 /* Relocate all markers pointing into the new, larger gap
1758 to point at the end of the text before the gap.
1759 Do this before recording the deletion,
1760 so that undo handles this after reinserting the text. */
1761 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1763 if (! EQ (current_buffer
->undo_list
, Qt
))
1764 record_delete (from
, deletion
);
1767 /* Relocate point as if it were a marker. */
1769 adjust_point (from
- (PT
< to
? PT
: to
),
1770 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1772 offset_intervals (current_buffer
, from
, - nchars_del
);
1774 /* Adjust the overlay center as needed. This must be done after
1775 adjusting the markers that bound the overlays. */
1776 adjust_overlays_for_delete (from
, nchars_del
);
1778 GAP_SIZE
+= nbytes_del
;
1779 ZV_BYTE
-= nbytes_del
;
1780 Z_BYTE
-= nbytes_del
;
1784 GPT_BYTE
= from_byte
;
1785 *(GPT_ADDR
) = 0; /* Put an anchor. */
1790 if (GPT
- BEG
< BEG_UNCHANGED
)
1791 BEG_UNCHANGED
= GPT
- BEG
;
1792 if (Z
- GPT
< END_UNCHANGED
)
1793 END_UNCHANGED
= Z
- GPT
;
1797 evaporate_overlays (from
);
1802 /* Call this if you're about to change the region of BUFFER from
1803 character positions START to END. This checks the read-only
1804 properties of the region, calls the necessary modification hooks,
1805 and warns the next redisplay that it should pay attention to that
1809 modify_region (buffer
, start
, end
)
1810 struct buffer
*buffer
;
1813 struct buffer
*old_buffer
= current_buffer
;
1815 if (buffer
!= old_buffer
)
1816 set_buffer_internal (buffer
);
1818 prepare_to_modify_buffer (start
, end
, NULL
);
1820 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1822 if (MODIFF
<= SAVE_MODIFF
)
1823 record_first_change ();
1826 buffer
->point_before_scroll
= Qnil
;
1828 if (buffer
!= old_buffer
)
1829 set_buffer_internal (old_buffer
);
1832 /* Check that it is okay to modify the buffer between START and END,
1833 which are char positions.
1835 Run the before-change-function, if any. If intervals are in use,
1836 verify that the text to be modified is not read-only, and call
1837 any modification properties the text may have.
1839 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1840 by holding its value temporarily in a marker. */
1843 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1847 if (!NILP (current_buffer
->read_only
))
1848 Fbarf_if_buffer_read_only ();
1850 /* Let redisplay consider other windows than selected_window
1851 if modifying another buffer. */
1852 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1853 ++windows_or_buffers_changed
;
1855 if (BUF_INTERVALS (current_buffer
) != 0)
1859 Lisp_Object preserve_marker
;
1860 struct gcpro gcpro1
;
1861 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1862 GCPRO1 (preserve_marker
);
1863 verify_interval_modification (current_buffer
, start
, end
);
1864 *preserve_ptr
= marker_position (preserve_marker
);
1865 unchain_marker (preserve_marker
);
1869 verify_interval_modification (current_buffer
, start
, end
);
1872 #ifdef CLASH_DETECTION
1873 if (!NILP (current_buffer
->file_truename
)
1874 /* Make binding buffer-file-name to nil effective. */
1875 && !NILP (current_buffer
->filename
)
1876 && SAVE_MODIFF
>= MODIFF
)
1877 lock_file (current_buffer
->file_truename
);
1879 /* At least warn if this file has changed on disk since it was visited. */
1880 if (!NILP (current_buffer
->filename
)
1881 && SAVE_MODIFF
>= MODIFF
1882 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1883 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1884 call1 (intern ("ask-user-about-supersession-threat"),
1885 current_buffer
->filename
);
1886 #endif /* not CLASH_DETECTION */
1888 signal_before_change (start
, end
, preserve_ptr
);
1890 if (current_buffer
->newline_cache
)
1891 invalidate_region_cache (current_buffer
,
1892 current_buffer
->newline_cache
,
1893 start
- BEG
, Z
- end
);
1894 if (current_buffer
->width_run_cache
)
1895 invalidate_region_cache (current_buffer
,
1896 current_buffer
->width_run_cache
,
1897 start
- BEG
, Z
- end
);
1899 Vdeactivate_mark
= Qt
;
1902 /* These macros work with an argument named `preserve_ptr'
1903 and a local variable named `preserve_marker'. */
1905 #define PRESERVE_VALUE \
1906 if (preserve_ptr && NILP (preserve_marker)) \
1907 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1909 #define RESTORE_VALUE \
1910 if (! NILP (preserve_marker)) \
1912 *preserve_ptr = marker_position (preserve_marker); \
1913 unchain_marker (preserve_marker); \
1916 #define PRESERVE_START_END \
1917 if (NILP (start_marker)) \
1918 start_marker = Fcopy_marker (start, Qnil); \
1919 if (NILP (end_marker)) \
1920 end_marker = Fcopy_marker (end, Qnil);
1922 #define FETCH_START \
1923 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1926 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1928 /* Signal a change to the buffer immediately before it happens.
1929 START_INT and END_INT are the bounds of the text to be changed.
1931 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1932 by holding its value temporarily in a marker. */
1935 signal_before_change (start_int
, end_int
, preserve_ptr
)
1936 int start_int
, end_int
;
1939 Lisp_Object start
, end
;
1940 Lisp_Object start_marker
, end_marker
;
1941 Lisp_Object preserve_marker
;
1942 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1944 if (inhibit_modification_hooks
)
1947 start
= make_number (start_int
);
1948 end
= make_number (end_int
);
1949 preserve_marker
= Qnil
;
1950 start_marker
= Qnil
;
1952 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1954 /* If buffer is unmodified, run a special hook for that case. */
1955 if (SAVE_MODIFF
>= MODIFF
1956 && !NILP (Vfirst_change_hook
)
1957 && !NILP (Vrun_hooks
))
1961 call1 (Vrun_hooks
, Qfirst_change_hook
);
1964 /* Now run the before-change-functions if any. */
1965 if (!NILP (Vbefore_change_functions
))
1967 Lisp_Object args
[3];
1968 Lisp_Object before_change_functions
;
1969 Lisp_Object after_change_functions
;
1970 struct gcpro gcpro1
, gcpro2
;
1971 struct buffer
*old
= current_buffer
;
1977 /* "Bind" before-change-functions and after-change-functions
1978 to nil--but in a way that errors don't know about.
1979 That way, if there's an error in them, they will stay nil. */
1980 before_change_functions
= Vbefore_change_functions
;
1981 after_change_functions
= Vafter_change_functions
;
1982 Vbefore_change_functions
= Qnil
;
1983 Vafter_change_functions
= Qnil
;
1984 GCPRO2 (before_change_functions
, after_change_functions
);
1986 /* Actually run the hook functions. */
1987 args
[0] = Qbefore_change_functions
;
1988 args
[1] = FETCH_START
;
1989 args
[2] = FETCH_END
;
1990 run_hook_list_with_args (before_change_functions
, 3, args
);
1992 /* "Unbind" the variables we "bound" to nil. Beware a
1993 buffer-local hook which changes the buffer when run (e.g. W3). */
1994 if (old
!= current_buffer
)
1996 new = current_buffer
;
1997 set_buffer_internal (old
);
1998 Vbefore_change_functions
= before_change_functions
;
1999 Vafter_change_functions
= after_change_functions
;
2000 set_buffer_internal (new);
2004 Vbefore_change_functions
= before_change_functions
;
2005 Vafter_change_functions
= after_change_functions
;
2010 if (!NILP (current_buffer
->overlays_before
)
2011 || !NILP (current_buffer
->overlays_after
))
2014 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2015 FETCH_START
, FETCH_END
, Qnil
);
2018 if (! NILP (start_marker
))
2019 free_marker (start_marker
);
2020 if (! NILP (end_marker
))
2021 free_marker (end_marker
);
2026 /* Signal a change immediately after it happens.
2027 CHARPOS is the character position of the start of the changed text.
2028 LENDEL is the number of characters of the text before the change.
2029 (Not the whole buffer; just the part that was changed.)
2030 LENINS is the number of characters in that part of the text
2031 after the change. */
2034 signal_after_change (charpos
, lendel
, lenins
)
2035 int charpos
, lendel
, lenins
;
2037 if (inhibit_modification_hooks
)
2040 /* If we are deferring calls to the after-change functions
2041 and there are no before-change functions,
2042 just record the args that we were going to use. */
2043 if (! NILP (Vcombine_after_change_calls
)
2044 && NILP (Vbefore_change_functions
)
2045 && NILP (current_buffer
->overlays_before
)
2046 && NILP (current_buffer
->overlays_after
))
2050 if (!NILP (combine_after_change_list
)
2051 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2052 Fcombine_after_change_execute ();
2054 elt
= Fcons (make_number (charpos
- BEG
),
2055 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2056 Fcons (make_number (lenins
- lendel
), Qnil
)));
2057 combine_after_change_list
2058 = Fcons (elt
, combine_after_change_list
);
2059 combine_after_change_buffer
= Fcurrent_buffer ();
2064 if (!NILP (combine_after_change_list
))
2065 Fcombine_after_change_execute ();
2067 if (!NILP (Vafter_change_functions
))
2069 Lisp_Object args
[4];
2070 Lisp_Object before_change_functions
;
2071 Lisp_Object after_change_functions
;
2072 struct buffer
*old
= current_buffer
;
2074 struct gcpro gcpro1
, gcpro2
;
2076 /* "Bind" before-change-functions and after-change-functions
2077 to nil--but in a way that errors don't know about.
2078 That way, if there's an error in them, they will stay nil. */
2079 before_change_functions
= Vbefore_change_functions
;
2080 after_change_functions
= Vafter_change_functions
;
2081 Vbefore_change_functions
= Qnil
;
2082 Vafter_change_functions
= Qnil
;
2083 GCPRO2 (before_change_functions
, after_change_functions
);
2085 /* Actually run the hook functions. */
2086 args
[0] = Qafter_change_functions
;
2087 XSETFASTINT (args
[1], charpos
);
2088 XSETFASTINT (args
[2], charpos
+ lenins
);
2089 XSETFASTINT (args
[3], lendel
);
2090 run_hook_list_with_args (after_change_functions
,
2093 /* "Unbind" the variables we "bound" to nil. Beware a
2094 buffer-local hook which changes the buffer when run (e.g. W3). */
2095 if (old
!= current_buffer
)
2097 new = current_buffer
;
2098 set_buffer_internal (old
);
2099 Vbefore_change_functions
= before_change_functions
;
2100 Vafter_change_functions
= after_change_functions
;
2101 set_buffer_internal (new);
2105 Vbefore_change_functions
= before_change_functions
;
2106 Vafter_change_functions
= after_change_functions
;
2111 if (!NILP (current_buffer
->overlays_before
)
2112 || !NILP (current_buffer
->overlays_after
))
2113 report_overlay_modification (make_number (charpos
),
2114 make_number (charpos
+ lenins
),
2116 make_number (charpos
),
2117 make_number (charpos
+ lenins
),
2118 make_number (lendel
));
2120 /* After an insertion, call the text properties
2121 insert-behind-hooks or insert-in-front-hooks. */
2123 report_interval_modification (make_number (charpos
),
2124 make_number (charpos
+ lenins
));
2128 Fcombine_after_change_execute_1 (val
)
2131 Vcombine_after_change_calls
= val
;
2135 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2136 Scombine_after_change_execute
, 0, 0, 0,
2137 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2140 int count
= specpdl_ptr
- specpdl
;
2141 int beg
, end
, change
;
2145 if (NILP (combine_after_change_list
))
2148 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2150 Fset_buffer (combine_after_change_buffer
);
2152 /* # chars unchanged at beginning of buffer. */
2154 /* # chars unchanged at end of buffer. */
2156 /* Total amount of insertion (negative for deletion). */
2159 /* Scan the various individual changes,
2160 accumulating the range info in BEG, END and CHANGE. */
2161 for (tail
= combine_after_change_list
; CONSP (tail
);
2165 int thisbeg
, thisend
, thischange
;
2167 /* Extract the info from the next element. */
2171 thisbeg
= XINT (XCAR (elt
));
2176 thisend
= XINT (XCAR (elt
));
2181 thischange
= XINT (XCAR (elt
));
2183 /* Merge this range into the accumulated range. */
2184 change
+= thischange
;
2191 /* Get the current start and end positions of the range
2192 that was changed. */
2196 /* We are about to handle these, so discard them. */
2197 combine_after_change_list
= Qnil
;
2199 /* Now run the after-change functions for real.
2200 Turn off the flag that defers them. */
2201 record_unwind_protect (Fcombine_after_change_execute_1
,
2202 Vcombine_after_change_calls
);
2203 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2204 update_compositions (begpos
, endpos
, CHECK_ALL
);
2206 return unbind_to (count
, Qnil
);
2212 staticpro (&combine_after_change_list
);
2213 combine_after_change_list
= Qnil
;
2214 combine_after_change_buffer
= Qnil
;
2216 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2217 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2218 check_markers_debug_flag
= 0;
2219 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2220 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2221 Vcombine_after_change_calls
= Qnil
;
2223 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2224 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2225 This affects `before-change-functions' and `after-change-functions',
2226 as well as hooks attached to text properties and overlays. */);
2227 inhibit_modification_hooks
= 0;
2228 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2229 staticpro (&Qinhibit_modification_hooks
);
2231 defsubr (&Scombine_after_change_execute
);