1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000, 01, 2003
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "intervals.h"
29 #include "blockinput.h"
30 #include "region-cache.h"
36 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
37 static void insert_from_buffer_1 ();
38 static void gap_left
P_ ((int, int, int));
39 static void gap_right
P_ ((int, int));
40 static void adjust_markers_gap_motion
P_ ((int, int, int));
41 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
42 void adjust_markers_for_delete
P_ ((int, int, int, int));
43 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
44 static void adjust_point
P_ ((int, int));
46 Lisp_Object
Fcombine_after_change_execute ();
48 /* Non-nil means don't call the after-change-functions right away,
49 just record an element in Vcombine_after_change_calls_list. */
50 Lisp_Object Vcombine_after_change_calls
;
52 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
53 describing changes which happened while combine_after_change_calls
54 was nonzero. We use this to decide how to call them
55 once the deferral ends.
58 BEG-UNCHANGED is the number of chars before the changed range.
59 END-UNCHANGED is the number of chars after the changed range,
60 and CHANGE-AMOUNT is the number of characters inserted by the change
61 (negative for a deletion). */
62 Lisp_Object combine_after_change_list
;
64 /* Buffer which combine_after_change_list is about. */
65 Lisp_Object combine_after_change_buffer
;
67 Lisp_Object Qinhibit_modification_hooks
;
70 /* Check all markers in the current buffer, looking for something invalid. */
72 static int check_markers_debug_flag
;
74 #define CHECK_MARKERS() \
75 if (check_markers_debug_flag) \
82 register struct Lisp_Marker
*tail
;
83 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
85 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
87 if (tail
->buffer
->text
!= current_buffer
->text
)
89 if (tail
->charpos
> Z
)
91 if (tail
->bytepos
> Z_BYTE
)
93 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (tail
->bytepos
)))
98 /* Move gap to position CHARPOS.
99 Note that this can quit! */
105 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
108 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
109 Note that this can quit! */
112 move_gap_both (charpos
, bytepos
)
113 int charpos
, bytepos
;
115 if (bytepos
< GPT_BYTE
)
116 gap_left (charpos
, bytepos
, 0);
117 else if (bytepos
> GPT_BYTE
)
118 gap_right (charpos
, bytepos
);
121 /* Move the gap to a position less than the current GPT.
122 BYTEPOS describes the new position as a byte position,
123 and CHARPOS is the corresponding char position.
124 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
127 gap_left (charpos
, bytepos
, newgap
)
128 register int charpos
, bytepos
;
131 register unsigned char *to
, *from
;
136 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
143 /* Now copy the characters. To move the gap down,
144 copy characters up. */
148 /* I gets number of characters left to copy. */
149 i
= new_s1
- bytepos
;
152 /* If a quit is requested, stop copying now.
153 Change BYTEPOS to be where we have actually moved the gap to. */
157 charpos
= BYTE_TO_CHAR (bytepos
);
160 /* Move at most 32000 chars before checking again for a quit. */
165 /* bcopy is safe if the two areas of memory do not overlap
166 or on systems where bcopy is always safe for moving upward. */
167 && (BCOPY_UPWARD_SAFE
168 || to
- from
>= 128))
170 /* If overlap is not safe, avoid it by not moving too many
171 characters at once. */
172 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
187 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
188 BYTEPOS is where the loop above stopped, which may be what was specified
189 or may be where a quit was detected. */
190 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
193 if (bytepos
< charpos
)
195 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
199 /* Move the gap to a position greater than than the current GPT.
200 BYTEPOS describes the new position as a byte position,
201 and CHARPOS is the corresponding char position. */
204 gap_right (charpos
, bytepos
)
205 register int charpos
, bytepos
;
207 register unsigned char *to
, *from
;
211 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
218 /* Now copy the characters. To move the gap up,
219 copy characters down. */
223 /* I gets number of characters left to copy. */
224 i
= bytepos
- new_s1
;
227 /* If a quit is requested, stop copying now.
228 Change BYTEPOS to be where we have actually moved the gap to. */
232 charpos
= BYTE_TO_CHAR (bytepos
);
235 /* Move at most 32000 chars before checking again for a quit. */
240 /* bcopy is safe if the two areas of memory do not overlap
241 or on systems where bcopy is always safe for moving downward. */
242 && (BCOPY_DOWNWARD_SAFE
243 || from
- to
>= 128))
245 /* If overlap is not safe, avoid it by not moving too many
246 characters at once. */
247 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
262 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
266 if (bytepos
< charpos
)
268 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
272 /* Add AMOUNT to the byte position of every marker in the current buffer
273 whose current byte position is between FROM (exclusive) and TO (inclusive).
275 Also, any markers past the outside of that interval, in the direction
276 of adjustment, are first moved back to the near end of the interval
277 and then adjusted by AMOUNT.
279 When the latter adjustment is done, if AMOUNT is negative,
280 we record the adjustment for undo. (This case happens only for
283 The markers' character positions are not altered,
284 because gap motion does not affect character positions. */
286 int adjust_markers_test
;
289 adjust_markers_gap_motion (from
, to
, amount
)
290 register int from
, to
, amount
;
292 /* Now that a marker has a bytepos, not counting the gap,
293 nothing needs to be done here. */
296 register struct Lisp_Marker
*m
;
299 marker
= BUF_MARKERS (current_buffer
);
301 while (!NILP (marker
))
303 m
= XMARKER (marker
);
307 if (mpos
> to
&& mpos
< to
+ amount
)
309 if (adjust_markers_test
)
316 /* Here's the case where a marker is inside text being deleted.
317 AMOUNT can be negative for gap motion, too,
318 but then this range contains no markers. */
319 if (mpos
> from
+ amount
&& mpos
<= from
)
321 if (adjust_markers_test
)
323 mpos
= from
+ amount
;
326 if (mpos
> from
&& mpos
<= to
)
334 /* Adjust all markers for a deletion
335 whose range in bytes is FROM_BYTE to TO_BYTE.
336 The range in charpos is FROM to TO.
338 This function assumes that the gap is adjacent to
339 or inside of the range being deleted. */
342 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
343 register int from
, from_byte
, to
, to_byte
;
346 register struct Lisp_Marker
*m
;
347 register int charpos
;
349 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
351 charpos
= m
->charpos
;
356 /* If the marker is after the deletion,
357 relocate by number of chars / bytes deleted. */
360 m
->charpos
-= to
- from
;
361 m
->bytepos
-= to_byte
- from_byte
;
363 /* Here's the case where a marker is inside text being deleted. */
364 else if (charpos
> from
)
366 if (! m
->insertion_type
)
367 { /* Normal markers will end up at the beginning of the
368 re-inserted text after undoing a deletion, and must be
369 adjusted to move them to the correct place. */
370 XSETMISC (marker
, m
);
371 record_marker_adjustment (marker
, from
- charpos
);
373 else if (charpos
< to
)
374 { /* Before-insertion markers will automatically move forward
375 upon re-inserting the deleted text, so we have to arrange
376 for them to move backward to the correct position. */
377 XSETMISC (marker
, m
);
378 record_marker_adjustment (marker
, charpos
- to
);
381 m
->bytepos
= from_byte
;
383 /* Here's the case where a before-insertion marker is immediately
384 before the deleted region. */
385 else if (charpos
== from
&& m
->insertion_type
)
387 /* Undoing the change uses normal insertion, which will
388 incorrectly make MARKER move forward, so we arrange for it
389 to then move backward to the correct place at the beginning
390 of the deleted region. */
391 XSETMISC (marker
, m
);
392 record_marker_adjustment (marker
, to
- from
);
398 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
399 to TO / TO_BYTE. We have to relocate the charpos of every marker
400 that points after the insertion (but not their bytepos).
402 When a marker points at the insertion point,
403 we advance it if either its insertion-type is t
404 or BEFORE_MARKERS is true. */
407 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
408 register int from
, from_byte
, to
, to_byte
;
411 struct Lisp_Marker
*m
;
413 int nchars
= to
- from
;
414 int nbytes
= to_byte
- from_byte
;
416 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
418 /* In a single-byte buffer, a marker's two positions must be
422 if (m
->charpos
!= m
->bytepos
)
426 if (m
->bytepos
== from_byte
)
428 if (m
->insertion_type
|| before_markers
)
430 m
->bytepos
= to_byte
;
432 if (m
->insertion_type
)
436 else if (m
->bytepos
> from_byte
)
438 m
->bytepos
+= nbytes
;
439 m
->charpos
+= nchars
;
443 /* Adjusting only markers whose insertion-type is t may result in
444 - disordered start and end in overlays, and
445 - disordered overlays in the slot `overlays_before' of current_buffer. */
448 fix_start_end_in_overlays(from
, to
);
449 fix_overlays_before (current_buffer
, from
, to
);
453 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
455 This is used only when the value of point changes due to an insert
456 or delete; it does not represent a conceptual change in point as a
457 marker. In particular, point is not crossing any interval
458 boundaries, so there's no need to use the usual SET_PT macro. In
459 fact it would be incorrect to do so, because either the old or the
460 new value of point is out of sync with the current set of
464 adjust_point (nchars
, nbytes
)
467 BUF_PT (current_buffer
) += nchars
;
468 BUF_PT_BYTE (current_buffer
) += nbytes
;
470 /* In a single-byte buffer, the two positions must be equal. */
476 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
477 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
478 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
482 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
483 new_chars
, new_bytes
)
484 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
486 register struct Lisp_Marker
*m
;
487 int prev_to_byte
= from_byte
+ old_bytes
;
488 int diff_chars
= new_chars
- old_chars
;
489 int diff_bytes
= new_bytes
- old_bytes
;
491 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
493 if (m
->bytepos
>= prev_to_byte
)
495 m
->charpos
+= diff_chars
;
496 m
->bytepos
+= diff_bytes
;
498 else if (m
->bytepos
> from_byte
)
501 m
->bytepos
= from_byte
;
509 /* Make the gap NBYTES_ADDED bytes longer. */
512 make_gap_larger (nbytes_added
)
517 int real_gap_loc_byte
;
520 /* If we have to get more space, get enough to last a while. */
521 nbytes_added
+= 2000;
523 /* Don't allow a buffer size that won't fit in an int
524 even if it will fit in a Lisp integer.
525 That won't work because so many places use `int'.
527 Make sure we don't introduce overflows in the calculation. */
529 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
530 >= (((EMACS_INT
) 1 << (min (VALBITS
, BITS_PER_INT
) - 1)) - 1
532 error ("Buffer exceeds maximum size");
534 enlarge_buffer_text (current_buffer
, nbytes_added
);
536 /* Prevent quitting in move_gap. */
541 real_gap_loc_byte
= GPT_BYTE
;
542 old_gap_size
= GAP_SIZE
;
544 /* Call the newly allocated space a gap at the end of the whole space. */
546 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
547 GAP_SIZE
= nbytes_added
;
549 /* Move the new gap down to be consecutive with the end of the old one.
550 This adjusts the markers properly too. */
551 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
553 /* Now combine the two into one large gap. */
554 GAP_SIZE
+= old_gap_size
;
556 GPT_BYTE
= real_gap_loc_byte
;
565 /* Make the gap NBYTES_REMOVED bytes shorter. */
568 make_gap_smaller (nbytes_removed
)
573 int real_gap_loc_byte
;
576 int real_beg_unchanged
;
579 /* Make sure the gap is at least 20 bytes. */
580 if (GAP_SIZE
- nbytes_removed
< 20)
581 nbytes_removed
= GAP_SIZE
- 20;
583 /* Prevent quitting in move_gap. */
588 real_gap_loc_byte
= GPT_BYTE
;
589 new_gap_size
= GAP_SIZE
- nbytes_removed
;
591 real_Z_byte
= Z_BYTE
;
592 real_beg_unchanged
= BEG_UNCHANGED
;
594 /* Pretend that the last unwanted part of the gap is the entire gap,
595 and that the first desired part of the gap is part of the buffer
597 bzero (GPT_ADDR
, new_gap_size
);
599 GPT_BYTE
+= new_gap_size
;
601 Z_BYTE
+= new_gap_size
;
602 GAP_SIZE
= nbytes_removed
;
604 /* Move the unwanted pretend gap to the end of the buffer. This
605 adjusts the markers properly too. */
606 gap_right (Z
, Z_BYTE
);
608 enlarge_buffer_text (current_buffer
, -nbytes_removed
);
610 /* Now restore the desired gap. */
611 GAP_SIZE
= new_gap_size
;
613 GPT_BYTE
= real_gap_loc_byte
;
615 Z_BYTE
= real_Z_byte
;
616 BEG_UNCHANGED
= real_beg_unchanged
;
625 make_gap (nbytes_added
)
628 if (nbytes_added
>= 0)
629 make_gap_larger (nbytes_added
);
630 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
632 make_gap_smaller (-nbytes_added
);
636 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
637 FROM_MULTIBYTE says whether the incoming text is multibyte.
638 TO_MULTIBYTE says whether to store the text as multibyte.
639 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
641 Return the number of bytes stored at TO_ADDR. */
644 copy_text (from_addr
, to_addr
, nbytes
,
645 from_multibyte
, to_multibyte
)
646 const unsigned char *from_addr
;
647 unsigned char *to_addr
;
649 int from_multibyte
, to_multibyte
;
651 if (from_multibyte
== to_multibyte
)
653 bcopy (from_addr
, to_addr
, nbytes
);
656 else if (from_multibyte
)
659 int bytes_left
= nbytes
;
660 Lisp_Object tbl
= Qnil
;
662 /* We set the variable tbl to the reverse table of
663 Vnonascii_translation_table in advance. */
664 if (CHAR_TABLE_P (Vnonascii_translation_table
))
666 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
668 if (!CHAR_TABLE_P (tbl
))
672 /* Convert multibyte to single byte. */
673 while (bytes_left
> 0)
676 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
677 if (!SINGLE_BYTE_CHAR_P (c
))
678 c
= multibyte_char_to_unibyte (c
, tbl
);
680 from_addr
+= thislen
;
681 bytes_left
-= thislen
;
688 unsigned char *initial_to_addr
= to_addr
;
690 /* Convert single-byte to multibyte. */
693 int c
= *from_addr
++;
697 c
= unibyte_char_to_multibyte (c
);
698 to_addr
+= CHAR_STRING (c
, to_addr
);
702 /* Special case for speed. */
703 *to_addr
++ = c
, nbytes
--;
705 return to_addr
- initial_to_addr
;
709 /* Return the number of bytes it would take
710 to convert some single-byte text to multibyte.
711 The single-byte text consists of NBYTES bytes at PTR. */
714 count_size_as_multibyte (ptr
, nbytes
)
715 const unsigned char *ptr
;
719 int outgoing_nbytes
= 0;
721 for (i
= 0; i
< nbytes
; i
++)
723 unsigned int c
= *ptr
++;
729 c
= unibyte_char_to_multibyte (c
);
730 outgoing_nbytes
+= CHAR_BYTES (c
);
734 return outgoing_nbytes
;
737 /* Insert a string of specified length before point.
738 This function judges multibyteness based on
739 enable_multibyte_characters in the current buffer;
740 it never converts between single-byte and multibyte.
742 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
743 prepare_to_modify_buffer could relocate the text. */
746 insert (string
, nbytes
)
747 register const unsigned char *string
;
753 insert_1 (string
, nbytes
, 0, 1, 0);
754 signal_after_change (opoint
, 0, PT
- opoint
);
755 update_compositions (opoint
, PT
, CHECK_BORDER
);
759 /* Likewise, but inherit text properties from neighboring characters. */
762 insert_and_inherit (string
, nbytes
)
763 register const unsigned char *string
;
769 insert_1 (string
, nbytes
, 1, 1, 0);
770 signal_after_change (opoint
, 0, PT
- opoint
);
771 update_compositions (opoint
, PT
, CHECK_BORDER
);
775 /* Insert the character C before point. Do not inherit text properties. */
781 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
784 if (! NILP (current_buffer
->enable_multibyte_characters
))
785 len
= CHAR_STRING (c
, str
);
795 /* Insert the null-terminated string S before point. */
801 insert (s
, strlen (s
));
804 /* Like `insert' except that all markers pointing at the place where
805 the insertion happens are adjusted to point after it.
806 Don't use this function to insert part of a Lisp string,
807 since gc could happen and relocate it. */
810 insert_before_markers (string
, nbytes
)
811 const unsigned char *string
;
818 insert_1 (string
, nbytes
, 0, 1, 1);
819 signal_after_change (opoint
, 0, PT
- opoint
);
820 update_compositions (opoint
, PT
, CHECK_BORDER
);
824 /* Likewise, but inherit text properties from neighboring characters. */
827 insert_before_markers_and_inherit (string
, nbytes
)
828 const unsigned char *string
;
835 insert_1 (string
, nbytes
, 1, 1, 1);
836 signal_after_change (opoint
, 0, PT
- opoint
);
837 update_compositions (opoint
, PT
, CHECK_BORDER
);
841 /* Subroutine used by the insert functions above. */
844 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
845 register const unsigned char *string
;
847 int inherit
, prepare
, before_markers
;
849 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
850 inherit
, prepare
, before_markers
);
854 #ifdef BYTE_COMBINING_DEBUG
856 /* See if the bytes before POS/POS_BYTE combine with bytes
857 at the start of STRING to form a single character.
858 If so, return the number of bytes at the start of STRING
859 which combine in this way. Otherwise, return 0. */
862 count_combining_before (string
, length
, pos
, pos_byte
)
863 const unsigned char *string
;
867 int len
, combining_bytes
;
868 const unsigned char *p
;
870 if (NILP (current_buffer
->enable_multibyte_characters
))
873 /* At first, we can exclude the following cases:
874 (1) STRING[0] can't be a following byte of multibyte sequence.
875 (2) POS is the start of the current buffer.
876 (3) A character before POS is not a multibyte character. */
877 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
879 if (pos_byte
== BEG_BYTE
) /* case (2) */
882 p
= BYTE_POS_ADDR (pos_byte
- 1);
883 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
884 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
887 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
888 if (combining_bytes
<= 0)
889 /* The character preceding POS is, complete and no room for
890 combining bytes (combining_bytes == 0), or an independent 8-bit
891 character (combining_bytes < 0). */
894 /* We have a combination situation. Count the bytes at STRING that
897 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
900 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
903 /* See if the bytes after POS/POS_BYTE combine with bytes
904 at the end of STRING to form a single character.
905 If so, return the number of bytes after POS/POS_BYTE
906 which combine in this way. Otherwise, return 0. */
909 count_combining_after (string
, length
, pos
, pos_byte
)
910 const unsigned char *string
;
914 int opos_byte
= pos_byte
;
919 if (NILP (current_buffer
->enable_multibyte_characters
))
922 /* At first, we can exclude the following cases:
923 (1) The last byte of STRING is an ASCII.
924 (2) POS is the last of the current buffer.
925 (3) A character at POS can't be a following byte of multibyte
927 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
929 if (pos_byte
== Z_BYTE
) /* case (2) */
931 bufp
= BYTE_POS_ADDR (pos_byte
);
932 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
936 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
942 /* All characters in STRING are not character head. We must
943 check also preceding bytes at POS. We are sure that the gap
945 unsigned char *p
= BEG_ADDR
;
947 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
949 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
952 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
953 return (bytes
<= pos_byte
- 1 - i
+ length
955 : bytes
- (pos_byte
- 1 - i
+ length
));
957 if (!BASE_LEADING_CODE_P (string
[i
]))
960 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
962 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
964 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
970 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
971 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
972 are the same as in insert_1. */
975 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
976 register const unsigned char *string
;
977 register int nchars
, nbytes
;
978 int inherit
, prepare
, before_markers
;
983 if (NILP (current_buffer
->enable_multibyte_characters
))
987 /* Do this before moving and increasing the gap,
988 because the before-change hooks might move the gap
989 or make it smaller. */
990 prepare_to_modify_buffer (PT
, PT
, NULL
);
993 move_gap_both (PT
, PT_BYTE
);
994 if (GAP_SIZE
< nbytes
)
995 make_gap (nbytes
- GAP_SIZE
);
997 #ifdef BYTE_COMBINING_DEBUG
998 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
999 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
1003 /* Record deletion of the surrounding text that combines with
1004 the insertion. This, together with recording the insertion,
1005 will add up to the right stuff in the undo list. */
1006 record_insert (PT
, nchars
);
1009 bcopy (string
, GPT_ADDR
, nbytes
);
1018 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1023 /* The insert may have been in the unchanged region, so check again. */
1024 if (Z
- GPT
< END_UNCHANGED
)
1025 END_UNCHANGED
= Z
- GPT
;
1027 adjust_overlays_for_insert (PT
, nchars
);
1028 adjust_markers_for_insert (PT
, PT_BYTE
,
1029 PT
+ nchars
, PT_BYTE
+ nbytes
,
1032 if (BUF_INTERVALS (current_buffer
) != 0)
1033 offset_intervals (current_buffer
, PT
, nchars
);
1035 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1036 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1039 adjust_point (nchars
, nbytes
);
1044 /* Insert the part of the text of STRING, a Lisp object assumed to be
1045 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1046 starting at position POS / POS_BYTE. If the text of STRING has properties,
1047 copy them into the buffer.
1049 It does not work to use `insert' for this, because a GC could happen
1050 before we bcopy the stuff into the buffer, and relocate the string
1051 without insert noticing. */
1054 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1056 register int pos
, pos_byte
, length
, length_byte
;
1060 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1062 signal_after_change (opoint
, 0, PT
- opoint
);
1063 update_compositions (opoint
, PT
, CHECK_BORDER
);
1066 /* Like `insert_from_string' except that all markers pointing
1067 at the place where the insertion happens are adjusted to point after it. */
1070 insert_from_string_before_markers (string
, pos
, pos_byte
,
1071 length
, length_byte
, inherit
)
1073 register int pos
, pos_byte
, length
, length_byte
;
1077 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1079 signal_after_change (opoint
, 0, PT
- opoint
);
1080 update_compositions (opoint
, PT
, CHECK_BORDER
);
1083 /* Subroutine of the insertion functions above. */
1086 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1087 inherit
, before_markers
)
1089 register int pos
, pos_byte
, nchars
, nbytes
;
1090 int inherit
, before_markers
;
1092 struct gcpro gcpro1
;
1093 int outgoing_nbytes
= nbytes
;
1096 /* Make OUTGOING_NBYTES describe the text
1097 as it will be inserted in this buffer. */
1099 if (NILP (current_buffer
->enable_multibyte_characters
))
1100 outgoing_nbytes
= nchars
;
1101 else if (! STRING_MULTIBYTE (string
))
1103 = count_size_as_multibyte (SDATA (string
) + pos_byte
,
1107 /* Do this before moving and increasing the gap,
1108 because the before-change hooks might move the gap
1109 or make it smaller. */
1110 prepare_to_modify_buffer (PT
, PT
, NULL
);
1113 move_gap_both (PT
, PT_BYTE
);
1114 if (GAP_SIZE
< outgoing_nbytes
)
1115 make_gap (outgoing_nbytes
- GAP_SIZE
);
1118 /* Copy the string text into the buffer, perhaps converting
1119 between single-byte and multibyte. */
1120 copy_text (SDATA (string
) + pos_byte
, GPT_ADDR
, nbytes
,
1121 STRING_MULTIBYTE (string
),
1122 ! NILP (current_buffer
->enable_multibyte_characters
));
1124 #ifdef BYTE_COMBINING_DEBUG
1125 /* We have copied text into the gap, but we have not altered
1126 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1127 to these functions and get the same results as we would
1128 have got earlier on. Meanwhile, PT_ADDR does point to
1129 the text that has been stored by copy_text. */
1130 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1131 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1135 record_insert (PT
, nchars
);
1138 GAP_SIZE
-= outgoing_nbytes
;
1142 GPT_BYTE
+= outgoing_nbytes
;
1143 ZV_BYTE
+= outgoing_nbytes
;
1144 Z_BYTE
+= outgoing_nbytes
;
1145 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1150 /* The insert may have been in the unchanged region, so check again. */
1151 if (Z
- GPT
< END_UNCHANGED
)
1152 END_UNCHANGED
= Z
- GPT
;
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
= STRING_INTERVALS (string
);
1162 /* Get the intervals for the part of the string we are inserting. */
1163 if (nbytes
< SBYTES (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 /* The insert may have been in the unchanged region, so check again. */
1302 if (Z
- GPT
< END_UNCHANGED
)
1303 END_UNCHANGED
= Z
- GPT
;
1305 adjust_overlays_for_insert (PT
, nchars
);
1306 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1307 PT_BYTE
+ outgoing_nbytes
,
1310 if (BUF_INTERVALS (current_buffer
) != 0)
1311 offset_intervals (current_buffer
, PT
, nchars
);
1313 /* Get the intervals for the part of the string we are inserting. */
1314 intervals
= BUF_INTERVALS (buf
);
1315 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1317 if (buf
== current_buffer
&& PT
<= from
)
1319 intervals
= copy_intervals (intervals
, from
, nchars
);
1322 /* Insert those intervals. */
1323 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1325 adjust_point (nchars
, outgoing_nbytes
);
1328 /* Record undo information and adjust markers and position keepers for
1329 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1330 chars (LEN_BYTE bytes) which resides in the gap just after
1333 PREV_TEXT nil means the new text was just inserted. */
1336 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1337 int from
, from_byte
, len
, len_byte
;
1338 Lisp_Object prev_text
;
1340 int nchars_del
= 0, nbytes_del
= 0;
1342 #ifdef BYTE_COMBINING_DEBUG
1343 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1344 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1348 if (STRINGP (prev_text
))
1350 nchars_del
= SCHARS (prev_text
);
1351 nbytes_del
= SBYTES (prev_text
);
1354 /* Update various buffer positions for the new text. */
1355 GAP_SIZE
-= len_byte
;
1357 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1358 GPT
+= len
; GPT_BYTE
+= len_byte
;
1359 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1362 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1365 adjust_markers_for_insert (from
, from_byte
,
1366 from
+ len
, from_byte
+ len_byte
, 0);
1368 if (! EQ (current_buffer
->undo_list
, Qt
))
1371 record_delete (from
, prev_text
);
1372 record_insert (from
, len
);
1375 if (len
> nchars_del
)
1376 adjust_overlays_for_insert (from
, len
- nchars_del
);
1377 else if (len
< nchars_del
)
1378 adjust_overlays_for_delete (from
, nchars_del
- len
);
1379 if (BUF_INTERVALS (current_buffer
) != 0)
1381 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1385 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1387 /* As byte combining will decrease Z, we must check this again. */
1388 if (Z
- GPT
< END_UNCHANGED
)
1389 END_UNCHANGED
= Z
- GPT
;
1394 evaporate_overlays (from
);
1398 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1399 This is for use when undo is not enabled in the current buffer. */
1402 adjust_after_replace_noundo (from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
)
1403 int from
, from_byte
, nchars_del
, nbytes_del
, len
, len_byte
;
1405 #ifdef BYTE_COMBINING_DEBUG
1406 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1407 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1411 /* Update various buffer positions for the new text. */
1412 GAP_SIZE
-= len_byte
;
1414 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1415 GPT
+= len
; GPT_BYTE
+= len_byte
;
1416 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1419 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1422 adjust_markers_for_insert (from
, from_byte
,
1423 from
+ len
, from_byte
+ len_byte
, 0);
1425 if (len
> nchars_del
)
1426 adjust_overlays_for_insert (from
, len
- nchars_del
);
1427 else if (len
< nchars_del
)
1428 adjust_overlays_for_delete (from
, nchars_del
- len
);
1429 if (BUF_INTERVALS (current_buffer
) != 0)
1431 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1435 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1437 /* As byte combining will decrease Z, we must check this again. */
1438 if (Z
- GPT
< END_UNCHANGED
)
1439 END_UNCHANGED
= Z
- GPT
;
1444 evaporate_overlays (from
);
1448 /* Record undo information, adjust markers and position keepers for an
1449 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1450 text already exists in the current buffer but character length (TO
1451 - FROM) may be incorrect, the correct length is NEWLEN. */
1454 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1455 int from
, from_byte
, to
, to_byte
, newlen
;
1457 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1460 move_gap_both (to
, to_byte
);
1461 GAP_SIZE
+= len_byte
;
1462 GPT
-= len
; GPT_BYTE
-= len_byte
;
1463 ZV
-= len
; ZV_BYTE
-= len_byte
;
1464 Z
-= len
; Z_BYTE
-= len_byte
;
1465 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1468 /* Replace the text from character positions FROM to TO with NEW,
1469 If PREPARE is nonzero, call prepare_to_modify_buffer.
1470 If INHERIT, the newly inserted text should inherit text properties
1471 from the surrounding non-deleted text. */
1473 /* Note that this does not yet handle markers quite right.
1474 Also it needs to record a single undo-entry that does a replacement
1475 rather than a separate delete and insert.
1476 That way, undo will also handle markers properly.
1478 But if MARKERS is 0, don't relocate markers. */
1481 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1483 int from
, to
, prepare
, inherit
, markers
;
1485 int inschars
= SCHARS (new);
1486 int insbytes
= SBYTES (new);
1487 int from_byte
, to_byte
;
1488 int nbytes_del
, nchars_del
;
1489 register Lisp_Object temp
;
1490 struct gcpro gcpro1
;
1492 int outgoing_insbytes
= insbytes
;
1493 Lisp_Object deletion
;
1502 int range_length
= to
- from
;
1503 prepare_to_modify_buffer (from
, to
, &from
);
1504 to
= from
+ range_length
;
1509 /* Make args be valid */
1515 from_byte
= CHAR_TO_BYTE (from
);
1516 to_byte
= CHAR_TO_BYTE (to
);
1518 nchars_del
= to
- from
;
1519 nbytes_del
= to_byte
- from_byte
;
1521 if (nbytes_del
<= 0 && insbytes
== 0)
1524 /* Make OUTGOING_INSBYTES describe the text
1525 as it will be inserted in this buffer. */
1527 if (NILP (current_buffer
->enable_multibyte_characters
))
1528 outgoing_insbytes
= inschars
;
1529 else if (! STRING_MULTIBYTE (new))
1531 = count_size_as_multibyte (SDATA (new), insbytes
);
1533 /* Make sure point-max won't overflow after this insertion. */
1534 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1535 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1536 error ("Maximum buffer size exceeded");
1540 /* Make sure the gap is somewhere in or next to what we are deleting. */
1542 gap_right (from
, from_byte
);
1544 gap_left (to
, to_byte
, 0);
1546 /* Even if we don't record for undo, we must keep the original text
1547 because we may have to recover it because of inappropriate byte
1549 if (! EQ (current_buffer
->undo_list
, Qt
))
1550 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1552 GAP_SIZE
+= nbytes_del
;
1555 ZV_BYTE
-= nbytes_del
;
1556 Z_BYTE
-= nbytes_del
;
1558 GPT_BYTE
= from_byte
;
1559 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1564 if (GPT
- BEG
< BEG_UNCHANGED
)
1565 BEG_UNCHANGED
= GPT
- BEG
;
1566 if (Z
- GPT
< END_UNCHANGED
)
1567 END_UNCHANGED
= Z
- GPT
;
1569 if (GAP_SIZE
< insbytes
)
1570 make_gap (insbytes
- GAP_SIZE
);
1572 /* Copy the string text into the buffer, perhaps converting
1573 between single-byte and multibyte. */
1574 copy_text (SDATA (new), GPT_ADDR
, insbytes
,
1575 STRING_MULTIBYTE (new),
1576 ! NILP (current_buffer
->enable_multibyte_characters
));
1578 #ifdef BYTE_COMBINING_DEBUG
1579 /* We have copied text into the gap, but we have not marked
1580 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1581 here, for both the previous text and the following text.
1582 Meanwhile, GPT_ADDR does point to
1583 the text that has been stored by copy_text. */
1584 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1585 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1589 if (! EQ (current_buffer
->undo_list
, Qt
))
1591 record_delete (from
, deletion
);
1592 record_insert (from
, inschars
);
1595 GAP_SIZE
-= outgoing_insbytes
;
1599 GPT_BYTE
+= outgoing_insbytes
;
1600 ZV_BYTE
+= outgoing_insbytes
;
1601 Z_BYTE
+= outgoing_insbytes
;
1602 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1607 /* Adjust the overlay center as needed. This must be done after
1608 adjusting the markers that bound the overlays. */
1609 adjust_overlays_for_delete (from
, nchars_del
);
1610 adjust_overlays_for_insert (from
, inschars
);
1612 /* Adjust markers for the deletion and the insertion. */
1614 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1615 inschars
, outgoing_insbytes
);
1617 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1619 /* Get the intervals for the part of the string we are inserting--
1620 not including the combined-before bytes. */
1621 intervals
= STRING_INTERVALS (new);
1622 /* Insert those intervals. */
1623 graft_intervals_into_buffer (intervals
, from
, inschars
,
1624 current_buffer
, inherit
);
1626 /* Relocate point as if it were a marker. */
1628 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1629 (from_byte
+ outgoing_insbytes
1630 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1632 if (outgoing_insbytes
== 0)
1633 evaporate_overlays (from
);
1640 signal_after_change (from
, nchars_del
, GPT
- from
);
1641 update_compositions (from
, GPT
, CHECK_BORDER
);
1644 /* Replace the text from character positions FROM to TO with
1645 the text in INS of length INSCHARS.
1646 Keep the text properties that applied to the old characters
1647 (extending them to all the new chars if there are more new chars).
1649 Note that this does not yet handle markers quite right.
1651 If MARKERS is nonzero, relocate markers.
1653 Unlike most functions at this level, never call
1654 prepare_to_modify_buffer and never call signal_after_change. */
1657 replace_range_2 (from
, from_byte
, to
, to_byte
, ins
, inschars
, insbytes
, markers
)
1658 int from
, from_byte
, to
, to_byte
;
1660 int inschars
, insbytes
, markers
;
1662 int nbytes_del
, nchars_del
;
1667 nchars_del
= to
- from
;
1668 nbytes_del
= to_byte
- from_byte
;
1670 if (nbytes_del
<= 0 && insbytes
== 0)
1673 /* Make sure point-max won't overflow after this insertion. */
1674 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1675 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1676 error ("Maximum buffer size exceeded");
1678 /* Make sure the gap is somewhere in or next to what we are deleting. */
1680 gap_right (from
, from_byte
);
1682 gap_left (to
, to_byte
, 0);
1684 GAP_SIZE
+= nbytes_del
;
1687 ZV_BYTE
-= nbytes_del
;
1688 Z_BYTE
-= nbytes_del
;
1690 GPT_BYTE
= from_byte
;
1691 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1696 if (GPT
- BEG
< BEG_UNCHANGED
)
1697 BEG_UNCHANGED
= GPT
- BEG
;
1698 if (Z
- GPT
< END_UNCHANGED
)
1699 END_UNCHANGED
= Z
- GPT
;
1701 if (GAP_SIZE
< insbytes
)
1702 make_gap (insbytes
- GAP_SIZE
);
1704 /* Copy the replacement text into the buffer. */
1705 bcopy (ins
, GPT_ADDR
, insbytes
);
1707 #ifdef BYTE_COMBINING_DEBUG
1708 /* We have copied text into the gap, but we have not marked
1709 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1710 here, for both the previous text and the following text.
1711 Meanwhile, GPT_ADDR does point to
1712 the text that has been stored by copy_text. */
1713 if (count_combining_before (GPT_ADDR
, insbytes
, from
, from_byte
)
1714 || count_combining_after (GPT_ADDR
, insbytes
, from
, from_byte
))
1718 GAP_SIZE
-= insbytes
;
1722 GPT_BYTE
+= insbytes
;
1723 ZV_BYTE
+= insbytes
;
1725 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1730 /* Adjust the overlay center as needed. This must be done after
1731 adjusting the markers that bound the overlays. */
1732 if (nchars_del
!= inschars
)
1734 adjust_overlays_for_insert (from
, inschars
);
1735 adjust_overlays_for_delete (from
+ inschars
, nchars_del
);
1738 /* Adjust markers for the deletion and the insertion. */
1740 && ! (nchars_del
== 1 && inschars
== 1))
1741 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1742 inschars
, insbytes
);
1744 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1746 /* Relocate point as if it were a marker. */
1747 if (from
< PT
&& nchars_del
!= inschars
)
1748 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1749 (from_byte
+ insbytes
1750 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1753 evaporate_overlays (from
);
1760 /* Delete characters in current buffer
1761 from FROM up to (but not including) TO.
1762 If TO comes before FROM, we delete nothing. */
1765 del_range (from
, to
)
1766 register int from
, to
;
1768 del_range_1 (from
, to
, 1, 0);
1771 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1772 RET_STRING says to return the deleted text. */
1775 del_range_1 (from
, to
, prepare
, ret_string
)
1776 int from
, to
, prepare
, ret_string
;
1778 int from_byte
, to_byte
;
1779 Lisp_Object deletion
;
1780 struct gcpro gcpro1
;
1782 /* Make args be valid */
1793 int range_length
= to
- from
;
1794 prepare_to_modify_buffer (from
, to
, &from
);
1795 to
= min (ZV
, from
+ range_length
);
1798 from_byte
= CHAR_TO_BYTE (from
);
1799 to_byte
= CHAR_TO_BYTE (to
);
1801 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1803 signal_after_change (from
, to
- from
, 0);
1804 update_compositions (from
, from
, CHECK_HEAD
);
1809 /* Like del_range_1 but args are byte positions, not char positions. */
1812 del_range_byte (from_byte
, to_byte
, prepare
)
1813 int from_byte
, to_byte
, prepare
;
1817 /* Make args be valid */
1818 if (from_byte
< BEGV_BYTE
)
1819 from_byte
= BEGV_BYTE
;
1820 if (to_byte
> ZV_BYTE
)
1823 if (to_byte
<= from_byte
)
1826 from
= BYTE_TO_CHAR (from_byte
);
1827 to
= BYTE_TO_CHAR (to_byte
);
1831 int old_from
= from
, old_to
= Z
- to
;
1832 int range_length
= to
- from
;
1833 prepare_to_modify_buffer (from
, to
, &from
);
1834 to
= from
+ range_length
;
1836 if (old_from
!= from
)
1837 from_byte
= CHAR_TO_BYTE (from
);
1843 else if (old_to
== Z
- to
)
1844 to_byte
= CHAR_TO_BYTE (to
);
1847 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1848 signal_after_change (from
, to
- from
, 0);
1849 update_compositions (from
, from
, CHECK_HEAD
);
1852 /* Like del_range_1, but positions are specified both as charpos
1856 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1857 int from
, from_byte
, to
, to_byte
, prepare
;
1859 /* Make args be valid */
1860 if (from_byte
< BEGV_BYTE
)
1861 from_byte
= BEGV_BYTE
;
1862 if (to_byte
> ZV_BYTE
)
1865 if (to_byte
<= from_byte
)
1875 int old_from
= from
, old_to
= Z
- to
;
1876 int range_length
= to
- from
;
1877 prepare_to_modify_buffer (from
, to
, &from
);
1878 to
= from
+ range_length
;
1880 if (old_from
!= from
)
1881 from_byte
= CHAR_TO_BYTE (from
);
1887 else if (old_to
== Z
- to
)
1888 to_byte
= CHAR_TO_BYTE (to
);
1891 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1892 signal_after_change (from
, to
- from
, 0);
1893 update_compositions (from
, from
, CHECK_HEAD
);
1896 /* Delete a range of text, specified both as character positions
1897 and byte positions. FROM and TO are character positions,
1898 while FROM_BYTE and TO_BYTE are byte positions.
1899 If RET_STRING is true, the deleted area is returned as a string. */
1902 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1903 int from
, from_byte
, to
, to_byte
, ret_string
;
1905 register int nbytes_del
, nchars_del
;
1906 Lisp_Object deletion
;
1910 nchars_del
= to
- from
;
1911 nbytes_del
= to_byte
- from_byte
;
1913 /* Make sure the gap is somewhere in or next to what we are deleting. */
1915 gap_right (from
, from_byte
);
1917 gap_left (to
, to_byte
, 0);
1919 #ifdef BYTE_COMBINING_DEBUG
1920 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1921 Z_BYTE
- to_byte
, from
, from_byte
))
1925 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1926 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1930 /* Relocate all markers pointing into the new, larger gap
1931 to point at the end of the text before the gap.
1932 Do this before recording the deletion,
1933 so that undo handles this after reinserting the text. */
1934 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1936 if (! EQ (current_buffer
->undo_list
, Qt
))
1937 record_delete (from
, deletion
);
1940 /* Relocate point as if it were a marker. */
1942 adjust_point (from
- (PT
< to
? PT
: to
),
1943 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1945 offset_intervals (current_buffer
, from
, - nchars_del
);
1947 /* Adjust the overlay center as needed. This must be done after
1948 adjusting the markers that bound the overlays. */
1949 adjust_overlays_for_delete (from
, nchars_del
);
1951 GAP_SIZE
+= nbytes_del
;
1952 ZV_BYTE
-= nbytes_del
;
1953 Z_BYTE
-= nbytes_del
;
1957 GPT_BYTE
= from_byte
;
1958 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1963 if (GPT
- BEG
< BEG_UNCHANGED
)
1964 BEG_UNCHANGED
= GPT
- BEG
;
1965 if (Z
- GPT
< END_UNCHANGED
)
1966 END_UNCHANGED
= Z
- GPT
;
1970 evaporate_overlays (from
);
1975 /* Call this if you're about to change the region of BUFFER from
1976 character positions START to END. This checks the read-only
1977 properties of the region, calls the necessary modification hooks,
1978 and warns the next redisplay that it should pay attention to that
1982 modify_region (buffer
, start
, end
)
1983 struct buffer
*buffer
;
1986 struct buffer
*old_buffer
= current_buffer
;
1988 if (buffer
!= old_buffer
)
1989 set_buffer_internal (buffer
);
1991 prepare_to_modify_buffer (start
, end
, NULL
);
1993 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1995 if (MODIFF
<= SAVE_MODIFF
)
1996 record_first_change ();
1999 buffer
->point_before_scroll
= Qnil
;
2001 if (buffer
!= old_buffer
)
2002 set_buffer_internal (old_buffer
);
2005 /* Check that it is okay to modify the buffer between START and END,
2006 which are char positions.
2008 Run the before-change-function, if any. If intervals are in use,
2009 verify that the text to be modified is not read-only, and call
2010 any modification properties the text may have.
2012 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2013 by holding its value temporarily in a marker. */
2016 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2020 if (!NILP (current_buffer
->read_only
))
2021 Fbarf_if_buffer_read_only ();
2023 /* Let redisplay consider other windows than selected_window
2024 if modifying another buffer. */
2025 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2026 ++windows_or_buffers_changed
;
2028 if (BUF_INTERVALS (current_buffer
) != 0)
2032 Lisp_Object preserve_marker
;
2033 struct gcpro gcpro1
;
2034 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2035 GCPRO1 (preserve_marker
);
2036 verify_interval_modification (current_buffer
, start
, end
);
2037 *preserve_ptr
= marker_position (preserve_marker
);
2038 unchain_marker (XMARKER (preserve_marker
));
2042 verify_interval_modification (current_buffer
, start
, end
);
2045 #ifdef CLASH_DETECTION
2046 if (!NILP (current_buffer
->file_truename
)
2047 /* Make binding buffer-file-name to nil effective. */
2048 && !NILP (current_buffer
->filename
)
2049 && SAVE_MODIFF
>= MODIFF
)
2050 lock_file (current_buffer
->file_truename
);
2052 /* At least warn if this file has changed on disk since it was visited. */
2053 if (!NILP (current_buffer
->filename
)
2054 && SAVE_MODIFF
>= MODIFF
2055 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2056 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2057 call1 (intern ("ask-user-about-supersession-threat"),
2058 current_buffer
->filename
);
2059 #endif /* not CLASH_DETECTION */
2061 signal_before_change (start
, end
, preserve_ptr
);
2063 if (current_buffer
->newline_cache
)
2064 invalidate_region_cache (current_buffer
,
2065 current_buffer
->newline_cache
,
2066 start
- BEG
, Z
- end
);
2067 if (current_buffer
->width_run_cache
)
2068 invalidate_region_cache (current_buffer
,
2069 current_buffer
->width_run_cache
,
2070 start
- BEG
, Z
- end
);
2072 Vdeactivate_mark
= Qt
;
2075 /* These macros work with an argument named `preserve_ptr'
2076 and a local variable named `preserve_marker'. */
2078 #define PRESERVE_VALUE \
2079 if (preserve_ptr && NILP (preserve_marker)) \
2080 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2082 #define RESTORE_VALUE \
2083 if (! NILP (preserve_marker)) \
2085 *preserve_ptr = marker_position (preserve_marker); \
2086 unchain_marker (XMARKER (preserve_marker)); \
2089 #define PRESERVE_START_END \
2090 if (NILP (start_marker)) \
2091 start_marker = Fcopy_marker (start, Qnil); \
2092 if (NILP (end_marker)) \
2093 end_marker = Fcopy_marker (end, Qnil);
2095 #define FETCH_START \
2096 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2099 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2101 /* Signal a change to the buffer immediately before it happens.
2102 START_INT and END_INT are the bounds of the text to be changed.
2104 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2105 by holding its value temporarily in a marker. */
2108 signal_before_change (start_int
, end_int
, preserve_ptr
)
2109 int start_int
, end_int
;
2112 Lisp_Object start
, end
;
2113 Lisp_Object start_marker
, end_marker
;
2114 Lisp_Object preserve_marker
;
2115 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2117 if (inhibit_modification_hooks
)
2120 start
= make_number (start_int
);
2121 end
= make_number (end_int
);
2122 preserve_marker
= Qnil
;
2123 start_marker
= Qnil
;
2125 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2127 /* If buffer is unmodified, run a special hook for that case. */
2128 if (SAVE_MODIFF
>= MODIFF
2129 && !NILP (Vfirst_change_hook
)
2130 && !NILP (Vrun_hooks
))
2134 call1 (Vrun_hooks
, Qfirst_change_hook
);
2137 /* Now run the before-change-functions if any. */
2138 if (!NILP (Vbefore_change_functions
))
2140 Lisp_Object args
[3];
2141 Lisp_Object before_change_functions
;
2142 Lisp_Object after_change_functions
;
2143 struct gcpro gcpro1
, gcpro2
;
2144 struct buffer
*old
= current_buffer
;
2150 /* "Bind" before-change-functions and after-change-functions
2151 to nil--but in a way that errors don't know about.
2152 That way, if there's an error in them, they will stay nil. */
2153 before_change_functions
= Vbefore_change_functions
;
2154 after_change_functions
= Vafter_change_functions
;
2155 Vbefore_change_functions
= Qnil
;
2156 Vafter_change_functions
= Qnil
;
2157 GCPRO2 (before_change_functions
, after_change_functions
);
2159 /* Actually run the hook functions. */
2160 args
[0] = Qbefore_change_functions
;
2161 args
[1] = FETCH_START
;
2162 args
[2] = FETCH_END
;
2163 run_hook_list_with_args (before_change_functions
, 3, args
);
2165 /* "Unbind" the variables we "bound" to nil. Beware a
2166 buffer-local hook which changes the buffer when run (e.g. W3). */
2167 if (old
!= current_buffer
)
2169 new = current_buffer
;
2170 set_buffer_internal (old
);
2171 Vbefore_change_functions
= before_change_functions
;
2172 Vafter_change_functions
= after_change_functions
;
2173 set_buffer_internal (new);
2177 Vbefore_change_functions
= before_change_functions
;
2178 Vafter_change_functions
= after_change_functions
;
2183 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2186 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2187 FETCH_START
, FETCH_END
, Qnil
);
2190 if (! NILP (start_marker
))
2191 free_marker (start_marker
);
2192 if (! NILP (end_marker
))
2193 free_marker (end_marker
);
2198 /* Signal a change immediately after it happens.
2199 CHARPOS is the character position of the start of the changed text.
2200 LENDEL is the number of characters of the text before the change.
2201 (Not the whole buffer; just the part that was changed.)
2202 LENINS is the number of characters in that part of the text
2203 after the change. */
2206 signal_after_change (charpos
, lendel
, lenins
)
2207 int charpos
, lendel
, lenins
;
2209 if (inhibit_modification_hooks
)
2212 /* If we are deferring calls to the after-change functions
2213 and there are no before-change functions,
2214 just record the args that we were going to use. */
2215 if (! NILP (Vcombine_after_change_calls
)
2216 && NILP (Vbefore_change_functions
)
2217 && !current_buffer
->overlays_before
2218 && !current_buffer
->overlays_after
)
2222 if (!NILP (combine_after_change_list
)
2223 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2224 Fcombine_after_change_execute ();
2226 elt
= Fcons (make_number (charpos
- BEG
),
2227 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2228 Fcons (make_number (lenins
- lendel
), Qnil
)));
2229 combine_after_change_list
2230 = Fcons (elt
, combine_after_change_list
);
2231 combine_after_change_buffer
= Fcurrent_buffer ();
2236 if (!NILP (combine_after_change_list
))
2237 Fcombine_after_change_execute ();
2239 if (!NILP (Vafter_change_functions
))
2241 Lisp_Object args
[4];
2242 Lisp_Object before_change_functions
;
2243 Lisp_Object after_change_functions
;
2244 struct buffer
*old
= current_buffer
;
2246 struct gcpro gcpro1
, gcpro2
;
2248 /* "Bind" before-change-functions and after-change-functions
2249 to nil--but in a way that errors don't know about.
2250 That way, if there's an error in them, they will stay nil. */
2251 before_change_functions
= Vbefore_change_functions
;
2252 after_change_functions
= Vafter_change_functions
;
2253 Vbefore_change_functions
= Qnil
;
2254 Vafter_change_functions
= Qnil
;
2255 GCPRO2 (before_change_functions
, after_change_functions
);
2257 /* Actually run the hook functions. */
2258 args
[0] = Qafter_change_functions
;
2259 XSETFASTINT (args
[1], charpos
);
2260 XSETFASTINT (args
[2], charpos
+ lenins
);
2261 XSETFASTINT (args
[3], lendel
);
2262 run_hook_list_with_args (after_change_functions
,
2265 /* "Unbind" the variables we "bound" to nil. Beware a
2266 buffer-local hook which changes the buffer when run (e.g. W3). */
2267 if (old
!= current_buffer
)
2269 new = current_buffer
;
2270 set_buffer_internal (old
);
2271 Vbefore_change_functions
= before_change_functions
;
2272 Vafter_change_functions
= after_change_functions
;
2273 set_buffer_internal (new);
2277 Vbefore_change_functions
= before_change_functions
;
2278 Vafter_change_functions
= after_change_functions
;
2283 if (current_buffer
->overlays_before
|| current_buffer
->overlays_after
)
2284 report_overlay_modification (make_number (charpos
),
2285 make_number (charpos
+ lenins
),
2287 make_number (charpos
),
2288 make_number (charpos
+ lenins
),
2289 make_number (lendel
));
2291 /* After an insertion, call the text properties
2292 insert-behind-hooks or insert-in-front-hooks. */
2294 report_interval_modification (make_number (charpos
),
2295 make_number (charpos
+ lenins
));
2299 Fcombine_after_change_execute_1 (val
)
2302 Vcombine_after_change_calls
= val
;
2306 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2307 Scombine_after_change_execute
, 0, 0, 0,
2308 doc
: /* This function is for use internally in `combine-after-change-calls'. */)
2311 int count
= SPECPDL_INDEX ();
2312 int beg
, end
, change
;
2316 if (NILP (combine_after_change_list
))
2319 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2321 Fset_buffer (combine_after_change_buffer
);
2323 /* # chars unchanged at beginning of buffer. */
2325 /* # chars unchanged at end of buffer. */
2327 /* Total amount of insertion (negative for deletion). */
2330 /* Scan the various individual changes,
2331 accumulating the range info in BEG, END and CHANGE. */
2332 for (tail
= combine_after_change_list
; CONSP (tail
);
2336 int thisbeg
, thisend
, thischange
;
2338 /* Extract the info from the next element. */
2342 thisbeg
= XINT (XCAR (elt
));
2347 thisend
= XINT (XCAR (elt
));
2352 thischange
= XINT (XCAR (elt
));
2354 /* Merge this range into the accumulated range. */
2355 change
+= thischange
;
2362 /* Get the current start and end positions of the range
2363 that was changed. */
2367 /* We are about to handle these, so discard them. */
2368 combine_after_change_list
= Qnil
;
2370 /* Now run the after-change functions for real.
2371 Turn off the flag that defers them. */
2372 record_unwind_protect (Fcombine_after_change_execute_1
,
2373 Vcombine_after_change_calls
);
2374 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2375 update_compositions (begpos
, endpos
, CHECK_ALL
);
2377 return unbind_to (count
, Qnil
);
2383 staticpro (&combine_after_change_list
);
2384 combine_after_change_list
= Qnil
;
2385 combine_after_change_buffer
= Qnil
;
2387 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2388 doc
: /* Non-nil means enable debugging checks for invalid marker positions. */);
2389 check_markers_debug_flag
= 0;
2390 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2391 doc
: /* Used internally by the `combine-after-change-calls' macro. */);
2392 Vcombine_after_change_calls
= Qnil
;
2394 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2395 doc
: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2396 This affects `before-change-functions' and `after-change-functions',
2397 as well as hooks attached to text properties and overlays. */);
2398 inhibit_modification_hooks
= 0;
2399 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2400 staticpro (&Qinhibit_modification_hooks
);
2402 defsubr (&Scombine_after_change_execute
);
2405 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2406 (do not change this comment) */