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 #define min(x, y) ((x) < (y) ? (x) : (y))
37 #define max(x, y) ((x) > (y) ? (x) : (y))
39 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
40 static void insert_from_buffer_1 ();
41 static void gap_left
P_ ((int, int, int));
42 static void gap_right
P_ ((int, int));
43 static void adjust_markers_gap_motion
P_ ((int, int, int));
44 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
45 void adjust_markers_for_delete
P_ ((int, int, int, int));
46 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
47 static void adjust_point
P_ ((int, int));
49 Lisp_Object
Fcombine_after_change_execute ();
51 /* Non-nil means don't call the after-change-functions right away,
52 just record an element in Vcombine_after_change_calls_list. */
53 Lisp_Object Vcombine_after_change_calls
;
55 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
56 describing changes which happened while combine_after_change_calls
57 was nonzero. We use this to decide how to call them
58 once the deferral ends.
61 BEG-UNCHANGED is the number of chars before the changed range.
62 END-UNCHANGED is the number of chars after the changed range,
63 and CHANGE-AMOUNT is the number of characters inserted by the change
64 (negative for a deletion). */
65 Lisp_Object combine_after_change_list
;
67 /* Buffer which combine_after_change_list is about. */
68 Lisp_Object combine_after_change_buffer
;
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 >= ((unsigned) 1 << (min (BITS_PER_INT
, VALBITS
) - 1)))
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
;
916 if (NILP (current_buffer
->enable_multibyte_characters
))
920 /* Do this before moving and increasing the gap,
921 because the before-change hooks might move the gap
922 or make it smaller. */
923 prepare_to_modify_buffer (PT
, PT
, NULL
);
926 move_gap_both (PT
, PT_BYTE
);
927 if (GAP_SIZE
< nbytes
)
928 make_gap (nbytes
- GAP_SIZE
);
930 #ifdef BYTE_COMBINING_DEBUG
931 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
932 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
936 /* Record deletion of the surrounding text that combines with
937 the insertion. This, together with recording the insertion,
938 will add up to the right stuff in the undo list. */
939 record_insert (PT
, nchars
);
942 bcopy (string
, GPT_ADDR
, nbytes
);
951 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
956 adjust_overlays_for_insert (PT
, nchars
);
957 adjust_markers_for_insert (PT
, PT_BYTE
,
958 PT
+ nchars
, PT_BYTE
+ nbytes
,
961 if (BUF_INTERVALS (current_buffer
) != 0)
962 offset_intervals (current_buffer
, PT
, nchars
);
964 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
965 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
968 adjust_point (nchars
, nbytes
);
973 /* Insert the part of the text of STRING, a Lisp object assumed to be
974 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
975 starting at position POS / POS_BYTE. If the text of STRING has properties,
976 copy them into the buffer.
978 It does not work to use `insert' for this, because a GC could happen
979 before we bcopy the stuff into the buffer, and relocate the string
980 without insert noticing. */
983 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
985 register int pos
, pos_byte
, length
, length_byte
;
989 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
991 signal_after_change (opoint
, 0, PT
- opoint
);
992 update_compositions (opoint
, PT
, CHECK_BORDER
);
995 /* Like `insert_from_string' except that all markers pointing
996 at the place where the insertion happens are adjusted to point after it. */
999 insert_from_string_before_markers (string
, pos
, pos_byte
,
1000 length
, length_byte
, inherit
)
1002 register int pos
, pos_byte
, length
, length_byte
;
1006 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1008 signal_after_change (opoint
, 0, PT
- opoint
);
1009 update_compositions (opoint
, PT
, CHECK_BORDER
);
1012 /* Subroutine of the insertion functions above. */
1015 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1016 inherit
, before_markers
)
1018 register int pos
, pos_byte
, nchars
, nbytes
;
1019 int inherit
, before_markers
;
1021 struct gcpro gcpro1
;
1022 int outgoing_nbytes
= nbytes
;
1025 /* Make OUTGOING_NBYTES describe the text
1026 as it will be inserted in this buffer. */
1028 if (NILP (current_buffer
->enable_multibyte_characters
))
1029 outgoing_nbytes
= nchars
;
1030 else if (! STRING_MULTIBYTE (string
))
1032 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1036 /* Do this before moving and increasing the gap,
1037 because the before-change hooks might move the gap
1038 or make it smaller. */
1039 prepare_to_modify_buffer (PT
, PT
, NULL
);
1042 move_gap_both (PT
, PT_BYTE
);
1043 if (GAP_SIZE
< outgoing_nbytes
)
1044 make_gap (outgoing_nbytes
- GAP_SIZE
);
1047 /* Copy the string text into the buffer, perhaps converting
1048 between single-byte and multibyte. */
1049 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1050 STRING_MULTIBYTE (string
),
1051 ! NILP (current_buffer
->enable_multibyte_characters
));
1053 #ifdef BYTE_COMBINING_DEBUG
1054 /* We have copied text into the gap, but we have not altered
1055 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1056 to these functions and get the same results as we would
1057 have got earlier on. Meanwhile, PT_ADDR does point to
1058 the text that has been stored by copy_text. */
1059 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1060 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1064 record_insert (PT
, nchars
);
1067 GAP_SIZE
-= outgoing_nbytes
;
1071 GPT_BYTE
+= outgoing_nbytes
;
1072 ZV_BYTE
+= outgoing_nbytes
;
1073 Z_BYTE
+= outgoing_nbytes
;
1074 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1079 adjust_overlays_for_insert (PT
, nchars
);
1080 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1081 PT_BYTE
+ outgoing_nbytes
,
1084 offset_intervals (current_buffer
, PT
, nchars
);
1086 intervals
= XSTRING (string
)->intervals
;
1087 /* Get the intervals for the part of the string we are inserting. */
1088 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1089 intervals
= copy_intervals (intervals
, pos
, nchars
);
1091 /* Insert those intervals. */
1092 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1093 current_buffer
, inherit
);
1095 adjust_point (nchars
, outgoing_nbytes
);
1098 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1099 current buffer. If the text in BUF has properties, they are absorbed
1100 into the current buffer.
1102 It does not work to use `insert' for this, because a malloc could happen
1103 and relocate BUF's text before the bcopy happens. */
1106 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1108 int charpos
, nchars
;
1113 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1114 signal_after_change (opoint
, 0, PT
- opoint
);
1115 update_compositions (opoint
, PT
, CHECK_BORDER
);
1119 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1124 register Lisp_Object temp
;
1125 int chunk
, chunk_expanded
;
1126 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1127 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1128 int incoming_nbytes
= to_byte
- from_byte
;
1129 int outgoing_nbytes
= incoming_nbytes
;
1132 /* Make OUTGOING_NBYTES describe the text
1133 as it will be inserted in this buffer. */
1135 if (NILP (current_buffer
->enable_multibyte_characters
))
1136 outgoing_nbytes
= nchars
;
1137 else if (NILP (buf
->enable_multibyte_characters
))
1139 int outgoing_before_gap
= 0;
1140 int outgoing_after_gap
= 0;
1142 if (from
< BUF_GPT (buf
))
1144 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1145 if (chunk
> incoming_nbytes
)
1146 chunk
= incoming_nbytes
;
1148 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1154 if (chunk
< incoming_nbytes
)
1156 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1158 incoming_nbytes
- chunk
);
1160 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1163 /* Make sure point-max won't overflow after this insertion. */
1164 XSETINT (temp
, outgoing_nbytes
+ Z
);
1165 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1166 error ("Maximum buffer size exceeded");
1168 /* Do this before moving and increasing the gap,
1169 because the before-change hooks might move the gap
1170 or make it smaller. */
1171 prepare_to_modify_buffer (PT
, PT
, NULL
);
1174 move_gap_both (PT
, PT_BYTE
);
1175 if (GAP_SIZE
< outgoing_nbytes
)
1176 make_gap (outgoing_nbytes
- GAP_SIZE
);
1178 if (from
< BUF_GPT (buf
))
1180 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1181 if (chunk
> incoming_nbytes
)
1182 chunk
= incoming_nbytes
;
1183 /* Record number of output bytes, so we know where
1184 to put the output from the second copy_text. */
1186 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1188 ! NILP (buf
->enable_multibyte_characters
),
1189 ! NILP (current_buffer
->enable_multibyte_characters
));
1192 chunk_expanded
= chunk
= 0;
1194 if (chunk
< incoming_nbytes
)
1195 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1196 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1197 ! NILP (buf
->enable_multibyte_characters
),
1198 ! NILP (current_buffer
->enable_multibyte_characters
));
1200 #ifdef BYTE_COMBINING_DEBUG
1201 /* We have copied text into the gap, but we have not altered
1202 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1203 to these functions and get the same results as we would
1204 have got earlier on. Meanwhile, GPT_ADDR does point to
1205 the text that has been stored by copy_text. */
1206 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1207 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1211 record_insert (PT
, nchars
);
1214 GAP_SIZE
-= outgoing_nbytes
;
1218 GPT_BYTE
+= outgoing_nbytes
;
1219 ZV_BYTE
+= outgoing_nbytes
;
1220 Z_BYTE
+= outgoing_nbytes
;
1221 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1226 adjust_overlays_for_insert (PT
, nchars
);
1227 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1228 PT_BYTE
+ outgoing_nbytes
,
1231 if (BUF_INTERVALS (current_buffer
) != 0)
1232 offset_intervals (current_buffer
, PT
, nchars
);
1234 /* Get the intervals for the part of the string we are inserting. */
1235 intervals
= BUF_INTERVALS (buf
);
1236 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1238 if (buf
== current_buffer
&& PT
<= from
)
1240 intervals
= copy_intervals (intervals
, from
, nchars
);
1243 /* Insert those intervals. */
1244 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1246 adjust_point (nchars
, outgoing_nbytes
);
1249 /* Record undo information and adjust markers and position keepers for
1250 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1251 chars (LEN_BYTE bytes) which resides in the gap just after
1254 PREV_TEXT nil means the new text was just inserted. */
1257 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1258 int from
, from_byte
, len
, len_byte
;
1259 Lisp_Object prev_text
;
1261 int nchars_del
= 0, nbytes_del
= 0;
1263 #ifdef BYTE_COMBINING_DEBUG
1264 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1265 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1269 if (STRINGP (prev_text
))
1271 nchars_del
= XSTRING (prev_text
)->size
;
1272 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1275 /* Update various buffer positions for the new text. */
1276 GAP_SIZE
-= len_byte
;
1278 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1279 GPT
+= len
; GPT_BYTE
+= len_byte
;
1280 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1283 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1286 adjust_markers_for_insert (from
, from_byte
,
1287 from
+ len
, from_byte
+ len_byte
, 0);
1289 if (! EQ (current_buffer
->undo_list
, Qt
))
1292 record_delete (from
, prev_text
);
1293 record_insert (from
, len
);
1296 if (len
> nchars_del
)
1297 adjust_overlays_for_insert (from
, len
- nchars_del
);
1298 else if (len
< nchars_del
)
1299 adjust_overlays_for_delete (from
, nchars_del
- len
);
1300 if (BUF_INTERVALS (current_buffer
) != 0)
1302 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1306 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1308 /* As byte combining will decrease Z, we must check this again. */
1309 if (Z
- GPT
< END_UNCHANGED
)
1310 END_UNCHANGED
= Z
- GPT
;
1315 evaporate_overlays (from
);
1319 /* Record undo information, adjust markers and position keepers for an
1320 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1321 text already exists in the current buffer but character length (TO
1322 - FROM) may be incorrect, the correct length is NEWLEN. */
1325 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1326 int from
, from_byte
, to
, to_byte
, newlen
;
1328 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1331 move_gap_both (to
, to_byte
);
1332 GAP_SIZE
+= len_byte
;
1333 GPT
-= len
; GPT_BYTE
-= len_byte
;
1334 ZV
-= len
; ZV_BYTE
-= len_byte
;
1335 Z
-= len
; Z_BYTE
-= len_byte
;
1336 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1339 /* Replace the text from character positions FROM to TO with NEW,
1340 If PREPARE is nonzero, call prepare_to_modify_buffer.
1341 If INHERIT, the newly inserted text should inherit text properties
1342 from the surrounding non-deleted text. */
1344 /* Note that this does not yet handle markers quite right.
1345 Also it needs to record a single undo-entry that does a replacement
1346 rather than a separate delete and insert.
1347 That way, undo will also handle markers properly.
1349 But if MARKERS is 0, don't relocate markers. */
1352 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1354 int from
, to
, prepare
, inherit
, markers
;
1356 int inschars
= XSTRING (new)->size
;
1357 int insbytes
= STRING_BYTES (XSTRING (new));
1358 int from_byte
, to_byte
;
1359 int nbytes_del
, nchars_del
;
1360 register Lisp_Object temp
;
1361 struct gcpro gcpro1
;
1363 int outgoing_insbytes
= insbytes
;
1364 Lisp_Object deletion
;
1373 int range_length
= to
- from
;
1374 prepare_to_modify_buffer (from
, to
, &from
);
1375 to
= from
+ range_length
;
1380 /* Make args be valid */
1386 from_byte
= CHAR_TO_BYTE (from
);
1387 to_byte
= CHAR_TO_BYTE (to
);
1389 nchars_del
= to
- from
;
1390 nbytes_del
= to_byte
- from_byte
;
1392 if (nbytes_del
<= 0 && insbytes
== 0)
1395 /* Make OUTGOING_INSBYTES describe the text
1396 as it will be inserted in this buffer. */
1398 if (NILP (current_buffer
->enable_multibyte_characters
))
1399 outgoing_insbytes
= inschars
;
1400 else if (! STRING_MULTIBYTE (new))
1402 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1404 /* Make sure point-max won't overflow after this insertion. */
1405 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1406 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1407 error ("Maximum buffer size exceeded");
1411 /* Make sure the gap is somewhere in or next to what we are deleting. */
1413 gap_right (from
, from_byte
);
1415 gap_left (to
, to_byte
, 0);
1417 /* Even if we don't record for undo, we must keep the original text
1418 because we may have to recover it because of inappropriate byte
1420 if (! EQ (current_buffer
->undo_list
, Qt
))
1421 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1424 /* Relocate all markers pointing into the new, larger gap
1425 to point at the end of the text before the gap.
1426 Do this before recording the deletion,
1427 so that undo handles this after reinserting the text. */
1428 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1430 GAP_SIZE
+= nbytes_del
;
1433 ZV_BYTE
-= nbytes_del
;
1434 Z_BYTE
-= nbytes_del
;
1436 GPT_BYTE
= from_byte
;
1437 *(GPT_ADDR
) = 0; /* Put an anchor. */
1442 if (GPT
- BEG
< BEG_UNCHANGED
)
1443 BEG_UNCHANGED
= GPT
- BEG
;
1444 if (Z
- GPT
< END_UNCHANGED
)
1445 END_UNCHANGED
= Z
- GPT
;
1447 if (GAP_SIZE
< insbytes
)
1448 make_gap (insbytes
- GAP_SIZE
);
1450 /* Copy the string text into the buffer, perhaps converting
1451 between single-byte and multibyte. */
1452 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1453 STRING_MULTIBYTE (new),
1454 ! NILP (current_buffer
->enable_multibyte_characters
));
1456 #ifdef BYTE_COMBINING_DEBUG
1457 /* We have copied text into the gap, but we have not marked
1458 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1459 here, for both the previous text and the following text.
1460 Meanwhile, GPT_ADDR does point to
1461 the text that has been stored by copy_text. */
1462 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1463 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1467 if (! EQ (current_buffer
->undo_list
, Qt
))
1469 record_delete (from
, deletion
);
1470 record_insert (from
, inschars
);
1473 GAP_SIZE
-= outgoing_insbytes
;
1477 GPT_BYTE
+= outgoing_insbytes
;
1478 ZV_BYTE
+= outgoing_insbytes
;
1479 Z_BYTE
+= outgoing_insbytes
;
1480 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1485 /* Adjust the overlay center as needed. This must be done after
1486 adjusting the markers that bound the overlays. */
1487 adjust_overlays_for_delete (from
, nchars_del
);
1488 adjust_overlays_for_insert (from
, inschars
);
1490 adjust_markers_for_insert (from
, from_byte
,
1491 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1494 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1496 /* Get the intervals for the part of the string we are inserting--
1497 not including the combined-before bytes. */
1498 intervals
= XSTRING (new)->intervals
;
1499 /* Insert those intervals. */
1500 graft_intervals_into_buffer (intervals
, from
, inschars
,
1501 current_buffer
, inherit
);
1503 /* Relocate point as if it were a marker. */
1505 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1506 (from_byte
+ outgoing_insbytes
1507 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1509 if (outgoing_insbytes
== 0)
1510 evaporate_overlays (from
);
1517 signal_after_change (from
, nchars_del
, GPT
- from
);
1518 update_compositions (from
, GPT
, CHECK_BORDER
);
1521 /* Delete characters in current buffer
1522 from FROM up to (but not including) TO.
1523 If TO comes before FROM, we delete nothing. */
1526 del_range (from
, to
)
1527 register int from
, to
;
1529 del_range_1 (from
, to
, 1, 0);
1532 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1533 RET_STRING says to return the deleted text. */
1536 del_range_1 (from
, to
, prepare
, ret_string
)
1537 int from
, to
, prepare
, ret_string
;
1539 int from_byte
, to_byte
;
1540 Lisp_Object deletion
;
1541 struct gcpro gcpro1
;
1543 /* Make args be valid */
1554 int range_length
= to
- from
;
1555 prepare_to_modify_buffer (from
, to
, &from
);
1556 to
= min (ZV
, from
+ range_length
);
1559 from_byte
= CHAR_TO_BYTE (from
);
1560 to_byte
= CHAR_TO_BYTE (to
);
1562 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1564 signal_after_change (from
, to
- from
, 0);
1565 update_compositions (from
, from
, CHECK_HEAD
);
1570 /* Like del_range_1 but args are byte positions, not char positions. */
1573 del_range_byte (from_byte
, to_byte
, prepare
)
1574 int from_byte
, to_byte
, prepare
;
1578 /* Make args be valid */
1579 if (from_byte
< BEGV_BYTE
)
1580 from_byte
= BEGV_BYTE
;
1581 if (to_byte
> ZV_BYTE
)
1584 if (to_byte
<= from_byte
)
1587 from
= BYTE_TO_CHAR (from_byte
);
1588 to
= BYTE_TO_CHAR (to_byte
);
1592 int old_from
= from
, old_to
= Z
- to
;
1593 int range_length
= to
- from
;
1594 prepare_to_modify_buffer (from
, to
, &from
);
1595 to
= from
+ range_length
;
1597 if (old_from
!= from
)
1598 from_byte
= CHAR_TO_BYTE (from
);
1604 else if (old_to
== Z
- to
)
1605 to_byte
= CHAR_TO_BYTE (to
);
1608 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1609 signal_after_change (from
, to
- from
, 0);
1610 update_compositions (from
, from
, CHECK_HEAD
);
1613 /* Like del_range_1, but positions are specified both as charpos
1617 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1618 int from
, from_byte
, to
, to_byte
, prepare
;
1620 /* Make args be valid */
1621 if (from_byte
< BEGV_BYTE
)
1622 from_byte
= BEGV_BYTE
;
1623 if (to_byte
> ZV_BYTE
)
1626 if (to_byte
<= from_byte
)
1636 int old_from
= from
, old_to
= Z
- to
;
1637 int range_length
= to
- from
;
1638 prepare_to_modify_buffer (from
, to
, &from
);
1639 to
= from
+ range_length
;
1641 if (old_from
!= from
)
1642 from_byte
= CHAR_TO_BYTE (from
);
1648 else if (old_to
== Z
- to
)
1649 to_byte
= CHAR_TO_BYTE (to
);
1652 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1653 signal_after_change (from
, to
- from
, 0);
1654 update_compositions (from
, from
, CHECK_HEAD
);
1657 /* Delete a range of text, specified both as character positions
1658 and byte positions. FROM and TO are character positions,
1659 while FROM_BYTE and TO_BYTE are byte positions.
1660 If RET_STRING is true, the deleted area is returned as a string. */
1663 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1664 int from
, from_byte
, to
, to_byte
, ret_string
;
1666 register int nbytes_del
, nchars_del
;
1667 Lisp_Object deletion
;
1671 nchars_del
= to
- from
;
1672 nbytes_del
= to_byte
- from_byte
;
1674 /* Make sure the gap is somewhere in or next to what we are deleting. */
1676 gap_right (from
, from_byte
);
1678 gap_left (to
, to_byte
, 0);
1680 #ifdef BYTE_COMBINING_DEBUG
1681 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1682 Z_BYTE
- to_byte
, from
, from_byte
))
1686 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1687 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1691 /* Relocate all markers pointing into the new, larger gap
1692 to point at the end of the text before the gap.
1693 Do this before recording the deletion,
1694 so that undo handles this after reinserting the text. */
1695 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1697 if (! EQ (current_buffer
->undo_list
, Qt
))
1698 record_delete (from
, deletion
);
1701 /* Relocate point as if it were a marker. */
1703 adjust_point (from
- (PT
< to
? PT
: to
),
1704 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1706 offset_intervals (current_buffer
, from
, - nchars_del
);
1708 /* Adjust the overlay center as needed. This must be done after
1709 adjusting the markers that bound the overlays. */
1710 adjust_overlays_for_delete (from
, nchars_del
);
1712 GAP_SIZE
+= nbytes_del
;
1713 ZV_BYTE
-= nbytes_del
;
1714 Z_BYTE
-= nbytes_del
;
1718 GPT_BYTE
= from_byte
;
1719 *(GPT_ADDR
) = 0; /* Put an anchor. */
1724 if (GPT
- BEG
< BEG_UNCHANGED
)
1725 BEG_UNCHANGED
= GPT
- BEG
;
1726 if (Z
- GPT
< END_UNCHANGED
)
1727 END_UNCHANGED
= Z
- GPT
;
1731 evaporate_overlays (from
);
1736 /* Call this if you're about to change the region of BUFFER from
1737 character positions START to END. This checks the read-only
1738 properties of the region, calls the necessary modification hooks,
1739 and warns the next redisplay that it should pay attention to that
1743 modify_region (buffer
, start
, end
)
1744 struct buffer
*buffer
;
1747 struct buffer
*old_buffer
= current_buffer
;
1749 if (buffer
!= old_buffer
)
1750 set_buffer_internal (buffer
);
1752 prepare_to_modify_buffer (start
, end
, NULL
);
1754 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1756 if (MODIFF
<= SAVE_MODIFF
)
1757 record_first_change ();
1760 buffer
->point_before_scroll
= Qnil
;
1762 if (buffer
!= old_buffer
)
1763 set_buffer_internal (old_buffer
);
1766 /* Check that it is okay to modify the buffer between START and END,
1767 which are char positions.
1769 Run the before-change-function, if any. If intervals are in use,
1770 verify that the text to be modified is not read-only, and call
1771 any modification properties the text may have.
1773 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1774 by holding its value temporarily in a marker. */
1777 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1781 if (!NILP (current_buffer
->read_only
))
1782 Fbarf_if_buffer_read_only ();
1784 /* Let redisplay consider other windows than selected_window
1785 if modifying another buffer. */
1786 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1787 ++windows_or_buffers_changed
;
1789 if (BUF_INTERVALS (current_buffer
) != 0)
1793 Lisp_Object preserve_marker
;
1794 struct gcpro gcpro1
;
1795 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1796 GCPRO1 (preserve_marker
);
1797 verify_interval_modification (current_buffer
, start
, end
);
1798 *preserve_ptr
= marker_position (preserve_marker
);
1799 unchain_marker (preserve_marker
);
1803 verify_interval_modification (current_buffer
, start
, end
);
1806 #ifdef CLASH_DETECTION
1807 if (!NILP (current_buffer
->file_truename
)
1808 /* Make binding buffer-file-name to nil effective. */
1809 && !NILP (current_buffer
->filename
)
1810 && SAVE_MODIFF
>= MODIFF
)
1811 lock_file (current_buffer
->file_truename
);
1813 /* At least warn if this file has changed on disk since it was visited. */
1814 if (!NILP (current_buffer
->filename
)
1815 && SAVE_MODIFF
>= MODIFF
1816 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1817 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1818 call1 (intern ("ask-user-about-supersession-threat"),
1819 current_buffer
->filename
);
1820 #endif /* not CLASH_DETECTION */
1822 signal_before_change (start
, end
, preserve_ptr
);
1824 if (current_buffer
->newline_cache
)
1825 invalidate_region_cache (current_buffer
,
1826 current_buffer
->newline_cache
,
1827 start
- BEG
, Z
- end
);
1828 if (current_buffer
->width_run_cache
)
1829 invalidate_region_cache (current_buffer
,
1830 current_buffer
->width_run_cache
,
1831 start
- BEG
, Z
- end
);
1833 Vdeactivate_mark
= Qt
;
1836 /* These macros work with an argument named `preserve_ptr'
1837 and a local variable named `preserve_marker'. */
1839 #define PRESERVE_VALUE \
1840 if (preserve_ptr && NILP (preserve_marker)) \
1841 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1843 #define RESTORE_VALUE \
1844 if (! NILP (preserve_marker)) \
1846 *preserve_ptr = marker_position (preserve_marker); \
1847 unchain_marker (preserve_marker); \
1850 #define PRESERVE_START_END \
1851 if (NILP (start_marker)) \
1852 start_marker = Fcopy_marker (start, Qnil); \
1853 if (NILP (end_marker)) \
1854 end_marker = Fcopy_marker (end, Qnil);
1856 #define FETCH_START \
1857 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1860 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1862 /* Signal a change to the buffer immediately before it happens.
1863 START_INT and END_INT are the bounds of the text to be changed.
1865 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1866 by holding its value temporarily in a marker. */
1869 signal_before_change (start_int
, end_int
, preserve_ptr
)
1870 int start_int
, end_int
;
1873 Lisp_Object start
, end
;
1874 Lisp_Object start_marker
, end_marker
;
1875 Lisp_Object preserve_marker
;
1876 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1878 if (inhibit_modification_hooks
)
1881 start
= make_number (start_int
);
1882 end
= make_number (end_int
);
1883 preserve_marker
= Qnil
;
1884 start_marker
= Qnil
;
1886 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1888 /* If buffer is unmodified, run a special hook for that case. */
1889 if (SAVE_MODIFF
>= MODIFF
1890 && !NILP (Vfirst_change_hook
)
1891 && !NILP (Vrun_hooks
))
1895 call1 (Vrun_hooks
, Qfirst_change_hook
);
1898 /* Now run the before-change-functions if any. */
1899 if (!NILP (Vbefore_change_functions
))
1901 Lisp_Object args
[3];
1902 Lisp_Object before_change_functions
;
1903 Lisp_Object after_change_functions
;
1904 struct gcpro gcpro1
, gcpro2
;
1905 struct buffer
*old
= current_buffer
;
1911 /* "Bind" before-change-functions and after-change-functions
1912 to nil--but in a way that errors don't know about.
1913 That way, if there's an error in them, they will stay nil. */
1914 before_change_functions
= Vbefore_change_functions
;
1915 after_change_functions
= Vafter_change_functions
;
1916 Vbefore_change_functions
= Qnil
;
1917 Vafter_change_functions
= Qnil
;
1918 GCPRO2 (before_change_functions
, after_change_functions
);
1920 /* Actually run the hook functions. */
1921 args
[0] = Qbefore_change_functions
;
1922 args
[1] = FETCH_START
;
1923 args
[2] = FETCH_END
;
1924 run_hook_list_with_args (before_change_functions
, 3, args
);
1926 /* "Unbind" the variables we "bound" to nil. Beware a
1927 buffer-local hook which changes the buffer when run (e.g. W3). */
1928 if (old
!= current_buffer
)
1930 new = current_buffer
;
1931 set_buffer_internal (old
);
1932 Vbefore_change_functions
= before_change_functions
;
1933 Vafter_change_functions
= after_change_functions
;
1934 set_buffer_internal (new);
1938 Vbefore_change_functions
= before_change_functions
;
1939 Vafter_change_functions
= after_change_functions
;
1944 if (!NILP (current_buffer
->overlays_before
)
1945 || !NILP (current_buffer
->overlays_after
))
1948 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1949 FETCH_START
, FETCH_END
, Qnil
);
1952 if (! NILP (start_marker
))
1953 free_marker (start_marker
);
1954 if (! NILP (end_marker
))
1955 free_marker (end_marker
);
1960 /* Signal a change immediately after it happens.
1961 CHARPOS is the character position of the start of the changed text.
1962 LENDEL is the number of characters of the text before the change.
1963 (Not the whole buffer; just the part that was changed.)
1964 LENINS is the number of characters in that part of the text
1965 after the change. */
1968 signal_after_change (charpos
, lendel
, lenins
)
1969 int charpos
, lendel
, lenins
;
1971 if (inhibit_modification_hooks
)
1974 /* If we are deferring calls to the after-change functions
1975 and there are no before-change functions,
1976 just record the args that we were going to use. */
1977 if (! NILP (Vcombine_after_change_calls
)
1978 && NILP (Vbefore_change_functions
)
1979 && NILP (current_buffer
->overlays_before
)
1980 && NILP (current_buffer
->overlays_after
))
1984 if (!NILP (combine_after_change_list
)
1985 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
1986 Fcombine_after_change_execute ();
1988 elt
= Fcons (make_number (charpos
- BEG
),
1989 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
1990 Fcons (make_number (lenins
- lendel
), Qnil
)));
1991 combine_after_change_list
1992 = Fcons (elt
, combine_after_change_list
);
1993 combine_after_change_buffer
= Fcurrent_buffer ();
1998 if (!NILP (combine_after_change_list
))
1999 Fcombine_after_change_execute ();
2001 if (!NILP (Vafter_change_functions
))
2003 Lisp_Object args
[4];
2004 Lisp_Object before_change_functions
;
2005 Lisp_Object after_change_functions
;
2006 struct buffer
*old
= current_buffer
;
2008 struct gcpro gcpro1
, gcpro2
;
2010 /* "Bind" before-change-functions and after-change-functions
2011 to nil--but in a way that errors don't know about.
2012 That way, if there's an error in them, they will stay nil. */
2013 before_change_functions
= Vbefore_change_functions
;
2014 after_change_functions
= Vafter_change_functions
;
2015 Vbefore_change_functions
= Qnil
;
2016 Vafter_change_functions
= Qnil
;
2017 GCPRO2 (before_change_functions
, after_change_functions
);
2019 /* Actually run the hook functions. */
2020 args
[0] = Qafter_change_functions
;
2021 XSETFASTINT (args
[1], charpos
);
2022 XSETFASTINT (args
[2], charpos
+ lenins
);
2023 XSETFASTINT (args
[3], lendel
);
2024 run_hook_list_with_args (after_change_functions
,
2027 /* "Unbind" the variables we "bound" to nil. Beware a
2028 buffer-local hook which changes the buffer when run (e.g. W3). */
2029 if (old
!= current_buffer
)
2031 new = current_buffer
;
2032 set_buffer_internal (old
);
2033 Vbefore_change_functions
= before_change_functions
;
2034 Vafter_change_functions
= after_change_functions
;
2035 set_buffer_internal (new);
2039 Vbefore_change_functions
= before_change_functions
;
2040 Vafter_change_functions
= after_change_functions
;
2045 if (!NILP (current_buffer
->overlays_before
)
2046 || !NILP (current_buffer
->overlays_after
))
2047 report_overlay_modification (make_number (charpos
),
2048 make_number (charpos
+ lenins
),
2050 make_number (charpos
),
2051 make_number (charpos
+ lenins
),
2052 make_number (lendel
));
2054 /* After an insertion, call the text properties
2055 insert-behind-hooks or insert-in-front-hooks. */
2057 report_interval_modification (make_number (charpos
),
2058 make_number (charpos
+ lenins
));
2062 Fcombine_after_change_execute_1 (val
)
2065 Vcombine_after_change_calls
= val
;
2069 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2070 Scombine_after_change_execute
, 0, 0, 0,
2071 "This function is for use internally in `combine-after-change-calls'.")
2074 int count
= specpdl_ptr
- specpdl
;
2075 int beg
, end
, change
;
2079 if (NILP (combine_after_change_list
))
2082 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2084 Fset_buffer (combine_after_change_buffer
);
2086 /* # chars unchanged at beginning of buffer. */
2088 /* # chars unchanged at end of buffer. */
2090 /* Total amount of insertion (negative for deletion). */
2093 /* Scan the various individual changes,
2094 accumulating the range info in BEG, END and CHANGE. */
2095 for (tail
= combine_after_change_list
; CONSP (tail
);
2099 int thisbeg
, thisend
, thischange
;
2101 /* Extract the info from the next element. */
2105 thisbeg
= XINT (XCAR (elt
));
2110 thisend
= XINT (XCAR (elt
));
2115 thischange
= XINT (XCAR (elt
));
2117 /* Merge this range into the accumulated range. */
2118 change
+= thischange
;
2125 /* Get the current start and end positions of the range
2126 that was changed. */
2130 /* We are about to handle these, so discard them. */
2131 combine_after_change_list
= Qnil
;
2133 /* Now run the after-change functions for real.
2134 Turn off the flag that defers them. */
2135 record_unwind_protect (Fcombine_after_change_execute_1
,
2136 Vcombine_after_change_calls
);
2137 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2138 update_compositions (begpos
, endpos
, CHECK_ALL
);
2140 return unbind_to (count
, Qnil
);
2146 staticpro (&combine_after_change_list
);
2147 combine_after_change_list
= Qnil
;
2148 combine_after_change_buffer
= Qnil
;
2150 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2151 "Non-nil means enable debugging checks for invalid marker positions.");
2152 check_markers_debug_flag
= 0;
2153 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2154 "Used internally by the `combine-after-change-calls' macro.");
2155 Vcombine_after_change_calls
= Qnil
;
2157 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2158 "Non-nil means don't run any of the hooks that respond to buffer changes.\n\
2159 This affects `before-change-functions' and `after-change-functions',\n\
2160 as well as hooks attached to text properties and overlays.");
2161 inhibit_modification_hooks
= 0;
2163 defsubr (&Scombine_after_change_execute
);