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
;
703 /* Convert multibyte to single byte. */
704 while (bytes_left
> 0)
707 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
708 *to_addr
++ = SINGLE_BYTE_CHAR_P (c
) ? c
: (c
& 0177) + 0200;
709 from_addr
+= thislen
;
717 unsigned char *initial_to_addr
= to_addr
;
719 /* Convert single-byte to multibyte. */
722 int c
= *from_addr
++;
723 unsigned char workbuf
[4], *str
;
726 if (c
>= 0240 && c
< 0400)
728 c
= unibyte_char_to_multibyte (c
);
729 len
= CHAR_STRING (c
, workbuf
, str
);
730 bcopy (str
, to_addr
, len
);
735 /* Special case for speed. */
736 *to_addr
++ = c
, nbytes
--;
738 return to_addr
- initial_to_addr
;
742 /* Return the number of bytes it would take
743 to convert some single-byte text to multibyte.
744 The single-byte text consists of NBYTES bytes at PTR. */
747 count_size_as_multibyte (ptr
, nbytes
)
752 int outgoing_nbytes
= 0;
754 for (i
= 0; i
< nbytes
; i
++)
756 unsigned int c
= *ptr
++;
762 c
= unibyte_char_to_multibyte (c
);
763 outgoing_nbytes
+= XINT (Fchar_bytes (make_number (c
)));
767 return outgoing_nbytes
;
770 /* Insert a string of specified length before point.
771 This function judges multibyteness based on
772 enable_multibyte_characters in the current buffer;
773 it never converts between single-byte and multibyte.
775 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
776 prepare_to_modify_buffer could relocate the text. */
779 insert (string
, nbytes
)
780 register unsigned char *string
;
786 insert_1 (string
, nbytes
, 0, 1, 0);
787 signal_after_change (opoint
, 0, PT
- opoint
);
791 /* Likewise, but inherit text properties from neighboring characters. */
794 insert_and_inherit (string
, nbytes
)
795 register unsigned char *string
;
801 insert_1 (string
, nbytes
, 1, 1, 0);
802 signal_after_change (opoint
, 0, PT
- opoint
);
806 /* Insert the character C before point. Do not inherit text properties. */
812 unsigned char workbuf
[4], *str
;
815 if (! NILP (current_buffer
->enable_multibyte_characters
))
816 len
= CHAR_STRING (c
, workbuf
, str
);
827 /* Insert the null-terminated string S before point. */
833 insert (s
, strlen (s
));
836 /* Like `insert' except that all markers pointing at the place where
837 the insertion happens are adjusted to point after it.
838 Don't use this function to insert part of a Lisp string,
839 since gc could happen and relocate it. */
842 insert_before_markers (string
, nbytes
)
843 unsigned char *string
;
850 insert_1 (string
, nbytes
, 0, 1, 1);
851 signal_after_change (opoint
, 0, PT
- opoint
);
855 /* Likewise, but inherit text properties from neighboring characters. */
858 insert_before_markers_and_inherit (string
, nbytes
)
859 unsigned char *string
;
866 insert_1 (string
, nbytes
, 1, 1, 1);
867 signal_after_change (opoint
, 0, PT
- opoint
);
871 /* Subroutine used by the insert functions above. */
874 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
875 register unsigned char *string
;
877 int inherit
, prepare
, before_markers
;
879 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
880 inherit
, prepare
, before_markers
);
883 /* See if the bytes before POS/POS_BYTE combine with bytes
884 at the start of STRING to form a single character.
885 If so, return the number of bytes at the start of STRING
886 which combine in this way. Otherwise, return 0. */
889 count_combining_before (string
, length
, pos
, pos_byte
)
890 unsigned char *string
;
894 int opos
= pos
, opos_byte
= pos_byte
;
896 unsigned char *p
= string
;
898 if (NILP (current_buffer
->enable_multibyte_characters
))
900 if (length
== 0 || CHAR_HEAD_P (*string
))
904 c
= FETCH_BYTE (pos_byte
- 1);
905 if (ASCII_BYTE_P (c
))
907 DEC_BOTH (pos
, pos_byte
);
908 c
= FETCH_BYTE (pos_byte
);
909 if (! BASE_LEADING_CODE_P (c
))
912 /* We have a combination situation.
913 Count the bytes at STRING that will combine. */
914 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
920 /* See if the bytes after POS/POS_BYTE combine with bytes
921 at the end of STRING to form a single character.
922 If so, return the number of bytes after POS/POS_BYTE
923 which combine in this way. Otherwise, return 0. */
926 count_combining_after (string
, length
, pos
, pos_byte
)
927 unsigned char *string
;
931 int opos
= pos
, opos_byte
= pos_byte
;
935 if (NILP (current_buffer
->enable_multibyte_characters
))
937 if (length
== 0 || ASCII_BYTE_P (string
[length
- 1]))
940 while (i
> 0 && ! CHAR_HEAD_P (string
[i
]))
944 if (! BASE_LEADING_CODE_P (string
[i
]))
949 c
= FETCH_BYTE (pos_byte
);
952 while (pos_byte
< ZV_BYTE
)
954 c
= FETCH_BYTE (pos_byte
);
960 return pos_byte
- opos_byte
;
963 /* Adjust the position TARGET/TARGET_BYTE for the combining of NBYTES
964 following the position POS/POS_BYTE to the character preceding POS.
965 If TARGET is after POS+NBYTES, we only have to adjust the character
966 position TARGET, else, if TARGET is after POS, we have to adjust
967 both the character position TARGET and the byte position
968 TARGET_BYTE, else we don't have to do any adjustment. */
970 #define ADJUST_CHAR_POS(target, target_byte) \
972 if (target > pos + nbytes) \
974 else if (target >= pos) \
977 target_byte = pos_byte + nbytes; \
981 /* Combine NBYTES stray trailing-codes, which were formerly separate
982 characters, with the preceding character. These bytes
983 are located after position POS / POS_BYTE, and the preceding character
984 is located just before that position. */
987 combine_bytes (pos
, pos_byte
, nbytes
)
988 int pos
, pos_byte
, nbytes
;
990 /* Adjust all markers. */
991 adjust_markers_for_delete (pos
, pos_byte
, pos
+ nbytes
, pos_byte
);
993 adjust_overlays_for_delete (pos
, nbytes
);
995 ADJUST_CHAR_POS (BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
996 ADJUST_CHAR_POS (GPT
, GPT_BYTE
);
997 ADJUST_CHAR_POS (Z
, Z_BYTE
);
998 ADJUST_CHAR_POS (ZV
, ZV_BYTE
);
1000 if (BUF_INTERVALS (current_buffer
) != 0)
1001 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1002 offset_intervals (current_buffer
, pos
, - nbytes
);
1007 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
1008 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
1009 are the same as in insert_1. */
1012 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
1013 register unsigned char *string
;
1014 register int nchars
, nbytes
;
1015 int inherit
, prepare
, before_markers
;
1017 register Lisp_Object temp
, deletion
;
1018 int combined_before_bytes
, combined_after_bytes
;
1020 if (NILP (current_buffer
->enable_multibyte_characters
))
1024 move_gap_both (PT
, PT_BYTE
);
1025 if (GAP_SIZE
< nbytes
)
1026 make_gap (nbytes
- GAP_SIZE
);
1029 prepare_to_modify_buffer (PT
, PT
, NULL
);
1031 combined_before_bytes
1032 = count_combining_before (string
, nbytes
, PT
, PT_BYTE
);
1033 combined_after_bytes
1034 = count_combining_after (string
, nbytes
, PT
, PT_BYTE
);
1036 /* Record deletion of the surrounding text that combines with
1037 the insertion. This, together with recording the insertion,
1038 will add up to the right stuff in the undo list.
1040 But there is no need to actually delete the combining bytes
1041 from the buffer and reinsert them. */
1043 if (combined_after_bytes
)
1045 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1046 PT
+ combined_after_bytes
,
1047 PT_BYTE
+ combined_after_bytes
, 1);
1049 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1050 PT
+ combined_after_bytes
,
1051 PT_BYTE
+ combined_after_bytes
);
1052 record_delete (PT
, deletion
);
1055 if (combined_before_bytes
)
1057 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1059 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1061 record_delete (PT
- 1, deletion
);
1064 record_insert (PT
- !!combined_before_bytes
,
1065 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1068 bcopy (string
, GPT_ADDR
, nbytes
);
1071 /* When we have combining at the end of the insertion,
1072 this is the character position before the combined character. */
1079 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1081 if (combined_after_bytes
)
1082 move_gap_both (GPT
+ combined_after_bytes
,
1083 GPT_BYTE
+ combined_after_bytes
);
1088 adjust_overlays_for_insert (PT
, nchars
);
1089 adjust_markers_for_insert (PT
, PT_BYTE
,
1090 PT
+ nchars
, PT_BYTE
+ nbytes
,
1091 combined_before_bytes
, combined_after_bytes
,
1094 #ifdef USE_TEXT_PROPERTIES
1095 if (BUF_INTERVALS (current_buffer
) != 0)
1096 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1097 offset_intervals (current_buffer
, PT
, nchars
);
1099 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1100 Fset_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1105 int pos
= PT
, pos_byte
= PT_BYTE
;
1107 adjust_point (nchars
+ combined_after_bytes
,
1108 nbytes
+ combined_after_bytes
);
1110 if (combined_after_bytes
)
1111 combine_bytes (pos
+ nchars
, pos_byte
+ nbytes
, combined_after_bytes
);
1113 if (combined_before_bytes
)
1114 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1118 /* Insert the part of the text of STRING, a Lisp object assumed to be
1119 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1120 starting at position POS / POS_BYTE. If the text of STRING has properties,
1121 copy them into the buffer.
1123 It does not work to use `insert' for this, because a GC could happen
1124 before we bcopy the stuff into the buffer, and relocate the string
1125 without insert noticing. */
1128 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1130 register int pos
, pos_byte
, length
, length_byte
;
1136 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1138 signal_after_change (opoint
, 0, PT
- opoint
);
1142 /* Like `insert_from_string' except that all markers pointing
1143 at the place where the insertion happens are adjusted to point after it. */
1146 insert_from_string_before_markers (string
, pos
, pos_byte
,
1147 length
, length_byte
, inherit
)
1149 register int pos
, pos_byte
, length
, length_byte
;
1155 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1157 signal_after_change (opoint
, 0, PT
- opoint
);
1161 /* Subroutine of the insertion functions above. */
1164 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1165 inherit
, before_markers
)
1167 register int pos
, pos_byte
, nchars
, nbytes
;
1168 int inherit
, before_markers
;
1170 register Lisp_Object temp
;
1171 struct gcpro gcpro1
;
1172 int outgoing_nbytes
= nbytes
;
1173 int combined_before_bytes
, combined_after_bytes
;
1174 int adjusted_nchars
;
1176 Lisp_Object deletion
;
1178 /* Make OUTGOING_NBYTES describe the text
1179 as it will be inserted in this buffer. */
1181 if (NILP (current_buffer
->enable_multibyte_characters
))
1182 outgoing_nbytes
= nchars
;
1183 else if (! STRING_MULTIBYTE (string
))
1185 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1188 /* Make sure point-max won't overflow after this insertion. */
1189 XSETINT (temp
, outgoing_nbytes
+ Z
);
1190 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1191 error ("Maximum buffer size exceeded");
1194 prepare_to_modify_buffer (PT
, PT
, NULL
);
1197 move_gap_both (PT
, PT_BYTE
);
1198 if (GAP_SIZE
< nbytes
)
1199 make_gap (outgoing_nbytes
- GAP_SIZE
);
1202 /* Copy the string text into the buffer, perhaps converting
1203 between single-byte and multibyte. */
1204 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1205 STRING_MULTIBYTE (string
),
1206 ! NILP (current_buffer
->enable_multibyte_characters
));
1208 /* We have copied text into the gap, but we have not altered
1209 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1210 to these functions and get the same results as we would
1211 have got earlier on. Meanwhile, PT_ADDR does point to
1212 the text that has been stored by copy_text. */
1214 combined_before_bytes
1215 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1216 combined_after_bytes
1217 = count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1219 /* Record deletion of the surrounding text that combines with
1220 the insertion. This, together with recording the insertion,
1221 will add up to the right stuff in the undo list.
1223 But there is no need to actually delete the combining bytes
1224 from the buffer and reinsert them. */
1226 if (combined_after_bytes
)
1228 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1229 PT
+ combined_after_bytes
,
1230 PT_BYTE
+ combined_after_bytes
, 1);
1232 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1233 PT
+ combined_after_bytes
,
1234 PT_BYTE
+ combined_after_bytes
);
1235 record_delete (PT
, deletion
);
1238 if (combined_before_bytes
)
1240 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1242 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1244 record_delete (PT
- 1, deletion
);
1247 record_insert (PT
- !!combined_before_bytes
,
1248 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1251 GAP_SIZE
-= outgoing_nbytes
;
1255 GPT_BYTE
+= outgoing_nbytes
;
1256 ZV_BYTE
+= outgoing_nbytes
;
1257 Z_BYTE
+= outgoing_nbytes
;
1258 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1260 if (combined_after_bytes
)
1261 move_gap_both (GPT
+ combined_after_bytes
,
1262 GPT_BYTE
+ combined_after_bytes
);
1267 adjust_overlays_for_insert (PT
, nchars
);
1268 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1269 PT_BYTE
+ outgoing_nbytes
,
1270 combined_before_bytes
, combined_after_bytes
,
1273 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1274 offset_intervals (current_buffer
, PT
, nchars
);
1276 intervals
= XSTRING (string
)->intervals
;
1277 /* Get the intervals for the part of the string we are inserting--
1278 not including the combined-before bytes. */
1279 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1280 intervals
= copy_intervals (intervals
, pos
, nchars
);
1282 /* Insert those intervals. */
1283 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1284 current_buffer
, inherit
);
1287 int pos
= PT
, pos_byte
= PT_BYTE
;
1289 adjust_point (nchars
+ combined_after_bytes
,
1290 outgoing_nbytes
+ combined_after_bytes
);
1292 if (combined_after_bytes
)
1293 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1294 combined_after_bytes
);
1296 if (combined_before_bytes
)
1297 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1301 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1302 current buffer. If the text in BUF has properties, they are absorbed
1303 into the current buffer.
1305 It does not work to use `insert' for this, because a malloc could happen
1306 and relocate BUF's text before the bcopy happens. */
1309 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1311 int charpos
, nchars
;
1318 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1319 signal_after_change (opoint
, 0, PT
- opoint
);
1324 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1329 register Lisp_Object temp
, deletion
;
1331 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1332 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1333 int incoming_nbytes
= to_byte
- from_byte
;
1334 int outgoing_nbytes
= incoming_nbytes
;
1335 int combined_before_bytes
, combined_after_bytes
;
1336 int adjusted_nchars
;
1339 /* Make OUTGOING_NBYTES describe the text
1340 as it will be inserted in this buffer. */
1342 if (NILP (current_buffer
->enable_multibyte_characters
))
1343 outgoing_nbytes
= nchars
;
1344 else if (NILP (buf
->enable_multibyte_characters
))
1346 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1349 /* Make sure point-max won't overflow after this insertion. */
1350 XSETINT (temp
, outgoing_nbytes
+ Z
);
1351 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1352 error ("Maximum buffer size exceeded");
1354 prepare_to_modify_buffer (PT
, PT
, NULL
);
1357 move_gap_both (PT
, PT_BYTE
);
1358 if (GAP_SIZE
< outgoing_nbytes
)
1359 make_gap (outgoing_nbytes
- GAP_SIZE
);
1361 if (from
< BUF_GPT (buf
))
1363 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1364 if (chunk
> incoming_nbytes
)
1365 chunk
= incoming_nbytes
;
1366 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1368 ! NILP (buf
->enable_multibyte_characters
),
1369 ! NILP (current_buffer
->enable_multibyte_characters
));
1373 if (chunk
< incoming_nbytes
)
1374 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1375 GPT_ADDR
+ chunk
, incoming_nbytes
- chunk
,
1376 ! NILP (buf
->enable_multibyte_characters
),
1377 ! NILP (current_buffer
->enable_multibyte_characters
));
1379 /* We have copied text into the gap, but we have not altered
1380 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1381 to these functions and get the same results as we would
1382 have got earlier on. Meanwhile, GPT_ADDR does point to
1383 the text that has been stored by copy_text. */
1384 combined_before_bytes
1385 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1386 combined_after_bytes
1387 = count_combining_after (GPT_ADDR
, outgoing_nbytes
,
1390 /* Record deletion of the surrounding text that combines with
1391 the insertion. This, together with recording the insertion,
1392 will add up to the right stuff in the undo list.
1394 But there is no need to actually delete the combining bytes
1395 from the buffer and reinsert them. */
1397 if (combined_after_bytes
)
1399 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1400 PT
+ combined_after_bytes
,
1401 PT_BYTE
+ combined_after_bytes
, 1);
1403 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1404 PT
+ combined_after_bytes
,
1405 PT_BYTE
+ combined_after_bytes
);
1406 record_delete (PT
, deletion
);
1409 if (combined_before_bytes
)
1411 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1413 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1415 record_delete (PT
- 1, deletion
);
1418 record_insert (PT
- !!combined_before_bytes
,
1419 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1422 GAP_SIZE
-= outgoing_nbytes
;
1426 GPT_BYTE
+= outgoing_nbytes
;
1427 ZV_BYTE
+= outgoing_nbytes
;
1428 Z_BYTE
+= outgoing_nbytes
;
1429 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1431 if (combined_after_bytes
)
1432 move_gap_both (GPT
+ combined_after_bytes
,
1433 GPT_BYTE
+ combined_after_bytes
);
1438 adjust_overlays_for_insert (PT
, nchars
);
1439 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1440 PT_BYTE
+ outgoing_nbytes
,
1441 combined_before_bytes
, combined_after_bytes
, 0);
1443 #ifdef USE_TEXT_PROPERTIES
1444 if (BUF_INTERVALS (current_buffer
) != 0)
1445 offset_intervals (current_buffer
, PT
, nchars
);
1448 /* Get the intervals for the part of the string we are inserting--
1449 not including the combined-before bytes. */
1450 intervals
= BUF_INTERVALS (buf
);
1451 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1452 intervals
= copy_intervals (intervals
, from
, nchars
);
1454 /* Insert those intervals. */
1455 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1458 int pos
= PT
, pos_byte
= PT_BYTE
;
1460 adjust_point (nchars
+ combined_after_bytes
,
1461 outgoing_nbytes
+ combined_after_bytes
);
1463 if (combined_after_bytes
)
1464 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1465 combined_after_bytes
);
1467 if (combined_before_bytes
)
1468 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1472 /* This function should be called after moving gap to FROM and before
1473 altering text between FROM and TO. This adjusts various position
1474 keepers and markers as if the text is deleted. Don't forget to
1475 call adjust_after_replace after you actually alter the text. */
1478 adjust_before_replace (from
, from_byte
, to
, to_byte
)
1479 int from
, from_byte
, to
, to_byte
;
1481 Lisp_Object deletion
;
1482 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1486 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1487 record_delete (from
, deletion
);
1488 adjust_overlays_for_delete (from
, to
- from
);
1491 /* Record undo information and adjust markers and position keepers for
1492 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1493 chars (LEN_BYTE bytes) which resides in the gap just after
1496 PREV_TEXT nil means the new text was just inserted. */
1499 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1500 int from
, from_byte
, len
, len_byte
;
1501 Lisp_Object prev_text
;
1503 int combined_before_bytes
1504 = count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
);
1505 int combined_after_bytes
1506 = count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
);
1507 Lisp_Object deletion
;
1508 int nchars_del
= 0, nbytes_del
= 0;
1510 if (combined_after_bytes
)
1512 deletion
= make_buffer_string_both (from
, from_byte
,
1513 from
+ combined_after_bytes
,
1514 from_byte
+ combined_after_bytes
, 1);
1516 adjust_markers_for_record_delete (from
, from_byte
,
1517 from
+ combined_after_bytes
,
1518 from_byte
+ combined_after_bytes
);
1519 record_delete (from
, deletion
);
1522 if (combined_before_bytes
)
1524 deletion
= make_buffer_string_both (from
- 1, CHAR_TO_BYTE (from
- 1),
1525 from
, from_byte
, 1);
1526 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1528 record_delete (from
- 1, deletion
);
1531 /* Update various buffer positions for the new text. */
1532 GAP_SIZE
-= len_byte
;
1534 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1535 GPT
+= len
; GPT_BYTE
+= len_byte
;
1536 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1538 if (combined_after_bytes
)
1539 move_gap_both (GPT
+ combined_after_bytes
,
1540 GPT_BYTE
+ combined_after_bytes
);
1542 if (STRINGP (prev_text
))
1544 nchars_del
= XSTRING (prev_text
)->size
;
1545 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1547 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1549 combined_before_bytes
, combined_after_bytes
);
1550 if (STRINGP (prev_text
))
1551 record_delete (from
, prev_text
);
1552 record_insert (from
- !!combined_before_bytes
,
1553 len
- combined_before_bytes
+ !!combined_before_bytes
);
1555 if (len
> nchars_del
)
1556 adjust_overlays_for_insert (from
, len
- nchars_del
);
1557 else if (len
< nchars_del
)
1558 adjust_overlays_for_delete (from
, nchars_del
- len
);
1559 #ifdef USE_TEXT_PROPERTIES
1560 if (BUF_INTERVALS (current_buffer
) != 0)
1561 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1565 int pos
= PT
, pos_byte
= PT_BYTE
;
1568 adjust_point (len
- nchars_del
+ combined_after_bytes
,
1569 len_byte
- nbytes_del
+ combined_after_bytes
);
1570 else if (from
== PT
&& combined_before_bytes
)
1571 adjust_point (0, combined_before_bytes
);
1573 if (combined_after_bytes
)
1574 combine_bytes (from
+ len
, from_byte
+ len_byte
, combined_after_bytes
);
1576 if (combined_before_bytes
)
1577 combine_bytes (from
, from_byte
, combined_before_bytes
);
1583 evaporate_overlays (from
);
1587 /* Record undo information, adjust markers and position keepers for an
1588 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1589 text already exists in the current buffer but character length (TO
1590 - FROM) may be incorrect, the correct length is NEWLEN. */
1593 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1594 int from
, from_byte
, to
, to_byte
, newlen
;
1596 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1599 move_gap_both (to
, to_byte
);
1600 GAP_SIZE
+= len_byte
;
1601 GPT
-= len
; GPT_BYTE
-= len_byte
;
1602 ZV
-= len
; ZV_BYTE
-= len_byte
;
1603 Z
-= len
; Z_BYTE
-= len_byte
;
1604 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1607 /* Replace the text from character positions FROM to TO with NEW,
1608 If PREPARE is nonzero, call prepare_to_modify_buffer.
1609 If INHERIT, the newly inserted text should inherit text properties
1610 from the surrounding non-deleted text. */
1612 /* Note that this does not yet handle markers quite right.
1613 Also it needs to record a single undo-entry that does a replacement
1614 rather than a separate delete and insert.
1615 That way, undo will also handle markers properly. */
1618 replace_range (from
, to
, new, prepare
, inherit
, nomarkers
)
1620 int from
, to
, prepare
, inherit
, nomarkers
;
1622 int inschars
= XSTRING (new)->size
;
1623 int insbytes
= STRING_BYTES (XSTRING (new));
1624 int from_byte
, to_byte
;
1625 int nbytes_del
, nchars_del
;
1626 register Lisp_Object temp
;
1627 struct gcpro gcpro1
;
1628 int combined_before_bytes
, combined_after_bytes
;
1629 int adjusted_inschars
;
1631 int outgoing_insbytes
= insbytes
;
1632 Lisp_Object deletion
;
1640 int range_length
= to
- from
;
1641 prepare_to_modify_buffer (from
, to
, &from
);
1642 to
= from
+ range_length
;
1647 /* Make args be valid */
1653 from_byte
= CHAR_TO_BYTE (from
);
1654 to_byte
= CHAR_TO_BYTE (to
);
1656 nchars_del
= to
- from
;
1657 nbytes_del
= to_byte
- from_byte
;
1659 if (nbytes_del
<= 0 && insbytes
== 0)
1662 /* Make OUTGOING_INSBYTES describe the text
1663 as it will be inserted in this buffer. */
1665 if (NILP (current_buffer
->enable_multibyte_characters
))
1666 outgoing_insbytes
= inschars
;
1667 else if (! STRING_MULTIBYTE (new))
1669 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1671 /* Make sure point-max won't overflow after this insertion. */
1672 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1673 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1674 error ("Maximum buffer size exceeded");
1678 /* Make sure the gap is somewhere in or next to what we are deleting. */
1680 gap_right (from
, from_byte
);
1682 gap_left (to
, to_byte
, 0);
1684 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1687 /* Relocate all markers pointing into the new, larger gap
1688 to point at the end of the text before the gap.
1689 Do this before recording the deletion,
1690 so that undo handles this after reinserting the text. */
1691 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1693 record_delete (from
, deletion
);
1695 GAP_SIZE
+= nbytes_del
;
1698 ZV_BYTE
-= nbytes_del
;
1699 Z_BYTE
-= nbytes_del
;
1701 GPT_BYTE
= from_byte
;
1702 *(GPT_ADDR
) = 0; /* Put an anchor. */
1707 if (GPT
- BEG
< beg_unchanged
)
1708 beg_unchanged
= GPT
- BEG
;
1709 if (Z
- GPT
< end_unchanged
)
1710 end_unchanged
= Z
- GPT
;
1712 if (GAP_SIZE
< insbytes
)
1713 make_gap (insbytes
- GAP_SIZE
);
1715 /* Copy the string text into the buffer, perhaps converting
1716 between single-byte and multibyte. */
1717 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1718 STRING_MULTIBYTE (new),
1719 ! NILP (current_buffer
->enable_multibyte_characters
));
1721 /* We have copied text into the gap, but we have not altered
1722 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1723 to these functions and get the same results as we would
1724 have got earlier on. Meanwhile, GPT_ADDR does point to
1725 the text that has been stored by copy_text. */
1727 combined_before_bytes
1728 = count_combining_before (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1729 combined_after_bytes
1730 = count_combining_after (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1732 /* Record deletion of the surrounding text that combines with
1733 the insertion. This, together with recording the insertion,
1734 will add up to the right stuff in the undo list.
1736 But there is no need to actually delete the combining bytes
1737 from the buffer and reinsert them. */
1739 if (combined_after_bytes
)
1741 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1742 PT
+ combined_after_bytes
,
1743 PT_BYTE
+ combined_after_bytes
, 1);
1745 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1746 PT
+ combined_after_bytes
,
1747 PT_BYTE
+ combined_after_bytes
);
1748 record_delete (PT
, deletion
);
1751 if (combined_before_bytes
)
1753 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1755 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1757 record_delete (PT
- 1, deletion
);
1760 record_insert (PT
- !!combined_before_bytes
,
1761 inschars
- combined_before_bytes
+ !!combined_before_bytes
);
1763 GAP_SIZE
-= outgoing_insbytes
;
1767 GPT_BYTE
+= outgoing_insbytes
;
1768 ZV_BYTE
+= outgoing_insbytes
;
1769 Z_BYTE
+= outgoing_insbytes
;
1770 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1772 if (combined_after_bytes
)
1773 move_gap_both (GPT
+ combined_after_bytes
,
1774 GPT_BYTE
+ combined_after_bytes
);
1779 /* Adjust the overlay center as needed. This must be done after
1780 adjusting the markers that bound the overlays. */
1781 adjust_overlays_for_delete (from
, nchars_del
);
1782 adjust_overlays_for_insert (from
, inschars
);
1784 adjust_markers_for_insert (from
, from_byte
,
1785 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1786 combined_before_bytes
, combined_after_bytes
, 0);
1788 #ifdef USE_TEXT_PROPERTIES
1789 offset_intervals (current_buffer
, PT
, inschars
- nchars_del
);
1791 /* Get the intervals for the part of the string we are inserting--
1792 not including the combined-before bytes. */
1793 intervals
= XSTRING (new)->intervals
;
1794 /* Insert those intervals. */
1795 graft_intervals_into_buffer (intervals
, from
, inschars
,
1796 current_buffer
, inherit
);
1799 /* Relocate point as if it were a marker. */
1801 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)
1802 + combined_after_bytes
),
1803 (from_byte
+ outgoing_insbytes
1804 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)
1805 + combined_after_bytes
));
1807 if (combined_after_bytes
)
1808 combine_bytes (from
+ inschars
, from_byte
+ outgoing_insbytes
,
1809 combined_after_bytes
);
1811 if (combined_before_bytes
)
1812 combine_bytes (from
, from_byte
, combined_before_bytes
);
1814 if (outgoing_insbytes
== 0)
1815 evaporate_overlays (from
);
1822 signal_after_change (from
, nchars_del
, PT
- from
);
1825 /* Delete characters in current buffer
1826 from FROM up to (but not including) TO.
1827 If TO comes before FROM, we delete nothing. */
1830 del_range (from
, to
)
1831 register int from
, to
;
1833 del_range_1 (from
, to
, 1);
1836 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer. */
1839 del_range_1 (from
, to
, prepare
)
1840 int from
, to
, prepare
;
1842 int from_byte
, to_byte
;
1844 /* Make args be valid */
1855 int range_length
= to
- from
;
1856 prepare_to_modify_buffer (from
, to
, &from
);
1857 to
= from
+ range_length
;
1860 from_byte
= CHAR_TO_BYTE (from
);
1861 to_byte
= CHAR_TO_BYTE (to
);
1863 del_range_2 (from
, from_byte
, to
, to_byte
);
1866 /* Like del_range_1 but args are byte positions, not char positions. */
1869 del_range_byte (from_byte
, to_byte
, prepare
)
1870 int from_byte
, to_byte
, prepare
;
1874 /* Make args be valid */
1875 if (from_byte
< BEGV_BYTE
)
1876 from_byte
= BEGV_BYTE
;
1877 if (to_byte
> ZV_BYTE
)
1880 if (to_byte
<= from_byte
)
1883 from
= BYTE_TO_CHAR (from_byte
);
1884 to
= BYTE_TO_CHAR (to_byte
);
1888 int old_from
= from
, old_to
= Z
- to
;
1889 int range_length
= to
- from
;
1890 prepare_to_modify_buffer (from
, to
, &from
);
1891 to
= from
+ range_length
;
1893 if (old_from
!= from
)
1894 from_byte
= CHAR_TO_BYTE (from
);
1895 if (old_to
== Z
- to
)
1896 to_byte
= CHAR_TO_BYTE (to
);
1899 del_range_2 (from
, from_byte
, to
, to_byte
);
1902 /* Like del_range_1, but positions are specified both as charpos
1906 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1907 int from
, from_byte
, to
, to_byte
, prepare
;
1909 /* Make args be valid */
1910 if (from_byte
< BEGV_BYTE
)
1911 from_byte
= BEGV_BYTE
;
1912 if (to_byte
> ZV_BYTE
)
1915 if (to_byte
<= from_byte
)
1925 int old_from
= from
, old_to
= Z
- to
;
1926 int range_length
= to
- from
;
1927 prepare_to_modify_buffer (from
, to
, &from
);
1928 to
= from
+ range_length
;
1930 if (old_from
!= from
)
1931 from_byte
= CHAR_TO_BYTE (from
);
1932 if (old_to
== Z
- to
)
1933 to_byte
= CHAR_TO_BYTE (to
);
1936 del_range_2 (from
, from_byte
, to
, to_byte
);
1939 /* Delete a range of text, specified both as character positions
1940 and byte positions. FROM and TO are character positions,
1941 while FROM_BYTE and TO_BYTE are byte positions. */
1944 del_range_2 (from
, from_byte
, to
, to_byte
)
1945 int from
, from_byte
, to
, to_byte
;
1947 register int nbytes_del
, nchars_del
;
1948 int combined_after_bytes
;
1949 Lisp_Object deletion
;
1954 nchars_del
= to
- from
;
1955 nbytes_del
= to_byte
- from_byte
;
1957 /* Make sure the gap is somewhere in or next to what we are deleting. */
1959 gap_right (from
, from_byte
);
1961 gap_left (to
, to_byte
, 0);
1963 combined_after_bytes
1964 = count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1965 ZV_BYTE
- to_byte
, from
, from_byte
);
1966 if (combined_after_bytes
)
1968 from_byte_1
= from_byte
;
1969 DEC_POS (from_byte_1
);
1972 from_byte_1
= from_byte
;
1975 = make_buffer_string_both (from
- !!combined_after_bytes
,
1977 to
+ combined_after_bytes
,
1978 to_byte
+ combined_after_bytes
, 1);
1979 if (combined_after_bytes
)
1980 /* COMBINED_AFTER_BYTES nonzero means that the above code moved
1981 the gap. We must move the gap again to a proper place. */
1982 move_gap_both (from
, from_byte
);
1984 /* Relocate all markers pointing into the new, larger gap
1985 to point at the end of the text before the gap.
1986 Do this before recording the deletion,
1987 so that undo handles this after reinserting the text. */
1988 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1989 if (combined_after_bytes
)
1991 /* Adjust markers for the phony deletion
1992 that we are about to call record_undo for. */
1994 /* Here we delete the markers that formerly
1995 pointed at TO ... TO + COMBINED_AFTER_BYTES.
1996 But because of the call to adjust_markers_for_delete, above,
1997 they now point at FROM ... FROM + COMBINED_AFTER_BYTES. */
1998 adjust_markers_for_record_delete (from
, from_byte
,
1999 from
+ combined_after_bytes
,
2000 from_byte
+ combined_after_bytes
);
2002 adjust_markers_for_record_delete (from
- 1, from_byte_1
,
2005 record_delete (from
- !!combined_after_bytes
, deletion
);
2008 /* Relocate point as if it were a marker. */
2010 adjust_point (from
- (PT
< to
? PT
: to
),
2011 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
2013 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2014 offset_intervals (current_buffer
, from
, - nchars_del
);
2016 /* Adjust the overlay center as needed. This must be done after
2017 adjusting the markers that bound the overlays. */
2018 adjust_overlays_for_delete (from
, nchars_del
);
2020 GAP_SIZE
+= nbytes_del
;
2021 ZV_BYTE
-= nbytes_del
;
2022 Z_BYTE
-= nbytes_del
;
2026 GPT_BYTE
= from_byte
;
2028 if (combined_after_bytes
)
2029 move_gap_both (GPT
+ combined_after_bytes
,
2030 GPT_BYTE
+ combined_after_bytes
);
2032 *(GPT_ADDR
) = 0; /* Put an anchor. */
2037 if (GPT
- BEG
< beg_unchanged
)
2038 beg_unchanged
= GPT
- BEG
;
2039 if (Z
- GPT
< end_unchanged
)
2040 end_unchanged
= Z
- GPT
;
2042 if (combined_after_bytes
)
2044 combine_bytes (from
, from_byte
, combined_after_bytes
);
2046 record_insert (GPT
- 1, 1);
2051 evaporate_overlays (from
);
2052 signal_after_change (from
, nchars_del
, 0);
2055 /* Call this if you're about to change the region of BUFFER from
2056 character positions START to END. This checks the read-only
2057 properties of the region, calls the necessary modification hooks,
2058 and warns the next redisplay that it should pay attention to that
2062 modify_region (buffer
, start
, end
)
2063 struct buffer
*buffer
;
2066 struct buffer
*old_buffer
= current_buffer
;
2068 if (buffer
!= old_buffer
)
2069 set_buffer_internal (buffer
);
2071 prepare_to_modify_buffer (start
, end
, NULL
);
2073 if (start
- 1 < beg_unchanged
2074 || (unchanged_modified
== MODIFF
2075 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2076 beg_unchanged
= start
- 1;
2077 if (Z
- end
< end_unchanged
2078 || (unchanged_modified
== MODIFF
2079 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2080 end_unchanged
= Z
- end
;
2082 if (MODIFF
<= SAVE_MODIFF
)
2083 record_first_change ();
2086 buffer
->point_before_scroll
= Qnil
;
2088 if (buffer
!= old_buffer
)
2089 set_buffer_internal (old_buffer
);
2092 /* Check that it is okay to modify the buffer between START and END,
2093 which are char positions.
2095 Run the before-change-function, if any. If intervals are in use,
2096 verify that the text to be modified is not read-only, and call
2097 any modification properties the text may have.
2099 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2100 by holding its value temporarily in a marker. */
2103 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2107 if (!NILP (current_buffer
->read_only
))
2108 Fbarf_if_buffer_read_only ();
2110 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2111 if (BUF_INTERVALS (current_buffer
) != 0)
2115 Lisp_Object preserve_marker
;
2116 struct gcpro gcpro1
;
2117 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2118 GCPRO1 (preserve_marker
);
2119 verify_interval_modification (current_buffer
, start
, end
);
2120 *preserve_ptr
= marker_position (preserve_marker
);
2121 unchain_marker (preserve_marker
);
2125 verify_interval_modification (current_buffer
, start
, end
);
2128 #ifdef CLASH_DETECTION
2129 if (!NILP (current_buffer
->file_truename
)
2130 /* Make binding buffer-file-name to nil effective. */
2131 && !NILP (current_buffer
->filename
)
2132 && SAVE_MODIFF
>= MODIFF
)
2133 lock_file (current_buffer
->file_truename
);
2135 /* At least warn if this file has changed on disk since it was visited. */
2136 if (!NILP (current_buffer
->filename
)
2137 && SAVE_MODIFF
>= MODIFF
2138 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2139 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2140 call1 (intern ("ask-user-about-supersession-threat"),
2141 current_buffer
->filename
);
2142 #endif /* not CLASH_DETECTION */
2144 signal_before_change (start
, end
, preserve_ptr
);
2146 if (current_buffer
->newline_cache
)
2147 invalidate_region_cache (current_buffer
,
2148 current_buffer
->newline_cache
,
2149 start
- BEG
, Z
- end
);
2150 if (current_buffer
->width_run_cache
)
2151 invalidate_region_cache (current_buffer
,
2152 current_buffer
->width_run_cache
,
2153 start
- BEG
, Z
- end
);
2155 Vdeactivate_mark
= Qt
;
2158 /* These macros work with an argument named `preserve_ptr'
2159 and a local variable named `preserve_marker'. */
2161 #define PRESERVE_VALUE \
2162 if (preserve_ptr && NILP (preserve_marker)) \
2163 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2165 #define RESTORE_VALUE \
2166 if (! NILP (preserve_marker)) \
2168 *preserve_ptr = marker_position (preserve_marker); \
2169 unchain_marker (preserve_marker); \
2172 #define PRESERVE_START_END \
2173 if (NILP (start_marker)) \
2174 start_marker = Fcopy_marker (start, Qnil); \
2175 if (NILP (end_marker)) \
2176 end_marker = Fcopy_marker (end, Qnil);
2178 #define FETCH_START \
2179 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2182 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2184 /* Signal a change to the buffer immediately before it happens.
2185 START_INT and END_INT are the bounds of the text to be changed.
2187 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2188 by holding its value temporarily in a marker. */
2191 signal_before_change (start_int
, end_int
, preserve_ptr
)
2192 int start_int
, end_int
;
2195 Lisp_Object start
, end
;
2196 Lisp_Object start_marker
, end_marker
;
2197 Lisp_Object preserve_marker
;
2198 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2200 start
= make_number (start_int
);
2201 end
= make_number (end_int
);
2202 preserve_marker
= Qnil
;
2203 start_marker
= Qnil
;
2205 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2207 /* If buffer is unmodified, run a special hook for that case. */
2208 if (SAVE_MODIFF
>= MODIFF
2209 && !NILP (Vfirst_change_hook
)
2210 && !NILP (Vrun_hooks
))
2214 call1 (Vrun_hooks
, Qfirst_change_hook
);
2217 /* Run the before-change-function if any.
2218 We don't bother "binding" this variable to nil
2219 because it is obsolete anyway and new code should not use it. */
2220 if (!NILP (Vbefore_change_function
))
2224 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
2227 /* Now run the before-change-functions if any. */
2228 if (!NILP (Vbefore_change_functions
))
2230 Lisp_Object args
[3];
2231 Lisp_Object before_change_functions
;
2232 Lisp_Object after_change_functions
;
2233 struct gcpro gcpro1
, gcpro2
;
2238 /* "Bind" before-change-functions and after-change-functions
2239 to nil--but in a way that errors don't know about.
2240 That way, if there's an error in them, they will stay nil. */
2241 before_change_functions
= Vbefore_change_functions
;
2242 after_change_functions
= Vafter_change_functions
;
2243 Vbefore_change_functions
= Qnil
;
2244 Vafter_change_functions
= Qnil
;
2245 GCPRO2 (before_change_functions
, after_change_functions
);
2247 /* Actually run the hook functions. */
2248 args
[0] = Qbefore_change_functions
;
2249 args
[1] = FETCH_START
;
2250 args
[2] = FETCH_END
;
2251 run_hook_list_with_args (before_change_functions
, 3, args
);
2253 /* "Unbind" the variables we "bound" to nil. */
2254 Vbefore_change_functions
= before_change_functions
;
2255 Vafter_change_functions
= after_change_functions
;
2259 if (!NILP (current_buffer
->overlays_before
)
2260 || !NILP (current_buffer
->overlays_after
))
2263 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2264 FETCH_START
, FETCH_END
, Qnil
);
2267 if (! NILP (start_marker
))
2268 free_marker (start_marker
);
2269 if (! NILP (end_marker
))
2270 free_marker (end_marker
);
2275 /* Signal a change immediately after it happens.
2276 CHARPOS is the character position of the start of the changed text.
2277 LENDEL is the number of characters of the text before the change.
2278 (Not the whole buffer; just the part that was changed.)
2279 LENINS is the number of characters in that part of the text
2280 after the change. */
2283 signal_after_change (charpos
, lendel
, lenins
)
2284 int charpos
, lendel
, lenins
;
2286 /* If we are deferring calls to the after-change functions
2287 and there are no before-change functions,
2288 just record the args that we were going to use. */
2289 if (! NILP (Vcombine_after_change_calls
)
2290 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
2291 && NILP (current_buffer
->overlays_before
)
2292 && NILP (current_buffer
->overlays_after
))
2296 if (!NILP (combine_after_change_list
)
2297 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2298 Fcombine_after_change_execute ();
2300 elt
= Fcons (make_number (charpos
- BEG
),
2301 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2302 Fcons (make_number (lenins
- lendel
), Qnil
)));
2303 combine_after_change_list
2304 = Fcons (elt
, combine_after_change_list
);
2305 combine_after_change_buffer
= Fcurrent_buffer ();
2310 if (!NILP (combine_after_change_list
))
2311 Fcombine_after_change_execute ();
2313 /* Run the after-change-function if any.
2314 We don't bother "binding" this variable to nil
2315 because it is obsolete anyway and new code should not use it. */
2316 if (!NILP (Vafter_change_function
))
2317 call3 (Vafter_change_function
,
2318 make_number (charpos
), make_number (charpos
+ lenins
),
2319 make_number (lendel
));
2321 if (!NILP (Vafter_change_functions
))
2323 Lisp_Object args
[4];
2324 Lisp_Object before_change_functions
;
2325 Lisp_Object after_change_functions
;
2326 struct gcpro gcpro1
, gcpro2
;
2328 /* "Bind" before-change-functions and after-change-functions
2329 to nil--but in a way that errors don't know about.
2330 That way, if there's an error in them, they will stay nil. */
2331 before_change_functions
= Vbefore_change_functions
;
2332 after_change_functions
= Vafter_change_functions
;
2333 Vbefore_change_functions
= Qnil
;
2334 Vafter_change_functions
= Qnil
;
2335 GCPRO2 (before_change_functions
, after_change_functions
);
2337 /* Actually run the hook functions. */
2338 args
[0] = Qafter_change_functions
;
2339 XSETFASTINT (args
[1], charpos
);
2340 XSETFASTINT (args
[2], charpos
+ lenins
);
2341 XSETFASTINT (args
[3], lendel
);
2342 run_hook_list_with_args (after_change_functions
,
2345 /* "Unbind" the variables we "bound" to nil. */
2346 Vbefore_change_functions
= before_change_functions
;
2347 Vafter_change_functions
= after_change_functions
;
2351 if (!NILP (current_buffer
->overlays_before
)
2352 || !NILP (current_buffer
->overlays_after
))
2353 report_overlay_modification (make_number (charpos
),
2354 make_number (charpos
+ lenins
),
2356 make_number (charpos
),
2357 make_number (charpos
+ lenins
),
2358 make_number (lendel
));
2360 /* After an insertion, call the text properties
2361 insert-behind-hooks or insert-in-front-hooks. */
2363 report_interval_modification (charpos
, charpos
+ lenins
);
2367 Fcombine_after_change_execute_1 (val
)
2370 Vcombine_after_change_calls
= val
;
2374 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2375 Scombine_after_change_execute
, 0, 0, 0,
2376 "This function is for use internally in `combine-after-change-calls'.")
2379 register Lisp_Object val
;
2380 int count
= specpdl_ptr
- specpdl
;
2381 int beg
, end
, change
;
2385 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2387 Fset_buffer (combine_after_change_buffer
);
2389 /* # chars unchanged at beginning of buffer. */
2391 /* # chars unchanged at end of buffer. */
2393 /* Total amount of insertion (negative for deletion). */
2396 /* Scan the various individual changes,
2397 accumulating the range info in BEG, END and CHANGE. */
2398 for (tail
= combine_after_change_list
; CONSP (tail
);
2399 tail
= XCONS (tail
)->cdr
)
2402 int thisbeg
, thisend
, thischange
;
2404 /* Extract the info from the next element. */
2405 elt
= XCONS (tail
)->car
;
2408 thisbeg
= XINT (XCONS (elt
)->car
);
2410 elt
= XCONS (elt
)->cdr
;
2413 thisend
= XINT (XCONS (elt
)->car
);
2415 elt
= XCONS (elt
)->cdr
;
2418 thischange
= XINT (XCONS (elt
)->car
);
2420 /* Merge this range into the accumulated range. */
2421 change
+= thischange
;
2428 /* Get the current start and end positions of the range
2429 that was changed. */
2433 /* We are about to handle these, so discard them. */
2434 combine_after_change_list
= Qnil
;
2436 /* Now run the after-change functions for real.
2437 Turn off the flag that defers them. */
2438 record_unwind_protect (Fcombine_after_change_execute_1
,
2439 Vcombine_after_change_calls
);
2440 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2442 return unbind_to (count
, val
);
2448 staticpro (&combine_after_change_list
);
2449 combine_after_change_list
= Qnil
;
2451 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2452 "Non-nil means enable debugging checks for invalid marker positions.");
2453 check_markers_debug_flag
= 0;
2454 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2455 "Used internally by the `combine-after-change-calls' macro.");
2456 Vcombine_after_change_calls
= Qnil
;
2458 defsubr (&Scombine_after_change_execute
);