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 (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
;
572 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
573 FROM_MULTIBYTE says whether the incoming text is multibyte.
574 TO_MULTIBYTE says whether to store the text as multibyte.
575 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
577 Return the number of bytes stored at TO_ADDR. */
580 copy_text (from_addr
, to_addr
, nbytes
,
581 from_multibyte
, to_multibyte
)
582 unsigned char *from_addr
;
583 unsigned char *to_addr
;
585 int from_multibyte
, to_multibyte
;
587 if (from_multibyte
== to_multibyte
)
589 bcopy (from_addr
, to_addr
, nbytes
);
592 else if (from_multibyte
)
595 int bytes_left
= nbytes
;
596 Lisp_Object tbl
= Qnil
;
598 /* We set the variable tbl to the reverse table of
599 Vnonascii_translation_table in advance. */
600 if (CHAR_TABLE_P (Vnonascii_translation_table
))
602 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
604 if (!CHAR_TABLE_P (tbl
))
608 /* Convert multibyte to single byte. */
609 while (bytes_left
> 0)
612 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
613 if (!SINGLE_BYTE_CHAR_P (c
))
614 c
= multibyte_char_to_unibyte (c
, tbl
);
616 from_addr
+= thislen
;
617 bytes_left
-= thislen
;
624 unsigned char *initial_to_addr
= to_addr
;
626 /* Convert single-byte to multibyte. */
629 int c
= *from_addr
++;
633 c
= unibyte_char_to_multibyte (c
);
634 to_addr
+= CHAR_STRING (c
, to_addr
);
638 /* Special case for speed. */
639 *to_addr
++ = c
, nbytes
--;
641 return to_addr
- initial_to_addr
;
645 /* Return the number of bytes it would take
646 to convert some single-byte text to multibyte.
647 The single-byte text consists of NBYTES bytes at PTR. */
650 count_size_as_multibyte (ptr
, nbytes
)
655 int outgoing_nbytes
= 0;
657 for (i
= 0; i
< nbytes
; i
++)
659 unsigned int c
= *ptr
++;
665 c
= unibyte_char_to_multibyte (c
);
666 outgoing_nbytes
+= CHAR_BYTES (c
);
670 return outgoing_nbytes
;
673 /* Insert a string of specified length before point.
674 This function judges multibyteness based on
675 enable_multibyte_characters in the current buffer;
676 it never converts between single-byte and multibyte.
678 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
679 prepare_to_modify_buffer could relocate the text. */
682 insert (string
, nbytes
)
683 register unsigned char *string
;
689 insert_1 (string
, nbytes
, 0, 1, 0);
690 signal_after_change (opoint
, 0, PT
- opoint
);
691 update_compositions (opoint
, PT
, CHECK_BORDER
);
695 /* Likewise, but inherit text properties from neighboring characters. */
698 insert_and_inherit (string
, nbytes
)
699 register unsigned char *string
;
705 insert_1 (string
, nbytes
, 1, 1, 0);
706 signal_after_change (opoint
, 0, PT
- opoint
);
707 update_compositions (opoint
, PT
, CHECK_BORDER
);
711 /* Insert the character C before point. Do not inherit text properties. */
717 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
720 if (! NILP (current_buffer
->enable_multibyte_characters
))
721 len
= CHAR_STRING (c
, str
);
731 /* Insert the null-terminated string S before point. */
737 insert (s
, strlen (s
));
740 /* Like `insert' except that all markers pointing at the place where
741 the insertion happens are adjusted to point after it.
742 Don't use this function to insert part of a Lisp string,
743 since gc could happen and relocate it. */
746 insert_before_markers (string
, nbytes
)
747 unsigned char *string
;
754 insert_1 (string
, nbytes
, 0, 1, 1);
755 signal_after_change (opoint
, 0, PT
- opoint
);
756 update_compositions (opoint
, PT
, CHECK_BORDER
);
760 /* Likewise, but inherit text properties from neighboring characters. */
763 insert_before_markers_and_inherit (string
, nbytes
)
764 unsigned char *string
;
771 insert_1 (string
, nbytes
, 1, 1, 1);
772 signal_after_change (opoint
, 0, PT
- opoint
);
773 update_compositions (opoint
, PT
, CHECK_BORDER
);
777 /* Subroutine used by the insert functions above. */
780 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
781 register unsigned char *string
;
783 int inherit
, prepare
, before_markers
;
785 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
786 inherit
, prepare
, before_markers
);
790 #ifdef BYTE_COMBINING_DEBUG
792 /* See if the bytes before POS/POS_BYTE combine with bytes
793 at the start of STRING to form a single character.
794 If so, return the number of bytes at the start of STRING
795 which combine in this way. Otherwise, return 0. */
798 count_combining_before (string
, length
, pos
, pos_byte
)
799 unsigned char *string
;
803 int len
, combining_bytes
;
806 if (NILP (current_buffer
->enable_multibyte_characters
))
809 /* At first, we can exclude the following cases:
810 (1) STRING[0] can't be a following byte of multibyte sequence.
811 (2) POS is the start of the current buffer.
812 (3) A character before POS is not a multibyte character. */
813 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
815 if (pos_byte
== BEG_BYTE
) /* case (2) */
818 p
= BYTE_POS_ADDR (pos_byte
- 1);
819 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
820 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
823 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
824 if (combining_bytes
<= 0)
825 /* The character preceding POS is, complete and no room for
826 combining bytes (combining_bytes == 0), or an independent 8-bit
827 character (combining_bytes < 0). */
830 /* We have a combination situation. Count the bytes at STRING that
833 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
836 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
839 /* See if the bytes after POS/POS_BYTE combine with bytes
840 at the end of STRING to form a single character.
841 If so, return the number of bytes after POS/POS_BYTE
842 which combine in this way. Otherwise, return 0. */
845 count_combining_after (string
, length
, pos
, pos_byte
)
846 unsigned char *string
;
850 int opos_byte
= pos_byte
;
855 if (NILP (current_buffer
->enable_multibyte_characters
))
858 /* At first, we can exclude the following cases:
859 (1) The last byte of STRING is an ASCII.
860 (2) POS is the last of the current buffer.
861 (3) A character at POS can't be a following byte of multibyte
863 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
865 if (pos_byte
== Z_BYTE
) /* case (2) */
867 bufp
= BYTE_POS_ADDR (pos_byte
);
868 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
872 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
878 /* All characters in STRING are not character head. We must
879 check also preceding bytes at POS. We are sure that the gap
881 unsigned char *p
= BEG_ADDR
;
883 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
885 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
888 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
889 return (bytes
<= pos_byte
- 1 - i
+ length
891 : bytes
- (pos_byte
- 1 - i
+ length
));
893 if (!BASE_LEADING_CODE_P (string
[i
]))
896 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
898 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
900 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
906 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
907 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
908 are the same as in insert_1. */
911 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
912 register unsigned char *string
;
913 register int nchars
, nbytes
;
914 int inherit
, prepare
, before_markers
;
919 if (NILP (current_buffer
->enable_multibyte_characters
))
923 /* Do this before moving and increasing the gap,
924 because the before-change hooks might move the gap
925 or make it smaller. */
926 prepare_to_modify_buffer (PT
, PT
, NULL
);
929 move_gap_both (PT
, PT_BYTE
);
930 if (GAP_SIZE
< nbytes
)
931 make_gap (nbytes
- GAP_SIZE
);
933 #ifdef BYTE_COMBINING_DEBUG
934 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
935 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
939 /* Record deletion of the surrounding text that combines with
940 the insertion. This, together with recording the insertion,
941 will add up to the right stuff in the undo list. */
942 record_insert (PT
, nchars
);
945 bcopy (string
, GPT_ADDR
, nbytes
);
954 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
959 adjust_overlays_for_insert (PT
, nchars
);
960 adjust_markers_for_insert (PT
, PT_BYTE
,
961 PT
+ nchars
, PT_BYTE
+ nbytes
,
964 if (BUF_INTERVALS (current_buffer
) != 0)
965 offset_intervals (current_buffer
, PT
, nchars
);
967 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
968 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
971 adjust_point (nchars
, nbytes
);
976 /* Insert the part of the text of STRING, a Lisp object assumed to be
977 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
978 starting at position POS / POS_BYTE. If the text of STRING has properties,
979 copy them into the buffer.
981 It does not work to use `insert' for this, because a GC could happen
982 before we bcopy the stuff into the buffer, and relocate the string
983 without insert noticing. */
986 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
988 register int pos
, pos_byte
, length
, length_byte
;
992 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
994 signal_after_change (opoint
, 0, PT
- opoint
);
995 update_compositions (opoint
, PT
, CHECK_BORDER
);
998 /* Like `insert_from_string' except that all markers pointing
999 at the place where the insertion happens are adjusted to point after it. */
1002 insert_from_string_before_markers (string
, pos
, pos_byte
,
1003 length
, length_byte
, inherit
)
1005 register int pos
, pos_byte
, length
, length_byte
;
1009 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1011 signal_after_change (opoint
, 0, PT
- opoint
);
1012 update_compositions (opoint
, PT
, CHECK_BORDER
);
1015 /* Subroutine of the insertion functions above. */
1018 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1019 inherit
, before_markers
)
1021 register int pos
, pos_byte
, nchars
, nbytes
;
1022 int inherit
, before_markers
;
1024 struct gcpro gcpro1
;
1025 int outgoing_nbytes
= nbytes
;
1028 /* Make OUTGOING_NBYTES describe the text
1029 as it will be inserted in this buffer. */
1031 if (NILP (current_buffer
->enable_multibyte_characters
))
1032 outgoing_nbytes
= nchars
;
1033 else if (! STRING_MULTIBYTE (string
))
1035 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1039 /* Do this before moving and increasing the gap,
1040 because the before-change hooks might move the gap
1041 or make it smaller. */
1042 prepare_to_modify_buffer (PT
, PT
, NULL
);
1045 move_gap_both (PT
, PT_BYTE
);
1046 if (GAP_SIZE
< outgoing_nbytes
)
1047 make_gap (outgoing_nbytes
- GAP_SIZE
);
1050 /* Copy the string text into the buffer, perhaps converting
1051 between single-byte and multibyte. */
1052 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1053 STRING_MULTIBYTE (string
),
1054 ! NILP (current_buffer
->enable_multibyte_characters
));
1056 #ifdef BYTE_COMBINING_DEBUG
1057 /* We have copied text into the gap, but we have not altered
1058 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1059 to these functions and get the same results as we would
1060 have got earlier on. Meanwhile, PT_ADDR does point to
1061 the text that has been stored by copy_text. */
1062 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1063 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1067 record_insert (PT
, nchars
);
1070 GAP_SIZE
-= outgoing_nbytes
;
1074 GPT_BYTE
+= outgoing_nbytes
;
1075 ZV_BYTE
+= outgoing_nbytes
;
1076 Z_BYTE
+= outgoing_nbytes
;
1077 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1082 adjust_overlays_for_insert (PT
, nchars
);
1083 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1084 PT_BYTE
+ outgoing_nbytes
,
1087 offset_intervals (current_buffer
, PT
, nchars
);
1089 intervals
= XSTRING (string
)->intervals
;
1090 /* Get the intervals for the part of the string we are inserting. */
1091 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1092 intervals
= copy_intervals (intervals
, pos
, nchars
);
1094 /* Insert those intervals. */
1095 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1096 current_buffer
, inherit
);
1098 adjust_point (nchars
, outgoing_nbytes
);
1101 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1102 current buffer. If the text in BUF has properties, they are absorbed
1103 into the current buffer.
1105 It does not work to use `insert' for this, because a malloc could happen
1106 and relocate BUF's text before the bcopy happens. */
1109 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1111 int charpos
, nchars
;
1116 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1117 signal_after_change (opoint
, 0, PT
- opoint
);
1118 update_compositions (opoint
, PT
, CHECK_BORDER
);
1122 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1127 register Lisp_Object temp
;
1128 int chunk
, chunk_expanded
;
1129 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1130 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1131 int incoming_nbytes
= to_byte
- from_byte
;
1132 int outgoing_nbytes
= incoming_nbytes
;
1135 /* Make OUTGOING_NBYTES describe the text
1136 as it will be inserted in this buffer. */
1138 if (NILP (current_buffer
->enable_multibyte_characters
))
1139 outgoing_nbytes
= nchars
;
1140 else if (NILP (buf
->enable_multibyte_characters
))
1142 int outgoing_before_gap
= 0;
1143 int outgoing_after_gap
= 0;
1145 if (from
< BUF_GPT (buf
))
1147 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1148 if (chunk
> incoming_nbytes
)
1149 chunk
= incoming_nbytes
;
1151 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1157 if (chunk
< incoming_nbytes
)
1159 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1161 incoming_nbytes
- chunk
);
1163 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1166 /* Make sure point-max won't overflow after this insertion. */
1167 XSETINT (temp
, outgoing_nbytes
+ Z
);
1168 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1169 error ("Maximum buffer size exceeded");
1171 /* Do this before moving and increasing the gap,
1172 because the before-change hooks might move the gap
1173 or make it smaller. */
1174 prepare_to_modify_buffer (PT
, PT
, NULL
);
1177 move_gap_both (PT
, PT_BYTE
);
1178 if (GAP_SIZE
< outgoing_nbytes
)
1179 make_gap (outgoing_nbytes
- GAP_SIZE
);
1181 if (from
< BUF_GPT (buf
))
1183 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1184 if (chunk
> incoming_nbytes
)
1185 chunk
= incoming_nbytes
;
1186 /* Record number of output bytes, so we know where
1187 to put the output from the second copy_text. */
1189 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1191 ! NILP (buf
->enable_multibyte_characters
),
1192 ! NILP (current_buffer
->enable_multibyte_characters
));
1195 chunk_expanded
= chunk
= 0;
1197 if (chunk
< incoming_nbytes
)
1198 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1199 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1200 ! NILP (buf
->enable_multibyte_characters
),
1201 ! NILP (current_buffer
->enable_multibyte_characters
));
1203 #ifdef BYTE_COMBINING_DEBUG
1204 /* We have copied text into the gap, but we have not altered
1205 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1206 to these functions and get the same results as we would
1207 have got earlier on. Meanwhile, GPT_ADDR does point to
1208 the text that has been stored by copy_text. */
1209 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1210 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1214 record_insert (PT
, nchars
);
1217 GAP_SIZE
-= outgoing_nbytes
;
1221 GPT_BYTE
+= outgoing_nbytes
;
1222 ZV_BYTE
+= outgoing_nbytes
;
1223 Z_BYTE
+= outgoing_nbytes
;
1224 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1229 adjust_overlays_for_insert (PT
, nchars
);
1230 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1231 PT_BYTE
+ outgoing_nbytes
,
1234 if (BUF_INTERVALS (current_buffer
) != 0)
1235 offset_intervals (current_buffer
, PT
, nchars
);
1237 /* Get the intervals for the part of the string we are inserting. */
1238 intervals
= BUF_INTERVALS (buf
);
1239 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1241 if (buf
== current_buffer
&& PT
<= from
)
1243 intervals
= copy_intervals (intervals
, from
, nchars
);
1246 /* Insert those intervals. */
1247 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1249 adjust_point (nchars
, outgoing_nbytes
);
1252 /* Record undo information and adjust markers and position keepers for
1253 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1254 chars (LEN_BYTE bytes) which resides in the gap just after
1257 PREV_TEXT nil means the new text was just inserted. */
1260 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1261 int from
, from_byte
, len
, len_byte
;
1262 Lisp_Object prev_text
;
1264 int nchars_del
= 0, nbytes_del
= 0;
1266 #ifdef BYTE_COMBINING_DEBUG
1267 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1268 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1272 if (STRINGP (prev_text
))
1274 nchars_del
= XSTRING (prev_text
)->size
;
1275 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1278 /* Update various buffer positions for the new text. */
1279 GAP_SIZE
-= len_byte
;
1281 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1282 GPT
+= len
; GPT_BYTE
+= len_byte
;
1283 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1286 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1289 adjust_markers_for_insert (from
, from_byte
,
1290 from
+ len
, from_byte
+ len_byte
, 0);
1292 if (! EQ (current_buffer
->undo_list
, Qt
))
1295 record_delete (from
, prev_text
);
1296 record_insert (from
, len
);
1299 if (len
> nchars_del
)
1300 adjust_overlays_for_insert (from
, len
- nchars_del
);
1301 else if (len
< nchars_del
)
1302 adjust_overlays_for_delete (from
, nchars_del
- len
);
1303 if (BUF_INTERVALS (current_buffer
) != 0)
1305 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1309 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1311 /* As byte combining will decrease Z, we must check this again. */
1312 if (Z
- GPT
< END_UNCHANGED
)
1313 END_UNCHANGED
= Z
- GPT
;
1318 evaporate_overlays (from
);
1322 /* Record undo information, adjust markers and position keepers for an
1323 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1324 text already exists in the current buffer but character length (TO
1325 - FROM) may be incorrect, the correct length is NEWLEN. */
1328 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1329 int from
, from_byte
, to
, to_byte
, newlen
;
1331 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1334 move_gap_both (to
, to_byte
);
1335 GAP_SIZE
+= len_byte
;
1336 GPT
-= len
; GPT_BYTE
-= len_byte
;
1337 ZV
-= len
; ZV_BYTE
-= len_byte
;
1338 Z
-= len
; Z_BYTE
-= len_byte
;
1339 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1342 /* Replace the text from character positions FROM to TO with NEW,
1343 If PREPARE is nonzero, call prepare_to_modify_buffer.
1344 If INHERIT, the newly inserted text should inherit text properties
1345 from the surrounding non-deleted text. */
1347 /* Note that this does not yet handle markers quite right.
1348 Also it needs to record a single undo-entry that does a replacement
1349 rather than a separate delete and insert.
1350 That way, undo will also handle markers properly.
1352 But if MARKERS is 0, don't relocate markers. */
1355 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1357 int from
, to
, prepare
, inherit
, markers
;
1359 int inschars
= XSTRING (new)->size
;
1360 int insbytes
= STRING_BYTES (XSTRING (new));
1361 int from_byte
, to_byte
;
1362 int nbytes_del
, nchars_del
;
1363 register Lisp_Object temp
;
1364 struct gcpro gcpro1
;
1366 int outgoing_insbytes
= insbytes
;
1367 Lisp_Object deletion
;
1376 int range_length
= to
- from
;
1377 prepare_to_modify_buffer (from
, to
, &from
);
1378 to
= from
+ range_length
;
1383 /* Make args be valid */
1389 from_byte
= CHAR_TO_BYTE (from
);
1390 to_byte
= CHAR_TO_BYTE (to
);
1392 nchars_del
= to
- from
;
1393 nbytes_del
= to_byte
- from_byte
;
1395 if (nbytes_del
<= 0 && insbytes
== 0)
1398 /* Make OUTGOING_INSBYTES describe the text
1399 as it will be inserted in this buffer. */
1401 if (NILP (current_buffer
->enable_multibyte_characters
))
1402 outgoing_insbytes
= inschars
;
1403 else if (! STRING_MULTIBYTE (new))
1405 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1407 /* Make sure point-max won't overflow after this insertion. */
1408 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1409 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1410 error ("Maximum buffer size exceeded");
1414 /* Make sure the gap is somewhere in or next to what we are deleting. */
1416 gap_right (from
, from_byte
);
1418 gap_left (to
, to_byte
, 0);
1420 /* Even if we don't record for undo, we must keep the original text
1421 because we may have to recover it because of inappropriate byte
1423 if (! EQ (current_buffer
->undo_list
, Qt
))
1424 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1427 /* Relocate all markers pointing into the new, larger gap
1428 to point at the end of the text before the gap.
1429 Do this before recording the deletion,
1430 so that undo handles this after reinserting the text. */
1431 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1433 GAP_SIZE
+= nbytes_del
;
1436 ZV_BYTE
-= nbytes_del
;
1437 Z_BYTE
-= nbytes_del
;
1439 GPT_BYTE
= from_byte
;
1440 *(GPT_ADDR
) = 0; /* Put an anchor. */
1445 if (GPT
- BEG
< BEG_UNCHANGED
)
1446 BEG_UNCHANGED
= GPT
- BEG
;
1447 if (Z
- GPT
< END_UNCHANGED
)
1448 END_UNCHANGED
= Z
- GPT
;
1450 if (GAP_SIZE
< insbytes
)
1451 make_gap (insbytes
- GAP_SIZE
);
1453 /* Copy the string text into the buffer, perhaps converting
1454 between single-byte and multibyte. */
1455 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1456 STRING_MULTIBYTE (new),
1457 ! NILP (current_buffer
->enable_multibyte_characters
));
1459 #ifdef BYTE_COMBINING_DEBUG
1460 /* We have copied text into the gap, but we have not marked
1461 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1462 here, for both the previous text and the following text.
1463 Meanwhile, GPT_ADDR does point to
1464 the text that has been stored by copy_text. */
1465 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1466 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1470 if (! EQ (current_buffer
->undo_list
, Qt
))
1472 record_delete (from
, deletion
);
1473 record_insert (from
, inschars
);
1476 GAP_SIZE
-= outgoing_insbytes
;
1480 GPT_BYTE
+= outgoing_insbytes
;
1481 ZV_BYTE
+= outgoing_insbytes
;
1482 Z_BYTE
+= outgoing_insbytes
;
1483 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1488 /* Adjust the overlay center as needed. This must be done after
1489 adjusting the markers that bound the overlays. */
1490 adjust_overlays_for_delete (from
, nchars_del
);
1491 adjust_overlays_for_insert (from
, inschars
);
1493 adjust_markers_for_insert (from
, from_byte
,
1494 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1497 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1499 /* Get the intervals for the part of the string we are inserting--
1500 not including the combined-before bytes. */
1501 intervals
= XSTRING (new)->intervals
;
1502 /* Insert those intervals. */
1503 graft_intervals_into_buffer (intervals
, from
, inschars
,
1504 current_buffer
, inherit
);
1506 /* Relocate point as if it were a marker. */
1508 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1509 (from_byte
+ outgoing_insbytes
1510 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1512 if (outgoing_insbytes
== 0)
1513 evaporate_overlays (from
);
1520 signal_after_change (from
, nchars_del
, GPT
- from
);
1521 update_compositions (from
, GPT
, CHECK_BORDER
);
1524 /* Delete characters in current buffer
1525 from FROM up to (but not including) TO.
1526 If TO comes before FROM, we delete nothing. */
1529 del_range (from
, to
)
1530 register int from
, to
;
1532 del_range_1 (from
, to
, 1, 0);
1535 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1536 RET_STRING says to return the deleted text. */
1539 del_range_1 (from
, to
, prepare
, ret_string
)
1540 int from
, to
, prepare
, ret_string
;
1542 int from_byte
, to_byte
;
1543 Lisp_Object deletion
;
1544 struct gcpro gcpro1
;
1546 /* Make args be valid */
1557 int range_length
= to
- from
;
1558 prepare_to_modify_buffer (from
, to
, &from
);
1559 to
= min (ZV
, from
+ range_length
);
1562 from_byte
= CHAR_TO_BYTE (from
);
1563 to_byte
= CHAR_TO_BYTE (to
);
1565 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1567 signal_after_change (from
, to
- from
, 0);
1568 update_compositions (from
, from
, CHECK_HEAD
);
1573 /* Like del_range_1 but args are byte positions, not char positions. */
1576 del_range_byte (from_byte
, to_byte
, prepare
)
1577 int from_byte
, to_byte
, prepare
;
1581 /* Make args be valid */
1582 if (from_byte
< BEGV_BYTE
)
1583 from_byte
= BEGV_BYTE
;
1584 if (to_byte
> ZV_BYTE
)
1587 if (to_byte
<= from_byte
)
1590 from
= BYTE_TO_CHAR (from_byte
);
1591 to
= BYTE_TO_CHAR (to_byte
);
1595 int old_from
= from
, old_to
= Z
- to
;
1596 int range_length
= to
- from
;
1597 prepare_to_modify_buffer (from
, to
, &from
);
1598 to
= from
+ range_length
;
1600 if (old_from
!= from
)
1601 from_byte
= CHAR_TO_BYTE (from
);
1607 else if (old_to
== Z
- to
)
1608 to_byte
= CHAR_TO_BYTE (to
);
1611 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1612 signal_after_change (from
, to
- from
, 0);
1613 update_compositions (from
, from
, CHECK_HEAD
);
1616 /* Like del_range_1, but positions are specified both as charpos
1620 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1621 int from
, from_byte
, to
, to_byte
, prepare
;
1623 /* Make args be valid */
1624 if (from_byte
< BEGV_BYTE
)
1625 from_byte
= BEGV_BYTE
;
1626 if (to_byte
> ZV_BYTE
)
1629 if (to_byte
<= from_byte
)
1639 int old_from
= from
, old_to
= Z
- to
;
1640 int range_length
= to
- from
;
1641 prepare_to_modify_buffer (from
, to
, &from
);
1642 to
= from
+ range_length
;
1644 if (old_from
!= from
)
1645 from_byte
= CHAR_TO_BYTE (from
);
1651 else if (old_to
== Z
- to
)
1652 to_byte
= CHAR_TO_BYTE (to
);
1655 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1656 signal_after_change (from
, to
- from
, 0);
1657 update_compositions (from
, from
, CHECK_HEAD
);
1660 /* Delete a range of text, specified both as character positions
1661 and byte positions. FROM and TO are character positions,
1662 while FROM_BYTE and TO_BYTE are byte positions.
1663 If RET_STRING is true, the deleted area is returned as a string. */
1666 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1667 int from
, from_byte
, to
, to_byte
, ret_string
;
1669 register int nbytes_del
, nchars_del
;
1670 Lisp_Object deletion
;
1674 nchars_del
= to
- from
;
1675 nbytes_del
= to_byte
- from_byte
;
1677 /* Make sure the gap is somewhere in or next to what we are deleting. */
1679 gap_right (from
, from_byte
);
1681 gap_left (to
, to_byte
, 0);
1683 #ifdef BYTE_COMBINING_DEBUG
1684 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1685 Z_BYTE
- to_byte
, from
, from_byte
))
1689 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1690 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1694 /* Relocate all markers pointing into the new, larger gap
1695 to point at the end of the text before the gap.
1696 Do this before recording the deletion,
1697 so that undo handles this after reinserting the text. */
1698 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1700 if (! EQ (current_buffer
->undo_list
, Qt
))
1701 record_delete (from
, deletion
);
1704 /* Relocate point as if it were a marker. */
1706 adjust_point (from
- (PT
< to
? PT
: to
),
1707 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1709 offset_intervals (current_buffer
, from
, - nchars_del
);
1711 /* Adjust the overlay center as needed. This must be done after
1712 adjusting the markers that bound the overlays. */
1713 adjust_overlays_for_delete (from
, nchars_del
);
1715 GAP_SIZE
+= nbytes_del
;
1716 ZV_BYTE
-= nbytes_del
;
1717 Z_BYTE
-= nbytes_del
;
1721 GPT_BYTE
= from_byte
;
1722 *(GPT_ADDR
) = 0; /* Put an anchor. */
1727 if (GPT
- BEG
< BEG_UNCHANGED
)
1728 BEG_UNCHANGED
= GPT
- BEG
;
1729 if (Z
- GPT
< END_UNCHANGED
)
1730 END_UNCHANGED
= Z
- GPT
;
1734 evaporate_overlays (from
);
1739 /* Call this if you're about to change the region of BUFFER from
1740 character positions START to END. This checks the read-only
1741 properties of the region, calls the necessary modification hooks,
1742 and warns the next redisplay that it should pay attention to that
1746 modify_region (buffer
, start
, end
)
1747 struct buffer
*buffer
;
1750 struct buffer
*old_buffer
= current_buffer
;
1752 if (buffer
!= old_buffer
)
1753 set_buffer_internal (buffer
);
1755 prepare_to_modify_buffer (start
, end
, NULL
);
1757 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1759 if (MODIFF
<= SAVE_MODIFF
)
1760 record_first_change ();
1763 buffer
->point_before_scroll
= Qnil
;
1765 if (buffer
!= old_buffer
)
1766 set_buffer_internal (old_buffer
);
1769 /* Check that it is okay to modify the buffer between START and END,
1770 which are char positions.
1772 Run the before-change-function, if any. If intervals are in use,
1773 verify that the text to be modified is not read-only, and call
1774 any modification properties the text may have.
1776 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1777 by holding its value temporarily in a marker. */
1780 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1784 if (!NILP (current_buffer
->read_only
))
1785 Fbarf_if_buffer_read_only ();
1787 /* Let redisplay consider other windows than selected_window
1788 if modifying another buffer. */
1789 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1790 ++windows_or_buffers_changed
;
1792 if (BUF_INTERVALS (current_buffer
) != 0)
1796 Lisp_Object preserve_marker
;
1797 struct gcpro gcpro1
;
1798 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1799 GCPRO1 (preserve_marker
);
1800 verify_interval_modification (current_buffer
, start
, end
);
1801 *preserve_ptr
= marker_position (preserve_marker
);
1802 unchain_marker (preserve_marker
);
1806 verify_interval_modification (current_buffer
, start
, end
);
1809 #ifdef CLASH_DETECTION
1810 if (!NILP (current_buffer
->file_truename
)
1811 /* Make binding buffer-file-name to nil effective. */
1812 && !NILP (current_buffer
->filename
)
1813 && SAVE_MODIFF
>= MODIFF
)
1814 lock_file (current_buffer
->file_truename
);
1816 /* At least warn if this file has changed on disk since it was visited. */
1817 if (!NILP (current_buffer
->filename
)
1818 && SAVE_MODIFF
>= MODIFF
1819 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1820 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1821 call1 (intern ("ask-user-about-supersession-threat"),
1822 current_buffer
->filename
);
1823 #endif /* not CLASH_DETECTION */
1825 signal_before_change (start
, end
, preserve_ptr
);
1827 if (current_buffer
->newline_cache
)
1828 invalidate_region_cache (current_buffer
,
1829 current_buffer
->newline_cache
,
1830 start
- BEG
, Z
- end
);
1831 if (current_buffer
->width_run_cache
)
1832 invalidate_region_cache (current_buffer
,
1833 current_buffer
->width_run_cache
,
1834 start
- BEG
, Z
- end
);
1836 Vdeactivate_mark
= Qt
;
1839 /* These macros work with an argument named `preserve_ptr'
1840 and a local variable named `preserve_marker'. */
1842 #define PRESERVE_VALUE \
1843 if (preserve_ptr && NILP (preserve_marker)) \
1844 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1846 #define RESTORE_VALUE \
1847 if (! NILP (preserve_marker)) \
1849 *preserve_ptr = marker_position (preserve_marker); \
1850 unchain_marker (preserve_marker); \
1853 #define PRESERVE_START_END \
1854 if (NILP (start_marker)) \
1855 start_marker = Fcopy_marker (start, Qnil); \
1856 if (NILP (end_marker)) \
1857 end_marker = Fcopy_marker (end, Qnil);
1859 #define FETCH_START \
1860 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1863 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1865 /* Signal a change to the buffer immediately before it happens.
1866 START_INT and END_INT are the bounds of the text to be changed.
1868 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1869 by holding its value temporarily in a marker. */
1872 signal_before_change (start_int
, end_int
, preserve_ptr
)
1873 int start_int
, end_int
;
1876 Lisp_Object start
, end
;
1877 Lisp_Object start_marker
, end_marker
;
1878 Lisp_Object preserve_marker
;
1879 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1881 if (inhibit_modification_hooks
)
1884 start
= make_number (start_int
);
1885 end
= make_number (end_int
);
1886 preserve_marker
= Qnil
;
1887 start_marker
= Qnil
;
1889 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1891 /* If buffer is unmodified, run a special hook for that case. */
1892 if (SAVE_MODIFF
>= MODIFF
1893 && !NILP (Vfirst_change_hook
)
1894 && !NILP (Vrun_hooks
))
1898 call1 (Vrun_hooks
, Qfirst_change_hook
);
1901 /* Now run the before-change-functions if any. */
1902 if (!NILP (Vbefore_change_functions
))
1904 Lisp_Object args
[3];
1905 Lisp_Object before_change_functions
;
1906 Lisp_Object after_change_functions
;
1907 struct gcpro gcpro1
, gcpro2
;
1908 struct buffer
*old
= current_buffer
;
1914 /* "Bind" before-change-functions and after-change-functions
1915 to nil--but in a way that errors don't know about.
1916 That way, if there's an error in them, they will stay nil. */
1917 before_change_functions
= Vbefore_change_functions
;
1918 after_change_functions
= Vafter_change_functions
;
1919 Vbefore_change_functions
= Qnil
;
1920 Vafter_change_functions
= Qnil
;
1921 GCPRO2 (before_change_functions
, after_change_functions
);
1923 /* Actually run the hook functions. */
1924 args
[0] = Qbefore_change_functions
;
1925 args
[1] = FETCH_START
;
1926 args
[2] = FETCH_END
;
1927 run_hook_list_with_args (before_change_functions
, 3, args
);
1929 /* "Unbind" the variables we "bound" to nil. Beware a
1930 buffer-local hook which changes the buffer when run (e.g. W3). */
1931 if (old
!= current_buffer
)
1933 new = current_buffer
;
1934 set_buffer_internal (old
);
1935 Vbefore_change_functions
= before_change_functions
;
1936 Vafter_change_functions
= after_change_functions
;
1937 set_buffer_internal (new);
1941 Vbefore_change_functions
= before_change_functions
;
1942 Vafter_change_functions
= after_change_functions
;
1947 if (!NILP (current_buffer
->overlays_before
)
1948 || !NILP (current_buffer
->overlays_after
))
1951 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1952 FETCH_START
, FETCH_END
, Qnil
);
1955 if (! NILP (start_marker
))
1956 free_marker (start_marker
);
1957 if (! NILP (end_marker
))
1958 free_marker (end_marker
);
1963 /* Signal a change immediately after it happens.
1964 CHARPOS is the character position of the start of the changed text.
1965 LENDEL is the number of characters of the text before the change.
1966 (Not the whole buffer; just the part that was changed.)
1967 LENINS is the number of characters in that part of the text
1968 after the change. */
1971 signal_after_change (charpos
, lendel
, lenins
)
1972 int charpos
, lendel
, lenins
;
1974 if (inhibit_modification_hooks
)
1977 /* If we are deferring calls to the after-change functions
1978 and there are no before-change functions,
1979 just record the args that we were going to use. */
1980 if (! NILP (Vcombine_after_change_calls
)
1981 && NILP (Vbefore_change_functions
)
1982 && NILP (current_buffer
->overlays_before
)
1983 && NILP (current_buffer
->overlays_after
))
1987 if (!NILP (combine_after_change_list
)
1988 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
1989 Fcombine_after_change_execute ();
1991 elt
= Fcons (make_number (charpos
- BEG
),
1992 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
1993 Fcons (make_number (lenins
- lendel
), Qnil
)));
1994 combine_after_change_list
1995 = Fcons (elt
, combine_after_change_list
);
1996 combine_after_change_buffer
= Fcurrent_buffer ();
2001 if (!NILP (combine_after_change_list
))
2002 Fcombine_after_change_execute ();
2004 if (!NILP (Vafter_change_functions
))
2006 Lisp_Object args
[4];
2007 Lisp_Object before_change_functions
;
2008 Lisp_Object after_change_functions
;
2009 struct buffer
*old
= current_buffer
;
2011 struct gcpro gcpro1
, gcpro2
;
2013 /* "Bind" before-change-functions and after-change-functions
2014 to nil--but in a way that errors don't know about.
2015 That way, if there's an error in them, they will stay nil. */
2016 before_change_functions
= Vbefore_change_functions
;
2017 after_change_functions
= Vafter_change_functions
;
2018 Vbefore_change_functions
= Qnil
;
2019 Vafter_change_functions
= Qnil
;
2020 GCPRO2 (before_change_functions
, after_change_functions
);
2022 /* Actually run the hook functions. */
2023 args
[0] = Qafter_change_functions
;
2024 XSETFASTINT (args
[1], charpos
);
2025 XSETFASTINT (args
[2], charpos
+ lenins
);
2026 XSETFASTINT (args
[3], lendel
);
2027 run_hook_list_with_args (after_change_functions
,
2030 /* "Unbind" the variables we "bound" to nil. Beware a
2031 buffer-local hook which changes the buffer when run (e.g. W3). */
2032 if (old
!= current_buffer
)
2034 new = current_buffer
;
2035 set_buffer_internal (old
);
2036 Vbefore_change_functions
= before_change_functions
;
2037 Vafter_change_functions
= after_change_functions
;
2038 set_buffer_internal (new);
2042 Vbefore_change_functions
= before_change_functions
;
2043 Vafter_change_functions
= after_change_functions
;
2048 if (!NILP (current_buffer
->overlays_before
)
2049 || !NILP (current_buffer
->overlays_after
))
2050 report_overlay_modification (make_number (charpos
),
2051 make_number (charpos
+ lenins
),
2053 make_number (charpos
),
2054 make_number (charpos
+ lenins
),
2055 make_number (lendel
));
2057 /* After an insertion, call the text properties
2058 insert-behind-hooks or insert-in-front-hooks. */
2060 report_interval_modification (make_number (charpos
),
2061 make_number (charpos
+ lenins
));
2065 Fcombine_after_change_execute_1 (val
)
2068 Vcombine_after_change_calls
= val
;
2072 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2073 Scombine_after_change_execute
, 0, 0, 0,
2074 "This function is for use internally in `combine-after-change-calls'.")
2077 int count
= specpdl_ptr
- specpdl
;
2078 int beg
, end
, change
;
2082 if (NILP (combine_after_change_list
))
2085 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2087 Fset_buffer (combine_after_change_buffer
);
2089 /* # chars unchanged at beginning of buffer. */
2091 /* # chars unchanged at end of buffer. */
2093 /* Total amount of insertion (negative for deletion). */
2096 /* Scan the various individual changes,
2097 accumulating the range info in BEG, END and CHANGE. */
2098 for (tail
= combine_after_change_list
; CONSP (tail
);
2102 int thisbeg
, thisend
, thischange
;
2104 /* Extract the info from the next element. */
2108 thisbeg
= XINT (XCAR (elt
));
2113 thisend
= XINT (XCAR (elt
));
2118 thischange
= XINT (XCAR (elt
));
2120 /* Merge this range into the accumulated range. */
2121 change
+= thischange
;
2128 /* Get the current start and end positions of the range
2129 that was changed. */
2133 /* We are about to handle these, so discard them. */
2134 combine_after_change_list
= Qnil
;
2136 /* Now run the after-change functions for real.
2137 Turn off the flag that defers them. */
2138 record_unwind_protect (Fcombine_after_change_execute_1
,
2139 Vcombine_after_change_calls
);
2140 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2141 update_compositions (begpos
, endpos
, CHECK_ALL
);
2143 return unbind_to (count
, Qnil
);
2149 staticpro (&combine_after_change_list
);
2150 combine_after_change_list
= Qnil
;
2151 combine_after_change_buffer
= Qnil
;
2153 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2154 "Non-nil means enable debugging checks for invalid marker positions.");
2155 check_markers_debug_flag
= 0;
2156 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2157 "Used internally by the `combine-after-change-calls' macro.");
2158 Vcombine_after_change_calls
= Qnil
;
2160 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2161 "Non-nil means don't run any of the hooks that respond to buffer changes.\n\
2162 This affects `before-change-functions' and `after-change-functions',\n\
2163 as well as hooks attached to text properties and overlays.");
2164 inhibit_modification_hooks
= 0;
2165 Qinhibit_modification_hooks
= intern ("inhibit-modification-hooks");
2166 staticpro (&Qinhibit_modification_hooks
);
2168 defsubr (&Scombine_after_change_execute
);