1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86, 93, 94, 95, 97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "intervals.h"
28 #include "blockinput.h"
34 #define min(x, y) ((x) < (y) ? (x) : (y))
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, int, int));
42 static void adjust_markers_for_delete
P_ ((int, int, int, int));
43 static void adjust_markers_for_record_delete
P_ ((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.
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 /* Move gap to position CHARPOS.
68 Note that this can quit! */
74 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
77 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
78 Note that this can quit! */
81 move_gap_both (charpos
, bytepos
)
84 if (bytepos
< GPT_BYTE
)
85 gap_left (charpos
, bytepos
, 0);
86 else if (bytepos
> GPT_BYTE
)
87 gap_right (charpos
, bytepos
);
90 /* Move the gap to a position less than the current GPT.
91 BYTEPOS describes the new position as a byte position,
92 and CHARPOS is the corresponding char position.
93 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
96 gap_left (charpos
, bytepos
, newgap
)
97 register int charpos
, bytepos
;
100 register unsigned char *to
, *from
;
106 if (unchanged_modified
== MODIFF
107 && overlay_unchanged_modified
== OVERLAY_MODIFF
)
109 beg_unchanged
= charpos
- BEG
;
110 end_unchanged
= Z
- charpos
;
114 if (Z
- GPT
< end_unchanged
)
115 end_unchanged
= Z
- GPT
;
116 if (charpos
< beg_unchanged
)
117 beg_unchanged
= charpos
- BEG
;
126 /* Now copy the characters. To move the gap down,
127 copy characters up. */
131 /* I gets number of characters left to copy. */
132 i
= new_s1
- bytepos
;
135 /* If a quit is requested, stop copying now.
136 Change BYTEPOS to be where we have actually moved the gap to. */
140 charpos
= BYTE_TO_CHAR (bytepos
);
143 /* Move at most 32000 chars before checking again for a quit. */
148 /* bcopy is safe if the two areas of memory do not overlap
149 or on systems where bcopy is always safe for moving upward. */
150 && (BCOPY_UPWARD_SAFE
151 || to
- from
>= 128))
153 /* If overlap is not safe, avoid it by not moving too many
154 characters at once. */
155 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
170 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
171 BYTEPOS is where the loop above stopped, which may be what was specified
172 or may be where a quit was detected. */
173 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
176 if (bytepos
< charpos
)
178 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
182 /* Move the gap to a position greater than than the current GPT.
183 BYTEPOS describes the new position as a byte position,
184 and CHARPOS is the corresponding char position. */
187 gap_right (charpos
, bytepos
)
188 register int charpos
, bytepos
;
190 register unsigned char *to
, *from
;
194 if (unchanged_modified
== MODIFF
195 && overlay_unchanged_modified
== OVERLAY_MODIFF
)
197 beg_unchanged
= charpos
- BEG
;
198 end_unchanged
= Z
- charpos
;
202 if (Z
- charpos
- 1 < end_unchanged
)
203 end_unchanged
= Z
- charpos
;
204 if (GPT
- BEG
< beg_unchanged
)
205 beg_unchanged
= GPT
- BEG
;
213 /* Now copy the characters. To move the gap up,
214 copy characters down. */
218 /* I gets number of characters left to copy. */
219 i
= bytepos
- new_s1
;
222 /* If a quit is requested, stop copying now.
223 Change BYTEPOS to be where we have actually moved the gap to. */
227 charpos
= BYTE_TO_CHAR (bytepos
);
230 /* Move at most 32000 chars before checking again for a quit. */
235 /* bcopy is safe if the two areas of memory do not overlap
236 or on systems where bcopy is always safe for moving downward. */
237 && (BCOPY_DOWNWARD_SAFE
238 || from
- to
>= 128))
240 /* If overlap is not safe, avoid it by not moving too many
241 characters at once. */
242 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
257 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
261 if (bytepos
< charpos
)
263 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
267 /* Add AMOUNT to the byte position of every marker in the current buffer
268 whose current byte position is between FROM (exclusive) and TO (inclusive).
270 Also, any markers past the outside of that interval, in the direction
271 of adjustment, are first moved back to the near end of the interval
272 and then adjusted by AMOUNT.
274 When the latter adjustment is done, if AMOUNT is negative,
275 we record the adjustment for undo. (This case happens only for
278 The markers' character positions are not altered,
279 because gap motion does not affect character positions. */
281 int adjust_markers_test
;
284 adjust_markers_gap_motion (from
, to
, amount
)
285 register int from
, to
, amount
;
287 /* Now that a marker has a bytepos, not counting the gap,
288 nothing needs to be done here. */
291 register struct Lisp_Marker
*m
;
294 marker
= BUF_MARKERS (current_buffer
);
296 while (!NILP (marker
))
298 m
= XMARKER (marker
);
302 if (mpos
> to
&& mpos
< to
+ amount
)
304 if (adjust_markers_test
)
311 /* Here's the case where a marker is inside text being deleted.
312 AMOUNT can be negative for gap motion, too,
313 but then this range contains no markers. */
314 if (mpos
> from
+ amount
&& mpos
<= from
)
316 if (adjust_markers_test
)
318 mpos
= from
+ amount
;
321 if (mpos
> from
&& mpos
<= to
)
329 /* Adjust all markers for a deletion
330 whose range in bytes is FROM_BYTE to TO_BYTE.
331 The range in charpos is FROM to TO.
333 This function assumes that the gap is adjacent to
334 or inside of the range being deleted. */
337 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
338 register int from
, from_byte
, to
, to_byte
;
341 register struct Lisp_Marker
*m
;
342 register int charpos
;
344 marker
= BUF_MARKERS (current_buffer
);
346 while (!NILP (marker
))
348 m
= XMARKER (marker
);
349 charpos
= m
->charpos
;
354 /* If the marker is after the deletion,
355 relocate by number of chars / bytes deleted. */
358 m
->charpos
-= to
- from
;
359 m
->bytepos
-= to_byte
- from_byte
;
362 /* Here's the case where a marker is inside text being deleted. */
363 else if (charpos
> from
)
365 record_marker_adjustment (marker
, from
- charpos
);
367 m
->bytepos
= from_byte
;
374 /* Adjust all markers for calling record_delete for combining bytes.
375 whose range in bytes is FROM_BYTE to TO_BYTE.
376 The range in charpos is FROM to TO. */
379 adjust_markers_for_record_delete (from
, from_byte
, to
, to_byte
)
380 register int from
, from_byte
, to
, to_byte
;
383 register struct Lisp_Marker
*m
;
384 register int charpos
;
386 marker
= BUF_MARKERS (current_buffer
);
388 while (!NILP (marker
))
390 m
= XMARKER (marker
);
391 charpos
= m
->charpos
;
393 /* If the marker is after the deletion,
394 relocate by number of chars / bytes deleted. */
397 /* Here's the case where a marker is inside text being deleted. */
398 else if (charpos
> from
)
399 record_marker_adjustment (marker
, from
- charpos
);
405 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
406 to TO / TO_BYTE. We have to relocate the charpos of every marker
407 that points after the insertion (but not their bytepos).
409 COMBINED_BEFORE_BYTES is the number of bytes at the start of the insertion
410 that combine into one character with the text before the insertion.
411 COMBINED_AFTER_BYTES is the number of bytes after the insertion
412 that combine into one character with the last inserted bytes.
414 When a marker points at the insertion point,
415 we advance it if either its insertion-type is t
416 or BEFORE_MARKERS is true. */
419 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
,
420 combined_before_bytes
, combined_after_bytes
,
422 register int from
, from_byte
, to
, to_byte
;
423 int combined_before_bytes
, combined_after_bytes
, before_markers
;
427 int nchars
= to
- from
;
428 int nbytes
= to_byte
- from_byte
;
430 marker
= BUF_MARKERS (current_buffer
);
432 while (!NILP (marker
))
434 register struct Lisp_Marker
*m
= XMARKER (marker
);
436 /* In a single-byte buffer, a marker's two positions must be equal.
437 (If this insertion is going to combine characters, Z will
438 become different from Z_BYTE, but they might be the same now.
439 If so, the two OLD positions of the marker should be equal.) */
442 if (m
->charpos
!= m
->bytepos
)
446 if (m
->bytepos
== from_byte
)
448 if (m
->insertion_type
|| before_markers
)
450 m
->bytepos
+= nbytes
+ combined_after_bytes
;
451 m
->charpos
+= nchars
+ !!combined_after_bytes
;
452 /* Point the marker before the combined character,
453 so that undoing the insertion puts it back where it was. */
454 if (combined_after_bytes
)
455 DEC_BOTH (m
->charpos
, m
->bytepos
);
456 if (m
->insertion_type
)
459 else if (combined_before_bytes
)
461 /* This marker doesn't "need relocation",
462 but don't leave it pointing in the middle of a character.
463 Point the marker after the combined character,
464 so that undoing the insertion puts it back where it was. */
466 /* Here we depend on the fact that the gap is after
467 all of the combining bytes that we are going to skip over. */
468 DEC_BOTH (m
->charpos
, m
->bytepos
);
469 INC_BOTH (m
->charpos
, m
->bytepos
);
472 /* If a marker was pointing into the combining bytes
473 after the insertion, don't leave it there
474 in the middle of a character. */
475 else if (combined_after_bytes
&& m
->bytepos
>= from_byte
476 && m
->bytepos
< from_byte
+ combined_after_bytes
)
478 /* Put it after the combining bytes. */
479 m
->bytepos
= to_byte
+ combined_after_bytes
;
481 /* Now move it back before the combined character,
482 so that undoing the insertion will put it where it was. */
483 DEC_BOTH (m
->charpos
, m
->bytepos
);
485 else if (m
->bytepos
> from_byte
)
487 m
->bytepos
+= nbytes
;
488 m
->charpos
+= nchars
;
494 /* Adjusting only markers whose insertion-type is t may result in
495 disordered overlays in the slot `overlays_before'. */
497 fix_overlays_before (current_buffer
, from
, to
);
500 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
502 This is used only when the value of point changes due to an insert
503 or delete; it does not represent a conceptual change in point as a
504 marker. In particular, point is not crossing any interval
505 boundaries, so there's no need to use the usual SET_PT macro. In
506 fact it would be incorrect to do so, because either the old or the
507 new value of point is out of sync with the current set of
511 adjust_point (nchars
, nbytes
)
514 BUF_PT (current_buffer
) += nchars
;
515 BUF_PT_BYTE (current_buffer
) += nbytes
;
517 /* In a single-byte buffer, the two positions must be equal. */
523 /* Make the gap NBYTES_ADDED bytes longer. */
526 make_gap (nbytes_added
)
529 unsigned char *result
;
532 int real_gap_loc_byte
;
535 /* If we have to get more space, get enough to last a while. */
536 nbytes_added
+= 2000;
538 /* Don't allow a buffer size that won't fit in an int
539 even if it will fit in a Lisp integer.
540 That won't work because so many places use `int'. */
542 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
+ nbytes_added
543 >= ((unsigned) 1 << (min (BITS_PER_INT
, VALBITS
) - 1)))
544 error ("Buffer exceeds maximum size");
547 /* We allocate extra 1-byte `\0' at the tail for anchoring a search. */
548 result
= BUFFER_REALLOC (BEG_ADDR
, (Z_BYTE
- BEG_BYTE
549 + GAP_SIZE
+ nbytes_added
+ 1));
557 /* We can't unblock until the new address is properly stored. */
561 /* Prevent quitting in move_gap. */
566 real_gap_loc_byte
= GPT_BYTE
;
567 old_gap_size
= GAP_SIZE
;
569 /* Call the newly allocated space a gap at the end of the whole space. */
571 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
572 GAP_SIZE
= nbytes_added
;
574 /* Move the new gap down to be consecutive with the end of the old one.
575 This adjusts the markers properly too. */
576 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
578 /* Now combine the two into one large gap. */
579 GAP_SIZE
+= old_gap_size
;
581 GPT_BYTE
= real_gap_loc_byte
;
589 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
590 FROM_MULTIBYTE says whether the incoming text is multibyte.
591 TO_MULTIBYTE says whether to store the text as multibyte.
592 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
594 Return the number of bytes stored at TO_ADDR. */
597 copy_text (from_addr
, to_addr
, nbytes
,
598 from_multibyte
, to_multibyte
)
599 unsigned char *from_addr
;
600 unsigned char *to_addr
;
602 int from_multibyte
, to_multibyte
;
604 if (from_multibyte
== to_multibyte
)
606 bcopy (from_addr
, to_addr
, nbytes
);
609 else if (from_multibyte
)
612 int bytes_left
= nbytes
;
614 /* Convert multibyte to single byte. */
615 while (bytes_left
> 0)
618 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
619 *to_addr
++ = SINGLE_BYTE_CHAR_P (c
) ? c
: (c
& 0177) + 0200;
620 from_addr
+= thislen
;
628 unsigned char *initial_to_addr
= to_addr
;
630 /* Convert single-byte to multibyte. */
633 int c
= *from_addr
++;
634 unsigned char workbuf
[4], *str
;
637 if (c
>= 0240 && c
< 0400)
639 c
= unibyte_char_to_multibyte (c
);
640 len
= CHAR_STRING (c
, workbuf
, str
);
641 bcopy (str
, to_addr
, len
);
646 /* Special case for speed. */
647 *to_addr
++ = c
, nbytes
--;
649 return to_addr
- initial_to_addr
;
653 /* Return the number of bytes it would take
654 to convert some single-byte text to multibyte.
655 The single-byte text consists of NBYTES bytes at PTR. */
658 count_size_as_multibyte (ptr
, nbytes
)
663 int outgoing_nbytes
= 0;
665 for (i
= 0; i
< nbytes
; i
++)
667 unsigned int c
= *ptr
++;
673 c
= unibyte_char_to_multibyte (c
);
674 outgoing_nbytes
+= XINT (Fchar_bytes (make_number (c
)));
678 return outgoing_nbytes
;
681 /* Insert a string of specified length before point.
682 This function judges multibyteness based on
683 enable_multibyte_characters in the current buffer;
684 it never converts between single-byte and multibyte.
686 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
687 prepare_to_modify_buffer could relocate the text. */
690 insert (string
, nbytes
)
691 register unsigned char *string
;
697 insert_1 (string
, nbytes
, 0, 1, 0);
698 signal_after_change (opoint
, 0, PT
- opoint
);
702 /* Likewise, but inherit text properties from neighboring characters. */
705 insert_and_inherit (string
, nbytes
)
706 register unsigned char *string
;
712 insert_1 (string
, nbytes
, 1, 1, 0);
713 signal_after_change (opoint
, 0, PT
- opoint
);
717 /* Insert the character C before point. Do not inherit text properties. */
723 unsigned char workbuf
[4], *str
;
726 if (! NILP (current_buffer
->enable_multibyte_characters
))
727 len
= CHAR_STRING (c
, workbuf
, str
);
738 /* Insert the null-terminated string S before point. */
744 insert (s
, strlen (s
));
747 /* Like `insert' except that all markers pointing at the place where
748 the insertion happens are adjusted to point after it.
749 Don't use this function to insert part of a Lisp string,
750 since gc could happen and relocate it. */
753 insert_before_markers (string
, nbytes
)
754 unsigned char *string
;
761 insert_1 (string
, nbytes
, 0, 1, 1);
762 signal_after_change (opoint
, 0, PT
- opoint
);
766 /* Likewise, but inherit text properties from neighboring characters. */
769 insert_before_markers_and_inherit (string
, nbytes
)
770 unsigned char *string
;
777 insert_1 (string
, nbytes
, 1, 1, 1);
778 signal_after_change (opoint
, 0, PT
- opoint
);
782 /* Subroutine used by the insert functions above. */
785 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
786 register unsigned char *string
;
788 int inherit
, prepare
, before_markers
;
790 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
791 inherit
, prepare
, before_markers
);
794 /* See if the bytes before POS/POS_BYTE combine with bytes
795 at the start of STRING to form a single character.
796 If so, return the number of bytes at the start of STRING
797 which combine in this way. Otherwise, return 0. */
800 count_combining_before (string
, length
, pos
, pos_byte
)
801 unsigned char *string
;
805 int opos
= pos
, opos_byte
= pos_byte
;
807 unsigned char *p
= string
;
809 if (NILP (current_buffer
->enable_multibyte_characters
))
811 if (length
== 0 || CHAR_HEAD_P (*string
))
815 c
= FETCH_BYTE (pos_byte
- 1);
816 if (ASCII_BYTE_P (c
))
818 DEC_BOTH (pos
, pos_byte
);
819 c
= FETCH_BYTE (pos_byte
);
820 if (! BASE_LEADING_CODE_P (c
))
823 /* We have a combination situation.
824 Count the bytes at STRING that will combine. */
825 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
831 /* See if the bytes after POS/POS_BYTE combine with bytes
832 at the end of STRING to form a single character.
833 If so, return the number of bytes after POS/POS_BYTE
834 which combine in this way. Otherwise, return 0. */
837 count_combining_after (string
, length
, pos
, pos_byte
)
838 unsigned char *string
;
842 int opos
= pos
, opos_byte
= pos_byte
;
846 if (NILP (current_buffer
->enable_multibyte_characters
))
848 if (length
== 0 || ASCII_BYTE_P (string
[length
- 1]))
851 while (i
> 0 && ! CHAR_HEAD_P (string
[i
]))
855 if (! BASE_LEADING_CODE_P (string
[i
]))
860 c
= FETCH_BYTE (pos_byte
);
863 while (pos_byte
< ZV_BYTE
)
865 c
= FETCH_BYTE (pos_byte
);
871 return pos_byte
- opos_byte
;
874 /* Adjust the position TARGET/TARGET_BYTE for the combining of NBYTES
875 following the position POS/POS_BYTE to the character preceding POS.
876 If TARGET is after POS+NBYTES, we only have to adjust the character
877 position TARGET, else, if TARGET is after POS, we have to adjust
878 both the character position TARGET and the byte position
879 TARGET_BYTE, else we don't have to do any adjustment. */
881 #define ADJUST_CHAR_POS(target, target_byte) \
883 if (target > pos + nbytes) \
885 else if (target >= pos) \
888 target_byte = pos_byte + nbytes; \
892 /* Combine NBYTES stray trailing-codes, which were formerly separate
893 characters, with the preceding character. These bytes
894 are located after position POS / POS_BYTE, and the preceding character
895 is located just before that position. */
898 combine_bytes (pos
, pos_byte
, nbytes
)
899 int pos
, pos_byte
, nbytes
;
901 /* Adjust all markers. */
902 adjust_markers_for_delete (pos
, pos_byte
, pos
+ nbytes
, pos_byte
);
904 adjust_overlays_for_delete (pos
, nbytes
);
906 ADJUST_CHAR_POS (BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
907 ADJUST_CHAR_POS (GPT
, GPT_BYTE
);
908 ADJUST_CHAR_POS (Z
, Z_BYTE
);
909 ADJUST_CHAR_POS (ZV
, ZV_BYTE
);
911 if (BUF_INTERVALS (current_buffer
) != 0)
912 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
913 offset_intervals (current_buffer
, pos
, - nbytes
);
916 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
917 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
918 are the same as in insert_1. */
921 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
922 register unsigned char *string
;
923 register int nchars
, nbytes
;
924 int inherit
, prepare
, before_markers
;
926 register Lisp_Object temp
;
927 int combined_before_bytes
, combined_after_bytes
;
929 if (NILP (current_buffer
->enable_multibyte_characters
))
933 move_gap_both (PT
, PT_BYTE
);
934 if (GAP_SIZE
< nbytes
)
935 make_gap (nbytes
- GAP_SIZE
);
938 prepare_to_modify_buffer (PT
, PT
, NULL
);
940 combined_before_bytes
941 = count_combining_before (string
, nbytes
, PT
, PT_BYTE
);
943 = count_combining_after (string
, nbytes
, PT
, PT_BYTE
);
945 /* Record deletion of the surrounding text that combines with
946 the insertion. This, together with recording the insertion,
947 will add up to the right stuff in the undo list.
949 But there is no need to actually delete the combining bytes
950 from the buffer and reinsert them. */
952 if (combined_after_bytes
)
954 adjust_markers_for_record_delete (PT
, PT_BYTE
,
955 PT
+ combined_after_bytes
,
956 PT_BYTE
+ combined_after_bytes
);
957 record_delete (PT
, combined_after_bytes
);
960 if (combined_before_bytes
)
962 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
964 record_delete (PT
- 1, 1);
967 record_insert (PT
- !!combined_before_bytes
,
968 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
971 bcopy (string
, GPT_ADDR
, nbytes
);
974 /* When we have combining at the end of the insertion,
975 this is the character position before the combined character. */
982 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
984 if (combined_after_bytes
)
985 move_gap_both (GPT
+ combined_after_bytes
,
986 GPT_BYTE
+ combined_after_bytes
);
991 adjust_overlays_for_insert (PT
, nchars
);
992 adjust_markers_for_insert (PT
, PT_BYTE
,
993 PT
+ nchars
, PT_BYTE
+ nbytes
,
994 combined_before_bytes
, combined_after_bytes
,
997 #ifdef USE_TEXT_PROPERTIES
998 if (BUF_INTERVALS (current_buffer
) != 0)
999 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1000 offset_intervals (current_buffer
, PT
, nchars
);
1002 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1003 Fset_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1008 int pos
= PT
, pos_byte
= PT_BYTE
;
1010 adjust_point (nchars
+ combined_after_bytes
,
1011 nbytes
+ combined_after_bytes
);
1013 if (combined_after_bytes
)
1014 combine_bytes (pos
+ nchars
, pos_byte
+ nbytes
, combined_after_bytes
);
1016 if (combined_before_bytes
)
1017 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1021 /* Insert the part of the text of STRING, a Lisp object assumed to be
1022 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1023 starting at position POS / POS_BYTE. If the text of STRING has properties,
1024 copy them into the buffer.
1026 It does not work to use `insert' for this, because a GC could happen
1027 before we bcopy the stuff into the buffer, and relocate the string
1028 without insert noticing. */
1031 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1033 register int pos
, pos_byte
, length
, length_byte
;
1039 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1041 signal_after_change (opoint
, 0, PT
- opoint
);
1045 /* Like `insert_from_string' except that all markers pointing
1046 at the place where the insertion happens are adjusted to point after it. */
1049 insert_from_string_before_markers (string
, pos
, pos_byte
,
1050 length
, length_byte
, inherit
)
1052 register int pos
, pos_byte
, length
, length_byte
;
1058 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1060 signal_after_change (opoint
, 0, PT
- opoint
);
1064 /* Subroutine of the insertion functions above. */
1067 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1068 inherit
, before_markers
)
1070 register int pos
, pos_byte
, nchars
, nbytes
;
1071 int inherit
, before_markers
;
1073 register Lisp_Object temp
;
1074 struct gcpro gcpro1
;
1075 int outgoing_nbytes
= nbytes
;
1076 int combined_before_bytes
, combined_after_bytes
;
1077 int adjusted_nchars
;
1080 /* Make OUTGOING_NBYTES describe the text
1081 as it will be inserted in this buffer. */
1083 if (NILP (current_buffer
->enable_multibyte_characters
))
1084 outgoing_nbytes
= nchars
;
1085 else if (nchars
== nbytes
)
1087 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1090 /* Make sure point-max won't overflow after this insertion. */
1091 XSETINT (temp
, outgoing_nbytes
+ Z
);
1092 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1093 error ("Maximum buffer size exceeded");
1096 prepare_to_modify_buffer (PT
, PT
, NULL
);
1099 move_gap_both (PT
, PT_BYTE
);
1100 if (GAP_SIZE
< nbytes
)
1101 make_gap (outgoing_nbytes
- GAP_SIZE
);
1104 /* Copy the string text into the buffer, perhaps converting
1105 between single-byte and multibyte. */
1106 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1107 /* If these are equal, it is a single-byte string.
1108 Its chars are either ASCII, in which case copy_text
1109 won't change it, or single-byte non-ASCII chars,
1110 that need to be changed. */
1112 ! NILP (current_buffer
->enable_multibyte_characters
));
1114 /* We have copied text into the gap, but we have not altered
1115 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1116 to these functions and get the same results as we would
1117 have got earlier on. Meanwhile, PT_ADDR does point to
1118 the text that has been stored by copy_text. */
1120 combined_before_bytes
1121 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1122 combined_after_bytes
1123 = count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1125 /* Record deletion of the surrounding text that combines with
1126 the insertion. This, together with recording the insertion,
1127 will add up to the right stuff in the undo list.
1129 But there is no need to actually delete the combining bytes
1130 from the buffer and reinsert them. */
1132 if (combined_after_bytes
)
1134 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1135 PT
+ combined_after_bytes
,
1136 PT_BYTE
+ combined_after_bytes
);
1137 record_delete (PT
, combined_after_bytes
);
1140 if (combined_before_bytes
)
1142 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1144 record_delete (PT
- 1, 1);
1147 record_insert (PT
- !!combined_before_bytes
,
1148 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1151 GAP_SIZE
-= outgoing_nbytes
;
1155 GPT_BYTE
+= outgoing_nbytes
;
1156 ZV_BYTE
+= outgoing_nbytes
;
1157 Z_BYTE
+= outgoing_nbytes
;
1158 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1160 if (combined_after_bytes
)
1161 move_gap_both (GPT
+ combined_after_bytes
,
1162 GPT_BYTE
+ combined_after_bytes
);
1167 adjust_overlays_for_insert (PT
, nchars
);
1168 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1169 PT_BYTE
+ outgoing_nbytes
,
1170 combined_before_bytes
, combined_after_bytes
,
1173 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1174 offset_intervals (current_buffer
, PT
, nchars
);
1176 intervals
= XSTRING (string
)->intervals
;
1177 /* Get the intervals for the part of the string we are inserting--
1178 not including the combined-before bytes. */
1179 if (nbytes
< XSTRING (string
)->size_byte
)
1180 intervals
= copy_intervals (intervals
, pos
, nchars
);
1182 /* Insert those intervals. */
1183 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1184 current_buffer
, inherit
);
1187 int pos
= PT
, pos_byte
= PT_BYTE
;
1189 adjust_point (nchars
+ combined_after_bytes
,
1190 outgoing_nbytes
+ combined_after_bytes
);
1192 if (combined_after_bytes
)
1193 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1194 combined_after_bytes
);
1196 if (combined_before_bytes
)
1197 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1201 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1202 current buffer. If the text in BUF has properties, they are absorbed
1203 into the current buffer.
1205 It does not work to use `insert' for this, because a malloc could happen
1206 and relocate BUF's text before the bcopy happens. */
1209 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1211 int charpos
, nchars
;
1218 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1219 signal_after_change (opoint
, 0, PT
- opoint
);
1224 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1229 register Lisp_Object temp
;
1231 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1232 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1233 int incoming_nbytes
= to_byte
- from_byte
;
1234 int outgoing_nbytes
= incoming_nbytes
;
1235 int combined_before_bytes
, combined_after_bytes
;
1236 int adjusted_nchars
;
1239 /* Make OUTGOING_NBYTES describe the text
1240 as it will be inserted in this buffer. */
1242 if (NILP (current_buffer
->enable_multibyte_characters
))
1243 outgoing_nbytes
= nchars
;
1244 else if (NILP (buf
->enable_multibyte_characters
))
1246 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1249 /* Make sure point-max won't overflow after this insertion. */
1250 XSETINT (temp
, outgoing_nbytes
+ Z
);
1251 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1252 error ("Maximum buffer size exceeded");
1254 prepare_to_modify_buffer (PT
, PT
, NULL
);
1257 move_gap_both (PT
, PT_BYTE
);
1258 if (GAP_SIZE
< outgoing_nbytes
)
1259 make_gap (outgoing_nbytes
- GAP_SIZE
);
1261 if (from
< BUF_GPT (buf
))
1263 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1264 if (chunk
> incoming_nbytes
)
1265 chunk
= incoming_nbytes
;
1266 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1268 ! NILP (buf
->enable_multibyte_characters
),
1269 ! NILP (current_buffer
->enable_multibyte_characters
));
1273 if (chunk
< incoming_nbytes
)
1274 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1275 GPT_ADDR
+ chunk
, incoming_nbytes
- chunk
,
1276 ! NILP (buf
->enable_multibyte_characters
),
1277 ! NILP (current_buffer
->enable_multibyte_characters
));
1279 /* We have copied text into the gap, but we have not altered
1280 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1281 to these functions and get the same results as we would
1282 have got earlier on. Meanwhile, GPT_ADDR does point to
1283 the text that has been stored by copy_text. */
1284 combined_before_bytes
1285 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1286 combined_after_bytes
1287 = count_combining_after (GPT_ADDR
, outgoing_nbytes
,
1290 /* Record deletion of the surrounding text that combines with
1291 the insertion. This, together with recording the insertion,
1292 will add up to the right stuff in the undo list.
1294 But there is no need to actually delete the combining bytes
1295 from the buffer and reinsert them. */
1297 if (combined_after_bytes
)
1299 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1300 PT
+ combined_after_bytes
,
1301 PT_BYTE
+ combined_after_bytes
);
1302 record_delete (PT
, combined_after_bytes
);
1305 if (combined_before_bytes
)
1307 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1309 record_delete (PT
- 1, 1);
1312 record_insert (PT
- !!combined_before_bytes
,
1313 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1316 GAP_SIZE
-= outgoing_nbytes
;
1320 GPT_BYTE
+= outgoing_nbytes
;
1321 ZV_BYTE
+= outgoing_nbytes
;
1322 Z_BYTE
+= outgoing_nbytes
;
1323 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1325 if (combined_after_bytes
)
1326 move_gap_both (GPT
+ combined_after_bytes
,
1327 GPT_BYTE
+ combined_after_bytes
);
1332 adjust_overlays_for_insert (PT
, nchars
);
1333 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1334 PT_BYTE
+ outgoing_nbytes
,
1335 combined_before_bytes
, combined_after_bytes
, 0);
1337 #ifdef USE_TEXT_PROPERTIES
1338 if (BUF_INTERVALS (current_buffer
) != 0)
1339 offset_intervals (current_buffer
, PT
, nchars
);
1342 /* Get the intervals for the part of the string we are inserting--
1343 not including the combined-before bytes. */
1344 intervals
= BUF_INTERVALS (buf
);
1345 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1346 intervals
= copy_intervals (intervals
, from
, nchars
);
1348 /* Insert those intervals. */
1349 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1352 int pos
= PT
, pos_byte
= PT_BYTE
;
1354 adjust_point (nchars
+ combined_after_bytes
,
1355 outgoing_nbytes
+ combined_after_bytes
);
1357 if (combined_after_bytes
)
1358 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1359 combined_after_bytes
);
1361 if (combined_before_bytes
)
1362 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1366 /* This function should be called after moving gap to FROM and before
1367 altering text between FROM and TO. This adjusts various position
1368 keepers and markers as if the text is deleted. Don't forget to
1369 call adjust_after_replace after you actually alter the text. */
1372 adjust_before_replace (from
, from_byte
, to
, to_byte
)
1373 int from
, from_byte
, to
, to_byte
;
1375 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1376 record_delete (from
, to
- from
);
1377 adjust_overlays_for_delete (from
, to
- from
);
1380 /* This function should be called after altering the text between FROM
1381 and TO to a new text of LEN chars (LEN_BYTE bytes), but before
1382 making the text a buffer contents. It exists just after GPT_ADDR. */
1385 adjust_after_replace (from
, from_byte
, to
, to_byte
, len
, len_byte
, replace
)
1386 int from
, from_byte
, to
, to_byte
, len
, len_byte
, replace
;
1388 int combined_before_bytes
1389 = count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
);
1390 int combined_after_bytes
1391 = count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
);
1393 if (combined_after_bytes
)
1395 adjust_markers_for_record_delete (from
, from_byte
,
1396 from
+ combined_after_bytes
,
1397 from_byte
+ combined_after_bytes
);
1398 record_delete (from
, combined_after_bytes
);
1401 if (combined_before_bytes
)
1403 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1405 record_delete (from
- 1, 1);
1408 /* Update various buffer positions for the new text. */
1409 GAP_SIZE
-= len_byte
;
1411 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1412 GPT
+= len
; GPT_BYTE
+= len_byte
;
1413 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1415 if (combined_after_bytes
)
1416 move_gap_both (GPT
+ combined_after_bytes
,
1417 GPT_BYTE
+ combined_after_bytes
);
1419 record_insert (from
- !!combined_before_bytes
,
1420 len
- combined_before_bytes
+ !!combined_before_bytes
);
1421 adjust_overlays_for_insert (from
, len
);
1422 adjust_markers_for_insert (from
, from_byte
,
1423 from
+ len
, from_byte
+ len_byte
,
1424 combined_before_bytes
, combined_after_bytes
, 0);
1425 #ifdef USE_TEXT_PROPERTIES
1426 if (BUF_INTERVALS (current_buffer
) != 0)
1427 /* REPLACE zero means that we have not yet adjusted the interval
1428 tree for the text between FROM and TO, thus, we must treat the
1429 new text as a newly inserted text, not as a replacement of
1431 offset_intervals (current_buffer
, from
, len
- (replace
? to
- from
: 0));
1435 int pos
= PT
, pos_byte
= PT_BYTE
;
1438 adjust_point (len
- (to
- from
) + combined_after_bytes
,
1439 len_byte
- (to_byte
- from_byte
) + combined_after_bytes
);
1440 else if (from
== PT
&& combined_before_bytes
)
1441 adjust_point (0, combined_before_bytes
);
1443 if (combined_after_bytes
)
1444 combine_bytes (from
+ len
, from_byte
+ len_byte
, combined_after_bytes
);
1446 if (combined_before_bytes
)
1447 combine_bytes (from
, from_byte
, combined_before_bytes
);
1451 evaporate_overlays (from
);
1455 /* Replace the text from character positions FROM to TO with NEW,
1456 If PREPARE is nonzero, call prepare_to_modify_buffer.
1457 If INHERIT, the newly inserted text should inherit text properties
1458 from the surrounding non-deleted text. */
1460 /* Note that this does not yet handle markers quite right.
1461 Also it needs to record a single undo-entry that does a replacement
1462 rather than a separate delete and insert.
1463 That way, undo will also handle markers properly. */
1466 replace_range (from
, to
, new, prepare
, inherit
)
1468 int from
, to
, prepare
, inherit
;
1470 int inschars
= XSTRING (new)->size
;
1471 int insbytes
= XSTRING (new)->size_byte
;
1472 int from_byte
, to_byte
;
1473 int nbytes_del
, nchars_del
;
1474 register Lisp_Object temp
;
1475 struct gcpro gcpro1
;
1476 int combined_before_bytes
, combined_after_bytes
;
1477 int adjusted_inschars
;
1479 int outgoing_insbytes
= insbytes
;
1485 int range_length
= to
- from
;
1486 prepare_to_modify_buffer (from
, to
, &from
);
1487 to
= from
+ range_length
;
1492 /* Make args be valid */
1498 from_byte
= CHAR_TO_BYTE (from
);
1499 to_byte
= CHAR_TO_BYTE (to
);
1501 nchars_del
= to
- from
;
1502 nbytes_del
= to_byte
- from_byte
;
1504 if (nbytes_del
<= 0 && insbytes
== 0)
1507 /* Make OUTGOING_INSBYTES describe the text
1508 as it will be inserted in this buffer. */
1510 if (NILP (current_buffer
->enable_multibyte_characters
))
1511 outgoing_insbytes
= inschars
;
1512 else if (inschars
== insbytes
)
1514 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1516 /* Make sure point-max won't overflow after this insertion. */
1517 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1518 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1519 error ("Maximum buffer size exceeded");
1523 /* Make sure the gap is somewhere in or next to what we are deleting. */
1525 gap_right (from
, from_byte
);
1527 gap_left (to
, to_byte
, 0);
1529 /* Relocate all markers pointing into the new, larger gap
1530 to point at the end of the text before the gap.
1531 Do this before recording the deletion,
1532 so that undo handles this after reinserting the text. */
1533 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1535 record_delete (from
, nchars_del
);
1537 GAP_SIZE
+= nbytes_del
;
1540 ZV_BYTE
-= nbytes_del
;
1541 Z_BYTE
-= nbytes_del
;
1543 GPT_BYTE
= from_byte
;
1544 *(GPT_ADDR
) = 0; /* Put an anchor. */
1549 if (GPT
- BEG
< beg_unchanged
)
1550 beg_unchanged
= GPT
- BEG
;
1551 if (Z
- GPT
< end_unchanged
)
1552 end_unchanged
= Z
- GPT
;
1554 if (GAP_SIZE
< insbytes
)
1555 make_gap (insbytes
- GAP_SIZE
);
1557 /* Copy the string text into the buffer, perhaps converting
1558 between single-byte and multibyte. */
1559 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1560 /* If these are equal, it is a single-byte string.
1561 Its chars are either ASCII, in which case copy_text
1562 won't change it, or single-byte non-ASCII chars,
1563 that need to be changed. */
1564 inschars
!= insbytes
,
1565 ! NILP (current_buffer
->enable_multibyte_characters
));
1567 /* We have copied text into the gap, but we have not altered
1568 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1569 to these functions and get the same results as we would
1570 have got earlier on. Meanwhile, GPT_ADDR does point to
1571 the text that has been stored by copy_text. */
1573 combined_before_bytes
1574 = count_combining_before (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1575 combined_after_bytes
1576 = count_combining_after (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1578 /* Record deletion of the surrounding text that combines with
1579 the insertion. This, together with recording the insertion,
1580 will add up to the right stuff in the undo list.
1582 But there is no need to actually delete the combining bytes
1583 from the buffer and reinsert them. */
1585 if (combined_after_bytes
)
1587 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1588 PT
+ combined_after_bytes
,
1589 PT_BYTE
+ combined_after_bytes
);
1590 record_delete (PT
, combined_after_bytes
);
1593 if (combined_before_bytes
)
1595 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1597 record_delete (PT
- 1, 1);
1600 record_insert (PT
- !!combined_before_bytes
,
1601 inschars
- combined_before_bytes
+ !!combined_before_bytes
);
1603 GAP_SIZE
-= outgoing_insbytes
;
1607 GPT_BYTE
+= outgoing_insbytes
;
1608 ZV_BYTE
+= outgoing_insbytes
;
1609 Z_BYTE
+= outgoing_insbytes
;
1610 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1612 if (combined_after_bytes
)
1613 move_gap_both (GPT
+ combined_after_bytes
,
1614 GPT_BYTE
+ combined_after_bytes
);
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
);
1623 adjust_markers_for_insert (from
, from_byte
,
1624 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1625 combined_before_bytes
, combined_after_bytes
, 0);
1627 #ifdef USE_TEXT_PROPERTIES
1628 offset_intervals (current_buffer
, PT
, inschars
- nchars_del
);
1630 /* Get the intervals for the part of the string we are inserting--
1631 not including the combined-before bytes. */
1632 intervals
= XSTRING (new)->intervals
;
1633 /* Insert those intervals. */
1634 graft_intervals_into_buffer (intervals
, from
, inschars
,
1635 current_buffer
, inherit
);
1638 /* Relocate point as if it were a marker. */
1640 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)
1641 + combined_after_bytes
),
1642 (from_byte
+ outgoing_insbytes
1643 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)
1644 + combined_after_bytes
));
1646 if (combined_after_bytes
)
1647 combine_bytes (from
+ inschars
, from_byte
+ outgoing_insbytes
,
1648 combined_after_bytes
);
1650 if (combined_before_bytes
)
1651 combine_bytes (from
, from_byte
, combined_before_bytes
);
1653 if (outgoing_insbytes
== 0)
1654 evaporate_overlays (from
);
1659 signal_after_change (from
, nchars_del
, PT
- from
);
1662 /* Delete characters in current buffer
1663 from FROM up to (but not including) TO.
1664 If TO comes before FROM, we delete nothing. */
1667 del_range (from
, to
)
1668 register int from
, to
;
1670 del_range_1 (from
, to
, 1);
1673 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer. */
1676 del_range_1 (from
, to
, prepare
)
1677 int from
, to
, prepare
;
1679 int from_byte
, to_byte
;
1681 /* Make args be valid */
1692 int range_length
= to
- from
;
1693 prepare_to_modify_buffer (from
, to
, &from
);
1694 to
= from
+ range_length
;
1697 from_byte
= CHAR_TO_BYTE (from
);
1698 to_byte
= CHAR_TO_BYTE (to
);
1700 del_range_2 (from
, from_byte
, to
, to_byte
);
1703 /* Like del_range_1 but args are byte positions, not char positions. */
1706 del_range_byte (from_byte
, to_byte
, prepare
)
1707 int from_byte
, to_byte
, prepare
;
1711 /* Make args be valid */
1712 if (from_byte
< BEGV_BYTE
)
1713 from_byte
= BEGV_BYTE
;
1714 if (to_byte
> ZV_BYTE
)
1717 if (to_byte
<= from_byte
)
1720 from
= BYTE_TO_CHAR (from_byte
);
1721 to
= BYTE_TO_CHAR (to_byte
);
1725 int old_from
= from
, old_to
= Z
- to
;
1726 int range_length
= to
- from
;
1727 prepare_to_modify_buffer (from
, to
, &from
);
1728 to
= from
+ range_length
;
1730 if (old_from
!= from
)
1731 from_byte
= CHAR_TO_BYTE (from
);
1732 if (old_to
== Z
- to
)
1733 to_byte
= CHAR_TO_BYTE (to
);
1736 del_range_2 (from
, from_byte
, to
, to_byte
);
1739 /* Like del_range_1, but positions are specified both as charpos
1743 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1744 int from
, from_byte
, to
, to_byte
, prepare
;
1746 /* Make args be valid */
1747 if (from_byte
< BEGV_BYTE
)
1748 from_byte
= BEGV_BYTE
;
1749 if (to_byte
> ZV_BYTE
)
1752 if (to_byte
<= from_byte
)
1762 int old_from
= from
, old_to
= Z
- to
;
1763 int range_length
= to
- from
;
1764 prepare_to_modify_buffer (from
, to
, &from
);
1765 to
= from
+ range_length
;
1767 if (old_from
!= from
)
1768 from_byte
= CHAR_TO_BYTE (from
);
1769 if (old_to
== Z
- to
)
1770 to_byte
= CHAR_TO_BYTE (to
);
1773 del_range_2 (from
, from_byte
, to
, to_byte
);
1776 /* Delete a range of text, specified both as character positions
1777 and byte positions. FROM and TO are character positions,
1778 while FROM_BYTE and TO_BYTE are byte positions. */
1781 del_range_2 (from
, from_byte
, to
, to_byte
)
1782 int from
, from_byte
, to
, to_byte
;
1784 register int nbytes_del
, nchars_del
;
1785 int combined_after_bytes
;
1787 nchars_del
= to
- from
;
1788 nbytes_del
= to_byte
- from_byte
;
1790 /* Make sure the gap is somewhere in or next to what we are deleting. */
1792 gap_right (from
, from_byte
);
1794 gap_left (to
, to_byte
, 0);
1796 combined_after_bytes
1797 = count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1798 ZV_BYTE
- to_byte
, from
, from_byte
);
1800 /* Relocate all markers pointing into the new, larger gap
1801 to point at the end of the text before the gap.
1802 Do this before recording the deletion,
1803 so that undo handles this after reinserting the text. */
1804 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1805 if (combined_after_bytes
)
1807 int from_byte_1
= from_byte
;
1808 DEC_POS (from_byte_1
);
1810 /* Adjust markers for the phony deletion
1811 that we are about to call record_undo for. */
1813 /* Here we delete the markers that formerly
1814 pointed at TO ... TO + COMBINED_AFTER_BYTES.
1815 But because of the call to adjust_markers_for_delete, above,
1816 they now point at FROM ... FROM + COMBINED_AFTER_BYTES. */
1817 adjust_markers_for_record_delete (from
, from_byte
,
1818 from
+ combined_after_bytes
,
1819 from_byte
+ combined_after_bytes
);
1821 adjust_markers_for_record_delete (from
- 1, from_byte_1
,
1824 record_delete (from
- !!combined_after_bytes
,
1825 nchars_del
+ combined_after_bytes
+ !!combined_after_bytes
);
1827 if (combined_after_bytes
)
1828 /* COMBINED_AFTER_BYTES nonzero means that the above record_delete
1829 moved the gap by calling Fbuffer_substring. We must move the
1830 gap again to a proper place. */
1831 move_gap_both (from
, from_byte
);
1834 /* Relocate point as if it were a marker. */
1836 adjust_point (from
- (PT
< to
? PT
: to
),
1837 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1839 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1840 offset_intervals (current_buffer
, from
, - nchars_del
);
1842 /* Adjust the overlay center as needed. This must be done after
1843 adjusting the markers that bound the overlays. */
1844 adjust_overlays_for_delete (from
, nchars_del
);
1846 GAP_SIZE
+= nbytes_del
;
1847 ZV_BYTE
-= nbytes_del
;
1848 Z_BYTE
-= nbytes_del
;
1852 GPT_BYTE
= from_byte
;
1854 if (combined_after_bytes
)
1855 move_gap_both (GPT
+ combined_after_bytes
,
1856 GPT_BYTE
+ combined_after_bytes
);
1858 *(GPT_ADDR
) = 0; /* Put an anchor. */
1863 if (GPT
- BEG
< beg_unchanged
)
1864 beg_unchanged
= GPT
- BEG
;
1865 if (Z
- GPT
< end_unchanged
)
1866 end_unchanged
= Z
- GPT
;
1868 if (combined_after_bytes
)
1870 combine_bytes (from
, from_byte
, combined_after_bytes
);
1872 record_insert (GPT
- 1, 1);
1875 evaporate_overlays (from
);
1876 signal_after_change (from
, nchars_del
, 0);
1879 /* Call this if you're about to change the region of BUFFER from
1880 character positions START to END. This checks the read-only
1881 properties of the region, calls the necessary modification hooks,
1882 and warns the next redisplay that it should pay attention to that
1886 modify_region (buffer
, start
, end
)
1887 struct buffer
*buffer
;
1890 struct buffer
*old_buffer
= current_buffer
;
1892 if (buffer
!= old_buffer
)
1893 set_buffer_internal (buffer
);
1895 prepare_to_modify_buffer (start
, end
, NULL
);
1897 if (start
- 1 < beg_unchanged
1898 || (unchanged_modified
== MODIFF
1899 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
1900 beg_unchanged
= start
- 1;
1901 if (Z
- end
< end_unchanged
1902 || (unchanged_modified
== MODIFF
1903 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
1904 end_unchanged
= Z
- end
;
1906 if (MODIFF
<= SAVE_MODIFF
)
1907 record_first_change ();
1910 buffer
->point_before_scroll
= Qnil
;
1912 if (buffer
!= old_buffer
)
1913 set_buffer_internal (old_buffer
);
1916 /* Check that it is okay to modify the buffer between START and END,
1917 which are char positions.
1919 Run the before-change-function, if any. If intervals are in use,
1920 verify that the text to be modified is not read-only, and call
1921 any modification properties the text may have.
1923 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1924 by holding its value temporarily in a marker. */
1927 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1931 if (!NILP (current_buffer
->read_only
))
1932 Fbarf_if_buffer_read_only ();
1934 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1935 if (BUF_INTERVALS (current_buffer
) != 0)
1939 Lisp_Object preserve_marker
;
1940 struct gcpro gcpro1
;
1941 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1942 GCPRO1 (preserve_marker
);
1943 verify_interval_modification (current_buffer
, start
, end
);
1944 *preserve_ptr
= marker_position (preserve_marker
);
1945 unchain_marker (preserve_marker
);
1949 verify_interval_modification (current_buffer
, start
, end
);
1952 #ifdef CLASH_DETECTION
1953 if (!NILP (current_buffer
->file_truename
)
1954 /* Make binding buffer-file-name to nil effective. */
1955 && !NILP (current_buffer
->filename
)
1956 && SAVE_MODIFF
>= MODIFF
)
1957 lock_file (current_buffer
->file_truename
);
1959 /* At least warn if this file has changed on disk since it was visited. */
1960 if (!NILP (current_buffer
->filename
)
1961 && SAVE_MODIFF
>= MODIFF
1962 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1963 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1964 call1 (intern ("ask-user-about-supersession-threat"),
1965 current_buffer
->filename
);
1966 #endif /* not CLASH_DETECTION */
1968 signal_before_change (start
, end
, preserve_ptr
);
1970 if (current_buffer
->newline_cache
)
1971 invalidate_region_cache (current_buffer
,
1972 current_buffer
->newline_cache
,
1973 start
- BEG
, Z
- end
);
1974 if (current_buffer
->width_run_cache
)
1975 invalidate_region_cache (current_buffer
,
1976 current_buffer
->width_run_cache
,
1977 start
- BEG
, Z
- end
);
1979 Vdeactivate_mark
= Qt
;
1982 /* These macros work with an argument named `preserve_ptr'
1983 and a local variable named `preserve_marker'. */
1985 #define PRESERVE_VALUE \
1986 if (preserve_ptr && NILP (preserve_marker)) \
1987 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1989 #define RESTORE_VALUE \
1990 if (! NILP (preserve_marker)) \
1992 *preserve_ptr = marker_position (preserve_marker); \
1993 unchain_marker (preserve_marker); \
1996 #define PRESERVE_START_END \
1997 if (NILP (start_marker)) \
1998 start_marker = Fcopy_marker (start, Qnil); \
1999 if (NILP (end_marker)) \
2000 end_marker = Fcopy_marker (end, Qnil);
2002 #define FETCH_START \
2003 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2006 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2008 /* Signal a change to the buffer immediately before it happens.
2009 START_INT and END_INT are the bounds of the text to be changed.
2011 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2012 by holding its value temporarily in a marker. */
2015 signal_before_change (start_int
, end_int
, preserve_ptr
)
2016 int start_int
, end_int
;
2019 Lisp_Object start
, end
;
2020 Lisp_Object start_marker
, end_marker
;
2021 Lisp_Object preserve_marker
;
2022 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2024 start
= make_number (start_int
);
2025 end
= make_number (end_int
);
2026 preserve_marker
= Qnil
;
2027 start_marker
= Qnil
;
2029 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2031 /* If buffer is unmodified, run a special hook for that case. */
2032 if (SAVE_MODIFF
>= MODIFF
2033 && !NILP (Vfirst_change_hook
)
2034 && !NILP (Vrun_hooks
))
2038 call1 (Vrun_hooks
, Qfirst_change_hook
);
2041 /* Run the before-change-function if any.
2042 We don't bother "binding" this variable to nil
2043 because it is obsolete anyway and new code should not use it. */
2044 if (!NILP (Vbefore_change_function
))
2048 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
2051 /* Now run the before-change-functions if any. */
2052 if (!NILP (Vbefore_change_functions
))
2054 Lisp_Object args
[3];
2055 Lisp_Object before_change_functions
;
2056 Lisp_Object after_change_functions
;
2057 struct gcpro gcpro1
, gcpro2
;
2062 /* "Bind" before-change-functions and after-change-functions
2063 to nil--but in a way that errors don't know about.
2064 That way, if there's an error in them, they will stay nil. */
2065 before_change_functions
= Vbefore_change_functions
;
2066 after_change_functions
= Vafter_change_functions
;
2067 Vbefore_change_functions
= Qnil
;
2068 Vafter_change_functions
= Qnil
;
2069 GCPRO2 (before_change_functions
, after_change_functions
);
2071 /* Actually run the hook functions. */
2072 args
[0] = Qbefore_change_functions
;
2073 args
[1] = FETCH_START
;
2074 args
[2] = FETCH_END
;
2075 run_hook_list_with_args (before_change_functions
, 3, args
);
2077 /* "Unbind" the variables we "bound" to nil. */
2078 Vbefore_change_functions
= before_change_functions
;
2079 Vafter_change_functions
= after_change_functions
;
2083 if (!NILP (current_buffer
->overlays_before
)
2084 || !NILP (current_buffer
->overlays_after
))
2087 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2088 FETCH_START
, FETCH_END
, Qnil
);
2091 if (! NILP (start_marker
))
2092 free_marker (start_marker
);
2093 if (! NILP (end_marker
))
2094 free_marker (end_marker
);
2099 /* Signal a change immediately after it happens.
2100 CHARPOS is the character position of the start of the changed text.
2101 LENDEL is the number of characters of the text before the change.
2102 (Not the whole buffer; just the part that was changed.)
2103 LENINS is the number of characters in that part of the text
2104 after the change. */
2107 signal_after_change (charpos
, lendel
, lenins
)
2108 int charpos
, lendel
, lenins
;
2110 /* If we are deferring calls to the after-change functions
2111 and there are no before-change functions,
2112 just record the args that we were going to use. */
2113 if (! NILP (Vcombine_after_change_calls
)
2114 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
2115 && NILP (current_buffer
->overlays_before
)
2116 && NILP (current_buffer
->overlays_after
))
2120 if (!NILP (combine_after_change_list
)
2121 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2122 Fcombine_after_change_execute ();
2124 elt
= Fcons (make_number (charpos
- BEG
),
2125 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2126 Fcons (make_number (lenins
- lendel
), Qnil
)));
2127 combine_after_change_list
2128 = Fcons (elt
, combine_after_change_list
);
2129 combine_after_change_buffer
= Fcurrent_buffer ();
2134 if (!NILP (combine_after_change_list
))
2135 Fcombine_after_change_execute ();
2137 /* Run the after-change-function if any.
2138 We don't bother "binding" this variable to nil
2139 because it is obsolete anyway and new code should not use it. */
2140 if (!NILP (Vafter_change_function
))
2141 call3 (Vafter_change_function
,
2142 make_number (charpos
), make_number (charpos
+ lenins
),
2143 make_number (lendel
));
2145 if (!NILP (Vafter_change_functions
))
2147 Lisp_Object args
[4];
2148 Lisp_Object before_change_functions
;
2149 Lisp_Object after_change_functions
;
2150 struct gcpro gcpro1
, gcpro2
;
2152 /* "Bind" before-change-functions and after-change-functions
2153 to nil--but in a way that errors don't know about.
2154 That way, if there's an error in them, they will stay nil. */
2155 before_change_functions
= Vbefore_change_functions
;
2156 after_change_functions
= Vafter_change_functions
;
2157 Vbefore_change_functions
= Qnil
;
2158 Vafter_change_functions
= Qnil
;
2159 GCPRO2 (before_change_functions
, after_change_functions
);
2161 /* Actually run the hook functions. */
2162 args
[0] = Qafter_change_functions
;
2163 XSETFASTINT (args
[1], charpos
);
2164 XSETFASTINT (args
[2], charpos
+ lenins
);
2165 XSETFASTINT (args
[3], lendel
);
2166 run_hook_list_with_args (after_change_functions
,
2169 /* "Unbind" the variables we "bound" to nil. */
2170 Vbefore_change_functions
= before_change_functions
;
2171 Vafter_change_functions
= after_change_functions
;
2175 if (!NILP (current_buffer
->overlays_before
)
2176 || !NILP (current_buffer
->overlays_after
))
2177 report_overlay_modification (make_number (charpos
),
2178 make_number (charpos
+ lenins
),
2180 make_number (charpos
),
2181 make_number (charpos
+ lenins
),
2182 make_number (lendel
));
2184 /* After an insertion, call the text properties
2185 insert-behind-hooks or insert-in-front-hooks. */
2187 report_interval_modification (charpos
, charpos
+ lenins
);
2191 Fcombine_after_change_execute_1 (val
)
2194 Vcombine_after_change_calls
= val
;
2198 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2199 Scombine_after_change_execute
, 0, 0, 0,
2200 "This function is for use internally in `combine-after-change-calls'.")
2203 register Lisp_Object val
;
2204 int count
= specpdl_ptr
- specpdl
;
2205 int beg
, end
, change
;
2209 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2211 Fset_buffer (combine_after_change_buffer
);
2213 /* # chars unchanged at beginning of buffer. */
2215 /* # chars unchanged at end of buffer. */
2217 /* Total amount of insertion (negative for deletion). */
2220 /* Scan the various individual changes,
2221 accumulating the range info in BEG, END and CHANGE. */
2222 for (tail
= combine_after_change_list
; CONSP (tail
);
2223 tail
= XCONS (tail
)->cdr
)
2226 int thisbeg
, thisend
, thischange
;
2228 /* Extract the info from the next element. */
2229 elt
= XCONS (tail
)->car
;
2232 thisbeg
= XINT (XCONS (elt
)->car
);
2234 elt
= XCONS (elt
)->cdr
;
2237 thisend
= XINT (XCONS (elt
)->car
);
2239 elt
= XCONS (elt
)->cdr
;
2242 thischange
= XINT (XCONS (elt
)->car
);
2244 /* Merge this range into the accumulated range. */
2245 change
+= thischange
;
2252 /* Get the current start and end positions of the range
2253 that was changed. */
2257 /* We are about to handle these, so discard them. */
2258 combine_after_change_list
= Qnil
;
2260 /* Now run the after-change functions for real.
2261 Turn off the flag that defers them. */
2262 record_unwind_protect (Fcombine_after_change_execute_1
,
2263 Vcombine_after_change_calls
);
2264 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2266 return unbind_to (count
, val
);
2271 staticpro (&combine_after_change_list
);
2272 combine_after_change_list
= Qnil
;
2274 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2275 "Used internally by the `combine-after-change-calls' macro.");
2276 Vcombine_after_change_calls
= Qnil
;
2278 defsubr (&Scombine_after_change_execute
);