*** empty log message ***
[emacs.git] / src / insdel.c
blobe89ad9292bf2e4341f24239a196a509a6619f5b3
1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999, 2000 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 #include <config.h>
23 #include "lisp.h"
24 #include "intervals.h"
25 #include "buffer.h"
26 #include "charset.h"
27 #include "window.h"
28 #include "blockinput.h"
29 #include "region-cache.h"
31 #ifndef NULL
32 #define NULL 0
33 #endif
35 #define min(x, y) ((x) < (y) ? (x) : (y))
36 #define max(x, y) ((x) > (y) ? (x) : (y))
38 static void insert_from_string_1 P_ ((Lisp_Object, int, int, int, int, int, int));
39 static void insert_from_buffer_1 ();
40 static void gap_left P_ ((int, int, int));
41 static void gap_right P_ ((int, int));
42 static void adjust_markers_gap_motion P_ ((int, int, int));
43 static void adjust_markers_for_insert P_ ((int, int, int, int, int));
44 void adjust_markers_for_delete P_ ((int, int, int, int));
45 static void adjust_markers_for_replace P_ ((int, int, int, int, int, int));
46 static void adjust_point P_ ((int, int));
48 Lisp_Object Fcombine_after_change_execute ();
50 /* Non-nil means don't call the after-change-functions right away,
51 just record an element in Vcombine_after_change_calls_list. */
52 Lisp_Object Vcombine_after_change_calls;
54 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
55 describing changes which happened while combine_after_change_calls
56 was nonzero. We use this to decide how to call them
57 once the deferral ends.
59 In each element.
60 BEG-UNCHANGED is the number of chars before the changed range.
61 END-UNCHANGED is the number of chars after the changed range,
62 and CHANGE-AMOUNT is the number of characters inserted by the change
63 (negative for a deletion). */
64 Lisp_Object combine_after_change_list;
66 /* Buffer which combine_after_change_list is about. */
67 Lisp_Object combine_after_change_buffer;
69 /* Check all markers in the current buffer, looking for something invalid. */
71 static int check_markers_debug_flag;
73 #define CHECK_MARKERS() \
74 if (check_markers_debug_flag) \
75 check_markers (); \
76 else
78 void
79 check_markers ()
81 register Lisp_Object tail;
82 int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
84 tail = BUF_MARKERS (current_buffer);
86 while (! NILP (tail))
88 if (XMARKER (tail)->buffer->text != current_buffer->text)
89 abort ();
90 if (XMARKER (tail)->charpos > Z)
91 abort ();
92 if (XMARKER (tail)->bytepos > Z_BYTE)
93 abort ();
94 if (multibyte && ! CHAR_HEAD_P (FETCH_BYTE (XMARKER (tail)->bytepos)))
95 abort ();
97 tail = XMARKER (tail)->chain;
101 /* Move gap to position CHARPOS.
102 Note that this can quit! */
104 void
105 move_gap (charpos)
106 int charpos;
108 move_gap_both (charpos, charpos_to_bytepos (charpos));
111 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
112 Note that this can quit! */
114 void
115 move_gap_both (charpos, bytepos)
116 int charpos, bytepos;
118 if (bytepos < GPT_BYTE)
119 gap_left (charpos, bytepos, 0);
120 else if (bytepos > GPT_BYTE)
121 gap_right (charpos, bytepos);
124 /* Move the gap to a position less than the current GPT.
125 BYTEPOS describes the new position as a byte position,
126 and CHARPOS is the corresponding char position.
127 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
129 static void
130 gap_left (charpos, bytepos, newgap)
131 register int charpos, bytepos;
132 int newgap;
134 register unsigned char *to, *from;
135 register int i;
136 int new_s1;
138 if (!newgap)
139 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
141 i = GPT_BYTE;
142 to = GAP_END_ADDR;
143 from = GPT_ADDR;
144 new_s1 = GPT_BYTE;
146 /* Now copy the characters. To move the gap down,
147 copy characters up. */
149 while (1)
151 /* I gets number of characters left to copy. */
152 i = new_s1 - bytepos;
153 if (i == 0)
154 break;
155 /* If a quit is requested, stop copying now.
156 Change BYTEPOS to be where we have actually moved the gap to. */
157 if (QUITP)
159 bytepos = new_s1;
160 charpos = BYTE_TO_CHAR (bytepos);
161 break;
163 /* Move at most 32000 chars before checking again for a quit. */
164 if (i > 32000)
165 i = 32000;
166 #ifdef GAP_USE_BCOPY
167 if (i >= 128
168 /* bcopy is safe if the two areas of memory do not overlap
169 or on systems where bcopy is always safe for moving upward. */
170 && (BCOPY_UPWARD_SAFE
171 || to - from >= 128))
173 /* If overlap is not safe, avoid it by not moving too many
174 characters at once. */
175 if (!BCOPY_UPWARD_SAFE && i > to - from)
176 i = to - from;
177 new_s1 -= i;
178 from -= i, to -= i;
179 bcopy (from, to, i);
181 else
182 #endif
184 new_s1 -= i;
185 while (--i >= 0)
186 *--to = *--from;
190 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
191 BYTEPOS is where the loop above stopped, which may be what was specified
192 or may be where a quit was detected. */
193 adjust_markers_gap_motion (bytepos, GPT_BYTE, GAP_SIZE);
194 GPT_BYTE = bytepos;
195 GPT = charpos;
196 if (bytepos < charpos)
197 abort ();
198 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
199 QUIT;
202 /* Move the gap to a position greater than than the current GPT.
203 BYTEPOS describes the new position as a byte position,
204 and CHARPOS is the corresponding char position. */
206 static void
207 gap_right (charpos, bytepos)
208 register int charpos, bytepos;
210 register unsigned char *to, *from;
211 register int i;
212 int new_s1;
214 BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
216 i = GPT_BYTE;
217 from = GAP_END_ADDR;
218 to = GPT_ADDR;
219 new_s1 = GPT_BYTE;
221 /* Now copy the characters. To move the gap up,
222 copy characters down. */
224 while (1)
226 /* I gets number of characters left to copy. */
227 i = bytepos - new_s1;
228 if (i == 0)
229 break;
230 /* If a quit is requested, stop copying now.
231 Change BYTEPOS to be where we have actually moved the gap to. */
232 if (QUITP)
234 bytepos = new_s1;
235 charpos = BYTE_TO_CHAR (bytepos);
236 break;
238 /* Move at most 32000 chars before checking again for a quit. */
239 if (i > 32000)
240 i = 32000;
241 #ifdef GAP_USE_BCOPY
242 if (i >= 128
243 /* bcopy is safe if the two areas of memory do not overlap
244 or on systems where bcopy is always safe for moving downward. */
245 && (BCOPY_DOWNWARD_SAFE
246 || from - to >= 128))
248 /* If overlap is not safe, avoid it by not moving too many
249 characters at once. */
250 if (!BCOPY_DOWNWARD_SAFE && i > from - to)
251 i = from - to;
252 new_s1 += i;
253 bcopy (from, to, i);
254 from += i, to += i;
256 else
257 #endif
259 new_s1 += i;
260 while (--i >= 0)
261 *to++ = *from++;
265 adjust_markers_gap_motion (GPT_BYTE + GAP_SIZE, bytepos + GAP_SIZE,
266 - GAP_SIZE);
267 GPT = charpos;
268 GPT_BYTE = bytepos;
269 if (bytepos < charpos)
270 abort ();
271 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
272 QUIT;
275 /* Add AMOUNT to the byte position of every marker in the current buffer
276 whose current byte position is between FROM (exclusive) and TO (inclusive).
278 Also, any markers past the outside of that interval, in the direction
279 of adjustment, are first moved back to the near end of the interval
280 and then adjusted by AMOUNT.
282 When the latter adjustment is done, if AMOUNT is negative,
283 we record the adjustment for undo. (This case happens only for
284 deletion.)
286 The markers' character positions are not altered,
287 because gap motion does not affect character positions. */
289 int adjust_markers_test;
291 static void
292 adjust_markers_gap_motion (from, to, amount)
293 register int from, to, amount;
295 /* Now that a marker has a bytepos, not counting the gap,
296 nothing needs to be done here. */
297 #if 0
298 Lisp_Object marker;
299 register struct Lisp_Marker *m;
300 register int mpos;
302 marker = BUF_MARKERS (current_buffer);
304 while (!NILP (marker))
306 m = XMARKER (marker);
307 mpos = m->bytepos;
308 if (amount > 0)
310 if (mpos > to && mpos < to + amount)
312 if (adjust_markers_test)
313 abort ();
314 mpos = to + amount;
317 else
319 /* Here's the case where a marker is inside text being deleted.
320 AMOUNT can be negative for gap motion, too,
321 but then this range contains no markers. */
322 if (mpos > from + amount && mpos <= from)
324 if (adjust_markers_test)
325 abort ();
326 mpos = from + amount;
329 if (mpos > from && mpos <= to)
330 mpos += amount;
331 m->bufpos = mpos;
332 marker = m->chain;
334 #endif
337 /* Adjust all markers for a deletion
338 whose range in bytes is FROM_BYTE to TO_BYTE.
339 The range in charpos is FROM to TO.
341 This function assumes that the gap is adjacent to
342 or inside of the range being deleted. */
344 void
345 adjust_markers_for_delete (from, from_byte, to, to_byte)
346 register int from, from_byte, to, to_byte;
348 Lisp_Object marker;
349 register struct Lisp_Marker *m;
350 register int charpos;
352 marker = BUF_MARKERS (current_buffer);
354 while (!NILP (marker))
356 m = XMARKER (marker);
357 charpos = m->charpos;
359 if (charpos > Z)
360 abort ();
362 /* If the marker is after the deletion,
363 relocate by number of chars / bytes deleted. */
364 if (charpos > to)
366 m->charpos -= to - from;
367 m->bytepos -= to_byte - from_byte;
369 /* Here's the case where a marker is inside text being deleted. */
370 else if (charpos > from)
372 if (! m->insertion_type)
373 /* Normal markers will end up at the beginning of the
374 re-inserted text after undoing a deletion, and must be
375 adjusted to move them to the correct place. */
376 record_marker_adjustment (marker, from - charpos);
377 else if (charpos < to)
378 /* Before-insertion markers will automatically move forward
379 upon re-inserting the deleted text, so we have to arrange
380 for them to move backward to the correct position. */
381 record_marker_adjustment (marker, charpos - to);
383 m->charpos = from;
384 m->bytepos = from_byte;
386 /* Here's the case where a before-insertion marker is immediately
387 before the deleted region. */
388 else if (charpos == from && m->insertion_type)
390 /* Undoing the change uses normal insertion, which will
391 incorrectly make MARKER move forward, so we arrange for it
392 to then move backward to the correct place at the beginning
393 of the deleted region. */
394 record_marker_adjustment (marker, to - from);
397 marker = m->chain;
402 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
403 to TO / TO_BYTE. We have to relocate the charpos of every marker
404 that points after the insertion (but not their bytepos).
406 When a marker points at the insertion point,
407 we advance it if either its insertion-type is t
408 or BEFORE_MARKERS is true. */
410 static void
411 adjust_markers_for_insert (from, from_byte, to, to_byte, before_markers)
412 register int from, from_byte, to, to_byte;
413 int before_markers;
415 Lisp_Object marker;
416 int adjusted = 0;
417 int nchars = to - from;
418 int nbytes = to_byte - from_byte;
420 marker = BUF_MARKERS (current_buffer);
422 while (!NILP (marker))
424 register struct Lisp_Marker *m = XMARKER (marker);
426 /* In a single-byte buffer, a marker's two positions must be
427 equal. */
428 if (Z == Z_BYTE)
430 if (m->charpos != m->bytepos)
431 abort ();
434 if (m->bytepos == from_byte)
436 if (m->insertion_type || before_markers)
438 m->bytepos = to_byte;
439 m->charpos = to;
440 if (m->insertion_type)
441 adjusted = 1;
444 else if (m->bytepos > from_byte)
446 m->bytepos += nbytes;
447 m->charpos += nchars;
450 marker = m->chain;
453 /* Adjusting only markers whose insertion-type is t may result in
454 disordered overlays in the slot `overlays_before'. */
455 if (adjusted)
456 fix_overlays_before (current_buffer, from, to);
459 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
461 This is used only when the value of point changes due to an insert
462 or delete; it does not represent a conceptual change in point as a
463 marker. In particular, point is not crossing any interval
464 boundaries, so there's no need to use the usual SET_PT macro. In
465 fact it would be incorrect to do so, because either the old or the
466 new value of point is out of sync with the current set of
467 intervals. */
469 static void
470 adjust_point (nchars, nbytes)
471 int nchars, nbytes;
473 BUF_PT (current_buffer) += nchars;
474 BUF_PT_BYTE (current_buffer) += nbytes;
476 /* In a single-byte buffer, the two positions must be equal. */
477 if (ZV == ZV_BYTE
478 && PT != PT_BYTE)
479 abort ();
482 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
483 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
484 (NEW_BYTES). It is assumed that OLD_CHARS > 0, i.e., this is not
485 an insertion. */
487 static void
488 adjust_markers_for_replace (from, from_byte, old_chars, old_bytes,
489 new_chars, new_bytes)
490 int from, from_byte, old_chars, old_bytes, new_chars, new_bytes;
492 Lisp_Object marker = BUF_MARKERS (current_buffer);
493 int prev_to_byte = from_byte + old_bytes;
494 int diff_chars = new_chars - old_chars;
495 int diff_bytes = new_bytes - old_bytes;
497 while (!NILP (marker))
499 register struct Lisp_Marker *m = XMARKER (marker);
501 if (m->bytepos >= prev_to_byte)
503 m->charpos += diff_chars;
504 m->bytepos += diff_bytes;
506 else if (m->bytepos > from_byte)
508 m->charpos = from;
509 m->bytepos = from_byte;
512 marker = m->chain;
515 CHECK_MARKERS ();
519 /* Make the gap NBYTES_ADDED bytes longer. */
521 void
522 make_gap (nbytes_added)
523 int nbytes_added;
525 unsigned char *result;
526 Lisp_Object tem;
527 int real_gap_loc;
528 int real_gap_loc_byte;
529 int old_gap_size;
531 /* If we have to get more space, get enough to last a while. */
532 nbytes_added += 2000;
534 /* Don't allow a buffer size that won't fit in an int
535 even if it will fit in a Lisp integer.
536 That won't work because so many places use `int'. */
538 if (Z_BYTE - BEG_BYTE + GAP_SIZE + nbytes_added
539 >= ((unsigned) 1 << (min (BITS_PER_INT, VALBITS) - 1)))
540 error ("Buffer exceeds maximum size");
542 enlarge_buffer_text (current_buffer, nbytes_added);
544 /* Prevent quitting in move_gap. */
545 tem = Vinhibit_quit;
546 Vinhibit_quit = Qt;
548 real_gap_loc = GPT;
549 real_gap_loc_byte = GPT_BYTE;
550 old_gap_size = GAP_SIZE;
552 /* Call the newly allocated space a gap at the end of the whole space. */
553 GPT = Z + GAP_SIZE;
554 GPT_BYTE = Z_BYTE + GAP_SIZE;
555 GAP_SIZE = nbytes_added;
557 /* Move the new gap down to be consecutive with the end of the old one.
558 This adjusts the markers properly too. */
559 gap_left (real_gap_loc + old_gap_size, real_gap_loc_byte + old_gap_size, 1);
561 /* Now combine the two into one large gap. */
562 GAP_SIZE += old_gap_size;
563 GPT = real_gap_loc;
564 GPT_BYTE = real_gap_loc_byte;
566 /* Put an anchor. */
567 *(Z_ADDR) = 0;
569 Vinhibit_quit = tem;
572 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
573 FROM_MULTIBYTE says whether the incoming text is multibyte.
574 TO_MULTIBYTE says whether to store the text as multibyte.
575 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
577 Return the number of bytes stored at TO_ADDR. */
580 copy_text (from_addr, to_addr, nbytes,
581 from_multibyte, to_multibyte)
582 unsigned char *from_addr;
583 unsigned char *to_addr;
584 int nbytes;
585 int from_multibyte, to_multibyte;
587 if (from_multibyte == to_multibyte)
589 bcopy (from_addr, to_addr, nbytes);
590 return nbytes;
592 else if (from_multibyte)
594 int nchars = 0;
595 int bytes_left = nbytes;
596 Lisp_Object tbl = Qnil;
598 /* We set the variable tbl to the reverse table of
599 Vnonascii_translation_table in advance. */
600 if (CHAR_TABLE_P (Vnonascii_translation_table))
602 tbl = Fchar_table_extra_slot (Vnonascii_translation_table,
603 make_number (0));
604 if (!CHAR_TABLE_P (tbl))
605 tbl = Qnil;
608 /* Convert multibyte to single byte. */
609 while (bytes_left > 0)
611 int thislen, c;
612 c = STRING_CHAR_AND_LENGTH (from_addr, bytes_left, thislen);
613 if (!SINGLE_BYTE_CHAR_P (c))
614 c = multibyte_char_to_unibyte (c, tbl);
615 *to_addr++ = c;
616 from_addr += thislen;
617 bytes_left -= thislen;
618 nchars++;
620 return nchars;
622 else
624 unsigned char *initial_to_addr = to_addr;
626 /* Convert single-byte to multibyte. */
627 while (nbytes > 0)
629 int c = *from_addr++;
631 if (c >= 0200)
633 c = unibyte_char_to_multibyte (c);
634 to_addr += CHAR_STRING (c, to_addr);
635 nbytes--;
637 else
638 /* Special case for speed. */
639 *to_addr++ = c, nbytes--;
641 return to_addr - initial_to_addr;
645 /* Return the number of bytes it would take
646 to convert some single-byte text to multibyte.
647 The single-byte text consists of NBYTES bytes at PTR. */
650 count_size_as_multibyte (ptr, nbytes)
651 unsigned char *ptr;
652 int nbytes;
654 int i;
655 int outgoing_nbytes = 0;
657 for (i = 0; i < nbytes; i++)
659 unsigned int c = *ptr++;
661 if (c < 0200)
662 outgoing_nbytes++;
663 else
665 c = unibyte_char_to_multibyte (c);
666 outgoing_nbytes += CHAR_BYTES (c);
670 return outgoing_nbytes;
673 /* Insert a string of specified length before point.
674 This function judges multibyteness based on
675 enable_multibyte_characters in the current buffer;
676 it never converts between single-byte and multibyte.
678 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
679 prepare_to_modify_buffer could relocate the text. */
681 void
682 insert (string, nbytes)
683 register unsigned char *string;
684 register int nbytes;
686 if (nbytes > 0)
688 int opoint = PT;
689 insert_1 (string, nbytes, 0, 1, 0);
690 signal_after_change (opoint, 0, PT - opoint);
691 update_compositions (opoint, PT, CHECK_BORDER);
695 /* Likewise, but inherit text properties from neighboring characters. */
697 void
698 insert_and_inherit (string, nbytes)
699 register unsigned char *string;
700 register int nbytes;
702 if (nbytes > 0)
704 int opoint = PT;
705 insert_1 (string, nbytes, 1, 1, 0);
706 signal_after_change (opoint, 0, PT - opoint);
707 update_compositions (opoint, PT, CHECK_BORDER);
711 /* Insert the character C before point. Do not inherit text properties. */
713 void
714 insert_char (c)
715 int c;
717 unsigned char str[MAX_MULTIBYTE_LENGTH];
718 int len;
720 if (! NILP (current_buffer->enable_multibyte_characters))
721 len = CHAR_STRING (c, str);
722 else
724 len = 1;
725 str[0] = c;
728 insert (str, len);
731 /* Insert the null-terminated string S before point. */
733 void
734 insert_string (s)
735 char *s;
737 insert (s, strlen (s));
740 /* Like `insert' except that all markers pointing at the place where
741 the insertion happens are adjusted to point after it.
742 Don't use this function to insert part of a Lisp string,
743 since gc could happen and relocate it. */
745 void
746 insert_before_markers (string, nbytes)
747 unsigned char *string;
748 register int nbytes;
750 if (nbytes > 0)
752 int opoint = PT;
754 insert_1 (string, nbytes, 0, 1, 1);
755 signal_after_change (opoint, 0, PT - opoint);
756 update_compositions (opoint, PT, CHECK_BORDER);
760 /* Likewise, but inherit text properties from neighboring characters. */
762 void
763 insert_before_markers_and_inherit (string, nbytes)
764 unsigned char *string;
765 register int nbytes;
767 if (nbytes > 0)
769 int opoint = PT;
771 insert_1 (string, nbytes, 1, 1, 1);
772 signal_after_change (opoint, 0, PT - opoint);
773 update_compositions (opoint, PT, CHECK_BORDER);
777 /* Subroutine used by the insert functions above. */
779 void
780 insert_1 (string, nbytes, inherit, prepare, before_markers)
781 register unsigned char *string;
782 register int nbytes;
783 int inherit, prepare, before_markers;
785 insert_1_both (string, chars_in_text (string, nbytes), nbytes,
786 inherit, prepare, before_markers);
790 #ifdef BYTE_COMBINING_DEBUG
792 /* See if the bytes before POS/POS_BYTE combine with bytes
793 at the start of STRING to form a single character.
794 If so, return the number of bytes at the start of STRING
795 which combine in this way. Otherwise, return 0. */
798 count_combining_before (string, length, pos, pos_byte)
799 unsigned char *string;
800 int length;
801 int pos, pos_byte;
803 int len, combining_bytes;
804 unsigned char *p;
806 if (NILP (current_buffer->enable_multibyte_characters))
807 return 0;
809 /* At first, we can exclude the following cases:
810 (1) STRING[0] can't be a following byte of multibyte sequence.
811 (2) POS is the start of the current buffer.
812 (3) A character before POS is not a multibyte character. */
813 if (length == 0 || CHAR_HEAD_P (*string)) /* case (1) */
814 return 0;
815 if (pos_byte == BEG_BYTE) /* case (2) */
816 return 0;
817 len = 1;
818 p = BYTE_POS_ADDR (pos_byte - 1);
819 while (! CHAR_HEAD_P (*p)) p--, len++;
820 if (! BASE_LEADING_CODE_P (*p)) /* case (3) */
821 return 0;
823 combining_bytes = BYTES_BY_CHAR_HEAD (*p) - len;
824 if (combining_bytes <= 0)
825 /* The character preceding POS is, complete and no room for
826 combining bytes (combining_bytes == 0), or an independent 8-bit
827 character (combining_bytes < 0). */
828 return 0;
830 /* We have a combination situation. Count the bytes at STRING that
831 may combine. */
832 p = string + 1;
833 while (!CHAR_HEAD_P (*p) && p < string + length)
834 p++;
836 return (combining_bytes < p - string ? combining_bytes : p - string);
839 /* See if the bytes after POS/POS_BYTE combine with bytes
840 at the end of STRING to form a single character.
841 If so, return the number of bytes after POS/POS_BYTE
842 which combine in this way. Otherwise, return 0. */
845 count_combining_after (string, length, pos, pos_byte)
846 unsigned char *string;
847 int length;
848 int pos, pos_byte;
850 int opos_byte = pos_byte;
851 int i;
852 int bytes;
853 unsigned char *bufp;
855 if (NILP (current_buffer->enable_multibyte_characters))
856 return 0;
858 /* At first, we can exclude the following cases:
859 (1) The last byte of STRING is an ASCII.
860 (2) POS is the last of the current buffer.
861 (3) A character at POS can't be a following byte of multibyte
862 character. */
863 if (length > 0 && ASCII_BYTE_P (string[length - 1])) /* case (1) */
864 return 0;
865 if (pos_byte == Z_BYTE) /* case (2) */
866 return 0;
867 bufp = BYTE_POS_ADDR (pos_byte);
868 if (CHAR_HEAD_P (*bufp)) /* case (3) */
869 return 0;
871 i = length - 1;
872 while (i >= 0 && ! CHAR_HEAD_P (string[i]))
874 i--;
876 if (i < 0)
878 /* All characters in STRING are not character head. We must
879 check also preceding bytes at POS. We are sure that the gap
880 is at POS. */
881 unsigned char *p = BEG_ADDR;
882 i = pos_byte - 2;
883 while (i >= 0 && ! CHAR_HEAD_P (p[i]))
884 i--;
885 if (i < 0 || !BASE_LEADING_CODE_P (p[i]))
886 return 0;
888 bytes = BYTES_BY_CHAR_HEAD (p[i]);
889 return (bytes <= pos_byte - 1 - i + length
891 : bytes - (pos_byte - 1 - i + length));
893 if (!BASE_LEADING_CODE_P (string[i]))
894 return 0;
896 bytes = BYTES_BY_CHAR_HEAD (string[i]) - (length - i);
897 bufp++, pos_byte++;
898 while (!CHAR_HEAD_P (*bufp)) bufp++, pos_byte++;
900 return (bytes <= pos_byte - opos_byte ? bytes : pos_byte - opos_byte);
903 #endif
906 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
907 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
908 are the same as in insert_1. */
910 void
911 insert_1_both (string, nchars, nbytes, inherit, prepare, before_markers)
912 register unsigned char *string;
913 register int nchars, nbytes;
914 int inherit, prepare, before_markers;
916 if (NILP (current_buffer->enable_multibyte_characters))
917 nchars = nbytes;
919 if (prepare)
920 /* Do this before moving and increasing the gap,
921 because the before-change hooks might move the gap
922 or make it smaller. */
923 prepare_to_modify_buffer (PT, PT, NULL);
925 if (PT != GPT)
926 move_gap_both (PT, PT_BYTE);
927 if (GAP_SIZE < nbytes)
928 make_gap (nbytes - GAP_SIZE);
930 #ifdef BYTE_COMBINING_DEBUG
931 if (count_combining_before (string, nbytes, PT, PT_BYTE)
932 || count_combining_after (string, nbytes, PT, PT_BYTE))
933 abort ();
934 #endif
936 /* Record deletion of the surrounding text that combines with
937 the insertion. This, together with recording the insertion,
938 will add up to the right stuff in the undo list. */
939 record_insert (PT, nchars);
940 MODIFF++;
942 bcopy (string, GPT_ADDR, nbytes);
944 GAP_SIZE -= nbytes;
945 GPT += nchars;
946 ZV += nchars;
947 Z += nchars;
948 GPT_BYTE += nbytes;
949 ZV_BYTE += nbytes;
950 Z_BYTE += nbytes;
951 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
953 if (GPT_BYTE < GPT)
954 abort ();
956 adjust_overlays_for_insert (PT, nchars);
957 adjust_markers_for_insert (PT, PT_BYTE,
958 PT + nchars, PT_BYTE + nbytes,
959 before_markers);
961 if (BUF_INTERVALS (current_buffer) != 0)
962 offset_intervals (current_buffer, PT, nchars);
964 if (!inherit && BUF_INTERVALS (current_buffer) != 0)
965 set_text_properties (make_number (PT), make_number (PT + nchars),
966 Qnil, Qnil, Qnil);
968 adjust_point (nchars, nbytes);
970 CHECK_MARKERS ();
973 /* Insert the part of the text of STRING, a Lisp object assumed to be
974 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
975 starting at position POS / POS_BYTE. If the text of STRING has properties,
976 copy them into the buffer.
978 It does not work to use `insert' for this, because a GC could happen
979 before we bcopy the stuff into the buffer, and relocate the string
980 without insert noticing. */
982 void
983 insert_from_string (string, pos, pos_byte, length, length_byte, inherit)
984 Lisp_Object string;
985 register int pos, pos_byte, length, length_byte;
986 int inherit;
988 int opoint = PT;
989 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
990 inherit, 0);
991 signal_after_change (opoint, 0, PT - opoint);
992 update_compositions (opoint, PT, CHECK_BORDER);
995 /* Like `insert_from_string' except that all markers pointing
996 at the place where the insertion happens are adjusted to point after it. */
998 void
999 insert_from_string_before_markers (string, pos, pos_byte,
1000 length, length_byte, inherit)
1001 Lisp_Object string;
1002 register int pos, pos_byte, length, length_byte;
1003 int inherit;
1005 int opoint = PT;
1006 insert_from_string_1 (string, pos, pos_byte, length, length_byte,
1007 inherit, 1);
1008 signal_after_change (opoint, 0, PT - opoint);
1009 update_compositions (opoint, PT, CHECK_BORDER);
1012 /* Subroutine of the insertion functions above. */
1014 static void
1015 insert_from_string_1 (string, pos, pos_byte, nchars, nbytes,
1016 inherit, before_markers)
1017 Lisp_Object string;
1018 register int pos, pos_byte, nchars, nbytes;
1019 int inherit, before_markers;
1021 struct gcpro gcpro1;
1022 int outgoing_nbytes = nbytes;
1023 INTERVAL intervals;
1025 /* Make OUTGOING_NBYTES describe the text
1026 as it will be inserted in this buffer. */
1028 if (NILP (current_buffer->enable_multibyte_characters))
1029 outgoing_nbytes = nchars;
1030 else if (! STRING_MULTIBYTE (string))
1031 outgoing_nbytes
1032 = count_size_as_multibyte (&XSTRING (string)->data[pos_byte],
1033 nbytes);
1035 GCPRO1 (string);
1036 /* Do this before moving and increasing the gap,
1037 because the before-change hooks might move the gap
1038 or make it smaller. */
1039 prepare_to_modify_buffer (PT, PT, NULL);
1041 if (PT != GPT)
1042 move_gap_both (PT, PT_BYTE);
1043 if (GAP_SIZE < outgoing_nbytes)
1044 make_gap (outgoing_nbytes - GAP_SIZE);
1045 UNGCPRO;
1047 /* Copy the string text into the buffer, perhaps converting
1048 between single-byte and multibyte. */
1049 copy_text (XSTRING (string)->data + pos_byte, GPT_ADDR, nbytes,
1050 STRING_MULTIBYTE (string),
1051 ! NILP (current_buffer->enable_multibyte_characters));
1053 #ifdef BYTE_COMBINING_DEBUG
1054 /* We have copied text into the gap, but we have not altered
1055 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1056 to these functions and get the same results as we would
1057 have got earlier on. Meanwhile, PT_ADDR does point to
1058 the text that has been stored by copy_text. */
1059 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
1060 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
1061 abort ();
1062 #endif
1064 record_insert (PT, nchars);
1065 MODIFF++;
1067 GAP_SIZE -= outgoing_nbytes;
1068 GPT += nchars;
1069 ZV += nchars;
1070 Z += nchars;
1071 GPT_BYTE += outgoing_nbytes;
1072 ZV_BYTE += outgoing_nbytes;
1073 Z_BYTE += outgoing_nbytes;
1074 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1076 if (GPT_BYTE < GPT)
1077 abort ();
1079 adjust_overlays_for_insert (PT, nchars);
1080 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
1081 PT_BYTE + outgoing_nbytes,
1082 before_markers);
1084 offset_intervals (current_buffer, PT, nchars);
1086 intervals = XSTRING (string)->intervals;
1087 /* Get the intervals for the part of the string we are inserting. */
1088 if (nbytes < STRING_BYTES (XSTRING (string)))
1089 intervals = copy_intervals (intervals, pos, nchars);
1091 /* Insert those intervals. */
1092 graft_intervals_into_buffer (intervals, PT, nchars,
1093 current_buffer, inherit);
1095 adjust_point (nchars, outgoing_nbytes);
1098 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1099 current buffer. If the text in BUF has properties, they are absorbed
1100 into the current buffer.
1102 It does not work to use `insert' for this, because a malloc could happen
1103 and relocate BUF's text before the bcopy happens. */
1105 void
1106 insert_from_buffer (buf, charpos, nchars, inherit)
1107 struct buffer *buf;
1108 int charpos, nchars;
1109 int inherit;
1111 int opoint = PT;
1113 insert_from_buffer_1 (buf, charpos, nchars, inherit);
1114 signal_after_change (opoint, 0, PT - opoint);
1115 update_compositions (opoint, PT, CHECK_BORDER);
1118 static void
1119 insert_from_buffer_1 (buf, from, nchars, inherit)
1120 struct buffer *buf;
1121 int from, nchars;
1122 int inherit;
1124 register Lisp_Object temp;
1125 int chunk, chunk_expanded;
1126 int from_byte = buf_charpos_to_bytepos (buf, from);
1127 int to_byte = buf_charpos_to_bytepos (buf, from + nchars);
1128 int incoming_nbytes = to_byte - from_byte;
1129 int outgoing_nbytes = incoming_nbytes;
1130 INTERVAL intervals;
1132 /* Make OUTGOING_NBYTES describe the text
1133 as it will be inserted in this buffer. */
1135 if (NILP (current_buffer->enable_multibyte_characters))
1136 outgoing_nbytes = nchars;
1137 else if (NILP (buf->enable_multibyte_characters))
1139 int outgoing_before_gap = 0;
1140 int outgoing_after_gap = 0;
1142 if (from < BUF_GPT (buf))
1144 chunk = BUF_GPT_BYTE (buf) - from_byte;
1145 if (chunk > incoming_nbytes)
1146 chunk = incoming_nbytes;
1147 outgoing_before_gap
1148 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf, from_byte),
1149 chunk);
1151 else
1152 chunk = 0;
1154 if (chunk < incoming_nbytes)
1155 outgoing_after_gap
1156 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf,
1157 from_byte + chunk),
1158 incoming_nbytes - chunk);
1160 outgoing_nbytes = outgoing_before_gap + outgoing_after_gap;
1163 /* Make sure point-max won't overflow after this insertion. */
1164 XSETINT (temp, outgoing_nbytes + Z);
1165 if (outgoing_nbytes + Z != XINT (temp))
1166 error ("Maximum buffer size exceeded");
1168 /* Do this before moving and increasing the gap,
1169 because the before-change hooks might move the gap
1170 or make it smaller. */
1171 prepare_to_modify_buffer (PT, PT, NULL);
1173 if (PT != GPT)
1174 move_gap_both (PT, PT_BYTE);
1175 if (GAP_SIZE < outgoing_nbytes)
1176 make_gap (outgoing_nbytes - GAP_SIZE);
1178 if (from < BUF_GPT (buf))
1180 chunk = BUF_GPT_BYTE (buf) - from_byte;
1181 if (chunk > incoming_nbytes)
1182 chunk = incoming_nbytes;
1183 /* Record number of output bytes, so we know where
1184 to put the output from the second copy_text. */
1185 chunk_expanded
1186 = copy_text (BUF_BYTE_ADDRESS (buf, from_byte),
1187 GPT_ADDR, chunk,
1188 ! NILP (buf->enable_multibyte_characters),
1189 ! NILP (current_buffer->enable_multibyte_characters));
1191 else
1192 chunk_expanded = chunk = 0;
1194 if (chunk < incoming_nbytes)
1195 copy_text (BUF_BYTE_ADDRESS (buf, from_byte + chunk),
1196 GPT_ADDR + chunk_expanded, incoming_nbytes - chunk,
1197 ! NILP (buf->enable_multibyte_characters),
1198 ! NILP (current_buffer->enable_multibyte_characters));
1200 #ifdef BYTE_COMBINING_DEBUG
1201 /* We have copied text into the gap, but we have not altered
1202 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1203 to these functions and get the same results as we would
1204 have got earlier on. Meanwhile, GPT_ADDR does point to
1205 the text that has been stored by copy_text. */
1206 if (count_combining_before (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE)
1207 || count_combining_after (GPT_ADDR, outgoing_nbytes, PT, PT_BYTE))
1208 abort ();
1209 #endif
1211 record_insert (PT, nchars);
1212 MODIFF++;
1214 GAP_SIZE -= outgoing_nbytes;
1215 GPT += nchars;
1216 ZV += nchars;
1217 Z += nchars;
1218 GPT_BYTE += outgoing_nbytes;
1219 ZV_BYTE += outgoing_nbytes;
1220 Z_BYTE += outgoing_nbytes;
1221 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1223 if (GPT_BYTE < GPT)
1224 abort ();
1226 adjust_overlays_for_insert (PT, nchars);
1227 adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
1228 PT_BYTE + outgoing_nbytes,
1231 if (BUF_INTERVALS (current_buffer) != 0)
1232 offset_intervals (current_buffer, PT, nchars);
1234 /* Get the intervals for the part of the string we are inserting. */
1235 intervals = BUF_INTERVALS (buf);
1236 if (outgoing_nbytes < BUF_Z_BYTE (buf) - BUF_BEG_BYTE (buf))
1238 if (buf == current_buffer && PT <= from)
1239 from += nchars;
1240 intervals = copy_intervals (intervals, from, nchars);
1243 /* Insert those intervals. */
1244 graft_intervals_into_buffer (intervals, PT, nchars, current_buffer, inherit);
1246 adjust_point (nchars, outgoing_nbytes);
1249 /* Record undo information and adjust markers and position keepers for
1250 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1251 chars (LEN_BYTE bytes) which resides in the gap just after
1252 GPT_ADDR.
1254 PREV_TEXT nil means the new text was just inserted. */
1256 void
1257 adjust_after_replace (from, from_byte, prev_text, len, len_byte)
1258 int from, from_byte, len, len_byte;
1259 Lisp_Object prev_text;
1261 int nchars_del = 0, nbytes_del = 0;
1263 #ifdef BYTE_COMBINING_DEBUG
1264 if (count_combining_before (GPT_ADDR, len_byte, from, from_byte)
1265 || count_combining_after (GPT_ADDR, len_byte, from, from_byte))
1266 abort ();
1267 #endif
1269 if (STRINGP (prev_text))
1271 nchars_del = XSTRING (prev_text)->size;
1272 nbytes_del = STRING_BYTES (XSTRING (prev_text));
1275 /* Update various buffer positions for the new text. */
1276 GAP_SIZE -= len_byte;
1277 ZV += len; Z+= len;
1278 ZV_BYTE += len_byte; Z_BYTE += len_byte;
1279 GPT += len; GPT_BYTE += len_byte;
1280 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1282 if (nchars_del > 0)
1283 adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
1284 len, len_byte);
1285 else
1286 adjust_markers_for_insert (from, from_byte,
1287 from + len, from_byte + len_byte, 0);
1289 if (! EQ (current_buffer->undo_list, Qt))
1291 if (nchars_del > 0)
1292 record_delete (from, prev_text);
1293 record_insert (from, len);
1296 if (len > nchars_del)
1297 adjust_overlays_for_insert (from, len - nchars_del);
1298 else if (len < nchars_del)
1299 adjust_overlays_for_delete (from, nchars_del - len);
1300 if (BUF_INTERVALS (current_buffer) != 0)
1302 offset_intervals (current_buffer, from, len - nchars_del);
1305 if (from < PT)
1306 adjust_point (len - nchars_del, len_byte - nbytes_del);
1308 /* As byte combining will decrease Z, we must check this again. */
1309 if (Z - GPT < END_UNCHANGED)
1310 END_UNCHANGED = Z - GPT;
1312 CHECK_MARKERS ();
1314 if (len == 0)
1315 evaporate_overlays (from);
1316 MODIFF++;
1319 /* Record undo information, adjust markers and position keepers for an
1320 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1321 text already exists in the current buffer but character length (TO
1322 - FROM) may be incorrect, the correct length is NEWLEN. */
1324 void
1325 adjust_after_insert (from, from_byte, to, to_byte, newlen)
1326 int from, from_byte, to, to_byte, newlen;
1328 int len = to - from, len_byte = to_byte - from_byte;
1330 if (GPT != to)
1331 move_gap_both (to, to_byte);
1332 GAP_SIZE += len_byte;
1333 GPT -= len; GPT_BYTE -= len_byte;
1334 ZV -= len; ZV_BYTE -= len_byte;
1335 Z -= len; Z_BYTE -= len_byte;
1336 adjust_after_replace (from, from_byte, Qnil, newlen, len_byte);
1339 /* Replace the text from character positions FROM to TO with NEW,
1340 If PREPARE is nonzero, call prepare_to_modify_buffer.
1341 If INHERIT, the newly inserted text should inherit text properties
1342 from the surrounding non-deleted text. */
1344 /* Note that this does not yet handle markers quite right.
1345 Also it needs to record a single undo-entry that does a replacement
1346 rather than a separate delete and insert.
1347 That way, undo will also handle markers properly.
1349 But if MARKERS is 0, don't relocate markers. */
1351 void
1352 replace_range (from, to, new, prepare, inherit, markers)
1353 Lisp_Object new;
1354 int from, to, prepare, inherit, markers;
1356 int inschars = XSTRING (new)->size;
1357 int insbytes = STRING_BYTES (XSTRING (new));
1358 int from_byte, to_byte;
1359 int nbytes_del, nchars_del;
1360 register Lisp_Object temp;
1361 struct gcpro gcpro1;
1362 INTERVAL intervals;
1363 int outgoing_insbytes = insbytes;
1364 Lisp_Object deletion;
1366 CHECK_MARKERS ();
1368 GCPRO1 (new);
1369 deletion = Qnil;
1371 if (prepare)
1373 int range_length = to - from;
1374 prepare_to_modify_buffer (from, to, &from);
1375 to = from + range_length;
1378 UNGCPRO;
1380 /* Make args be valid */
1381 if (from < BEGV)
1382 from = BEGV;
1383 if (to > ZV)
1384 to = ZV;
1386 from_byte = CHAR_TO_BYTE (from);
1387 to_byte = CHAR_TO_BYTE (to);
1389 nchars_del = to - from;
1390 nbytes_del = to_byte - from_byte;
1392 if (nbytes_del <= 0 && insbytes == 0)
1393 return;
1395 /* Make OUTGOING_INSBYTES describe the text
1396 as it will be inserted in this buffer. */
1398 if (NILP (current_buffer->enable_multibyte_characters))
1399 outgoing_insbytes = inschars;
1400 else if (! STRING_MULTIBYTE (new))
1401 outgoing_insbytes
1402 = count_size_as_multibyte (XSTRING (new)->data, insbytes);
1404 /* Make sure point-max won't overflow after this insertion. */
1405 XSETINT (temp, Z_BYTE - nbytes_del + insbytes);
1406 if (Z_BYTE - nbytes_del + insbytes != XINT (temp))
1407 error ("Maximum buffer size exceeded");
1409 GCPRO1 (new);
1411 /* Make sure the gap is somewhere in or next to what we are deleting. */
1412 if (from > GPT)
1413 gap_right (from, from_byte);
1414 if (to < GPT)
1415 gap_left (to, to_byte, 0);
1417 /* Even if we don't record for undo, we must keep the original text
1418 because we may have to recover it because of inappropriate byte
1419 combining. */
1420 if (! EQ (current_buffer->undo_list, Qt))
1421 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1423 if (markers)
1424 /* Relocate all markers pointing into the new, larger gap
1425 to point at the end of the text before the gap.
1426 Do this before recording the deletion,
1427 so that undo handles this after reinserting the text. */
1428 adjust_markers_for_delete (from, from_byte, to, to_byte);
1430 GAP_SIZE += nbytes_del;
1431 ZV -= nchars_del;
1432 Z -= nchars_del;
1433 ZV_BYTE -= nbytes_del;
1434 Z_BYTE -= nbytes_del;
1435 GPT = from;
1436 GPT_BYTE = from_byte;
1437 *(GPT_ADDR) = 0; /* Put an anchor. */
1439 if (GPT_BYTE < GPT)
1440 abort ();
1442 if (GPT - BEG < BEG_UNCHANGED)
1443 BEG_UNCHANGED = GPT - BEG;
1444 if (Z - GPT < END_UNCHANGED)
1445 END_UNCHANGED = Z - GPT;
1447 if (GAP_SIZE < insbytes)
1448 make_gap (insbytes - GAP_SIZE);
1450 /* Copy the string text into the buffer, perhaps converting
1451 between single-byte and multibyte. */
1452 copy_text (XSTRING (new)->data, GPT_ADDR, insbytes,
1453 STRING_MULTIBYTE (new),
1454 ! NILP (current_buffer->enable_multibyte_characters));
1456 #ifdef BYTE_COMBINING_DEBUG
1457 /* We have copied text into the gap, but we have not marked
1458 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1459 here, for both the previous text and the following text.
1460 Meanwhile, GPT_ADDR does point to
1461 the text that has been stored by copy_text. */
1462 if (count_combining_before (GPT_ADDR, outgoing_insbytes, from, from_byte)
1463 || count_combining_after (GPT_ADDR, outgoing_insbytes, from, from_byte))
1464 abort ();
1465 #endif
1467 if (! EQ (current_buffer->undo_list, Qt))
1469 record_delete (from, deletion);
1470 record_insert (from, inschars);
1473 GAP_SIZE -= outgoing_insbytes;
1474 GPT += inschars;
1475 ZV += inschars;
1476 Z += inschars;
1477 GPT_BYTE += outgoing_insbytes;
1478 ZV_BYTE += outgoing_insbytes;
1479 Z_BYTE += outgoing_insbytes;
1480 if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
1482 if (GPT_BYTE < GPT)
1483 abort ();
1485 /* Adjust the overlay center as needed. This must be done after
1486 adjusting the markers that bound the overlays. */
1487 adjust_overlays_for_delete (from, nchars_del);
1488 adjust_overlays_for_insert (from, inschars);
1489 if (markers)
1490 adjust_markers_for_insert (from, from_byte,
1491 from + inschars, from_byte + outgoing_insbytes,
1494 offset_intervals (current_buffer, from, inschars - nchars_del);
1496 /* Get the intervals for the part of the string we are inserting--
1497 not including the combined-before bytes. */
1498 intervals = XSTRING (new)->intervals;
1499 /* Insert those intervals. */
1500 graft_intervals_into_buffer (intervals, from, inschars,
1501 current_buffer, inherit);
1503 /* Relocate point as if it were a marker. */
1504 if (from < PT)
1505 adjust_point ((from + inschars - (PT < to ? PT : to)),
1506 (from_byte + outgoing_insbytes
1507 - (PT_BYTE < to_byte ? PT_BYTE : to_byte)));
1509 if (outgoing_insbytes == 0)
1510 evaporate_overlays (from);
1512 CHECK_MARKERS ();
1514 MODIFF++;
1515 UNGCPRO;
1517 signal_after_change (from, nchars_del, GPT - from);
1518 update_compositions (from, GPT, CHECK_BORDER);
1521 /* Delete characters in current buffer
1522 from FROM up to (but not including) TO.
1523 If TO comes before FROM, we delete nothing. */
1525 void
1526 del_range (from, to)
1527 register int from, to;
1529 del_range_1 (from, to, 1, 0);
1532 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1533 RET_STRING says to return the deleted text. */
1535 Lisp_Object
1536 del_range_1 (from, to, prepare, ret_string)
1537 int from, to, prepare, ret_string;
1539 int from_byte, to_byte;
1540 Lisp_Object deletion;
1541 struct gcpro gcpro1;
1543 /* Make args be valid */
1544 if (from < BEGV)
1545 from = BEGV;
1546 if (to > ZV)
1547 to = ZV;
1549 if (to <= from)
1550 return Qnil;
1552 if (prepare)
1554 int range_length = to - from;
1555 prepare_to_modify_buffer (from, to, &from);
1556 to = from + range_length;
1559 from_byte = CHAR_TO_BYTE (from);
1560 to_byte = CHAR_TO_BYTE (to);
1562 deletion = del_range_2 (from, from_byte, to, to_byte, ret_string);
1563 GCPRO1(deletion);
1564 signal_after_change (from, to - from, 0);
1565 update_compositions (from, from, CHECK_HEAD);
1566 UNGCPRO;
1567 return deletion;
1570 /* Like del_range_1 but args are byte positions, not char positions. */
1572 void
1573 del_range_byte (from_byte, to_byte, prepare)
1574 int from_byte, to_byte, prepare;
1576 int from, to;
1578 /* Make args be valid */
1579 if (from_byte < BEGV_BYTE)
1580 from_byte = BEGV_BYTE;
1581 if (to_byte > ZV_BYTE)
1582 to_byte = ZV_BYTE;
1584 if (to_byte <= from_byte)
1585 return;
1587 from = BYTE_TO_CHAR (from_byte);
1588 to = BYTE_TO_CHAR (to_byte);
1590 if (prepare)
1592 int old_from = from, old_to = Z - to;
1593 int range_length = to - from;
1594 prepare_to_modify_buffer (from, to, &from);
1595 to = from + range_length;
1597 if (old_from != from)
1598 from_byte = CHAR_TO_BYTE (from);
1599 if (old_to == Z - to)
1600 to_byte = CHAR_TO_BYTE (to);
1603 del_range_2 (from, from_byte, to, to_byte, 0);
1604 signal_after_change (from, to - from, 0);
1605 update_compositions (from, from, CHECK_HEAD);
1608 /* Like del_range_1, but positions are specified both as charpos
1609 and bytepos. */
1611 void
1612 del_range_both (from, from_byte, to, to_byte, prepare)
1613 int from, from_byte, to, to_byte, prepare;
1615 /* Make args be valid */
1616 if (from_byte < BEGV_BYTE)
1617 from_byte = BEGV_BYTE;
1618 if (to_byte > ZV_BYTE)
1619 to_byte = ZV_BYTE;
1621 if (to_byte <= from_byte)
1622 return;
1624 if (from < BEGV)
1625 from = BEGV;
1626 if (to > ZV)
1627 to = ZV;
1629 if (prepare)
1631 int old_from = from, old_to = Z - to;
1632 int range_length = to - from;
1633 prepare_to_modify_buffer (from, to, &from);
1634 to = from + range_length;
1636 if (old_from != from)
1637 from_byte = CHAR_TO_BYTE (from);
1638 if (old_to == Z - to)
1639 to_byte = CHAR_TO_BYTE (to);
1642 del_range_2 (from, from_byte, to, to_byte, 0);
1643 signal_after_change (from, to - from, 0);
1644 update_compositions (from, from, CHECK_HEAD);
1647 /* Delete a range of text, specified both as character positions
1648 and byte positions. FROM and TO are character positions,
1649 while FROM_BYTE and TO_BYTE are byte positions.
1650 If RET_STRING is true, the deleted area is returned as a string. */
1652 Lisp_Object
1653 del_range_2 (from, from_byte, to, to_byte, ret_string)
1654 int from, from_byte, to, to_byte, ret_string;
1656 register int nbytes_del, nchars_del;
1657 Lisp_Object deletion;
1659 CHECK_MARKERS ();
1661 nchars_del = to - from;
1662 nbytes_del = to_byte - from_byte;
1664 /* Make sure the gap is somewhere in or next to what we are deleting. */
1665 if (from > GPT)
1666 gap_right (from, from_byte);
1667 if (to < GPT)
1668 gap_left (to, to_byte, 0);
1670 #ifdef BYTE_COMBINING_DEBUG
1671 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer, to_byte),
1672 Z_BYTE - to_byte, from, from_byte))
1673 abort ();
1674 #endif
1676 if (ret_string || ! EQ (current_buffer->undo_list, Qt))
1677 deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
1678 else
1679 deletion = Qnil;
1681 /* Relocate all markers pointing into the new, larger gap
1682 to point at the end of the text before the gap.
1683 Do this before recording the deletion,
1684 so that undo handles this after reinserting the text. */
1685 adjust_markers_for_delete (from, from_byte, to, to_byte);
1687 if (! EQ (current_buffer->undo_list, Qt))
1688 record_delete (from, deletion);
1689 MODIFF++;
1691 /* Relocate point as if it were a marker. */
1692 if (from < PT)
1693 adjust_point (from - (PT < to ? PT : to),
1694 from_byte - (PT_BYTE < to_byte ? PT_BYTE : to_byte));
1696 offset_intervals (current_buffer, from, - nchars_del);
1698 /* Adjust the overlay center as needed. This must be done after
1699 adjusting the markers that bound the overlays. */
1700 adjust_overlays_for_delete (from, nchars_del);
1702 GAP_SIZE += nbytes_del;
1703 ZV_BYTE -= nbytes_del;
1704 Z_BYTE -= nbytes_del;
1705 ZV -= nchars_del;
1706 Z -= nchars_del;
1707 GPT = from;
1708 GPT_BYTE = from_byte;
1709 *(GPT_ADDR) = 0; /* Put an anchor. */
1711 if (GPT_BYTE < GPT)
1712 abort ();
1714 if (GPT - BEG < BEG_UNCHANGED)
1715 BEG_UNCHANGED = GPT - BEG;
1716 if (Z - GPT < END_UNCHANGED)
1717 END_UNCHANGED = Z - GPT;
1719 CHECK_MARKERS ();
1721 evaporate_overlays (from);
1723 return deletion;
1726 /* Call this if you're about to change the region of BUFFER from
1727 character positions START to END. This checks the read-only
1728 properties of the region, calls the necessary modification hooks,
1729 and warns the next redisplay that it should pay attention to that
1730 area. */
1732 void
1733 modify_region (buffer, start, end)
1734 struct buffer *buffer;
1735 int start, end;
1737 struct buffer *old_buffer = current_buffer;
1739 if (buffer != old_buffer)
1740 set_buffer_internal (buffer);
1742 prepare_to_modify_buffer (start, end, NULL);
1744 BUF_COMPUTE_UNCHANGED (buffer, start - 1, end);
1746 if (MODIFF <= SAVE_MODIFF)
1747 record_first_change ();
1748 MODIFF++;
1750 buffer->point_before_scroll = Qnil;
1752 if (buffer != old_buffer)
1753 set_buffer_internal (old_buffer);
1756 /* Check that it is okay to modify the buffer between START and END,
1757 which are char positions.
1759 Run the before-change-function, if any. If intervals are in use,
1760 verify that the text to be modified is not read-only, and call
1761 any modification properties the text may have.
1763 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1764 by holding its value temporarily in a marker. */
1766 void
1767 prepare_to_modify_buffer (start, end, preserve_ptr)
1768 int start, end;
1769 int *preserve_ptr;
1771 if (!NILP (current_buffer->read_only))
1772 Fbarf_if_buffer_read_only ();
1774 /* Let redisplay consider other windows than selected_window
1775 if modifying another buffer. */
1776 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1777 ++windows_or_buffers_changed;
1779 if (BUF_INTERVALS (current_buffer) != 0)
1781 if (preserve_ptr)
1783 Lisp_Object preserve_marker;
1784 struct gcpro gcpro1;
1785 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil);
1786 GCPRO1 (preserve_marker);
1787 verify_interval_modification (current_buffer, start, end);
1788 *preserve_ptr = marker_position (preserve_marker);
1789 unchain_marker (preserve_marker);
1790 UNGCPRO;
1792 else
1793 verify_interval_modification (current_buffer, start, end);
1796 #ifdef CLASH_DETECTION
1797 if (!NILP (current_buffer->file_truename)
1798 /* Make binding buffer-file-name to nil effective. */
1799 && !NILP (current_buffer->filename)
1800 && SAVE_MODIFF >= MODIFF)
1801 lock_file (current_buffer->file_truename);
1802 #else
1803 /* At least warn if this file has changed on disk since it was visited. */
1804 if (!NILP (current_buffer->filename)
1805 && SAVE_MODIFF >= MODIFF
1806 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1807 && !NILP (Ffile_exists_p (current_buffer->filename)))
1808 call1 (intern ("ask-user-about-supersession-threat"),
1809 current_buffer->filename);
1810 #endif /* not CLASH_DETECTION */
1812 signal_before_change (start, end, preserve_ptr);
1814 if (current_buffer->newline_cache)
1815 invalidate_region_cache (current_buffer,
1816 current_buffer->newline_cache,
1817 start - BEG, Z - end);
1818 if (current_buffer->width_run_cache)
1819 invalidate_region_cache (current_buffer,
1820 current_buffer->width_run_cache,
1821 start - BEG, Z - end);
1823 Vdeactivate_mark = Qt;
1826 /* These macros work with an argument named `preserve_ptr'
1827 and a local variable named `preserve_marker'. */
1829 #define PRESERVE_VALUE \
1830 if (preserve_ptr && NILP (preserve_marker)) \
1831 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1833 #define RESTORE_VALUE \
1834 if (! NILP (preserve_marker)) \
1836 *preserve_ptr = marker_position (preserve_marker); \
1837 unchain_marker (preserve_marker); \
1840 #define PRESERVE_START_END \
1841 if (NILP (start_marker)) \
1842 start_marker = Fcopy_marker (start, Qnil); \
1843 if (NILP (end_marker)) \
1844 end_marker = Fcopy_marker (end, Qnil);
1846 #define FETCH_START \
1847 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1849 #define FETCH_END \
1850 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1852 /* Signal a change to the buffer immediately before it happens.
1853 START_INT and END_INT are the bounds of the text to be changed.
1855 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1856 by holding its value temporarily in a marker. */
1858 void
1859 signal_before_change (start_int, end_int, preserve_ptr)
1860 int start_int, end_int;
1861 int *preserve_ptr;
1863 Lisp_Object start, end;
1864 Lisp_Object start_marker, end_marker;
1865 Lisp_Object preserve_marker;
1866 struct gcpro gcpro1, gcpro2, gcpro3;
1868 if (inhibit_modification_hooks)
1869 return;
1871 start = make_number (start_int);
1872 end = make_number (end_int);
1873 preserve_marker = Qnil;
1874 start_marker = Qnil;
1875 end_marker = Qnil;
1876 GCPRO3 (preserve_marker, start_marker, end_marker);
1878 /* If buffer is unmodified, run a special hook for that case. */
1879 if (SAVE_MODIFF >= MODIFF
1880 && !NILP (Vfirst_change_hook)
1881 && !NILP (Vrun_hooks))
1883 PRESERVE_VALUE;
1884 PRESERVE_START_END;
1885 call1 (Vrun_hooks, Qfirst_change_hook);
1888 /* Now run the before-change-functions if any. */
1889 if (!NILP (Vbefore_change_functions))
1891 Lisp_Object args[3];
1892 Lisp_Object before_change_functions;
1893 Lisp_Object after_change_functions;
1894 struct gcpro gcpro1, gcpro2;
1896 PRESERVE_VALUE;
1897 PRESERVE_START_END;
1899 /* "Bind" before-change-functions and after-change-functions
1900 to nil--but in a way that errors don't know about.
1901 That way, if there's an error in them, they will stay nil. */
1902 before_change_functions = Vbefore_change_functions;
1903 after_change_functions = Vafter_change_functions;
1904 Vbefore_change_functions = Qnil;
1905 Vafter_change_functions = Qnil;
1906 GCPRO2 (before_change_functions, after_change_functions);
1908 /* Actually run the hook functions. */
1909 args[0] = Qbefore_change_functions;
1910 args[1] = FETCH_START;
1911 args[2] = FETCH_END;
1912 run_hook_list_with_args (before_change_functions, 3, args);
1914 /* "Unbind" the variables we "bound" to nil. */
1915 Vbefore_change_functions = before_change_functions;
1916 Vafter_change_functions = after_change_functions;
1917 UNGCPRO;
1920 if (!NILP (current_buffer->overlays_before)
1921 || !NILP (current_buffer->overlays_after))
1923 PRESERVE_VALUE;
1924 report_overlay_modification (FETCH_START, FETCH_END, 0,
1925 FETCH_START, FETCH_END, Qnil);
1928 if (! NILP (start_marker))
1929 free_marker (start_marker);
1930 if (! NILP (end_marker))
1931 free_marker (end_marker);
1932 RESTORE_VALUE;
1933 UNGCPRO;
1936 /* Signal a change immediately after it happens.
1937 CHARPOS is the character position of the start of the changed text.
1938 LENDEL is the number of characters of the text before the change.
1939 (Not the whole buffer; just the part that was changed.)
1940 LENINS is the number of characters in that part of the text
1941 after the change. */
1943 void
1944 signal_after_change (charpos, lendel, lenins)
1945 int charpos, lendel, lenins;
1947 if (inhibit_modification_hooks)
1948 return;
1950 /* If we are deferring calls to the after-change functions
1951 and there are no before-change functions,
1952 just record the args that we were going to use. */
1953 if (! NILP (Vcombine_after_change_calls)
1954 && NILP (Vbefore_change_functions)
1955 && NILP (current_buffer->overlays_before)
1956 && NILP (current_buffer->overlays_after))
1958 Lisp_Object elt;
1960 if (!NILP (combine_after_change_list)
1961 && current_buffer != XBUFFER (combine_after_change_buffer))
1962 Fcombine_after_change_execute ();
1964 elt = Fcons (make_number (charpos - BEG),
1965 Fcons (make_number (Z - (charpos - lendel + lenins)),
1966 Fcons (make_number (lenins - lendel), Qnil)));
1967 combine_after_change_list
1968 = Fcons (elt, combine_after_change_list);
1969 combine_after_change_buffer = Fcurrent_buffer ();
1971 return;
1974 if (!NILP (combine_after_change_list))
1975 Fcombine_after_change_execute ();
1977 if (!NILP (Vafter_change_functions))
1979 Lisp_Object args[4];
1980 Lisp_Object before_change_functions;
1981 Lisp_Object after_change_functions;
1982 struct gcpro gcpro1, gcpro2;
1984 /* "Bind" before-change-functions and after-change-functions
1985 to nil--but in a way that errors don't know about.
1986 That way, if there's an error in them, they will stay nil. */
1987 before_change_functions = Vbefore_change_functions;
1988 after_change_functions = Vafter_change_functions;
1989 Vbefore_change_functions = Qnil;
1990 Vafter_change_functions = Qnil;
1991 GCPRO2 (before_change_functions, after_change_functions);
1993 /* Actually run the hook functions. */
1994 args[0] = Qafter_change_functions;
1995 XSETFASTINT (args[1], charpos);
1996 XSETFASTINT (args[2], charpos + lenins);
1997 XSETFASTINT (args[3], lendel);
1998 run_hook_list_with_args (after_change_functions,
1999 4, args);
2001 /* "Unbind" the variables we "bound" to nil. */
2002 Vbefore_change_functions = before_change_functions;
2003 Vafter_change_functions = after_change_functions;
2004 UNGCPRO;
2007 if (!NILP (current_buffer->overlays_before)
2008 || !NILP (current_buffer->overlays_after))
2009 report_overlay_modification (make_number (charpos),
2010 make_number (charpos + lenins),
2012 make_number (charpos),
2013 make_number (charpos + lenins),
2014 make_number (lendel));
2016 /* After an insertion, call the text properties
2017 insert-behind-hooks or insert-in-front-hooks. */
2018 if (lendel == 0)
2019 report_interval_modification (make_number (charpos),
2020 make_number (charpos + lenins));
2023 Lisp_Object
2024 Fcombine_after_change_execute_1 (val)
2025 Lisp_Object val;
2027 Vcombine_after_change_calls = val;
2028 return val;
2031 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
2032 Scombine_after_change_execute, 0, 0, 0,
2033 "This function is for use internally in `combine-after-change-calls'.")
2036 int count = specpdl_ptr - specpdl;
2037 int beg, end, change;
2038 int begpos, endpos;
2039 Lisp_Object tail;
2041 if (NILP (combine_after_change_list))
2042 return Qnil;
2044 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
2046 Fset_buffer (combine_after_change_buffer);
2048 /* # chars unchanged at beginning of buffer. */
2049 beg = Z - BEG;
2050 /* # chars unchanged at end of buffer. */
2051 end = beg;
2052 /* Total amount of insertion (negative for deletion). */
2053 change = 0;
2055 /* Scan the various individual changes,
2056 accumulating the range info in BEG, END and CHANGE. */
2057 for (tail = combine_after_change_list; CONSP (tail);
2058 tail = XCDR (tail))
2060 Lisp_Object elt;
2061 int thisbeg, thisend, thischange;
2063 /* Extract the info from the next element. */
2064 elt = XCAR (tail);
2065 if (! CONSP (elt))
2066 continue;
2067 thisbeg = XINT (XCAR (elt));
2069 elt = XCDR (elt);
2070 if (! CONSP (elt))
2071 continue;
2072 thisend = XINT (XCAR (elt));
2074 elt = XCDR (elt);
2075 if (! CONSP (elt))
2076 continue;
2077 thischange = XINT (XCAR (elt));
2079 /* Merge this range into the accumulated range. */
2080 change += thischange;
2081 if (thisbeg < beg)
2082 beg = thisbeg;
2083 if (thisend < end)
2084 end = thisend;
2087 /* Get the current start and end positions of the range
2088 that was changed. */
2089 begpos = BEG + beg;
2090 endpos = Z - end;
2092 /* We are about to handle these, so discard them. */
2093 combine_after_change_list = Qnil;
2095 /* Now run the after-change functions for real.
2096 Turn off the flag that defers them. */
2097 record_unwind_protect (Fcombine_after_change_execute_1,
2098 Vcombine_after_change_calls);
2099 signal_after_change (begpos, endpos - begpos - change, endpos - begpos);
2100 update_compositions (begpos, endpos, CHECK_ALL);
2102 return unbind_to (count, Qnil);
2105 void
2106 syms_of_insdel ()
2108 staticpro (&combine_after_change_list);
2109 combine_after_change_list = Qnil;
2110 combine_after_change_buffer = Qnil;
2112 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag,
2113 "Non-nil means enable debugging checks for invalid marker positions.");
2114 check_markers_debug_flag = 0;
2115 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls,
2116 "Used internally by the `combine-after-change-calls' macro.");
2117 Vcombine_after_change_calls = Qnil;
2119 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks,
2120 "Non-nil means don't run any of the hooks that respond to buffer changes.\n\
2121 This affects `before-change-functions' and `after-change-functions',\n\
2122 as well as hooks attached to text properties and overlays.");
2123 inhibit_modification_hooks = 0;
2125 defsubr (&Scombine_after_change_execute);