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
;
710 bytes_left
-= 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 /* Do this before moving and increasing the gap,
1025 because the before-change hooks might move the gap
1026 or make it smaller. */
1027 prepare_to_modify_buffer (PT
, PT
, NULL
);
1030 move_gap_both (PT
, PT_BYTE
);
1031 if (GAP_SIZE
< nbytes
)
1032 make_gap (nbytes
- GAP_SIZE
);
1034 combined_before_bytes
1035 = count_combining_before (string
, nbytes
, PT
, PT_BYTE
);
1036 combined_after_bytes
1037 = count_combining_after (string
, nbytes
, PT
, PT_BYTE
);
1039 /* Record deletion of the surrounding text that combines with
1040 the insertion. This, together with recording the insertion,
1041 will add up to the right stuff in the undo list.
1043 But there is no need to actually delete the combining bytes
1044 from the buffer and reinsert them. */
1046 if (combined_after_bytes
)
1048 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1049 PT
+ combined_after_bytes
,
1050 PT_BYTE
+ combined_after_bytes
, 1);
1052 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1053 PT
+ combined_after_bytes
,
1054 PT_BYTE
+ combined_after_bytes
);
1055 record_delete (PT
, deletion
);
1058 if (combined_before_bytes
)
1060 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1062 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1064 record_delete (PT
- 1, deletion
);
1067 record_insert (PT
- !!combined_before_bytes
,
1068 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1071 bcopy (string
, GPT_ADDR
, nbytes
);
1074 /* When we have combining at the end of the insertion,
1075 this is the character position before the combined character. */
1082 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1084 if (combined_after_bytes
)
1085 move_gap_both (GPT
+ combined_after_bytes
,
1086 GPT_BYTE
+ combined_after_bytes
);
1091 adjust_overlays_for_insert (PT
, nchars
);
1092 adjust_markers_for_insert (PT
, PT_BYTE
,
1093 PT
+ nchars
, PT_BYTE
+ nbytes
,
1094 combined_before_bytes
, combined_after_bytes
,
1097 #ifdef USE_TEXT_PROPERTIES
1098 if (BUF_INTERVALS (current_buffer
) != 0)
1099 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1100 offset_intervals (current_buffer
, PT
, nchars
);
1102 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1103 Fset_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1108 int pos
= PT
, pos_byte
= PT_BYTE
;
1110 adjust_point (nchars
+ combined_after_bytes
,
1111 nbytes
+ combined_after_bytes
);
1113 if (combined_after_bytes
)
1114 combine_bytes (pos
+ nchars
, pos_byte
+ nbytes
, combined_after_bytes
);
1116 if (combined_before_bytes
)
1117 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1121 /* Insert the part of the text of STRING, a Lisp object assumed to be
1122 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1123 starting at position POS / POS_BYTE. If the text of STRING has properties,
1124 copy them into the buffer.
1126 It does not work to use `insert' for this, because a GC could happen
1127 before we bcopy the stuff into the buffer, and relocate the string
1128 without insert noticing. */
1131 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1133 register int pos
, pos_byte
, length
, length_byte
;
1137 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1139 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
;
1153 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1155 signal_after_change (opoint
, 0, PT
- opoint
);
1158 /* Subroutine of the insertion functions above. */
1161 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1162 inherit
, before_markers
)
1164 register int pos
, pos_byte
, nchars
, nbytes
;
1165 int inherit
, before_markers
;
1167 register Lisp_Object temp
;
1168 struct gcpro gcpro1
;
1169 int outgoing_nbytes
= nbytes
;
1170 int combined_before_bytes
, combined_after_bytes
;
1171 int adjusted_nchars
;
1173 Lisp_Object deletion
;
1175 /* Make OUTGOING_NBYTES describe the text
1176 as it will be inserted in this buffer. */
1178 if (NILP (current_buffer
->enable_multibyte_characters
))
1179 outgoing_nbytes
= nchars
;
1180 else if (! STRING_MULTIBYTE (string
))
1182 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1186 /* Do this before moving and increasing the gap,
1187 because the before-change hooks might move the gap
1188 or make it smaller. */
1189 prepare_to_modify_buffer (PT
, PT
, NULL
);
1192 move_gap_both (PT
, PT_BYTE
);
1193 if (GAP_SIZE
< nbytes
)
1194 make_gap (outgoing_nbytes
- GAP_SIZE
);
1197 /* Copy the string text into the buffer, perhaps converting
1198 between single-byte and multibyte. */
1199 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1200 STRING_MULTIBYTE (string
),
1201 ! NILP (current_buffer
->enable_multibyte_characters
));
1203 /* We have copied text into the gap, but we have not altered
1204 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1205 to these functions and get the same results as we would
1206 have got earlier on. Meanwhile, PT_ADDR does point to
1207 the text that has been stored by copy_text. */
1209 combined_before_bytes
1210 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1211 combined_after_bytes
1212 = count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1214 /* Record deletion of the surrounding text that combines with
1215 the insertion. This, together with recording the insertion,
1216 will add up to the right stuff in the undo list.
1218 But there is no need to actually delete the combining bytes
1219 from the buffer and reinsert them. */
1221 if (combined_after_bytes
)
1223 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1224 PT
+ combined_after_bytes
,
1225 PT_BYTE
+ combined_after_bytes
, 1);
1227 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1228 PT
+ combined_after_bytes
,
1229 PT_BYTE
+ combined_after_bytes
);
1230 record_delete (PT
, deletion
);
1233 if (combined_before_bytes
)
1235 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1237 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1239 record_delete (PT
- 1, deletion
);
1242 record_insert (PT
- !!combined_before_bytes
,
1243 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1246 GAP_SIZE
-= outgoing_nbytes
;
1250 GPT_BYTE
+= outgoing_nbytes
;
1251 ZV_BYTE
+= outgoing_nbytes
;
1252 Z_BYTE
+= outgoing_nbytes
;
1253 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1255 if (combined_after_bytes
)
1256 move_gap_both (GPT
+ combined_after_bytes
,
1257 GPT_BYTE
+ combined_after_bytes
);
1262 adjust_overlays_for_insert (PT
, nchars
);
1263 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1264 PT_BYTE
+ outgoing_nbytes
,
1265 combined_before_bytes
, combined_after_bytes
,
1268 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1269 offset_intervals (current_buffer
, PT
, nchars
);
1271 intervals
= XSTRING (string
)->intervals
;
1272 /* Get the intervals for the part of the string we are inserting--
1273 not including the combined-before bytes. */
1274 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1275 intervals
= copy_intervals (intervals
, pos
, nchars
);
1277 /* Insert those intervals. */
1278 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1279 current_buffer
, inherit
);
1282 int pos
= PT
, pos_byte
= PT_BYTE
;
1284 adjust_point (nchars
+ combined_after_bytes
,
1285 outgoing_nbytes
+ combined_after_bytes
);
1287 if (combined_after_bytes
)
1288 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1289 combined_after_bytes
);
1291 if (combined_before_bytes
)
1292 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1296 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1297 current buffer. If the text in BUF has properties, they are absorbed
1298 into the current buffer.
1300 It does not work to use `insert' for this, because a malloc could happen
1301 and relocate BUF's text before the bcopy happens. */
1304 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1306 int charpos
, nchars
;
1311 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1312 signal_after_change (opoint
, 0, PT
- opoint
);
1316 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1321 register Lisp_Object temp
, deletion
;
1323 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1324 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1325 int incoming_nbytes
= to_byte
- from_byte
;
1326 int outgoing_nbytes
= incoming_nbytes
;
1327 int combined_before_bytes
, combined_after_bytes
;
1328 int adjusted_nchars
;
1331 /* Make OUTGOING_NBYTES describe the text
1332 as it will be inserted in this buffer. */
1334 if (NILP (current_buffer
->enable_multibyte_characters
))
1335 outgoing_nbytes
= nchars
;
1336 else if (NILP (buf
->enable_multibyte_characters
))
1338 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1341 /* Make sure point-max won't overflow after this insertion. */
1342 XSETINT (temp
, outgoing_nbytes
+ Z
);
1343 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1344 error ("Maximum buffer size exceeded");
1346 /* Do this before moving and increasing the gap,
1347 because the before-change hooks might move the gap
1348 or make it smaller. */
1349 prepare_to_modify_buffer (PT
, PT
, NULL
);
1352 move_gap_both (PT
, PT_BYTE
);
1353 if (GAP_SIZE
< outgoing_nbytes
)
1354 make_gap (outgoing_nbytes
- GAP_SIZE
);
1356 if (from
< BUF_GPT (buf
))
1358 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1359 if (chunk
> incoming_nbytes
)
1360 chunk
= incoming_nbytes
;
1361 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1363 ! NILP (buf
->enable_multibyte_characters
),
1364 ! NILP (current_buffer
->enable_multibyte_characters
));
1368 if (chunk
< incoming_nbytes
)
1369 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1370 GPT_ADDR
+ chunk
, incoming_nbytes
- chunk
,
1371 ! NILP (buf
->enable_multibyte_characters
),
1372 ! NILP (current_buffer
->enable_multibyte_characters
));
1374 /* We have copied text into the gap, but we have not altered
1375 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1376 to these functions and get the same results as we would
1377 have got earlier on. Meanwhile, GPT_ADDR does point to
1378 the text that has been stored by copy_text. */
1379 combined_before_bytes
1380 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1381 combined_after_bytes
1382 = count_combining_after (GPT_ADDR
, outgoing_nbytes
,
1385 /* Record deletion of the surrounding text that combines with
1386 the insertion. This, together with recording the insertion,
1387 will add up to the right stuff in the undo list.
1389 But there is no need to actually delete the combining bytes
1390 from the buffer and reinsert them. */
1392 if (combined_after_bytes
)
1394 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1395 PT
+ combined_after_bytes
,
1396 PT_BYTE
+ combined_after_bytes
, 1);
1398 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1399 PT
+ combined_after_bytes
,
1400 PT_BYTE
+ combined_after_bytes
);
1401 record_delete (PT
, deletion
);
1404 if (combined_before_bytes
)
1406 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1408 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1410 record_delete (PT
- 1, deletion
);
1413 record_insert (PT
- !!combined_before_bytes
,
1414 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1417 GAP_SIZE
-= outgoing_nbytes
;
1421 GPT_BYTE
+= outgoing_nbytes
;
1422 ZV_BYTE
+= outgoing_nbytes
;
1423 Z_BYTE
+= outgoing_nbytes
;
1424 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1426 if (combined_after_bytes
)
1427 move_gap_both (GPT
+ combined_after_bytes
,
1428 GPT_BYTE
+ combined_after_bytes
);
1433 adjust_overlays_for_insert (PT
, nchars
);
1434 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1435 PT_BYTE
+ outgoing_nbytes
,
1436 combined_before_bytes
, combined_after_bytes
, 0);
1438 #ifdef USE_TEXT_PROPERTIES
1439 if (BUF_INTERVALS (current_buffer
) != 0)
1440 offset_intervals (current_buffer
, PT
, nchars
);
1443 /* Get the intervals for the part of the string we are inserting--
1444 not including the combined-before bytes. */
1445 intervals
= BUF_INTERVALS (buf
);
1446 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1447 intervals
= copy_intervals (intervals
, from
, nchars
);
1449 /* Insert those intervals. */
1450 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1453 int pos
= PT
, pos_byte
= PT_BYTE
;
1455 adjust_point (nchars
+ combined_after_bytes
,
1456 outgoing_nbytes
+ combined_after_bytes
);
1458 if (combined_after_bytes
)
1459 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1460 combined_after_bytes
);
1462 if (combined_before_bytes
)
1463 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1467 /* This function should be called after moving gap to FROM and before
1468 altering text between FROM and TO. This adjusts various position
1469 keepers and markers as if the text is deleted. Don't forget to
1470 call adjust_after_replace after you actually alter the text. */
1473 adjust_before_replace (from
, from_byte
, to
, to_byte
)
1474 int from
, from_byte
, to
, to_byte
;
1476 Lisp_Object deletion
;
1477 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1481 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1482 record_delete (from
, deletion
);
1483 adjust_overlays_for_delete (from
, to
- from
);
1486 /* Record undo information and adjust markers and position keepers for
1487 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1488 chars (LEN_BYTE bytes) which resides in the gap just after
1491 PREV_TEXT nil means the new text was just inserted. */
1494 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1495 int from
, from_byte
, len
, len_byte
;
1496 Lisp_Object prev_text
;
1498 int combined_before_bytes
1499 = count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
);
1500 int combined_after_bytes
1501 = count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
);
1502 Lisp_Object deletion
;
1503 int nchars_del
= 0, nbytes_del
= 0;
1505 if (combined_after_bytes
)
1507 deletion
= make_buffer_string_both (from
, from_byte
,
1508 from
+ combined_after_bytes
,
1509 from_byte
+ combined_after_bytes
, 1);
1511 adjust_markers_for_record_delete (from
, from_byte
,
1512 from
+ combined_after_bytes
,
1513 from_byte
+ combined_after_bytes
);
1514 record_delete (from
, deletion
);
1517 if (combined_before_bytes
)
1519 deletion
= make_buffer_string_both (from
- 1, CHAR_TO_BYTE (from
- 1),
1520 from
, from_byte
, 1);
1521 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1523 record_delete (from
- 1, deletion
);
1526 /* Update various buffer positions for the new text. */
1527 GAP_SIZE
-= len_byte
;
1529 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1530 GPT
+= len
; GPT_BYTE
+= len_byte
;
1531 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1533 if (combined_after_bytes
)
1534 move_gap_both (GPT
+ combined_after_bytes
,
1535 GPT_BYTE
+ combined_after_bytes
);
1537 if (STRINGP (prev_text
))
1539 nchars_del
= XSTRING (prev_text
)->size
;
1540 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1542 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1544 combined_before_bytes
, combined_after_bytes
);
1545 if (STRINGP (prev_text
))
1546 record_delete (from
, prev_text
);
1547 record_insert (from
- !!combined_before_bytes
,
1548 len
- combined_before_bytes
+ !!combined_before_bytes
);
1550 if (len
> nchars_del
)
1551 adjust_overlays_for_insert (from
, len
- nchars_del
);
1552 else if (len
< nchars_del
)
1553 adjust_overlays_for_delete (from
, nchars_del
- len
);
1554 #ifdef USE_TEXT_PROPERTIES
1555 if (BUF_INTERVALS (current_buffer
) != 0)
1556 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1560 int pos
= PT
, pos_byte
= PT_BYTE
;
1563 adjust_point (len
- nchars_del
+ combined_after_bytes
,
1564 len_byte
- nbytes_del
+ combined_after_bytes
);
1565 else if (from
== PT
&& combined_before_bytes
)
1566 adjust_point (0, combined_before_bytes
);
1568 if (combined_after_bytes
)
1569 combine_bytes (from
+ len
, from_byte
+ len_byte
, combined_after_bytes
);
1571 if (combined_before_bytes
)
1572 combine_bytes (from
, from_byte
, combined_before_bytes
);
1578 evaporate_overlays (from
);
1582 /* Record undo information, adjust markers and position keepers for an
1583 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1584 text already exists in the current buffer but character length (TO
1585 - FROM) may be incorrect, the correct length is NEWLEN. */
1588 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1589 int from
, from_byte
, to
, to_byte
, newlen
;
1591 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1594 move_gap_both (to
, to_byte
);
1595 GAP_SIZE
+= len_byte
;
1596 GPT
-= len
; GPT_BYTE
-= len_byte
;
1597 ZV
-= len
; ZV_BYTE
-= len_byte
;
1598 Z
-= len
; Z_BYTE
-= len_byte
;
1599 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1602 /* Replace the text from character positions FROM to TO with NEW,
1603 If PREPARE is nonzero, call prepare_to_modify_buffer.
1604 If INHERIT, the newly inserted text should inherit text properties
1605 from the surrounding non-deleted text. */
1607 /* Note that this does not yet handle markers quite right.
1608 Also it needs to record a single undo-entry that does a replacement
1609 rather than a separate delete and insert.
1610 That way, undo will also handle markers properly. */
1613 replace_range (from
, to
, new, prepare
, inherit
, nomarkers
)
1615 int from
, to
, prepare
, inherit
, nomarkers
;
1617 int inschars
= XSTRING (new)->size
;
1618 int insbytes
= STRING_BYTES (XSTRING (new));
1619 int from_byte
, to_byte
;
1620 int nbytes_del
, nchars_del
;
1621 register Lisp_Object temp
;
1622 struct gcpro gcpro1
;
1623 int combined_before_bytes
, combined_after_bytes
;
1624 int adjusted_inschars
;
1626 int outgoing_insbytes
= insbytes
;
1627 Lisp_Object deletion
;
1635 int range_length
= to
- from
;
1636 prepare_to_modify_buffer (from
, to
, &from
);
1637 to
= from
+ range_length
;
1642 /* Make args be valid */
1648 from_byte
= CHAR_TO_BYTE (from
);
1649 to_byte
= CHAR_TO_BYTE (to
);
1651 nchars_del
= to
- from
;
1652 nbytes_del
= to_byte
- from_byte
;
1654 if (nbytes_del
<= 0 && insbytes
== 0)
1657 /* Make OUTGOING_INSBYTES describe the text
1658 as it will be inserted in this buffer. */
1660 if (NILP (current_buffer
->enable_multibyte_characters
))
1661 outgoing_insbytes
= inschars
;
1662 else if (! STRING_MULTIBYTE (new))
1664 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1666 /* Make sure point-max won't overflow after this insertion. */
1667 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1668 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1669 error ("Maximum buffer size exceeded");
1673 /* Make sure the gap is somewhere in or next to what we are deleting. */
1675 gap_right (from
, from_byte
);
1677 gap_left (to
, to_byte
, 0);
1679 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1682 /* Relocate all markers pointing into the new, larger gap
1683 to point at the end of the text before the gap.
1684 Do this before recording the deletion,
1685 so that undo handles this after reinserting the text. */
1686 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1688 record_delete (from
, deletion
);
1690 GAP_SIZE
+= nbytes_del
;
1693 ZV_BYTE
-= nbytes_del
;
1694 Z_BYTE
-= nbytes_del
;
1696 GPT_BYTE
= from_byte
;
1697 *(GPT_ADDR
) = 0; /* Put an anchor. */
1702 if (GPT
- BEG
< beg_unchanged
)
1703 beg_unchanged
= GPT
- BEG
;
1704 if (Z
- GPT
< end_unchanged
)
1705 end_unchanged
= Z
- GPT
;
1707 if (GAP_SIZE
< insbytes
)
1708 make_gap (insbytes
- GAP_SIZE
);
1710 /* Copy the string text into the buffer, perhaps converting
1711 between single-byte and multibyte. */
1712 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1713 STRING_MULTIBYTE (new),
1714 ! NILP (current_buffer
->enable_multibyte_characters
));
1716 /* We have copied text into the gap, but we have not altered
1717 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1718 to these functions and get the same results as we would
1719 have got earlier on. Meanwhile, GPT_ADDR does point to
1720 the text that has been stored by copy_text. */
1722 combined_before_bytes
1723 = count_combining_before (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1724 combined_after_bytes
1725 = count_combining_after (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1727 /* Record deletion of the surrounding text that combines with
1728 the insertion. This, together with recording the insertion,
1729 will add up to the right stuff in the undo list.
1731 But there is no need to actually delete the combining bytes
1732 from the buffer and reinsert them. */
1734 if (combined_after_bytes
)
1736 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1737 PT
+ combined_after_bytes
,
1738 PT_BYTE
+ combined_after_bytes
, 1);
1740 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1741 PT
+ combined_after_bytes
,
1742 PT_BYTE
+ combined_after_bytes
);
1743 record_delete (PT
, deletion
);
1746 if (combined_before_bytes
)
1748 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1750 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1752 record_delete (PT
- 1, deletion
);
1755 record_insert (PT
- !!combined_before_bytes
,
1756 inschars
- combined_before_bytes
+ !!combined_before_bytes
);
1758 GAP_SIZE
-= outgoing_insbytes
;
1762 GPT_BYTE
+= outgoing_insbytes
;
1763 ZV_BYTE
+= outgoing_insbytes
;
1764 Z_BYTE
+= outgoing_insbytes
;
1765 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1767 if (combined_after_bytes
)
1768 move_gap_both (GPT
+ combined_after_bytes
,
1769 GPT_BYTE
+ combined_after_bytes
);
1774 /* Adjust the overlay center as needed. This must be done after
1775 adjusting the markers that bound the overlays. */
1776 adjust_overlays_for_delete (from
, nchars_del
);
1777 adjust_overlays_for_insert (from
, inschars
);
1779 adjust_markers_for_insert (from
, from_byte
,
1780 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1781 combined_before_bytes
, combined_after_bytes
, 0);
1783 #ifdef USE_TEXT_PROPERTIES
1784 offset_intervals (current_buffer
, PT
, inschars
- nchars_del
);
1786 /* Get the intervals for the part of the string we are inserting--
1787 not including the combined-before bytes. */
1788 intervals
= XSTRING (new)->intervals
;
1789 /* Insert those intervals. */
1790 graft_intervals_into_buffer (intervals
, from
, inschars
,
1791 current_buffer
, inherit
);
1794 /* Relocate point as if it were a marker. */
1796 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)
1797 + combined_after_bytes
),
1798 (from_byte
+ outgoing_insbytes
1799 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)
1800 + combined_after_bytes
));
1802 if (combined_after_bytes
)
1803 combine_bytes (from
+ inschars
, from_byte
+ outgoing_insbytes
,
1804 combined_after_bytes
);
1806 if (combined_before_bytes
)
1807 combine_bytes (from
, from_byte
, combined_before_bytes
);
1809 if (outgoing_insbytes
== 0)
1810 evaporate_overlays (from
);
1817 signal_after_change (from
, nchars_del
, PT
- from
);
1820 /* Delete characters in current buffer
1821 from FROM up to (but not including) TO.
1822 If TO comes before FROM, we delete nothing. */
1825 del_range (from
, to
)
1826 register int from
, to
;
1828 del_range_1 (from
, to
, 1);
1831 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer. */
1834 del_range_1 (from
, to
, prepare
)
1835 int from
, to
, prepare
;
1837 int from_byte
, to_byte
;
1839 /* Make args be valid */
1850 int range_length
= to
- from
;
1851 prepare_to_modify_buffer (from
, to
, &from
);
1852 to
= from
+ range_length
;
1855 from_byte
= CHAR_TO_BYTE (from
);
1856 to_byte
= CHAR_TO_BYTE (to
);
1858 del_range_2 (from
, from_byte
, to
, to_byte
);
1861 /* Like del_range_1 but args are byte positions, not char positions. */
1864 del_range_byte (from_byte
, to_byte
, prepare
)
1865 int from_byte
, to_byte
, prepare
;
1869 /* Make args be valid */
1870 if (from_byte
< BEGV_BYTE
)
1871 from_byte
= BEGV_BYTE
;
1872 if (to_byte
> ZV_BYTE
)
1875 if (to_byte
<= from_byte
)
1878 from
= BYTE_TO_CHAR (from_byte
);
1879 to
= BYTE_TO_CHAR (to_byte
);
1883 int old_from
= from
, old_to
= Z
- to
;
1884 int range_length
= to
- from
;
1885 prepare_to_modify_buffer (from
, to
, &from
);
1886 to
= from
+ range_length
;
1888 if (old_from
!= from
)
1889 from_byte
= CHAR_TO_BYTE (from
);
1890 if (old_to
== Z
- to
)
1891 to_byte
= CHAR_TO_BYTE (to
);
1894 del_range_2 (from
, from_byte
, to
, to_byte
);
1897 /* Like del_range_1, but positions are specified both as charpos
1901 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1902 int from
, from_byte
, to
, to_byte
, prepare
;
1904 /* Make args be valid */
1905 if (from_byte
< BEGV_BYTE
)
1906 from_byte
= BEGV_BYTE
;
1907 if (to_byte
> ZV_BYTE
)
1910 if (to_byte
<= from_byte
)
1920 int old_from
= from
, old_to
= Z
- to
;
1921 int range_length
= to
- from
;
1922 prepare_to_modify_buffer (from
, to
, &from
);
1923 to
= from
+ range_length
;
1925 if (old_from
!= from
)
1926 from_byte
= CHAR_TO_BYTE (from
);
1927 if (old_to
== Z
- to
)
1928 to_byte
= CHAR_TO_BYTE (to
);
1931 del_range_2 (from
, from_byte
, to
, to_byte
);
1934 /* Delete a range of text, specified both as character positions
1935 and byte positions. FROM and TO are character positions,
1936 while FROM_BYTE and TO_BYTE are byte positions. */
1939 del_range_2 (from
, from_byte
, to
, to_byte
)
1940 int from
, from_byte
, to
, to_byte
;
1942 register int nbytes_del
, nchars_del
;
1943 int combined_after_bytes
;
1944 Lisp_Object deletion
;
1949 nchars_del
= to
- from
;
1950 nbytes_del
= to_byte
- from_byte
;
1952 /* Make sure the gap is somewhere in or next to what we are deleting. */
1954 gap_right (from
, from_byte
);
1956 gap_left (to
, to_byte
, 0);
1958 combined_after_bytes
1959 = count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1960 ZV_BYTE
- to_byte
, from
, from_byte
);
1961 if (combined_after_bytes
)
1963 from_byte_1
= from_byte
;
1964 DEC_POS (from_byte_1
);
1967 from_byte_1
= from_byte
;
1970 = make_buffer_string_both (from
- !!combined_after_bytes
,
1972 to
+ combined_after_bytes
,
1973 to_byte
+ combined_after_bytes
, 1);
1974 if (combined_after_bytes
)
1975 /* COMBINED_AFTER_BYTES nonzero means that the above code moved
1976 the gap. We must move the gap again to a proper place. */
1977 move_gap_both (from
, from_byte
);
1979 /* Relocate all markers pointing into the new, larger gap
1980 to point at the end of the text before the gap.
1981 Do this before recording the deletion,
1982 so that undo handles this after reinserting the text. */
1983 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1984 if (combined_after_bytes
)
1986 /* Adjust markers for the phony deletion
1987 that we are about to call record_undo for. */
1989 /* Here we delete the markers that formerly
1990 pointed at TO ... TO + COMBINED_AFTER_BYTES.
1991 But because of the call to adjust_markers_for_delete, above,
1992 they now point at FROM ... FROM + COMBINED_AFTER_BYTES. */
1993 adjust_markers_for_record_delete (from
, from_byte
,
1994 from
+ combined_after_bytes
,
1995 from_byte
+ combined_after_bytes
);
1997 adjust_markers_for_record_delete (from
- 1, from_byte_1
,
2000 record_delete (from
- !!combined_after_bytes
, deletion
);
2003 /* Relocate point as if it were a marker. */
2005 adjust_point (from
- (PT
< to
? PT
: to
),
2006 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
2008 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2009 offset_intervals (current_buffer
, from
, - nchars_del
);
2011 /* Adjust the overlay center as needed. This must be done after
2012 adjusting the markers that bound the overlays. */
2013 adjust_overlays_for_delete (from
, nchars_del
);
2015 GAP_SIZE
+= nbytes_del
;
2016 ZV_BYTE
-= nbytes_del
;
2017 Z_BYTE
-= nbytes_del
;
2021 GPT_BYTE
= from_byte
;
2023 if (combined_after_bytes
)
2024 move_gap_both (GPT
+ combined_after_bytes
,
2025 GPT_BYTE
+ combined_after_bytes
);
2027 *(GPT_ADDR
) = 0; /* Put an anchor. */
2032 if (GPT
- BEG
< beg_unchanged
)
2033 beg_unchanged
= GPT
- BEG
;
2034 if (Z
- GPT
< end_unchanged
)
2035 end_unchanged
= Z
- GPT
;
2037 if (combined_after_bytes
)
2039 combine_bytes (from
, from_byte
, combined_after_bytes
);
2041 record_insert (GPT
- 1, 1);
2046 evaporate_overlays (from
);
2047 signal_after_change (from
, nchars_del
, 0);
2050 /* Call this if you're about to change the region of BUFFER from
2051 character positions START to END. This checks the read-only
2052 properties of the region, calls the necessary modification hooks,
2053 and warns the next redisplay that it should pay attention to that
2057 modify_region (buffer
, start
, end
)
2058 struct buffer
*buffer
;
2061 struct buffer
*old_buffer
= current_buffer
;
2063 if (buffer
!= old_buffer
)
2064 set_buffer_internal (buffer
);
2066 prepare_to_modify_buffer (start
, end
, NULL
);
2068 if (start
- 1 < beg_unchanged
2069 || (unchanged_modified
== MODIFF
2070 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2071 beg_unchanged
= start
- 1;
2072 if (Z
- end
< end_unchanged
2073 || (unchanged_modified
== MODIFF
2074 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
2075 end_unchanged
= Z
- end
;
2077 if (MODIFF
<= SAVE_MODIFF
)
2078 record_first_change ();
2081 buffer
->point_before_scroll
= Qnil
;
2083 if (buffer
!= old_buffer
)
2084 set_buffer_internal (old_buffer
);
2087 /* Check that it is okay to modify the buffer between START and END,
2088 which are char positions.
2090 Run the before-change-function, if any. If intervals are in use,
2091 verify that the text to be modified is not read-only, and call
2092 any modification properties the text may have.
2094 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2095 by holding its value temporarily in a marker. */
2098 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
2102 if (!NILP (current_buffer
->read_only
))
2103 Fbarf_if_buffer_read_only ();
2105 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
2106 if (BUF_INTERVALS (current_buffer
) != 0)
2110 Lisp_Object preserve_marker
;
2111 struct gcpro gcpro1
;
2112 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
2113 GCPRO1 (preserve_marker
);
2114 verify_interval_modification (current_buffer
, start
, end
);
2115 *preserve_ptr
= marker_position (preserve_marker
);
2116 unchain_marker (preserve_marker
);
2120 verify_interval_modification (current_buffer
, start
, end
);
2123 #ifdef CLASH_DETECTION
2124 if (!NILP (current_buffer
->file_truename
)
2125 /* Make binding buffer-file-name to nil effective. */
2126 && !NILP (current_buffer
->filename
)
2127 && SAVE_MODIFF
>= MODIFF
)
2128 lock_file (current_buffer
->file_truename
);
2130 /* At least warn if this file has changed on disk since it was visited. */
2131 if (!NILP (current_buffer
->filename
)
2132 && SAVE_MODIFF
>= MODIFF
2133 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2134 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2135 call1 (intern ("ask-user-about-supersession-threat"),
2136 current_buffer
->filename
);
2137 #endif /* not CLASH_DETECTION */
2139 signal_before_change (start
, end
, preserve_ptr
);
2141 if (current_buffer
->newline_cache
)
2142 invalidate_region_cache (current_buffer
,
2143 current_buffer
->newline_cache
,
2144 start
- BEG
, Z
- end
);
2145 if (current_buffer
->width_run_cache
)
2146 invalidate_region_cache (current_buffer
,
2147 current_buffer
->width_run_cache
,
2148 start
- BEG
, Z
- end
);
2150 Vdeactivate_mark
= Qt
;
2153 /* These macros work with an argument named `preserve_ptr'
2154 and a local variable named `preserve_marker'. */
2156 #define PRESERVE_VALUE \
2157 if (preserve_ptr && NILP (preserve_marker)) \
2158 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2160 #define RESTORE_VALUE \
2161 if (! NILP (preserve_marker)) \
2163 *preserve_ptr = marker_position (preserve_marker); \
2164 unchain_marker (preserve_marker); \
2167 #define PRESERVE_START_END \
2168 if (NILP (start_marker)) \
2169 start_marker = Fcopy_marker (start, Qnil); \
2170 if (NILP (end_marker)) \
2171 end_marker = Fcopy_marker (end, Qnil);
2173 #define FETCH_START \
2174 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2177 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2179 /* Signal a change to the buffer immediately before it happens.
2180 START_INT and END_INT are the bounds of the text to be changed.
2182 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2183 by holding its value temporarily in a marker. */
2186 signal_before_change (start_int
, end_int
, preserve_ptr
)
2187 int start_int
, end_int
;
2190 Lisp_Object start
, end
;
2191 Lisp_Object start_marker
, end_marker
;
2192 Lisp_Object preserve_marker
;
2193 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2195 start
= make_number (start_int
);
2196 end
= make_number (end_int
);
2197 preserve_marker
= Qnil
;
2198 start_marker
= Qnil
;
2200 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2202 /* If buffer is unmodified, run a special hook for that case. */
2203 if (SAVE_MODIFF
>= MODIFF
2204 && !NILP (Vfirst_change_hook
)
2205 && !NILP (Vrun_hooks
))
2209 call1 (Vrun_hooks
, Qfirst_change_hook
);
2212 /* Run the before-change-function if any.
2213 We don't bother "binding" this variable to nil
2214 because it is obsolete anyway and new code should not use it. */
2215 if (!NILP (Vbefore_change_function
))
2219 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
2222 /* Now run the before-change-functions if any. */
2223 if (!NILP (Vbefore_change_functions
))
2225 Lisp_Object args
[3];
2226 Lisp_Object before_change_functions
;
2227 Lisp_Object after_change_functions
;
2228 struct gcpro gcpro1
, gcpro2
;
2233 /* "Bind" before-change-functions and after-change-functions
2234 to nil--but in a way that errors don't know about.
2235 That way, if there's an error in them, they will stay nil. */
2236 before_change_functions
= Vbefore_change_functions
;
2237 after_change_functions
= Vafter_change_functions
;
2238 Vbefore_change_functions
= Qnil
;
2239 Vafter_change_functions
= Qnil
;
2240 GCPRO2 (before_change_functions
, after_change_functions
);
2242 /* Actually run the hook functions. */
2243 args
[0] = Qbefore_change_functions
;
2244 args
[1] = FETCH_START
;
2245 args
[2] = FETCH_END
;
2246 run_hook_list_with_args (before_change_functions
, 3, args
);
2248 /* "Unbind" the variables we "bound" to nil. */
2249 Vbefore_change_functions
= before_change_functions
;
2250 Vafter_change_functions
= after_change_functions
;
2254 if (!NILP (current_buffer
->overlays_before
)
2255 || !NILP (current_buffer
->overlays_after
))
2258 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2259 FETCH_START
, FETCH_END
, Qnil
);
2262 if (! NILP (start_marker
))
2263 free_marker (start_marker
);
2264 if (! NILP (end_marker
))
2265 free_marker (end_marker
);
2270 /* Signal a change immediately after it happens.
2271 CHARPOS is the character position of the start of the changed text.
2272 LENDEL is the number of characters of the text before the change.
2273 (Not the whole buffer; just the part that was changed.)
2274 LENINS is the number of characters in that part of the text
2275 after the change. */
2278 signal_after_change (charpos
, lendel
, lenins
)
2279 int charpos
, lendel
, lenins
;
2281 /* If we are deferring calls to the after-change functions
2282 and there are no before-change functions,
2283 just record the args that we were going to use. */
2284 if (! NILP (Vcombine_after_change_calls
)
2285 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
2286 && NILP (current_buffer
->overlays_before
)
2287 && NILP (current_buffer
->overlays_after
))
2291 if (!NILP (combine_after_change_list
)
2292 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2293 Fcombine_after_change_execute ();
2295 elt
= Fcons (make_number (charpos
- BEG
),
2296 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2297 Fcons (make_number (lenins
- lendel
), Qnil
)));
2298 combine_after_change_list
2299 = Fcons (elt
, combine_after_change_list
);
2300 combine_after_change_buffer
= Fcurrent_buffer ();
2305 if (!NILP (combine_after_change_list
))
2306 Fcombine_after_change_execute ();
2308 /* Run the after-change-function if any.
2309 We don't bother "binding" this variable to nil
2310 because it is obsolete anyway and new code should not use it. */
2311 if (!NILP (Vafter_change_function
))
2312 call3 (Vafter_change_function
,
2313 make_number (charpos
), make_number (charpos
+ lenins
),
2314 make_number (lendel
));
2316 if (!NILP (Vafter_change_functions
))
2318 Lisp_Object args
[4];
2319 Lisp_Object before_change_functions
;
2320 Lisp_Object after_change_functions
;
2321 struct gcpro gcpro1
, gcpro2
;
2323 /* "Bind" before-change-functions and after-change-functions
2324 to nil--but in a way that errors don't know about.
2325 That way, if there's an error in them, they will stay nil. */
2326 before_change_functions
= Vbefore_change_functions
;
2327 after_change_functions
= Vafter_change_functions
;
2328 Vbefore_change_functions
= Qnil
;
2329 Vafter_change_functions
= Qnil
;
2330 GCPRO2 (before_change_functions
, after_change_functions
);
2332 /* Actually run the hook functions. */
2333 args
[0] = Qafter_change_functions
;
2334 XSETFASTINT (args
[1], charpos
);
2335 XSETFASTINT (args
[2], charpos
+ lenins
);
2336 XSETFASTINT (args
[3], lendel
);
2337 run_hook_list_with_args (after_change_functions
,
2340 /* "Unbind" the variables we "bound" to nil. */
2341 Vbefore_change_functions
= before_change_functions
;
2342 Vafter_change_functions
= after_change_functions
;
2346 if (!NILP (current_buffer
->overlays_before
)
2347 || !NILP (current_buffer
->overlays_after
))
2348 report_overlay_modification (make_number (charpos
),
2349 make_number (charpos
+ lenins
),
2351 make_number (charpos
),
2352 make_number (charpos
+ lenins
),
2353 make_number (lendel
));
2355 /* After an insertion, call the text properties
2356 insert-behind-hooks or insert-in-front-hooks. */
2358 report_interval_modification (make_number (charpos
),
2359 make_number (charpos
+ lenins
));
2363 Fcombine_after_change_execute_1 (val
)
2366 Vcombine_after_change_calls
= val
;
2370 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2371 Scombine_after_change_execute
, 0, 0, 0,
2372 "This function is for use internally in `combine-after-change-calls'.")
2375 register Lisp_Object val
;
2376 int count
= specpdl_ptr
- specpdl
;
2377 int beg
, end
, change
;
2381 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2383 Fset_buffer (combine_after_change_buffer
);
2385 /* # chars unchanged at beginning of buffer. */
2387 /* # chars unchanged at end of buffer. */
2389 /* Total amount of insertion (negative for deletion). */
2392 /* Scan the various individual changes,
2393 accumulating the range info in BEG, END and CHANGE. */
2394 for (tail
= combine_after_change_list
; CONSP (tail
);
2395 tail
= XCONS (tail
)->cdr
)
2398 int thisbeg
, thisend
, thischange
;
2400 /* Extract the info from the next element. */
2401 elt
= XCONS (tail
)->car
;
2404 thisbeg
= XINT (XCONS (elt
)->car
);
2406 elt
= XCONS (elt
)->cdr
;
2409 thisend
= XINT (XCONS (elt
)->car
);
2411 elt
= XCONS (elt
)->cdr
;
2414 thischange
= XINT (XCONS (elt
)->car
);
2416 /* Merge this range into the accumulated range. */
2417 change
+= thischange
;
2424 /* Get the current start and end positions of the range
2425 that was changed. */
2429 /* We are about to handle these, so discard them. */
2430 combine_after_change_list
= Qnil
;
2432 /* Now run the after-change functions for real.
2433 Turn off the flag that defers them. */
2434 record_unwind_protect (Fcombine_after_change_execute_1
,
2435 Vcombine_after_change_calls
);
2436 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2438 return unbind_to (count
, val
);
2444 staticpro (&combine_after_change_list
);
2445 combine_after_change_list
= Qnil
;
2447 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2448 "Non-nil means enable debugging checks for invalid marker positions.");
2449 check_markers_debug_flag
= 0;
2450 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2451 "Used internally by the `combine-after-change-calls' macro.");
2452 Vcombine_after_change_calls
= Qnil
;
2454 defsubr (&Scombine_after_change_execute
);