Add arch tagline
[emacs.git] / src / insdel.c
blob5cde53864b73b2a3733f1884a23531a75c1b1f06
1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #include <config.h>
24 #include "lisp.h"
25 #include "intervals.h"
26 #include "buffer.h"
27 #include "charset.h"
28 #include "window.h"
29 #include "blockinput.h"
30 #include "region-cache.h"
32 #ifndef NULL
33 #define NULL 0
34 #endif
36 static void insert_from_string_1 P_ ((Lisp_Object, int, int, int, int, int, int));
37 static void insert_from_buffer_1 ();
38 static void gap_left P_ ((int, int, int));
39 static void gap_right P_ ((int, int));
40 static void adjust_markers_gap_motion P_ ((int, int, int));
41 static void adjust_markers_for_insert P_ ((int, int, int, int, int));
42 void adjust_markers_for_delete P_ ((int, int, int, int));
43 static void adjust_markers_for_replace P_ ((int, int, int, int, int, int));
44 static void adjust_point P_ ((int, int));
46 Lisp_Object Fcombine_after_change_execute ();
48 /* Non-nil means don't call the after-change-functions right away,
49 just record an element in Vcombine_after_change_calls_list. */
50 Lisp_Object Vcombine_after_change_calls;
52 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
53 describing changes which happened while combine_after_change_calls
54 was nonzero. We use this to decide how to call them
55 once the deferral ends.
57 In each element.
58 BEG-UNCHANGED is the number of chars before the changed range.
59 END-UNCHANGED is the number of chars after the changed range,
60 and CHANGE-AMOUNT is the number of characters inserted by the change
61 (negative for a deletion). */
62 Lisp_Object combine_after_change_list;
64 /* Buffer which combine_after_change_list is about. */
65 Lisp_Object combine_after_change_buffer;
67 Lisp_Object Qinhibit_modification_hooks;
70 /* Check all markers in the current buffer, looking for something invalid. */
72 static int check_markers_debug_flag;
74 #define CHECK_MARKERS() \
75 if (check_markers_debug_flag) \
76 check_markers (); \
77 else
79 void
80 check_markers ()
82 register struct Lisp_Marker *tail;
83 int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
85 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
87 if (tail->buffer->text != current_buffer->text)
88 abort ();
89 if (tail->charpos > Z)
90 abort ();
91 if (tail->bytepos > Z_BYTE)
92 abort ();
93 if (multibyte && ! CHAR_HEAD_P (FETCH_BYTE (tail->bytepos)))
94 abort ();
98 /* Move gap to position CHARPOS.
99 Note that this can quit! */
101 void
102 move_gap (charpos)
103 int charpos;
105 move_gap_both (charpos, charpos_to_bytepos (charpos));
108 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
109 Note that this can quit! */
111 void
112 move_gap_both (charpos, bytepos)
113 int charpos, bytepos;
115 if (bytepos < GPT_BYTE)
116 gap_left (charpos, bytepos, 0);
117 else if (bytepos > GPT_BYTE)
118 gap_right (charpos, bytepos);
121 /* Move the gap to a position less than the current GPT.
122 BYTEPOS describes the new position as a byte position,
123 and CHARPOS is the corresponding char position.
124 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
126 static void
127 gap_left (charpos, bytepos, newgap)
128 register int charpos, bytepos;
129 int newgap;
131 register unsigned char *to, *from;
132 register int i;
133 int new_s1;
135 if (!newgap)
136 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
138 i = GPT_BYTE;
139 to = GAP_END_ADDR;
140 from = GPT_ADDR;
141 new_s1 = GPT_BYTE;
143 /* Now copy the characters. To move the gap down,
144 copy characters up. */
146 while (1)
148 /* I gets number of characters left to copy. */
149 i = new_s1 - bytepos;
150 if (i == 0)
151 break;
152 /* If a quit is requested, stop copying now.
153 Change BYTEPOS to be where we have actually moved the gap to. */
154 if (QUITP)
156 bytepos = new_s1;
157 charpos = BYTE_TO_CHAR (bytepos);
158 break;
160 /* Move at most 32000 chars before checking again for a quit. */
161 if (i > 32000)
162 i = 32000;
163 #ifdef GAP_USE_BCOPY
164 if (i >= 128
165 /* bcopy is safe if the two areas of memory do not overlap
166 or on systems where bcopy is always safe for moving upward. */
167 && (BCOPY_UPWARD_SAFE
168 || to - from >= 128))
170 /* If overlap is not safe, avoid it by not moving too many
171 characters at once. */
172 if (!BCOPY_UPWARD_SAFE && i > to - from)
173 i = to - from;
174 new_s1 -= i;
175 from -= i, to -= i;
176 bcopy (from, to, i);
178 else
179 #endif
181 new_s1 -= i;
182 while (--i >= 0)
183 *--to = *--from;
187 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
188 BYTEPOS is where the loop above stopped, which may be what was specified
189 or may be where a quit was detected. */
190 adjust_markers_gap_motion (bytepos, GPT_BYTE, GAP_SIZE);
191 GPT_BYTE = bytepos;
192 GPT = charpos;
193 if (bytepos < charpos)
194 abort ();
195 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
196 QUIT;
199 /* Move the gap to a position greater than than the current GPT.
200 BYTEPOS describes the new position as a byte position,
201 and CHARPOS is the corresponding char position. */
203 static void
204 gap_right (charpos, bytepos)
205 register int charpos, bytepos;
207 register unsigned char *to, *from;
208 register int i;
209 int new_s1;
211 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
213 i = GPT_BYTE;
214 from = GAP_END_ADDR;
215 to = GPT_ADDR;
216 new_s1 = GPT_BYTE;
218 /* Now copy the characters. To move the gap up,
219 copy characters down. */
221 while (1)
223 /* I gets number of characters left to copy. */
224 i = bytepos - new_s1;
225 if (i == 0)
226 break;
227 /* If a quit is requested, stop copying now.
228 Change BYTEPOS to be where we have actually moved the gap to. */
229 if (QUITP)
231 bytepos = new_s1;
232 charpos = BYTE_TO_CHAR (bytepos);
233 break;
235 /* Move at most 32000 chars before checking again for a quit. */
236 if (i > 32000)
237 i = 32000;
238 #ifdef GAP_USE_BCOPY
239 if (i >= 128
240 /* bcopy is safe if the two areas of memory do not overlap
241 or on systems where bcopy is always safe for moving downward. */
242 && (BCOPY_DOWNWARD_SAFE
243 || from - to >= 128))
245 /* If overlap is not safe, avoid it by not moving too many
246 characters at once. */
247 if (!BCOPY_DOWNWARD_SAFE && i > from - to)
248 i = from - to;
249 new_s1 += i;
250 bcopy (from, to, i);
251 from += i, to += i;
253 else
254 #endif
256 new_s1 += i;
257 while (--i >= 0)
258 *to++ = *from++;
262 adjust_markers_gap_motion (GPT_BYTE + GAP_SIZE, bytepos + GAP_SIZE,
263 - GAP_SIZE);
264 GPT = charpos;
265 GPT_BYTE = bytepos;
266 if (bytepos < charpos)
267 abort ();
268 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
269 QUIT;
272 /* Add AMOUNT to the byte position of every marker in the current buffer
273 whose current byte position is between FROM (exclusive) and TO (inclusive).
275 Also, any markers past the outside of that interval, in the direction
276 of adjustment, are first moved back to the near end of the interval
277 and then adjusted by AMOUNT.
279 When the latter adjustment is done, if AMOUNT is negative,
280 we record the adjustment for undo. (This case happens only for
281 deletion.)
283 The markers' character positions are not altered,
284 because gap motion does not affect character positions. */
286 int adjust_markers_test;
288 static void
289 adjust_markers_gap_motion (from, to, amount)
290 register int from, to, amount;
292 /* Now that a marker has a bytepos, not counting the gap,
293 nothing needs to be done here. */
294 #if 0
295 Lisp_Object marker;
296 register struct Lisp_Marker *m;
297 register int mpos;
299 marker = BUF_MARKERS (current_buffer);
301 while (!NILP (marker))
303 m = XMARKER (marker);
304 mpos = m->bytepos;
305 if (amount > 0)
307 if (mpos > to && mpos < to + amount)
309 if (adjust_markers_test)
310 abort ();
311 mpos = to + amount;
314 else
316 /* Here's the case where a marker is inside text being deleted.
317 AMOUNT can be negative for gap motion, too,
318 but then this range contains no markers. */
319 if (mpos > from + amount && mpos <= from)
321 if (adjust_markers_test)
322 abort ();
323 mpos = from + amount;
326 if (mpos > from && mpos <= to)
327 mpos += amount;
328 m->bufpos = mpos;
329 marker = m->chain;
331 #endif
334 /* Adjust all markers for a deletion
335 whose range in bytes is FROM_BYTE to TO_BYTE.
336 The range in charpos is FROM to TO.
338 This function assumes that the gap is adjacent to
339 or inside of the range being deleted. */
341 void
342 adjust_markers_for_delete (from, from_byte, to, to_byte)
343 register int from, from_byte, to, to_byte;
345 Lisp_Object marker;
346 register struct Lisp_Marker *m;
347 register int charpos;
349 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
351 charpos = m->charpos;
353 if (charpos > Z)
354 abort ();
356 /* If the marker is after the deletion,
357 relocate by number of chars / bytes deleted. */
358 if (charpos > to)
360 m->charpos -= to - from;
361 m->bytepos -= to_byte - from_byte;
363 /* Here's the case where a marker is inside text being deleted. */
364 else if (charpos > from)
366 if (! m->insertion_type)
367 { /* Normal markers will end up at the beginning of the
368 re-inserted text after undoing a deletion, and must be
369 adjusted to move them to the correct place. */
370 XSETMISC (marker, m);
371 record_marker_adjustment (marker, from - charpos);
373 else if (charpos < to)
374 { /* Before-insertion markers will automatically move forward
375 upon re-inserting the deleted text, so we have to arrange
376 for them to move backward to the correct position. */
377 XSETMISC (marker, m);
378 record_marker_adjustment (marker, charpos - to);
380 m->charpos = from;
381 m->bytepos = from_byte;
383 /* Here's the case where a before-insertion marker is immediately
384 before the deleted region. */
385 else if (charpos == from && m->insertion_type)
387 /* Undoing the change uses normal insertion, which will
388 incorrectly make MARKER move forward, so we arrange for it
389 to then move backward to the correct place at the beginning
390 of the deleted region. */
391 XSETMISC (marker, m);
392 record_marker_adjustment (marker, to - from);
398 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
399 to TO / TO_BYTE. We have to relocate the charpos of every marker
400 that points after the insertion (but not their bytepos).
402 When a marker points at the insertion point,
403 we advance it if either its insertion-type is t
404 or BEFORE_MARKERS is true. */
406 static void
407 adjust_markers_for_insert (from, from_byte, to, to_byte, before_markers)
408 register int from, from_byte, to, to_byte;
409 int before_markers;
411 struct Lisp_Marker *m;
412 int adjusted = 0;
413 int nchars = to - from;
414 int nbytes = to_byte - from_byte;
416 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
418 eassert (m->bytepos >= m->charpos
419 && m->bytepos - m->charpos <= Z_BYTE - Z);
421 if (m->bytepos == from_byte)
423 if (m->insertion_type || before_markers)
425 m->bytepos = to_byte;
426 m->charpos = to;
427 if (m->insertion_type)
428 adjusted = 1;
431 else if (m->bytepos > from_byte)
433 m->bytepos += nbytes;
434 m->charpos += nchars;
438 /* Adjusting only markers whose insertion-type is t may result in
439 - disordered start and end in overlays, and
440 - disordered overlays in the slot `overlays_before' of current_buffer. */
441 if (adjusted)
443 fix_start_end_in_overlays(from, to);
444 fix_overlays_before (current_buffer, from, to);
448 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
450 This is used only when the value of point changes due to an insert
451 or delete; it does not represent a conceptual change in point as a
452 marker. In particular, point is not crossing any interval
453 boundaries, so there's no need to use the usual SET_PT macro. In
454 fact it would be incorrect to do so, because either the old or the
455 new value of point is out of sync with the current set of
456 intervals. */
458 static void
459 adjust_point (nchars, nbytes)
460 int nchars, nbytes;
462 BUF_PT (current_buffer) += nchars;
463 BUF_PT_BYTE (current_buffer) += nbytes;
465 /* In a single-byte buffer, the two positions must be equal. */
466 eassert (PT_BYTE >= PT && PT_BYTE - PT <= ZV_BYTE - ZV);
469 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
470 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
471 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
472 an insertion. */
474 static void
475 adjust_markers_for_replace (from, from_byte, old_chars, old_bytes,
476 new_chars, new_bytes)
477 int from, from_byte, old_chars, old_bytes, new_chars, new_bytes;
479 register struct Lisp_Marker *m;
480 int prev_to_byte = from_byte + old_bytes;
481 int diff_chars = new_chars - old_chars;
482 int diff_bytes = new_bytes - old_bytes;
484 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
486 if (m->bytepos >= prev_to_byte)
488 m->charpos += diff_chars;
489 m->bytepos += diff_bytes;
491 else if (m->bytepos > from_byte)
493 m->charpos = from;
494 m->bytepos = from_byte;
498 CHECK_MARKERS ();
502 /* Make the gap NBYTES_ADDED bytes longer. */
504 void
505 make_gap_larger (nbytes_added)
506 int nbytes_added;
508 Lisp_Object tem;
509 int real_gap_loc;
510 int real_gap_loc_byte;
511 int old_gap_size;
513 /* If we have to get more space, get enough to last a while. */
514 nbytes_added += 2000;
516 /* Don't allow a buffer size that won't fit in an int
517 even if it will fit in a Lisp integer.
518 That won't work because so many places use `int'.
520 Make sure we don't introduce overflows in the calculation. */
522 if (Z_BYTE - BEG_BYTE + GAP_SIZE
523 >= (((EMACS_INT) 1 << (min (VALBITS, BITS_PER_INT) - 1)) - 1
524 - nbytes_added))
525 error ("Buffer exceeds maximum size");
527 enlarge_buffer_text (current_buffer, nbytes_added);
529 /* Prevent quitting in move_gap. */
530 tem = Vinhibit_quit;
531 Vinhibit_quit = Qt;
533 real_gap_loc = GPT;
534 real_gap_loc_byte = GPT_BYTE;
535 old_gap_size = GAP_SIZE;
537 /* Call the newly allocated space a gap at the end of the whole space. */
538 GPT = Z + GAP_SIZE;
539 GPT_BYTE = Z_BYTE + GAP_SIZE;
540 GAP_SIZE = nbytes_added;
542 /* Move the new gap down to be consecutive with the end of the old one.
543 This adjusts the markers properly too. */
544 gap_left (real_gap_loc + old_gap_size, real_gap_loc_byte + old_gap_size, 1);
546 /* Now combine the two into one large gap. */
547 GAP_SIZE += old_gap_size;
548 GPT = real_gap_loc;
549 GPT_BYTE = real_gap_loc_byte;
551 /* Put an anchor. */
552 *(Z_ADDR) = 0;
554 Vinhibit_quit = tem;
558 /* Make the gap NBYTES_REMOVED bytes shorter. */
560 void
561 make_gap_smaller (nbytes_removed)
562 int nbytes_removed;
564 Lisp_Object tem;
565 int real_gap_loc;
566 int real_gap_loc_byte;
567 int real_Z;
568 int real_Z_byte;
569 int real_beg_unchanged;
570 int new_gap_size;
572 /* Make sure the gap is at least 20 bytes. */
573 if (GAP_SIZE - nbytes_removed < 20)
574 nbytes_removed = GAP_SIZE - 20;
576 /* Prevent quitting in move_gap. */
577 tem = Vinhibit_quit;
578 Vinhibit_quit = Qt;
580 real_gap_loc = GPT;
581 real_gap_loc_byte = GPT_BYTE;
582 new_gap_size = GAP_SIZE - nbytes_removed;
583 real_Z = Z;
584 real_Z_byte = Z_BYTE;
585 real_beg_unchanged = BEG_UNCHANGED;
587 /* Pretend that the last unwanted part of the gap is the entire gap,
588 and that the first desired part of the gap is part of the buffer
589 text. */
590 bzero (GPT_ADDR, new_gap_size);
591 GPT += new_gap_size;
592 GPT_BYTE += new_gap_size;
593 Z += new_gap_size;
594 Z_BYTE += new_gap_size;
595 GAP_SIZE = nbytes_removed;
597 /* Move the unwanted pretend gap to the end of the buffer. This
598 adjusts the markers properly too. */
599 gap_right (Z, Z_BYTE);
601 enlarge_buffer_text (current_buffer, -nbytes_removed);
603 /* Now restore the desired gap. */
604 GAP_SIZE = new_gap_size;
605 GPT = real_gap_loc;
606 GPT_BYTE = real_gap_loc_byte;
607 Z = real_Z;
608 Z_BYTE = real_Z_byte;
609 BEG_UNCHANGED = real_beg_unchanged;
611 /* Put an anchor. */
612 *(Z_ADDR) = 0;
614 Vinhibit_quit = tem;
617 void
618 make_gap (nbytes_added)
619 int nbytes_added;
621 if (nbytes_added >= 0)
622 make_gap_larger (nbytes_added);
623 #if defined USE_MMAP_FOR_BUFFERS || defined REL_ALLOC || defined DOUG_LEA_MALLOC
624 else
625 make_gap_smaller (-nbytes_added);
626 #endif
629 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
630 FROM_MULTIBYTE says whether the incoming text is multibyte.
631 TO_MULTIBYTE says whether to store the text as multibyte.
632 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
634 Return the number of bytes stored at TO_ADDR. */
637 copy_text (from_addr, to_addr, nbytes,
638 from_multibyte, to_multibyte)
639 const unsigned char *from_addr;
640 unsigned char *to_addr;
641 int nbytes;
642 int from_multibyte, to_multibyte;
644 if (from_multibyte == to_multibyte)
646 bcopy (from_addr, to_addr, nbytes);
647 return nbytes;
649 else if (from_multibyte)
651 int nchars = 0;
652 int bytes_left = nbytes;
653 Lisp_Object tbl = Qnil;
655 /* We set the variable tbl to the reverse table of
656 Vnonascii_translation_table in advance. */
657 if (CHAR_TABLE_P (Vnonascii_translation_table))
659 tbl = Fchar_table_extra_slot (Vnonascii_translation_table,
660 make_number (0));
661 if (!CHAR_TABLE_P (tbl))
662 tbl = Qnil;
665 /* Convert multibyte to single byte. */
666 while (bytes_left > 0)
668 int thislen, c;
669 c = STRING_CHAR_AND_LENGTH (from_addr, bytes_left, thislen);
670 if (!SINGLE_BYTE_CHAR_P (c))
671 c = multibyte_char_to_unibyte (c, tbl);
672 *to_addr++ = c;
673 from_addr += thislen;
674 bytes_left -= thislen;
675 nchars++;
677 return nchars;
679 else
681 unsigned char *initial_to_addr = to_addr;
683 /* Convert single-byte to multibyte. */
684 while (nbytes > 0)
686 int c = *from_addr++;
688 if (c >= 0200)
690 c = unibyte_char_to_multibyte (c);
691 to_addr += CHAR_STRING (c, to_addr);
692 nbytes--;
694 else
695 /* Special case for speed. */
696 *to_addr++ = c, nbytes--;
698 return to_addr - initial_to_addr;
702 /* Return the number of bytes it would take
703 to convert some single-byte text to multibyte.
704 The single-byte text consists of NBYTES bytes at PTR. */
707 count_size_as_multibyte (ptr, nbytes)
708 const unsigned char *ptr;
709 int nbytes;
711 int i;
712 int outgoing_nbytes = 0;
714 for (i = 0; i < nbytes; i++)
716 unsigned int c = *ptr++;
718 if (c < 0200)
719 outgoing_nbytes++;
720 else
722 c = unibyte_char_to_multibyte (c);
723 outgoing_nbytes += CHAR_BYTES (c);
727 return outgoing_nbytes;
730 /* Insert a string of specified length before point.
731 This function judges multibyteness based on
732 enable_multibyte_characters in the current buffer;
733 it never converts between single-byte and multibyte.
735 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
736 prepare_to_modify_buffer could relocate the text. */
738 void
739 insert (string, nbytes)
740 register const unsigned char *string;
741 register int nbytes;
743 if (nbytes > 0)
745 int len = chars_in_text (string, nbytes), opoint;
746 insert_1_both (string, len, nbytes, 0, 1, 0);
747 opoint = PT - len;
748 signal_after_change (opoint, 0, len);
749 update_compositions (opoint, PT, CHECK_BORDER);
753 /* Likewise, but inherit text properties from neighboring characters. */
755 void
756 insert_and_inherit (string, nbytes)
757 register const unsigned char *string;
758 register int nbytes;
760 if (nbytes > 0)
762 int len = chars_in_text (string, nbytes), opoint;
763 insert_1_both (string, len, nbytes, 1, 1, 0);
764 opoint = PT - len;
765 signal_after_change (opoint, 0, len);
766 update_compositions (opoint, PT, CHECK_BORDER);
770 /* Insert the character C before point. Do not inherit text properties. */
772 void
773 insert_char (c)
774 int c;
776 unsigned char str[MAX_MULTIBYTE_LENGTH];
777 int len;
779 if (! NILP (current_buffer->enable_multibyte_characters))
780 len = CHAR_STRING (c, str);
781 else
783 len = 1;
784 str[0] = c;
787 insert (str, len);
790 /* Insert the null-terminated string S before point. */
792 void
793 insert_string (s)
794 const char *s;
796 insert (s, strlen (s));
799 /* Like `insert' except that all markers pointing at the place where
800 the insertion happens are adjusted to point after it.
801 Don't use this function to insert part of a Lisp string,
802 since gc could happen and relocate it. */
804 void
805 insert_before_markers (string, nbytes)
806 const unsigned char *string;
807 register int nbytes;
809 if (nbytes > 0)
811 int len = chars_in_text (string, nbytes), opoint;
812 insert_1_both (string, len, nbytes, 0, 1, 1);
813 opoint = PT - len;
814 signal_after_change (opoint, 0, len);
815 update_compositions (opoint, PT, CHECK_BORDER);
819 /* Likewise, but inherit text properties from neighboring characters. */
821 void
822 insert_before_markers_and_inherit (string, nbytes)
823 const unsigned char *string;
824 register int nbytes;
826 if (nbytes > 0)
828 int len = chars_in_text (string, nbytes), opoint;
829 insert_1_both (string, len, nbytes, 1, 1, 1);
830 opoint = PT - len;
831 signal_after_change (opoint, 0, len);
832 update_compositions (opoint, PT, CHECK_BORDER);
836 /* Subroutine used by the insert functions above. */
838 void
839 insert_1 (string, nbytes, inherit, prepare, before_markers)
840 register const unsigned char *string;
841 register int nbytes;
842 int inherit, prepare, before_markers;
844 insert_1_both (string, chars_in_text (string, nbytes), nbytes,
845 inherit, prepare, before_markers);
849 #ifdef BYTE_COMBINING_DEBUG
851 /* See if the bytes before POS/POS_BYTE combine with bytes
852 at the start of STRING to form a single character.
853 If so, return the number of bytes at the start of STRING
854 which combine in this way. Otherwise, return 0. */
857 count_combining_before (string, length, pos, pos_byte)
858 const unsigned char *string;
859 int length;
860 int pos, pos_byte;
862 int len, combining_bytes;
863 const unsigned char *p;
865 if (NILP (current_buffer->enable_multibyte_characters))
866 return 0;
868 /* At first, we can exclude the following cases:
869 (1) STRING[0] can't be a following byte of multibyte sequence.
870 (2) POS is the start of the current buffer.
871 (3) A character before POS is not a multibyte character. */
872 if (length == 0 || CHAR_HEAD_P (*string)) /* case (1) */
873 return 0;
874 if (pos_byte == BEG_BYTE) /* case (2) */
875 return 0;
876 len = 1;
877 p = BYTE_POS_ADDR (pos_byte - 1);
878 while (! CHAR_HEAD_P (*p)) p--, len++;
879 if (! BASE_LEADING_CODE_P (*p)) /* case (3) */
880 return 0;
882 combining_bytes = BYTES_BY_CHAR_HEAD (*p) - len;
883 if (combining_bytes <= 0)
884 /* The character preceding POS is, complete and no room for
885 combining bytes (combining_bytes == 0), or an independent 8-bit
886 character (combining_bytes < 0). */
887 return 0;
889 /* We have a combination situation. Count the bytes at STRING that
890 may combine. */
891 p = string + 1;
892 while (!CHAR_HEAD_P (*p) && p < string + length)
893 p++;
895 return (combining_bytes < p - string ? combining_bytes : p - string);
898 /* See if the bytes after POS/POS_BYTE combine with bytes
899 at the end of STRING to form a single character.
900 If so, return the number of bytes after POS/POS_BYTE
901 which combine in this way. Otherwise, return 0. */
904 count_combining_after (string, length, pos, pos_byte)
905 const unsigned char *string;
906 int length;
907 int pos, pos_byte;
909 int opos_byte = pos_byte;
910 int i;
911 int bytes;
912 unsigned char *bufp;
914 if (NILP (current_buffer->enable_multibyte_characters))
915 return 0;
917 /* At first, we can exclude the following cases:
918 (1) The last byte of STRING is an ASCII.
919 (2) POS is the last of the current buffer.
920 (3) A character at POS can't be a following byte of multibyte
921 character. */
922 if (length > 0 && ASCII_BYTE_P (string[length - 1])) /* case (1) */
923 return 0;
924 if (pos_byte == Z_BYTE) /* case (2) */
925 return 0;
926 bufp = BYTE_POS_ADDR (pos_byte);
927 if (CHAR_HEAD_P (*bufp)) /* case (3) */
928 return 0;
930 i = length - 1;
931 while (i >= 0 && ! CHAR_HEAD_P (string[i]))
933 i--;
935 if (i < 0)
937 /* All characters in STRING are not character head. We must
938 check also preceding bytes at POS. We are sure that the gap
939 is at POS. */
940 unsigned char *p = BEG_ADDR;
941 i = pos_byte - 2;
942 while (i >= 0 && ! CHAR_HEAD_P (p[i]))
943 i--;
944 if (i < 0 || !BASE_LEADING_CODE_P (p[i]))
945 return 0;
947 bytes = BYTES_BY_CHAR_HEAD (p[i]);
948 return (bytes <= pos_byte - 1 - i + length
950 : bytes - (pos_byte - 1 - i + length));
952 if (!BASE_LEADING_CODE_P (string[i]))
953 return 0;
955 bytes = BYTES_BY_CHAR_HEAD (string[i]) - (length - i);
956 bufp++, pos_byte++;
957 while (!CHAR_HEAD_P (*bufp)) bufp++, pos_byte++;
959 return (bytes <= pos_byte - opos_byte ? bytes : pos_byte - opos_byte);
962 #endif
965 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
966 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
967 are the same as in insert_1. */
969 void
970 insert_1_both (string, nchars, nbytes, inherit, prepare, before_markers)
971 register const unsigned char *string;
972 register int nchars, nbytes;
973 int inherit, prepare, before_markers;
975 if (nchars == 0)
976 return;
978 if (NILP (current_buffer->enable_multibyte_characters))
979 nchars = nbytes;
981 if (prepare)
982 /* Do this before moving and increasing the gap,
983 because the before-change hooks might move the gap
984 or make it smaller. */
985 prepare_to_modify_buffer (PT, PT, NULL);
987 if (PT != GPT)
988 move_gap_both (PT, PT_BYTE);
989 if (GAP_SIZE < nbytes)
990 make_gap (nbytes - GAP_SIZE);
992 #ifdef BYTE_COMBINING_DEBUG
993 if (count_combining_before (string, nbytes, PT, PT_BYTE)
994 || count_combining_after (string, nbytes, PT, PT_BYTE))
995 abort ();
996 #endif
998 /* Record deletion of the surrounding text that combines with
999 the insertion. This, together with recording the insertion,
1000 will add up to the right stuff in the undo list. */
1001 record_insert (PT, nchars);
1002 MODIFF++;
1003 CHARS_MODIFF = MODIFF;
1005 bcopy (string, GPT_ADDR, nbytes);
1007 GAP_SIZE -= nbytes;
1008 GPT += nchars;
1009 ZV += nchars;
1010 Z += nchars;
1011 GPT_BYTE += nbytes;
1012 ZV_BYTE += nbytes;
1013 Z_BYTE += nbytes;
1014 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1016 if (GPT_BYTE < GPT)
1017 abort ();
1019 /* The insert may have been in the unchanged region, so check again. */
1020 if (Z - GPT < END_UNCHANGED)
1021 END_UNCHANGED = Z - GPT;
1023 adjust_overlays_for_insert (PT, nchars);
1024 adjust_markers_for_insert (PT, PT_BYTE,
1025 PT + nchars, PT_BYTE + nbytes,
1026 before_markers);
1028 if (BUF_INTERVALS (current_buffer) != 0)
1029 offset_intervals (current_buffer, PT, nchars);
1031 if (!inherit && BUF_INTERVALS (current_buffer) != 0)
1032 set_text_properties (make_number (PT), make_number (PT + nchars),
1033 Qnil, Qnil, Qnil);
1035 adjust_point (nchars, nbytes);
1037 CHECK_MARKERS ();
1040 /* Insert the part of the text of STRING, a Lisp object assumed to be
1041 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1042 starting at position POS / POS_BYTE. If the text of STRING has properties,
1043 copy them into the buffer.
1045 It does not work to use `insert' for this, because a GC could happen
1046 before we bcopy the stuff into the buffer, and relocate the string
1047 without insert noticing. */
1049 void
1050 insert_from_string (string, pos, pos_byte, length, length_byte, inherit)
1051 Lisp_Object string;
1052 register int pos, pos_byte, length, length_byte;
1053 int inherit;
1055 int opoint = PT;
1057 if (SCHARS (string) == 0)
1058 return;
1060 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
1061 inherit, 0);
1062 signal_after_change (opoint, 0, PT - opoint);
1063 update_compositions (opoint, PT, CHECK_BORDER);
1066 /* Like `insert_from_string' except that all markers pointing
1067 at the place where the insertion happens are adjusted to point after it. */
1069 void
1070 insert_from_string_before_markers (string, pos, pos_byte,
1071 length, length_byte, inherit)
1072 Lisp_Object string;
1073 register int pos, pos_byte, length, length_byte;
1074 int inherit;
1076 int opoint = PT;
1078 if (SCHARS (string) == 0)
1079 return;
1081 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
1082 inherit, 1);
1083 signal_after_change (opoint, 0, PT - opoint);
1084 update_compositions (opoint, PT, CHECK_BORDER);
1087 /* Subroutine of the insertion functions above. */
1089 static void
1090 insert_from_string_1 (string, pos, pos_byte, nchars, nbytes,
1091 inherit, before_markers)
1092 Lisp_Object string;
1093 register int pos, pos_byte, nchars, nbytes;
1094 int inherit, before_markers;
1096 struct gcpro gcpro1;
1097 int outgoing_nbytes = nbytes;
1098 INTERVAL intervals;
1100 /* Make OUTGOING_NBYTES describe the text
1101 as it will be inserted in this buffer. */
1103 if (NILP (current_buffer->enable_multibyte_characters))
1104 outgoing_nbytes = nchars;
1105 else if (! STRING_MULTIBYTE (string))
1106 outgoing_nbytes
1107 = count_size_as_multibyte (SDATA (string) + pos_byte,
1108 nbytes);
1110 GCPRO1 (string);
1111 /* Do this before moving and increasing the gap,
1112 because the before-change hooks might move the gap
1113 or make it smaller. */
1114 prepare_to_modify_buffer (PT, PT, NULL);
1116 if (PT != GPT)
1117 move_gap_both (PT, PT_BYTE);
1118 if (GAP_SIZE < outgoing_nbytes)
1119 make_gap (outgoing_nbytes - GAP_SIZE);
1120 UNGCPRO;
1122 /* Copy the string text into the buffer, perhaps converting
1123 between single-byte and multibyte. */
1124 copy_text (SDATA (string) + pos_byte, GPT_ADDR, nbytes,
1125 STRING_MULTIBYTE (string),
1126 ! NILP (current_buffer->enable_multibyte_characters));
1128 #ifdef BYTE_COMBINING_DEBUG
1129 /* We have copied text into the gap, but we have not altered
1130 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1131 to these functions and get the same results as we would
1132 have got earlier on. Meanwhile, PT_ADDR does point to
1133 the text that has been stored by copy_text. */
1134 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
1135 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
1136 abort ();
1137 #endif
1139 record_insert (PT, nchars);
1140 MODIFF++;
1141 CHARS_MODIFF = MODIFF;
1143 GAP_SIZE -= outgoing_nbytes;
1144 GPT += nchars;
1145 ZV += nchars;
1146 Z += nchars;
1147 GPT_BYTE += outgoing_nbytes;
1148 ZV_BYTE += outgoing_nbytes;
1149 Z_BYTE += outgoing_nbytes;
1150 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1152 if (GPT_BYTE < GPT)
1153 abort ();
1155 /* The insert may have been in the unchanged region, so check again. */
1156 if (Z - GPT < END_UNCHANGED)
1157 END_UNCHANGED = Z - GPT;
1159 adjust_overlays_for_insert (PT, nchars);
1160 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
1161 PT_BYTE + outgoing_nbytes,
1162 before_markers);
1164 offset_intervals (current_buffer, PT, nchars);
1166 intervals = STRING_INTERVALS (string);
1167 /* Get the intervals for the part of the string we are inserting. */
1168 if (nbytes < SBYTES (string))
1169 intervals = copy_intervals (intervals, pos, nchars);
1171 /* Insert those intervals. */
1172 graft_intervals_into_buffer (intervals, PT, nchars,
1173 current_buffer, inherit);
1175 adjust_point (nchars, outgoing_nbytes);
1178 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1179 current buffer. If the text in BUF has properties, they are absorbed
1180 into the current buffer.
1182 It does not work to use `insert' for this, because a malloc could happen
1183 and relocate BUF's text before the bcopy happens. */
1185 void
1186 insert_from_buffer (buf, charpos, nchars, inherit)
1187 struct buffer *buf;
1188 int charpos, nchars;
1189 int inherit;
1191 int opoint = PT;
1193 insert_from_buffer_1 (buf, charpos, nchars, inherit);
1194 signal_after_change (opoint, 0, PT - opoint);
1195 update_compositions (opoint, PT, CHECK_BORDER);
1198 static void
1199 insert_from_buffer_1 (buf, from, nchars, inherit)
1200 struct buffer *buf;
1201 int from, nchars;
1202 int inherit;
1204 register Lisp_Object temp;
1205 int chunk, chunk_expanded;
1206 int from_byte = buf_charpos_to_bytepos (buf, from);
1207 int to_byte = buf_charpos_to_bytepos (buf, from + nchars);
1208 int incoming_nbytes = to_byte - from_byte;
1209 int outgoing_nbytes = incoming_nbytes;
1210 INTERVAL intervals;
1212 /* Make OUTGOING_NBYTES describe the text
1213 as it will be inserted in this buffer. */
1215 if (NILP (current_buffer->enable_multibyte_characters))
1216 outgoing_nbytes = nchars;
1217 else if (NILP (buf->enable_multibyte_characters))
1219 int outgoing_before_gap = 0;
1220 int outgoing_after_gap = 0;
1222 if (from < BUF_GPT (buf))
1224 chunk = BUF_GPT_BYTE (buf) - from_byte;
1225 if (chunk > incoming_nbytes)
1226 chunk = incoming_nbytes;
1227 outgoing_before_gap
1228 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf, from_byte),
1229 chunk);
1231 else
1232 chunk = 0;
1234 if (chunk < incoming_nbytes)
1235 outgoing_after_gap
1236 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf,
1237 from_byte + chunk),
1238 incoming_nbytes - chunk);
1240 outgoing_nbytes = outgoing_before_gap + outgoing_after_gap;
1243 /* Make sure point-max won't overflow after this insertion. */
1244 XSETINT (temp, outgoing_nbytes + Z);
1245 if (outgoing_nbytes + Z != XINT (temp))
1246 error ("Maximum buffer size exceeded");
1248 /* Do this before moving and increasing the gap,
1249 because the before-change hooks might move the gap
1250 or make it smaller. */
1251 prepare_to_modify_buffer (PT, PT, NULL);
1253 if (PT != GPT)
1254 move_gap_both (PT, PT_BYTE);
1255 if (GAP_SIZE < outgoing_nbytes)
1256 make_gap (outgoing_nbytes - GAP_SIZE);
1258 if (from < BUF_GPT (buf))
1260 chunk = BUF_GPT_BYTE (buf) - from_byte;
1261 if (chunk > incoming_nbytes)
1262 chunk = incoming_nbytes;
1263 /* Record number of output bytes, so we know where
1264 to put the output from the second copy_text. */
1265 chunk_expanded
1266 = copy_text (BUF_BYTE_ADDRESS (buf, from_byte),
1267 GPT_ADDR, chunk,
1268 ! NILP (buf->enable_multibyte_characters),
1269 ! NILP (current_buffer->enable_multibyte_characters));
1271 else
1272 chunk_expanded = chunk = 0;
1274 if (chunk < incoming_nbytes)
1275 copy_text (BUF_BYTE_ADDRESS (buf, from_byte + chunk),
1276 GPT_ADDR + chunk_expanded, incoming_nbytes - chunk,
1277 ! NILP (buf->enable_multibyte_characters),
1278 ! NILP (current_buffer->enable_multibyte_characters));
1280 #ifdef BYTE_COMBINING_DEBUG
1281 /* We have copied text into the gap, but we have not altered
1282 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1283 to these functions and get the same results as we would
1284 have got earlier on. Meanwhile, GPT_ADDR does point to
1285 the text that has been stored by copy_text. */
1286 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
1287 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
1288 abort ();
1289 #endif
1291 record_insert (PT, nchars);
1292 MODIFF++;
1293 CHARS_MODIFF = MODIFF;
1295 GAP_SIZE -= outgoing_nbytes;
1296 GPT += nchars;
1297 ZV += nchars;
1298 Z += nchars;
1299 GPT_BYTE += outgoing_nbytes;
1300 ZV_BYTE += outgoing_nbytes;
1301 Z_BYTE += outgoing_nbytes;
1302 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1304 if (GPT_BYTE < GPT)
1305 abort ();
1307 /* The insert may have been in the unchanged region, so check again. */
1308 if (Z - GPT < END_UNCHANGED)
1309 END_UNCHANGED = Z - GPT;
1311 adjust_overlays_for_insert (PT, nchars);
1312 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
1313 PT_BYTE + outgoing_nbytes,
1316 if (BUF_INTERVALS (current_buffer) != 0)
1317 offset_intervals (current_buffer, PT, nchars);
1319 /* Get the intervals for the part of the string we are inserting. */
1320 intervals = BUF_INTERVALS (buf);
1321 if (outgoing_nbytes < BUF_Z_BYTE (buf) - BUF_BEG_BYTE (buf))
1323 if (buf == current_buffer && PT <= from)
1324 from += nchars;
1325 intervals = copy_intervals (intervals, from, nchars);
1328 /* Insert those intervals. */
1329 graft_intervals_into_buffer (intervals, PT, nchars, current_buffer, inherit);
1331 adjust_point (nchars, outgoing_nbytes);
1334 /* Record undo information and adjust markers and position keepers for
1335 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1336 chars (LEN_BYTE bytes) which resides in the gap just after
1337 GPT_ADDR.
1339 PREV_TEXT nil means the new text was just inserted. */
1341 void
1342 adjust_after_replace (from, from_byte, prev_text, len, len_byte)
1343 int from, from_byte, len, len_byte;
1344 Lisp_Object prev_text;
1346 int nchars_del = 0, nbytes_del = 0;
1348 #ifdef BYTE_COMBINING_DEBUG
1349 if (count_combining_before (GPT_ADDR, len_byte, from, from_byte)
1350 || count_combining_after (GPT_ADDR, len_byte, from, from_byte))
1351 abort ();
1352 #endif
1354 if (STRINGP (prev_text))
1356 nchars_del = SCHARS (prev_text);
1357 nbytes_del = SBYTES (prev_text);
1360 /* Update various buffer positions for the new text. */
1361 GAP_SIZE -= len_byte;
1362 ZV += len; Z+= len;
1363 ZV_BYTE += len_byte; Z_BYTE += len_byte;
1364 GPT += len; GPT_BYTE += len_byte;
1365 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1367 if (nchars_del > 0)
1368 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1369 len, len_byte);
1370 else
1371 adjust_markers_for_insert (from, from_byte,
1372 from + len, from_byte + len_byte, 0);
1374 if (! EQ (current_buffer->undo_list, Qt))
1376 if (nchars_del > 0)
1377 record_delete (from, prev_text);
1378 record_insert (from, len);
1381 if (len > nchars_del)
1382 adjust_overlays_for_insert (from, len - nchars_del);
1383 else if (len < nchars_del)
1384 adjust_overlays_for_delete (from, nchars_del - len);
1385 if (BUF_INTERVALS (current_buffer) != 0)
1387 offset_intervals (current_buffer, from, len - nchars_del);
1390 if (from < PT)
1391 adjust_point (len - nchars_del, len_byte - nbytes_del);
1393 /* As byte combining will decrease Z, we must check this again. */
1394 if (Z - GPT < END_UNCHANGED)
1395 END_UNCHANGED = Z - GPT;
1397 CHECK_MARKERS ();
1399 if (len == 0)
1400 evaporate_overlays (from);
1401 MODIFF++;
1402 CHARS_MODIFF = MODIFF;
1405 /* Like adjust_after_replace, but doesn't require PREV_TEXT.
1406 This is for use when undo is not enabled in the current buffer. */
1408 void
1409 adjust_after_replace_noundo (from, from_byte, nchars_del, nbytes_del, len, len_byte)
1410 int from, from_byte, nchars_del, nbytes_del, len, len_byte;
1412 #ifdef BYTE_COMBINING_DEBUG
1413 if (count_combining_before (GPT_ADDR, len_byte, from, from_byte)
1414 || count_combining_after (GPT_ADDR, len_byte, from, from_byte))
1415 abort ();
1416 #endif
1418 /* Update various buffer positions for the new text. */
1419 GAP_SIZE -= len_byte;
1420 ZV += len; Z+= len;
1421 ZV_BYTE += len_byte; Z_BYTE += len_byte;
1422 GPT += len; GPT_BYTE += len_byte;
1423 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1425 if (nchars_del > 0)
1426 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1427 len, len_byte);
1428 else
1429 adjust_markers_for_insert (from, from_byte,
1430 from + len, from_byte + len_byte, 0);
1432 if (len > nchars_del)
1433 adjust_overlays_for_insert (from, len - nchars_del);
1434 else if (len < nchars_del)
1435 adjust_overlays_for_delete (from, nchars_del - len);
1436 if (BUF_INTERVALS (current_buffer) != 0)
1438 offset_intervals (current_buffer, from, len - nchars_del);
1441 if (from < PT)
1442 adjust_point (len - nchars_del, len_byte - nbytes_del);
1444 /* As byte combining will decrease Z, we must check this again. */
1445 if (Z - GPT < END_UNCHANGED)
1446 END_UNCHANGED = Z - GPT;
1448 CHECK_MARKERS ();
1450 if (len == 0)
1451 evaporate_overlays (from);
1452 MODIFF++;
1453 CHARS_MODIFF = MODIFF;
1456 /* Record undo information, adjust markers and position keepers for an
1457 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1458 text already exists in the current buffer but character length (TO
1459 - FROM) may be incorrect, the correct length is NEWLEN. */
1461 void
1462 adjust_after_insert (from, from_byte, to, to_byte, newlen)
1463 int from, from_byte, to, to_byte, newlen;
1465 int len = to - from, len_byte = to_byte - from_byte;
1467 if (GPT != to)
1468 move_gap_both (to, to_byte);
1469 GAP_SIZE += len_byte;
1470 GPT -= len; GPT_BYTE -= len_byte;
1471 ZV -= len; ZV_BYTE -= len_byte;
1472 Z -= len; Z_BYTE -= len_byte;
1473 adjust_after_replace (from, from_byte, Qnil, newlen, len_byte);
1476 /* Replace the text from character positions FROM to TO with NEW,
1477 If PREPARE is nonzero, call prepare_to_modify_buffer.
1478 If INHERIT, the newly inserted text should inherit text properties
1479 from the surrounding non-deleted text. */
1481 /* Note that this does not yet handle markers quite right.
1482 Also it needs to record a single undo-entry that does a replacement
1483 rather than a separate delete and insert.
1484 That way, undo will also handle markers properly.
1486 But if MARKERS is 0, don't relocate markers. */
1488 void
1489 replace_range (from, to, new, prepare, inherit, markers)
1490 Lisp_Object new;
1491 int from, to, prepare, inherit, markers;
1493 int inschars = SCHARS (new);
1494 int insbytes = SBYTES (new);
1495 int from_byte, to_byte;
1496 int nbytes_del, nchars_del;
1497 register Lisp_Object temp;
1498 struct gcpro gcpro1;
1499 INTERVAL intervals;
1500 int outgoing_insbytes = insbytes;
1501 Lisp_Object deletion;
1503 CHECK_MARKERS ();
1505 GCPRO1 (new);
1506 deletion = Qnil;
1508 if (prepare)
1510 int range_length = to - from;
1511 prepare_to_modify_buffer (from, to, &from);
1512 to = from + range_length;
1515 UNGCPRO;
1517 /* Make args be valid */
1518 if (from < BEGV)
1519 from = BEGV;
1520 if (to > ZV)
1521 to = ZV;
1523 from_byte = CHAR_TO_BYTE (from);
1524 to_byte = CHAR_TO_BYTE (to);
1526 nchars_del = to - from;
1527 nbytes_del = to_byte - from_byte;
1529 if (nbytes_del <= 0 && insbytes == 0)
1530 return;
1532 /* Make OUTGOING_INSBYTES describe the text
1533 as it will be inserted in this buffer. */
1535 if (NILP (current_buffer->enable_multibyte_characters))
1536 outgoing_insbytes = inschars;
1537 else if (! STRING_MULTIBYTE (new))
1538 outgoing_insbytes
1539 = count_size_as_multibyte (SDATA (new), insbytes);
1541 /* Make sure point-max won't overflow after this insertion. */
1542 XSETINT (temp, Z_BYTE - nbytes_del + insbytes);
1543 if (Z_BYTE - nbytes_del + insbytes != XINT (temp))
1544 error ("Maximum buffer size exceeded");
1546 GCPRO1 (new);
1548 /* Make sure the gap is somewhere in or next to what we are deleting. */
1549 if (from > GPT)
1550 gap_right (from, from_byte);
1551 if (to < GPT)
1552 gap_left (to, to_byte, 0);
1554 /* Even if we don't record for undo, we must keep the original text
1555 because we may have to recover it because of inappropriate byte
1556 combining. */
1557 if (! EQ (current_buffer->undo_list, Qt))
1558 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1560 GAP_SIZE += nbytes_del;
1561 ZV -= nchars_del;
1562 Z -= nchars_del;
1563 ZV_BYTE -= nbytes_del;
1564 Z_BYTE -= nbytes_del;
1565 GPT = from;
1566 GPT_BYTE = from_byte;
1567 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1569 if (GPT_BYTE < GPT)
1570 abort ();
1572 if (GPT - BEG < BEG_UNCHANGED)
1573 BEG_UNCHANGED = GPT - BEG;
1574 if (Z - GPT < END_UNCHANGED)
1575 END_UNCHANGED = Z - GPT;
1577 if (GAP_SIZE < insbytes)
1578 make_gap (insbytes - GAP_SIZE);
1580 /* Copy the string text into the buffer, perhaps converting
1581 between single-byte and multibyte. */
1582 copy_text (SDATA (new), GPT_ADDR, insbytes,
1583 STRING_MULTIBYTE (new),
1584 ! NILP (current_buffer->enable_multibyte_characters));
1586 #ifdef BYTE_COMBINING_DEBUG
1587 /* We have copied text into the gap, but we have not marked
1588 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1589 here, for both the previous text and the following text.
1590 Meanwhile, GPT_ADDR does point to
1591 the text that has been stored by copy_text. */
1592 if (count_combining_before (GPT_ADDR, outgoing_insbytes, from, from_byte)
1593 || count_combining_after (GPT_ADDR, outgoing_insbytes, from, from_byte))
1594 abort ();
1595 #endif
1597 if (! EQ (current_buffer->undo_list, Qt))
1599 /* Record the insertion first, so that when we undo,
1600 the deletion will be undone first. Thus, undo
1601 will insert before deleting, and thus will keep
1602 the markers before and after this text separate. */
1603 record_insert (from + SCHARS (deletion), inschars);
1604 record_delete (from, deletion);
1607 GAP_SIZE -= outgoing_insbytes;
1608 GPT += inschars;
1609 ZV += inschars;
1610 Z += inschars;
1611 GPT_BYTE += outgoing_insbytes;
1612 ZV_BYTE += outgoing_insbytes;
1613 Z_BYTE += outgoing_insbytes;
1614 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1616 if (GPT_BYTE < GPT)
1617 abort ();
1619 /* Adjust the overlay center as needed. This must be done after
1620 adjusting the markers that bound the overlays. */
1621 adjust_overlays_for_delete (from, nchars_del);
1622 adjust_overlays_for_insert (from, inschars);
1624 /* Adjust markers for the deletion and the insertion. */
1625 if (markers)
1626 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1627 inschars, outgoing_insbytes);
1629 offset_intervals (current_buffer, from, inschars - nchars_del);
1631 /* Get the intervals for the part of the string we are inserting--
1632 not including the combined-before bytes. */
1633 intervals = STRING_INTERVALS (new);
1634 /* Insert those intervals. */
1635 graft_intervals_into_buffer (intervals, from, inschars,
1636 current_buffer, inherit);
1638 /* Relocate point as if it were a marker. */
1639 if (from < PT)
1640 adjust_point ((from + inschars - (PT < to ? PT : to)),
1641 (from_byte + outgoing_insbytes
1642 - (PT_BYTE < to_byte ? PT_BYTE : to_byte)));
1644 if (outgoing_insbytes == 0)
1645 evaporate_overlays (from);
1647 CHECK_MARKERS ();
1649 MODIFF++;
1650 CHARS_MODIFF = MODIFF;
1651 UNGCPRO;
1653 signal_after_change (from, nchars_del, GPT - from);
1654 update_compositions (from, GPT, CHECK_BORDER);
1657 /* Replace the text from character positions FROM to TO with
1658 the text in INS of length INSCHARS.
1659 Keep the text properties that applied to the old characters
1660 (extending them to all the new chars if there are more new chars).
1662 Note that this does not yet handle markers quite right.
1664 If MARKERS is nonzero, relocate markers.
1666 Unlike most functions at this level, never call
1667 prepare_to_modify_buffer and never call signal_after_change. */
1669 void
1670 replace_range_2 (from, from_byte, to, to_byte, ins, inschars, insbytes, markers)
1671 int from, from_byte, to, to_byte;
1672 char *ins;
1673 int inschars, insbytes, markers;
1675 int nbytes_del, nchars_del;
1676 Lisp_Object temp;
1678 CHECK_MARKERS ();
1680 nchars_del = to - from;
1681 nbytes_del = to_byte - from_byte;
1683 if (nbytes_del <= 0 && insbytes == 0)
1684 return;
1686 /* Make sure point-max won't overflow after this insertion. */
1687 XSETINT (temp, Z_BYTE - nbytes_del + insbytes);
1688 if (Z_BYTE - nbytes_del + insbytes != XINT (temp))
1689 error ("Maximum buffer size exceeded");
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 GAP_SIZE += nbytes_del;
1698 ZV -= nchars_del;
1699 Z -= nchars_del;
1700 ZV_BYTE -= nbytes_del;
1701 Z_BYTE -= nbytes_del;
1702 GPT = from;
1703 GPT_BYTE = from_byte;
1704 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1706 if (GPT_BYTE < GPT)
1707 abort ();
1709 if (GPT - BEG < BEG_UNCHANGED)
1710 BEG_UNCHANGED = GPT - BEG;
1711 if (Z - GPT < END_UNCHANGED)
1712 END_UNCHANGED = Z - GPT;
1714 if (GAP_SIZE < insbytes)
1715 make_gap (insbytes - GAP_SIZE);
1717 /* Copy the replacement text into the buffer. */
1718 bcopy (ins, GPT_ADDR, insbytes);
1720 #ifdef BYTE_COMBINING_DEBUG
1721 /* We have copied text into the gap, but we have not marked
1722 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1723 here, for both the previous text and the following text.
1724 Meanwhile, GPT_ADDR does point to
1725 the text that has been stored by copy_text. */
1726 if (count_combining_before (GPT_ADDR, insbytes, from, from_byte)
1727 || count_combining_after (GPT_ADDR, insbytes, from, from_byte))
1728 abort ();
1729 #endif
1731 GAP_SIZE -= insbytes;
1732 GPT += inschars;
1733 ZV += inschars;
1734 Z += inschars;
1735 GPT_BYTE += insbytes;
1736 ZV_BYTE += insbytes;
1737 Z_BYTE += insbytes;
1738 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1740 if (GPT_BYTE < GPT)
1741 abort ();
1743 /* Adjust the overlay center as needed. This must be done after
1744 adjusting the markers that bound the overlays. */
1745 if (nchars_del != inschars)
1747 adjust_overlays_for_insert (from, inschars);
1748 adjust_overlays_for_delete (from + inschars, nchars_del);
1751 /* Adjust markers for the deletion and the insertion. */
1752 if (markers
1753 && ! (nchars_del == 1 && inschars == 1 && nbytes_del == insbytes))
1754 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1755 inschars, insbytes);
1757 offset_intervals (current_buffer, from, inschars - nchars_del);
1759 /* Relocate point as if it were a marker. */
1760 if (from < PT && (nchars_del != inschars || nbytes_del != insbytes))
1762 if (PT < to)
1763 /* PT was within the deleted text. Move it to FROM. */
1764 adjust_point (from - PT, from_byte - PT_BYTE);
1765 else
1766 adjust_point (inschars - nchars_del, insbytes - nbytes_del);
1769 if (insbytes == 0)
1770 evaporate_overlays (from);
1772 CHECK_MARKERS ();
1774 MODIFF++;
1775 CHARS_MODIFF = MODIFF;
1778 /* Delete characters in current buffer
1779 from FROM up to (but not including) TO.
1780 If TO comes before FROM, we delete nothing. */
1782 void
1783 del_range (from, to)
1784 register int from, to;
1786 del_range_1 (from, to, 1, 0);
1789 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1790 RET_STRING says to return the deleted text. */
1792 Lisp_Object
1793 del_range_1 (from, to, prepare, ret_string)
1794 int from, to, prepare, ret_string;
1796 int from_byte, to_byte;
1797 Lisp_Object deletion;
1798 struct gcpro gcpro1;
1800 /* Make args be valid */
1801 if (from < BEGV)
1802 from = BEGV;
1803 if (to > ZV)
1804 to = ZV;
1806 if (to <= from)
1807 return Qnil;
1809 if (prepare)
1811 int range_length = to - from;
1812 prepare_to_modify_buffer (from, to, &from);
1813 to = min (ZV, from + range_length);
1816 from_byte = CHAR_TO_BYTE (from);
1817 to_byte = CHAR_TO_BYTE (to);
1819 deletion = del_range_2 (from, from_byte, to, to_byte, ret_string);
1820 GCPRO1(deletion);
1821 signal_after_change (from, to - from, 0);
1822 update_compositions (from, from, CHECK_HEAD);
1823 UNGCPRO;
1824 return deletion;
1827 /* Like del_range_1 but args are byte positions, not char positions. */
1829 void
1830 del_range_byte (from_byte, to_byte, prepare)
1831 int from_byte, to_byte, prepare;
1833 int from, to;
1835 /* Make args be valid */
1836 if (from_byte < BEGV_BYTE)
1837 from_byte = BEGV_BYTE;
1838 if (to_byte > ZV_BYTE)
1839 to_byte = ZV_BYTE;
1841 if (to_byte <= from_byte)
1842 return;
1844 from = BYTE_TO_CHAR (from_byte);
1845 to = BYTE_TO_CHAR (to_byte);
1847 if (prepare)
1849 int old_from = from, old_to = Z - to;
1850 int range_length = to - from;
1851 prepare_to_modify_buffer (from, to, &from);
1852 to = from + range_length;
1854 if (old_from != from)
1855 from_byte = CHAR_TO_BYTE (from);
1856 if (to > ZV)
1858 to = ZV;
1859 to_byte = ZV_BYTE;
1861 else if (old_to == Z - to)
1862 to_byte = CHAR_TO_BYTE (to);
1865 del_range_2 (from, from_byte, to, to_byte, 0);
1866 signal_after_change (from, to - from, 0);
1867 update_compositions (from, from, CHECK_HEAD);
1870 /* Like del_range_1, but positions are specified both as charpos
1871 and bytepos. */
1873 void
1874 del_range_both (from, from_byte, to, to_byte, prepare)
1875 int from, from_byte, to, to_byte, prepare;
1877 /* Make args be valid */
1878 if (from_byte < BEGV_BYTE)
1879 from_byte = BEGV_BYTE;
1880 if (to_byte > ZV_BYTE)
1881 to_byte = ZV_BYTE;
1883 if (to_byte <= from_byte)
1884 return;
1886 if (from < BEGV)
1887 from = BEGV;
1888 if (to > ZV)
1889 to = ZV;
1891 if (prepare)
1893 int old_from = from, old_to = Z - to;
1894 int range_length = to - from;
1895 prepare_to_modify_buffer (from, to, &from);
1896 to = from + range_length;
1898 if (old_from != from)
1899 from_byte = CHAR_TO_BYTE (from);
1900 if (to > ZV)
1902 to = ZV;
1903 to_byte = ZV_BYTE;
1905 else if (old_to == Z - to)
1906 to_byte = CHAR_TO_BYTE (to);
1909 del_range_2 (from, from_byte, to, to_byte, 0);
1910 signal_after_change (from, to - from, 0);
1911 update_compositions (from, from, CHECK_HEAD);
1914 /* Delete a range of text, specified both as character positions
1915 and byte positions. FROM and TO are character positions,
1916 while FROM_BYTE and TO_BYTE are byte positions.
1917 If RET_STRING is true, the deleted area is returned as a string. */
1919 Lisp_Object
1920 del_range_2 (from, from_byte, to, to_byte, ret_string)
1921 int from, from_byte, to, to_byte, ret_string;
1923 register int nbytes_del, nchars_del;
1924 Lisp_Object deletion;
1926 CHECK_MARKERS ();
1928 nchars_del = to - from;
1929 nbytes_del = to_byte - from_byte;
1931 /* Make sure the gap is somewhere in or next to what we are deleting. */
1932 if (from > GPT)
1933 gap_right (from, from_byte);
1934 if (to < GPT)
1935 gap_left (to, to_byte, 0);
1937 #ifdef BYTE_COMBINING_DEBUG
1938 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer, to_byte),
1939 Z_BYTE - to_byte, from, from_byte))
1940 abort ();
1941 #endif
1943 if (ret_string || ! EQ (current_buffer->undo_list, Qt))
1944 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1945 else
1946 deletion = Qnil;
1948 /* Relocate all markers pointing into the new, larger gap
1949 to point at the end of the text before the gap.
1950 Do this before recording the deletion,
1951 so that undo handles this after reinserting the text. */
1952 adjust_markers_for_delete (from, from_byte, to, to_byte);
1954 if (! EQ (current_buffer->undo_list, Qt))
1955 record_delete (from, deletion);
1956 MODIFF++;
1957 CHARS_MODIFF = MODIFF;
1959 /* Relocate point as if it were a marker. */
1960 if (from < PT)
1961 adjust_point (from - (PT < to ? PT : to),
1962 from_byte - (PT_BYTE < to_byte ? PT_BYTE : to_byte));
1964 offset_intervals (current_buffer, from, - nchars_del);
1966 /* Adjust the overlay center as needed. This must be done after
1967 adjusting the markers that bound the overlays. */
1968 adjust_overlays_for_delete (from, nchars_del);
1970 GAP_SIZE += nbytes_del;
1971 ZV_BYTE -= nbytes_del;
1972 Z_BYTE -= nbytes_del;
1973 ZV -= nchars_del;
1974 Z -= nchars_del;
1975 GPT = from;
1976 GPT_BYTE = from_byte;
1977 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1979 if (GPT_BYTE < GPT)
1980 abort ();
1982 if (GPT - BEG < BEG_UNCHANGED)
1983 BEG_UNCHANGED = GPT - BEG;
1984 if (Z - GPT < END_UNCHANGED)
1985 END_UNCHANGED = Z - GPT;
1987 CHECK_MARKERS ();
1989 evaporate_overlays (from);
1991 return deletion;
1994 /* Call this if you're about to change the region of BUFFER from
1995 character positions START to END. This checks the read-only
1996 properties of the region, calls the necessary modification hooks,
1997 and warns the next redisplay that it should pay attention to that
1998 area.
2000 If PRESERVE_CHARS_MODIFF is non-zero, do not update CHARS_MODIFF.
2001 Otherwise set CHARS_MODIFF to the new value of MODIFF. */
2003 void
2004 modify_region (buffer, start, end, preserve_chars_modiff)
2005 struct buffer *buffer;
2006 int start, end, preserve_chars_modiff;
2008 struct buffer *old_buffer = current_buffer;
2010 if (buffer != old_buffer)
2011 set_buffer_internal (buffer);
2013 prepare_to_modify_buffer (start, end, NULL);
2015 BUF_COMPUTE_UNCHANGED (buffer, start - 1, end);
2017 if (MODIFF <= SAVE_MODIFF)
2018 record_first_change ();
2019 MODIFF++;
2020 if (! preserve_chars_modiff)
2021 CHARS_MODIFF = MODIFF;
2023 buffer->point_before_scroll = Qnil;
2025 if (buffer != old_buffer)
2026 set_buffer_internal (old_buffer);
2029 /* Check that it is okay to modify the buffer between START and END,
2030 which are char positions.
2032 Run the before-change-function, if any. If intervals are in use,
2033 verify that the text to be modified is not read-only, and call
2034 any modification properties the text may have.
2036 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2037 by holding its value temporarily in a marker. */
2039 void
2040 prepare_to_modify_buffer (start, end, preserve_ptr)
2041 int start, end;
2042 int *preserve_ptr;
2044 struct buffer *base_buffer;
2046 if (!NILP (current_buffer->read_only))
2047 Fbarf_if_buffer_read_only ();
2049 /* Let redisplay consider other windows than selected_window
2050 if modifying another buffer. */
2051 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
2052 ++windows_or_buffers_changed;
2054 if (BUF_INTERVALS (current_buffer) != 0)
2056 if (preserve_ptr)
2058 Lisp_Object preserve_marker;
2059 struct gcpro gcpro1;
2060 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil);
2061 GCPRO1 (preserve_marker);
2062 verify_interval_modification (current_buffer, start, end);
2063 *preserve_ptr = marker_position (preserve_marker);
2064 unchain_marker (XMARKER (preserve_marker));
2065 UNGCPRO;
2067 else
2068 verify_interval_modification (current_buffer, start, end);
2071 /* For indirect buffers, use the base buffer to check clashes. */
2072 if (current_buffer->base_buffer != 0)
2073 base_buffer = current_buffer->base_buffer;
2074 else
2075 base_buffer = current_buffer;
2077 #ifdef CLASH_DETECTION
2078 if (!NILP (base_buffer->file_truename)
2079 /* Make binding buffer-file-name to nil effective. */
2080 && !NILP (base_buffer->filename)
2081 && SAVE_MODIFF >= MODIFF)
2082 lock_file (base_buffer->file_truename);
2083 #else
2084 /* At least warn if this file has changed on disk since it was visited. */
2085 if (!NILP (base_buffer->filename)
2086 && SAVE_MODIFF >= MODIFF
2087 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2088 && !NILP (Ffile_exists_p (base_buffer->filename)))
2089 call1 (intern ("ask-user-about-supersession-threat"),
2090 base_buffer->filename);
2091 #endif /* not CLASH_DETECTION */
2093 signal_before_change (start, end, preserve_ptr);
2095 if (current_buffer->newline_cache)
2096 invalidate_region_cache (current_buffer,
2097 current_buffer->newline_cache,
2098 start - BEG, Z - end);
2099 if (current_buffer->width_run_cache)
2100 invalidate_region_cache (current_buffer,
2101 current_buffer->width_run_cache,
2102 start - BEG, Z - end);
2104 Vdeactivate_mark = Qt;
2107 /* These macros work with an argument named `preserve_ptr'
2108 and a local variable named `preserve_marker'. */
2110 #define PRESERVE_VALUE \
2111 if (preserve_ptr && NILP (preserve_marker)) \
2112 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2114 #define RESTORE_VALUE \
2115 if (! NILP (preserve_marker)) \
2117 *preserve_ptr = marker_position (preserve_marker); \
2118 unchain_marker (XMARKER (preserve_marker)); \
2121 #define PRESERVE_START_END \
2122 if (NILP (start_marker)) \
2123 start_marker = Fcopy_marker (start, Qnil); \
2124 if (NILP (end_marker)) \
2125 end_marker = Fcopy_marker (end, Qnil);
2127 #define FETCH_START \
2128 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2130 #define FETCH_END \
2131 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2133 /* Set a variable to nil if an error occurred.
2134 Don't change the variable if there was no error.
2135 VAL is a cons-cell (VARIABLE . NO-ERROR-FLAG).
2136 VARIABLE is the variable to maybe set to nil.
2137 NO-ERROR-FLAG is nil if there was an error,
2138 anything else meaning no error (so this function does nothing). */
2139 Lisp_Object
2140 reset_var_on_error (val)
2141 Lisp_Object val;
2143 if (NILP (XCDR (val)))
2144 Fset (XCAR (val), Qnil);
2145 return Qnil;
2148 /* Signal a change to the buffer immediately before it happens.
2149 START_INT and END_INT are the bounds of the text to be changed.
2151 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2152 by holding its value temporarily in a marker. */
2154 void
2155 signal_before_change (start_int, end_int, preserve_ptr)
2156 int start_int, end_int;
2157 int *preserve_ptr;
2159 Lisp_Object start, end;
2160 Lisp_Object start_marker, end_marker;
2161 Lisp_Object preserve_marker;
2162 struct gcpro gcpro1, gcpro2, gcpro3;
2163 int count = SPECPDL_INDEX ();
2165 if (inhibit_modification_hooks)
2166 return;
2168 start = make_number (start_int);
2169 end = make_number (end_int);
2170 preserve_marker = Qnil;
2171 start_marker = Qnil;
2172 end_marker = Qnil;
2173 GCPRO3 (preserve_marker, start_marker, end_marker);
2175 specbind (Qinhibit_modification_hooks, Qt);
2177 /* If buffer is unmodified, run a special hook for that case. */
2178 if (SAVE_MODIFF >= MODIFF
2179 && !NILP (Vfirst_change_hook)
2180 && !NILP (Vrun_hooks))
2182 PRESERVE_VALUE;
2183 PRESERVE_START_END;
2184 call1 (Vrun_hooks, Qfirst_change_hook);
2187 /* Now run the before-change-functions if any. */
2188 if (!NILP (Vbefore_change_functions))
2190 Lisp_Object args[3];
2191 Lisp_Object rvoe_arg = Fcons (Qbefore_change_functions, Qnil);
2193 PRESERVE_VALUE;
2194 PRESERVE_START_END;
2196 /* Mark before-change-functions to be reset to nil in case of error. */
2197 record_unwind_protect (reset_var_on_error, rvoe_arg);
2199 /* Actually run the hook functions. */
2200 args[0] = Qbefore_change_functions;
2201 args[1] = FETCH_START;
2202 args[2] = FETCH_END;
2203 Frun_hook_with_args (3, args);
2205 /* There was no error: unarm the reset_on_error. */
2206 XSETCDR (rvoe_arg, Qt);
2209 if (current_buffer->overlays_before || current_buffer->overlays_after)
2211 PRESERVE_VALUE;
2212 report_overlay_modification (FETCH_START, FETCH_END, 0,
2213 FETCH_START, FETCH_END, Qnil);
2216 if (! NILP (start_marker))
2217 free_marker (start_marker);
2218 if (! NILP (end_marker))
2219 free_marker (end_marker);
2220 RESTORE_VALUE;
2221 UNGCPRO;
2223 unbind_to (count, Qnil);
2226 /* Signal a change immediately after it happens.
2227 CHARPOS is the character position of the start of the changed text.
2228 LENDEL is the number of characters of the text before the change.
2229 (Not the whole buffer; just the part that was changed.)
2230 LENINS is the number of characters in that part of the text
2231 after the change. */
2233 void
2234 signal_after_change (charpos, lendel, lenins)
2235 int charpos, lendel, lenins;
2237 int count = SPECPDL_INDEX ();
2238 if (inhibit_modification_hooks)
2239 return;
2241 /* If we are deferring calls to the after-change functions
2242 and there are no before-change functions,
2243 just record the args that we were going to use. */
2244 if (! NILP (Vcombine_after_change_calls)
2245 && NILP (Vbefore_change_functions)
2246 && !current_buffer->overlays_before
2247 && !current_buffer->overlays_after)
2249 Lisp_Object elt;
2251 if (!NILP (combine_after_change_list)
2252 && current_buffer != XBUFFER (combine_after_change_buffer))
2253 Fcombine_after_change_execute ();
2255 elt = Fcons (make_number (charpos - BEG),
2256 Fcons (make_number (Z - (charpos - lendel + lenins)),
2257 Fcons (make_number (lenins - lendel), Qnil)));
2258 combine_after_change_list
2259 = Fcons (elt, combine_after_change_list);
2260 combine_after_change_buffer = Fcurrent_buffer ();
2262 return;
2265 if (!NILP (combine_after_change_list))
2266 Fcombine_after_change_execute ();
2268 specbind (Qinhibit_modification_hooks, Qt);
2270 if (!NILP (Vafter_change_functions))
2272 Lisp_Object args[4];
2273 Lisp_Object rvoe_arg = Fcons (Qafter_change_functions, Qnil);
2275 /* Mark after-change-functions to be reset to nil in case of error. */
2276 record_unwind_protect (reset_var_on_error, rvoe_arg);
2278 /* Actually run the hook functions. */
2279 args[0] = Qafter_change_functions;
2280 XSETFASTINT (args[1], charpos);
2281 XSETFASTINT (args[2], charpos + lenins);
2282 XSETFASTINT (args[3], lendel);
2283 Frun_hook_with_args (4, args);
2285 /* There was no error: unarm the reset_on_error. */
2286 XSETCDR (rvoe_arg, Qt);
2289 if (current_buffer->overlays_before || current_buffer->overlays_after)
2290 report_overlay_modification (make_number (charpos),
2291 make_number (charpos + lenins),
2293 make_number (charpos),
2294 make_number (charpos + lenins),
2295 make_number (lendel));
2297 /* After an insertion, call the text properties
2298 insert-behind-hooks or insert-in-front-hooks. */
2299 if (lendel == 0)
2300 report_interval_modification (make_number (charpos),
2301 make_number (charpos + lenins));
2303 unbind_to (count, Qnil);
2306 Lisp_Object
2307 Fcombine_after_change_execute_1 (val)
2308 Lisp_Object val;
2310 Vcombine_after_change_calls = val;
2311 return val;
2314 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
2315 Scombine_after_change_execute, 0, 0, 0,
2316 doc: /* This function is for use internally in `combine-after-change-calls'. */)
2319 int count = SPECPDL_INDEX ();
2320 int beg, end, change;
2321 int begpos, endpos;
2322 Lisp_Object tail;
2324 if (NILP (combine_after_change_list))
2325 return Qnil;
2327 /* It is rare for combine_after_change_buffer to be invalid, but
2328 possible. It can happen when combine-after-change-calls is
2329 non-nil, and insertion calls a file handler (e.g. through
2330 lock_file) which scribbles into a temp file -- cyd */
2331 if (!BUFFERP (combine_after_change_buffer)
2332 || NILP (XBUFFER (combine_after_change_buffer)->name))
2334 combine_after_change_list = Qnil;
2335 return Qnil;
2338 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
2340 Fset_buffer (combine_after_change_buffer);
2342 /* # chars unchanged at beginning of buffer. */
2343 beg = Z - BEG;
2344 /* # chars unchanged at end of buffer. */
2345 end = beg;
2346 /* Total amount of insertion (negative for deletion). */
2347 change = 0;
2349 /* Scan the various individual changes,
2350 accumulating the range info in BEG, END and CHANGE. */
2351 for (tail = combine_after_change_list; CONSP (tail);
2352 tail = XCDR (tail))
2354 Lisp_Object elt;
2355 int thisbeg, thisend, thischange;
2357 /* Extract the info from the next element. */
2358 elt = XCAR (tail);
2359 if (! CONSP (elt))
2360 continue;
2361 thisbeg = XINT (XCAR (elt));
2363 elt = XCDR (elt);
2364 if (! CONSP (elt))
2365 continue;
2366 thisend = XINT (XCAR (elt));
2368 elt = XCDR (elt);
2369 if (! CONSP (elt))
2370 continue;
2371 thischange = XINT (XCAR (elt));
2373 /* Merge this range into the accumulated range. */
2374 change += thischange;
2375 if (thisbeg < beg)
2376 beg = thisbeg;
2377 if (thisend < end)
2378 end = thisend;
2381 /* Get the current start and end positions of the range
2382 that was changed. */
2383 begpos = BEG + beg;
2384 endpos = Z - end;
2386 /* We are about to handle these, so discard them. */
2387 combine_after_change_list = Qnil;
2389 /* Now run the after-change functions for real.
2390 Turn off the flag that defers them. */
2391 record_unwind_protect (Fcombine_after_change_execute_1,
2392 Vcombine_after_change_calls);
2393 signal_after_change (begpos, endpos - begpos - change, endpos - begpos);
2394 update_compositions (begpos, endpos, CHECK_ALL);
2396 return unbind_to (count, Qnil);
2399 void
2400 syms_of_insdel ()
2402 staticpro (&combine_after_change_list);
2403 staticpro (&combine_after_change_buffer);
2404 combine_after_change_list = Qnil;
2405 combine_after_change_buffer = Qnil;
2407 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag,
2408 doc: /* Non-nil means enable debugging checks for invalid marker positions. */);
2409 check_markers_debug_flag = 0;
2410 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls,
2411 doc: /* Used internally by the `combine-after-change-calls' macro. */);
2412 Vcombine_after_change_calls = Qnil;
2414 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks,
2415 doc: /* Non-nil means don't run any of the hooks that respond to buffer changes.
2416 This affects `before-change-functions' and `after-change-functions',
2417 as well as hooks attached to text properties and overlays. */);
2418 inhibit_modification_hooks = 0;
2419 Qinhibit_modification_hooks = intern ("inhibit-modification-hooks");
2420 staticpro (&Qinhibit_modification_hooks);
2422 defsubr (&Scombine_after_change_execute);
2425 /* arch-tag: 9b34b886-47d7-465e-a234-299af411b23d
2426 (do not change this comment) */