1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86, 93, 94, 95, 97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "intervals.h"
28 #include "blockinput.h"
29 #include "region-cache.h"
35 #define min(x, y) ((x) < (y) ? (x) : (y))
37 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
38 static void insert_from_buffer_1 ();
39 static void gap_left
P_ ((int, int, int));
40 static void gap_right
P_ ((int, int));
41 static void adjust_markers_gap_motion
P_ ((int, int, int));
42 static void adjust_markers_for_insert
P_ ((int, int, int, int, int, int, int));
43 static void adjust_markers_for_delete
P_ ((int, int, int, int));
44 static void adjust_markers_for_record_delete
P_ ((int, int, int, int));
45 static void adjust_point
P_ ((int, int));
47 Lisp_Object
Fcombine_after_change_execute ();
49 /* Non-nil means don't call the after-change-functions right away,
50 just record an element in Vcombine_after_change_calls_list. */
51 Lisp_Object Vcombine_after_change_calls
;
53 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
54 describing changes which happened while combine_after_change_calls
55 was nonzero. We use this to decide how to call them
56 once the deferral ends.
59 BEG-UNCHANGED is the number of chars before the changed range.
60 END-UNCHANGED is the number of chars after the changed range,
61 and CHANGE-AMOUNT is the number of characters inserted by the change
62 (negative for a deletion). */
63 Lisp_Object combine_after_change_list
;
65 /* Buffer which combine_after_change_list is about. */
66 Lisp_Object combine_after_change_buffer
;
68 /* Check all markers in the current buffer, looking for something invalid. */
70 static int check_markers_debug_flag
;
72 #define CHECK_MARKERS() \
73 if (check_markers_debug_flag) \
80 register Lisp_Object tail
, prev
, next
;
82 tail
= BUF_MARKERS (current_buffer
);
84 while (XSYMBOL (tail
) != XSYMBOL (Qnil
))
86 if (XMARKER (tail
)->buffer
->text
!= current_buffer
->text
)
88 if (XMARKER (tail
)->charpos
> Z
)
90 if (XMARKER (tail
)->bytepos
> Z_BYTE
)
93 tail
= XMARKER (tail
)->chain
;
97 /* Move gap to position CHARPOS.
98 Note that this can quit! */
104 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
107 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
108 Note that this can quit! */
111 move_gap_both (charpos
, bytepos
)
112 int charpos
, bytepos
;
114 if (bytepos
< GPT_BYTE
)
115 gap_left (charpos
, bytepos
, 0);
116 else if (bytepos
> GPT_BYTE
)
117 gap_right (charpos
, bytepos
);
120 /* Move the gap to a position less than the current GPT.
121 BYTEPOS describes the new position as a byte position,
122 and CHARPOS is the corresponding char position.
123 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
126 gap_left (charpos
, bytepos
, newgap
)
127 register int charpos
, bytepos
;
130 register unsigned char *to
, *from
;
136 if (unchanged_modified
== MODIFF
137 && overlay_unchanged_modified
== OVERLAY_MODIFF
)
139 beg_unchanged
= charpos
- BEG
;
140 end_unchanged
= Z
- charpos
;
144 if (Z
- GPT
< end_unchanged
)
145 end_unchanged
= Z
- GPT
;
146 if (charpos
< beg_unchanged
)
147 beg_unchanged
= charpos
- BEG
;
156 /* Now copy the characters. To move the gap down,
157 copy characters up. */
161 /* I gets number of characters left to copy. */
162 i
= new_s1
- bytepos
;
165 /* If a quit is requested, stop copying now.
166 Change BYTEPOS to be where we have actually moved the gap to. */
170 charpos
= BYTE_TO_CHAR (bytepos
);
173 /* Move at most 32000 chars before checking again for a quit. */
178 /* bcopy is safe if the two areas of memory do not overlap
179 or on systems where bcopy is always safe for moving upward. */
180 && (BCOPY_UPWARD_SAFE
181 || to
- from
>= 128))
183 /* If overlap is not safe, avoid it by not moving too many
184 characters at once. */
185 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
200 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
201 BYTEPOS is where the loop above stopped, which may be what was specified
202 or may be where a quit was detected. */
203 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
206 if (bytepos
< charpos
)
208 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
212 /* Move the gap to a position greater than than the current GPT.
213 BYTEPOS describes the new position as a byte position,
214 and CHARPOS is the corresponding char position. */
217 gap_right (charpos
, bytepos
)
218 register int charpos
, bytepos
;
220 register unsigned char *to
, *from
;
224 if (unchanged_modified
== MODIFF
225 && overlay_unchanged_modified
== OVERLAY_MODIFF
)
227 beg_unchanged
= charpos
- BEG
;
228 end_unchanged
= Z
- charpos
;
232 if (Z
- charpos
- 1 < end_unchanged
)
233 end_unchanged
= Z
- charpos
;
234 if (GPT
- BEG
< beg_unchanged
)
235 beg_unchanged
= GPT
- BEG
;
243 /* Now copy the characters. To move the gap up,
244 copy characters down. */
248 /* I gets number of characters left to copy. */
249 i
= bytepos
- new_s1
;
252 /* If a quit is requested, stop copying now.
253 Change BYTEPOS to be where we have actually moved the gap to. */
257 charpos
= BYTE_TO_CHAR (bytepos
);
260 /* Move at most 32000 chars before checking again for a quit. */
265 /* bcopy is safe if the two areas of memory do not overlap
266 or on systems where bcopy is always safe for moving downward. */
267 && (BCOPY_DOWNWARD_SAFE
268 || from
- to
>= 128))
270 /* If overlap is not safe, avoid it by not moving too many
271 characters at once. */
272 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
287 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
291 if (bytepos
< charpos
)
293 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
297 /* Add AMOUNT to the byte position of every marker in the current buffer
298 whose current byte position is between FROM (exclusive) and TO (inclusive).
300 Also, any markers past the outside of that interval, in the direction
301 of adjustment, are first moved back to the near end of the interval
302 and then adjusted by AMOUNT.
304 When the latter adjustment is done, if AMOUNT is negative,
305 we record the adjustment for undo. (This case happens only for
308 The markers' character positions are not altered,
309 because gap motion does not affect character positions. */
311 int adjust_markers_test
;
314 adjust_markers_gap_motion (from
, to
, amount
)
315 register int from
, to
, amount
;
317 /* Now that a marker has a bytepos, not counting the gap,
318 nothing needs to be done here. */
321 register struct Lisp_Marker
*m
;
324 marker
= BUF_MARKERS (current_buffer
);
326 while (!NILP (marker
))
328 m
= XMARKER (marker
);
332 if (mpos
> to
&& mpos
< to
+ amount
)
334 if (adjust_markers_test
)
341 /* Here's the case where a marker is inside text being deleted.
342 AMOUNT can be negative for gap motion, too,
343 but then this range contains no markers. */
344 if (mpos
> from
+ amount
&& mpos
<= from
)
346 if (adjust_markers_test
)
348 mpos
= from
+ amount
;
351 if (mpos
> from
&& mpos
<= to
)
359 /* Adjust all markers for a deletion
360 whose range in bytes is FROM_BYTE to TO_BYTE.
361 The range in charpos is FROM to TO.
363 This function assumes that the gap is adjacent to
364 or inside of the range being deleted. */
367 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
368 register int from
, from_byte
, to
, to_byte
;
371 register struct Lisp_Marker
*m
;
372 register int charpos
;
374 marker
= BUF_MARKERS (current_buffer
);
376 while (!NILP (marker
))
378 m
= XMARKER (marker
);
379 charpos
= m
->charpos
;
384 /* If the marker is after the deletion,
385 relocate by number of chars / bytes deleted. */
388 m
->charpos
-= to
- from
;
389 m
->bytepos
-= to_byte
- from_byte
;
392 /* Here's the case where a marker is inside text being deleted. */
393 else if (charpos
> from
)
395 record_marker_adjustment (marker
, from
- charpos
);
397 m
->bytepos
= from_byte
;
404 /* Adjust all markers for calling record_delete for combining bytes.
405 whose range in bytes is FROM_BYTE to TO_BYTE.
406 The range in charpos is FROM to TO. */
409 adjust_markers_for_record_delete (from
, from_byte
, to
, to_byte
)
410 register int from
, from_byte
, to
, to_byte
;
413 register struct Lisp_Marker
*m
;
414 register int charpos
;
416 marker
= BUF_MARKERS (current_buffer
);
418 while (!NILP (marker
))
420 m
= XMARKER (marker
);
421 charpos
= m
->charpos
;
423 /* If the marker is after the deletion,
424 relocate by number of chars / bytes deleted. */
427 /* Here's the case where a marker is inside text being deleted. */
428 else if (charpos
> from
)
429 record_marker_adjustment (marker
, from
- charpos
);
435 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
436 to TO / TO_BYTE. We have to relocate the charpos of every marker
437 that points after the insertion (but not their bytepos).
439 COMBINED_BEFORE_BYTES is the number of bytes at the start of the insertion
440 that combine into one character with the text before the insertion.
441 COMBINED_AFTER_BYTES is the number of bytes after the insertion
442 that combine into one character with the last inserted bytes.
444 When a marker points at the insertion point,
445 we advance it if either its insertion-type is t
446 or BEFORE_MARKERS is true. */
449 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
,
450 combined_before_bytes
, combined_after_bytes
,
452 register int from
, from_byte
, to
, to_byte
;
453 int combined_before_bytes
, combined_after_bytes
, before_markers
;
457 int nchars
= to
- from
;
458 int nbytes
= to_byte
- from_byte
;
460 marker
= BUF_MARKERS (current_buffer
);
462 while (!NILP (marker
))
464 register struct Lisp_Marker
*m
= XMARKER (marker
);
466 /* In a single-byte buffer, a marker's two positions must be equal.
467 (If this insertion is going to combine characters, Z will
468 become different from Z_BYTE, but they might be the same now.
469 If so, the two OLD positions of the marker should be equal.) */
472 if (m
->charpos
!= m
->bytepos
)
476 if (m
->bytepos
== from_byte
)
478 if (m
->insertion_type
|| before_markers
)
480 m
->bytepos
+= nbytes
+ combined_after_bytes
;
481 m
->charpos
+= nchars
+ !!combined_after_bytes
;
482 /* Point the marker before the combined character,
483 so that undoing the insertion puts it back where it was. */
484 if (combined_after_bytes
)
485 DEC_BOTH (m
->charpos
, m
->bytepos
);
486 if (m
->insertion_type
)
489 else if (combined_before_bytes
)
491 /* This marker doesn't "need relocation",
492 but don't leave it pointing in the middle of a character.
493 Point the marker after the combined character,
494 so that undoing the insertion puts it back where it was. */
496 /* Here we depend on the fact that the gap is after
497 all of the combining bytes that we are going to skip over. */
498 DEC_BOTH (m
->charpos
, m
->bytepos
);
499 INC_BOTH (m
->charpos
, m
->bytepos
);
502 /* If a marker was pointing into the combining bytes
503 after the insertion, don't leave it there
504 in the middle of a character. */
505 else if (combined_after_bytes
&& m
->bytepos
>= from_byte
506 && m
->bytepos
< from_byte
+ combined_after_bytes
)
508 /* Put it after the combining bytes. */
509 m
->bytepos
= to_byte
+ combined_after_bytes
;
511 /* Now move it back before the combined character,
512 so that undoing the insertion will put it where it was. */
513 DEC_BOTH (m
->charpos
, m
->bytepos
);
515 else if (m
->bytepos
> from_byte
)
517 m
->bytepos
+= nbytes
;
518 m
->charpos
+= nchars
;
524 /* Adjusting only markers whose insertion-type is t may result in
525 disordered overlays in the slot `overlays_before'. */
527 fix_overlays_before (current_buffer
, from
, to
);
530 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
532 This is used only when the value of point changes due to an insert
533 or delete; it does not represent a conceptual change in point as a
534 marker. In particular, point is not crossing any interval
535 boundaries, so there's no need to use the usual SET_PT macro. In
536 fact it would be incorrect to do so, because either the old or the
537 new value of point is out of sync with the current set of
541 adjust_point (nchars
, nbytes
)
544 BUF_PT (current_buffer
) += nchars
;
545 BUF_PT_BYTE (current_buffer
) += nbytes
;
547 /* In a single-byte buffer, the two positions must be equal. */
553 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
554 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
557 See the comment of adjust_markers_for_insert for the args
558 COMBINED_BEFORE_BYTES and COMBINED_AFTER_BYTES. */
561 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
562 new_chars
, new_bytes
,
563 combined_before_bytes
, combined_after_bytes
)
564 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
565 int combined_before_bytes
, combined_after_bytes
;
567 Lisp_Object marker
= BUF_MARKERS (current_buffer
);
568 int prev_to_byte
= from_byte
+ old_bytes
;
569 int diff_chars
= new_chars
- old_chars
;
570 int diff_bytes
= new_bytes
- old_bytes
;
572 while (!NILP (marker
))
574 register struct Lisp_Marker
*m
= XMARKER (marker
);
576 if (m
->bytepos
>= prev_to_byte
)
578 if (m
->bytepos
< prev_to_byte
+ combined_after_bytes
)
580 /* Put it after the combining bytes. */
581 m
->bytepos
= from_byte
+ new_bytes
;
582 m
->charpos
= from
+ new_chars
;
586 m
->charpos
+= diff_chars
;
587 m
->bytepos
+= diff_bytes
;
589 if (m
->charpos
== from
+ new_chars
)
590 record_marker_adjustment (marker
, - old_chars
);
592 else if (m
->bytepos
> from_byte
)
594 record_marker_adjustment (marker
, from
- m
->charpos
);
596 m
->bytepos
= from_byte
;
598 else if (m
->bytepos
== from_byte
)
600 if (combined_before_bytes
)
602 DEC_BOTH (m
->charpos
, m
->bytepos
);
603 INC_BOTH (m
->charpos
, m
->bytepos
);
612 /* Make the gap NBYTES_ADDED bytes longer. */
615 make_gap (nbytes_added
)
618 unsigned char *result
;
621 int real_gap_loc_byte
;
624 /* If we have to get more space, get enough to last a while. */
625 nbytes_added
+= 2000;
627 /* Don't allow a buffer size that won't fit in an int
628 even if it will fit in a Lisp integer.
629 That won't work because so many places use `int'. */
631 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
+ nbytes_added
632 >= ((unsigned) 1 << (min (BITS_PER_INT
, VALBITS
) - 1)))
633 error ("Buffer exceeds maximum size");
636 /* We allocate extra 1-byte `\0' at the tail for anchoring a search. */
637 result
= BUFFER_REALLOC (BEG_ADDR
, (Z_BYTE
- BEG_BYTE
638 + GAP_SIZE
+ nbytes_added
+ 1));
646 /* We can't unblock until the new address is properly stored. */
650 /* Prevent quitting in move_gap. */
655 real_gap_loc_byte
= GPT_BYTE
;
656 old_gap_size
= GAP_SIZE
;
658 /* Call the newly allocated space a gap at the end of the whole space. */
660 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
661 GAP_SIZE
= nbytes_added
;
663 /* Move the new gap down to be consecutive with the end of the old one.
664 This adjusts the markers properly too. */
665 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
667 /* Now combine the two into one large gap. */
668 GAP_SIZE
+= old_gap_size
;
670 GPT_BYTE
= real_gap_loc_byte
;
678 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
679 FROM_MULTIBYTE says whether the incoming text is multibyte.
680 TO_MULTIBYTE says whether to store the text as multibyte.
681 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
683 Return the number of bytes stored at TO_ADDR. */
686 copy_text (from_addr
, to_addr
, nbytes
,
687 from_multibyte
, to_multibyte
)
688 unsigned char *from_addr
;
689 unsigned char *to_addr
;
691 int from_multibyte
, to_multibyte
;
693 if (from_multibyte
== to_multibyte
)
695 bcopy (from_addr
, to_addr
, nbytes
);
698 else if (from_multibyte
)
701 int bytes_left
= nbytes
;
702 Lisp_Object tbl
= Qnil
, temp
;
704 /* We set the variable tbl to the reverse table of
705 Vnonascii_translation_table in advance. */
706 if (CHAR_TABLE_P (Vnonascii_translation_table
))
708 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
710 if (!CHAR_TABLE_P (tbl
))
714 /* Convert multibyte to single byte. */
715 while (bytes_left
> 0)
717 int thislen
, c
, c_save
;
718 c
= c_save
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
719 if (!SINGLE_BYTE_CHAR_P (c
))
720 c
= multibyte_char_to_unibyte (c
, tbl
);
722 from_addr
+= thislen
;
723 bytes_left
-= thislen
;
730 unsigned char *initial_to_addr
= to_addr
;
732 /* Convert single-byte to multibyte. */
735 int c
= *from_addr
++;
736 unsigned char workbuf
[4], *str
;
739 if (c
>= 0240 && c
< 0400)
741 c
= unibyte_char_to_multibyte (c
);
742 len
= CHAR_STRING (c
, workbuf
, str
);
743 bcopy (str
, to_addr
, len
);
748 /* Special case for speed. */
749 *to_addr
++ = c
, nbytes
--;
751 return to_addr
- initial_to_addr
;
755 /* Return the number of bytes it would take
756 to convert some single-byte text to multibyte.
757 The single-byte text consists of NBYTES bytes at PTR. */
760 count_size_as_multibyte (ptr
, nbytes
)
765 int outgoing_nbytes
= 0;
767 for (i
= 0; i
< nbytes
; i
++)
769 unsigned int c
= *ptr
++;
775 c
= unibyte_char_to_multibyte (c
);
776 outgoing_nbytes
+= CHAR_BYTES (c
);
780 return outgoing_nbytes
;
783 /* Insert a string of specified length before point.
784 This function judges multibyteness based on
785 enable_multibyte_characters in the current buffer;
786 it never converts between single-byte and multibyte.
788 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
789 prepare_to_modify_buffer could relocate the text. */
792 insert (string
, nbytes
)
793 register unsigned char *string
;
799 insert_1 (string
, nbytes
, 0, 1, 0);
800 signal_after_change (opoint
, 0, PT
- opoint
);
804 /* Likewise, but inherit text properties from neighboring characters. */
807 insert_and_inherit (string
, nbytes
)
808 register unsigned char *string
;
814 insert_1 (string
, nbytes
, 1, 1, 0);
815 signal_after_change (opoint
, 0, PT
- opoint
);
819 /* Insert the character C before point. Do not inherit text properties. */
825 unsigned char workbuf
[4], *str
;
828 if (! NILP (current_buffer
->enable_multibyte_characters
))
829 len
= CHAR_STRING (c
, workbuf
, str
);
840 /* Insert the null-terminated string S before point. */
846 insert (s
, strlen (s
));
849 /* Like `insert' except that all markers pointing at the place where
850 the insertion happens are adjusted to point after it.
851 Don't use this function to insert part of a Lisp string,
852 since gc could happen and relocate it. */
855 insert_before_markers (string
, nbytes
)
856 unsigned char *string
;
863 insert_1 (string
, nbytes
, 0, 1, 1);
864 signal_after_change (opoint
, 0, PT
- opoint
);
868 /* Likewise, but inherit text properties from neighboring characters. */
871 insert_before_markers_and_inherit (string
, nbytes
)
872 unsigned char *string
;
879 insert_1 (string
, nbytes
, 1, 1, 1);
880 signal_after_change (opoint
, 0, PT
- opoint
);
884 /* Subroutine used by the insert functions above. */
887 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
888 register unsigned char *string
;
890 int inherit
, prepare
, before_markers
;
892 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
893 inherit
, prepare
, before_markers
);
896 /* See if the bytes before POS/POS_BYTE combine with bytes
897 at the start of STRING to form a single character.
898 If so, return the number of bytes at the start of STRING
899 which combine in this way. Otherwise, return 0. */
902 count_combining_before (string
, length
, pos
, pos_byte
)
903 unsigned char *string
;
907 int opos
= pos
, opos_byte
= pos_byte
;
909 unsigned char *p
= string
;
911 if (NILP (current_buffer
->enable_multibyte_characters
))
913 if (length
== 0 || CHAR_HEAD_P (*string
))
917 c
= FETCH_BYTE (pos_byte
- 1);
918 if (ASCII_BYTE_P (c
))
920 DEC_BOTH (pos
, pos_byte
);
921 c
= FETCH_BYTE (pos_byte
);
922 if (! BASE_LEADING_CODE_P (c
))
925 /* We have a combination situation.
926 Count the bytes at STRING that will combine. */
927 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
933 /* See if the bytes after POS/POS_BYTE combine with bytes
934 at the end of STRING to form a single character.
935 If so, return the number of bytes after POS/POS_BYTE
936 which combine in this way. Otherwise, return 0. */
939 count_combining_after (string
, length
, pos
, pos_byte
)
940 unsigned char *string
;
944 int opos
= pos
, opos_byte
= pos_byte
;
948 if (NILP (current_buffer
->enable_multibyte_characters
))
950 if (length
== 0 || ASCII_BYTE_P (string
[length
- 1]))
953 while (i
> 0 && ! CHAR_HEAD_P (string
[i
]))
957 if (! BASE_LEADING_CODE_P (string
[i
]))
962 c
= FETCH_BYTE (pos_byte
);
965 while (pos_byte
< ZV_BYTE
)
967 c
= FETCH_BYTE (pos_byte
);
973 return pos_byte
- opos_byte
;
976 /* Adjust the position TARGET/TARGET_BYTE for the combining of NBYTES
977 following the position POS/POS_BYTE to the character preceding POS.
978 If TARGET is after POS+NBYTES, we only have to adjust the character
979 position TARGET, else, if TARGET is after POS, we have to adjust
980 both the character position TARGET and the byte position
981 TARGET_BYTE, else we don't have to do any adjustment. */
983 #define ADJUST_CHAR_POS(target, target_byte) \
985 if (target > pos + nbytes) \
987 else if (target >= pos) \
990 target_byte = pos_byte + nbytes; \
994 /* Combine NBYTES stray trailing-codes, which were formerly separate
995 characters, with the preceding character. These bytes
996 are located after position POS / POS_BYTE, and the preceding character
997 is located just before that position. */
1000 combine_bytes (pos
, pos_byte
, nbytes
)
1001 int pos
, pos_byte
, nbytes
;
1003 /* Adjust all markers. */
1004 adjust_markers_for_delete (pos
, pos_byte
, pos
+ nbytes
, pos_byte
);
1006 adjust_overlays_for_delete (pos
, nbytes
);
1008 ADJUST_CHAR_POS (BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
1009 ADJUST_CHAR_POS (GPT
, GPT_BYTE
);
1010 ADJUST_CHAR_POS (Z
, Z_BYTE
);
1011 ADJUST_CHAR_POS (ZV
, ZV_BYTE
);
1013 if (BUF_INTERVALS (current_buffer
) != 0)
1014 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1015 offset_intervals (current_buffer
, pos
, - nbytes
);
1020 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1021 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
1022 are the same as in insert_1. */
1025 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
1026 register unsigned char *string
;
1027 register int nchars
, nbytes
;
1028 int inherit
, prepare
, before_markers
;
1030 register Lisp_Object temp
;
1031 int combined_before_bytes
, combined_after_bytes
;
1033 if (NILP (current_buffer
->enable_multibyte_characters
))
1037 /* Do this before moving and increasing the gap,
1038 because the before-change hooks might move the gap
1039 or make it smaller. */
1040 prepare_to_modify_buffer (PT
, PT
, NULL
);
1043 move_gap_both (PT
, PT_BYTE
);
1044 if (GAP_SIZE
< nbytes
)
1045 make_gap (nbytes
- GAP_SIZE
);
1047 combined_before_bytes
1048 = count_combining_before (string
, nbytes
, PT
, PT_BYTE
);
1049 combined_after_bytes
1050 = count_combining_after (string
, nbytes
, PT
, PT_BYTE
);
1052 /* Record deletion of the surrounding text that combines with
1053 the insertion. This, together with recording the insertion,
1054 will add up to the right stuff in the undo list.
1056 But there is no need to actually delete the combining bytes
1057 from the buffer and reinsert them. */
1059 if (combined_after_bytes
)
1061 Lisp_Object deletion
;
1064 if (! EQ (current_buffer
->undo_list
, Qt
))
1065 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1066 PT
+ combined_after_bytes
,
1067 PT_BYTE
+ combined_after_bytes
, 1);
1069 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1070 PT
+ combined_after_bytes
,
1071 PT_BYTE
+ combined_after_bytes
);
1072 if (! EQ (current_buffer
->undo_list
, Qt
))
1073 record_delete (PT
, deletion
);
1076 if (combined_before_bytes
)
1078 Lisp_Object deletion
;
1081 if (! EQ (current_buffer
->undo_list
, Qt
))
1082 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1084 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1086 if (! EQ (current_buffer
->undo_list
, Qt
))
1087 record_delete (PT
- 1, deletion
);
1090 record_insert (PT
- !!combined_before_bytes
,
1091 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1094 bcopy (string
, GPT_ADDR
, nbytes
);
1097 /* When we have combining at the end of the insertion,
1098 this is the character position before the combined character. */
1105 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1107 if (combined_after_bytes
)
1108 move_gap_both (GPT
+ combined_after_bytes
,
1109 GPT_BYTE
+ combined_after_bytes
);
1114 adjust_overlays_for_insert (PT
, nchars
);
1115 adjust_markers_for_insert (PT
, PT_BYTE
,
1116 PT
+ nchars
, PT_BYTE
+ nbytes
,
1117 combined_before_bytes
, combined_after_bytes
,
1120 #ifdef USE_TEXT_PROPERTIES
1121 if (BUF_INTERVALS (current_buffer
) != 0)
1122 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1123 offset_intervals (current_buffer
, PT
, nchars
);
1125 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1126 Fset_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1131 int pos
= PT
, pos_byte
= PT_BYTE
;
1133 adjust_point (nchars
+ combined_after_bytes
,
1134 nbytes
+ combined_after_bytes
);
1136 if (combined_after_bytes
)
1137 combine_bytes (pos
+ nchars
, pos_byte
+ nbytes
, combined_after_bytes
);
1139 if (combined_before_bytes
)
1140 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1144 /* Insert the part of the text of STRING, a Lisp object assumed to be
1145 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1146 starting at position POS / POS_BYTE. If the text of STRING has properties,
1147 copy them into the buffer.
1149 It does not work to use `insert' for this, because a GC could happen
1150 before we bcopy the stuff into the buffer, and relocate the string
1151 without insert noticing. */
1154 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1156 register int pos
, pos_byte
, length
, length_byte
;
1160 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1162 signal_after_change (opoint
, 0, PT
- opoint
);
1165 /* Like `insert_from_string' except that all markers pointing
1166 at the place where the insertion happens are adjusted to point after it. */
1169 insert_from_string_before_markers (string
, pos
, pos_byte
,
1170 length
, length_byte
, inherit
)
1172 register int pos
, pos_byte
, length
, length_byte
;
1176 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1178 signal_after_change (opoint
, 0, PT
- opoint
);
1181 /* Subroutine of the insertion functions above. */
1184 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1185 inherit
, before_markers
)
1187 register int pos
, pos_byte
, nchars
, nbytes
;
1188 int inherit
, before_markers
;
1190 register Lisp_Object temp
;
1191 struct gcpro gcpro1
;
1192 int outgoing_nbytes
= nbytes
;
1193 int combined_before_bytes
, combined_after_bytes
;
1194 int adjusted_nchars
;
1197 /* Make OUTGOING_NBYTES describe the text
1198 as it will be inserted in this buffer. */
1200 if (NILP (current_buffer
->enable_multibyte_characters
))
1201 outgoing_nbytes
= nchars
;
1202 else if (! STRING_MULTIBYTE (string
))
1204 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1208 /* Do this before moving and increasing the gap,
1209 because the before-change hooks might move the gap
1210 or make it smaller. */
1211 prepare_to_modify_buffer (PT
, PT
, NULL
);
1214 move_gap_both (PT
, PT_BYTE
);
1215 if (GAP_SIZE
< nbytes
)
1216 make_gap (outgoing_nbytes
- GAP_SIZE
);
1219 /* Copy the string text into the buffer, perhaps converting
1220 between single-byte and multibyte. */
1221 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1222 STRING_MULTIBYTE (string
),
1223 ! NILP (current_buffer
->enable_multibyte_characters
));
1225 /* We have copied text into the gap, but we have not altered
1226 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1227 to these functions and get the same results as we would
1228 have got earlier on. Meanwhile, PT_ADDR does point to
1229 the text that has been stored by copy_text. */
1231 combined_before_bytes
1232 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1233 combined_after_bytes
1234 = count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1236 /* Record deletion of the surrounding text that combines with
1237 the insertion. This, together with recording the insertion,
1238 will add up to the right stuff in the undo list.
1240 But there is no need to actually delete the combining bytes
1241 from the buffer and reinsert them. */
1243 if (combined_after_bytes
)
1245 Lisp_Object deletion
;
1248 if (! EQ (current_buffer
->undo_list
, Qt
))
1249 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1250 PT
+ combined_after_bytes
,
1251 PT_BYTE
+ combined_after_bytes
, 1);
1253 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1254 PT
+ combined_after_bytes
,
1255 PT_BYTE
+ combined_after_bytes
);
1256 if (! EQ (current_buffer
->undo_list
, Qt
))
1257 record_delete (PT
, deletion
);
1260 if (combined_before_bytes
)
1262 Lisp_Object deletion
;
1265 if (! EQ (current_buffer
->undo_list
, Qt
))
1266 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1268 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1270 if (! EQ (current_buffer
->undo_list
, Qt
))
1271 record_delete (PT
- 1, deletion
);
1274 record_insert (PT
- !!combined_before_bytes
,
1275 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1278 GAP_SIZE
-= outgoing_nbytes
;
1282 GPT_BYTE
+= outgoing_nbytes
;
1283 ZV_BYTE
+= outgoing_nbytes
;
1284 Z_BYTE
+= outgoing_nbytes
;
1285 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1287 if (combined_after_bytes
)
1288 move_gap_both (GPT
+ combined_after_bytes
,
1289 GPT_BYTE
+ combined_after_bytes
);
1294 adjust_overlays_for_insert (PT
, nchars
);
1295 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1296 PT_BYTE
+ outgoing_nbytes
,
1297 combined_before_bytes
, combined_after_bytes
,
1300 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1301 offset_intervals (current_buffer
, PT
, nchars
);
1303 intervals
= XSTRING (string
)->intervals
;
1304 /* Get the intervals for the part of the string we are inserting--
1305 not including the combined-before bytes. */
1306 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1307 intervals
= copy_intervals (intervals
, pos
, nchars
);
1309 /* Insert those intervals. */
1310 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1311 current_buffer
, inherit
);
1314 int pos
= PT
, pos_byte
= PT_BYTE
;
1316 adjust_point (nchars
+ combined_after_bytes
,
1317 outgoing_nbytes
+ combined_after_bytes
);
1319 if (combined_after_bytes
)
1320 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1321 combined_after_bytes
);
1323 if (combined_before_bytes
)
1324 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1328 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1329 current buffer. If the text in BUF has properties, they are absorbed
1330 into the current buffer.
1332 It does not work to use `insert' for this, because a malloc could happen
1333 and relocate BUF's text before the bcopy happens. */
1336 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1338 int charpos
, nchars
;
1343 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1344 signal_after_change (opoint
, 0, PT
- opoint
);
1348 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1353 register Lisp_Object temp
;
1355 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1356 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1357 int incoming_nbytes
= to_byte
- from_byte
;
1358 int outgoing_nbytes
= incoming_nbytes
;
1359 int combined_before_bytes
, combined_after_bytes
;
1360 int adjusted_nchars
;
1363 /* Make OUTGOING_NBYTES describe the text
1364 as it will be inserted in this buffer. */
1366 if (NILP (current_buffer
->enable_multibyte_characters
))
1367 outgoing_nbytes
= nchars
;
1368 else if (NILP (buf
->enable_multibyte_characters
))
1370 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1373 /* Make sure point-max won't overflow after this insertion. */
1374 XSETINT (temp
, outgoing_nbytes
+ Z
);
1375 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1376 error ("Maximum buffer size exceeded");
1378 /* Do this before moving and increasing the gap,
1379 because the before-change hooks might move the gap
1380 or make it smaller. */
1381 prepare_to_modify_buffer (PT
, PT
, NULL
);
1384 move_gap_both (PT
, PT_BYTE
);
1385 if (GAP_SIZE
< outgoing_nbytes
)
1386 make_gap (outgoing_nbytes
- GAP_SIZE
);
1388 if (from
< BUF_GPT (buf
))
1390 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1391 if (chunk
> incoming_nbytes
)
1392 chunk
= incoming_nbytes
;
1393 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1395 ! NILP (buf
->enable_multibyte_characters
),
1396 ! NILP (current_buffer
->enable_multibyte_characters
));
1400 if (chunk
< incoming_nbytes
)
1401 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1402 GPT_ADDR
+ chunk
, incoming_nbytes
- chunk
,
1403 ! NILP (buf
->enable_multibyte_characters
),
1404 ! NILP (current_buffer
->enable_multibyte_characters
));
1406 /* We have copied text into the gap, but we have not altered
1407 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1408 to these functions and get the same results as we would
1409 have got earlier on. Meanwhile, GPT_ADDR does point to
1410 the text that has been stored by copy_text. */
1411 combined_before_bytes
1412 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1413 combined_after_bytes
1414 = count_combining_after (GPT_ADDR
, outgoing_nbytes
,
1417 /* Record deletion of the surrounding text that combines with
1418 the insertion. This, together with recording the insertion,
1419 will add up to the right stuff in the undo list.
1421 But there is no need to actually delete the combining bytes
1422 from the buffer and reinsert them. */
1424 if (combined_after_bytes
)
1426 Lisp_Object deletion
;
1429 if (! EQ (current_buffer
->undo_list
, Qt
))
1430 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1431 PT
+ combined_after_bytes
,
1432 PT_BYTE
+ combined_after_bytes
, 1);
1434 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1435 PT
+ combined_after_bytes
,
1436 PT_BYTE
+ combined_after_bytes
);
1437 if (! EQ (current_buffer
->undo_list
, Qt
))
1438 record_delete (PT
, deletion
);
1441 if (combined_before_bytes
)
1443 Lisp_Object deletion
;
1446 if (! EQ (current_buffer
->undo_list
, Qt
))
1447 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1449 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1451 if (! EQ (current_buffer
->undo_list
, Qt
))
1452 record_delete (PT
- 1, deletion
);
1455 record_insert (PT
- !!combined_before_bytes
,
1456 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1459 GAP_SIZE
-= outgoing_nbytes
;
1463 GPT_BYTE
+= outgoing_nbytes
;
1464 ZV_BYTE
+= outgoing_nbytes
;
1465 Z_BYTE
+= outgoing_nbytes
;
1466 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1468 if (combined_after_bytes
)
1469 move_gap_both (GPT
+ combined_after_bytes
,
1470 GPT_BYTE
+ combined_after_bytes
);
1475 adjust_overlays_for_insert (PT
, nchars
);
1476 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1477 PT_BYTE
+ outgoing_nbytes
,
1478 combined_before_bytes
, combined_after_bytes
, 0);
1480 #ifdef USE_TEXT_PROPERTIES
1481 if (BUF_INTERVALS (current_buffer
) != 0)
1482 offset_intervals (current_buffer
, PT
, nchars
);
1485 /* Get the intervals for the part of the string we are inserting--
1486 not including the combined-before bytes. */
1487 intervals
= BUF_INTERVALS (buf
);
1488 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1489 intervals
= copy_intervals (intervals
, from
, nchars
);
1491 /* Insert those intervals. */
1492 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1495 int pos
= PT
, pos_byte
= PT_BYTE
;
1497 adjust_point (nchars
+ combined_after_bytes
,
1498 outgoing_nbytes
+ combined_after_bytes
);
1500 if (combined_after_bytes
)
1501 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1502 combined_after_bytes
);
1504 if (combined_before_bytes
)
1505 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1509 /* This function should be called after moving gap to FROM and before
1510 altering text between FROM and TO. This adjusts various position
1511 keepers and markers as if the text is deleted. Don't forget to
1512 call adjust_after_replace after you actually alter the text. */
1515 adjust_before_replace (from
, from_byte
, to
, to_byte
)
1516 int from
, from_byte
, to
, to_byte
;
1518 Lisp_Object deletion
;
1520 if (! EQ (current_buffer
->undo_list
, Qt
))
1521 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1525 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1527 if (! EQ (current_buffer
->undo_list
, Qt
))
1528 record_delete (from
, deletion
);
1530 adjust_overlays_for_delete (from
, to
- from
);
1533 /* Record undo information and adjust markers and position keepers for
1534 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1535 chars (LEN_BYTE bytes) which resides in the gap just after
1538 PREV_TEXT nil means the new text was just inserted. */
1541 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1542 int from
, from_byte
, len
, len_byte
;
1543 Lisp_Object prev_text
;
1545 int combined_before_bytes
1546 = count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
);
1547 int combined_after_bytes
1548 = count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
);
1549 int nchars_del
= 0, nbytes_del
= 0;
1551 if (combined_after_bytes
)
1553 Lisp_Object deletion
;
1556 if (! EQ (current_buffer
->undo_list
, Qt
))
1557 deletion
= make_buffer_string_both (from
, from_byte
,
1558 from
+ combined_after_bytes
,
1559 from_byte
+ combined_after_bytes
,
1562 adjust_markers_for_record_delete (from
, from_byte
,
1563 from
+ combined_after_bytes
,
1564 from_byte
+ combined_after_bytes
);
1566 if (! EQ (current_buffer
->undo_list
, Qt
))
1567 record_delete (from
, deletion
);
1570 if (combined_before_bytes
)
1572 Lisp_Object deletion
;
1575 if (! EQ (current_buffer
->undo_list
, Qt
))
1576 deletion
= make_buffer_string_both (from
- 1, CHAR_TO_BYTE (from
- 1),
1577 from
, from_byte
, 1);
1578 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1580 if (! EQ (current_buffer
->undo_list
, Qt
))
1581 record_delete (from
- 1, deletion
);
1584 /* Update various buffer positions for the new text. */
1585 GAP_SIZE
-= len_byte
;
1587 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1588 GPT
+= len
; GPT_BYTE
+= len_byte
;
1589 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1591 if (combined_after_bytes
)
1592 move_gap_both (GPT
+ combined_after_bytes
,
1593 GPT_BYTE
+ combined_after_bytes
);
1595 if (STRINGP (prev_text
))
1597 nchars_del
= XSTRING (prev_text
)->size
;
1598 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1600 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1602 combined_before_bytes
, combined_after_bytes
);
1603 if (STRINGP (prev_text
))
1604 record_delete (from
- !!combined_before_bytes
, prev_text
);
1605 record_insert (from
- !!combined_before_bytes
,
1606 len
- combined_before_bytes
+ !!combined_before_bytes
);
1608 if (len
> nchars_del
)
1609 adjust_overlays_for_insert (from
, len
- nchars_del
);
1610 else if (len
< nchars_del
)
1611 adjust_overlays_for_delete (from
, nchars_del
- len
);
1612 #ifdef USE_TEXT_PROPERTIES
1613 if (BUF_INTERVALS (current_buffer
) != 0)
1615 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1616 if (len
- nchars_del
> 0)
1617 Fset_text_properties (make_number (from
),
1618 make_number (from
+ len
- nchars_del
),
1624 int pos
= PT
, pos_byte
= PT_BYTE
;
1627 adjust_point (len
- nchars_del
+ combined_after_bytes
,
1628 len_byte
- nbytes_del
+ combined_after_bytes
);
1629 else if (from
== PT
&& combined_before_bytes
)
1630 adjust_point (0, combined_before_bytes
);
1632 if (combined_after_bytes
)
1633 combine_bytes (from
+ len
, from_byte
+ len_byte
, combined_after_bytes
);
1635 if (combined_before_bytes
)
1636 combine_bytes (from
, from_byte
, combined_before_bytes
);
1642 evaporate_overlays (from
);
1646 /* Record undo information, adjust markers and position keepers for an
1647 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1648 text already exists in the current buffer but character length (TO
1649 - FROM) may be incorrect, the correct length is NEWLEN. */
1652 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1653 int from
, from_byte
, to
, to_byte
, newlen
;
1655 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1658 move_gap_both (to
, to_byte
);
1659 GAP_SIZE
+= len_byte
;
1660 GPT
-= len
; GPT_BYTE
-= len_byte
;
1661 ZV
-= len
; ZV_BYTE
-= len_byte
;
1662 Z
-= len
; Z_BYTE
-= len_byte
;
1663 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1666 /* Replace the text from character positions FROM to TO with NEW,
1667 If PREPARE is nonzero, call prepare_to_modify_buffer.
1668 If INHERIT, the newly inserted text should inherit text properties
1669 from the surrounding non-deleted text. */
1671 /* Note that this does not yet handle markers quite right.
1672 Also it needs to record a single undo-entry that does a replacement
1673 rather than a separate delete and insert.
1674 That way, undo will also handle markers properly.
1676 But if MARKERS is 0, don't relocate markers. */
1679 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1681 int from
, to
, prepare
, inherit
, markers
;
1683 int inschars
= XSTRING (new)->size
;
1684 int insbytes
= STRING_BYTES (XSTRING (new));
1685 int from_byte
, to_byte
;
1686 int nbytes_del
, nchars_del
;
1687 register Lisp_Object temp
;
1688 struct gcpro gcpro1
;
1689 int combined_before_bytes
, combined_after_bytes
;
1690 int adjusted_inschars
;
1692 int outgoing_insbytes
= insbytes
;
1700 int range_length
= to
- from
;
1701 prepare_to_modify_buffer (from
, to
, &from
);
1702 to
= from
+ range_length
;
1707 /* Make args be valid */
1713 from_byte
= CHAR_TO_BYTE (from
);
1714 to_byte
= CHAR_TO_BYTE (to
);
1716 nchars_del
= to
- from
;
1717 nbytes_del
= to_byte
- from_byte
;
1719 if (nbytes_del
<= 0 && insbytes
== 0)
1722 /* Make OUTGOING_INSBYTES describe the text
1723 as it will be inserted in this buffer. */
1725 if (NILP (current_buffer
->enable_multibyte_characters
))
1726 outgoing_insbytes
= inschars
;
1727 else if (! STRING_MULTIBYTE (new))
1729 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1731 /* Make sure point-max won't overflow after this insertion. */
1732 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1733 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1734 error ("Maximum buffer size exceeded");
1738 /* Make sure the gap is somewhere in or next to what we are deleting. */
1740 gap_right (from
, from_byte
);
1742 gap_left (to
, to_byte
, 0);
1745 Lisp_Object deletion
;
1748 if (! EQ (current_buffer
->undo_list
, Qt
))
1749 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1752 /* Relocate all markers pointing into the new, larger gap
1753 to point at the end of the text before the gap.
1754 Do this before recording the deletion,
1755 so that undo handles this after reinserting the text. */
1756 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1758 if (! EQ (current_buffer
->undo_list
, Qt
))
1759 record_delete (from
, deletion
);
1762 GAP_SIZE
+= nbytes_del
;
1765 ZV_BYTE
-= nbytes_del
;
1766 Z_BYTE
-= nbytes_del
;
1768 GPT_BYTE
= from_byte
;
1769 *(GPT_ADDR
) = 0; /* Put an anchor. */
1774 if (GPT
- BEG
< beg_unchanged
)
1775 beg_unchanged
= GPT
- BEG
;
1776 if (Z
- GPT
< end_unchanged
)
1777 end_unchanged
= Z
- GPT
;
1779 if (GAP_SIZE
< insbytes
)
1780 make_gap (insbytes
- GAP_SIZE
);
1782 /* Copy the string text into the buffer, perhaps converting
1783 between single-byte and multibyte. */
1784 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1785 STRING_MULTIBYTE (new),
1786 ! NILP (current_buffer
->enable_multibyte_characters
));
1788 /* We have copied text into the gap, but we have not marked
1789 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1790 here, for both the previous text and the following text.
1791 Meanwhile, GPT_ADDR does point to
1792 the text that has been stored by copy_text. */
1794 combined_before_bytes
1795 = count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
);
1796 combined_after_bytes
1797 = count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
);
1799 /* Record deletion of the surrounding text that combines with
1800 the insertion. This, together with recording the insertion,
1801 will add up to the right stuff in the undo list.
1803 But there is no need to actually delete the combining bytes
1804 from the buffer and reinsert them. */
1806 if (combined_after_bytes
)
1808 Lisp_Object deletion
;
1811 if (! EQ (current_buffer
->undo_list
, Qt
))
1812 deletion
= make_buffer_string_both (from
, from_byte
,
1813 from
+ combined_after_bytes
,
1814 from_byte
+ combined_after_bytes
, 1);
1816 adjust_markers_for_record_delete (from
, from_byte
,
1817 from
+ combined_after_bytes
,
1818 from_byte
+ combined_after_bytes
);
1819 if (! EQ (current_buffer
->undo_list
, Qt
))
1820 record_delete (from
, deletion
);
1823 if (combined_before_bytes
)
1825 Lisp_Object deletion
;
1828 if (! EQ (current_buffer
->undo_list
, Qt
))
1829 deletion
= make_buffer_string_both (from
- 1, CHAR_TO_BYTE (from
- 1),
1830 from
, from_byte
, 1);
1831 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1833 if (! EQ (current_buffer
->undo_list
, Qt
))
1834 record_delete (from
- 1, deletion
);
1837 record_insert (from
- !!combined_before_bytes
,
1838 inschars
- combined_before_bytes
+ !!combined_before_bytes
);
1840 GAP_SIZE
-= outgoing_insbytes
;
1844 GPT_BYTE
+= outgoing_insbytes
;
1845 ZV_BYTE
+= outgoing_insbytes
;
1846 Z_BYTE
+= outgoing_insbytes
;
1847 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1849 if (combined_after_bytes
)
1850 move_gap_both (GPT
+ combined_after_bytes
,
1851 GPT_BYTE
+ combined_after_bytes
);
1856 /* Adjust the overlay center as needed. This must be done after
1857 adjusting the markers that bound the overlays. */
1858 adjust_overlays_for_delete (from
, nchars_del
);
1859 adjust_overlays_for_insert (from
, inschars
);
1861 adjust_markers_for_insert (from
, from_byte
,
1862 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1863 combined_before_bytes
, combined_after_bytes
, 0);
1865 #ifdef USE_TEXT_PROPERTIES
1866 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1868 /* Get the intervals for the part of the string we are inserting--
1869 not including the combined-before bytes. */
1870 intervals
= XSTRING (new)->intervals
;
1871 /* Insert those intervals. */
1872 graft_intervals_into_buffer (intervals
, from
, inschars
,
1873 current_buffer
, inherit
);
1876 /* Relocate point as if it were a marker. */
1878 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)
1879 + combined_after_bytes
),
1880 (from_byte
+ outgoing_insbytes
1881 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)
1882 + combined_after_bytes
));
1884 if (combined_after_bytes
)
1885 combine_bytes (from
+ inschars
, from_byte
+ outgoing_insbytes
,
1886 combined_after_bytes
);
1888 if (combined_before_bytes
)
1889 combine_bytes (from
, from_byte
, combined_before_bytes
);
1891 if (outgoing_insbytes
== 0)
1892 evaporate_overlays (from
);
1899 signal_after_change (from
, nchars_del
, GPT
- from
);
1902 /* Delete characters in current buffer
1903 from FROM up to (but not including) TO.
1904 If TO comes before FROM, we delete nothing. */
1907 del_range (from
, to
)
1908 register int from
, to
;
1910 del_range_1 (from
, to
, 1);
1913 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer. */
1916 del_range_1 (from
, to
, prepare
)
1917 int from
, to
, prepare
;
1919 int from_byte
, to_byte
;
1921 /* Make args be valid */
1932 int range_length
= to
- from
;
1933 prepare_to_modify_buffer (from
, to
, &from
);
1934 to
= from
+ range_length
;
1937 from_byte
= CHAR_TO_BYTE (from
);
1938 to_byte
= CHAR_TO_BYTE (to
);
1940 del_range_2 (from
, from_byte
, to
, to_byte
);
1943 /* Like del_range_1 but args are byte positions, not char positions. */
1946 del_range_byte (from_byte
, to_byte
, prepare
)
1947 int from_byte
, to_byte
, prepare
;
1951 /* Make args be valid */
1952 if (from_byte
< BEGV_BYTE
)
1953 from_byte
= BEGV_BYTE
;
1954 if (to_byte
> ZV_BYTE
)
1957 if (to_byte
<= from_byte
)
1960 from
= BYTE_TO_CHAR (from_byte
);
1961 to
= BYTE_TO_CHAR (to_byte
);
1965 int old_from
= from
, old_to
= Z
- to
;
1966 int range_length
= to
- from
;
1967 prepare_to_modify_buffer (from
, to
, &from
);
1968 to
= from
+ range_length
;
1970 if (old_from
!= from
)
1971 from_byte
= CHAR_TO_BYTE (from
);
1972 if (old_to
== Z
- to
)
1973 to_byte
= CHAR_TO_BYTE (to
);
1976 del_range_2 (from
, from_byte
, to
, to_byte
);
1979 /* Like del_range_1, but positions are specified both as charpos
1983 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1984 int from
, from_byte
, to
, to_byte
, prepare
;
1986 /* Make args be valid */
1987 if (from_byte
< BEGV_BYTE
)
1988 from_byte
= BEGV_BYTE
;
1989 if (to_byte
> ZV_BYTE
)
1992 if (to_byte
<= from_byte
)
2002 int old_from
= from
, old_to
= Z
- to
;
2003 int range_length
= to
- from
;
2004 prepare_to_modify_buffer (from
, to
, &from
);
2005 to
= from
+ range_length
;
2007 if (old_from
!= from
)
2008 from_byte
= CHAR_TO_BYTE (from
);
2009 if (old_to
== Z
- to
)
2010 to_byte
= CHAR_TO_BYTE (to
);
2013 del_range_2 (from
, from_byte
, to
, to_byte
);
2016 /* Delete a range of text, specified both as character positions
2017 and byte positions. FROM and TO are character positions,
2018 while FROM_BYTE and TO_BYTE are byte positions. */
2021 del_range_2 (from
, from_byte
, to
, to_byte
)
2022 int from
, from_byte
, to
, to_byte
;
2024 register int nbytes_del
, nchars_del
;
2025 int combined_after_bytes
;
2026 Lisp_Object deletion
;
2031 nchars_del
= to
- from
;
2032 nbytes_del
= to_byte
- from_byte
;
2034 /* Make sure the gap is somewhere in or next to what we are deleting. */
2036 gap_right (from
, from_byte
);
2038 gap_left (to
, to_byte
, 0);
2040 combined_after_bytes
2041 = count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
2042 ZV_BYTE
- to_byte
, from
, from_byte
);
2043 if (combined_after_bytes
)
2045 from_byte_1
= from_byte
;
2046 DEC_POS (from_byte_1
);
2049 from_byte_1
= from_byte
;
2051 if (! EQ (current_buffer
->undo_list
, Qt
))
2053 = make_buffer_string_both (from
- !!combined_after_bytes
,
2055 to
+ combined_after_bytes
,
2056 to_byte
+ combined_after_bytes
, 1);
2057 if (combined_after_bytes
)
2058 /* COMBINED_AFTER_BYTES nonzero means that the above code moved
2059 the gap. We must move the gap again to a proper place. */
2060 move_gap_both (from
, from_byte
);
2062 /* Relocate all markers pointing into the new, larger gap
2063 to point at the end of the text before the gap.
2064 Do this before recording the deletion,
2065 so that undo handles this after reinserting the text. */
2066 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
2067 if (combined_after_bytes
)
2069 /* Adjust markers for the phony deletion
2070 that we are about to call record_undo for. */
2072 /* Here we delete the markers that formerly
2073 pointed at TO ... TO + COMBINED_AFTER_BYTES.
2074 But because of the call to adjust_markers_for_delete, above,
2075 they now point at FROM ... FROM + COMBINED_AFTER_BYTES. */
2076 adjust_markers_for_record_delete (from
, from_byte
,
2077 from
+ combined_after_bytes
,
2078 from_byte
+ combined_after_bytes
);
2080 adjust_markers_for_record_delete (from
- 1, from_byte_1
,
2083 if (! EQ (current_buffer
->undo_list
, Qt
))
2084 record_delete (from
- !!combined_after_bytes
, deletion
);
2087 /* Relocate point as if it were a marker. */
2089 adjust_point (from
- (PT
< to
? PT
: to
),
2090 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
2092 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2093 offset_intervals (current_buffer
, from
, - nchars_del
);
2095 /* Adjust the overlay center as needed. This must be done after
2096 adjusting the markers that bound the overlays. */
2097 adjust_overlays_for_delete (from
, nchars_del
);
2099 GAP_SIZE
+= nbytes_del
;
2100 ZV_BYTE
-= nbytes_del
;
2101 Z_BYTE
-= nbytes_del
;
2105 GPT_BYTE
= from_byte
;
2107 if (combined_after_bytes
)
2108 move_gap_both (GPT
+ combined_after_bytes
,
2109 GPT_BYTE
+ combined_after_bytes
);
2111 *(GPT_ADDR
) = 0; /* Put an anchor. */
2116 if (GPT
- BEG
< beg_unchanged
)
2117 beg_unchanged
= GPT
- BEG
;
2118 if (Z
- GPT
< end_unchanged
)
2119 end_unchanged
= Z
- GPT
;
2121 if (combined_after_bytes
)
2123 combine_bytes (from
, from_byte
, combined_after_bytes
);
2125 record_insert (GPT
- 1, 1);
2130 evaporate_overlays (from
);
2131 signal_after_change (from
, nchars_del
, 0);
2134 /* Call this if you're about to change the region of BUFFER from
2135 character positions START to END. This checks the read-only
2136 properties of the region, calls the necessary modification hooks,
2137 and warns the next redisplay that it should pay attention to that
2141 modify_region (buffer
, start
, end
)
2142 struct buffer
*buffer
;
2145 struct buffer
*old_buffer
= current_buffer
;
2147 if (buffer
!= old_buffer
)
2148 set_buffer_internal (buffer
);
2150 prepare_to_modify_buffer (start
, end
, NULL
);
2152 if (start
- 1 < beg_unchanged
2153 || (unchanged_modified
== MODIFF
2154 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2155 beg_unchanged
= start
- 1;
2156 if (Z
- end
< end_unchanged
2157 || (unchanged_modified
== MODIFF
2158 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2159 end_unchanged
= Z
- end
;
2161 if (MODIFF
<= SAVE_MODIFF
)
2162 record_first_change ();
2165 buffer
->point_before_scroll
= Qnil
;
2167 if (buffer
!= old_buffer
)
2168 set_buffer_internal (old_buffer
);
2171 /* Check that it is okay to modify the buffer between START and END,
2172 which are char positions.
2174 Run the before-change-function, if any. If intervals are in use,
2175 verify that the text to be modified is not read-only, and call
2176 any modification properties the text may have.
2178 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2179 by holding its value temporarily in a marker. */
2182 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2186 if (!NILP (current_buffer
->read_only
))
2187 Fbarf_if_buffer_read_only ();
2189 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2190 if (BUF_INTERVALS (current_buffer
) != 0)
2194 Lisp_Object preserve_marker
;
2195 struct gcpro gcpro1
;
2196 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2197 GCPRO1 (preserve_marker
);
2198 verify_interval_modification (current_buffer
, start
, end
);
2199 *preserve_ptr
= marker_position (preserve_marker
);
2200 unchain_marker (preserve_marker
);
2204 verify_interval_modification (current_buffer
, start
, end
);
2207 #ifdef CLASH_DETECTION
2208 if (!NILP (current_buffer
->file_truename
)
2209 /* Make binding buffer-file-name to nil effective. */
2210 && !NILP (current_buffer
->filename
)
2211 && SAVE_MODIFF
>= MODIFF
)
2212 lock_file (current_buffer
->file_truename
);
2214 /* At least warn if this file has changed on disk since it was visited. */
2215 if (!NILP (current_buffer
->filename
)
2216 && SAVE_MODIFF
>= MODIFF
2217 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2218 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2219 call1 (intern ("ask-user-about-supersession-threat"),
2220 current_buffer
->filename
);
2221 #endif /* not CLASH_DETECTION */
2223 signal_before_change (start
, end
, preserve_ptr
);
2225 if (current_buffer
->newline_cache
)
2226 invalidate_region_cache (current_buffer
,
2227 current_buffer
->newline_cache
,
2228 start
- BEG
, Z
- end
);
2229 if (current_buffer
->width_run_cache
)
2230 invalidate_region_cache (current_buffer
,
2231 current_buffer
->width_run_cache
,
2232 start
- BEG
, Z
- end
);
2234 Vdeactivate_mark
= Qt
;
2237 /* These macros work with an argument named `preserve_ptr'
2238 and a local variable named `preserve_marker'. */
2240 #define PRESERVE_VALUE \
2241 if (preserve_ptr && NILP (preserve_marker)) \
2242 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2244 #define RESTORE_VALUE \
2245 if (! NILP (preserve_marker)) \
2247 *preserve_ptr = marker_position (preserve_marker); \
2248 unchain_marker (preserve_marker); \
2251 #define PRESERVE_START_END \
2252 if (NILP (start_marker)) \
2253 start_marker = Fcopy_marker (start, Qnil); \
2254 if (NILP (end_marker)) \
2255 end_marker = Fcopy_marker (end, Qnil);
2257 #define FETCH_START \
2258 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2261 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2263 /* Signal a change to the buffer immediately before it happens.
2264 START_INT and END_INT are the bounds of the text to be changed.
2266 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2267 by holding its value temporarily in a marker. */
2270 signal_before_change (start_int
, end_int
, preserve_ptr
)
2271 int start_int
, end_int
;
2274 Lisp_Object start
, end
;
2275 Lisp_Object start_marker
, end_marker
;
2276 Lisp_Object preserve_marker
;
2277 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2279 start
= make_number (start_int
);
2280 end
= make_number (end_int
);
2281 preserve_marker
= Qnil
;
2282 start_marker
= Qnil
;
2284 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2286 /* If buffer is unmodified, run a special hook for that case. */
2287 if (SAVE_MODIFF
>= MODIFF
2288 && !NILP (Vfirst_change_hook
)
2289 && !NILP (Vrun_hooks
))
2293 call1 (Vrun_hooks
, Qfirst_change_hook
);
2296 /* Run the before-change-function if any.
2297 We don't bother "binding" this variable to nil
2298 because it is obsolete anyway and new code should not use it. */
2299 if (!NILP (Vbefore_change_function
))
2303 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
2306 /* Now run the before-change-functions if any. */
2307 if (!NILP (Vbefore_change_functions
))
2309 Lisp_Object args
[3];
2310 Lisp_Object before_change_functions
;
2311 Lisp_Object after_change_functions
;
2312 struct gcpro gcpro1
, gcpro2
;
2317 /* "Bind" before-change-functions and after-change-functions
2318 to nil--but in a way that errors don't know about.
2319 That way, if there's an error in them, they will stay nil. */
2320 before_change_functions
= Vbefore_change_functions
;
2321 after_change_functions
= Vafter_change_functions
;
2322 Vbefore_change_functions
= Qnil
;
2323 Vafter_change_functions
= Qnil
;
2324 GCPRO2 (before_change_functions
, after_change_functions
);
2326 /* Actually run the hook functions. */
2327 args
[0] = Qbefore_change_functions
;
2328 args
[1] = FETCH_START
;
2329 args
[2] = FETCH_END
;
2330 run_hook_list_with_args (before_change_functions
, 3, args
);
2332 /* "Unbind" the variables we "bound" to nil. */
2333 Vbefore_change_functions
= before_change_functions
;
2334 Vafter_change_functions
= after_change_functions
;
2338 if (!NILP (current_buffer
->overlays_before
)
2339 || !NILP (current_buffer
->overlays_after
))
2342 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2343 FETCH_START
, FETCH_END
, Qnil
);
2346 if (! NILP (start_marker
))
2347 free_marker (start_marker
);
2348 if (! NILP (end_marker
))
2349 free_marker (end_marker
);
2354 /* Signal a change immediately after it happens.
2355 CHARPOS is the character position of the start of the changed text.
2356 LENDEL is the number of characters of the text before the change.
2357 (Not the whole buffer; just the part that was changed.)
2358 LENINS is the number of characters in that part of the text
2359 after the change. */
2362 signal_after_change (charpos
, lendel
, lenins
)
2363 int charpos
, lendel
, lenins
;
2365 /* If we are deferring calls to the after-change functions
2366 and there are no before-change functions,
2367 just record the args that we were going to use. */
2368 if (! NILP (Vcombine_after_change_calls
)
2369 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
2370 && NILP (current_buffer
->overlays_before
)
2371 && NILP (current_buffer
->overlays_after
))
2375 if (!NILP (combine_after_change_list
)
2376 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2377 Fcombine_after_change_execute ();
2379 elt
= Fcons (make_number (charpos
- BEG
),
2380 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2381 Fcons (make_number (lenins
- lendel
), Qnil
)));
2382 combine_after_change_list
2383 = Fcons (elt
, combine_after_change_list
);
2384 combine_after_change_buffer
= Fcurrent_buffer ();
2389 if (!NILP (combine_after_change_list
))
2390 Fcombine_after_change_execute ();
2392 /* Run the after-change-function if any.
2393 We don't bother "binding" this variable to nil
2394 because it is obsolete anyway and new code should not use it. */
2395 if (!NILP (Vafter_change_function
))
2396 call3 (Vafter_change_function
,
2397 make_number (charpos
), make_number (charpos
+ lenins
),
2398 make_number (lendel
));
2400 if (!NILP (Vafter_change_functions
))
2402 Lisp_Object args
[4];
2403 Lisp_Object before_change_functions
;
2404 Lisp_Object after_change_functions
;
2405 struct gcpro gcpro1
, gcpro2
;
2407 /* "Bind" before-change-functions and after-change-functions
2408 to nil--but in a way that errors don't know about.
2409 That way, if there's an error in them, they will stay nil. */
2410 before_change_functions
= Vbefore_change_functions
;
2411 after_change_functions
= Vafter_change_functions
;
2412 Vbefore_change_functions
= Qnil
;
2413 Vafter_change_functions
= Qnil
;
2414 GCPRO2 (before_change_functions
, after_change_functions
);
2416 /* Actually run the hook functions. */
2417 args
[0] = Qafter_change_functions
;
2418 XSETFASTINT (args
[1], charpos
);
2419 XSETFASTINT (args
[2], charpos
+ lenins
);
2420 XSETFASTINT (args
[3], lendel
);
2421 run_hook_list_with_args (after_change_functions
,
2424 /* "Unbind" the variables we "bound" to nil. */
2425 Vbefore_change_functions
= before_change_functions
;
2426 Vafter_change_functions
= after_change_functions
;
2430 if (!NILP (current_buffer
->overlays_before
)
2431 || !NILP (current_buffer
->overlays_after
))
2432 report_overlay_modification (make_number (charpos
),
2433 make_number (charpos
+ lenins
),
2435 make_number (charpos
),
2436 make_number (charpos
+ lenins
),
2437 make_number (lendel
));
2439 /* After an insertion, call the text properties
2440 insert-behind-hooks or insert-in-front-hooks. */
2442 report_interval_modification (make_number (charpos
),
2443 make_number (charpos
+ lenins
));
2447 Fcombine_after_change_execute_1 (val
)
2450 Vcombine_after_change_calls
= val
;
2454 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2455 Scombine_after_change_execute
, 0, 0, 0,
2456 "This function is for use internally in `combine-after-change-calls'.")
2459 register Lisp_Object val
;
2460 int count
= specpdl_ptr
- specpdl
;
2461 int beg
, end
, change
;
2465 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2467 Fset_buffer (combine_after_change_buffer
);
2469 /* # chars unchanged at beginning of buffer. */
2471 /* # chars unchanged at end of buffer. */
2473 /* Total amount of insertion (negative for deletion). */
2476 /* Scan the various individual changes,
2477 accumulating the range info in BEG, END and CHANGE. */
2478 for (tail
= combine_after_change_list
; CONSP (tail
);
2479 tail
= XCONS (tail
)->cdr
)
2482 int thisbeg
, thisend
, thischange
;
2484 /* Extract the info from the next element. */
2485 elt
= XCONS (tail
)->car
;
2488 thisbeg
= XINT (XCONS (elt
)->car
);
2490 elt
= XCONS (elt
)->cdr
;
2493 thisend
= XINT (XCONS (elt
)->car
);
2495 elt
= XCONS (elt
)->cdr
;
2498 thischange
= XINT (XCONS (elt
)->car
);
2500 /* Merge this range into the accumulated range. */
2501 change
+= thischange
;
2508 /* Get the current start and end positions of the range
2509 that was changed. */
2513 /* We are about to handle these, so discard them. */
2514 combine_after_change_list
= Qnil
;
2516 /* Now run the after-change functions for real.
2517 Turn off the flag that defers them. */
2518 record_unwind_protect (Fcombine_after_change_execute_1
,
2519 Vcombine_after_change_calls
);
2520 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2522 return unbind_to (count
, val
);
2528 staticpro (&combine_after_change_list
);
2529 combine_after_change_list
= Qnil
;
2531 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2532 "Non-nil means enable debugging checks for invalid marker positions.");
2533 check_markers_debug_flag
= 0;
2534 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2535 "Used internally by the `combine-after-change-calls' macro.");
2536 Vcombine_after_change_calls
= Qnil
;
2538 defsubr (&Scombine_after_change_execute
);