* lisp/international/mule.el (find-auto-coding): Include file name in
[emacs.git] / src / insdel.c
blobc0afa80d5e8ab27d15ed1881b0674480d0af9ae5
1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software
3 Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #include <intprops.h>
25 #include "lisp.h"
26 #include "intervals.h"
27 #include "character.h"
28 #include "buffer.h"
29 #include "window.h"
30 #include "blockinput.h"
31 #include "region-cache.h"
33 static void insert_from_string_1 (Lisp_Object, ptrdiff_t, ptrdiff_t, ptrdiff_t,
34 ptrdiff_t, bool, bool);
35 static void insert_from_buffer_1 (struct buffer *, ptrdiff_t, ptrdiff_t, bool);
36 static void gap_left (ptrdiff_t, ptrdiff_t, bool);
37 static void gap_right (ptrdiff_t, ptrdiff_t);
39 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
40 describing changes which happened while combine_after_change_calls
41 was non-nil. We use this to decide how to call them
42 once the deferral ends.
44 In each element.
45 BEG-UNCHANGED is the number of chars before the changed range.
46 END-UNCHANGED is the number of chars after the changed range,
47 and CHANGE-AMOUNT is the number of characters inserted by the change
48 (negative for a deletion). */
49 static Lisp_Object combine_after_change_list;
51 /* Buffer which combine_after_change_list is about. */
52 static Lisp_Object combine_after_change_buffer;
54 Lisp_Object Qinhibit_modification_hooks;
56 static void signal_before_change (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
58 /* Also used in marker.c to enable expensive marker checks. */
60 #ifdef MARKER_DEBUG
62 static void
63 check_markers (void)
65 struct Lisp_Marker *tail;
66 bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
68 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
70 if (tail->buffer->text != current_buffer->text)
71 emacs_abort ();
72 if (tail->charpos > Z)
73 emacs_abort ();
74 if (tail->bytepos > Z_BYTE)
75 emacs_abort ();
76 if (multibyte && ! CHAR_HEAD_P (FETCH_BYTE (tail->bytepos)))
77 emacs_abort ();
81 #else /* not MARKER_DEBUG */
83 #define check_markers() do { } while (0)
85 #endif /* MARKER_DEBUG */
87 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
88 Note that this can quit! */
90 void
91 move_gap_both (ptrdiff_t charpos, ptrdiff_t bytepos)
93 eassert (charpos == BYTE_TO_CHAR (bytepos)
94 && bytepos == CHAR_TO_BYTE (charpos));
95 if (bytepos < GPT_BYTE)
96 gap_left (charpos, bytepos, 0);
97 else if (bytepos > GPT_BYTE)
98 gap_right (charpos, bytepos);
101 /* Move the gap to a position less than the current GPT.
102 BYTEPOS describes the new position as a byte position,
103 and CHARPOS is the corresponding char position.
104 If NEWGAP, then don't update beg_unchanged and end_unchanged. */
106 static void
107 gap_left (ptrdiff_t charpos, ptrdiff_t bytepos, bool newgap)
109 unsigned char *to, *from;
110 ptrdiff_t i;
111 ptrdiff_t new_s1;
113 if (!newgap)
114 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
116 i = GPT_BYTE;
117 to = GAP_END_ADDR;
118 from = GPT_ADDR;
119 new_s1 = GPT_BYTE;
121 /* Now copy the characters. To move the gap down,
122 copy characters up. */
124 while (1)
126 /* I gets number of characters left to copy. */
127 i = new_s1 - bytepos;
128 if (i == 0)
129 break;
130 /* If a quit is requested, stop copying now.
131 Change BYTEPOS to be where we have actually moved the gap to. */
132 if (QUITP)
134 bytepos = new_s1;
135 charpos = BYTE_TO_CHAR (bytepos);
136 break;
138 /* Move at most 32000 chars before checking again for a quit. */
139 if (i > 32000)
140 i = 32000;
141 new_s1 -= i;
142 from -= i, to -= i;
143 memmove (to, from, i);
146 /* Adjust buffer data structure, to put the gap at BYTEPOS.
147 BYTEPOS is where the loop above stopped, which may be what
148 was specified or may be where a quit was detected. */
149 GPT_BYTE = bytepos;
150 GPT = charpos;
151 eassert (charpos <= bytepos);
152 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
153 QUIT;
156 /* Move the gap to a position greater than the current GPT.
157 BYTEPOS describes the new position as a byte position,
158 and CHARPOS is the corresponding char position. */
160 static void
161 gap_right (ptrdiff_t charpos, ptrdiff_t bytepos)
163 register unsigned char *to, *from;
164 register ptrdiff_t i;
165 ptrdiff_t new_s1;
167 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
169 i = GPT_BYTE;
170 from = GAP_END_ADDR;
171 to = GPT_ADDR;
172 new_s1 = GPT_BYTE;
174 /* Now copy the characters. To move the gap up,
175 copy characters down. */
177 while (1)
179 /* I gets number of characters left to copy. */
180 i = bytepos - new_s1;
181 if (i == 0)
182 break;
183 /* If a quit is requested, stop copying now.
184 Change BYTEPOS to be where we have actually moved the gap to. */
185 if (QUITP)
187 bytepos = new_s1;
188 charpos = BYTE_TO_CHAR (bytepos);
189 break;
191 /* Move at most 32000 chars before checking again for a quit. */
192 if (i > 32000)
193 i = 32000;
194 new_s1 += i;
195 memmove (to, from, i);
196 from += i, to += i;
199 GPT = charpos;
200 GPT_BYTE = bytepos;
201 eassert (charpos <= bytepos);
202 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
203 QUIT;
206 /* Adjust all markers for a deletion
207 whose range in bytes is FROM_BYTE to TO_BYTE.
208 The range in charpos is FROM to TO.
210 This function assumes that the gap is adjacent to
211 or inside of the range being deleted. */
213 void
214 adjust_markers_for_delete (ptrdiff_t from, ptrdiff_t from_byte,
215 ptrdiff_t to, ptrdiff_t to_byte)
217 Lisp_Object marker;
218 register struct Lisp_Marker *m;
219 register ptrdiff_t charpos;
221 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
223 charpos = m->charpos;
224 eassert (charpos <= Z);
226 /* If the marker is after the deletion,
227 relocate by number of chars / bytes deleted. */
228 if (charpos > to)
230 m->charpos -= to - from;
231 m->bytepos -= to_byte - from_byte;
233 /* Here's the case where a marker is inside text being deleted. */
234 else if (charpos > from)
236 if (! m->insertion_type)
237 { /* Normal markers will end up at the beginning of the
238 re-inserted text after undoing a deletion, and must be
239 adjusted to move them to the correct place. */
240 XSETMISC (marker, m);
241 record_marker_adjustment (marker, from - charpos);
243 else if (charpos < to)
244 { /* Before-insertion markers will automatically move forward
245 upon re-inserting the deleted text, so we have to arrange
246 for them to move backward to the correct position. */
247 XSETMISC (marker, m);
248 record_marker_adjustment (marker, to - charpos);
250 m->charpos = from;
251 m->bytepos = from_byte;
253 /* Here's the case where a before-insertion marker is immediately
254 before the deleted region. */
255 else if (charpos == from && m->insertion_type)
257 /* Undoing the change uses normal insertion, which will
258 incorrectly make MARKER move forward, so we arrange for it
259 to then move backward to the correct place at the beginning
260 of the deleted region. */
261 XSETMISC (marker, m);
262 record_marker_adjustment (marker, to - from);
268 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
269 to TO / TO_BYTE. We have to relocate the charpos of every marker
270 that points after the insertion (but not their bytepos).
272 When a marker points at the insertion point,
273 we advance it if either its insertion-type is t
274 or BEFORE_MARKERS is true. */
276 static void
277 adjust_markers_for_insert (ptrdiff_t from, ptrdiff_t from_byte,
278 ptrdiff_t to, ptrdiff_t to_byte, bool before_markers)
280 struct Lisp_Marker *m;
281 bool adjusted = 0;
282 ptrdiff_t nchars = to - from;
283 ptrdiff_t nbytes = to_byte - from_byte;
285 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
287 eassert (m->bytepos >= m->charpos
288 && m->bytepos - m->charpos <= Z_BYTE - Z);
290 if (m->bytepos == from_byte)
292 if (m->insertion_type || before_markers)
294 m->bytepos = to_byte;
295 m->charpos = to;
296 if (m->insertion_type)
297 adjusted = 1;
300 else if (m->bytepos > from_byte)
302 m->bytepos += nbytes;
303 m->charpos += nchars;
307 /* Adjusting only markers whose insertion-type is t may result in
308 - disordered start and end in overlays, and
309 - disordered overlays in the slot `overlays_before' of current_buffer. */
310 if (adjusted)
312 fix_start_end_in_overlays (from, to);
313 fix_overlays_before (current_buffer, from, to);
317 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
319 This is used only when the value of point changes due to an insert
320 or delete; it does not represent a conceptual change in point as a
321 marker. In particular, point is not crossing any interval
322 boundaries, so there's no need to use the usual SET_PT macro. In
323 fact it would be incorrect to do so, because either the old or the
324 new value of point is out of sync with the current set of
325 intervals. */
327 static void
328 adjust_point (ptrdiff_t nchars, ptrdiff_t nbytes)
330 SET_BUF_PT_BOTH (current_buffer, PT + nchars, PT_BYTE + nbytes);
331 /* In a single-byte buffer, the two positions must be equal. */
332 eassert (PT_BYTE >= PT && PT_BYTE - PT <= ZV_BYTE - ZV);
335 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
336 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
337 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
338 an insertion. */
340 static void
341 adjust_markers_for_replace (ptrdiff_t from, ptrdiff_t from_byte,
342 ptrdiff_t old_chars, ptrdiff_t old_bytes,
343 ptrdiff_t new_chars, ptrdiff_t new_bytes)
345 register struct Lisp_Marker *m;
346 ptrdiff_t prev_to_byte = from_byte + old_bytes;
347 ptrdiff_t diff_chars = new_chars - old_chars;
348 ptrdiff_t diff_bytes = new_bytes - old_bytes;
350 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
352 if (m->bytepos >= prev_to_byte)
354 m->charpos += diff_chars;
355 m->bytepos += diff_bytes;
357 else if (m->bytepos > from_byte)
359 m->charpos = from;
360 m->bytepos = from_byte;
364 check_markers ();
368 void
369 buffer_overflow (void)
371 error ("Maximum buffer size exceeded");
374 /* Make the gap NBYTES_ADDED bytes longer. */
376 static void
377 make_gap_larger (ptrdiff_t nbytes_added)
379 Lisp_Object tem;
380 ptrdiff_t real_gap_loc;
381 ptrdiff_t real_gap_loc_byte;
382 ptrdiff_t old_gap_size;
383 ptrdiff_t current_size = Z_BYTE - BEG_BYTE + GAP_SIZE;
385 if (BUF_BYTES_MAX - current_size < nbytes_added)
386 buffer_overflow ();
388 /* If we have to get more space, get enough to last a while;
389 but do not exceed the maximum buffer size. */
390 nbytes_added = min (nbytes_added + GAP_BYTES_DFL,
391 BUF_BYTES_MAX - current_size);
393 enlarge_buffer_text (current_buffer, nbytes_added);
395 /* Prevent quitting in move_gap. */
396 tem = Vinhibit_quit;
397 Vinhibit_quit = Qt;
399 real_gap_loc = GPT;
400 real_gap_loc_byte = GPT_BYTE;
401 old_gap_size = GAP_SIZE;
403 /* Call the newly allocated space a gap at the end of the whole space. */
404 GPT = Z + GAP_SIZE;
405 GPT_BYTE = Z_BYTE + GAP_SIZE;
406 GAP_SIZE = nbytes_added;
408 /* Move the new gap down to be consecutive with the end of the old one. */
409 gap_left (real_gap_loc + old_gap_size, real_gap_loc_byte + old_gap_size, 1);
411 /* Now combine the two into one large gap. */
412 GAP_SIZE += old_gap_size;
413 GPT = real_gap_loc;
414 GPT_BYTE = real_gap_loc_byte;
416 /* Put an anchor. */
417 *(Z_ADDR) = 0;
419 Vinhibit_quit = tem;
422 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
424 /* Make the gap NBYTES_REMOVED bytes shorter. */
426 static void
427 make_gap_smaller (ptrdiff_t nbytes_removed)
429 Lisp_Object tem;
430 ptrdiff_t real_gap_loc;
431 ptrdiff_t real_gap_loc_byte;
432 ptrdiff_t real_Z;
433 ptrdiff_t real_Z_byte;
434 ptrdiff_t real_beg_unchanged;
435 ptrdiff_t new_gap_size;
437 /* Make sure the gap is at least GAP_BYTES_MIN bytes. */
438 if (GAP_SIZE - nbytes_removed < GAP_BYTES_MIN)
439 nbytes_removed = GAP_SIZE - GAP_BYTES_MIN;
441 /* Prevent quitting in move_gap. */
442 tem = Vinhibit_quit;
443 Vinhibit_quit = Qt;
445 real_gap_loc = GPT;
446 real_gap_loc_byte = GPT_BYTE;
447 new_gap_size = GAP_SIZE - nbytes_removed;
448 real_Z = Z;
449 real_Z_byte = Z_BYTE;
450 real_beg_unchanged = BEG_UNCHANGED;
452 /* Pretend that the last unwanted part of the gap is the entire gap,
453 and that the first desired part of the gap is part of the buffer
454 text. */
455 memset (GPT_ADDR, 0, new_gap_size);
456 GPT += new_gap_size;
457 GPT_BYTE += new_gap_size;
458 Z += new_gap_size;
459 Z_BYTE += new_gap_size;
460 GAP_SIZE = nbytes_removed;
462 /* Move the unwanted pretend gap to the end of the buffer. */
463 gap_right (Z, Z_BYTE);
465 enlarge_buffer_text (current_buffer, -nbytes_removed);
467 /* Now restore the desired gap. */
468 GAP_SIZE = new_gap_size;
469 GPT = real_gap_loc;
470 GPT_BYTE = real_gap_loc_byte;
471 Z = real_Z;
472 Z_BYTE = real_Z_byte;
473 BEG_UNCHANGED = real_beg_unchanged;
475 /* Put an anchor. */
476 *(Z_ADDR) = 0;
478 Vinhibit_quit = tem;
481 #endif /* USE_MMAP_FOR_BUFFERS || REL_ALLOC || DOUG_LEA_MALLOC */
483 void
484 make_gap (ptrdiff_t nbytes_added)
486 if (nbytes_added >= 0)
487 make_gap_larger (nbytes_added);
488 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
489 else
490 make_gap_smaller (-nbytes_added);
491 #endif
494 /* Add NBYTES to B's gap. It's enough to temporarily
495 fake current_buffer and avoid real switch to B. */
497 void
498 make_gap_1 (struct buffer *b, ptrdiff_t nbytes)
500 struct buffer *oldb = current_buffer;
502 current_buffer = b;
503 make_gap (nbytes);
504 current_buffer = oldb;
507 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
508 FROM_MULTIBYTE says whether the incoming text is multibyte.
509 TO_MULTIBYTE says whether to store the text as multibyte.
510 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
512 Return the number of bytes stored at TO_ADDR. */
514 ptrdiff_t
515 copy_text (const unsigned char *from_addr, unsigned char *to_addr,
516 ptrdiff_t nbytes, bool from_multibyte, bool to_multibyte)
518 if (from_multibyte == to_multibyte)
520 memcpy (to_addr, from_addr, nbytes);
521 return nbytes;
523 else if (from_multibyte)
525 ptrdiff_t nchars = 0;
526 ptrdiff_t bytes_left = nbytes;
528 while (bytes_left > 0)
530 int thislen, c;
531 c = STRING_CHAR_AND_LENGTH (from_addr, thislen);
532 if (! ASCII_CHAR_P (c))
533 c &= 0xFF;
534 *to_addr++ = c;
535 from_addr += thislen;
536 bytes_left -= thislen;
537 nchars++;
539 return nchars;
541 else
543 unsigned char *initial_to_addr = to_addr;
545 /* Convert single-byte to multibyte. */
546 while (nbytes > 0)
548 int c = *from_addr++;
550 if (!ASCII_CHAR_P (c))
552 c = BYTE8_TO_CHAR (c);
553 to_addr += CHAR_STRING (c, to_addr);
554 nbytes--;
556 else
557 /* Special case for speed. */
558 *to_addr++ = c, nbytes--;
560 return to_addr - initial_to_addr;
564 /* Insert a string of specified length before point.
565 This function judges multibyteness based on
566 enable_multibyte_characters in the current buffer;
567 it never converts between single-byte and multibyte.
569 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
570 prepare_to_modify_buffer could relocate the text. */
572 void
573 insert (const char *string, ptrdiff_t nbytes)
575 if (nbytes > 0)
577 ptrdiff_t len = chars_in_text ((unsigned char *) string, nbytes), opoint;
578 insert_1_both (string, len, nbytes, 0, 1, 0);
579 opoint = PT - len;
580 signal_after_change (opoint, 0, len);
581 update_compositions (opoint, PT, CHECK_BORDER);
585 /* Likewise, but inherit text properties from neighboring characters. */
587 void
588 insert_and_inherit (const char *string, ptrdiff_t nbytes)
590 if (nbytes > 0)
592 ptrdiff_t len = chars_in_text ((unsigned char *) string, nbytes), opoint;
593 insert_1_both (string, len, nbytes, 1, 1, 0);
594 opoint = PT - len;
595 signal_after_change (opoint, 0, len);
596 update_compositions (opoint, PT, CHECK_BORDER);
600 /* Insert the character C before point. Do not inherit text properties. */
602 void
603 insert_char (int c)
605 unsigned char str[MAX_MULTIBYTE_LENGTH];
606 int len;
608 if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
609 len = CHAR_STRING (c, str);
610 else
612 len = 1;
613 str[0] = c;
616 insert ((char *) str, len);
619 /* Insert the null-terminated string S before point. */
621 void
622 insert_string (const char *s)
624 insert (s, strlen (s));
627 /* Like `insert' except that all markers pointing at the place where
628 the insertion happens are adjusted to point after it.
629 Don't use this function to insert part of a Lisp string,
630 since gc could happen and relocate it. */
632 void
633 insert_before_markers (const char *string, ptrdiff_t nbytes)
635 if (nbytes > 0)
637 ptrdiff_t len = chars_in_text ((unsigned char *) string, nbytes), opoint;
638 insert_1_both (string, len, nbytes, 0, 1, 1);
639 opoint = PT - len;
640 signal_after_change (opoint, 0, len);
641 update_compositions (opoint, PT, CHECK_BORDER);
645 /* Likewise, but inherit text properties from neighboring characters. */
647 void
648 insert_before_markers_and_inherit (const char *string,
649 ptrdiff_t nbytes)
651 if (nbytes > 0)
653 ptrdiff_t len = chars_in_text ((unsigned char *) string, nbytes), opoint;
654 insert_1_both (string, len, nbytes, 1, 1, 1);
655 opoint = PT - len;
656 signal_after_change (opoint, 0, len);
657 update_compositions (opoint, PT, CHECK_BORDER);
661 #ifdef BYTE_COMBINING_DEBUG
663 /* See if the bytes before POS/POS_BYTE combine with bytes
664 at the start of STRING to form a single character.
665 If so, return the number of bytes at the start of STRING
666 which combine in this way. Otherwise, return 0. */
669 count_combining_before (const unsigned char *string, ptrdiff_t length,
670 ptrdiff_t pos, ptrdiff_t pos_byte)
672 int len, combining_bytes;
673 const unsigned char *p;
675 if (NILP (current_buffer->enable_multibyte_characters))
676 return 0;
678 /* At first, we can exclude the following cases:
679 (1) STRING[0] can't be a following byte of multibyte sequence.
680 (2) POS is the start of the current buffer.
681 (3) A character before POS is not a multibyte character. */
682 if (length == 0 || CHAR_HEAD_P (*string)) /* case (1) */
683 return 0;
684 if (pos_byte == BEG_BYTE) /* case (2) */
685 return 0;
686 len = 1;
687 p = BYTE_POS_ADDR (pos_byte - 1);
688 while (! CHAR_HEAD_P (*p)) p--, len++;
689 if (! LEADING_CODE_P (*p)) /* case (3) */
690 return 0;
692 combining_bytes = BYTES_BY_CHAR_HEAD (*p) - len;
693 if (combining_bytes <= 0)
694 /* The character preceding POS is, complete and no room for
695 combining bytes (combining_bytes == 0), or an independent 8-bit
696 character (combining_bytes < 0). */
697 return 0;
699 /* We have a combination situation. Count the bytes at STRING that
700 may combine. */
701 p = string + 1;
702 while (!CHAR_HEAD_P (*p) && p < string + length)
703 p++;
705 return (combining_bytes < p - string ? combining_bytes : p - string);
708 /* See if the bytes after POS/POS_BYTE combine with bytes
709 at the end of STRING to form a single character.
710 If so, return the number of bytes after POS/POS_BYTE
711 which combine in this way. Otherwise, return 0. */
714 count_combining_after (const unsigned char *string,
715 ptrdiff_t length, ptrdiff_t pos, ptrdiff_t pos_byte)
717 ptrdiff_t opos_byte = pos_byte;
718 ptrdiff_t i;
719 ptrdiff_t bytes;
720 unsigned char *bufp;
722 if (NILP (current_buffer->enable_multibyte_characters))
723 return 0;
725 /* At first, we can exclude the following cases:
726 (1) The last byte of STRING is an ASCII.
727 (2) POS is the last of the current buffer.
728 (3) A character at POS can't be a following byte of multibyte
729 character. */
730 if (length > 0 && ASCII_BYTE_P (string[length - 1])) /* case (1) */
731 return 0;
732 if (pos_byte == Z_BYTE) /* case (2) */
733 return 0;
734 bufp = BYTE_POS_ADDR (pos_byte);
735 if (CHAR_HEAD_P (*bufp)) /* case (3) */
736 return 0;
738 i = length - 1;
739 while (i >= 0 && ! CHAR_HEAD_P (string[i]))
741 i--;
743 if (i < 0)
745 /* All characters in STRING are not character head. We must
746 check also preceding bytes at POS. We are sure that the gap
747 is at POS. */
748 unsigned char *p = BEG_ADDR;
749 i = pos_byte - 2;
750 while (i >= 0 && ! CHAR_HEAD_P (p[i]))
751 i--;
752 if (i < 0 || !LEADING_CODE_P (p[i]))
753 return 0;
755 bytes = BYTES_BY_CHAR_HEAD (p[i]);
756 return (bytes <= pos_byte - 1 - i + length
758 : bytes - (pos_byte - 1 - i + length));
760 if (!LEADING_CODE_P (string[i]))
761 return 0;
763 bytes = BYTES_BY_CHAR_HEAD (string[i]) - (length - i);
764 bufp++, pos_byte++;
765 while (!CHAR_HEAD_P (*bufp)) bufp++, pos_byte++;
767 return (bytes <= pos_byte - opos_byte ? bytes : pos_byte - opos_byte);
770 #endif
773 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
774 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
775 are the same as in insert_1. */
777 void
778 insert_1_both (const char *string,
779 ptrdiff_t nchars, ptrdiff_t nbytes,
780 bool inherit, bool prepare, bool before_markers)
782 if (nchars == 0)
783 return;
785 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
786 nchars = nbytes;
788 if (prepare)
789 /* Do this before moving and increasing the gap,
790 because the before-change hooks might move the gap
791 or make it smaller. */
792 prepare_to_modify_buffer (PT, PT, NULL);
794 if (PT != GPT)
795 move_gap_both (PT, PT_BYTE);
796 if (GAP_SIZE < nbytes)
797 make_gap (nbytes - GAP_SIZE);
799 #ifdef BYTE_COMBINING_DEBUG
800 if (count_combining_before (string, nbytes, PT, PT_BYTE)
801 || count_combining_after (string, nbytes, PT, PT_BYTE))
802 emacs_abort ();
803 #endif
805 /* Record deletion of the surrounding text that combines with
806 the insertion. This, together with recording the insertion,
807 will add up to the right stuff in the undo list. */
808 record_insert (PT, nchars);
809 MODIFF++;
810 CHARS_MODIFF = MODIFF;
812 memcpy (GPT_ADDR, string, nbytes);
814 GAP_SIZE -= nbytes;
815 GPT += nchars;
816 ZV += nchars;
817 Z += nchars;
818 GPT_BYTE += nbytes;
819 ZV_BYTE += nbytes;
820 Z_BYTE += nbytes;
821 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
823 eassert (GPT <= GPT_BYTE);
825 /* The insert may have been in the unchanged region, so check again. */
826 if (Z - GPT < END_UNCHANGED)
827 END_UNCHANGED = Z - GPT;
829 adjust_overlays_for_insert (PT, nchars);
830 adjust_markers_for_insert (PT, PT_BYTE,
831 PT + nchars, PT_BYTE + nbytes,
832 before_markers);
834 offset_intervals (current_buffer, PT, nchars);
836 if (!inherit && buffer_intervals (current_buffer))
837 set_text_properties (make_number (PT), make_number (PT + nchars),
838 Qnil, Qnil, Qnil);
840 adjust_point (nchars, nbytes);
842 check_markers ();
845 /* Insert the part of the text of STRING, a Lisp object assumed to be
846 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
847 starting at position POS / POS_BYTE. If the text of STRING has properties,
848 copy them into the buffer.
850 It does not work to use `insert' for this, because a GC could happen
851 before we copy the stuff into the buffer, and relocate the string
852 without insert noticing. */
854 void
855 insert_from_string (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
856 ptrdiff_t length, ptrdiff_t length_byte, bool inherit)
858 ptrdiff_t opoint = PT;
860 if (SCHARS (string) == 0)
861 return;
863 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
864 inherit, 0);
865 signal_after_change (opoint, 0, PT - opoint);
866 update_compositions (opoint, PT, CHECK_BORDER);
869 /* Like `insert_from_string' except that all markers pointing
870 at the place where the insertion happens are adjusted to point after it. */
872 void
873 insert_from_string_before_markers (Lisp_Object string,
874 ptrdiff_t pos, ptrdiff_t pos_byte,
875 ptrdiff_t length, ptrdiff_t length_byte,
876 bool inherit)
878 ptrdiff_t opoint = PT;
880 if (SCHARS (string) == 0)
881 return;
883 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
884 inherit, 1);
885 signal_after_change (opoint, 0, PT - opoint);
886 update_compositions (opoint, PT, CHECK_BORDER);
889 /* Subroutine of the insertion functions above. */
891 static void
892 insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
893 ptrdiff_t nchars, ptrdiff_t nbytes,
894 bool inherit, bool before_markers)
896 struct gcpro gcpro1;
897 ptrdiff_t outgoing_nbytes = nbytes;
898 INTERVAL intervals;
900 /* Make OUTGOING_NBYTES describe the text
901 as it will be inserted in this buffer. */
903 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
904 outgoing_nbytes = nchars;
905 else if (! STRING_MULTIBYTE (string))
906 outgoing_nbytes
907 = count_size_as_multibyte (SDATA (string) + pos_byte,
908 nbytes);
910 GCPRO1 (string);
911 /* Do this before moving and increasing the gap,
912 because the before-change hooks might move the gap
913 or make it smaller. */
914 prepare_to_modify_buffer (PT, PT, NULL);
916 if (PT != GPT)
917 move_gap_both (PT, PT_BYTE);
918 if (GAP_SIZE < outgoing_nbytes)
919 make_gap (outgoing_nbytes - GAP_SIZE);
920 UNGCPRO;
922 /* Copy the string text into the buffer, perhaps converting
923 between single-byte and multibyte. */
924 copy_text (SDATA (string) + pos_byte, GPT_ADDR, nbytes,
925 STRING_MULTIBYTE (string),
926 ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
928 #ifdef BYTE_COMBINING_DEBUG
929 /* We have copied text into the gap, but we have not altered
930 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
931 to these functions and get the same results as we would
932 have got earlier on. Meanwhile, PT_ADDR does point to
933 the text that has been stored by copy_text. */
934 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
935 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
936 emacs_abort ();
937 #endif
939 record_insert (PT, nchars);
940 MODIFF++;
941 CHARS_MODIFF = MODIFF;
943 GAP_SIZE -= outgoing_nbytes;
944 GPT += nchars;
945 ZV += nchars;
946 Z += nchars;
947 GPT_BYTE += outgoing_nbytes;
948 ZV_BYTE += outgoing_nbytes;
949 Z_BYTE += outgoing_nbytes;
950 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
952 eassert (GPT <= GPT_BYTE);
954 /* The insert may have been in the unchanged region, so check again. */
955 if (Z - GPT < END_UNCHANGED)
956 END_UNCHANGED = Z - GPT;
958 adjust_overlays_for_insert (PT, nchars);
959 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
960 PT_BYTE + outgoing_nbytes,
961 before_markers);
963 offset_intervals (current_buffer, PT, nchars);
965 intervals = string_intervals (string);
966 /* Get the intervals for the part of the string we are inserting. */
967 if (nbytes < SBYTES (string))
968 intervals = copy_intervals (intervals, pos, nchars);
970 /* Insert those intervals. */
971 graft_intervals_into_buffer (intervals, PT, nchars,
972 current_buffer, inherit);
974 adjust_point (nchars, outgoing_nbytes);
976 check_markers ();
979 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
980 starting at GPT_ADDR. */
982 void
983 insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes)
985 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
986 nchars = nbytes;
988 record_insert (GPT, nchars);
989 MODIFF++;
991 GAP_SIZE -= nbytes;
992 GPT += nchars;
993 ZV += nchars;
994 Z += nchars;
995 GPT_BYTE += nbytes;
996 ZV_BYTE += nbytes;
997 Z_BYTE += nbytes;
998 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1000 eassert (GPT <= GPT_BYTE);
1002 adjust_overlays_for_insert (GPT - nchars, nchars);
1003 adjust_markers_for_insert (GPT - nchars, GPT_BYTE - nbytes,
1004 GPT, GPT_BYTE, 0);
1006 if (buffer_intervals (current_buffer))
1008 offset_intervals (current_buffer, GPT - nchars, nchars);
1009 graft_intervals_into_buffer (NULL, GPT - nchars, nchars,
1010 current_buffer, 0);
1013 if (GPT - nchars < PT)
1014 adjust_point (nchars, nbytes);
1016 check_markers ();
1019 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1020 current buffer. If the text in BUF has properties, they are absorbed
1021 into the current buffer.
1023 It does not work to use `insert' for this, because a malloc could happen
1024 and relocate BUF's text before the copy happens. */
1026 void
1027 insert_from_buffer (struct buffer *buf,
1028 ptrdiff_t charpos, ptrdiff_t nchars, bool inherit)
1030 ptrdiff_t opoint = PT;
1032 insert_from_buffer_1 (buf, charpos, nchars, inherit);
1033 signal_after_change (opoint, 0, PT - opoint);
1034 update_compositions (opoint, PT, CHECK_BORDER);
1037 static void
1038 insert_from_buffer_1 (struct buffer *buf,
1039 ptrdiff_t from, ptrdiff_t nchars, bool inherit)
1041 ptrdiff_t chunk, chunk_expanded;
1042 ptrdiff_t from_byte = buf_charpos_to_bytepos (buf, from);
1043 ptrdiff_t to_byte = buf_charpos_to_bytepos (buf, from + nchars);
1044 ptrdiff_t incoming_nbytes = to_byte - from_byte;
1045 ptrdiff_t outgoing_nbytes = incoming_nbytes;
1046 INTERVAL intervals;
1048 /* Make OUTGOING_NBYTES describe the text
1049 as it will be inserted in this buffer. */
1051 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1052 outgoing_nbytes = nchars;
1053 else if (NILP (BVAR (buf, enable_multibyte_characters)))
1055 ptrdiff_t outgoing_before_gap = 0;
1056 ptrdiff_t outgoing_after_gap = 0;
1058 if (from < BUF_GPT (buf))
1060 chunk = BUF_GPT_BYTE (buf) - from_byte;
1061 if (chunk > incoming_nbytes)
1062 chunk = incoming_nbytes;
1063 outgoing_before_gap
1064 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf, from_byte),
1065 chunk);
1067 else
1068 chunk = 0;
1070 if (chunk < incoming_nbytes)
1071 outgoing_after_gap
1072 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf,
1073 from_byte + chunk),
1074 incoming_nbytes - chunk);
1076 outgoing_nbytes = outgoing_before_gap + outgoing_after_gap;
1079 /* Do this before moving and increasing the gap,
1080 because the before-change hooks might move the gap
1081 or make it smaller. */
1082 prepare_to_modify_buffer (PT, PT, NULL);
1084 if (PT != GPT)
1085 move_gap_both (PT, PT_BYTE);
1086 if (GAP_SIZE < outgoing_nbytes)
1087 make_gap (outgoing_nbytes - GAP_SIZE);
1089 if (from < BUF_GPT (buf))
1091 chunk = BUF_GPT_BYTE (buf) - from_byte;
1092 if (chunk > incoming_nbytes)
1093 chunk = incoming_nbytes;
1094 /* Record number of output bytes, so we know where
1095 to put the output from the second copy_text. */
1096 chunk_expanded
1097 = copy_text (BUF_BYTE_ADDRESS (buf, from_byte),
1098 GPT_ADDR, chunk,
1099 ! NILP (BVAR (buf, enable_multibyte_characters)),
1100 ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
1102 else
1103 chunk_expanded = chunk = 0;
1105 if (chunk < incoming_nbytes)
1106 copy_text (BUF_BYTE_ADDRESS (buf, from_byte + chunk),
1107 GPT_ADDR + chunk_expanded, incoming_nbytes - chunk,
1108 ! NILP (BVAR (buf, enable_multibyte_characters)),
1109 ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
1111 #ifdef BYTE_COMBINING_DEBUG
1112 /* We have copied text into the gap, but we have not altered
1113 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1114 to these functions and get the same results as we would
1115 have got earlier on. Meanwhile, GPT_ADDR does point to
1116 the text that has been stored by copy_text. */
1117 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
1118 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
1119 emacs_abort ();
1120 #endif
1122 record_insert (PT, nchars);
1123 MODIFF++;
1124 CHARS_MODIFF = MODIFF;
1126 GAP_SIZE -= outgoing_nbytes;
1127 GPT += nchars;
1128 ZV += nchars;
1129 Z += nchars;
1130 GPT_BYTE += outgoing_nbytes;
1131 ZV_BYTE += outgoing_nbytes;
1132 Z_BYTE += outgoing_nbytes;
1133 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1135 eassert (GPT <= GPT_BYTE);
1137 /* The insert may have been in the unchanged region, so check again. */
1138 if (Z - GPT < END_UNCHANGED)
1139 END_UNCHANGED = Z - GPT;
1141 adjust_overlays_for_insert (PT, nchars);
1142 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
1143 PT_BYTE + outgoing_nbytes,
1146 offset_intervals (current_buffer, PT, nchars);
1148 /* Get the intervals for the part of the string we are inserting. */
1149 intervals = buffer_intervals (buf);
1150 if (nchars < BUF_Z (buf) - BUF_BEG (buf))
1152 if (buf == current_buffer && PT <= from)
1153 from += nchars;
1154 intervals = copy_intervals (intervals, from, nchars);
1157 /* Insert those intervals. */
1158 graft_intervals_into_buffer (intervals, PT, nchars, current_buffer, inherit);
1160 adjust_point (nchars, outgoing_nbytes);
1163 /* Record undo information and adjust markers and position keepers for
1164 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1165 chars (LEN_BYTE bytes). If TEXT_AT_GAP_TAIL, the new text
1166 resides at the gap tail; i.e. at (GAP_END_ADDR - LEN_BYTE)
1167 Otherwise, the text resides in the gap just after GPT_BYTE.
1169 PREV_TEXT nil means the new text was just inserted. */
1171 void
1172 adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
1173 Lisp_Object prev_text, ptrdiff_t len, ptrdiff_t len_byte,
1174 bool text_at_gap_tail)
1176 ptrdiff_t nchars_del = 0, nbytes_del = 0;
1178 #ifdef BYTE_COMBINING_DEBUG
1179 if (count_combining_before (GPT_ADDR, len_byte, from, from_byte)
1180 || count_combining_after (GPT_ADDR, len_byte, from, from_byte))
1181 emacs_abort ();
1182 #endif
1184 if (STRINGP (prev_text))
1186 nchars_del = SCHARS (prev_text);
1187 nbytes_del = SBYTES (prev_text);
1190 /* Update various buffer positions for the new text. */
1191 GAP_SIZE -= len_byte;
1192 ZV += len; Z+= len;
1193 ZV_BYTE += len_byte; Z_BYTE += len_byte;
1194 if (! text_at_gap_tail)
1196 GPT += len; GPT_BYTE += len_byte;
1197 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1200 if (nchars_del > 0)
1201 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1202 len, len_byte);
1203 else
1204 adjust_markers_for_insert (from, from_byte,
1205 from + len, from_byte + len_byte, 0);
1207 if (! EQ (BVAR (current_buffer, undo_list), Qt))
1209 if (nchars_del > 0)
1210 record_delete (from, prev_text);
1211 record_insert (from, len);
1214 if (len > nchars_del)
1215 adjust_overlays_for_insert (from, len - nchars_del);
1216 else if (len < nchars_del)
1217 adjust_overlays_for_delete (from, nchars_del - len);
1219 offset_intervals (current_buffer, from, len - nchars_del);
1221 if (from < PT)
1222 adjust_point (len - nchars_del, len_byte - nbytes_del);
1224 /* As byte combining will decrease Z, we must check this again. */
1225 if (Z - GPT < END_UNCHANGED)
1226 END_UNCHANGED = Z - GPT;
1228 check_markers ();
1230 if (len == 0)
1231 evaporate_overlays (from);
1232 MODIFF++;
1233 CHARS_MODIFF = MODIFF;
1236 /* Record undo information, adjust markers and position keepers for an
1237 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1238 text already exists in the current buffer but character length (TO
1239 - FROM) may be incorrect, the correct length is NEWLEN. */
1241 void
1242 adjust_after_insert (ptrdiff_t from, ptrdiff_t from_byte,
1243 ptrdiff_t to, ptrdiff_t to_byte, ptrdiff_t newlen)
1245 ptrdiff_t len = to - from, len_byte = to_byte - from_byte;
1247 if (GPT != to)
1248 move_gap_both (to, to_byte);
1249 GAP_SIZE += len_byte;
1250 GPT -= len; GPT_BYTE -= len_byte;
1251 ZV -= len; ZV_BYTE -= len_byte;
1252 Z -= len; Z_BYTE -= len_byte;
1253 adjust_after_replace (from, from_byte, Qnil, newlen, len_byte, 0);
1256 /* Replace the text from character positions FROM to TO with NEW,
1257 If PREPARE, call prepare_to_modify_buffer.
1258 If INHERIT, the newly inserted text should inherit text properties
1259 from the surrounding non-deleted text. */
1261 /* Note that this does not yet handle markers quite right.
1262 Also it needs to record a single undo-entry that does a replacement
1263 rather than a separate delete and insert.
1264 That way, undo will also handle markers properly.
1266 But if MARKERS is 0, don't relocate markers. */
1268 void
1269 replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
1270 bool prepare, bool inherit, bool markers)
1272 ptrdiff_t inschars = SCHARS (new);
1273 ptrdiff_t insbytes = SBYTES (new);
1274 ptrdiff_t from_byte, to_byte;
1275 ptrdiff_t nbytes_del, nchars_del;
1276 struct gcpro gcpro1;
1277 INTERVAL intervals;
1278 ptrdiff_t outgoing_insbytes = insbytes;
1279 Lisp_Object deletion;
1281 check_markers ();
1283 GCPRO1 (new);
1284 deletion = Qnil;
1286 if (prepare)
1288 ptrdiff_t range_length = to - from;
1289 prepare_to_modify_buffer (from, to, &from);
1290 to = from + range_length;
1293 UNGCPRO;
1295 /* Make args be valid. */
1296 if (from < BEGV)
1297 from = BEGV;
1298 if (to > ZV)
1299 to = ZV;
1301 from_byte = CHAR_TO_BYTE (from);
1302 to_byte = CHAR_TO_BYTE (to);
1304 nchars_del = to - from;
1305 nbytes_del = to_byte - from_byte;
1307 if (nbytes_del <= 0 && insbytes == 0)
1308 return;
1310 /* Make OUTGOING_INSBYTES describe the text
1311 as it will be inserted in this buffer. */
1313 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1314 outgoing_insbytes = inschars;
1315 else if (! STRING_MULTIBYTE (new))
1316 outgoing_insbytes
1317 = count_size_as_multibyte (SDATA (new), insbytes);
1319 GCPRO1 (new);
1321 /* Make sure the gap is somewhere in or next to what we are deleting. */
1322 if (from > GPT)
1323 gap_right (from, from_byte);
1324 if (to < GPT)
1325 gap_left (to, to_byte, 0);
1327 /* Even if we don't record for undo, we must keep the original text
1328 because we may have to recover it because of inappropriate byte
1329 combining. */
1330 if (! EQ (BVAR (current_buffer, undo_list), Qt))
1331 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1333 GAP_SIZE += nbytes_del;
1334 ZV -= nchars_del;
1335 Z -= nchars_del;
1336 ZV_BYTE -= nbytes_del;
1337 Z_BYTE -= nbytes_del;
1338 GPT = from;
1339 GPT_BYTE = from_byte;
1340 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1342 eassert (GPT <= GPT_BYTE);
1344 if (GPT - BEG < BEG_UNCHANGED)
1345 BEG_UNCHANGED = GPT - BEG;
1346 if (Z - GPT < END_UNCHANGED)
1347 END_UNCHANGED = Z - GPT;
1349 if (GAP_SIZE < outgoing_insbytes)
1350 make_gap (outgoing_insbytes - GAP_SIZE);
1352 /* Copy the string text into the buffer, perhaps converting
1353 between single-byte and multibyte. */
1354 copy_text (SDATA (new), GPT_ADDR, insbytes,
1355 STRING_MULTIBYTE (new),
1356 ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
1358 #ifdef BYTE_COMBINING_DEBUG
1359 /* We have copied text into the gap, but we have not marked
1360 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1361 here, for both the previous text and the following text.
1362 Meanwhile, GPT_ADDR does point to
1363 the text that has been stored by copy_text. */
1364 if (count_combining_before (GPT_ADDR, outgoing_insbytes, from, from_byte)
1365 || count_combining_after (GPT_ADDR, outgoing_insbytes, from, from_byte))
1366 emacs_abort ();
1367 #endif
1369 if (! EQ (BVAR (current_buffer, undo_list), Qt))
1371 /* Record the insertion first, so that when we undo,
1372 the deletion will be undone first. Thus, undo
1373 will insert before deleting, and thus will keep
1374 the markers before and after this text separate. */
1375 record_insert (from + SCHARS (deletion), inschars);
1376 record_delete (from, deletion);
1379 GAP_SIZE -= outgoing_insbytes;
1380 GPT += inschars;
1381 ZV += inschars;
1382 Z += inschars;
1383 GPT_BYTE += outgoing_insbytes;
1384 ZV_BYTE += outgoing_insbytes;
1385 Z_BYTE += outgoing_insbytes;
1386 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1388 eassert (GPT <= GPT_BYTE);
1390 /* Adjust markers for the deletion and the insertion. */
1391 if (markers)
1392 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1393 inschars, outgoing_insbytes);
1395 /* Adjust the overlay center as needed. This must be done after
1396 adjusting the markers that bound the overlays. */
1397 adjust_overlays_for_delete (from, nchars_del);
1398 adjust_overlays_for_insert (from, inschars);
1400 offset_intervals (current_buffer, from, inschars - nchars_del);
1402 /* Get the intervals for the part of the string we are inserting--
1403 not including the combined-before bytes. */
1404 intervals = string_intervals (new);
1405 /* Insert those intervals. */
1406 graft_intervals_into_buffer (intervals, from, inschars,
1407 current_buffer, inherit);
1409 /* Relocate point as if it were a marker. */
1410 if (from < PT)
1411 adjust_point ((from + inschars - (PT < to ? PT : to)),
1412 (from_byte + outgoing_insbytes
1413 - (PT_BYTE < to_byte ? PT_BYTE : to_byte)));
1415 if (outgoing_insbytes == 0)
1416 evaporate_overlays (from);
1418 check_markers ();
1420 MODIFF++;
1421 CHARS_MODIFF = MODIFF;
1422 UNGCPRO;
1424 signal_after_change (from, nchars_del, GPT - from);
1425 update_compositions (from, GPT, CHECK_BORDER);
1428 /* Replace the text from character positions FROM to TO with
1429 the text in INS of length INSCHARS.
1430 Keep the text properties that applied to the old characters
1431 (extending them to all the new chars if there are more new chars).
1433 Note that this does not yet handle markers quite right.
1435 If MARKERS, relocate markers.
1437 Unlike most functions at this level, never call
1438 prepare_to_modify_buffer and never call signal_after_change. */
1440 void
1441 replace_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
1442 ptrdiff_t to, ptrdiff_t to_byte,
1443 const char *ins, ptrdiff_t inschars, ptrdiff_t insbytes,
1444 bool markers)
1446 ptrdiff_t nbytes_del, nchars_del;
1448 check_markers ();
1450 nchars_del = to - from;
1451 nbytes_del = to_byte - from_byte;
1453 if (nbytes_del <= 0 && insbytes == 0)
1454 return;
1456 /* Make sure the gap is somewhere in or next to what we are deleting. */
1457 if (from > GPT)
1458 gap_right (from, from_byte);
1459 if (to < GPT)
1460 gap_left (to, to_byte, 0);
1462 GAP_SIZE += nbytes_del;
1463 ZV -= nchars_del;
1464 Z -= nchars_del;
1465 ZV_BYTE -= nbytes_del;
1466 Z_BYTE -= nbytes_del;
1467 GPT = from;
1468 GPT_BYTE = from_byte;
1469 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1471 eassert (GPT <= GPT_BYTE);
1473 if (GPT - BEG < BEG_UNCHANGED)
1474 BEG_UNCHANGED = GPT - BEG;
1475 if (Z - GPT < END_UNCHANGED)
1476 END_UNCHANGED = Z - GPT;
1478 if (GAP_SIZE < insbytes)
1479 make_gap (insbytes - GAP_SIZE);
1481 /* Copy the replacement text into the buffer. */
1482 memcpy (GPT_ADDR, ins, insbytes);
1484 #ifdef BYTE_COMBINING_DEBUG
1485 /* We have copied text into the gap, but we have not marked
1486 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1487 here, for both the previous text and the following text.
1488 Meanwhile, GPT_ADDR does point to
1489 the text that has been stored by copy_text. */
1490 if (count_combining_before (GPT_ADDR, insbytes, from, from_byte)
1491 || count_combining_after (GPT_ADDR, insbytes, from, from_byte))
1492 emacs_abort ();
1493 #endif
1495 GAP_SIZE -= insbytes;
1496 GPT += inschars;
1497 ZV += inschars;
1498 Z += inschars;
1499 GPT_BYTE += insbytes;
1500 ZV_BYTE += insbytes;
1501 Z_BYTE += insbytes;
1502 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1504 eassert (GPT <= GPT_BYTE);
1506 /* Adjust markers for the deletion and the insertion. */
1507 if (markers
1508 && ! (nchars_del == 1 && inschars == 1 && nbytes_del == insbytes))
1509 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1510 inschars, insbytes);
1512 /* Adjust the overlay center as needed. This must be done after
1513 adjusting the markers that bound the overlays. */
1514 if (nchars_del != inschars)
1516 adjust_overlays_for_insert (from, inschars);
1517 adjust_overlays_for_delete (from + inschars, nchars_del);
1520 offset_intervals (current_buffer, from, inschars - nchars_del);
1522 /* Relocate point as if it were a marker. */
1523 if (from < PT && (nchars_del != inschars || nbytes_del != insbytes))
1525 if (PT < to)
1526 /* PT was within the deleted text. Move it to FROM. */
1527 adjust_point (from - PT, from_byte - PT_BYTE);
1528 else
1529 adjust_point (inschars - nchars_del, insbytes - nbytes_del);
1532 if (insbytes == 0)
1533 evaporate_overlays (from);
1535 check_markers ();
1537 MODIFF++;
1538 CHARS_MODIFF = MODIFF;
1541 /* Delete characters in current buffer
1542 from FROM up to (but not including) TO.
1543 If TO comes before FROM, we delete nothing. */
1545 void
1546 del_range (ptrdiff_t from, ptrdiff_t to)
1548 del_range_1 (from, to, 1, 0);
1551 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1552 RET_STRING says to return the deleted text. */
1554 Lisp_Object
1555 del_range_1 (ptrdiff_t from, ptrdiff_t to, bool prepare, bool ret_string)
1557 ptrdiff_t from_byte, to_byte;
1558 Lisp_Object deletion;
1559 struct gcpro gcpro1;
1561 /* Make args be valid */
1562 if (from < BEGV)
1563 from = BEGV;
1564 if (to > ZV)
1565 to = ZV;
1567 if (to <= from)
1568 return Qnil;
1570 if (prepare)
1572 ptrdiff_t range_length = to - from;
1573 prepare_to_modify_buffer (from, to, &from);
1574 to = min (ZV, from + range_length);
1577 from_byte = CHAR_TO_BYTE (from);
1578 to_byte = CHAR_TO_BYTE (to);
1580 deletion = del_range_2 (from, from_byte, to, to_byte, ret_string);
1581 GCPRO1 (deletion);
1582 signal_after_change (from, to - from, 0);
1583 update_compositions (from, from, CHECK_HEAD);
1584 UNGCPRO;
1585 return deletion;
1588 /* Like del_range_1 but args are byte positions, not char positions. */
1590 void
1591 del_range_byte (ptrdiff_t from_byte, ptrdiff_t to_byte, bool prepare)
1593 ptrdiff_t from, to;
1595 /* Make args be valid */
1596 if (from_byte < BEGV_BYTE)
1597 from_byte = BEGV_BYTE;
1598 if (to_byte > ZV_BYTE)
1599 to_byte = ZV_BYTE;
1601 if (to_byte <= from_byte)
1602 return;
1604 from = BYTE_TO_CHAR (from_byte);
1605 to = BYTE_TO_CHAR (to_byte);
1607 if (prepare)
1609 ptrdiff_t old_from = from, old_to = Z - to;
1610 ptrdiff_t range_length = to - from;
1611 prepare_to_modify_buffer (from, to, &from);
1612 to = from + range_length;
1614 if (old_from != from)
1615 from_byte = CHAR_TO_BYTE (from);
1616 if (to > ZV)
1618 to = ZV;
1619 to_byte = ZV_BYTE;
1621 else if (old_to == Z - to)
1622 to_byte = CHAR_TO_BYTE (to);
1625 del_range_2 (from, from_byte, to, to_byte, 0);
1626 signal_after_change (from, to - from, 0);
1627 update_compositions (from, from, CHECK_HEAD);
1630 /* Like del_range_1, but positions are specified both as charpos
1631 and bytepos. */
1633 void
1634 del_range_both (ptrdiff_t from, ptrdiff_t from_byte,
1635 ptrdiff_t to, ptrdiff_t to_byte, bool prepare)
1637 /* Make args be valid */
1638 if (from_byte < BEGV_BYTE)
1639 from_byte = BEGV_BYTE;
1640 if (to_byte > ZV_BYTE)
1641 to_byte = ZV_BYTE;
1643 if (to_byte <= from_byte)
1644 return;
1646 if (from < BEGV)
1647 from = BEGV;
1648 if (to > ZV)
1649 to = ZV;
1651 if (prepare)
1653 ptrdiff_t old_from = from, old_to = Z - to;
1654 ptrdiff_t range_length = to - from;
1655 prepare_to_modify_buffer (from, to, &from);
1656 to = from + range_length;
1658 if (old_from != from)
1659 from_byte = CHAR_TO_BYTE (from);
1660 if (to > ZV)
1662 to = ZV;
1663 to_byte = ZV_BYTE;
1665 else if (old_to == Z - to)
1666 to_byte = CHAR_TO_BYTE (to);
1669 del_range_2 (from, from_byte, to, to_byte, 0);
1670 signal_after_change (from, to - from, 0);
1671 update_compositions (from, from, CHECK_HEAD);
1674 /* Delete a range of text, specified both as character positions
1675 and byte positions. FROM and TO are character positions,
1676 while FROM_BYTE and TO_BYTE are byte positions.
1677 If RET_STRING, the deleted area is returned as a string. */
1679 Lisp_Object
1680 del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
1681 ptrdiff_t to, ptrdiff_t to_byte, bool ret_string)
1683 ptrdiff_t nbytes_del, nchars_del;
1684 Lisp_Object deletion;
1686 check_markers ();
1688 nchars_del = to - from;
1689 nbytes_del = to_byte - from_byte;
1691 /* Make sure the gap is somewhere in or next to what we are deleting. */
1692 if (from > GPT)
1693 gap_right (from, from_byte);
1694 if (to < GPT)
1695 gap_left (to, to_byte, 0);
1697 #ifdef BYTE_COMBINING_DEBUG
1698 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer, to_byte),
1699 Z_BYTE - to_byte, from, from_byte))
1700 emacs_abort ();
1701 #endif
1703 if (ret_string || ! EQ (BVAR (current_buffer, undo_list), Qt))
1704 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1705 else
1706 deletion = Qnil;
1708 /* Relocate all markers pointing into the new, larger gap
1709 to point at the end of the text before the gap.
1710 Do this before recording the deletion,
1711 so that undo handles this after reinserting the text. */
1712 adjust_markers_for_delete (from, from_byte, to, to_byte);
1714 if (! EQ (BVAR (current_buffer, undo_list), Qt))
1715 record_delete (from, deletion);
1716 MODIFF++;
1717 CHARS_MODIFF = MODIFF;
1719 /* Relocate point as if it were a marker. */
1720 if (from < PT)
1721 adjust_point (from - (PT < to ? PT : to),
1722 from_byte - (PT_BYTE < to_byte ? PT_BYTE : to_byte));
1724 offset_intervals (current_buffer, from, - nchars_del);
1726 /* Adjust the overlay center as needed. This must be done after
1727 adjusting the markers that bound the overlays. */
1728 adjust_overlays_for_delete (from, nchars_del);
1730 GAP_SIZE += nbytes_del;
1731 ZV_BYTE -= nbytes_del;
1732 Z_BYTE -= nbytes_del;
1733 ZV -= nchars_del;
1734 Z -= nchars_del;
1735 GPT = from;
1736 GPT_BYTE = from_byte;
1737 if (GAP_SIZE > 0 && !current_buffer->text->inhibit_shrinking)
1738 /* Put an anchor, unless called from decode_coding_object which
1739 needs to access the previous gap contents. */
1740 *(GPT_ADDR) = 0;
1742 eassert (GPT <= GPT_BYTE);
1744 if (GPT - BEG < BEG_UNCHANGED)
1745 BEG_UNCHANGED = GPT - BEG;
1746 if (Z - GPT < END_UNCHANGED)
1747 END_UNCHANGED = Z - GPT;
1749 check_markers ();
1751 evaporate_overlays (from);
1753 return deletion;
1756 /* Call this if you're about to change the region of current buffer
1757 from character positions START to END. This checks the read-only
1758 properties of the region, calls the necessary modification hooks,
1759 and warns the next redisplay that it should pay attention to that
1760 area.
1762 If PRESERVE_CHARS_MODIFF, do not update CHARS_MODIFF.
1763 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
1765 void
1766 modify_region_1 (ptrdiff_t start, ptrdiff_t end, bool preserve_chars_modiff)
1768 prepare_to_modify_buffer (start, end, NULL);
1770 BUF_COMPUTE_UNCHANGED (current_buffer, start - 1, end);
1772 if (MODIFF <= SAVE_MODIFF)
1773 record_first_change ();
1774 MODIFF++;
1775 if (! preserve_chars_modiff)
1776 CHARS_MODIFF = MODIFF;
1778 bset_point_before_scroll (current_buffer, Qnil);
1781 /* Check that it is okay to modify the buffer between START and END,
1782 which are char positions.
1784 Run the before-change-function, if any. If intervals are in use,
1785 verify that the text to be modified is not read-only, and call
1786 any modification properties the text may have.
1788 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1789 by holding its value temporarily in a marker. */
1791 void
1792 prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
1793 ptrdiff_t *preserve_ptr)
1795 struct buffer *base_buffer;
1797 if (!NILP (BVAR (current_buffer, read_only)))
1798 Fbarf_if_buffer_read_only ();
1800 /* If we're modifying the buffer other than shown in a selected window,
1801 let redisplay consider other windows if this buffer is visible. */
1802 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer
1803 && buffer_window_count (current_buffer))
1804 ++windows_or_buffers_changed;
1806 if (buffer_intervals (current_buffer))
1808 if (preserve_ptr)
1810 Lisp_Object preserve_marker;
1811 struct gcpro gcpro1;
1812 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil);
1813 GCPRO1 (preserve_marker);
1814 verify_interval_modification (current_buffer, start, end);
1815 *preserve_ptr = marker_position (preserve_marker);
1816 unchain_marker (XMARKER (preserve_marker));
1817 UNGCPRO;
1819 else
1820 verify_interval_modification (current_buffer, start, end);
1823 /* For indirect buffers, use the base buffer to check clashes. */
1824 if (current_buffer->base_buffer != 0)
1825 base_buffer = current_buffer->base_buffer;
1826 else
1827 base_buffer = current_buffer;
1829 #ifdef CLASH_DETECTION
1830 if (!NILP (BVAR (base_buffer, file_truename))
1831 /* Make binding buffer-file-name to nil effective. */
1832 && !NILP (BVAR (base_buffer, filename))
1833 && SAVE_MODIFF >= MODIFF)
1834 lock_file (BVAR (base_buffer, file_truename));
1835 #else
1836 /* At least warn if this file has changed on disk since it was visited. */
1837 if (!NILP (BVAR (base_buffer, filename))
1838 && SAVE_MODIFF >= MODIFF
1839 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1840 && !NILP (Ffile_exists_p (BVAR (base_buffer, filename))))
1841 call1 (intern ("ask-user-about-supersession-threat"),
1842 BVAR (base_buffer,filename));
1843 #endif /* not CLASH_DETECTION */
1845 /* If `select-active-regions' is non-nil, save the region text. */
1846 if (!NILP (BVAR (current_buffer, mark_active))
1847 && !inhibit_modification_hooks
1848 && XMARKER (BVAR (current_buffer, mark))->buffer
1849 && NILP (Vsaved_region_selection)
1850 && (EQ (Vselect_active_regions, Qonly)
1851 ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
1852 : (!NILP (Vselect_active_regions)
1853 && !NILP (Vtransient_mark_mode))))
1855 ptrdiff_t b = marker_position (BVAR (current_buffer, mark));
1856 ptrdiff_t e = PT;
1857 if (b < e)
1858 Vsaved_region_selection = make_buffer_string (b, e, 0);
1859 else if (b > e)
1860 Vsaved_region_selection = make_buffer_string (e, b, 0);
1863 signal_before_change (start, end, preserve_ptr);
1865 if (current_buffer->newline_cache)
1866 invalidate_region_cache (current_buffer,
1867 current_buffer->newline_cache,
1868 start - BEG, Z - end);
1869 if (current_buffer->width_run_cache)
1870 invalidate_region_cache (current_buffer,
1871 current_buffer->width_run_cache,
1872 start - BEG, Z - end);
1874 Vdeactivate_mark = Qt;
1877 /* These macros work with an argument named `preserve_ptr'
1878 and a local variable named `preserve_marker'. */
1880 #define PRESERVE_VALUE \
1881 if (preserve_ptr && NILP (preserve_marker)) \
1882 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1884 #define RESTORE_VALUE \
1885 if (! NILP (preserve_marker)) \
1887 *preserve_ptr = marker_position (preserve_marker); \
1888 unchain_marker (XMARKER (preserve_marker)); \
1891 #define PRESERVE_START_END \
1892 if (NILP (start_marker)) \
1893 start_marker = Fcopy_marker (start, Qnil); \
1894 if (NILP (end_marker)) \
1895 end_marker = Fcopy_marker (end, Qnil);
1897 #define FETCH_START \
1898 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1900 #define FETCH_END \
1901 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1903 /* Set a variable to nil if an error occurred.
1904 Don't change the variable if there was no error.
1905 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
1906 VARIABLE is the variable to maybe set to nil.
1907 NO-ERROR-FLAG is nil if there was an error,
1908 anything else meaning no error (so this function does nothing). */
1909 static Lisp_Object
1910 reset_var_on_error (Lisp_Object val)
1912 if (NILP (XCDR (val)))
1913 Fset (XCAR (val), Qnil);
1914 return Qnil;
1917 /* Signal a change to the buffer immediately before it happens.
1918 START_INT and END_INT are the bounds of the text to be changed.
1920 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1921 by holding its value temporarily in a marker. */
1923 static void
1924 signal_before_change (ptrdiff_t start_int, ptrdiff_t end_int,
1925 ptrdiff_t *preserve_ptr)
1927 Lisp_Object start, end;
1928 Lisp_Object start_marker, end_marker;
1929 Lisp_Object preserve_marker;
1930 struct gcpro gcpro1, gcpro2, gcpro3;
1931 ptrdiff_t count = SPECPDL_INDEX ();
1933 if (inhibit_modification_hooks)
1934 return;
1936 start = make_number (start_int);
1937 end = make_number (end_int);
1938 preserve_marker = Qnil;
1939 start_marker = Qnil;
1940 end_marker = Qnil;
1941 GCPRO3 (preserve_marker, start_marker, end_marker);
1943 specbind (Qinhibit_modification_hooks, Qt);
1945 /* If buffer is unmodified, run a special hook for that case. The
1946 check for Vfirst_change_hook is just a minor optimization. */
1947 if (SAVE_MODIFF >= MODIFF
1948 && !NILP (Vfirst_change_hook))
1950 PRESERVE_VALUE;
1951 PRESERVE_START_END;
1952 Frun_hooks (1, &Qfirst_change_hook);
1955 /* Now run the before-change-functions if any. */
1956 if (!NILP (Vbefore_change_functions))
1958 Lisp_Object args[3];
1959 Lisp_Object rvoe_arg = Fcons (Qbefore_change_functions, Qnil);
1961 PRESERVE_VALUE;
1962 PRESERVE_START_END;
1964 /* Mark before-change-functions to be reset to nil in case of error. */
1965 record_unwind_protect (reset_var_on_error, rvoe_arg);
1967 /* Actually run the hook functions. */
1968 args[0] = Qbefore_change_functions;
1969 args[1] = FETCH_START;
1970 args[2] = FETCH_END;
1971 Frun_hook_with_args (3, args);
1973 /* There was no error: unarm the reset_on_error. */
1974 XSETCDR (rvoe_arg, Qt);
1977 if (buffer_has_overlays ())
1979 PRESERVE_VALUE;
1980 report_overlay_modification (FETCH_START, FETCH_END, 0,
1981 FETCH_START, FETCH_END, Qnil);
1984 if (! NILP (start_marker))
1985 free_marker (start_marker);
1986 if (! NILP (end_marker))
1987 free_marker (end_marker);
1988 RESTORE_VALUE;
1989 UNGCPRO;
1991 unbind_to (count, Qnil);
1994 /* Signal a change immediately after it happens.
1995 CHARPOS is the character position of the start of the changed text.
1996 LENDEL is the number of characters of the text before the change.
1997 (Not the whole buffer; just the part that was changed.)
1998 LENINS is the number of characters in that part of the text
1999 after the change. */
2001 void
2002 signal_after_change (ptrdiff_t charpos, ptrdiff_t lendel, ptrdiff_t lenins)
2004 ptrdiff_t count = SPECPDL_INDEX ();
2005 if (inhibit_modification_hooks)
2006 return;
2008 /* If we are deferring calls to the after-change functions
2009 and there are no before-change functions,
2010 just record the args that we were going to use. */
2011 if (! NILP (Vcombine_after_change_calls)
2012 && NILP (Vbefore_change_functions)
2013 && !buffer_has_overlays ())
2015 Lisp_Object elt;
2017 if (!NILP (combine_after_change_list)
2018 && current_buffer != XBUFFER (combine_after_change_buffer))
2019 Fcombine_after_change_execute ();
2021 elt = list3i (charpos - BEG, Z - (charpos - lendel + lenins),
2022 lenins - lendel);
2023 combine_after_change_list
2024 = Fcons (elt, combine_after_change_list);
2025 combine_after_change_buffer = Fcurrent_buffer ();
2027 return;
2030 if (!NILP (combine_after_change_list))
2031 Fcombine_after_change_execute ();
2033 specbind (Qinhibit_modification_hooks, Qt);
2035 if (!NILP (Vafter_change_functions))
2037 Lisp_Object args[4];
2038 Lisp_Object rvoe_arg = Fcons (Qafter_change_functions, Qnil);
2040 /* Mark after-change-functions to be reset to nil in case of error. */
2041 record_unwind_protect (reset_var_on_error, rvoe_arg);
2043 /* Actually run the hook functions. */
2044 args[0] = Qafter_change_functions;
2045 XSETFASTINT (args[1], charpos);
2046 XSETFASTINT (args[2], charpos + lenins);
2047 XSETFASTINT (args[3], lendel);
2048 Frun_hook_with_args (4, args);
2050 /* There was no error: unarm the reset_on_error. */
2051 XSETCDR (rvoe_arg, Qt);
2054 if (buffer_has_overlays ())
2055 report_overlay_modification (make_number (charpos),
2056 make_number (charpos + lenins),
2058 make_number (charpos),
2059 make_number (charpos + lenins),
2060 make_number (lendel));
2062 /* After an insertion, call the text properties
2063 insert-behind-hooks or insert-in-front-hooks. */
2064 if (lendel == 0)
2065 report_interval_modification (make_number (charpos),
2066 make_number (charpos + lenins));
2068 unbind_to (count, Qnil);
2071 static Lisp_Object
2072 Fcombine_after_change_execute_1 (Lisp_Object val)
2074 Vcombine_after_change_calls = val;
2075 return val;
2078 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
2079 Scombine_after_change_execute, 0, 0, 0,
2080 doc: /* This function is for use internally in the function `combine-after-change-calls'. */)
2081 (void)
2083 ptrdiff_t count = SPECPDL_INDEX ();
2084 ptrdiff_t beg, end, change;
2085 ptrdiff_t begpos, endpos;
2086 Lisp_Object tail;
2088 if (NILP (combine_after_change_list))
2089 return Qnil;
2091 /* It is rare for combine_after_change_buffer to be invalid, but
2092 possible. It can happen when combine-after-change-calls is
2093 non-nil, and insertion calls a file handler (e.g. through
2094 lock_file) which scribbles into a temp file -- cyd */
2095 if (!BUFFERP (combine_after_change_buffer)
2096 || !BUFFER_LIVE_P (XBUFFER (combine_after_change_buffer)))
2098 combine_after_change_list = Qnil;
2099 return Qnil;
2102 record_unwind_current_buffer ();
2104 Fset_buffer (combine_after_change_buffer);
2106 /* # chars unchanged at beginning of buffer. */
2107 beg = Z - BEG;
2108 /* # chars unchanged at end of buffer. */
2109 end = beg;
2110 /* Total amount of insertion (negative for deletion). */
2111 change = 0;
2113 /* Scan the various individual changes,
2114 accumulating the range info in BEG, END and CHANGE. */
2115 for (tail = combine_after_change_list; CONSP (tail);
2116 tail = XCDR (tail))
2118 Lisp_Object elt;
2119 ptrdiff_t thisbeg, thisend, thischange;
2121 /* Extract the info from the next element. */
2122 elt = XCAR (tail);
2123 if (! CONSP (elt))
2124 continue;
2125 thisbeg = XINT (XCAR (elt));
2127 elt = XCDR (elt);
2128 if (! CONSP (elt))
2129 continue;
2130 thisend = XINT (XCAR (elt));
2132 elt = XCDR (elt);
2133 if (! CONSP (elt))
2134 continue;
2135 thischange = XINT (XCAR (elt));
2137 /* Merge this range into the accumulated range. */
2138 change += thischange;
2139 if (thisbeg < beg)
2140 beg = thisbeg;
2141 if (thisend < end)
2142 end = thisend;
2145 /* Get the current start and end positions of the range
2146 that was changed. */
2147 begpos = BEG + beg;
2148 endpos = Z - end;
2150 /* We are about to handle these, so discard them. */
2151 combine_after_change_list = Qnil;
2153 /* Now run the after-change functions for real.
2154 Turn off the flag that defers them. */
2155 record_unwind_protect (Fcombine_after_change_execute_1,
2156 Vcombine_after_change_calls);
2157 signal_after_change (begpos, endpos - begpos - change, endpos - begpos);
2158 update_compositions (begpos, endpos, CHECK_ALL);
2160 return unbind_to (count, Qnil);
2163 void
2164 syms_of_insdel (void)
2166 staticpro (&combine_after_change_list);
2167 staticpro (&combine_after_change_buffer);
2168 combine_after_change_list = Qnil;
2169 combine_after_change_buffer = Qnil;
2171 DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls,
2172 doc: /* Used internally by the function `combine-after-change-calls' macro. */);
2173 Vcombine_after_change_calls = Qnil;
2175 DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks,
2176 doc: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2177 This affects `before-change-functions' and `after-change-functions',
2178 as well as hooks attached to text properties and overlays. */);
2179 inhibit_modification_hooks = 0;
2180 DEFSYM (Qinhibit_modification_hooks, "inhibit-modification-hooks");
2182 defsubr (&Scombine_after_change_execute);